/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __esm = (fn3, res) => function __init() {
  return fn3 && (res = (0, fn3[__getOwnPropNames(fn3)[0]])(fn3 = 0)), res;
};
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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};

// src/types/plugin-settings_0_5_0.ts
var DEFAULT_PLUGIN_SETTINGS_0_5_0;
var init_plugin_settings_0_5_0 = __esm({
  "src/types/plugin-settings_0_5_0.ts"() {
    DEFAULT_PLUGIN_SETTINGS_0_5_0 = {
      settingsVersion: "0.5.0",
      onboardingTips: {
        welcomeTipRead: false,
        strokeLimitTipRead: false,
        lastVersionTipRead: ""
      },
      gettingStartedExpanded: true,
      customAttachmentFolders: false,
      noteAttachmentFolderLocation: "obsidian",
      notelessAttachmentFolderLocation: "obsidian",
      writingSubfolder: "Ink/Writing",
      drawingSubfolder: "Ink/Drawing",
      debugLoggingEnabled: false,
      dominantHand: "right",
      writingEnabled: true,
      writingStrokeLimit: 200,
      writingBufferLines: 3,
      writingLineHeight: 150,
      writingDynamicStrokeThickness: true,
      writingSmoothing: false,
      writingLinesWhenLocked: true,
      writingBackgroundWhenLocked: true,
      drawingEnabled: true,
      drawingGridEnabledByDefault: true,
      drawingFrameWhenLocked: false,
      drawingBackgroundWhenLocked: false
    };
  }
});

// src/types/types-map.ts
var DEFAULT_SETTINGS;
var init_types_map = __esm({
  "src/types/types-map.ts"() {
    init_plugin_settings_0_5_0();
    DEFAULT_SETTINGS = DEFAULT_PLUGIN_SETTINGS_0_5_0;
  }
});

// src/types/plugin-settings.ts
var init_plugin_settings = __esm({
  "src/types/plugin-settings.ts"() {
    init_types_map();
  }
});

// src/components/dom-components/modals/confirmation-modal/confirmation-modal.ts
var import_obsidian2, ConfirmationModal;
var init_confirmation_modal = __esm({
  "src/components/dom-components/modals/confirmation-modal/confirmation-modal.ts"() {
    import_obsidian2 = require("obsidian");
    ConfirmationModal = class extends import_obsidian2.Modal {
      constructor(options) {
        super(options.plugin.app);
        this.title = "Confirmation";
        this.message = "Are you sure?";
        this.cancelLabel = "Cancel";
        this.cancelAction = () => {
        };
        this.confirmLabel = "Yes";
        this.title = options.title || this.title;
        this.message = options.message || this.message;
        this.cancelLabel = options.cancelLabel || this.cancelLabel;
        this.confirmLabel = options.confirmLabel || this.confirmLabel;
        this.cancelAction = options.cancelAction || this.cancelAction;
        this.confirmAction = options.confirmAction;
      }
      onOpen() {
        const { titleEl, contentEl } = this;
        titleEl.setText(this.title);
        contentEl.createEl("p", { text: this.message });
        new import_obsidian2.Setting(contentEl).addButton((cancelBtn) => {
          cancelBtn.setClass("uo_button");
          cancelBtn.setButtonText(this.cancelLabel);
          cancelBtn.onClick(() => {
            this.close();
            this.cancelAction();
          });
        }).addButton((confirmBtn) => {
          confirmBtn.setClass("uo_button");
          confirmBtn.setWarning();
          confirmBtn.setButtonText(this.confirmLabel);
          confirmBtn.onClick(() => {
            this.close();
            this.confirmAction();
          });
        });
      }
      onClose() {
        const { titleEl, contentEl } = this;
        titleEl.empty();
        contentEl.empty();
      }
    };
  }
});

// src/components/dom-components/notice-components.scss
var init_ = __esm({
  "src/components/dom-components/notice-components.scss"() {
  }
});

// src/components/dom-components/notice-components.ts
function createNoticeTemplate(noticeNumber, noticeTotal) {
  const noticeBody = activeDocument.createDocumentFragment();
  const scrollAreaEl = noticeBody.createDiv("ddc_ink_notice-scroll");
  createNoticeLabel(scrollAreaEl, noticeNumber, noticeTotal);
  const footerEl = noticeBody.createDiv("ddc_ink_notice-footer");
  return {
    noticeBody,
    scrollAreaEl,
    footerEl
  };
}
function launchPersistentNotice(noticeBody) {
  const notice = new import_obsidian3.Notice(noticeBody, 0);
  notice.noticeEl.classList.add("ddc_ink_notice");
  wireNoticePointerHandling(notice.noticeEl);
  return notice;
}
function wireNoticePointerHandling(noticeContentEl) {
  noticeContentEl.querySelector(".ddc_ink_notice-scroll")?.addEventListener("click", (event) => {
    event.stopPropagation();
  });
  noticeContentEl.querySelector(".ddc_ink_notice-footer")?.addEventListener("click", (event) => {
    if (event.target instanceof HTMLElement && event.target.closest("a, button")) {
      return;
    }
    event.stopPropagation();
  });
}
function createNoticeLabel(noticeParent, noticeNumber, noticeTotal) {
  const labelEl = noticeParent.createEl("p");
  let labelText = `Ink plugin`;
  labelEl.setText(labelText);
  labelEl.classList.add("ddc_ink_notice-label");
  return labelEl;
}
function createNoticeInlineQuote(parentEl, text) {
  return parentEl.createEl("q", {
    cls: "ddc_ink_notice-inline-quote",
    text
  });
}
function createNoticeCtaBar(footerEl, props) {
  let primaryBtnEl = null;
  let tertiaryBtnEl = null;
  const footerLinkEls = [];
  const links = props.footerLinks ?? (props.footerLink ? [props.footerLink] : []);
  if (links.length > 0) {
    const footerLinksEl = footerEl.createDiv("ddc_ink_notice-footer-links");
    for (const link of links) {
      const footerLinkEl = footerLinksEl.createEl("a");
      footerLinkEl.setAttribute("href", link.href);
      footerLinkEl.setText(link.label);
      footerLinkEl.onClickEvent((event) => event.stopPropagation());
      footerLinkEls.push(footerLinkEl);
    }
  }
  const ctaBarEl = footerEl.createDiv("ddc_ink_notice-cta-bar");
  if (props.primaryLabel) {
    primaryBtnEl = ctaBarEl.createEl("button");
    primaryBtnEl.setText(props.primaryLabel);
    primaryBtnEl.classList.add("ddc_ink_primary-btn");
  }
  if (props.tertiaryLabel) {
    tertiaryBtnEl = ctaBarEl.createEl("button");
    tertiaryBtnEl.setText(props.tertiaryLabel);
    tertiaryBtnEl.classList.add("ddc_ink_tertiary-btn");
  }
  return {
    ctaBarEl,
    primaryBtnEl,
    tertiaryBtnEl,
    footerLinkEls
  };
}
var import_obsidian3;
var init_notice_components = __esm({
  "src/components/dom-components/notice-components.ts"() {
    init_();
    import_obsidian3 = require("obsidian");
  }
});

// node_modules/semver/internal/constants.js
var require_constants = __commonJS({
  "node_modules/semver/internal/constants.js"(exports, module2) {
    "use strict";
    var SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
    var RELEASE_TYPES = [
      "major",
      "premajor",
      "minor",
      "preminor",
      "patch",
      "prepatch",
      "prerelease"
    ];
    module2.exports = {
      MAX_LENGTH,
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_SAFE_INTEGER,
      RELEASE_TYPES,
      SEMVER_SPEC_VERSION,
      FLAG_INCLUDE_PRERELEASE: 1,
      FLAG_LOOSE: 2
    };
  }
});

// node_modules/semver/internal/debug.js
var require_debug = __commonJS({
  "node_modules/semver/internal/debug.js"(exports, module2) {
    "use strict";
    var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
    };
    module2.exports = debug2;
  }
});

// node_modules/semver/internal/re.js
var require_re = __commonJS({
  "node_modules/semver/internal/re.js"(exports, module2) {
    "use strict";
    var {
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_LENGTH
    } = require_constants();
    var debug2 = require_debug();
    exports = module2.exports = {};
    var re2 = exports.re = [];
    var safeRe = exports.safeRe = [];
    var src = exports.src = [];
    var safeSrc = exports.safeSrc = [];
    var t3 = exports.t = {};
    var R2 = 0;
    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
    var safeRegexReplacements = [
      ["\\s", 1],
      ["\\d", MAX_LENGTH],
      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
    ];
    var makeSafeRegex = (value) => {
      for (const [token, max3] of safeRegexReplacements) {
        value = value.split(`${token}*`).join(`${token}{0,${max3}}`).split(`${token}+`).join(`${token}{1,${max3}}`);
      }
      return value;
    };
    var createToken = (name, value, isGlobal) => {
      const safe = makeSafeRegex(value);
      const index3 = R2++;
      debug2(name, index3, value);
      t3[name] = index3;
      src[index3] = value;
      safeSrc[index3] = safe;
      re2[index3] = new RegExp(value, isGlobal ? "g" : void 0);
      safeRe[index3] = new RegExp(safe, isGlobal ? "g" : void 0);
    };
    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
    createToken("MAINVERSION", `(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})`);
    createToken("MAINVERSIONLOOSE", `(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASEIDENTIFIER", `(?:${src[t3.NONNUMERICIDENTIFIER]}|${src[t3.NUMERICIDENTIFIER]})`);
    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t3.NONNUMERICIDENTIFIER]}|${src[t3.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASE", `(?:-(${src[t3.PRERELEASEIDENTIFIER]}(?:\\.${src[t3.PRERELEASEIDENTIFIER]})*))`);
    createToken("PRERELEASELOOSE", `(?:-?(${src[t3.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t3.PRERELEASEIDENTIFIERLOOSE]})*))`);
    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
    createToken("BUILD", `(?:\\+(${src[t3.BUILDIDENTIFIER]}(?:\\.${src[t3.BUILDIDENTIFIER]})*))`);
    createToken("FULLPLAIN", `v?${src[t3.MAINVERSION]}${src[t3.PRERELEASE]}?${src[t3.BUILD]}?`);
    createToken("FULL", `^${src[t3.FULLPLAIN]}$`);
    createToken("LOOSEPLAIN", `[v=\\s]*${src[t3.MAINVERSIONLOOSE]}${src[t3.PRERELEASELOOSE]}?${src[t3.BUILD]}?`);
    createToken("LOOSE", `^${src[t3.LOOSEPLAIN]}$`);
    createToken("GTLT", "((?:<|>)?=?)");
    createToken("XRANGEIDENTIFIERLOOSE", `${src[t3.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
    createToken("XRANGEIDENTIFIER", `${src[t3.NUMERICIDENTIFIER]}|x|X|\\*`);
    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:${src[t3.PRERELEASE]})?${src[t3.BUILD]}?)?)?`);
    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:${src[t3.PRERELEASELOOSE]})?${src[t3.BUILD]}?)?)?`);
    createToken("XRANGE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAIN]}$`);
    createToken("XRANGELOOSE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
    createToken("COERCE", `${src[t3.COERCEPLAIN]}(?:$|[^\\d])`);
    createToken("COERCEFULL", src[t3.COERCEPLAIN] + `(?:${src[t3.PRERELEASE]})?(?:${src[t3.BUILD]})?(?:$|[^\\d])`);
    createToken("COERCERTL", src[t3.COERCE], true);
    createToken("COERCERTLFULL", src[t3.COERCEFULL], true);
    createToken("LONETILDE", "(?:~>?)");
    createToken("TILDETRIM", `(\\s*)${src[t3.LONETILDE]}\\s+`, true);
    exports.tildeTrimReplace = "$1~";
    createToken("TILDE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAIN]}$`);
    createToken("TILDELOOSE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("LONECARET", "(?:\\^)");
    createToken("CARETTRIM", `(\\s*)${src[t3.LONECARET]}\\s+`, true);
    exports.caretTrimReplace = "$1^";
    createToken("CARET", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAIN]}$`);
    createToken("CARETLOOSE", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("COMPARATORLOOSE", `^${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]})$|^$`);
    createToken("COMPARATOR", `^${src[t3.GTLT]}\\s*(${src[t3.FULLPLAIN]})$|^$`);
    createToken("COMPARATORTRIM", `(\\s*)${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]}|${src[t3.XRANGEPLAIN]})`, true);
    exports.comparatorTrimReplace = "$1$2$3";
    createToken("HYPHENRANGE", `^\\s*(${src[t3.XRANGEPLAIN]})\\s+-\\s+(${src[t3.XRANGEPLAIN]})\\s*$`);
    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t3.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t3.XRANGEPLAINLOOSE]})\\s*$`);
    createToken("STAR", "(<|>)?=?\\s*\\*");
    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
  }
});

// node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
  "node_modules/semver/internal/parse-options.js"(exports, module2) {
    "use strict";
    var looseOption = Object.freeze({ loose: true });
    var emptyOpts = Object.freeze({});
    var parseOptions = (options) => {
      if (!options) {
        return emptyOpts;
      }
      if (typeof options !== "object") {
        return looseOption;
      }
      return options;
    };
    module2.exports = parseOptions;
  }
});

// node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
  "node_modules/semver/internal/identifiers.js"(exports, module2) {
    "use strict";
    var numeric = /^[0-9]+$/;
    var compareIdentifiers = (a2, b2) => {
      if (typeof a2 === "number" && typeof b2 === "number") {
        return a2 === b2 ? 0 : a2 < b2 ? -1 : 1;
      }
      const anum = numeric.test(a2);
      const bnum = numeric.test(b2);
      if (anum && bnum) {
        a2 = +a2;
        b2 = +b2;
      }
      return a2 === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a2 < b2 ? -1 : 1;
    };
    var rcompareIdentifiers = (a2, b2) => compareIdentifiers(b2, a2);
    module2.exports = {
      compareIdentifiers,
      rcompareIdentifiers
    };
  }
});

// node_modules/semver/classes/semver.js
var require_semver = __commonJS({
  "node_modules/semver/classes/semver.js"(exports, module2) {
    "use strict";
    var debug2 = require_debug();
    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
    var { safeRe: re2, t: t3 } = require_re();
    var parseOptions = require_parse_options();
    var { compareIdentifiers } = require_identifiers();
    var SemVer = class {
      constructor(version2, options) {
        options = parseOptions(options);
        if (version2 instanceof SemVer) {
          if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
            return version2;
          } else {
            version2 = version2.version;
          }
        } else if (typeof version2 !== "string") {
          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
        }
        if (version2.length > MAX_LENGTH) {
          throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
        }
        debug2("SemVer", version2, options);
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        const m2 = version2.trim().match(options.loose ? re2[t3.LOOSE] : re2[t3.FULL]);
        if (!m2) {
          throw new TypeError(`Invalid Version: ${version2}`);
        }
        this.raw = version2;
        this.major = +m2[1];
        this.minor = +m2[2];
        this.patch = +m2[3];
        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
          throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
          throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
          throw new TypeError("Invalid patch version");
        }
        if (!m2[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m2[4].split(".").map((id) => {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num >= 0 && num < MAX_SAFE_INTEGER) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m2[5] ? m2[5].split(".") : [];
        this.format();
      }
      format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
          this.version += `-${this.prerelease.join(".")}`;
        }
        return this.version;
      }
      toString() {
        return this.version;
      }
      compare(other) {
        debug2("SemVer.compare", this.version, this.options, other);
        if (!(other instanceof SemVer)) {
          if (typeof other === "string" && other === this.version) {
            return 0;
          }
          other = new SemVer(other, this.options);
        }
        if (other.version === this.version) {
          return 0;
        }
        return this.compareMain(other) || this.comparePre(other);
      }
      compareMain(other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        if (this.major < other.major) {
          return -1;
        }
        if (this.major > other.major) {
          return 1;
        }
        if (this.minor < other.minor) {
          return -1;
        }
        if (this.minor > other.minor) {
          return 1;
        }
        if (this.patch < other.patch) {
          return -1;
        }
        if (this.patch > other.patch) {
          return 1;
        }
        return 0;
      }
      comparePre(other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        if (this.prerelease.length && !other.prerelease.length) {
          return -1;
        } else if (!this.prerelease.length && other.prerelease.length) {
          return 1;
        } else if (!this.prerelease.length && !other.prerelease.length) {
          return 0;
        }
        let i2 = 0;
        do {
          const a2 = this.prerelease[i2];
          const b2 = other.prerelease[i2];
          debug2("prerelease compare", i2, a2, b2);
          if (a2 === void 0 && b2 === void 0) {
            return 0;
          } else if (b2 === void 0) {
            return 1;
          } else if (a2 === void 0) {
            return -1;
          } else if (a2 === b2) {
            continue;
          } else {
            return compareIdentifiers(a2, b2);
          }
        } while (++i2);
      }
      compareBuild(other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        let i2 = 0;
        do {
          const a2 = this.build[i2];
          const b2 = other.build[i2];
          debug2("build compare", i2, a2, b2);
          if (a2 === void 0 && b2 === void 0) {
            return 0;
          } else if (b2 === void 0) {
            return 1;
          } else if (a2 === void 0) {
            return -1;
          } else if (a2 === b2) {
            continue;
          } else {
            return compareIdentifiers(a2, b2);
          }
        } while (++i2);
      }
      inc(release, identifier, identifierBase) {
        if (release.startsWith("pre")) {
          if (!identifier && identifierBase === false) {
            throw new Error("invalid increment argument: identifier is empty");
          }
          if (identifier) {
            const match = `-${identifier}`.match(this.options.loose ? re2[t3.PRERELEASELOOSE] : re2[t3.PRERELEASE]);
            if (!match || match[1] !== identifier) {
              throw new Error(`invalid identifier: ${identifier}`);
            }
          }
        }
        switch (release) {
          case "premajor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor = 0;
            this.major++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "preminor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "prepatch":
            this.prerelease.length = 0;
            this.inc("patch", identifier, identifierBase);
            this.inc("pre", identifier, identifierBase);
            break;
          case "prerelease":
            if (this.prerelease.length === 0) {
              this.inc("patch", identifier, identifierBase);
            }
            this.inc("pre", identifier, identifierBase);
            break;
          case "release":
            if (this.prerelease.length === 0) {
              throw new Error(`version ${this.raw} is not a prerelease`);
            }
            this.prerelease.length = 0;
            break;
          case "major":
            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
              this.major++;
            }
            this.minor = 0;
            this.patch = 0;
            this.prerelease = [];
            break;
          case "minor":
            if (this.patch !== 0 || this.prerelease.length === 0) {
              this.minor++;
            }
            this.patch = 0;
            this.prerelease = [];
            break;
          case "patch":
            if (this.prerelease.length === 0) {
              this.patch++;
            }
            this.prerelease = [];
            break;
          case "pre": {
            const base = Number(identifierBase) ? 1 : 0;
            if (this.prerelease.length === 0) {
              this.prerelease = [base];
            } else {
              let i2 = this.prerelease.length;
              while (--i2 >= 0) {
                if (typeof this.prerelease[i2] === "number") {
                  this.prerelease[i2]++;
                  i2 = -2;
                }
              }
              if (i2 === -1) {
                if (identifier === this.prerelease.join(".") && identifierBase === false) {
                  throw new Error("invalid increment argument: identifier already exists");
                }
                this.prerelease.push(base);
              }
            }
            if (identifier) {
              let prerelease = [identifier, base];
              if (identifierBase === false) {
                prerelease = [identifier];
              }
              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
                if (isNaN(this.prerelease[1])) {
                  this.prerelease = prerelease;
                }
              } else {
                this.prerelease = prerelease;
              }
            }
            break;
          }
          default:
            throw new Error(`invalid increment argument: ${release}`);
        }
        this.raw = this.format();
        if (this.build.length) {
          this.raw += `+${this.build.join(".")}`;
        }
        return this;
      }
    };
    module2.exports = SemVer;
  }
});

// node_modules/semver/functions/parse.js
var require_parse = __commonJS({
  "node_modules/semver/functions/parse.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse2 = (version2, options, throwErrors = false) => {
      if (version2 instanceof SemVer) {
        return version2;
      }
      try {
        return new SemVer(version2, options);
      } catch (er) {
        if (!throwErrors) {
          return null;
        }
        throw er;
      }
    };
    module2.exports = parse2;
  }
});

// node_modules/semver/functions/valid.js
var require_valid = __commonJS({
  "node_modules/semver/functions/valid.js"(exports, module2) {
    "use strict";
    var parse2 = require_parse();
    var valid2 = (version2, options) => {
      const v2 = parse2(version2, options);
      return v2 ? v2.version : null;
    };
    module2.exports = valid2;
  }
});

// node_modules/semver/functions/clean.js
var require_clean = __commonJS({
  "node_modules/semver/functions/clean.js"(exports, module2) {
    "use strict";
    var parse2 = require_parse();
    var clean = (version2, options) => {
      const s2 = parse2(version2.trim().replace(/^[=v]+/, ""), options);
      return s2 ? s2.version : null;
    };
    module2.exports = clean;
  }
});

// node_modules/semver/functions/inc.js
var require_inc = __commonJS({
  "node_modules/semver/functions/inc.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var inc = (version2, release, options, identifier, identifierBase) => {
      if (typeof options === "string") {
        identifierBase = identifier;
        identifier = options;
        options = void 0;
      }
      try {
        return new SemVer(version2 instanceof SemVer ? version2.version : version2, options).inc(release, identifier, identifierBase).version;
      } catch (er) {
        return null;
      }
    };
    module2.exports = inc;
  }
});

// node_modules/semver/functions/diff.js
var require_diff = __commonJS({
  "node_modules/semver/functions/diff.js"(exports, module2) {
    "use strict";
    var parse2 = require_parse();
    var diff = (version1, version2) => {
      const v1 = parse2(version1, null, true);
      const v2 = parse2(version2, null, true);
      const comparison = v1.compare(v2);
      if (comparison === 0) {
        return null;
      }
      const v1Higher = comparison > 0;
      const highVersion = v1Higher ? v1 : v2;
      const lowVersion = v1Higher ? v2 : v1;
      const highHasPre = !!highVersion.prerelease.length;
      const lowHasPre = !!lowVersion.prerelease.length;
      if (lowHasPre && !highHasPre) {
        if (!lowVersion.patch && !lowVersion.minor) {
          return "major";
        }
        if (lowVersion.compareMain(highVersion) === 0) {
          if (lowVersion.minor && !lowVersion.patch) {
            return "minor";
          }
          return "patch";
        }
      }
      const prefix = highHasPre ? "pre" : "";
      if (v1.major !== v2.major) {
        return prefix + "major";
      }
      if (v1.minor !== v2.minor) {
        return prefix + "minor";
      }
      if (v1.patch !== v2.patch) {
        return prefix + "patch";
      }
      return "prerelease";
    };
    module2.exports = diff;
  }
});

// node_modules/semver/functions/major.js
var require_major = __commonJS({
  "node_modules/semver/functions/major.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var major = (a2, loose) => new SemVer(a2, loose).major;
    module2.exports = major;
  }
});

// node_modules/semver/functions/minor.js
var require_minor = __commonJS({
  "node_modules/semver/functions/minor.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var minor = (a2, loose) => new SemVer(a2, loose).minor;
    module2.exports = minor;
  }
});

// node_modules/semver/functions/patch.js
var require_patch = __commonJS({
  "node_modules/semver/functions/patch.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var patch = (a2, loose) => new SemVer(a2, loose).patch;
    module2.exports = patch;
  }
});

// node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
  "node_modules/semver/functions/prerelease.js"(exports, module2) {
    "use strict";
    var parse2 = require_parse();
    var prerelease = (version2, options) => {
      const parsed = parse2(version2, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    };
    module2.exports = prerelease;
  }
});

// node_modules/semver/functions/compare.js
var require_compare = __commonJS({
  "node_modules/semver/functions/compare.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var compare = (a2, b2, loose) => new SemVer(a2, loose).compare(new SemVer(b2, loose));
    module2.exports = compare;
  }
});

// node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
  "node_modules/semver/functions/rcompare.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var rcompare = (a2, b2, loose) => compare(b2, a2, loose);
    module2.exports = rcompare;
  }
});

// node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
  "node_modules/semver/functions/compare-loose.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var compareLoose = (a2, b2) => compare(a2, b2, true);
    module2.exports = compareLoose;
  }
});

// node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
  "node_modules/semver/functions/compare-build.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var compareBuild = (a2, b2, loose) => {
      const versionA = new SemVer(a2, loose);
      const versionB = new SemVer(b2, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    };
    module2.exports = compareBuild;
  }
});

// node_modules/semver/functions/sort.js
var require_sort = __commonJS({
  "node_modules/semver/functions/sort.js"(exports, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var sort = (list, loose) => list.sort((a2, b2) => compareBuild(a2, b2, loose));
    module2.exports = sort;
  }
});

// node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
  "node_modules/semver/functions/rsort.js"(exports, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var rsort = (list, loose) => list.sort((a2, b2) => compareBuild(b2, a2, loose));
    module2.exports = rsort;
  }
});

// node_modules/semver/functions/gt.js
var require_gt = __commonJS({
  "node_modules/semver/functions/gt.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var gt2 = (a2, b2, loose) => compare(a2, b2, loose) > 0;
    module2.exports = gt2;
  }
});

// node_modules/semver/functions/lt.js
var require_lt = __commonJS({
  "node_modules/semver/functions/lt.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var lt = (a2, b2, loose) => compare(a2, b2, loose) < 0;
    module2.exports = lt;
  }
});

// node_modules/semver/functions/eq.js
var require_eq = __commonJS({
  "node_modules/semver/functions/eq.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var eq = (a2, b2, loose) => compare(a2, b2, loose) === 0;
    module2.exports = eq;
  }
});

// node_modules/semver/functions/neq.js
var require_neq = __commonJS({
  "node_modules/semver/functions/neq.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var neq = (a2, b2, loose) => compare(a2, b2, loose) !== 0;
    module2.exports = neq;
  }
});

// node_modules/semver/functions/gte.js
var require_gte = __commonJS({
  "node_modules/semver/functions/gte.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var gte = (a2, b2, loose) => compare(a2, b2, loose) >= 0;
    module2.exports = gte;
  }
});

// node_modules/semver/functions/lte.js
var require_lte = __commonJS({
  "node_modules/semver/functions/lte.js"(exports, module2) {
    "use strict";
    var compare = require_compare();
    var lte = (a2, b2, loose) => compare(a2, b2, loose) <= 0;
    module2.exports = lte;
  }
});

// node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
  "node_modules/semver/functions/cmp.js"(exports, module2) {
    "use strict";
    var eq = require_eq();
    var neq = require_neq();
    var gt2 = require_gt();
    var gte = require_gte();
    var lt = require_lt();
    var lte = require_lte();
    var cmp = (a2, op, b2, loose) => {
      switch (op) {
        case "===":
          if (typeof a2 === "object") {
            a2 = a2.version;
          }
          if (typeof b2 === "object") {
            b2 = b2.version;
          }
          return a2 === b2;
        case "!==":
          if (typeof a2 === "object") {
            a2 = a2.version;
          }
          if (typeof b2 === "object") {
            b2 = b2.version;
          }
          return a2 !== b2;
        case "":
        case "=":
        case "==":
          return eq(a2, b2, loose);
        case "!=":
          return neq(a2, b2, loose);
        case ">":
          return gt2(a2, b2, loose);
        case ">=":
          return gte(a2, b2, loose);
        case "<":
          return lt(a2, b2, loose);
        case "<=":
          return lte(a2, b2, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    };
    module2.exports = cmp;
  }
});

// node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
  "node_modules/semver/functions/coerce.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse2 = require_parse();
    var { safeRe: re2, t: t3 } = require_re();
    var coerce = (version2, options) => {
      if (version2 instanceof SemVer) {
        return version2;
      }
      if (typeof version2 === "number") {
        version2 = String(version2);
      }
      if (typeof version2 !== "string") {
        return null;
      }
      options = options || {};
      let match = null;
      if (!options.rtl) {
        match = version2.match(options.includePrerelease ? re2[t3.COERCEFULL] : re2[t3.COERCE]);
      } else {
        const coerceRtlRegex = options.includePrerelease ? re2[t3.COERCERTLFULL] : re2[t3.COERCERTL];
        let next;
        while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
        }
        coerceRtlRegex.lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      const major = match[2];
      const minor = match[3] || "0";
      const patch = match[4] || "0";
      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
      return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
    };
    module2.exports = coerce;
  }
});

// node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
  "node_modules/semver/internal/lrucache.js"(exports, module2) {
    "use strict";
    var LRUCache = class {
      constructor() {
        this.max = 1e3;
        this.map = /* @__PURE__ */ new Map();
      }
      get(key) {
        const value = this.map.get(key);
        if (value === void 0) {
          return void 0;
        } else {
          this.map.delete(key);
          this.map.set(key, value);
          return value;
        }
      }
      delete(key) {
        return this.map.delete(key);
      }
      set(key, value) {
        const deleted = this.delete(key);
        if (!deleted && value !== void 0) {
          if (this.map.size >= this.max) {
            const firstKey = this.map.keys().next().value;
            this.delete(firstKey);
          }
          this.map.set(key, value);
        }
        return this;
      }
    };
    module2.exports = LRUCache;
  }
});

// node_modules/semver/classes/range.js
var require_range = __commonJS({
  "node_modules/semver/classes/range.js"(exports, module2) {
    "use strict";
    var SPACE_CHARACTERS = /\s+/g;
    var Range3 = class {
      constructor(range, options) {
        options = parseOptions(options);
        if (range instanceof Range3) {
          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
            return range;
          } else {
            return new Range3(range.raw, options);
          }
        }
        if (range instanceof Comparator) {
          this.raw = range.value;
          this.set = [[range]];
          this.formatted = void 0;
          return this;
        }
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
        this.set = this.raw.split("||").map((r2) => this.parseRange(r2.trim())).filter((c2) => c2.length);
        if (!this.set.length) {
          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
        }
        if (this.set.length > 1) {
          const first = this.set[0];
          this.set = this.set.filter((c2) => !isNullSet(c2[0]));
          if (this.set.length === 0) {
            this.set = [first];
          } else if (this.set.length > 1) {
            for (const c2 of this.set) {
              if (c2.length === 1 && isAny(c2[0])) {
                this.set = [c2];
                break;
              }
            }
          }
        }
        this.formatted = void 0;
      }
      get range() {
        if (this.formatted === void 0) {
          this.formatted = "";
          for (let i2 = 0; i2 < this.set.length; i2++) {
            if (i2 > 0) {
              this.formatted += "||";
            }
            const comps = this.set[i2];
            for (let k2 = 0; k2 < comps.length; k2++) {
              if (k2 > 0) {
                this.formatted += " ";
              }
              this.formatted += comps[k2].toString().trim();
            }
          }
        }
        return this.formatted;
      }
      format() {
        return this.range;
      }
      toString() {
        return this.range;
      }
      parseRange(range) {
        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
        const memoKey = memoOpts + ":" + range;
        const cached = cache.get(memoKey);
        if (cached) {
          return cached;
        }
        const loose = this.options.loose;
        const hr = loose ? re2[t3.HYPHENRANGELOOSE] : re2[t3.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
        debug2("hyphen replace", range);
        range = range.replace(re2[t3.COMPARATORTRIM], comparatorTrimReplace);
        debug2("comparator trim", range);
        range = range.replace(re2[t3.TILDETRIM], tildeTrimReplace);
        debug2("tilde trim", range);
        range = range.replace(re2[t3.CARETTRIM], caretTrimReplace);
        debug2("caret trim", range);
        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
        if (loose) {
          rangeList = rangeList.filter((comp) => {
            debug2("loose invalid filter", comp, this.options);
            return !!comp.match(re2[t3.COMPARATORLOOSE]);
          });
        }
        debug2("range list", rangeList);
        const rangeMap = /* @__PURE__ */ new Map();
        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
        for (const comp of comparators) {
          if (isNullSet(comp)) {
            return [comp];
          }
          rangeMap.set(comp.value, comp);
        }
        if (rangeMap.size > 1 && rangeMap.has("")) {
          rangeMap.delete("");
        }
        const result = [...rangeMap.values()];
        cache.set(memoKey, result);
        return result;
      }
      intersects(range, options) {
        if (!(range instanceof Range3)) {
          throw new TypeError("a Range is required");
        }
        return this.set.some((thisComparators) => {
          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
              return rangeComparators.every((rangeComparator) => {
                return thisComparator.intersects(rangeComparator, options);
              });
            });
          });
        });
      }
      test(version2) {
        if (!version2) {
          return false;
        }
        if (typeof version2 === "string") {
          try {
            version2 = new SemVer(version2, this.options);
          } catch (er) {
            return false;
          }
        }
        for (let i2 = 0; i2 < this.set.length; i2++) {
          if (testSet(this.set[i2], version2, this.options)) {
            return true;
          }
        }
        return false;
      }
    };
    module2.exports = Range3;
    var LRU = require_lrucache();
    var cache = new LRU();
    var parseOptions = require_parse_options();
    var Comparator = require_comparator();
    var debug2 = require_debug();
    var SemVer = require_semver();
    var {
      safeRe: re2,
      t: t3,
      comparatorTrimReplace,
      tildeTrimReplace,
      caretTrimReplace
    } = require_re();
    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
    var isNullSet = (c2) => c2.value === "<0.0.0-0";
    var isAny = (c2) => c2.value === "";
    var isSatisfiable = (comparators, options) => {
      let result = true;
      const remainingComparators = comparators.slice();
      let testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every((otherComparator) => {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    };
    var parseComparator = (comp, options) => {
      comp = comp.replace(re2[t3.BUILD], "");
      debug2("comp", comp, options);
      comp = replaceCarets(comp, options);
      debug2("caret", comp);
      comp = replaceTildes(comp, options);
      debug2("tildes", comp);
      comp = replaceXRanges(comp, options);
      debug2("xrange", comp);
      comp = replaceStars(comp, options);
      debug2("stars", comp);
      return comp;
    };
    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
    var replaceTildes = (comp, options) => {
      return comp.trim().split(/\s+/).map((c2) => replaceTilde(c2, options)).join(" ");
    };
    var replaceTilde = (comp, options) => {
      const r2 = options.loose ? re2[t3.TILDELOOSE] : re2[t3.TILDE];
      return comp.replace(r2, (_2, M2, m2, p2, pr) => {
        debug2("tilde", comp, _2, M2, m2, p2, pr);
        let ret;
        if (isX(M2)) {
          ret = "";
        } else if (isX(m2)) {
          ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0`;
        } else if (isX(p2)) {
          ret = `>=${M2}.${m2}.0 <${M2}.${+m2 + 1}.0-0`;
        } else if (pr) {
          debug2("replaceTilde pr", pr);
          ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
        } else {
          ret = `>=${M2}.${m2}.${p2} <${M2}.${+m2 + 1}.0-0`;
        }
        debug2("tilde return", ret);
        return ret;
      });
    };
    var replaceCarets = (comp, options) => {
      return comp.trim().split(/\s+/).map((c2) => replaceCaret(c2, options)).join(" ");
    };
    var replaceCaret = (comp, options) => {
      debug2("caret", comp, options);
      const r2 = options.loose ? re2[t3.CARETLOOSE] : re2[t3.CARET];
      const z = options.includePrerelease ? "-0" : "";
      return comp.replace(r2, (_2, M2, m2, p2, pr) => {
        debug2("caret", comp, _2, M2, m2, p2, pr);
        let ret;
        if (isX(M2)) {
          ret = "";
        } else if (isX(m2)) {
          ret = `>=${M2}.0.0${z} <${+M2 + 1}.0.0-0`;
        } else if (isX(p2)) {
          if (M2 === "0") {
            ret = `>=${M2}.${m2}.0${z} <${M2}.${+m2 + 1}.0-0`;
          } else {
            ret = `>=${M2}.${m2}.0${z} <${+M2 + 1}.0.0-0`;
          }
        } else if (pr) {
          debug2("replaceCaret pr", pr);
          if (M2 === "0") {
            if (m2 === "0") {
              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${m2}.${+p2 + 1}-0`;
            } else {
              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
            }
          } else {
            ret = `>=${M2}.${m2}.${p2}-${pr} <${+M2 + 1}.0.0-0`;
          }
        } else {
          debug2("no pr");
          if (M2 === "0") {
            if (m2 === "0") {
              ret = `>=${M2}.${m2}.${p2}${z} <${M2}.${m2}.${+p2 + 1}-0`;
            } else {
              ret = `>=${M2}.${m2}.${p2}${z} <${M2}.${+m2 + 1}.0-0`;
            }
          } else {
            ret = `>=${M2}.${m2}.${p2} <${+M2 + 1}.0.0-0`;
          }
        }
        debug2("caret return", ret);
        return ret;
      });
    };
    var replaceXRanges = (comp, options) => {
      debug2("replaceXRanges", comp, options);
      return comp.split(/\s+/).map((c2) => replaceXRange(c2, options)).join(" ");
    };
    var replaceXRange = (comp, options) => {
      comp = comp.trim();
      const r2 = options.loose ? re2[t3.XRANGELOOSE] : re2[t3.XRANGE];
      return comp.replace(r2, (ret, gtlt, M2, m2, p2, pr) => {
        debug2("xRange", comp, ret, gtlt, M2, m2, p2, pr);
        const xM = isX(M2);
        const xm = xM || isX(m2);
        const xp = xm || isX(p2);
        const anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr = options.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m2 = 0;
          }
          p2 = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M2 = +M2 + 1;
              m2 = 0;
              p2 = 0;
            } else {
              m2 = +m2 + 1;
              p2 = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M2 = +M2 + 1;
            } else {
              m2 = +m2 + 1;
            }
          }
          if (gtlt === "<") {
            pr = "-0";
          }
          ret = `${gtlt + M2}.${m2}.${p2}${pr}`;
        } else if (xm) {
          ret = `>=${M2}.0.0${pr} <${+M2 + 1}.0.0-0`;
        } else if (xp) {
          ret = `>=${M2}.${m2}.0${pr} <${M2}.${+m2 + 1}.0-0`;
        }
        debug2("xRange return", ret);
        return ret;
      });
    };
    var replaceStars = (comp, options) => {
      debug2("replaceStars", comp, options);
      return comp.trim().replace(re2[t3.STAR], "");
    };
    var replaceGTE0 = (comp, options) => {
      debug2("replaceGTE0", comp, options);
      return comp.trim().replace(re2[options.includePrerelease ? t3.GTE0PRE : t3.GTE0], "");
    };
    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
      if (isX(fM)) {
        from = "";
      } else if (isX(fm)) {
        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
      } else if (isX(fp)) {
        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
      } else if (fpr) {
        from = `>=${from}`;
      } else {
        from = `>=${from}${incPr ? "-0" : ""}`;
      }
      if (isX(tM)) {
        to = "";
      } else if (isX(tm)) {
        to = `<${+tM + 1}.0.0-0`;
      } else if (isX(tp)) {
        to = `<${tM}.${+tm + 1}.0-0`;
      } else if (tpr) {
        to = `<=${tM}.${tm}.${tp}-${tpr}`;
      } else if (incPr) {
        to = `<${tM}.${tm}.${+tp + 1}-0`;
      } else {
        to = `<=${to}`;
      }
      return `${from} ${to}`.trim();
    };
    var testSet = (set, version2, options) => {
      for (let i2 = 0; i2 < set.length; i2++) {
        if (!set[i2].test(version2)) {
          return false;
        }
      }
      if (version2.prerelease.length && !options.includePrerelease) {
        for (let i2 = 0; i2 < set.length; i2++) {
          debug2(set[i2].semver);
          if (set[i2].semver === Comparator.ANY) {
            continue;
          }
          if (set[i2].semver.prerelease.length > 0) {
            const allowed = set[i2].semver;
            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    };
  }
});

// node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
  "node_modules/semver/classes/comparator.js"(exports, module2) {
    "use strict";
    var ANY = Symbol("SemVer ANY");
    var Comparator = class {
      static get ANY() {
        return ANY;
      }
      constructor(comp, options) {
        options = parseOptions(options);
        if (comp instanceof Comparator) {
          if (comp.loose === !!options.loose) {
            return comp;
          } else {
            comp = comp.value;
          }
        }
        comp = comp.trim().split(/\s+/).join(" ");
        debug2("comparator", comp, options);
        this.options = options;
        this.loose = !!options.loose;
        this.parse(comp);
        if (this.semver === ANY) {
          this.value = "";
        } else {
          this.value = this.operator + this.semver.version;
        }
        debug2("comp", this);
      }
      parse(comp) {
        const r2 = this.options.loose ? re2[t3.COMPARATORLOOSE] : re2[t3.COMPARATOR];
        const m2 = comp.match(r2);
        if (!m2) {
          throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = m2[1] !== void 0 ? m2[1] : "";
        if (this.operator === "=") {
          this.operator = "";
        }
        if (!m2[2]) {
          this.semver = ANY;
        } else {
          this.semver = new SemVer(m2[2], this.options.loose);
        }
      }
      toString() {
        return this.value;
      }
      test(version2) {
        debug2("Comparator.test", version2, this.options.loose);
        if (this.semver === ANY || version2 === ANY) {
          return true;
        }
        if (typeof version2 === "string") {
          try {
            version2 = new SemVer(version2, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version2, this.operator, this.semver, this.options);
      }
      intersects(comp, options) {
        if (!(comp instanceof Comparator)) {
          throw new TypeError("a Comparator is required");
        }
        if (this.operator === "") {
          if (this.value === "") {
            return true;
          }
          return new Range3(comp.value, options).test(this.value);
        } else if (comp.operator === "") {
          if (comp.value === "") {
            return true;
          }
          return new Range3(this.value, options).test(comp.semver);
        }
        options = parseOptions(options);
        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
          return false;
        }
        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
          return false;
        }
        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
          return true;
        }
        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
          return true;
        }
        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
          return true;
        }
        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
          return true;
        }
        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
          return true;
        }
        return false;
      }
    };
    module2.exports = Comparator;
    var parseOptions = require_parse_options();
    var { safeRe: re2, t: t3 } = require_re();
    var cmp = require_cmp();
    var debug2 = require_debug();
    var SemVer = require_semver();
    var Range3 = require_range();
  }
});

// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
  "node_modules/semver/functions/satisfies.js"(exports, module2) {
    "use strict";
    var Range3 = require_range();
    var satisfies = (version2, range, options) => {
      try {
        range = new Range3(range, options);
      } catch (er) {
        return false;
      }
      return range.test(version2);
    };
    module2.exports = satisfies;
  }
});

// node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
  "node_modules/semver/ranges/to-comparators.js"(exports, module2) {
    "use strict";
    var Range3 = require_range();
    var toComparators = (range, options) => new Range3(range, options).set.map((comp) => comp.map((c2) => c2.value).join(" ").trim().split(" "));
    module2.exports = toComparators;
  }
});

// node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
  "node_modules/semver/ranges/max-satisfying.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range3 = require_range();
    var maxSatisfying = (versions, range, options) => {
      let max3 = null;
      let maxSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range3(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v2) => {
        if (rangeObj.test(v2)) {
          if (!max3 || maxSV.compare(v2) === -1) {
            max3 = v2;
            maxSV = new SemVer(max3, options);
          }
        }
      });
      return max3;
    };
    module2.exports = maxSatisfying;
  }
});

// node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
  "node_modules/semver/ranges/min-satisfying.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range3 = require_range();
    var minSatisfying = (versions, range, options) => {
      let min4 = null;
      let minSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range3(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v2) => {
        if (rangeObj.test(v2)) {
          if (!min4 || minSV.compare(v2) === 1) {
            min4 = v2;
            minSV = new SemVer(min4, options);
          }
        }
      });
      return min4;
    };
    module2.exports = minSatisfying;
  }
});

// node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
  "node_modules/semver/ranges/min-version.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range3 = require_range();
    var gt2 = require_gt();
    var minVersion = (range, loose) => {
      range = new Range3(range, loose);
      let minver = new SemVer("0.0.0");
      if (range.test(minver)) {
        return minver;
      }
      minver = new SemVer("0.0.0-0");
      if (range.test(minver)) {
        return minver;
      }
      minver = null;
      for (let i2 = 0; i2 < range.set.length; ++i2) {
        const comparators = range.set[i2];
        let setMin = null;
        comparators.forEach((comparator) => {
          const compver = new SemVer(comparator.semver.version);
          switch (comparator.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            case "":
            case ">=":
              if (!setMin || gt2(compver, setMin)) {
                setMin = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            default:
              throw new Error(`Unexpected operation: ${comparator.operator}`);
          }
        });
        if (setMin && (!minver || gt2(minver, setMin))) {
          minver = setMin;
        }
      }
      if (minver && range.test(minver)) {
        return minver;
      }
      return null;
    };
    module2.exports = minVersion;
  }
});

// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
  "node_modules/semver/ranges/valid.js"(exports, module2) {
    "use strict";
    var Range3 = require_range();
    var validRange = (range, options) => {
      try {
        return new Range3(range, options).range || "*";
      } catch (er) {
        return null;
      }
    };
    module2.exports = validRange;
  }
});

// node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
  "node_modules/semver/ranges/outside.js"(exports, module2) {
    "use strict";
    var SemVer = require_semver();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var Range3 = require_range();
    var satisfies = require_satisfies();
    var gt2 = require_gt();
    var lt = require_lt();
    var lte = require_lte();
    var gte = require_gte();
    var outside = (version2, range, hilo, options) => {
      version2 = new SemVer(version2, options);
      range = new Range3(range, options);
      let gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt2;
          ltefn = lte;
          ltfn = lt;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt;
          ltefn = gte;
          ltfn = gt2;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version2, range, options)) {
        return false;
      }
      for (let i2 = 0; i2 < range.set.length; ++i2) {
        const comparators = range.set[i2];
        let high = null;
        let low = null;
        comparators.forEach((comparator) => {
          if (comparator.semver === ANY) {
            comparator = new Comparator(">=0.0.0");
          }
          high = high || comparator;
          low = low || comparator;
          if (gtfn(comparator.semver, high.semver, options)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options)) {
            low = comparator;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
          return false;
        }
      }
      return true;
    };
    module2.exports = outside;
  }
});

// node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
  "node_modules/semver/ranges/gtr.js"(exports, module2) {
    "use strict";
    var outside = require_outside();
    var gtr = (version2, range, options) => outside(version2, range, ">", options);
    module2.exports = gtr;
  }
});

// node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
  "node_modules/semver/ranges/ltr.js"(exports, module2) {
    "use strict";
    var outside = require_outside();
    var ltr = (version2, range, options) => outside(version2, range, "<", options);
    module2.exports = ltr;
  }
});

// node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
  "node_modules/semver/ranges/intersects.js"(exports, module2) {
    "use strict";
    var Range3 = require_range();
    var intersects = (r1, r2, options) => {
      r1 = new Range3(r1, options);
      r2 = new Range3(r2, options);
      return r1.intersects(r2, options);
    };
    module2.exports = intersects;
  }
});

// node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
  "node_modules/semver/ranges/simplify.js"(exports, module2) {
    "use strict";
    var satisfies = require_satisfies();
    var compare = require_compare();
    module2.exports = (versions, range, options) => {
      const set = [];
      let first = null;
      let prev = null;
      const v2 = versions.sort((a2, b2) => compare(a2, b2, options));
      for (const version2 of v2) {
        const included = satisfies(version2, range, options);
        if (included) {
          prev = version2;
          if (!first) {
            first = version2;
          }
        } else {
          if (prev) {
            set.push([first, prev]);
          }
          prev = null;
          first = null;
        }
      }
      if (first) {
        set.push([first, null]);
      }
      const ranges = [];
      for (const [min4, max3] of set) {
        if (min4 === max3) {
          ranges.push(min4);
        } else if (!max3 && min4 === v2[0]) {
          ranges.push("*");
        } else if (!max3) {
          ranges.push(`>=${min4}`);
        } else if (min4 === v2[0]) {
          ranges.push(`<=${max3}`);
        } else {
          ranges.push(`${min4} - ${max3}`);
        }
      }
      const simplified = ranges.join(" || ");
      const original = typeof range.raw === "string" ? range.raw : String(range);
      return simplified.length < original.length ? simplified : range;
    };
  }
});

// node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
  "node_modules/semver/ranges/subset.js"(exports, module2) {
    "use strict";
    var Range3 = require_range();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var satisfies = require_satisfies();
    var compare = require_compare();
    var subset = (sub, dom, options = {}) => {
      if (sub === dom) {
        return true;
      }
      sub = new Range3(sub, options);
      dom = new Range3(dom, options);
      let sawNonNull = false;
      OUTER:
        for (const simpleSub of sub.set) {
          for (const simpleDom of dom.set) {
            const isSub = simpleSubset(simpleSub, simpleDom, options);
            sawNonNull = sawNonNull || isSub !== null;
            if (isSub) {
              continue OUTER;
            }
          }
          if (sawNonNull) {
            return false;
          }
        }
      return true;
    };
    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
    var minimumVersion = [new Comparator(">=0.0.0")];
    var simpleSubset = (sub, dom, options) => {
      if (sub === dom) {
        return true;
      }
      if (sub.length === 1 && sub[0].semver === ANY) {
        if (dom.length === 1 && dom[0].semver === ANY) {
          return true;
        } else if (options.includePrerelease) {
          sub = minimumVersionWithPreRelease;
        } else {
          sub = minimumVersion;
        }
      }
      if (dom.length === 1 && dom[0].semver === ANY) {
        if (options.includePrerelease) {
          return true;
        } else {
          dom = minimumVersion;
        }
      }
      const eqSet = /* @__PURE__ */ new Set();
      let gt2, lt;
      for (const c2 of sub) {
        if (c2.operator === ">" || c2.operator === ">=") {
          gt2 = higherGT(gt2, c2, options);
        } else if (c2.operator === "<" || c2.operator === "<=") {
          lt = lowerLT(lt, c2, options);
        } else {
          eqSet.add(c2.semver);
        }
      }
      if (eqSet.size > 1) {
        return null;
      }
      let gtltComp;
      if (gt2 && lt) {
        gtltComp = compare(gt2.semver, lt.semver, options);
        if (gtltComp > 0) {
          return null;
        } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt.operator !== "<=")) {
          return null;
        }
      }
      for (const eq of eqSet) {
        if (gt2 && !satisfies(eq, String(gt2), options)) {
          return null;
        }
        if (lt && !satisfies(eq, String(lt), options)) {
          return null;
        }
        for (const c2 of dom) {
          if (!satisfies(eq, String(c2), options)) {
            return false;
          }
        }
        return true;
      }
      let higher, lower;
      let hasDomLT, hasDomGT;
      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
      let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false;
      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
        needDomLTPre = false;
      }
      for (const c2 of dom) {
        hasDomGT = hasDomGT || c2.operator === ">" || c2.operator === ">=";
        hasDomLT = hasDomLT || c2.operator === "<" || c2.operator === "<=";
        if (gt2) {
          if (needDomGTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomGTPre.major && c2.semver.minor === needDomGTPre.minor && c2.semver.patch === needDomGTPre.patch) {
              needDomGTPre = false;
            }
          }
          if (c2.operator === ">" || c2.operator === ">=") {
            higher = higherGT(gt2, c2, options);
            if (higher === c2 && higher !== gt2) {
              return false;
            }
          } else if (gt2.operator === ">=" && !satisfies(gt2.semver, String(c2), options)) {
            return false;
          }
        }
        if (lt) {
          if (needDomLTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomLTPre.major && c2.semver.minor === needDomLTPre.minor && c2.semver.patch === needDomLTPre.patch) {
              needDomLTPre = false;
            }
          }
          if (c2.operator === "<" || c2.operator === "<=") {
            lower = lowerLT(lt, c2, options);
            if (lower === c2 && lower !== lt) {
              return false;
            }
          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c2), options)) {
            return false;
          }
        }
        if (!c2.operator && (lt || gt2) && gtltComp !== 0) {
          return false;
        }
      }
      if (gt2 && hasDomLT && !lt && gtltComp !== 0) {
        return false;
      }
      if (lt && hasDomGT && !gt2 && gtltComp !== 0) {
        return false;
      }
      if (needDomGTPre || needDomLTPre) {
        return false;
      }
      return true;
    };
    var higherGT = (a2, b2, options) => {
      if (!a2) {
        return b2;
      }
      const comp = compare(a2.semver, b2.semver, options);
      return comp > 0 ? a2 : comp < 0 ? b2 : b2.operator === ">" && a2.operator === ">=" ? b2 : a2;
    };
    var lowerLT = (a2, b2, options) => {
      if (!a2) {
        return b2;
      }
      const comp = compare(a2.semver, b2.semver, options);
      return comp < 0 ? a2 : comp > 0 ? b2 : b2.operator === "<" && a2.operator === "<=" ? b2 : a2;
    };
    module2.exports = subset;
  }
});

// node_modules/semver/index.js
var require_semver2 = __commonJS({
  "node_modules/semver/index.js"(exports, module2) {
    "use strict";
    var internalRe = require_re();
    var constants = require_constants();
    var SemVer = require_semver();
    var identifiers = require_identifiers();
    var parse2 = require_parse();
    var valid2 = require_valid();
    var clean = require_clean();
    var inc = require_inc();
    var diff = require_diff();
    var major = require_major();
    var minor = require_minor();
    var patch = require_patch();
    var prerelease = require_prerelease();
    var compare = require_compare();
    var rcompare = require_rcompare();
    var compareLoose = require_compare_loose();
    var compareBuild = require_compare_build();
    var sort = require_sort();
    var rsort = require_rsort();
    var gt2 = require_gt();
    var lt = require_lt();
    var eq = require_eq();
    var neq = require_neq();
    var gte = require_gte();
    var lte = require_lte();
    var cmp = require_cmp();
    var coerce = require_coerce();
    var Comparator = require_comparator();
    var Range3 = require_range();
    var satisfies = require_satisfies();
    var toComparators = require_to_comparators();
    var maxSatisfying = require_max_satisfying();
    var minSatisfying = require_min_satisfying();
    var minVersion = require_min_version();
    var validRange = require_valid2();
    var outside = require_outside();
    var gtr = require_gtr();
    var ltr = require_ltr();
    var intersects = require_intersects();
    var simplifyRange = require_simplify();
    var subset = require_subset();
    module2.exports = {
      parse: parse2,
      valid: valid2,
      clean,
      inc,
      diff,
      major,
      minor,
      patch,
      prerelease,
      compare,
      rcompare,
      compareLoose,
      compareBuild,
      sort,
      rsort,
      gt: gt2,
      lt,
      eq,
      neq,
      gte,
      lte,
      cmp,
      coerce,
      Comparator,
      Range: Range3,
      satisfies,
      toComparators,
      maxSatisfying,
      minSatisfying,
      minVersion,
      validRange,
      outside,
      gtr,
      ltr,
      intersects,
      simplifyRange,
      subset,
      SemVer,
      re: internalRe.re,
      src: internalRe.src,
      tokens: internalRe.t,
      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
      RELEASE_TYPES: constants.RELEASE_TYPES,
      compareIdentifiers: identifiers.compareIdentifiers,
      rcompareIdentifiers: identifiers.rcompareIdentifiers
    };
  }
});

// node_modules/jotai/esm/vanilla.mjs
function atom(read2, write2) {
  const key = `atom${++keyCount}`;
  const config = {
    toString() {
      return (import_meta.env ? import_meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
    }
  };
  if (typeof read2 === "function") {
    config.read = read2;
  } else {
    config.init = read2;
    config.read = defaultRead;
    config.write = defaultWrite;
  }
  if (write2) {
    config.write = write2;
  }
  return config;
}
function defaultRead(get) {
  return get(this);
}
function defaultWrite(get, set, arg) {
  return set(this, typeof arg === "function" ? arg(get(this)) : arg);
}
var import_meta, keyCount, isSelfAtom, hasInitialValue, isActuallyWritableAtom, CONTINUE_PROMISE, PENDING, FULFILLED, REJECTED, isContinuablePromise, continuablePromiseMap, createContinuablePromise, isPromiseLike, isAtomStateInitialized, returnAtomValue, getPendingContinuablePromise, addPendingContinuablePromiseToDependency, addDependency, createPending, addPendingAtom, addPendingDependent, getPendingDependents, addPendingFunction, flushPending, buildStore, createStore, defaultStore, getDefaultStore;
var init_vanilla = __esm({
  "node_modules/jotai/esm/vanilla.mjs"() {
    import_meta = {};
    keyCount = 0;
    isSelfAtom = (atom3, a2) => atom3.unstable_is ? atom3.unstable_is(a2) : a2 === atom3;
    hasInitialValue = (atom3) => "init" in atom3;
    isActuallyWritableAtom = (atom3) => !!atom3.write;
    CONTINUE_PROMISE = Symbol((import_meta.env ? import_meta.env.MODE : void 0) !== "production" ? "CONTINUE_PROMISE" : "");
    PENDING = "pending";
    FULFILLED = "fulfilled";
    REJECTED = "rejected";
    isContinuablePromise = (promise) => typeof promise === "object" && promise !== null && CONTINUE_PROMISE in promise;
    continuablePromiseMap = /* @__PURE__ */ new WeakMap();
    createContinuablePromise = (promise, abort, complete) => {
      if (!continuablePromiseMap.has(promise)) {
        let continuePromise;
        const p2 = new Promise((resolve, reject) => {
          let curr = promise;
          const onFulfilled = (me) => (v2) => {
            if (curr === me) {
              p2.status = FULFILLED;
              p2.value = v2;
              resolve(v2);
              complete();
            }
          };
          const onRejected = (me) => (e2) => {
            if (curr === me) {
              p2.status = REJECTED;
              p2.reason = e2;
              reject(e2);
              complete();
            }
          };
          promise.then(onFulfilled(promise), onRejected(promise));
          continuePromise = (nextPromise, nextAbort) => {
            if (nextPromise) {
              continuablePromiseMap.set(nextPromise, p2);
              curr = nextPromise;
              nextPromise.then(onFulfilled(nextPromise), onRejected(nextPromise));
              abort();
              abort = nextAbort;
            }
          };
        });
        p2.status = PENDING;
        p2[CONTINUE_PROMISE] = continuePromise;
        continuablePromiseMap.set(promise, p2);
      }
      return continuablePromiseMap.get(promise);
    };
    isPromiseLike = (x2) => typeof (x2 == null ? void 0 : x2.then) === "function";
    isAtomStateInitialized = (atomState) => "v" in atomState || "e" in atomState;
    returnAtomValue = (atomState) => {
      if ("e" in atomState) {
        throw atomState.e;
      }
      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !("v" in atomState)) {
        throw new Error("[Bug] atom state is not initialized");
      }
      return atomState.v;
    };
    getPendingContinuablePromise = (atomState) => {
      const value = atomState.v;
      if (isContinuablePromise(value) && value.status === PENDING) {
        return value;
      }
      return null;
    };
    addPendingContinuablePromiseToDependency = (atom3, promise, dependencyAtomState) => {
      if (!dependencyAtomState.p.has(atom3)) {
        dependencyAtomState.p.add(atom3);
        promise.then(() => {
          dependencyAtomState.p.delete(atom3);
        }, () => {
          dependencyAtomState.p.delete(atom3);
        });
      }
    };
    addDependency = (pending, atom3, atomState, a2, aState) => {
      var _a;
      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && a2 === atom3) {
        throw new Error("[Bug] atom cannot depend on itself");
      }
      atomState.d.set(a2, aState.n);
      const continuablePromise = getPendingContinuablePromise(atomState);
      if (continuablePromise) {
        addPendingContinuablePromiseToDependency(atom3, continuablePromise, aState);
      }
      (_a = aState.m) == null ? void 0 : _a.t.add(atom3);
      if (pending) {
        addPendingDependent(pending, a2, atom3);
      }
    };
    createPending = () => [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()];
    addPendingAtom = (pending, atom3, atomState) => {
      if (!pending[0].has(atom3)) {
        pending[0].set(atom3, /* @__PURE__ */ new Set());
      }
      pending[1].set(atom3, atomState);
    };
    addPendingDependent = (pending, atom3, dependent) => {
      const dependents = pending[0].get(atom3);
      if (dependents) {
        dependents.add(dependent);
      }
    };
    getPendingDependents = (pending, atom3) => pending[0].get(atom3);
    addPendingFunction = (pending, fn3) => {
      pending[2].add(fn3);
    };
    flushPending = (pending) => {
      while (pending[1].size || pending[2].size) {
        pending[0].clear();
        const atomStates = new Set(pending[1].values());
        pending[1].clear();
        const functions = new Set(pending[2]);
        pending[2].clear();
        atomStates.forEach((atomState) => {
          var _a;
          return (_a = atomState.m) == null ? void 0 : _a.l.forEach((l2) => l2());
        });
        functions.forEach((fn3) => fn3());
      }
    };
    buildStore = (getAtomState) => {
      let debugMountedAtoms;
      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
        debugMountedAtoms = /* @__PURE__ */ new Set();
      }
      const setAtomStateValueOrPromise = (atom3, atomState, valueOrPromise, abortPromise = () => {
      }, completePromise = () => {
      }) => {
        const hasPrevValue = "v" in atomState;
        const prevValue = atomState.v;
        const pendingPromise = getPendingContinuablePromise(atomState);
        if (isPromiseLike(valueOrPromise)) {
          if (pendingPromise) {
            if (pendingPromise !== valueOrPromise) {
              pendingPromise[CONTINUE_PROMISE](valueOrPromise, abortPromise);
              ++atomState.n;
            }
          } else {
            const continuablePromise = createContinuablePromise(valueOrPromise, abortPromise, completePromise);
            if (continuablePromise.status === PENDING) {
              for (const a2 of atomState.d.keys()) {
                addPendingContinuablePromiseToDependency(atom3, continuablePromise, getAtomState(a2, atomState));
              }
            }
            atomState.v = continuablePromise;
            delete atomState.e;
          }
        } else {
          if (pendingPromise) {
            pendingPromise[CONTINUE_PROMISE](Promise.resolve(valueOrPromise), abortPromise);
          }
          atomState.v = valueOrPromise;
          delete atomState.e;
        }
        if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
          ++atomState.n;
        }
      };
      const readAtomState = (pending, atom3, atomState, force) => {
        if (!(force == null ? void 0 : force(atom3)) && isAtomStateInitialized(atomState)) {
          if (atomState.m) {
            return atomState;
          }
          if (Array.from(atomState.d).every(([a2, n2]) => readAtomState(pending, a2, getAtomState(a2, atomState), force).n === n2)) {
            return atomState;
          }
        }
        atomState.d.clear();
        let isSync = true;
        const getter = (a2) => {
          if (isSelfAtom(atom3, a2)) {
            const aState2 = getAtomState(a2, atomState);
            if (!isAtomStateInitialized(aState2)) {
              if (hasInitialValue(a2)) {
                setAtomStateValueOrPromise(a2, aState2, a2.init);
              } else {
                throw new Error("no atom init");
              }
            }
            return returnAtomValue(aState2);
          }
          const aState = readAtomState(pending, a2, getAtomState(a2, atomState), force);
          if (isSync) {
            addDependency(pending, atom3, atomState, a2, aState);
          } else {
            const pending2 = createPending();
            addDependency(pending2, atom3, atomState, a2, aState);
            mountDependencies(pending2, atom3, atomState);
            flushPending(pending2);
          }
          return returnAtomValue(aState);
        };
        let controller;
        let setSelf;
        const options = {
          get signal() {
            if (!controller) {
              controller = new AbortController();
            }
            return controller.signal;
          },
          get setSelf() {
            if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom3)) {
              console.warn("setSelf function cannot be used with read-only atom");
            }
            if (!setSelf && isActuallyWritableAtom(atom3)) {
              setSelf = (...args) => {
                if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && isSync) {
                  console.warn("setSelf function cannot be called in sync");
                }
                if (!isSync) {
                  return writeAtom(atom3, ...args);
                }
              };
            }
            return setSelf;
          }
        };
        try {
          const valueOrPromise = atom3.read(getter, options);
          setAtomStateValueOrPromise(atom3, atomState, valueOrPromise, () => controller == null ? void 0 : controller.abort(), () => {
            if (atomState.m) {
              const pending2 = createPending();
              mountDependencies(pending2, atom3, atomState);
              flushPending(pending2);
            }
          });
          return atomState;
        } catch (error2) {
          delete atomState.v;
          atomState.e = error2;
          ++atomState.n;
          return atomState;
        } finally {
          isSync = false;
        }
      };
      const readAtom = (atom3) => returnAtomValue(readAtomState(void 0, atom3, getAtomState(atom3)));
      const getDependents = (pending, atom3, atomState) => {
        var _a, _b;
        const dependents = /* @__PURE__ */ new Map();
        for (const a2 of ((_a = atomState.m) == null ? void 0 : _a.t) || []) {
          dependents.set(a2, getAtomState(a2, atomState));
        }
        for (const atomWithPendingContinuablePromise of atomState.p) {
          dependents.set(atomWithPendingContinuablePromise, getAtomState(atomWithPendingContinuablePromise, atomState));
        }
        (_b = getPendingDependents(pending, atom3)) == null ? void 0 : _b.forEach((dependent) => {
          dependents.set(dependent, getAtomState(dependent, atomState));
        });
        return dependents;
      };
      const recomputeDependents = (pending, atom3, atomState) => {
        const topsortedAtoms = [];
        const markedAtoms = /* @__PURE__ */ new Set();
        const visit = (a2, aState) => {
          if (markedAtoms.has(a2)) {
            return;
          }
          markedAtoms.add(a2);
          for (const [d2, s2] of getDependents(pending, a2, aState)) {
            if (a2 !== d2) {
              visit(d2, s2);
            }
          }
          topsortedAtoms.push([a2, aState, aState.n]);
        };
        visit(atom3, atomState);
        const changedAtoms = /* @__PURE__ */ new Set([atom3]);
        const isMarked = (a2) => markedAtoms.has(a2);
        for (let i2 = topsortedAtoms.length - 1; i2 >= 0; --i2) {
          const [a2, aState, prevEpochNumber] = topsortedAtoms[i2];
          let hasChangedDeps = false;
          for (const dep of aState.d.keys()) {
            if (dep !== a2 && changedAtoms.has(dep)) {
              hasChangedDeps = true;
              break;
            }
          }
          if (hasChangedDeps) {
            readAtomState(pending, a2, aState, isMarked);
            mountDependencies(pending, a2, aState);
            if (prevEpochNumber !== aState.n) {
              addPendingAtom(pending, a2, aState);
              changedAtoms.add(a2);
            }
          }
          markedAtoms.delete(a2);
        }
      };
      const writeAtomState = (pending, atom3, atomState, ...args) => {
        const getter = (a2) => returnAtomValue(readAtomState(pending, a2, getAtomState(a2, atomState)));
        const setter = (a2, ...args2) => {
          const aState = getAtomState(a2, atomState);
          let r2;
          if (isSelfAtom(atom3, a2)) {
            if (!hasInitialValue(a2)) {
              throw new Error("atom not writable");
            }
            const hasPrevValue = "v" in aState;
            const prevValue = aState.v;
            const v2 = args2[0];
            setAtomStateValueOrPromise(a2, aState, v2);
            mountDependencies(pending, a2, aState);
            if (!hasPrevValue || !Object.is(prevValue, aState.v)) {
              addPendingAtom(pending, a2, aState);
              recomputeDependents(pending, a2, aState);
            }
          } else {
            r2 = writeAtomState(pending, a2, aState, ...args2);
          }
          flushPending(pending);
          return r2;
        };
        const result = atom3.write(getter, setter, ...args);
        return result;
      };
      const writeAtom = (atom3, ...args) => {
        const pending = createPending();
        const result = writeAtomState(pending, atom3, getAtomState(atom3), ...args);
        flushPending(pending);
        return result;
      };
      const mountDependencies = (pending, atom3, atomState) => {
        if (atomState.m && !getPendingContinuablePromise(atomState)) {
          for (const a2 of atomState.d.keys()) {
            if (!atomState.m.d.has(a2)) {
              const aMounted = mountAtom(pending, a2, getAtomState(a2, atomState));
              aMounted.t.add(atom3);
              atomState.m.d.add(a2);
            }
          }
          for (const a2 of atomState.m.d || []) {
            if (!atomState.d.has(a2)) {
              atomState.m.d.delete(a2);
              const aMounted = unmountAtom(pending, a2, getAtomState(a2, atomState));
              aMounted == null ? void 0 : aMounted.t.delete(atom3);
            }
          }
        }
      };
      const mountAtom = (pending, atom3, atomState) => {
        if (!atomState.m) {
          readAtomState(pending, atom3, atomState);
          for (const a2 of atomState.d.keys()) {
            const aMounted = mountAtom(pending, a2, getAtomState(a2, atomState));
            aMounted.t.add(atom3);
          }
          atomState.m = {
            l: /* @__PURE__ */ new Set(),
            d: new Set(atomState.d.keys()),
            t: /* @__PURE__ */ new Set()
          };
          if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
            debugMountedAtoms.add(atom3);
          }
          if (isActuallyWritableAtom(atom3) && atom3.onMount) {
            const mounted = atomState.m;
            const { onMount: onMount2 } = atom3;
            addPendingFunction(pending, () => {
              const onUnmount = onMount2((...args) => writeAtomState(pending, atom3, atomState, ...args));
              if (onUnmount) {
                mounted.u = onUnmount;
              }
            });
          }
        }
        return atomState.m;
      };
      const unmountAtom = (pending, atom3, atomState) => {
        if (atomState.m && !atomState.m.l.size && !Array.from(atomState.m.t).some((a2) => {
          var _a;
          return (_a = getAtomState(a2, atomState).m) == null ? void 0 : _a.d.has(atom3);
        })) {
          const onUnmount = atomState.m.u;
          if (onUnmount) {
            addPendingFunction(pending, onUnmount);
          }
          delete atomState.m;
          if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
            debugMountedAtoms.delete(atom3);
          }
          for (const a2 of atomState.d.keys()) {
            const aMounted = unmountAtom(pending, a2, getAtomState(a2, atomState));
            aMounted == null ? void 0 : aMounted.t.delete(atom3);
          }
          const pendingPromise = getPendingContinuablePromise(atomState);
          if (pendingPromise) {
            pendingPromise[CONTINUE_PROMISE](void 0, () => {
            });
          }
          return void 0;
        }
        return atomState.m;
      };
      const subscribeAtom = (atom3, listener) => {
        const pending = createPending();
        const atomState = getAtomState(atom3);
        const mounted = mountAtom(pending, atom3, atomState);
        flushPending(pending);
        const listeners = mounted.l;
        listeners.add(listener);
        return () => {
          listeners.delete(listener);
          const pending2 = createPending();
          unmountAtom(pending2, atom3, atomState);
          flushPending(pending2);
        };
      };
      const unstable_derive = (fn3) => buildStore(...fn3(getAtomState));
      const store = {
        get: readAtom,
        set: writeAtom,
        sub: subscribeAtom,
        unstable_derive
      };
      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
        const devStore = {
          dev4_get_internal_weak_map: () => ({
            get: (atom3) => {
              const atomState = getAtomState(atom3);
              if (atomState.n === 0) {
                return void 0;
              }
              return atomState;
            }
          }),
          dev4_get_mounted_atoms: () => debugMountedAtoms,
          dev4_restore_atoms: (values) => {
            const pending = createPending();
            for (const [atom3, value] of values) {
              if (hasInitialValue(atom3)) {
                const atomState = getAtomState(atom3);
                const hasPrevValue = "v" in atomState;
                const prevValue = atomState.v;
                setAtomStateValueOrPromise(atom3, atomState, value);
                mountDependencies(pending, atom3, atomState);
                if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
                  addPendingAtom(pending, atom3, atomState);
                  recomputeDependents(pending, atom3, atomState);
                }
              }
            }
            flushPending(pending);
          }
        };
        Object.assign(store, devStore);
      }
      return store;
    };
    createStore = () => {
      const atomStateMap = /* @__PURE__ */ new WeakMap();
      const getAtomState = (atom3) => {
        let atomState = atomStateMap.get(atom3);
        if (!atomState) {
          atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
          atomStateMap.set(atom3, atomState);
        }
        return atomState;
      };
      return buildStore(getAtomState);
    };
    getDefaultStore = () => {
      if (!defaultStore) {
        defaultStore = createStore();
        if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
          globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
          if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
            console.warn("Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044");
          }
        }
      }
      return defaultStore;
    };
  }
});

// node_modules/react/cjs/react.production.min.js
var require_react_production_min = __commonJS({
  "node_modules/react/cjs/react.production.min.js"(exports) {
    "use strict";
    var l2 = Symbol.for("react.element");
    var n2 = Symbol.for("react.portal");
    var p2 = Symbol.for("react.fragment");
    var q = Symbol.for("react.strict_mode");
    var r2 = Symbol.for("react.profiler");
    var t3 = Symbol.for("react.provider");
    var u2 = Symbol.for("react.context");
    var v2 = Symbol.for("react.forward_ref");
    var w2 = Symbol.for("react.suspense");
    var x2 = Symbol.for("react.memo");
    var y2 = Symbol.for("react.lazy");
    var z = Symbol.iterator;
    function A2(a2) {
      if (a2 === null || typeof a2 !== "object")
        return null;
      a2 = z && a2[z] || a2["@@iterator"];
      return typeof a2 === "function" ? a2 : null;
    }
    var B = { isMounted: function() {
      return false;
    }, enqueueForceUpdate: function() {
    }, enqueueReplaceState: function() {
    }, enqueueSetState: function() {
    } };
    var C2 = Object.assign;
    var D2 = {};
    function E2(a2, b2, e2) {
      this.props = a2;
      this.context = b2;
      this.refs = D2;
      this.updater = e2 || B;
    }
    E2.prototype.isReactComponent = {};
    E2.prototype.setState = function(a2, b2) {
      if (typeof a2 !== "object" && typeof a2 !== "function" && a2 != null)
        throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
      this.updater.enqueueSetState(this, a2, b2, "setState");
    };
    E2.prototype.forceUpdate = function(a2) {
      this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
    };
    function F2() {
    }
    F2.prototype = E2.prototype;
    function G(a2, b2, e2) {
      this.props = a2;
      this.context = b2;
      this.refs = D2;
      this.updater = e2 || B;
    }
    var H = G.prototype = new F2();
    H.constructor = G;
    C2(H, E2.prototype);
    H.isPureReactComponent = true;
    var I2 = Array.isArray;
    var J = Object.prototype.hasOwnProperty;
    var K = { current: null };
    var L2 = { key: true, ref: true, __self: true, __source: true };
    function M2(a2, b2, e2) {
      var d2, c2 = {}, k2 = null, h2 = null;
      if (b2 != null)
        for (d2 in b2.ref !== void 0 && (h2 = b2.ref), b2.key !== void 0 && (k2 = "" + b2.key), b2)
          J.call(b2, d2) && !L2.hasOwnProperty(d2) && (c2[d2] = b2[d2]);
      var g2 = arguments.length - 2;
      if (g2 === 1)
        c2.children = e2;
      else if (1 < g2) {
        for (var f2 = Array(g2), m2 = 0; m2 < g2; m2++)
          f2[m2] = arguments[m2 + 2];
        c2.children = f2;
      }
      if (a2 && a2.defaultProps)
        for (d2 in g2 = a2.defaultProps, g2)
          c2[d2] === void 0 && (c2[d2] = g2[d2]);
      return { $$typeof: l2, type: a2, key: k2, ref: h2, props: c2, _owner: K.current };
    }
    function N2(a2, b2) {
      return { $$typeof: l2, type: a2.type, key: b2, ref: a2.ref, props: a2.props, _owner: a2._owner };
    }
    function O2(a2) {
      return typeof a2 === "object" && a2 !== null && a2.$$typeof === l2;
    }
    function escape(a2) {
      var b2 = { "=": "=0", ":": "=2" };
      return "$" + a2.replace(/[=:]/g, function(a3) {
        return b2[a3];
      });
    }
    var P2 = /\/+/g;
    function Q(a2, b2) {
      return typeof a2 === "object" && a2 !== null && a2.key != null ? escape("" + a2.key) : b2.toString(36);
    }
    function R2(a2, b2, e2, d2, c2) {
      var k2 = typeof a2;
      if (k2 === "undefined" || k2 === "boolean")
        a2 = null;
      var h2 = false;
      if (a2 === null)
        h2 = true;
      else
        switch (k2) {
          case "string":
          case "number":
            h2 = true;
            break;
          case "object":
            switch (a2.$$typeof) {
              case l2:
              case n2:
                h2 = true;
            }
        }
      if (h2)
        return h2 = a2, c2 = c2(h2), a2 = d2 === "" ? "." + Q(h2, 0) : d2, I2(c2) ? (e2 = "", a2 != null && (e2 = a2.replace(P2, "$&/") + "/"), R2(c2, b2, e2, "", function(a3) {
          return a3;
        })) : c2 != null && (O2(c2) && (c2 = N2(c2, e2 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(P2, "$&/") + "/") + a2)), b2.push(c2)), 1;
      h2 = 0;
      d2 = d2 === "" ? "." : d2 + ":";
      if (I2(a2))
        for (var g2 = 0; g2 < a2.length; g2++) {
          k2 = a2[g2];
          var f2 = d2 + Q(k2, g2);
          h2 += R2(k2, b2, e2, f2, c2);
        }
      else if (f2 = A2(a2), typeof f2 === "function")
        for (a2 = f2.call(a2), g2 = 0; !(k2 = a2.next()).done; )
          k2 = k2.value, f2 = d2 + Q(k2, g2++), h2 += R2(k2, b2, e2, f2, c2);
      else if (k2 === "object")
        throw b2 = String(a2), Error("Objects are not valid as a React child (found: " + (b2 === "[object Object]" ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead.");
      return h2;
    }
    function S2(a2, b2, e2) {
      if (a2 == null)
        return a2;
      var d2 = [], c2 = 0;
      R2(a2, d2, "", "", function(a3) {
        return b2.call(e2, a3, c2++);
      });
      return d2;
    }
    function T2(a2) {
      if (a2._status === -1) {
        var b2 = a2._result;
        b2 = b2();
        b2.then(function(b3) {
          if (a2._status === 0 || a2._status === -1)
            a2._status = 1, a2._result = b3;
        }, function(b3) {
          if (a2._status === 0 || a2._status === -1)
            a2._status = 2, a2._result = b3;
        });
        a2._status === -1 && (a2._status = 0, a2._result = b2);
      }
      if (a2._status === 1)
        return a2._result.default;
      throw a2._result;
    }
    var U = { current: null };
    var V = { transition: null };
    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
    exports.Children = { map: S2, forEach: function(a2, b2, e2) {
      S2(a2, function() {
        b2.apply(this, arguments);
      }, e2);
    }, count: function(a2) {
      var b2 = 0;
      S2(a2, function() {
        b2++;
      });
      return b2;
    }, toArray: function(a2) {
      return S2(a2, function(a3) {
        return a3;
      }) || [];
    }, only: function(a2) {
      if (!O2(a2))
        throw Error("React.Children.only expected to receive a single React element child.");
      return a2;
    } };
    exports.Component = E2;
    exports.Fragment = p2;
    exports.Profiler = r2;
    exports.PureComponent = G;
    exports.StrictMode = q;
    exports.Suspense = w2;
    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
    exports.cloneElement = function(a2, b2, e2) {
      if (a2 === null || a2 === void 0)
        throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
      var d2 = C2({}, a2.props), c2 = a2.key, k2 = a2.ref, h2 = a2._owner;
      if (b2 != null) {
        b2.ref !== void 0 && (k2 = b2.ref, h2 = K.current);
        b2.key !== void 0 && (c2 = "" + b2.key);
        if (a2.type && a2.type.defaultProps)
          var g2 = a2.type.defaultProps;
        for (f2 in b2)
          J.call(b2, f2) && !L2.hasOwnProperty(f2) && (d2[f2] = b2[f2] === void 0 && g2 !== void 0 ? g2[f2] : b2[f2]);
      }
      var f2 = arguments.length - 2;
      if (f2 === 1)
        d2.children = e2;
      else if (1 < f2) {
        g2 = Array(f2);
        for (var m2 = 0; m2 < f2; m2++)
          g2[m2] = arguments[m2 + 2];
        d2.children = g2;
      }
      return { $$typeof: l2, type: a2.type, key: c2, ref: k2, props: d2, _owner: h2 };
    };
    exports.createContext = function(a2) {
      a2 = { $$typeof: u2, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
      a2.Provider = { $$typeof: t3, _context: a2 };
      return a2.Consumer = a2;
    };
    exports.createElement = M2;
    exports.createFactory = function(a2) {
      var b2 = M2.bind(null, a2);
      b2.type = a2;
      return b2;
    };
    exports.createRef = function() {
      return { current: null };
    };
    exports.forwardRef = function(a2) {
      return { $$typeof: v2, render: a2 };
    };
    exports.isValidElement = O2;
    exports.lazy = function(a2) {
      return { $$typeof: y2, _payload: { _status: -1, _result: a2 }, _init: T2 };
    };
    exports.memo = function(a2, b2) {
      return { $$typeof: x2, type: a2, compare: b2 === void 0 ? null : b2 };
    };
    exports.startTransition = function(a2) {
      var b2 = V.transition;
      V.transition = {};
      try {
        a2();
      } finally {
        V.transition = b2;
      }
    };
    exports.unstable_act = function() {
      throw Error("act(...) is not supported in production builds of React.");
    };
    exports.useCallback = function(a2, b2) {
      return U.current.useCallback(a2, b2);
    };
    exports.useContext = function(a2) {
      return U.current.useContext(a2);
    };
    exports.useDebugValue = function() {
    };
    exports.useDeferredValue = function(a2) {
      return U.current.useDeferredValue(a2);
    };
    exports.useEffect = function(a2, b2) {
      return U.current.useEffect(a2, b2);
    };
    exports.useId = function() {
      return U.current.useId();
    };
    exports.useImperativeHandle = function(a2, b2, e2) {
      return U.current.useImperativeHandle(a2, b2, e2);
    };
    exports.useInsertionEffect = function(a2, b2) {
      return U.current.useInsertionEffect(a2, b2);
    };
    exports.useLayoutEffect = function(a2, b2) {
      return U.current.useLayoutEffect(a2, b2);
    };
    exports.useMemo = function(a2, b2) {
      return U.current.useMemo(a2, b2);
    };
    exports.useReducer = function(a2, b2, e2) {
      return U.current.useReducer(a2, b2, e2);
    };
    exports.useRef = function(a2) {
      return U.current.useRef(a2);
    };
    exports.useState = function(a2) {
      return U.current.useState(a2);
    };
    exports.useSyncExternalStore = function(a2, b2, e2) {
      return U.current.useSyncExternalStore(a2, b2, e2);
    };
    exports.useTransition = function() {
      return U.current.useTransition();
    };
    exports.version = "18.2.0";
  }
});

// node_modules/react/index.js
var require_react = __commonJS({
  "node_modules/react/index.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_react_production_min();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/jotai/esm/react.mjs
function useAtomValue(atom3, options) {
  const store = useStore(options);
  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = (0, import_react.useReducer)((prev) => {
    const nextValue = store.get(atom3);
    if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom3) {
      return prev;
    }
    return [nextValue, store, atom3];
  }, void 0, () => [store.get(atom3), store, atom3]);
  let value = valueFromReducer;
  if (storeFromReducer !== store || atomFromReducer !== atom3) {
    rerender();
    value = store.get(atom3);
  }
  const delay = options == null ? void 0 : options.delay;
  (0, import_react.useEffect)(() => {
    const unsub = store.sub(atom3, () => {
      if (typeof delay === "number") {
        setTimeout(rerender, delay);
        return;
      }
      rerender();
    });
    rerender();
    return unsub;
  }, [store, atom3, delay]);
  (0, import_react.useDebugValue)(value);
  return isPromiseLike2(value) ? use(value) : value;
}
function useSetAtom(atom3, options) {
  const store = useStore(options);
  const setAtom = (0, import_react.useCallback)((...args) => {
    if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && !("write" in atom3)) {
      throw new Error("not writable atom");
    }
    return store.set(atom3, ...args);
  }, [store, atom3]);
  return setAtom;
}
var import_react, import_meta2, StoreContext, useStore, Provider, isPromiseLike2, use;
var init_react = __esm({
  "node_modules/jotai/esm/react.mjs"() {
    import_react = __toESM(require_react(), 1);
    init_vanilla();
    import_meta2 = {};
    "use client";
    StoreContext = (0, import_react.createContext)(void 0);
    useStore = (options) => {
      const store = (0, import_react.useContext)(StoreContext);
      return (options == null ? void 0 : options.store) || store || getDefaultStore();
    };
    Provider = ({
      children,
      store
    }) => {
      const storeRef = (0, import_react.useRef)();
      if (!store && !storeRef.current) {
        storeRef.current = createStore();
      }
      return (0, import_react.createElement)(StoreContext.Provider, {
        value: store || storeRef.current
      }, children);
    };
    isPromiseLike2 = (x2) => typeof (x2 == null ? void 0 : x2.then) === "function";
    use = import_react.default.use || ((promise) => {
      if (promise.status === "pending") {
        throw promise;
      } else if (promise.status === "fulfilled") {
        return promise.value;
      } else if (promise.status === "rejected") {
        throw promise.reason;
      } else {
        promise.status = "pending";
        promise.then((v2) => {
          promise.status = "fulfilled";
          promise.value = v2;
        }, (e2) => {
          promise.status = "rejected";
          promise.reason = e2;
        });
        throw promise;
      }
    });
  }
});

// node_modules/jotai/esm/index.mjs
var init_esm = __esm({
  "node_modules/jotai/esm/index.mjs"() {
    init_vanilla();
    init_react();
  }
});

// src/stores/dominant-hand-store.ts
function setDominantHand(value) {
  dominantHandStore.set(dominantHandAtom, value);
}
function useDominantHand() {
  return useAtomValue(dominantHandAtom, { store: dominantHandStore });
}
var dominantHandAtom, dominantHandStore;
var init_dominant_hand_store = __esm({
  "src/stores/dominant-hand-store.ts"() {
    init_esm();
    dominantHandAtom = atom("right");
    dominantHandStore = getDefaultStore();
  }
});

// manifest.json
var manifest_default;
var init_manifest = __esm({
  "manifest.json"() {
    manifest_default = {
      id: "ink",
      name: "Ink",
      author: "Dale de Silva",
      description: "Hand write or draw directly between paragraphs in your notes using a digital pen, stylus, or Apple pencil. Useful for handwriting, sketches, scribbles, or even math equations and scientific notation. Runs on the tldraw framework and drawing provides an infinite canvas.",
      version: "0.5.6",
      minAppVersion: "1.8.7",
      authorUrl: "https://designdebt.club",
      fundingUrl: "https://ko-fi.com/daledesilva",
      isDesktopOnly: false
    };
  }
});

// src/constants.ts
var PLUGIN_VERSION, TLDRAW_VERSION, INK_CANVAS_FORMAT_VERSION, INK_EMBED_BASE_URL, LOCAL_STORAGE_PREFIX, WRITE_FILE_V1_EXT, DRAW_FILE_V1_EXT, WRITE_EMBED_KEY, DRAW_EMBED_KEY, MENUBAR_HEIGHT_PX, WRITE_SHORT_DELAY_MS, WRITE_LONG_DELAY_MS, DRAW_SHORT_DELAY_MS, DRAW_LONG_DELAY_MS, WRITING_PAGE_WIDTH, WRITING_LINE_HEIGHT, WRITING_MIN_PAGE_HEIGHT, DRAWING_INITIAL_WIDTH, DRAWING_INITIAL_ASPECT_RATIO, DRAWING_INITIAL_HEIGHT;
var init_constants = __esm({
  "src/constants.ts"() {
    init_manifest();
    PLUGIN_VERSION = manifest_default.version;
    TLDRAW_VERSION = "2.4.3";
    INK_CANVAS_FORMAT_VERSION = "0.5.0";
    INK_EMBED_BASE_URL = "https://youtu.be/2arL1jh8ihA";
    LOCAL_STORAGE_PREFIX = "au_ink_";
    WRITE_FILE_V1_EXT = "writing";
    DRAW_FILE_V1_EXT = "drawing";
    WRITE_EMBED_KEY = "handwritten-ink";
    DRAW_EMBED_KEY = "handdrawn-ink";
    MENUBAR_HEIGHT_PX = 100;
    WRITE_SHORT_DELAY_MS = 500;
    WRITE_LONG_DELAY_MS = 2e3;
    DRAW_SHORT_DELAY_MS = 500;
    DRAW_LONG_DELAY_MS = 2e3;
    WRITING_PAGE_WIDTH = 2e3;
    WRITING_LINE_HEIGHT = 150;
    WRITING_MIN_PAGE_HEIGHT = WRITING_LINE_HEIGHT * 2.5;
    DRAWING_INITIAL_WIDTH = 500;
    DRAWING_INITIAL_ASPECT_RATIO = 1;
    DRAWING_INITIAL_HEIGHT = Math.round(DRAWING_INITIAL_WIDTH * DRAWING_INITIAL_ASPECT_RATIO);
  }
});

// src/stores/global-store.ts
function setGlobals(globals) {
  const store = getDefaultStore();
  store.set(globalsAtom, globals);
}
function getGlobals() {
  const store = getDefaultStore();
  const globals = store.get(globalsAtom);
  if (!globals) {
    throw new Error(`Project Browser plugin globals isn't available yet`);
  }
  return globals;
}
var globalsAtom;
var init_global_store = __esm({
  "src/stores/global-store.ts"() {
    init_esm();
    globalsAtom = atom();
  }
});

// src/logic/utils/log-to-vault.ts
function getTodayDateString() {
  const now = new Date();
  const yyyy = now.getFullYear();
  const mm = String(now.getMonth() + 1).padStart(2, "0");
  const dd = String(now.getDate()).padStart(2, "0");
  return `${yyyy}-${mm}-${dd}`;
}
function getTimestamp() {
  const now = new Date();
  const hh = String(now.getHours()).padStart(2, "0");
  const min4 = String(now.getMinutes()).padStart(2, "0");
  const ss = String(now.getSeconds()).padStart(2, "0");
  const ms = String(now.getMilliseconds()).padStart(3, "0");
  return `${hh}:${min4}:${ss}.${ms}`;
}
function logToVault(message) {
  if (!getGlobals().plugin.settings.debugLoggingEnabled)
    return;
  const filename = `ink-debug_${getTodayDateString()}.md`;
  const line = `[${getTimestamp()}] ${message}
`;
  void getGlobals().plugin.app.vault.adapter.append(filename, line);
}
var init_log_to_vault = __esm({
  "src/logic/utils/log-to-vault.ts"() {
    init_global_store();
  }
});

// src/components/formats/current/utils/ink-file-storage-engine.ts
function getInkFileStorageEngine(fileData) {
  return fileData.inkCanvas != null ? "ink-canvas" : "tldraw";
}
function isInkCanvasFile(fileData) {
  return getInkFileStorageEngine(fileData) === "ink-canvas";
}
var init_ink_file_storage_engine = __esm({
  "src/components/formats/current/utils/ink-file-storage-engine.ts"() {
  }
});

// src/defaults/empty-drawing-embed.svg
var empty_drawing_embed_default;
var init_empty_drawing_embed = __esm({
  "src/defaults/empty-drawing-embed.svg"() {
    empty_drawing_embed_default = '<svg\n    xmlns="http://www.w3.org/2000/svg"\n    version="1.1"\n    viewBox="0 0 395 130" \n    width="395"\n    height="130"\n    fill="none"\n    class="ddc_ink_drawing-placeholder"\n>\n    <g>\n        <rect rx="10" ry="10" x="1" y="1" width="393" height="128" style="fill: none; stroke-width: 1; stroke: rgb(255, 255, 255); stroke-opacity: 0.1;"/>\n    </g>\n    <g>\n        <rect rx="2" ry="2" x="189" y="56" width="18" height="18" style="fill: none; stroke-width: 2; stroke: rgb(255, 255, 255); stroke-opacity: 1;" class="stroke-shape"/>\n        <circle cx="195" cy="62" style="fill: none; stroke-width: 2; stroke: rgb(255, 255, 255); stroke-opacity: 1;" r="2" class="stroke-shape"/>\n        <path d="m207 68-3.086-3.086a2 2 0 0 0-2.828 0L192 74" style="fill: none; stroke-width: 2; stroke: rgb(255, 255, 255); stroke-opacity: 1;" class="stroke-shape"/>\n    </g>\n</svg>';
  }
});

// src/components/formats/current/utils/build-file-data.ts
var buildInkCanvasDrawingFileData, buildInkCanvasWritingFileData;
var init_build_file_data = __esm({
  "src/components/formats/current/utils/build-file-data.ts"() {
    init_constants();
    buildInkCanvasDrawingFileData = (props) => {
      return {
        meta: {
          pluginVersion: PLUGIN_VERSION,
          tldrawVersion: "",
          fileType: "inkDrawing"
        },
        tldraw: {},
        inkCanvas: props.inkCanvasSnapshot,
        svgString: props.svgString
      };
    };
    buildInkCanvasWritingFileData = (props) => {
      return {
        meta: {
          pluginVersion: PLUGIN_VERSION,
          tldrawVersion: "",
          fileType: "inkWriting"
        },
        tldraw: {},
        inkCanvas: props.inkCanvasSnapshot,
        svgString: props.svgString
      };
    };
  }
});

// node_modules/@xmldom/xmldom/lib/conventions.js
var require_conventions = __commonJS({
  "node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {
    "use strict";
    function find(list, predicate, ac) {
      if (ac === void 0) {
        ac = Array.prototype;
      }
      if (list && typeof ac.find === "function") {
        return ac.find.call(list, predicate);
      }
      for (var i2 = 0; i2 < list.length; i2++) {
        if (Object.prototype.hasOwnProperty.call(list, i2)) {
          var item = list[i2];
          if (predicate.call(void 0, item, i2, list)) {
            return item;
          }
        }
      }
    }
    function freeze(object2, oc) {
      if (oc === void 0) {
        oc = Object;
      }
      return oc && typeof oc.freeze === "function" ? oc.freeze(object2) : object2;
    }
    function assign(target, source) {
      if (target === null || typeof target !== "object") {
        throw new TypeError("target is not an object");
      }
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
      return target;
    }
    var MIME_TYPE = freeze({
      HTML: "text/html",
      isHTML: function(value) {
        return value === MIME_TYPE.HTML;
      },
      XML_APPLICATION: "application/xml",
      XML_TEXT: "text/xml",
      XML_XHTML_APPLICATION: "application/xhtml+xml",
      XML_SVG_IMAGE: "image/svg+xml"
    });
    var NAMESPACE = freeze({
      HTML: "http://www.w3.org/1999/xhtml",
      isHTML: function(uri) {
        return uri === NAMESPACE.HTML;
      },
      SVG: "http://www.w3.org/2000/svg",
      XML: "http://www.w3.org/XML/1998/namespace",
      XMLNS: "http://www.w3.org/2000/xmlns/"
    });
    exports.assign = assign;
    exports.find = find;
    exports.freeze = freeze;
    exports.MIME_TYPE = MIME_TYPE;
    exports.NAMESPACE = NAMESPACE;
  }
});

// node_modules/@xmldom/xmldom/lib/dom.js
var require_dom = __commonJS({
  "node_modules/@xmldom/xmldom/lib/dom.js"(exports) {
    var conventions = require_conventions();
    var find = conventions.find;
    var NAMESPACE = conventions.NAMESPACE;
    function notEmptyString(input) {
      return input !== "";
    }
    function splitOnASCIIWhitespace(input) {
      return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
    }
    function orderedSetReducer(current, element) {
      if (!current.hasOwnProperty(element)) {
        current[element] = true;
      }
      return current;
    }
    function toOrderedSet(input) {
      if (!input)
        return [];
      var list = splitOnASCIIWhitespace(input);
      return Object.keys(list.reduce(orderedSetReducer, {}));
    }
    function arrayIncludes(list) {
      return function(element) {
        return list && list.indexOf(element) !== -1;
      };
    }
    function copy(src, dest) {
      for (var p2 in src) {
        if (Object.prototype.hasOwnProperty.call(src, p2)) {
          dest[p2] = src[p2];
        }
      }
    }
    function _extends(Class, Super) {
      var pt = Class.prototype;
      if (!(pt instanceof Super)) {
        let t4 = function() {
        };
        var t3 = t4;
        ;
        t4.prototype = Super.prototype;
        t4 = new t4();
        copy(pt, t4);
        Class.prototype = pt = t4;
      }
      if (pt.constructor != Class) {
        if (typeof Class != "function") {
          console.error("unknown Class:" + Class);
        }
        pt.constructor = Class;
      }
    }
    var NodeType = {};
    var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
    var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
    var TEXT_NODE = NodeType.TEXT_NODE = 3;
    var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
    var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
    var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
    var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
    var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
    var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
    var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
    var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
    var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
    var ExceptionCode = {};
    var ExceptionMessage = {};
    var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
    var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
    var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
    var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
    var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
    var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
    var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
    var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
    var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
    var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
    var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
    var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
    var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
    var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
    var INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
    function DOMException2(code2, message) {
      if (message instanceof Error) {
        var error2 = message;
      } else {
        error2 = this;
        Error.call(this, ExceptionMessage[code2]);
        this.message = ExceptionMessage[code2];
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, DOMException2);
      }
      error2.code = code2;
      if (message)
        this.message = this.message + ": " + message;
      return error2;
    }
    DOMException2.prototype = Error.prototype;
    copy(ExceptionCode, DOMException2);
    function NodeList() {
    }
    NodeList.prototype = {
      length: 0,
      item: function(index3) {
        return index3 >= 0 && index3 < this.length ? this[index3] : null;
      },
      toString: function(isHTML, nodeFilter, options) {
        var requireWellFormed = !!options && !!options.requireWellFormed;
        for (var buf = [], i2 = 0; i2 < this.length; i2++) {
          serializeToString(this[i2], buf, isHTML, nodeFilter, null, requireWellFormed);
        }
        return buf.join("");
      },
      filter: function(predicate) {
        return Array.prototype.filter.call(this, predicate);
      },
      indexOf: function(item) {
        return Array.prototype.indexOf.call(this, item);
      }
    };
    function LiveNodeList(node, refresh) {
      this._node = node;
      this._refresh = refresh;
      _updateLiveList(this);
    }
    function _updateLiveList(list) {
      var inc = list._node._inc || list._node.ownerDocument._inc;
      if (list._inc !== inc) {
        var ls = list._refresh(list._node);
        __set__(list, "length", ls.length);
        if (!list.$$length || ls.length < list.$$length) {
          for (var i2 = ls.length; i2 in list; i2++) {
            if (Object.prototype.hasOwnProperty.call(list, i2)) {
              delete list[i2];
            }
          }
        }
        copy(ls, list);
        list._inc = inc;
      }
    }
    LiveNodeList.prototype.item = function(i2) {
      _updateLiveList(this);
      return this[i2] || null;
    };
    _extends(LiveNodeList, NodeList);
    function NamedNodeMap() {
    }
    function _findNodeIndex(list, node) {
      var i2 = list.length;
      while (i2--) {
        if (list[i2] === node) {
          return i2;
        }
      }
    }
    function _addNamedNode(el, list, newAttr, oldAttr) {
      if (oldAttr) {
        list[_findNodeIndex(list, oldAttr)] = newAttr;
      } else {
        list[list.length++] = newAttr;
      }
      if (el) {
        newAttr.ownerElement = el;
        var doc = el.ownerDocument;
        if (doc) {
          oldAttr && _onRemoveAttribute(doc, el, oldAttr);
          _onAddAttribute(doc, el, newAttr);
        }
      }
    }
    function _removeNamedNode(el, list, attr) {
      var i2 = _findNodeIndex(list, attr);
      if (i2 >= 0) {
        var lastIndex = list.length - 1;
        while (i2 < lastIndex) {
          list[i2] = list[++i2];
        }
        list.length = lastIndex;
        if (el) {
          var doc = el.ownerDocument;
          if (doc) {
            _onRemoveAttribute(doc, el, attr);
            attr.ownerElement = null;
          }
        }
      } else {
        throw new DOMException2(NOT_FOUND_ERR, new Error(el.tagName + "@" + attr));
      }
    }
    NamedNodeMap.prototype = {
      length: 0,
      item: NodeList.prototype.item,
      getNamedItem: function(key) {
        var i2 = this.length;
        while (i2--) {
          var attr = this[i2];
          if (attr.nodeName == key) {
            return attr;
          }
        }
      },
      setNamedItem: function(attr) {
        var el = attr.ownerElement;
        if (el && el != this._ownerElement) {
          throw new DOMException2(INUSE_ATTRIBUTE_ERR);
        }
        var oldAttr = this.getNamedItem(attr.nodeName);
        _addNamedNode(this._ownerElement, this, attr, oldAttr);
        return oldAttr;
      },
      setNamedItemNS: function(attr) {
        var el = attr.ownerElement, oldAttr;
        if (el && el != this._ownerElement) {
          throw new DOMException2(INUSE_ATTRIBUTE_ERR);
        }
        oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
        _addNamedNode(this._ownerElement, this, attr, oldAttr);
        return oldAttr;
      },
      removeNamedItem: function(key) {
        var attr = this.getNamedItem(key);
        _removeNamedNode(this._ownerElement, this, attr);
        return attr;
      },
      removeNamedItemNS: function(namespaceURI, localName) {
        var attr = this.getNamedItemNS(namespaceURI, localName);
        _removeNamedNode(this._ownerElement, this, attr);
        return attr;
      },
      getNamedItemNS: function(namespaceURI, localName) {
        var i2 = this.length;
        while (i2--) {
          var node = this[i2];
          if (node.localName == localName && node.namespaceURI == namespaceURI) {
            return node;
          }
        }
        return null;
      }
    };
    function DOMImplementation() {
    }
    DOMImplementation.prototype = {
      hasFeature: function(feature, version2) {
        return true;
      },
      createDocument: function(namespaceURI, qualifiedName, doctype) {
        var doc = new Document();
        doc.implementation = this;
        doc.childNodes = new NodeList();
        doc.doctype = doctype || null;
        if (doctype) {
          doc.appendChild(doctype);
        }
        if (qualifiedName) {
          var root = doc.createElementNS(namespaceURI, qualifiedName);
          doc.appendChild(root);
        }
        return doc;
      },
      createDocumentType: function(qualifiedName, publicId, systemId) {
        var node = new DocumentType();
        node.name = qualifiedName;
        node.nodeName = qualifiedName;
        node.publicId = publicId || "";
        node.systemId = systemId || "";
        return node;
      }
    };
    function Node2() {
    }
    Node2.prototype = {
      firstChild: null,
      lastChild: null,
      previousSibling: null,
      nextSibling: null,
      attributes: null,
      parentNode: null,
      childNodes: null,
      ownerDocument: null,
      nodeValue: null,
      namespaceURI: null,
      prefix: null,
      localName: null,
      insertBefore: function(newChild, refChild) {
        return _insertBefore(this, newChild, refChild);
      },
      replaceChild: function(newChild, oldChild) {
        _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
        if (oldChild) {
          this.removeChild(oldChild);
        }
      },
      removeChild: function(oldChild) {
        return _removeChild(this, oldChild);
      },
      appendChild: function(newChild) {
        return this.insertBefore(newChild, null);
      },
      hasChildNodes: function() {
        return this.firstChild != null;
      },
      cloneNode: function(deep) {
        return cloneNode(this.ownerDocument || this, this, deep);
      },
      normalize: function() {
        walkDOM(this, null, {
          enter: function(node) {
            var child = node.firstChild;
            while (child) {
              var next = child.nextSibling;
              if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
                node.removeChild(next);
                child.appendData(next.data);
              } else {
                child = next;
              }
            }
            return true;
          }
        });
      },
      isSupported: function(feature, version2) {
        return this.ownerDocument.implementation.hasFeature(feature, version2);
      },
      hasAttributes: function() {
        return this.attributes.length > 0;
      },
      lookupPrefix: function(namespaceURI) {
        var el = this;
        while (el) {
          var map = el._nsMap;
          if (map) {
            for (var n2 in map) {
              if (Object.prototype.hasOwnProperty.call(map, n2) && map[n2] === namespaceURI) {
                return n2;
              }
            }
          }
          el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
        }
        return null;
      },
      lookupNamespaceURI: function(prefix) {
        var el = this;
        while (el) {
          var map = el._nsMap;
          if (map) {
            if (Object.prototype.hasOwnProperty.call(map, prefix)) {
              return map[prefix];
            }
          }
          el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
        }
        return null;
      },
      isDefaultNamespace: function(namespaceURI) {
        var prefix = this.lookupPrefix(namespaceURI);
        return prefix == null;
      }
    };
    function _xmlEncoder(c2) {
      return c2 == "<" && "&lt;" || c2 == ">" && "&gt;" || c2 == "&" && "&amp;" || c2 == '"' && "&quot;" || "&#" + c2.charCodeAt() + ";";
    }
    copy(NodeType, Node2);
    copy(NodeType, Node2.prototype);
    function _visitNode(node, callback) {
      return walkDOM(node, null, { enter: function(n2) {
        return callback(n2) ? walkDOM.STOP : true;
      } }) === walkDOM.STOP;
    }
    function walkDOM(node, context, callbacks) {
      var stack2 = [{ node, context, phase: walkDOM.ENTER }];
      while (stack2.length > 0) {
        var frame3 = stack2.pop();
        if (frame3.phase === walkDOM.ENTER) {
          var childContext = callbacks.enter(frame3.node, frame3.context);
          if (childContext === walkDOM.STOP) {
            return walkDOM.STOP;
          }
          stack2.push({ node: frame3.node, context: childContext, phase: walkDOM.EXIT });
          if (childContext === null || childContext === void 0) {
            continue;
          }
          var child = frame3.node.lastChild;
          while (child) {
            stack2.push({ node: child, context: childContext, phase: walkDOM.ENTER });
            child = child.previousSibling;
          }
        } else {
          if (callbacks.exit) {
            callbacks.exit(frame3.node, frame3.context);
          }
        }
      }
    }
    walkDOM.STOP = Symbol("walkDOM.STOP");
    walkDOM.ENTER = 0;
    walkDOM.EXIT = 1;
    function Document() {
      this.ownerDocument = this;
    }
    function _onAddAttribute(doc, el, newAttr) {
      doc && doc._inc++;
      var ns = newAttr.namespaceURI;
      if (ns === NAMESPACE.XMLNS) {
        el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;
      }
    }
    function _onRemoveAttribute(doc, el, newAttr, remove2) {
      doc && doc._inc++;
      var ns = newAttr.namespaceURI;
      if (ns === NAMESPACE.XMLNS) {
        delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
      }
    }
    function _onUpdateChild(doc, el, newChild) {
      if (doc && doc._inc) {
        doc._inc++;
        var cs = el.childNodes;
        if (newChild) {
          cs[cs.length++] = newChild;
        } else {
          var child = el.firstChild;
          var i2 = 0;
          while (child) {
            cs[i2++] = child;
            child = child.nextSibling;
          }
          cs.length = i2;
          delete cs[cs.length];
        }
      }
    }
    function _removeChild(parentNode, child) {
      var previous = child.previousSibling;
      var next = child.nextSibling;
      if (previous) {
        previous.nextSibling = next;
      } else {
        parentNode.firstChild = next;
      }
      if (next) {
        next.previousSibling = previous;
      } else {
        parentNode.lastChild = previous;
      }
      child.parentNode = null;
      child.previousSibling = null;
      child.nextSibling = null;
      _onUpdateChild(parentNode.ownerDocument, parentNode);
      return child;
    }
    function hasValidParentNodeType(node) {
      return node && (node.nodeType === Node2.DOCUMENT_NODE || node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node2.ELEMENT_NODE);
    }
    function hasInsertableNodeType(node) {
      return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node2.COMMENT_NODE || node.nodeType === Node2.PROCESSING_INSTRUCTION_NODE);
    }
    function isDocTypeNode(node) {
      return node && node.nodeType === Node2.DOCUMENT_TYPE_NODE;
    }
    function isElementNode(node) {
      return node && node.nodeType === Node2.ELEMENT_NODE;
    }
    function isTextNode(node) {
      return node && node.nodeType === Node2.TEXT_NODE;
    }
    function isElementInsertionPossible(doc, child) {
      var parentChildNodes = doc.childNodes || [];
      if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) {
        return false;
      }
      var docTypeNode = find(parentChildNodes, isDocTypeNode);
      return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
    }
    function isElementReplacementPossible(doc, child) {
      var parentChildNodes = doc.childNodes || [];
      function hasElementChildThatIsNotChild(node) {
        return isElementNode(node) && node !== child;
      }
      if (find(parentChildNodes, hasElementChildThatIsNotChild)) {
        return false;
      }
      var docTypeNode = find(parentChildNodes, isDocTypeNode);
      return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
    }
    function assertPreInsertionValidity1to5(parent, node, child) {
      if (!hasValidParentNodeType(parent)) {
        throw new DOMException2(HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
      }
      if (child && child.parentNode !== parent) {
        throw new DOMException2(NOT_FOUND_ERR, "child not in parent");
      }
      if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent.nodeType !== Node2.DOCUMENT_NODE) {
        throw new DOMException2(HIERARCHY_REQUEST_ERR, "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType);
      }
    }
    function assertPreInsertionValidityInDocument(parent, node, child) {
      var parentChildNodes = parent.childNodes || [];
      var nodeChildNodes = node.childNodes || [];
      if (node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE) {
        var nodeChildElements = nodeChildNodes.filter(isElementNode);
        if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
        }
        if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
        }
      }
      if (isElementNode(node)) {
        if (!isElementInsertionPossible(parent, child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
        }
      }
      if (isDocTypeNode(node)) {
        if (find(parentChildNodes, isDocTypeNode)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
        }
        var parentElementChild = find(parentChildNodes, isElementNode);
        if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
        }
        if (!child && parentElementChild) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
        }
      }
    }
    function assertPreReplacementValidityInDocument(parent, node, child) {
      var parentChildNodes = parent.childNodes || [];
      var nodeChildNodes = node.childNodes || [];
      if (node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE) {
        var nodeChildElements = nodeChildNodes.filter(isElementNode);
        if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
        }
        if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
        }
      }
      if (isElementNode(node)) {
        if (!isElementReplacementPossible(parent, child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
        }
      }
      if (isDocTypeNode(node)) {
        let hasDoctypeChildThatIsNotChild2 = function(node2) {
          return isDocTypeNode(node2) && node2 !== child;
        };
        var hasDoctypeChildThatIsNotChild = hasDoctypeChildThatIsNotChild2;
        if (find(parentChildNodes, hasDoctypeChildThatIsNotChild2)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
        }
        var parentElementChild = find(parentChildNodes, isElementNode);
        if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
          throw new DOMException2(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
        }
      }
    }
    function _insertBefore(parent, node, child, _inDocumentAssertion) {
      assertPreInsertionValidity1to5(parent, node, child);
      if (parent.nodeType === Node2.DOCUMENT_NODE) {
        (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
      }
      var cp = node.parentNode;
      if (cp) {
        cp.removeChild(node);
      }
      if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
        var newFirst = node.firstChild;
        if (newFirst == null) {
          return node;
        }
        var newLast = node.lastChild;
      } else {
        newFirst = newLast = node;
      }
      var pre = child ? child.previousSibling : parent.lastChild;
      newFirst.previousSibling = pre;
      newLast.nextSibling = child;
      if (pre) {
        pre.nextSibling = newFirst;
      } else {
        parent.firstChild = newFirst;
      }
      if (child == null) {
        parent.lastChild = newLast;
      } else {
        child.previousSibling = newLast;
      }
      do {
        newFirst.parentNode = parent;
        var targetDoc = parent.ownerDocument || parent;
        _updateOwnerDocument(newFirst, targetDoc);
      } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
      _onUpdateChild(parent.ownerDocument || parent, parent);
      if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {
        node.firstChild = node.lastChild = null;
      }
      return node;
    }
    function _updateOwnerDocument(node, newOwnerDocument) {
      if (node.ownerDocument === newOwnerDocument) {
        return;
      }
      node.ownerDocument = newOwnerDocument;
      if (node.nodeType === ELEMENT_NODE && node.attributes) {
        for (var i2 = 0; i2 < node.attributes.length; i2++) {
          var attr = node.attributes.item(i2);
          if (attr) {
            attr.ownerDocument = newOwnerDocument;
          }
        }
      }
      var child = node.firstChild;
      while (child) {
        _updateOwnerDocument(child, newOwnerDocument);
        child = child.nextSibling;
      }
    }
    function _appendSingleChild(parentNode, newChild) {
      if (newChild.parentNode) {
        newChild.parentNode.removeChild(newChild);
      }
      newChild.parentNode = parentNode;
      newChild.previousSibling = parentNode.lastChild;
      newChild.nextSibling = null;
      if (newChild.previousSibling) {
        newChild.previousSibling.nextSibling = newChild;
      } else {
        parentNode.firstChild = newChild;
      }
      parentNode.lastChild = newChild;
      _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
      var targetDoc = parentNode.ownerDocument || parentNode;
      _updateOwnerDocument(newChild, targetDoc);
      return newChild;
    }
    Document.prototype = {
      nodeName: "#document",
      nodeType: DOCUMENT_NODE,
      doctype: null,
      documentElement: null,
      _inc: 1,
      insertBefore: function(newChild, refChild) {
        if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
          var child = newChild.firstChild;
          while (child) {
            var next = child.nextSibling;
            this.insertBefore(child, refChild);
            child = next;
          }
          return newChild;
        }
        _insertBefore(this, newChild, refChild);
        _updateOwnerDocument(newChild, this);
        if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {
          this.documentElement = newChild;
        }
        return newChild;
      },
      removeChild: function(oldChild) {
        if (this.documentElement == oldChild) {
          this.documentElement = null;
        }
        return _removeChild(this, oldChild);
      },
      replaceChild: function(newChild, oldChild) {
        _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
        _updateOwnerDocument(newChild, this);
        if (oldChild) {
          this.removeChild(oldChild);
        }
        if (isElementNode(newChild)) {
          this.documentElement = newChild;
        }
      },
      importNode: function(importedNode, deep) {
        return importNode(this, importedNode, deep);
      },
      getElementById: function(id) {
        var rtv = null;
        _visitNode(this.documentElement, function(node) {
          if (node.nodeType == ELEMENT_NODE) {
            if (node.getAttribute("id") == id) {
              rtv = node;
              return true;
            }
          }
        });
        return rtv;
      },
      getElementsByClassName: function(classNames49) {
        var classNamesSet = toOrderedSet(classNames49);
        return new LiveNodeList(this, function(base) {
          var ls = [];
          if (classNamesSet.length > 0) {
            _visitNode(base.documentElement, function(node) {
              if (node !== base && node.nodeType === ELEMENT_NODE) {
                var nodeClassNames = node.getAttribute("class");
                if (nodeClassNames) {
                  var matches = classNames49 === nodeClassNames;
                  if (!matches) {
                    var nodeClassNamesSet = toOrderedSet(nodeClassNames);
                    matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
                  }
                  if (matches) {
                    ls.push(node);
                  }
                }
              }
            });
          }
          return ls;
        });
      },
      createElement: function(tagName) {
        var node = new Element2();
        node.ownerDocument = this;
        node.nodeName = tagName;
        node.tagName = tagName;
        node.localName = tagName;
        node.childNodes = new NodeList();
        var attrs = node.attributes = new NamedNodeMap();
        attrs._ownerElement = node;
        return node;
      },
      createDocumentFragment: function() {
        var node = new DocumentFragment();
        node.ownerDocument = this;
        node.childNodes = new NodeList();
        return node;
      },
      createTextNode: function(data) {
        var node = new Text();
        node.ownerDocument = this;
        node.appendData(data);
        return node;
      },
      createComment: function(data) {
        var node = new Comment();
        node.ownerDocument = this;
        node.appendData(data);
        return node;
      },
      createCDATASection: function(data) {
        if (data.indexOf("]]>") !== -1) {
          throw new DOMException2(INVALID_CHARACTER_ERR, 'data contains "]]>"');
        }
        var node = new CDATASection();
        node.ownerDocument = this;
        node.appendData(data);
        return node;
      },
      createProcessingInstruction: function(target, data) {
        var node = new ProcessingInstruction();
        node.ownerDocument = this;
        node.tagName = node.nodeName = node.target = target;
        node.nodeValue = node.data = data;
        return node;
      },
      createAttribute: function(name) {
        var node = new Attr();
        node.ownerDocument = this;
        node.name = name;
        node.nodeName = name;
        node.localName = name;
        node.specified = true;
        return node;
      },
      createEntityReference: function(name) {
        var node = new EntityReference();
        node.ownerDocument = this;
        node.nodeName = name;
        return node;
      },
      createElementNS: function(namespaceURI, qualifiedName) {
        var node = new Element2();
        var pl = qualifiedName.split(":");
        var attrs = node.attributes = new NamedNodeMap();
        node.childNodes = new NodeList();
        node.ownerDocument = this;
        node.nodeName = qualifiedName;
        node.tagName = qualifiedName;
        node.namespaceURI = namespaceURI;
        if (pl.length == 2) {
          node.prefix = pl[0];
          node.localName = pl[1];
        } else {
          node.localName = qualifiedName;
        }
        attrs._ownerElement = node;
        return node;
      },
      createAttributeNS: function(namespaceURI, qualifiedName) {
        var node = new Attr();
        var pl = qualifiedName.split(":");
        node.ownerDocument = this;
        node.nodeName = qualifiedName;
        node.name = qualifiedName;
        node.namespaceURI = namespaceURI;
        node.specified = true;
        if (pl.length == 2) {
          node.prefix = pl[0];
          node.localName = pl[1];
        } else {
          node.localName = qualifiedName;
        }
        return node;
      }
    };
    _extends(Document, Node2);
    function Element2() {
      this._nsMap = {};
    }
    Element2.prototype = {
      nodeType: ELEMENT_NODE,
      hasAttribute: function(name) {
        return this.getAttributeNode(name) != null;
      },
      getAttribute: function(name) {
        var attr = this.getAttributeNode(name);
        return attr && attr.value || "";
      },
      getAttributeNode: function(name) {
        return this.attributes.getNamedItem(name);
      },
      setAttribute: function(name, value) {
        var attr = this.ownerDocument.createAttribute(name);
        attr.value = attr.nodeValue = "" + value;
        this.setAttributeNode(attr);
      },
      removeAttribute: function(name) {
        var attr = this.getAttributeNode(name);
        attr && this.removeAttributeNode(attr);
      },
      appendChild: function(newChild) {
        if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
          return this.insertBefore(newChild, null);
        } else {
          return _appendSingleChild(this, newChild);
        }
      },
      setAttributeNode: function(newAttr) {
        return this.attributes.setNamedItem(newAttr);
      },
      setAttributeNodeNS: function(newAttr) {
        return this.attributes.setNamedItemNS(newAttr);
      },
      removeAttributeNode: function(oldAttr) {
        return this.attributes.removeNamedItem(oldAttr.nodeName);
      },
      removeAttributeNS: function(namespaceURI, localName) {
        var old = this.getAttributeNodeNS(namespaceURI, localName);
        old && this.removeAttributeNode(old);
      },
      hasAttributeNS: function(namespaceURI, localName) {
        return this.getAttributeNodeNS(namespaceURI, localName) != null;
      },
      getAttributeNS: function(namespaceURI, localName) {
        var attr = this.getAttributeNodeNS(namespaceURI, localName);
        return attr && attr.value || "";
      },
      setAttributeNS: function(namespaceURI, qualifiedName, value) {
        var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
        attr.value = attr.nodeValue = "" + value;
        this.setAttributeNode(attr);
      },
      getAttributeNodeNS: function(namespaceURI, localName) {
        return this.attributes.getNamedItemNS(namespaceURI, localName);
      },
      getElementsByTagName: function(tagName) {
        return new LiveNodeList(this, function(base) {
          var ls = [];
          _visitNode(base, function(node) {
            if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) {
              ls.push(node);
            }
          });
          return ls;
        });
      },
      getElementsByTagNameNS: function(namespaceURI, localName) {
        return new LiveNodeList(this, function(base) {
          var ls = [];
          _visitNode(base, function(node) {
            if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) {
              ls.push(node);
            }
          });
          return ls;
        });
      }
    };
    Document.prototype.getElementsByTagName = Element2.prototype.getElementsByTagName;
    Document.prototype.getElementsByTagNameNS = Element2.prototype.getElementsByTagNameNS;
    _extends(Element2, Node2);
    function Attr() {
    }
    Attr.prototype.nodeType = ATTRIBUTE_NODE;
    _extends(Attr, Node2);
    function CharacterData() {
    }
    CharacterData.prototype = {
      data: "",
      substringData: function(offset5, count3) {
        return this.data.substring(offset5, offset5 + count3);
      },
      appendData: function(text) {
        text = this.data + text;
        this.nodeValue = this.data = text;
        this.length = text.length;
      },
      insertData: function(offset5, text) {
        this.replaceData(offset5, 0, text);
      },
      appendChild: function(newChild) {
        throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
      },
      deleteData: function(offset5, count3) {
        this.replaceData(offset5, count3, "");
      },
      replaceData: function(offset5, count3, text) {
        var start2 = this.data.substring(0, offset5);
        var end2 = this.data.substring(offset5 + count3);
        text = start2 + text + end2;
        this.nodeValue = this.data = text;
        this.length = text.length;
      }
    };
    _extends(CharacterData, Node2);
    function Text() {
    }
    Text.prototype = {
      nodeName: "#text",
      nodeType: TEXT_NODE,
      splitText: function(offset5) {
        var text = this.data;
        var newText = text.substring(offset5);
        text = text.substring(0, offset5);
        this.data = this.nodeValue = text;
        this.length = text.length;
        var newNode = this.ownerDocument.createTextNode(newText);
        if (this.parentNode) {
          this.parentNode.insertBefore(newNode, this.nextSibling);
        }
        return newNode;
      }
    };
    _extends(Text, CharacterData);
    function Comment() {
    }
    Comment.prototype = {
      nodeName: "#comment",
      nodeType: COMMENT_NODE
    };
    _extends(Comment, CharacterData);
    function CDATASection() {
    }
    CDATASection.prototype = {
      nodeName: "#cdata-section",
      nodeType: CDATA_SECTION_NODE
    };
    _extends(CDATASection, CharacterData);
    function DocumentType() {
    }
    DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
    _extends(DocumentType, Node2);
    function Notation() {
    }
    Notation.prototype.nodeType = NOTATION_NODE;
    _extends(Notation, Node2);
    function Entity() {
    }
    Entity.prototype.nodeType = ENTITY_NODE;
    _extends(Entity, Node2);
    function EntityReference() {
    }
    EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
    _extends(EntityReference, Node2);
    function DocumentFragment() {
    }
    DocumentFragment.prototype.nodeName = "#document-fragment";
    DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
    _extends(DocumentFragment, Node2);
    function ProcessingInstruction() {
    }
    ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
    _extends(ProcessingInstruction, Node2);
    function XMLSerializer3() {
    }
    XMLSerializer3.prototype.serializeToString = function(node, isHtml, nodeFilter, options) {
      return nodeSerializeToString.call(node, isHtml, nodeFilter, options);
    };
    Node2.prototype.toString = nodeSerializeToString;
    function nodeSerializeToString(isHtml, nodeFilter, options) {
      var requireWellFormed = !!options && !!options.requireWellFormed;
      var buf = [];
      var refNode = this.nodeType == 9 && this.documentElement || this;
      var prefix = refNode.prefix;
      var uri = refNode.namespaceURI;
      if (uri && prefix == null) {
        var prefix = refNode.lookupPrefix(uri);
        if (prefix == null) {
          var visibleNamespaces = [
            { namespace: uri, prefix: null }
          ];
        }
      }
      serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces, requireWellFormed);
      return buf.join("");
    }
    function needNamespaceDefine(node, isHTML, visibleNamespaces) {
      var prefix = node.prefix || "";
      var uri = node.namespaceURI;
      if (!uri) {
        return false;
      }
      if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {
        return false;
      }
      var i2 = visibleNamespaces.length;
      while (i2--) {
        var ns = visibleNamespaces[i2];
        if (ns.prefix === prefix) {
          return ns.namespace !== uri;
        }
      }
      return true;
    }
    function addSerializedAttribute(buf, qualifiedName, value) {
      buf.push(" ", qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
    }
    function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces, requireWellFormed) {
      if (!visibleNamespaces) {
        visibleNamespaces = [];
      }
      walkDOM(node, { ns: visibleNamespaces, isHTML }, {
        enter: function(n2, ctx) {
          var ns = ctx.ns;
          var html = ctx.isHTML;
          if (nodeFilter) {
            n2 = nodeFilter(n2);
            if (n2) {
              if (typeof n2 == "string") {
                buf.push(n2);
                return null;
              }
            } else {
              return null;
            }
          }
          switch (n2.nodeType) {
            case ELEMENT_NODE:
              var attrs = n2.attributes;
              var len = attrs.length;
              var nodeName = n2.tagName;
              html = NAMESPACE.isHTML(n2.namespaceURI) || html;
              var prefixedNodeName = nodeName;
              if (!html && !n2.prefix && n2.namespaceURI) {
                var defaultNS;
                for (var ai = 0; ai < attrs.length; ai++) {
                  if (attrs.item(ai).name === "xmlns") {
                    defaultNS = attrs.item(ai).value;
                    break;
                  }
                }
                if (!defaultNS) {
                  for (var nsi = ns.length - 1; nsi >= 0; nsi--) {
                    var nsEntry = ns[nsi];
                    if (nsEntry.prefix === "" && nsEntry.namespace === n2.namespaceURI) {
                      defaultNS = nsEntry.namespace;
                      break;
                    }
                  }
                }
                if (defaultNS !== n2.namespaceURI) {
                  for (var nsi = ns.length - 1; nsi >= 0; nsi--) {
                    var nsEntry = ns[nsi];
                    if (nsEntry.namespace === n2.namespaceURI) {
                      if (nsEntry.prefix) {
                        prefixedNodeName = nsEntry.prefix + ":" + nodeName;
                      }
                      break;
                    }
                  }
                }
              }
              buf.push("<", prefixedNodeName);
              var childNs = ns.slice();
              for (var i2 = 0; i2 < len; i2++) {
                var attr = attrs.item(i2);
                if (attr.prefix == "xmlns") {
                  childNs.push({ prefix: attr.localName, namespace: attr.value });
                } else if (attr.nodeName == "xmlns") {
                  childNs.push({ prefix: "", namespace: attr.value });
                }
              }
              for (var i2 = 0; i2 < len; i2++) {
                var attr = attrs.item(i2);
                if (needNamespaceDefine(attr, html, childNs)) {
                  var attrPrefix = attr.prefix || "";
                  var uri = attr.namespaceURI;
                  addSerializedAttribute(buf, attrPrefix ? "xmlns:" + attrPrefix : "xmlns", uri);
                  childNs.push({ prefix: attrPrefix, namespace: uri });
                }
                var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;
                if (filteredAttr) {
                  if (typeof filteredAttr === "string") {
                    buf.push(filteredAttr);
                  } else {
                    addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
                  }
                }
              }
              if (nodeName === prefixedNodeName && needNamespaceDefine(n2, html, childNs)) {
                var nodePrefix = n2.prefix || "";
                var uri = n2.namespaceURI;
                addSerializedAttribute(buf, nodePrefix ? "xmlns:" + nodePrefix : "xmlns", uri);
                childNs.push({ prefix: nodePrefix, namespace: uri });
              }
              var child = n2.firstChild;
              if (child || html && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
                buf.push(">");
                if (html && /^script$/i.test(nodeName)) {
                  while (child) {
                    if (child.data) {
                      buf.push(child.data);
                    } else {
                      serializeToString(child, buf, html, nodeFilter, childNs.slice(), requireWellFormed);
                    }
                    child = child.nextSibling;
                  }
                  buf.push("</", nodeName, ">");
                  return null;
                }
                return { ns: childNs, isHTML: html, tag: prefixedNodeName };
              } else {
                buf.push("/>");
                return null;
              }
            case DOCUMENT_NODE:
            case DOCUMENT_FRAGMENT_NODE:
              return { ns: ns.slice(), isHTML: html, tag: null };
            case ATTRIBUTE_NODE:
              addSerializedAttribute(buf, n2.name, n2.value);
              return null;
            case TEXT_NODE:
              buf.push(n2.data.replace(/[<&>]/g, _xmlEncoder));
              return null;
            case CDATA_SECTION_NODE:
              if (requireWellFormed && n2.data.indexOf("]]>") !== -1) {
                throw new DOMException2(INVALID_STATE_ERR, 'The CDATASection data contains "]]>"');
              }
              buf.push("<![CDATA[", n2.data.replace(/]]>/g, "]]]]><![CDATA[>"), "]]>");
              return null;
            case COMMENT_NODE:
              if (requireWellFormed && n2.data.indexOf("-->") !== -1) {
                throw new DOMException2(INVALID_STATE_ERR, 'The comment node data contains "-->"');
              }
              buf.push("<!--", n2.data, "-->");
              return null;
            case DOCUMENT_TYPE_NODE:
              if (requireWellFormed) {
                if (n2.publicId && !/^("[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%']*"|'[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%'"]*')$/.test(n2.publicId)) {
                  throw new DOMException2(INVALID_STATE_ERR, "DocumentType publicId is not a valid PubidLiteral");
                }
                if (n2.systemId && !/^("[^"]*"|'[^']*')$/.test(n2.systemId)) {
                  throw new DOMException2(INVALID_STATE_ERR, "DocumentType systemId is not a valid SystemLiteral");
                }
                if (n2.internalSubset && n2.internalSubset.indexOf("]>") !== -1) {
                  throw new DOMException2(INVALID_STATE_ERR, 'DocumentType internalSubset contains "]>"');
                }
              }
              var pubid = n2.publicId;
              var sysid = n2.systemId;
              buf.push("<!DOCTYPE ", n2.name);
              if (pubid) {
                buf.push(" PUBLIC ", pubid);
                if (sysid && sysid != ".") {
                  buf.push(" ", sysid);
                }
                buf.push(">");
              } else if (sysid && sysid != ".") {
                buf.push(" SYSTEM ", sysid, ">");
              } else {
                var sub = n2.internalSubset;
                if (sub) {
                  buf.push(" [", sub, "]");
                }
                buf.push(">");
              }
              return null;
            case PROCESSING_INSTRUCTION_NODE:
              if (requireWellFormed && n2.data.indexOf("?>") !== -1) {
                throw new DOMException2(INVALID_STATE_ERR, 'The ProcessingInstruction data contains "?>"');
              }
              buf.push("<?", n2.target, " ", n2.data, "?>");
              return null;
            case ENTITY_REFERENCE_NODE:
              buf.push("&", n2.nodeName, ";");
              return null;
            default:
              buf.push("??", n2.nodeName);
              return null;
          }
        },
        exit: function(n2, childCtx) {
          if (childCtx && childCtx.tag) {
            buf.push("</", childCtx.tag, ">");
          }
        }
      });
    }
    function importNode(doc, node, deep) {
      var destRoot;
      walkDOM(node, null, {
        enter: function(srcNode, destParent) {
          var destNode = srcNode.cloneNode(false);
          destNode.ownerDocument = doc;
          destNode.parentNode = null;
          if (destParent === null) {
            destRoot = destNode;
          } else {
            destParent.appendChild(destNode);
          }
          var shouldDeep = srcNode.nodeType === ATTRIBUTE_NODE || deep;
          return shouldDeep ? destNode : null;
        }
      });
      return destRoot;
    }
    function cloneNode(doc, node, deep) {
      var destRoot;
      walkDOM(node, null, {
        enter: function(srcNode, destParent) {
          var destNode = new srcNode.constructor();
          for (var n2 in srcNode) {
            if (Object.prototype.hasOwnProperty.call(srcNode, n2)) {
              var v2 = srcNode[n2];
              if (typeof v2 != "object") {
                if (v2 != destNode[n2]) {
                  destNode[n2] = v2;
                }
              }
            }
          }
          if (srcNode.childNodes) {
            destNode.childNodes = new NodeList();
          }
          destNode.ownerDocument = doc;
          var shouldDeep = deep;
          switch (destNode.nodeType) {
            case ELEMENT_NODE:
              var attrs = srcNode.attributes;
              var attrs2 = destNode.attributes = new NamedNodeMap();
              var len = attrs.length;
              attrs2._ownerElement = destNode;
              for (var i2 = 0; i2 < len; i2++) {
                destNode.setAttributeNode(cloneNode(doc, attrs.item(i2), true));
              }
              break;
            case ATTRIBUTE_NODE:
              shouldDeep = true;
          }
          if (destParent !== null) {
            destParent.appendChild(destNode);
          } else {
            destRoot = destNode;
          }
          return shouldDeep ? destNode : null;
        }
      });
      return destRoot;
    }
    function __set__(object2, key, value) {
      object2[key] = value;
    }
    try {
      if (Object.defineProperty) {
        Object.defineProperty(LiveNodeList.prototype, "length", {
          get: function() {
            _updateLiveList(this);
            return this.$$length;
          }
        });
        Object.defineProperty(Node2.prototype, "textContent", {
          get: function() {
            if (this.nodeType === ELEMENT_NODE || this.nodeType === DOCUMENT_FRAGMENT_NODE) {
              var buf = [];
              walkDOM(this, null, {
                enter: function(n2) {
                  if (n2.nodeType === ELEMENT_NODE || n2.nodeType === DOCUMENT_FRAGMENT_NODE) {
                    return true;
                  }
                  if (n2.nodeType === PROCESSING_INSTRUCTION_NODE || n2.nodeType === COMMENT_NODE) {
                    return null;
                  }
                  buf.push(n2.nodeValue);
                }
              });
              return buf.join("");
            }
            return this.nodeValue;
          },
          set: function(data) {
            switch (this.nodeType) {
              case ELEMENT_NODE:
              case DOCUMENT_FRAGMENT_NODE:
                while (this.firstChild) {
                  this.removeChild(this.firstChild);
                }
                if (data || String(data)) {
                  this.appendChild(this.ownerDocument.createTextNode(data));
                }
                break;
              default:
                this.data = data;
                this.value = data;
                this.nodeValue = data;
            }
          }
        });
        __set__ = function(object2, key, value) {
          object2["$$" + key] = value;
        };
      }
    } catch (e2) {
    }
    exports.DocumentType = DocumentType;
    exports.DOMException = DOMException2;
    exports.DOMImplementation = DOMImplementation;
    exports.Element = Element2;
    exports.Node = Node2;
    exports.NodeList = NodeList;
    exports.walkDOM = walkDOM;
    exports.XMLSerializer = XMLSerializer3;
  }
});

// node_modules/@xmldom/xmldom/lib/entities.js
var require_entities = __commonJS({
  "node_modules/@xmldom/xmldom/lib/entities.js"(exports) {
    "use strict";
    var freeze = require_conventions().freeze;
    exports.XML_ENTITIES = freeze({
      amp: "&",
      apos: "'",
      gt: ">",
      lt: "<",
      quot: '"'
    });
    exports.HTML_ENTITIES = freeze({
      Aacute: "\xC1",
      aacute: "\xE1",
      Abreve: "\u0102",
      abreve: "\u0103",
      ac: "\u223E",
      acd: "\u223F",
      acE: "\u223E\u0333",
      Acirc: "\xC2",
      acirc: "\xE2",
      acute: "\xB4",
      Acy: "\u0410",
      acy: "\u0430",
      AElig: "\xC6",
      aelig: "\xE6",
      af: "\u2061",
      Afr: "\u{1D504}",
      afr: "\u{1D51E}",
      Agrave: "\xC0",
      agrave: "\xE0",
      alefsym: "\u2135",
      aleph: "\u2135",
      Alpha: "\u0391",
      alpha: "\u03B1",
      Amacr: "\u0100",
      amacr: "\u0101",
      amalg: "\u2A3F",
      AMP: "&",
      amp: "&",
      And: "\u2A53",
      and: "\u2227",
      andand: "\u2A55",
      andd: "\u2A5C",
      andslope: "\u2A58",
      andv: "\u2A5A",
      ang: "\u2220",
      ange: "\u29A4",
      angle: "\u2220",
      angmsd: "\u2221",
      angmsdaa: "\u29A8",
      angmsdab: "\u29A9",
      angmsdac: "\u29AA",
      angmsdad: "\u29AB",
      angmsdae: "\u29AC",
      angmsdaf: "\u29AD",
      angmsdag: "\u29AE",
      angmsdah: "\u29AF",
      angrt: "\u221F",
      angrtvb: "\u22BE",
      angrtvbd: "\u299D",
      angsph: "\u2222",
      angst: "\xC5",
      angzarr: "\u237C",
      Aogon: "\u0104",
      aogon: "\u0105",
      Aopf: "\u{1D538}",
      aopf: "\u{1D552}",
      ap: "\u2248",
      apacir: "\u2A6F",
      apE: "\u2A70",
      ape: "\u224A",
      apid: "\u224B",
      apos: "'",
      ApplyFunction: "\u2061",
      approx: "\u2248",
      approxeq: "\u224A",
      Aring: "\xC5",
      aring: "\xE5",
      Ascr: "\u{1D49C}",
      ascr: "\u{1D4B6}",
      Assign: "\u2254",
      ast: "*",
      asymp: "\u2248",
      asympeq: "\u224D",
      Atilde: "\xC3",
      atilde: "\xE3",
      Auml: "\xC4",
      auml: "\xE4",
      awconint: "\u2233",
      awint: "\u2A11",
      backcong: "\u224C",
      backepsilon: "\u03F6",
      backprime: "\u2035",
      backsim: "\u223D",
      backsimeq: "\u22CD",
      Backslash: "\u2216",
      Barv: "\u2AE7",
      barvee: "\u22BD",
      Barwed: "\u2306",
      barwed: "\u2305",
      barwedge: "\u2305",
      bbrk: "\u23B5",
      bbrktbrk: "\u23B6",
      bcong: "\u224C",
      Bcy: "\u0411",
      bcy: "\u0431",
      bdquo: "\u201E",
      becaus: "\u2235",
      Because: "\u2235",
      because: "\u2235",
      bemptyv: "\u29B0",
      bepsi: "\u03F6",
      bernou: "\u212C",
      Bernoullis: "\u212C",
      Beta: "\u0392",
      beta: "\u03B2",
      beth: "\u2136",
      between: "\u226C",
      Bfr: "\u{1D505}",
      bfr: "\u{1D51F}",
      bigcap: "\u22C2",
      bigcirc: "\u25EF",
      bigcup: "\u22C3",
      bigodot: "\u2A00",
      bigoplus: "\u2A01",
      bigotimes: "\u2A02",
      bigsqcup: "\u2A06",
      bigstar: "\u2605",
      bigtriangledown: "\u25BD",
      bigtriangleup: "\u25B3",
      biguplus: "\u2A04",
      bigvee: "\u22C1",
      bigwedge: "\u22C0",
      bkarow: "\u290D",
      blacklozenge: "\u29EB",
      blacksquare: "\u25AA",
      blacktriangle: "\u25B4",
      blacktriangledown: "\u25BE",
      blacktriangleleft: "\u25C2",
      blacktriangleright: "\u25B8",
      blank: "\u2423",
      blk12: "\u2592",
      blk14: "\u2591",
      blk34: "\u2593",
      block: "\u2588",
      bne: "=\u20E5",
      bnequiv: "\u2261\u20E5",
      bNot: "\u2AED",
      bnot: "\u2310",
      Bopf: "\u{1D539}",
      bopf: "\u{1D553}",
      bot: "\u22A5",
      bottom: "\u22A5",
      bowtie: "\u22C8",
      boxbox: "\u29C9",
      boxDL: "\u2557",
      boxDl: "\u2556",
      boxdL: "\u2555",
      boxdl: "\u2510",
      boxDR: "\u2554",
      boxDr: "\u2553",
      boxdR: "\u2552",
      boxdr: "\u250C",
      boxH: "\u2550",
      boxh: "\u2500",
      boxHD: "\u2566",
      boxHd: "\u2564",
      boxhD: "\u2565",
      boxhd: "\u252C",
      boxHU: "\u2569",
      boxHu: "\u2567",
      boxhU: "\u2568",
      boxhu: "\u2534",
      boxminus: "\u229F",
      boxplus: "\u229E",
      boxtimes: "\u22A0",
      boxUL: "\u255D",
      boxUl: "\u255C",
      boxuL: "\u255B",
      boxul: "\u2518",
      boxUR: "\u255A",
      boxUr: "\u2559",
      boxuR: "\u2558",
      boxur: "\u2514",
      boxV: "\u2551",
      boxv: "\u2502",
      boxVH: "\u256C",
      boxVh: "\u256B",
      boxvH: "\u256A",
      boxvh: "\u253C",
      boxVL: "\u2563",
      boxVl: "\u2562",
      boxvL: "\u2561",
      boxvl: "\u2524",
      boxVR: "\u2560",
      boxVr: "\u255F",
      boxvR: "\u255E",
      boxvr: "\u251C",
      bprime: "\u2035",
      Breve: "\u02D8",
      breve: "\u02D8",
      brvbar: "\xA6",
      Bscr: "\u212C",
      bscr: "\u{1D4B7}",
      bsemi: "\u204F",
      bsim: "\u223D",
      bsime: "\u22CD",
      bsol: "\\",
      bsolb: "\u29C5",
      bsolhsub: "\u27C8",
      bull: "\u2022",
      bullet: "\u2022",
      bump: "\u224E",
      bumpE: "\u2AAE",
      bumpe: "\u224F",
      Bumpeq: "\u224E",
      bumpeq: "\u224F",
      Cacute: "\u0106",
      cacute: "\u0107",
      Cap: "\u22D2",
      cap: "\u2229",
      capand: "\u2A44",
      capbrcup: "\u2A49",
      capcap: "\u2A4B",
      capcup: "\u2A47",
      capdot: "\u2A40",
      CapitalDifferentialD: "\u2145",
      caps: "\u2229\uFE00",
      caret: "\u2041",
      caron: "\u02C7",
      Cayleys: "\u212D",
      ccaps: "\u2A4D",
      Ccaron: "\u010C",
      ccaron: "\u010D",
      Ccedil: "\xC7",
      ccedil: "\xE7",
      Ccirc: "\u0108",
      ccirc: "\u0109",
      Cconint: "\u2230",
      ccups: "\u2A4C",
      ccupssm: "\u2A50",
      Cdot: "\u010A",
      cdot: "\u010B",
      cedil: "\xB8",
      Cedilla: "\xB8",
      cemptyv: "\u29B2",
      cent: "\xA2",
      CenterDot: "\xB7",
      centerdot: "\xB7",
      Cfr: "\u212D",
      cfr: "\u{1D520}",
      CHcy: "\u0427",
      chcy: "\u0447",
      check: "\u2713",
      checkmark: "\u2713",
      Chi: "\u03A7",
      chi: "\u03C7",
      cir: "\u25CB",
      circ: "\u02C6",
      circeq: "\u2257",
      circlearrowleft: "\u21BA",
      circlearrowright: "\u21BB",
      circledast: "\u229B",
      circledcirc: "\u229A",
      circleddash: "\u229D",
      CircleDot: "\u2299",
      circledR: "\xAE",
      circledS: "\u24C8",
      CircleMinus: "\u2296",
      CirclePlus: "\u2295",
      CircleTimes: "\u2297",
      cirE: "\u29C3",
      cire: "\u2257",
      cirfnint: "\u2A10",
      cirmid: "\u2AEF",
      cirscir: "\u29C2",
      ClockwiseContourIntegral: "\u2232",
      CloseCurlyDoubleQuote: "\u201D",
      CloseCurlyQuote: "\u2019",
      clubs: "\u2663",
      clubsuit: "\u2663",
      Colon: "\u2237",
      colon: ":",
      Colone: "\u2A74",
      colone: "\u2254",
      coloneq: "\u2254",
      comma: ",",
      commat: "@",
      comp: "\u2201",
      compfn: "\u2218",
      complement: "\u2201",
      complexes: "\u2102",
      cong: "\u2245",
      congdot: "\u2A6D",
      Congruent: "\u2261",
      Conint: "\u222F",
      conint: "\u222E",
      ContourIntegral: "\u222E",
      Copf: "\u2102",
      copf: "\u{1D554}",
      coprod: "\u2210",
      Coproduct: "\u2210",
      COPY: "\xA9",
      copy: "\xA9",
      copysr: "\u2117",
      CounterClockwiseContourIntegral: "\u2233",
      crarr: "\u21B5",
      Cross: "\u2A2F",
      cross: "\u2717",
      Cscr: "\u{1D49E}",
      cscr: "\u{1D4B8}",
      csub: "\u2ACF",
      csube: "\u2AD1",
      csup: "\u2AD0",
      csupe: "\u2AD2",
      ctdot: "\u22EF",
      cudarrl: "\u2938",
      cudarrr: "\u2935",
      cuepr: "\u22DE",
      cuesc: "\u22DF",
      cularr: "\u21B6",
      cularrp: "\u293D",
      Cup: "\u22D3",
      cup: "\u222A",
      cupbrcap: "\u2A48",
      CupCap: "\u224D",
      cupcap: "\u2A46",
      cupcup: "\u2A4A",
      cupdot: "\u228D",
      cupor: "\u2A45",
      cups: "\u222A\uFE00",
      curarr: "\u21B7",
      curarrm: "\u293C",
      curlyeqprec: "\u22DE",
      curlyeqsucc: "\u22DF",
      curlyvee: "\u22CE",
      curlywedge: "\u22CF",
      curren: "\xA4",
      curvearrowleft: "\u21B6",
      curvearrowright: "\u21B7",
      cuvee: "\u22CE",
      cuwed: "\u22CF",
      cwconint: "\u2232",
      cwint: "\u2231",
      cylcty: "\u232D",
      Dagger: "\u2021",
      dagger: "\u2020",
      daleth: "\u2138",
      Darr: "\u21A1",
      dArr: "\u21D3",
      darr: "\u2193",
      dash: "\u2010",
      Dashv: "\u2AE4",
      dashv: "\u22A3",
      dbkarow: "\u290F",
      dblac: "\u02DD",
      Dcaron: "\u010E",
      dcaron: "\u010F",
      Dcy: "\u0414",
      dcy: "\u0434",
      DD: "\u2145",
      dd: "\u2146",
      ddagger: "\u2021",
      ddarr: "\u21CA",
      DDotrahd: "\u2911",
      ddotseq: "\u2A77",
      deg: "\xB0",
      Del: "\u2207",
      Delta: "\u0394",
      delta: "\u03B4",
      demptyv: "\u29B1",
      dfisht: "\u297F",
      Dfr: "\u{1D507}",
      dfr: "\u{1D521}",
      dHar: "\u2965",
      dharl: "\u21C3",
      dharr: "\u21C2",
      DiacriticalAcute: "\xB4",
      DiacriticalDot: "\u02D9",
      DiacriticalDoubleAcute: "\u02DD",
      DiacriticalGrave: "`",
      DiacriticalTilde: "\u02DC",
      diam: "\u22C4",
      Diamond: "\u22C4",
      diamond: "\u22C4",
      diamondsuit: "\u2666",
      diams: "\u2666",
      die: "\xA8",
      DifferentialD: "\u2146",
      digamma: "\u03DD",
      disin: "\u22F2",
      div: "\xF7",
      divide: "\xF7",
      divideontimes: "\u22C7",
      divonx: "\u22C7",
      DJcy: "\u0402",
      djcy: "\u0452",
      dlcorn: "\u231E",
      dlcrop: "\u230D",
      dollar: "$",
      Dopf: "\u{1D53B}",
      dopf: "\u{1D555}",
      Dot: "\xA8",
      dot: "\u02D9",
      DotDot: "\u20DC",
      doteq: "\u2250",
      doteqdot: "\u2251",
      DotEqual: "\u2250",
      dotminus: "\u2238",
      dotplus: "\u2214",
      dotsquare: "\u22A1",
      doublebarwedge: "\u2306",
      DoubleContourIntegral: "\u222F",
      DoubleDot: "\xA8",
      DoubleDownArrow: "\u21D3",
      DoubleLeftArrow: "\u21D0",
      DoubleLeftRightArrow: "\u21D4",
      DoubleLeftTee: "\u2AE4",
      DoubleLongLeftArrow: "\u27F8",
      DoubleLongLeftRightArrow: "\u27FA",
      DoubleLongRightArrow: "\u27F9",
      DoubleRightArrow: "\u21D2",
      DoubleRightTee: "\u22A8",
      DoubleUpArrow: "\u21D1",
      DoubleUpDownArrow: "\u21D5",
      DoubleVerticalBar: "\u2225",
      DownArrow: "\u2193",
      Downarrow: "\u21D3",
      downarrow: "\u2193",
      DownArrowBar: "\u2913",
      DownArrowUpArrow: "\u21F5",
      DownBreve: "\u0311",
      downdownarrows: "\u21CA",
      downharpoonleft: "\u21C3",
      downharpoonright: "\u21C2",
      DownLeftRightVector: "\u2950",
      DownLeftTeeVector: "\u295E",
      DownLeftVector: "\u21BD",
      DownLeftVectorBar: "\u2956",
      DownRightTeeVector: "\u295F",
      DownRightVector: "\u21C1",
      DownRightVectorBar: "\u2957",
      DownTee: "\u22A4",
      DownTeeArrow: "\u21A7",
      drbkarow: "\u2910",
      drcorn: "\u231F",
      drcrop: "\u230C",
      Dscr: "\u{1D49F}",
      dscr: "\u{1D4B9}",
      DScy: "\u0405",
      dscy: "\u0455",
      dsol: "\u29F6",
      Dstrok: "\u0110",
      dstrok: "\u0111",
      dtdot: "\u22F1",
      dtri: "\u25BF",
      dtrif: "\u25BE",
      duarr: "\u21F5",
      duhar: "\u296F",
      dwangle: "\u29A6",
      DZcy: "\u040F",
      dzcy: "\u045F",
      dzigrarr: "\u27FF",
      Eacute: "\xC9",
      eacute: "\xE9",
      easter: "\u2A6E",
      Ecaron: "\u011A",
      ecaron: "\u011B",
      ecir: "\u2256",
      Ecirc: "\xCA",
      ecirc: "\xEA",
      ecolon: "\u2255",
      Ecy: "\u042D",
      ecy: "\u044D",
      eDDot: "\u2A77",
      Edot: "\u0116",
      eDot: "\u2251",
      edot: "\u0117",
      ee: "\u2147",
      efDot: "\u2252",
      Efr: "\u{1D508}",
      efr: "\u{1D522}",
      eg: "\u2A9A",
      Egrave: "\xC8",
      egrave: "\xE8",
      egs: "\u2A96",
      egsdot: "\u2A98",
      el: "\u2A99",
      Element: "\u2208",
      elinters: "\u23E7",
      ell: "\u2113",
      els: "\u2A95",
      elsdot: "\u2A97",
      Emacr: "\u0112",
      emacr: "\u0113",
      empty: "\u2205",
      emptyset: "\u2205",
      EmptySmallSquare: "\u25FB",
      emptyv: "\u2205",
      EmptyVerySmallSquare: "\u25AB",
      emsp: "\u2003",
      emsp13: "\u2004",
      emsp14: "\u2005",
      ENG: "\u014A",
      eng: "\u014B",
      ensp: "\u2002",
      Eogon: "\u0118",
      eogon: "\u0119",
      Eopf: "\u{1D53C}",
      eopf: "\u{1D556}",
      epar: "\u22D5",
      eparsl: "\u29E3",
      eplus: "\u2A71",
      epsi: "\u03B5",
      Epsilon: "\u0395",
      epsilon: "\u03B5",
      epsiv: "\u03F5",
      eqcirc: "\u2256",
      eqcolon: "\u2255",
      eqsim: "\u2242",
      eqslantgtr: "\u2A96",
      eqslantless: "\u2A95",
      Equal: "\u2A75",
      equals: "=",
      EqualTilde: "\u2242",
      equest: "\u225F",
      Equilibrium: "\u21CC",
      equiv: "\u2261",
      equivDD: "\u2A78",
      eqvparsl: "\u29E5",
      erarr: "\u2971",
      erDot: "\u2253",
      Escr: "\u2130",
      escr: "\u212F",
      esdot: "\u2250",
      Esim: "\u2A73",
      esim: "\u2242",
      Eta: "\u0397",
      eta: "\u03B7",
      ETH: "\xD0",
      eth: "\xF0",
      Euml: "\xCB",
      euml: "\xEB",
      euro: "\u20AC",
      excl: "!",
      exist: "\u2203",
      Exists: "\u2203",
      expectation: "\u2130",
      ExponentialE: "\u2147",
      exponentiale: "\u2147",
      fallingdotseq: "\u2252",
      Fcy: "\u0424",
      fcy: "\u0444",
      female: "\u2640",
      ffilig: "\uFB03",
      fflig: "\uFB00",
      ffllig: "\uFB04",
      Ffr: "\u{1D509}",
      ffr: "\u{1D523}",
      filig: "\uFB01",
      FilledSmallSquare: "\u25FC",
      FilledVerySmallSquare: "\u25AA",
      fjlig: "fj",
      flat: "\u266D",
      fllig: "\uFB02",
      fltns: "\u25B1",
      fnof: "\u0192",
      Fopf: "\u{1D53D}",
      fopf: "\u{1D557}",
      ForAll: "\u2200",
      forall: "\u2200",
      fork: "\u22D4",
      forkv: "\u2AD9",
      Fouriertrf: "\u2131",
      fpartint: "\u2A0D",
      frac12: "\xBD",
      frac13: "\u2153",
      frac14: "\xBC",
      frac15: "\u2155",
      frac16: "\u2159",
      frac18: "\u215B",
      frac23: "\u2154",
      frac25: "\u2156",
      frac34: "\xBE",
      frac35: "\u2157",
      frac38: "\u215C",
      frac45: "\u2158",
      frac56: "\u215A",
      frac58: "\u215D",
      frac78: "\u215E",
      frasl: "\u2044",
      frown: "\u2322",
      Fscr: "\u2131",
      fscr: "\u{1D4BB}",
      gacute: "\u01F5",
      Gamma: "\u0393",
      gamma: "\u03B3",
      Gammad: "\u03DC",
      gammad: "\u03DD",
      gap: "\u2A86",
      Gbreve: "\u011E",
      gbreve: "\u011F",
      Gcedil: "\u0122",
      Gcirc: "\u011C",
      gcirc: "\u011D",
      Gcy: "\u0413",
      gcy: "\u0433",
      Gdot: "\u0120",
      gdot: "\u0121",
      gE: "\u2267",
      ge: "\u2265",
      gEl: "\u2A8C",
      gel: "\u22DB",
      geq: "\u2265",
      geqq: "\u2267",
      geqslant: "\u2A7E",
      ges: "\u2A7E",
      gescc: "\u2AA9",
      gesdot: "\u2A80",
      gesdoto: "\u2A82",
      gesdotol: "\u2A84",
      gesl: "\u22DB\uFE00",
      gesles: "\u2A94",
      Gfr: "\u{1D50A}",
      gfr: "\u{1D524}",
      Gg: "\u22D9",
      gg: "\u226B",
      ggg: "\u22D9",
      gimel: "\u2137",
      GJcy: "\u0403",
      gjcy: "\u0453",
      gl: "\u2277",
      gla: "\u2AA5",
      glE: "\u2A92",
      glj: "\u2AA4",
      gnap: "\u2A8A",
      gnapprox: "\u2A8A",
      gnE: "\u2269",
      gne: "\u2A88",
      gneq: "\u2A88",
      gneqq: "\u2269",
      gnsim: "\u22E7",
      Gopf: "\u{1D53E}",
      gopf: "\u{1D558}",
      grave: "`",
      GreaterEqual: "\u2265",
      GreaterEqualLess: "\u22DB",
      GreaterFullEqual: "\u2267",
      GreaterGreater: "\u2AA2",
      GreaterLess: "\u2277",
      GreaterSlantEqual: "\u2A7E",
      GreaterTilde: "\u2273",
      Gscr: "\u{1D4A2}",
      gscr: "\u210A",
      gsim: "\u2273",
      gsime: "\u2A8E",
      gsiml: "\u2A90",
      Gt: "\u226B",
      GT: ">",
      gt: ">",
      gtcc: "\u2AA7",
      gtcir: "\u2A7A",
      gtdot: "\u22D7",
      gtlPar: "\u2995",
      gtquest: "\u2A7C",
      gtrapprox: "\u2A86",
      gtrarr: "\u2978",
      gtrdot: "\u22D7",
      gtreqless: "\u22DB",
      gtreqqless: "\u2A8C",
      gtrless: "\u2277",
      gtrsim: "\u2273",
      gvertneqq: "\u2269\uFE00",
      gvnE: "\u2269\uFE00",
      Hacek: "\u02C7",
      hairsp: "\u200A",
      half: "\xBD",
      hamilt: "\u210B",
      HARDcy: "\u042A",
      hardcy: "\u044A",
      hArr: "\u21D4",
      harr: "\u2194",
      harrcir: "\u2948",
      harrw: "\u21AD",
      Hat: "^",
      hbar: "\u210F",
      Hcirc: "\u0124",
      hcirc: "\u0125",
      hearts: "\u2665",
      heartsuit: "\u2665",
      hellip: "\u2026",
      hercon: "\u22B9",
      Hfr: "\u210C",
      hfr: "\u{1D525}",
      HilbertSpace: "\u210B",
      hksearow: "\u2925",
      hkswarow: "\u2926",
      hoarr: "\u21FF",
      homtht: "\u223B",
      hookleftarrow: "\u21A9",
      hookrightarrow: "\u21AA",
      Hopf: "\u210D",
      hopf: "\u{1D559}",
      horbar: "\u2015",
      HorizontalLine: "\u2500",
      Hscr: "\u210B",
      hscr: "\u{1D4BD}",
      hslash: "\u210F",
      Hstrok: "\u0126",
      hstrok: "\u0127",
      HumpDownHump: "\u224E",
      HumpEqual: "\u224F",
      hybull: "\u2043",
      hyphen: "\u2010",
      Iacute: "\xCD",
      iacute: "\xED",
      ic: "\u2063",
      Icirc: "\xCE",
      icirc: "\xEE",
      Icy: "\u0418",
      icy: "\u0438",
      Idot: "\u0130",
      IEcy: "\u0415",
      iecy: "\u0435",
      iexcl: "\xA1",
      iff: "\u21D4",
      Ifr: "\u2111",
      ifr: "\u{1D526}",
      Igrave: "\xCC",
      igrave: "\xEC",
      ii: "\u2148",
      iiiint: "\u2A0C",
      iiint: "\u222D",
      iinfin: "\u29DC",
      iiota: "\u2129",
      IJlig: "\u0132",
      ijlig: "\u0133",
      Im: "\u2111",
      Imacr: "\u012A",
      imacr: "\u012B",
      image: "\u2111",
      ImaginaryI: "\u2148",
      imagline: "\u2110",
      imagpart: "\u2111",
      imath: "\u0131",
      imof: "\u22B7",
      imped: "\u01B5",
      Implies: "\u21D2",
      in: "\u2208",
      incare: "\u2105",
      infin: "\u221E",
      infintie: "\u29DD",
      inodot: "\u0131",
      Int: "\u222C",
      int: "\u222B",
      intcal: "\u22BA",
      integers: "\u2124",
      Integral: "\u222B",
      intercal: "\u22BA",
      Intersection: "\u22C2",
      intlarhk: "\u2A17",
      intprod: "\u2A3C",
      InvisibleComma: "\u2063",
      InvisibleTimes: "\u2062",
      IOcy: "\u0401",
      iocy: "\u0451",
      Iogon: "\u012E",
      iogon: "\u012F",
      Iopf: "\u{1D540}",
      iopf: "\u{1D55A}",
      Iota: "\u0399",
      iota: "\u03B9",
      iprod: "\u2A3C",
      iquest: "\xBF",
      Iscr: "\u2110",
      iscr: "\u{1D4BE}",
      isin: "\u2208",
      isindot: "\u22F5",
      isinE: "\u22F9",
      isins: "\u22F4",
      isinsv: "\u22F3",
      isinv: "\u2208",
      it: "\u2062",
      Itilde: "\u0128",
      itilde: "\u0129",
      Iukcy: "\u0406",
      iukcy: "\u0456",
      Iuml: "\xCF",
      iuml: "\xEF",
      Jcirc: "\u0134",
      jcirc: "\u0135",
      Jcy: "\u0419",
      jcy: "\u0439",
      Jfr: "\u{1D50D}",
      jfr: "\u{1D527}",
      jmath: "\u0237",
      Jopf: "\u{1D541}",
      jopf: "\u{1D55B}",
      Jscr: "\u{1D4A5}",
      jscr: "\u{1D4BF}",
      Jsercy: "\u0408",
      jsercy: "\u0458",
      Jukcy: "\u0404",
      jukcy: "\u0454",
      Kappa: "\u039A",
      kappa: "\u03BA",
      kappav: "\u03F0",
      Kcedil: "\u0136",
      kcedil: "\u0137",
      Kcy: "\u041A",
      kcy: "\u043A",
      Kfr: "\u{1D50E}",
      kfr: "\u{1D528}",
      kgreen: "\u0138",
      KHcy: "\u0425",
      khcy: "\u0445",
      KJcy: "\u040C",
      kjcy: "\u045C",
      Kopf: "\u{1D542}",
      kopf: "\u{1D55C}",
      Kscr: "\u{1D4A6}",
      kscr: "\u{1D4C0}",
      lAarr: "\u21DA",
      Lacute: "\u0139",
      lacute: "\u013A",
      laemptyv: "\u29B4",
      lagran: "\u2112",
      Lambda: "\u039B",
      lambda: "\u03BB",
      Lang: "\u27EA",
      lang: "\u27E8",
      langd: "\u2991",
      langle: "\u27E8",
      lap: "\u2A85",
      Laplacetrf: "\u2112",
      laquo: "\xAB",
      Larr: "\u219E",
      lArr: "\u21D0",
      larr: "\u2190",
      larrb: "\u21E4",
      larrbfs: "\u291F",
      larrfs: "\u291D",
      larrhk: "\u21A9",
      larrlp: "\u21AB",
      larrpl: "\u2939",
      larrsim: "\u2973",
      larrtl: "\u21A2",
      lat: "\u2AAB",
      lAtail: "\u291B",
      latail: "\u2919",
      late: "\u2AAD",
      lates: "\u2AAD\uFE00",
      lBarr: "\u290E",
      lbarr: "\u290C",
      lbbrk: "\u2772",
      lbrace: "{",
      lbrack: "[",
      lbrke: "\u298B",
      lbrksld: "\u298F",
      lbrkslu: "\u298D",
      Lcaron: "\u013D",
      lcaron: "\u013E",
      Lcedil: "\u013B",
      lcedil: "\u013C",
      lceil: "\u2308",
      lcub: "{",
      Lcy: "\u041B",
      lcy: "\u043B",
      ldca: "\u2936",
      ldquo: "\u201C",
      ldquor: "\u201E",
      ldrdhar: "\u2967",
      ldrushar: "\u294B",
      ldsh: "\u21B2",
      lE: "\u2266",
      le: "\u2264",
      LeftAngleBracket: "\u27E8",
      LeftArrow: "\u2190",
      Leftarrow: "\u21D0",
      leftarrow: "\u2190",
      LeftArrowBar: "\u21E4",
      LeftArrowRightArrow: "\u21C6",
      leftarrowtail: "\u21A2",
      LeftCeiling: "\u2308",
      LeftDoubleBracket: "\u27E6",
      LeftDownTeeVector: "\u2961",
      LeftDownVector: "\u21C3",
      LeftDownVectorBar: "\u2959",
      LeftFloor: "\u230A",
      leftharpoondown: "\u21BD",
      leftharpoonup: "\u21BC",
      leftleftarrows: "\u21C7",
      LeftRightArrow: "\u2194",
      Leftrightarrow: "\u21D4",
      leftrightarrow: "\u2194",
      leftrightarrows: "\u21C6",
      leftrightharpoons: "\u21CB",
      leftrightsquigarrow: "\u21AD",
      LeftRightVector: "\u294E",
      LeftTee: "\u22A3",
      LeftTeeArrow: "\u21A4",
      LeftTeeVector: "\u295A",
      leftthreetimes: "\u22CB",
      LeftTriangle: "\u22B2",
      LeftTriangleBar: "\u29CF",
      LeftTriangleEqual: "\u22B4",
      LeftUpDownVector: "\u2951",
      LeftUpTeeVector: "\u2960",
      LeftUpVector: "\u21BF",
      LeftUpVectorBar: "\u2958",
      LeftVector: "\u21BC",
      LeftVectorBar: "\u2952",
      lEg: "\u2A8B",
      leg: "\u22DA",
      leq: "\u2264",
      leqq: "\u2266",
      leqslant: "\u2A7D",
      les: "\u2A7D",
      lescc: "\u2AA8",
      lesdot: "\u2A7F",
      lesdoto: "\u2A81",
      lesdotor: "\u2A83",
      lesg: "\u22DA\uFE00",
      lesges: "\u2A93",
      lessapprox: "\u2A85",
      lessdot: "\u22D6",
      lesseqgtr: "\u22DA",
      lesseqqgtr: "\u2A8B",
      LessEqualGreater: "\u22DA",
      LessFullEqual: "\u2266",
      LessGreater: "\u2276",
      lessgtr: "\u2276",
      LessLess: "\u2AA1",
      lesssim: "\u2272",
      LessSlantEqual: "\u2A7D",
      LessTilde: "\u2272",
      lfisht: "\u297C",
      lfloor: "\u230A",
      Lfr: "\u{1D50F}",
      lfr: "\u{1D529}",
      lg: "\u2276",
      lgE: "\u2A91",
      lHar: "\u2962",
      lhard: "\u21BD",
      lharu: "\u21BC",
      lharul: "\u296A",
      lhblk: "\u2584",
      LJcy: "\u0409",
      ljcy: "\u0459",
      Ll: "\u22D8",
      ll: "\u226A",
      llarr: "\u21C7",
      llcorner: "\u231E",
      Lleftarrow: "\u21DA",
      llhard: "\u296B",
      lltri: "\u25FA",
      Lmidot: "\u013F",
      lmidot: "\u0140",
      lmoust: "\u23B0",
      lmoustache: "\u23B0",
      lnap: "\u2A89",
      lnapprox: "\u2A89",
      lnE: "\u2268",
      lne: "\u2A87",
      lneq: "\u2A87",
      lneqq: "\u2268",
      lnsim: "\u22E6",
      loang: "\u27EC",
      loarr: "\u21FD",
      lobrk: "\u27E6",
      LongLeftArrow: "\u27F5",
      Longleftarrow: "\u27F8",
      longleftarrow: "\u27F5",
      LongLeftRightArrow: "\u27F7",
      Longleftrightarrow: "\u27FA",
      longleftrightarrow: "\u27F7",
      longmapsto: "\u27FC",
      LongRightArrow: "\u27F6",
      Longrightarrow: "\u27F9",
      longrightarrow: "\u27F6",
      looparrowleft: "\u21AB",
      looparrowright: "\u21AC",
      lopar: "\u2985",
      Lopf: "\u{1D543}",
      lopf: "\u{1D55D}",
      loplus: "\u2A2D",
      lotimes: "\u2A34",
      lowast: "\u2217",
      lowbar: "_",
      LowerLeftArrow: "\u2199",
      LowerRightArrow: "\u2198",
      loz: "\u25CA",
      lozenge: "\u25CA",
      lozf: "\u29EB",
      lpar: "(",
      lparlt: "\u2993",
      lrarr: "\u21C6",
      lrcorner: "\u231F",
      lrhar: "\u21CB",
      lrhard: "\u296D",
      lrm: "\u200E",
      lrtri: "\u22BF",
      lsaquo: "\u2039",
      Lscr: "\u2112",
      lscr: "\u{1D4C1}",
      Lsh: "\u21B0",
      lsh: "\u21B0",
      lsim: "\u2272",
      lsime: "\u2A8D",
      lsimg: "\u2A8F",
      lsqb: "[",
      lsquo: "\u2018",
      lsquor: "\u201A",
      Lstrok: "\u0141",
      lstrok: "\u0142",
      Lt: "\u226A",
      LT: "<",
      lt: "<",
      ltcc: "\u2AA6",
      ltcir: "\u2A79",
      ltdot: "\u22D6",
      lthree: "\u22CB",
      ltimes: "\u22C9",
      ltlarr: "\u2976",
      ltquest: "\u2A7B",
      ltri: "\u25C3",
      ltrie: "\u22B4",
      ltrif: "\u25C2",
      ltrPar: "\u2996",
      lurdshar: "\u294A",
      luruhar: "\u2966",
      lvertneqq: "\u2268\uFE00",
      lvnE: "\u2268\uFE00",
      macr: "\xAF",
      male: "\u2642",
      malt: "\u2720",
      maltese: "\u2720",
      Map: "\u2905",
      map: "\u21A6",
      mapsto: "\u21A6",
      mapstodown: "\u21A7",
      mapstoleft: "\u21A4",
      mapstoup: "\u21A5",
      marker: "\u25AE",
      mcomma: "\u2A29",
      Mcy: "\u041C",
      mcy: "\u043C",
      mdash: "\u2014",
      mDDot: "\u223A",
      measuredangle: "\u2221",
      MediumSpace: "\u205F",
      Mellintrf: "\u2133",
      Mfr: "\u{1D510}",
      mfr: "\u{1D52A}",
      mho: "\u2127",
      micro: "\xB5",
      mid: "\u2223",
      midast: "*",
      midcir: "\u2AF0",
      middot: "\xB7",
      minus: "\u2212",
      minusb: "\u229F",
      minusd: "\u2238",
      minusdu: "\u2A2A",
      MinusPlus: "\u2213",
      mlcp: "\u2ADB",
      mldr: "\u2026",
      mnplus: "\u2213",
      models: "\u22A7",
      Mopf: "\u{1D544}",
      mopf: "\u{1D55E}",
      mp: "\u2213",
      Mscr: "\u2133",
      mscr: "\u{1D4C2}",
      mstpos: "\u223E",
      Mu: "\u039C",
      mu: "\u03BC",
      multimap: "\u22B8",
      mumap: "\u22B8",
      nabla: "\u2207",
      Nacute: "\u0143",
      nacute: "\u0144",
      nang: "\u2220\u20D2",
      nap: "\u2249",
      napE: "\u2A70\u0338",
      napid: "\u224B\u0338",
      napos: "\u0149",
      napprox: "\u2249",
      natur: "\u266E",
      natural: "\u266E",
      naturals: "\u2115",
      nbsp: "\xA0",
      nbump: "\u224E\u0338",
      nbumpe: "\u224F\u0338",
      ncap: "\u2A43",
      Ncaron: "\u0147",
      ncaron: "\u0148",
      Ncedil: "\u0145",
      ncedil: "\u0146",
      ncong: "\u2247",
      ncongdot: "\u2A6D\u0338",
      ncup: "\u2A42",
      Ncy: "\u041D",
      ncy: "\u043D",
      ndash: "\u2013",
      ne: "\u2260",
      nearhk: "\u2924",
      neArr: "\u21D7",
      nearr: "\u2197",
      nearrow: "\u2197",
      nedot: "\u2250\u0338",
      NegativeMediumSpace: "\u200B",
      NegativeThickSpace: "\u200B",
      NegativeThinSpace: "\u200B",
      NegativeVeryThinSpace: "\u200B",
      nequiv: "\u2262",
      nesear: "\u2928",
      nesim: "\u2242\u0338",
      NestedGreaterGreater: "\u226B",
      NestedLessLess: "\u226A",
      NewLine: "\n",
      nexist: "\u2204",
      nexists: "\u2204",
      Nfr: "\u{1D511}",
      nfr: "\u{1D52B}",
      ngE: "\u2267\u0338",
      nge: "\u2271",
      ngeq: "\u2271",
      ngeqq: "\u2267\u0338",
      ngeqslant: "\u2A7E\u0338",
      nges: "\u2A7E\u0338",
      nGg: "\u22D9\u0338",
      ngsim: "\u2275",
      nGt: "\u226B\u20D2",
      ngt: "\u226F",
      ngtr: "\u226F",
      nGtv: "\u226B\u0338",
      nhArr: "\u21CE",
      nharr: "\u21AE",
      nhpar: "\u2AF2",
      ni: "\u220B",
      nis: "\u22FC",
      nisd: "\u22FA",
      niv: "\u220B",
      NJcy: "\u040A",
      njcy: "\u045A",
      nlArr: "\u21CD",
      nlarr: "\u219A",
      nldr: "\u2025",
      nlE: "\u2266\u0338",
      nle: "\u2270",
      nLeftarrow: "\u21CD",
      nleftarrow: "\u219A",
      nLeftrightarrow: "\u21CE",
      nleftrightarrow: "\u21AE",
      nleq: "\u2270",
      nleqq: "\u2266\u0338",
      nleqslant: "\u2A7D\u0338",
      nles: "\u2A7D\u0338",
      nless: "\u226E",
      nLl: "\u22D8\u0338",
      nlsim: "\u2274",
      nLt: "\u226A\u20D2",
      nlt: "\u226E",
      nltri: "\u22EA",
      nltrie: "\u22EC",
      nLtv: "\u226A\u0338",
      nmid: "\u2224",
      NoBreak: "\u2060",
      NonBreakingSpace: "\xA0",
      Nopf: "\u2115",
      nopf: "\u{1D55F}",
      Not: "\u2AEC",
      not: "\xAC",
      NotCongruent: "\u2262",
      NotCupCap: "\u226D",
      NotDoubleVerticalBar: "\u2226",
      NotElement: "\u2209",
      NotEqual: "\u2260",
      NotEqualTilde: "\u2242\u0338",
      NotExists: "\u2204",
      NotGreater: "\u226F",
      NotGreaterEqual: "\u2271",
      NotGreaterFullEqual: "\u2267\u0338",
      NotGreaterGreater: "\u226B\u0338",
      NotGreaterLess: "\u2279",
      NotGreaterSlantEqual: "\u2A7E\u0338",
      NotGreaterTilde: "\u2275",
      NotHumpDownHump: "\u224E\u0338",
      NotHumpEqual: "\u224F\u0338",
      notin: "\u2209",
      notindot: "\u22F5\u0338",
      notinE: "\u22F9\u0338",
      notinva: "\u2209",
      notinvb: "\u22F7",
      notinvc: "\u22F6",
      NotLeftTriangle: "\u22EA",
      NotLeftTriangleBar: "\u29CF\u0338",
      NotLeftTriangleEqual: "\u22EC",
      NotLess: "\u226E",
      NotLessEqual: "\u2270",
      NotLessGreater: "\u2278",
      NotLessLess: "\u226A\u0338",
      NotLessSlantEqual: "\u2A7D\u0338",
      NotLessTilde: "\u2274",
      NotNestedGreaterGreater: "\u2AA2\u0338",
      NotNestedLessLess: "\u2AA1\u0338",
      notni: "\u220C",
      notniva: "\u220C",
      notnivb: "\u22FE",
      notnivc: "\u22FD",
      NotPrecedes: "\u2280",
      NotPrecedesEqual: "\u2AAF\u0338",
      NotPrecedesSlantEqual: "\u22E0",
      NotReverseElement: "\u220C",
      NotRightTriangle: "\u22EB",
      NotRightTriangleBar: "\u29D0\u0338",
      NotRightTriangleEqual: "\u22ED",
      NotSquareSubset: "\u228F\u0338",
      NotSquareSubsetEqual: "\u22E2",
      NotSquareSuperset: "\u2290\u0338",
      NotSquareSupersetEqual: "\u22E3",
      NotSubset: "\u2282\u20D2",
      NotSubsetEqual: "\u2288",
      NotSucceeds: "\u2281",
      NotSucceedsEqual: "\u2AB0\u0338",
      NotSucceedsSlantEqual: "\u22E1",
      NotSucceedsTilde: "\u227F\u0338",
      NotSuperset: "\u2283\u20D2",
      NotSupersetEqual: "\u2289",
      NotTilde: "\u2241",
      NotTildeEqual: "\u2244",
      NotTildeFullEqual: "\u2247",
      NotTildeTilde: "\u2249",
      NotVerticalBar: "\u2224",
      npar: "\u2226",
      nparallel: "\u2226",
      nparsl: "\u2AFD\u20E5",
      npart: "\u2202\u0338",
      npolint: "\u2A14",
      npr: "\u2280",
      nprcue: "\u22E0",
      npre: "\u2AAF\u0338",
      nprec: "\u2280",
      npreceq: "\u2AAF\u0338",
      nrArr: "\u21CF",
      nrarr: "\u219B",
      nrarrc: "\u2933\u0338",
      nrarrw: "\u219D\u0338",
      nRightarrow: "\u21CF",
      nrightarrow: "\u219B",
      nrtri: "\u22EB",
      nrtrie: "\u22ED",
      nsc: "\u2281",
      nsccue: "\u22E1",
      nsce: "\u2AB0\u0338",
      Nscr: "\u{1D4A9}",
      nscr: "\u{1D4C3}",
      nshortmid: "\u2224",
      nshortparallel: "\u2226",
      nsim: "\u2241",
      nsime: "\u2244",
      nsimeq: "\u2244",
      nsmid: "\u2224",
      nspar: "\u2226",
      nsqsube: "\u22E2",
      nsqsupe: "\u22E3",
      nsub: "\u2284",
      nsubE: "\u2AC5\u0338",
      nsube: "\u2288",
      nsubset: "\u2282\u20D2",
      nsubseteq: "\u2288",
      nsubseteqq: "\u2AC5\u0338",
      nsucc: "\u2281",
      nsucceq: "\u2AB0\u0338",
      nsup: "\u2285",
      nsupE: "\u2AC6\u0338",
      nsupe: "\u2289",
      nsupset: "\u2283\u20D2",
      nsupseteq: "\u2289",
      nsupseteqq: "\u2AC6\u0338",
      ntgl: "\u2279",
      Ntilde: "\xD1",
      ntilde: "\xF1",
      ntlg: "\u2278",
      ntriangleleft: "\u22EA",
      ntrianglelefteq: "\u22EC",
      ntriangleright: "\u22EB",
      ntrianglerighteq: "\u22ED",
      Nu: "\u039D",
      nu: "\u03BD",
      num: "#",
      numero: "\u2116",
      numsp: "\u2007",
      nvap: "\u224D\u20D2",
      nVDash: "\u22AF",
      nVdash: "\u22AE",
      nvDash: "\u22AD",
      nvdash: "\u22AC",
      nvge: "\u2265\u20D2",
      nvgt: ">\u20D2",
      nvHarr: "\u2904",
      nvinfin: "\u29DE",
      nvlArr: "\u2902",
      nvle: "\u2264\u20D2",
      nvlt: "<\u20D2",
      nvltrie: "\u22B4\u20D2",
      nvrArr: "\u2903",
      nvrtrie: "\u22B5\u20D2",
      nvsim: "\u223C\u20D2",
      nwarhk: "\u2923",
      nwArr: "\u21D6",
      nwarr: "\u2196",
      nwarrow: "\u2196",
      nwnear: "\u2927",
      Oacute: "\xD3",
      oacute: "\xF3",
      oast: "\u229B",
      ocir: "\u229A",
      Ocirc: "\xD4",
      ocirc: "\xF4",
      Ocy: "\u041E",
      ocy: "\u043E",
      odash: "\u229D",
      Odblac: "\u0150",
      odblac: "\u0151",
      odiv: "\u2A38",
      odot: "\u2299",
      odsold: "\u29BC",
      OElig: "\u0152",
      oelig: "\u0153",
      ofcir: "\u29BF",
      Ofr: "\u{1D512}",
      ofr: "\u{1D52C}",
      ogon: "\u02DB",
      Ograve: "\xD2",
      ograve: "\xF2",
      ogt: "\u29C1",
      ohbar: "\u29B5",
      ohm: "\u03A9",
      oint: "\u222E",
      olarr: "\u21BA",
      olcir: "\u29BE",
      olcross: "\u29BB",
      oline: "\u203E",
      olt: "\u29C0",
      Omacr: "\u014C",
      omacr: "\u014D",
      Omega: "\u03A9",
      omega: "\u03C9",
      Omicron: "\u039F",
      omicron: "\u03BF",
      omid: "\u29B6",
      ominus: "\u2296",
      Oopf: "\u{1D546}",
      oopf: "\u{1D560}",
      opar: "\u29B7",
      OpenCurlyDoubleQuote: "\u201C",
      OpenCurlyQuote: "\u2018",
      operp: "\u29B9",
      oplus: "\u2295",
      Or: "\u2A54",
      or: "\u2228",
      orarr: "\u21BB",
      ord: "\u2A5D",
      order: "\u2134",
      orderof: "\u2134",
      ordf: "\xAA",
      ordm: "\xBA",
      origof: "\u22B6",
      oror: "\u2A56",
      orslope: "\u2A57",
      orv: "\u2A5B",
      oS: "\u24C8",
      Oscr: "\u{1D4AA}",
      oscr: "\u2134",
      Oslash: "\xD8",
      oslash: "\xF8",
      osol: "\u2298",
      Otilde: "\xD5",
      otilde: "\xF5",
      Otimes: "\u2A37",
      otimes: "\u2297",
      otimesas: "\u2A36",
      Ouml: "\xD6",
      ouml: "\xF6",
      ovbar: "\u233D",
      OverBar: "\u203E",
      OverBrace: "\u23DE",
      OverBracket: "\u23B4",
      OverParenthesis: "\u23DC",
      par: "\u2225",
      para: "\xB6",
      parallel: "\u2225",
      parsim: "\u2AF3",
      parsl: "\u2AFD",
      part: "\u2202",
      PartialD: "\u2202",
      Pcy: "\u041F",
      pcy: "\u043F",
      percnt: "%",
      period: ".",
      permil: "\u2030",
      perp: "\u22A5",
      pertenk: "\u2031",
      Pfr: "\u{1D513}",
      pfr: "\u{1D52D}",
      Phi: "\u03A6",
      phi: "\u03C6",
      phiv: "\u03D5",
      phmmat: "\u2133",
      phone: "\u260E",
      Pi: "\u03A0",
      pi: "\u03C0",
      pitchfork: "\u22D4",
      piv: "\u03D6",
      planck: "\u210F",
      planckh: "\u210E",
      plankv: "\u210F",
      plus: "+",
      plusacir: "\u2A23",
      plusb: "\u229E",
      pluscir: "\u2A22",
      plusdo: "\u2214",
      plusdu: "\u2A25",
      pluse: "\u2A72",
      PlusMinus: "\xB1",
      plusmn: "\xB1",
      plussim: "\u2A26",
      plustwo: "\u2A27",
      pm: "\xB1",
      Poincareplane: "\u210C",
      pointint: "\u2A15",
      Popf: "\u2119",
      popf: "\u{1D561}",
      pound: "\xA3",
      Pr: "\u2ABB",
      pr: "\u227A",
      prap: "\u2AB7",
      prcue: "\u227C",
      prE: "\u2AB3",
      pre: "\u2AAF",
      prec: "\u227A",
      precapprox: "\u2AB7",
      preccurlyeq: "\u227C",
      Precedes: "\u227A",
      PrecedesEqual: "\u2AAF",
      PrecedesSlantEqual: "\u227C",
      PrecedesTilde: "\u227E",
      preceq: "\u2AAF",
      precnapprox: "\u2AB9",
      precneqq: "\u2AB5",
      precnsim: "\u22E8",
      precsim: "\u227E",
      Prime: "\u2033",
      prime: "\u2032",
      primes: "\u2119",
      prnap: "\u2AB9",
      prnE: "\u2AB5",
      prnsim: "\u22E8",
      prod: "\u220F",
      Product: "\u220F",
      profalar: "\u232E",
      profline: "\u2312",
      profsurf: "\u2313",
      prop: "\u221D",
      Proportion: "\u2237",
      Proportional: "\u221D",
      propto: "\u221D",
      prsim: "\u227E",
      prurel: "\u22B0",
      Pscr: "\u{1D4AB}",
      pscr: "\u{1D4C5}",
      Psi: "\u03A8",
      psi: "\u03C8",
      puncsp: "\u2008",
      Qfr: "\u{1D514}",
      qfr: "\u{1D52E}",
      qint: "\u2A0C",
      Qopf: "\u211A",
      qopf: "\u{1D562}",
      qprime: "\u2057",
      Qscr: "\u{1D4AC}",
      qscr: "\u{1D4C6}",
      quaternions: "\u210D",
      quatint: "\u2A16",
      quest: "?",
      questeq: "\u225F",
      QUOT: '"',
      quot: '"',
      rAarr: "\u21DB",
      race: "\u223D\u0331",
      Racute: "\u0154",
      racute: "\u0155",
      radic: "\u221A",
      raemptyv: "\u29B3",
      Rang: "\u27EB",
      rang: "\u27E9",
      rangd: "\u2992",
      range: "\u29A5",
      rangle: "\u27E9",
      raquo: "\xBB",
      Rarr: "\u21A0",
      rArr: "\u21D2",
      rarr: "\u2192",
      rarrap: "\u2975",
      rarrb: "\u21E5",
      rarrbfs: "\u2920",
      rarrc: "\u2933",
      rarrfs: "\u291E",
      rarrhk: "\u21AA",
      rarrlp: "\u21AC",
      rarrpl: "\u2945",
      rarrsim: "\u2974",
      Rarrtl: "\u2916",
      rarrtl: "\u21A3",
      rarrw: "\u219D",
      rAtail: "\u291C",
      ratail: "\u291A",
      ratio: "\u2236",
      rationals: "\u211A",
      RBarr: "\u2910",
      rBarr: "\u290F",
      rbarr: "\u290D",
      rbbrk: "\u2773",
      rbrace: "}",
      rbrack: "]",
      rbrke: "\u298C",
      rbrksld: "\u298E",
      rbrkslu: "\u2990",
      Rcaron: "\u0158",
      rcaron: "\u0159",
      Rcedil: "\u0156",
      rcedil: "\u0157",
      rceil: "\u2309",
      rcub: "}",
      Rcy: "\u0420",
      rcy: "\u0440",
      rdca: "\u2937",
      rdldhar: "\u2969",
      rdquo: "\u201D",
      rdquor: "\u201D",
      rdsh: "\u21B3",
      Re: "\u211C",
      real: "\u211C",
      realine: "\u211B",
      realpart: "\u211C",
      reals: "\u211D",
      rect: "\u25AD",
      REG: "\xAE",
      reg: "\xAE",
      ReverseElement: "\u220B",
      ReverseEquilibrium: "\u21CB",
      ReverseUpEquilibrium: "\u296F",
      rfisht: "\u297D",
      rfloor: "\u230B",
      Rfr: "\u211C",
      rfr: "\u{1D52F}",
      rHar: "\u2964",
      rhard: "\u21C1",
      rharu: "\u21C0",
      rharul: "\u296C",
      Rho: "\u03A1",
      rho: "\u03C1",
      rhov: "\u03F1",
      RightAngleBracket: "\u27E9",
      RightArrow: "\u2192",
      Rightarrow: "\u21D2",
      rightarrow: "\u2192",
      RightArrowBar: "\u21E5",
      RightArrowLeftArrow: "\u21C4",
      rightarrowtail: "\u21A3",
      RightCeiling: "\u2309",
      RightDoubleBracket: "\u27E7",
      RightDownTeeVector: "\u295D",
      RightDownVector: "\u21C2",
      RightDownVectorBar: "\u2955",
      RightFloor: "\u230B",
      rightharpoondown: "\u21C1",
      rightharpoonup: "\u21C0",
      rightleftarrows: "\u21C4",
      rightleftharpoons: "\u21CC",
      rightrightarrows: "\u21C9",
      rightsquigarrow: "\u219D",
      RightTee: "\u22A2",
      RightTeeArrow: "\u21A6",
      RightTeeVector: "\u295B",
      rightthreetimes: "\u22CC",
      RightTriangle: "\u22B3",
      RightTriangleBar: "\u29D0",
      RightTriangleEqual: "\u22B5",
      RightUpDownVector: "\u294F",
      RightUpTeeVector: "\u295C",
      RightUpVector: "\u21BE",
      RightUpVectorBar: "\u2954",
      RightVector: "\u21C0",
      RightVectorBar: "\u2953",
      ring: "\u02DA",
      risingdotseq: "\u2253",
      rlarr: "\u21C4",
      rlhar: "\u21CC",
      rlm: "\u200F",
      rmoust: "\u23B1",
      rmoustache: "\u23B1",
      rnmid: "\u2AEE",
      roang: "\u27ED",
      roarr: "\u21FE",
      robrk: "\u27E7",
      ropar: "\u2986",
      Ropf: "\u211D",
      ropf: "\u{1D563}",
      roplus: "\u2A2E",
      rotimes: "\u2A35",
      RoundImplies: "\u2970",
      rpar: ")",
      rpargt: "\u2994",
      rppolint: "\u2A12",
      rrarr: "\u21C9",
      Rrightarrow: "\u21DB",
      rsaquo: "\u203A",
      Rscr: "\u211B",
      rscr: "\u{1D4C7}",
      Rsh: "\u21B1",
      rsh: "\u21B1",
      rsqb: "]",
      rsquo: "\u2019",
      rsquor: "\u2019",
      rthree: "\u22CC",
      rtimes: "\u22CA",
      rtri: "\u25B9",
      rtrie: "\u22B5",
      rtrif: "\u25B8",
      rtriltri: "\u29CE",
      RuleDelayed: "\u29F4",
      ruluhar: "\u2968",
      rx: "\u211E",
      Sacute: "\u015A",
      sacute: "\u015B",
      sbquo: "\u201A",
      Sc: "\u2ABC",
      sc: "\u227B",
      scap: "\u2AB8",
      Scaron: "\u0160",
      scaron: "\u0161",
      sccue: "\u227D",
      scE: "\u2AB4",
      sce: "\u2AB0",
      Scedil: "\u015E",
      scedil: "\u015F",
      Scirc: "\u015C",
      scirc: "\u015D",
      scnap: "\u2ABA",
      scnE: "\u2AB6",
      scnsim: "\u22E9",
      scpolint: "\u2A13",
      scsim: "\u227F",
      Scy: "\u0421",
      scy: "\u0441",
      sdot: "\u22C5",
      sdotb: "\u22A1",
      sdote: "\u2A66",
      searhk: "\u2925",
      seArr: "\u21D8",
      searr: "\u2198",
      searrow: "\u2198",
      sect: "\xA7",
      semi: ";",
      seswar: "\u2929",
      setminus: "\u2216",
      setmn: "\u2216",
      sext: "\u2736",
      Sfr: "\u{1D516}",
      sfr: "\u{1D530}",
      sfrown: "\u2322",
      sharp: "\u266F",
      SHCHcy: "\u0429",
      shchcy: "\u0449",
      SHcy: "\u0428",
      shcy: "\u0448",
      ShortDownArrow: "\u2193",
      ShortLeftArrow: "\u2190",
      shortmid: "\u2223",
      shortparallel: "\u2225",
      ShortRightArrow: "\u2192",
      ShortUpArrow: "\u2191",
      shy: "\xAD",
      Sigma: "\u03A3",
      sigma: "\u03C3",
      sigmaf: "\u03C2",
      sigmav: "\u03C2",
      sim: "\u223C",
      simdot: "\u2A6A",
      sime: "\u2243",
      simeq: "\u2243",
      simg: "\u2A9E",
      simgE: "\u2AA0",
      siml: "\u2A9D",
      simlE: "\u2A9F",
      simne: "\u2246",
      simplus: "\u2A24",
      simrarr: "\u2972",
      slarr: "\u2190",
      SmallCircle: "\u2218",
      smallsetminus: "\u2216",
      smashp: "\u2A33",
      smeparsl: "\u29E4",
      smid: "\u2223",
      smile: "\u2323",
      smt: "\u2AAA",
      smte: "\u2AAC",
      smtes: "\u2AAC\uFE00",
      SOFTcy: "\u042C",
      softcy: "\u044C",
      sol: "/",
      solb: "\u29C4",
      solbar: "\u233F",
      Sopf: "\u{1D54A}",
      sopf: "\u{1D564}",
      spades: "\u2660",
      spadesuit: "\u2660",
      spar: "\u2225",
      sqcap: "\u2293",
      sqcaps: "\u2293\uFE00",
      sqcup: "\u2294",
      sqcups: "\u2294\uFE00",
      Sqrt: "\u221A",
      sqsub: "\u228F",
      sqsube: "\u2291",
      sqsubset: "\u228F",
      sqsubseteq: "\u2291",
      sqsup: "\u2290",
      sqsupe: "\u2292",
      sqsupset: "\u2290",
      sqsupseteq: "\u2292",
      squ: "\u25A1",
      Square: "\u25A1",
      square: "\u25A1",
      SquareIntersection: "\u2293",
      SquareSubset: "\u228F",
      SquareSubsetEqual: "\u2291",
      SquareSuperset: "\u2290",
      SquareSupersetEqual: "\u2292",
      SquareUnion: "\u2294",
      squarf: "\u25AA",
      squf: "\u25AA",
      srarr: "\u2192",
      Sscr: "\u{1D4AE}",
      sscr: "\u{1D4C8}",
      ssetmn: "\u2216",
      ssmile: "\u2323",
      sstarf: "\u22C6",
      Star: "\u22C6",
      star: "\u2606",
      starf: "\u2605",
      straightepsilon: "\u03F5",
      straightphi: "\u03D5",
      strns: "\xAF",
      Sub: "\u22D0",
      sub: "\u2282",
      subdot: "\u2ABD",
      subE: "\u2AC5",
      sube: "\u2286",
      subedot: "\u2AC3",
      submult: "\u2AC1",
      subnE: "\u2ACB",
      subne: "\u228A",
      subplus: "\u2ABF",
      subrarr: "\u2979",
      Subset: "\u22D0",
      subset: "\u2282",
      subseteq: "\u2286",
      subseteqq: "\u2AC5",
      SubsetEqual: "\u2286",
      subsetneq: "\u228A",
      subsetneqq: "\u2ACB",
      subsim: "\u2AC7",
      subsub: "\u2AD5",
      subsup: "\u2AD3",
      succ: "\u227B",
      succapprox: "\u2AB8",
      succcurlyeq: "\u227D",
      Succeeds: "\u227B",
      SucceedsEqual: "\u2AB0",
      SucceedsSlantEqual: "\u227D",
      SucceedsTilde: "\u227F",
      succeq: "\u2AB0",
      succnapprox: "\u2ABA",
      succneqq: "\u2AB6",
      succnsim: "\u22E9",
      succsim: "\u227F",
      SuchThat: "\u220B",
      Sum: "\u2211",
      sum: "\u2211",
      sung: "\u266A",
      Sup: "\u22D1",
      sup: "\u2283",
      sup1: "\xB9",
      sup2: "\xB2",
      sup3: "\xB3",
      supdot: "\u2ABE",
      supdsub: "\u2AD8",
      supE: "\u2AC6",
      supe: "\u2287",
      supedot: "\u2AC4",
      Superset: "\u2283",
      SupersetEqual: "\u2287",
      suphsol: "\u27C9",
      suphsub: "\u2AD7",
      suplarr: "\u297B",
      supmult: "\u2AC2",
      supnE: "\u2ACC",
      supne: "\u228B",
      supplus: "\u2AC0",
      Supset: "\u22D1",
      supset: "\u2283",
      supseteq: "\u2287",
      supseteqq: "\u2AC6",
      supsetneq: "\u228B",
      supsetneqq: "\u2ACC",
      supsim: "\u2AC8",
      supsub: "\u2AD4",
      supsup: "\u2AD6",
      swarhk: "\u2926",
      swArr: "\u21D9",
      swarr: "\u2199",
      swarrow: "\u2199",
      swnwar: "\u292A",
      szlig: "\xDF",
      Tab: "	",
      target: "\u2316",
      Tau: "\u03A4",
      tau: "\u03C4",
      tbrk: "\u23B4",
      Tcaron: "\u0164",
      tcaron: "\u0165",
      Tcedil: "\u0162",
      tcedil: "\u0163",
      Tcy: "\u0422",
      tcy: "\u0442",
      tdot: "\u20DB",
      telrec: "\u2315",
      Tfr: "\u{1D517}",
      tfr: "\u{1D531}",
      there4: "\u2234",
      Therefore: "\u2234",
      therefore: "\u2234",
      Theta: "\u0398",
      theta: "\u03B8",
      thetasym: "\u03D1",
      thetav: "\u03D1",
      thickapprox: "\u2248",
      thicksim: "\u223C",
      ThickSpace: "\u205F\u200A",
      thinsp: "\u2009",
      ThinSpace: "\u2009",
      thkap: "\u2248",
      thksim: "\u223C",
      THORN: "\xDE",
      thorn: "\xFE",
      Tilde: "\u223C",
      tilde: "\u02DC",
      TildeEqual: "\u2243",
      TildeFullEqual: "\u2245",
      TildeTilde: "\u2248",
      times: "\xD7",
      timesb: "\u22A0",
      timesbar: "\u2A31",
      timesd: "\u2A30",
      tint: "\u222D",
      toea: "\u2928",
      top: "\u22A4",
      topbot: "\u2336",
      topcir: "\u2AF1",
      Topf: "\u{1D54B}",
      topf: "\u{1D565}",
      topfork: "\u2ADA",
      tosa: "\u2929",
      tprime: "\u2034",
      TRADE: "\u2122",
      trade: "\u2122",
      triangle: "\u25B5",
      triangledown: "\u25BF",
      triangleleft: "\u25C3",
      trianglelefteq: "\u22B4",
      triangleq: "\u225C",
      triangleright: "\u25B9",
      trianglerighteq: "\u22B5",
      tridot: "\u25EC",
      trie: "\u225C",
      triminus: "\u2A3A",
      TripleDot: "\u20DB",
      triplus: "\u2A39",
      trisb: "\u29CD",
      tritime: "\u2A3B",
      trpezium: "\u23E2",
      Tscr: "\u{1D4AF}",
      tscr: "\u{1D4C9}",
      TScy: "\u0426",
      tscy: "\u0446",
      TSHcy: "\u040B",
      tshcy: "\u045B",
      Tstrok: "\u0166",
      tstrok: "\u0167",
      twixt: "\u226C",
      twoheadleftarrow: "\u219E",
      twoheadrightarrow: "\u21A0",
      Uacute: "\xDA",
      uacute: "\xFA",
      Uarr: "\u219F",
      uArr: "\u21D1",
      uarr: "\u2191",
      Uarrocir: "\u2949",
      Ubrcy: "\u040E",
      ubrcy: "\u045E",
      Ubreve: "\u016C",
      ubreve: "\u016D",
      Ucirc: "\xDB",
      ucirc: "\xFB",
      Ucy: "\u0423",
      ucy: "\u0443",
      udarr: "\u21C5",
      Udblac: "\u0170",
      udblac: "\u0171",
      udhar: "\u296E",
      ufisht: "\u297E",
      Ufr: "\u{1D518}",
      ufr: "\u{1D532}",
      Ugrave: "\xD9",
      ugrave: "\xF9",
      uHar: "\u2963",
      uharl: "\u21BF",
      uharr: "\u21BE",
      uhblk: "\u2580",
      ulcorn: "\u231C",
      ulcorner: "\u231C",
      ulcrop: "\u230F",
      ultri: "\u25F8",
      Umacr: "\u016A",
      umacr: "\u016B",
      uml: "\xA8",
      UnderBar: "_",
      UnderBrace: "\u23DF",
      UnderBracket: "\u23B5",
      UnderParenthesis: "\u23DD",
      Union: "\u22C3",
      UnionPlus: "\u228E",
      Uogon: "\u0172",
      uogon: "\u0173",
      Uopf: "\u{1D54C}",
      uopf: "\u{1D566}",
      UpArrow: "\u2191",
      Uparrow: "\u21D1",
      uparrow: "\u2191",
      UpArrowBar: "\u2912",
      UpArrowDownArrow: "\u21C5",
      UpDownArrow: "\u2195",
      Updownarrow: "\u21D5",
      updownarrow: "\u2195",
      UpEquilibrium: "\u296E",
      upharpoonleft: "\u21BF",
      upharpoonright: "\u21BE",
      uplus: "\u228E",
      UpperLeftArrow: "\u2196",
      UpperRightArrow: "\u2197",
      Upsi: "\u03D2",
      upsi: "\u03C5",
      upsih: "\u03D2",
      Upsilon: "\u03A5",
      upsilon: "\u03C5",
      UpTee: "\u22A5",
      UpTeeArrow: "\u21A5",
      upuparrows: "\u21C8",
      urcorn: "\u231D",
      urcorner: "\u231D",
      urcrop: "\u230E",
      Uring: "\u016E",
      uring: "\u016F",
      urtri: "\u25F9",
      Uscr: "\u{1D4B0}",
      uscr: "\u{1D4CA}",
      utdot: "\u22F0",
      Utilde: "\u0168",
      utilde: "\u0169",
      utri: "\u25B5",
      utrif: "\u25B4",
      uuarr: "\u21C8",
      Uuml: "\xDC",
      uuml: "\xFC",
      uwangle: "\u29A7",
      vangrt: "\u299C",
      varepsilon: "\u03F5",
      varkappa: "\u03F0",
      varnothing: "\u2205",
      varphi: "\u03D5",
      varpi: "\u03D6",
      varpropto: "\u221D",
      vArr: "\u21D5",
      varr: "\u2195",
      varrho: "\u03F1",
      varsigma: "\u03C2",
      varsubsetneq: "\u228A\uFE00",
      varsubsetneqq: "\u2ACB\uFE00",
      varsupsetneq: "\u228B\uFE00",
      varsupsetneqq: "\u2ACC\uFE00",
      vartheta: "\u03D1",
      vartriangleleft: "\u22B2",
      vartriangleright: "\u22B3",
      Vbar: "\u2AEB",
      vBar: "\u2AE8",
      vBarv: "\u2AE9",
      Vcy: "\u0412",
      vcy: "\u0432",
      VDash: "\u22AB",
      Vdash: "\u22A9",
      vDash: "\u22A8",
      vdash: "\u22A2",
      Vdashl: "\u2AE6",
      Vee: "\u22C1",
      vee: "\u2228",
      veebar: "\u22BB",
      veeeq: "\u225A",
      vellip: "\u22EE",
      Verbar: "\u2016",
      verbar: "|",
      Vert: "\u2016",
      vert: "|",
      VerticalBar: "\u2223",
      VerticalLine: "|",
      VerticalSeparator: "\u2758",
      VerticalTilde: "\u2240",
      VeryThinSpace: "\u200A",
      Vfr: "\u{1D519}",
      vfr: "\u{1D533}",
      vltri: "\u22B2",
      vnsub: "\u2282\u20D2",
      vnsup: "\u2283\u20D2",
      Vopf: "\u{1D54D}",
      vopf: "\u{1D567}",
      vprop: "\u221D",
      vrtri: "\u22B3",
      Vscr: "\u{1D4B1}",
      vscr: "\u{1D4CB}",
      vsubnE: "\u2ACB\uFE00",
      vsubne: "\u228A\uFE00",
      vsupnE: "\u2ACC\uFE00",
      vsupne: "\u228B\uFE00",
      Vvdash: "\u22AA",
      vzigzag: "\u299A",
      Wcirc: "\u0174",
      wcirc: "\u0175",
      wedbar: "\u2A5F",
      Wedge: "\u22C0",
      wedge: "\u2227",
      wedgeq: "\u2259",
      weierp: "\u2118",
      Wfr: "\u{1D51A}",
      wfr: "\u{1D534}",
      Wopf: "\u{1D54E}",
      wopf: "\u{1D568}",
      wp: "\u2118",
      wr: "\u2240",
      wreath: "\u2240",
      Wscr: "\u{1D4B2}",
      wscr: "\u{1D4CC}",
      xcap: "\u22C2",
      xcirc: "\u25EF",
      xcup: "\u22C3",
      xdtri: "\u25BD",
      Xfr: "\u{1D51B}",
      xfr: "\u{1D535}",
      xhArr: "\u27FA",
      xharr: "\u27F7",
      Xi: "\u039E",
      xi: "\u03BE",
      xlArr: "\u27F8",
      xlarr: "\u27F5",
      xmap: "\u27FC",
      xnis: "\u22FB",
      xodot: "\u2A00",
      Xopf: "\u{1D54F}",
      xopf: "\u{1D569}",
      xoplus: "\u2A01",
      xotime: "\u2A02",
      xrArr: "\u27F9",
      xrarr: "\u27F6",
      Xscr: "\u{1D4B3}",
      xscr: "\u{1D4CD}",
      xsqcup: "\u2A06",
      xuplus: "\u2A04",
      xutri: "\u25B3",
      xvee: "\u22C1",
      xwedge: "\u22C0",
      Yacute: "\xDD",
      yacute: "\xFD",
      YAcy: "\u042F",
      yacy: "\u044F",
      Ycirc: "\u0176",
      ycirc: "\u0177",
      Ycy: "\u042B",
      ycy: "\u044B",
      yen: "\xA5",
      Yfr: "\u{1D51C}",
      yfr: "\u{1D536}",
      YIcy: "\u0407",
      yicy: "\u0457",
      Yopf: "\u{1D550}",
      yopf: "\u{1D56A}",
      Yscr: "\u{1D4B4}",
      yscr: "\u{1D4CE}",
      YUcy: "\u042E",
      yucy: "\u044E",
      Yuml: "\u0178",
      yuml: "\xFF",
      Zacute: "\u0179",
      zacute: "\u017A",
      Zcaron: "\u017D",
      zcaron: "\u017E",
      Zcy: "\u0417",
      zcy: "\u0437",
      Zdot: "\u017B",
      zdot: "\u017C",
      zeetrf: "\u2128",
      ZeroWidthSpace: "\u200B",
      Zeta: "\u0396",
      zeta: "\u03B6",
      Zfr: "\u2128",
      zfr: "\u{1D537}",
      ZHcy: "\u0416",
      zhcy: "\u0436",
      zigrarr: "\u21DD",
      Zopf: "\u2124",
      zopf: "\u{1D56B}",
      Zscr: "\u{1D4B5}",
      zscr: "\u{1D4CF}",
      zwj: "\u200D",
      zwnj: "\u200C"
    });
    exports.entityMap = exports.HTML_ENTITIES;
  }
});

// node_modules/@xmldom/xmldom/lib/sax.js
var require_sax = __commonJS({
  "node_modules/@xmldom/xmldom/lib/sax.js"(exports) {
    var NAMESPACE = require_conventions().NAMESPACE;
    var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
    var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
    var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
    var S_TAG = 0;
    var S_ATTR = 1;
    var S_ATTR_SPACE = 2;
    var S_EQ = 3;
    var S_ATTR_NOQUOT_VALUE = 4;
    var S_ATTR_END = 5;
    var S_TAG_SPACE = 6;
    var S_TAG_CLOSE = 7;
    function ParseError(message, locator) {
      this.message = message;
      this.locator = locator;
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, ParseError);
    }
    ParseError.prototype = new Error();
    ParseError.prototype.name = ParseError.name;
    function XMLReader() {
    }
    XMLReader.prototype = {
      parse: function(source, defaultNSMap, entityMap) {
        var domBuilder = this.domBuilder;
        domBuilder.startDocument();
        _copy(defaultNSMap, defaultNSMap = {});
        parse2(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);
        domBuilder.endDocument();
      }
    };
    function parse2(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
      function fixedFromCharCode(code2) {
        if (code2 > 65535) {
          code2 -= 65536;
          var surrogate1 = 55296 + (code2 >> 10), surrogate2 = 56320 + (code2 & 1023);
          return String.fromCharCode(surrogate1, surrogate2);
        } else {
          return String.fromCharCode(code2);
        }
      }
      function entityReplacer(a3) {
        var k2 = a3.slice(1, -1);
        if (Object.hasOwnProperty.call(entityMap, k2)) {
          return entityMap[k2];
        } else if (k2.charAt(0) === "#") {
          return fixedFromCharCode(parseInt(k2.substr(1).replace("x", "0x")));
        } else {
          errorHandler.error("entity not found:" + a3);
          return a3;
        }
      }
      function appendText(end3) {
        if (end3 > start2) {
          var xt = source.substring(start2, end3).replace(/&#?\w+;/g, entityReplacer);
          locator && position(start2);
          domBuilder.characters(xt, 0, end3 - start2);
          start2 = end3;
        }
      }
      function position(p2, m2) {
        while (p2 >= lineEnd && (m2 = linePattern.exec(source))) {
          lineStart = m2.index;
          lineEnd = lineStart + m2[0].length;
          locator.lineNumber++;
        }
        locator.columnNumber = p2 - lineStart + 1;
      }
      var lineStart = 0;
      var lineEnd = 0;
      var linePattern = /.*(?:\r\n?|\n)|.*$/g;
      var locator = domBuilder.locator;
      var parseStack = [{ currentNSMap: defaultNSMapCopy }];
      var closeMap = {};
      var start2 = 0;
      while (true) {
        try {
          var tagStart = source.indexOf("<", start2);
          if (tagStart < 0) {
            if (!source.substr(start2).match(/^\s*$/)) {
              var doc = domBuilder.doc;
              var text = doc.createTextNode(source.substr(start2));
              doc.appendChild(text);
              domBuilder.currentElement = text;
            }
            return;
          }
          if (tagStart > start2) {
            appendText(tagStart);
          }
          switch (source.charAt(tagStart + 1)) {
            case "/":
              var end2 = source.indexOf(">", tagStart + 3);
              var tagName = source.substring(tagStart + 2, end2).replace(/[ \t\n\r]+$/g, "");
              var config = parseStack.pop();
              if (end2 < 0) {
                tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
                errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
                end2 = tagStart + 1 + tagName.length;
              } else if (tagName.match(/\s</)) {
                tagName = tagName.replace(/[\s<].*/, "");
                errorHandler.error("end tag name: " + tagName + " maybe not complete");
                end2 = tagStart + 1 + tagName.length;
              }
              var localNSMap = config.localNSMap;
              var endMatch = config.tagName == tagName;
              var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
              if (endIgnoreCaseMach) {
                domBuilder.endElement(config.uri, config.localName, tagName);
                if (localNSMap) {
                  for (var prefix in localNSMap) {
                    if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
                      domBuilder.endPrefixMapping(prefix);
                    }
                  }
                }
                if (!endMatch) {
                  errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
                }
              } else {
                parseStack.push(config);
              }
              end2++;
              break;
            case "?":
              locator && position(tagStart);
              end2 = parseInstruction(source, tagStart, domBuilder);
              break;
            case "!":
              locator && position(tagStart);
              end2 = parseDCC(source, tagStart, domBuilder, errorHandler);
              break;
            default:
              locator && position(tagStart);
              var el = new ElementAttributes();
              var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
              var end2 = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
              var len = el.length;
              if (!el.closed && fixSelfClosed(source, end2, el.tagName, closeMap)) {
                el.closed = true;
                if (!entityMap.nbsp) {
                  errorHandler.warning("unclosed xml attribute");
                }
              }
              if (locator && len) {
                var locator2 = copyLocator(locator, {});
                for (var i2 = 0; i2 < len; i2++) {
                  var a2 = el[i2];
                  position(a2.offset);
                  a2.locator = copyLocator(locator, {});
                }
                domBuilder.locator = locator2;
                if (appendElement(el, domBuilder, currentNSMap)) {
                  parseStack.push(el);
                }
                domBuilder.locator = locator;
              } else {
                if (appendElement(el, domBuilder, currentNSMap)) {
                  parseStack.push(el);
                }
              }
              if (NAMESPACE.isHTML(el.uri) && !el.closed) {
                end2 = parseHtmlSpecialContent(source, end2, el.tagName, entityReplacer, domBuilder);
              } else {
                end2++;
              }
          }
        } catch (e2) {
          if (e2 instanceof ParseError) {
            throw e2;
          }
          errorHandler.error("element parse error: " + e2);
          end2 = -1;
        }
        if (end2 > start2) {
          start2 = end2;
        } else {
          appendText(Math.max(tagStart, start2) + 1);
        }
      }
    }
    function copyLocator(f2, t3) {
      t3.lineNumber = f2.lineNumber;
      t3.columnNumber = f2.columnNumber;
      return t3;
    }
    function parseElementStartPart(source, start2, el, currentNSMap, entityReplacer, errorHandler) {
      function addAttribute(qname, value2, startIndex) {
        if (el.attributeNames.hasOwnProperty(qname)) {
          errorHandler.fatalError("Attribute " + qname + " redefined");
        }
        el.addValue(qname, value2.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer), startIndex);
      }
      var attrName;
      var value;
      var p2 = ++start2;
      var s2 = S_TAG;
      while (true) {
        var c2 = source.charAt(p2);
        switch (c2) {
          case "=":
            if (s2 === S_ATTR) {
              attrName = source.slice(start2, p2);
              s2 = S_EQ;
            } else if (s2 === S_ATTR_SPACE) {
              s2 = S_EQ;
            } else {
              throw new Error("attribute equal must after attrName");
            }
            break;
          case "'":
          case '"':
            if (s2 === S_EQ || s2 === S_ATTR) {
              if (s2 === S_ATTR) {
                errorHandler.warning('attribute value must after "="');
                attrName = source.slice(start2, p2);
              }
              start2 = p2 + 1;
              p2 = source.indexOf(c2, start2);
              if (p2 > 0) {
                value = source.slice(start2, p2);
                addAttribute(attrName, value, start2 - 1);
                s2 = S_ATTR_END;
              } else {
                throw new Error("attribute value no end '" + c2 + "' match");
              }
            } else if (s2 == S_ATTR_NOQUOT_VALUE) {
              value = source.slice(start2, p2);
              addAttribute(attrName, value, start2);
              errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c2 + ")!!");
              start2 = p2 + 1;
              s2 = S_ATTR_END;
            } else {
              throw new Error('attribute value must after "="');
            }
            break;
          case "/":
            switch (s2) {
              case S_TAG:
                el.setTagName(source.slice(start2, p2));
              case S_ATTR_END:
              case S_TAG_SPACE:
              case S_TAG_CLOSE:
                s2 = S_TAG_CLOSE;
                el.closed = true;
              case S_ATTR_NOQUOT_VALUE:
              case S_ATTR:
                break;
              case S_ATTR_SPACE:
                el.closed = true;
                break;
              default:
                throw new Error("attribute invalid close char('/')");
            }
            break;
          case "":
            errorHandler.error("unexpected end of input");
            if (s2 == S_TAG) {
              el.setTagName(source.slice(start2, p2));
            }
            return p2;
          case ">":
            switch (s2) {
              case S_TAG:
                el.setTagName(source.slice(start2, p2));
              case S_ATTR_END:
              case S_TAG_SPACE:
              case S_TAG_CLOSE:
                break;
              case S_ATTR_NOQUOT_VALUE:
              case S_ATTR:
                value = source.slice(start2, p2);
                if (value.slice(-1) === "/") {
                  el.closed = true;
                  value = value.slice(0, -1);
                }
              case S_ATTR_SPACE:
                if (s2 === S_ATTR_SPACE) {
                  value = attrName;
                }
                if (s2 == S_ATTR_NOQUOT_VALUE) {
                  errorHandler.warning('attribute "' + value + '" missed quot(")!');
                  addAttribute(attrName, value, start2);
                } else {
                  if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
                    errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
                  }
                  addAttribute(value, value, start2);
                }
                break;
              case S_EQ:
                throw new Error("attribute value missed!!");
            }
            return p2;
          case "\x80":
            c2 = " ";
          default:
            if (c2 <= " ") {
              switch (s2) {
                case S_TAG:
                  el.setTagName(source.slice(start2, p2));
                  s2 = S_TAG_SPACE;
                  break;
                case S_ATTR:
                  attrName = source.slice(start2, p2);
                  s2 = S_ATTR_SPACE;
                  break;
                case S_ATTR_NOQUOT_VALUE:
                  var value = source.slice(start2, p2);
                  errorHandler.warning('attribute "' + value + '" missed quot(")!!');
                  addAttribute(attrName, value, start2);
                case S_ATTR_END:
                  s2 = S_TAG_SPACE;
                  break;
              }
            } else {
              switch (s2) {
                case S_ATTR_SPACE:
                  var tagName = el.tagName;
                  if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
                    errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
                  }
                  addAttribute(attrName, attrName, start2);
                  start2 = p2;
                  s2 = S_ATTR;
                  break;
                case S_ATTR_END:
                  errorHandler.warning('attribute space is required"' + attrName + '"!!');
                case S_TAG_SPACE:
                  s2 = S_ATTR;
                  start2 = p2;
                  break;
                case S_EQ:
                  s2 = S_ATTR_NOQUOT_VALUE;
                  start2 = p2;
                  break;
                case S_TAG_CLOSE:
                  throw new Error("elements closed character '/' and '>' must be connected to");
              }
            }
        }
        p2++;
      }
    }
    function appendElement(el, domBuilder, currentNSMap) {
      var tagName = el.tagName;
      var localNSMap = null;
      var i2 = el.length;
      while (i2--) {
        var a2 = el[i2];
        var qName = a2.qName;
        var value = a2.value;
        var nsp = qName.indexOf(":");
        if (nsp > 0) {
          var prefix = a2.prefix = qName.slice(0, nsp);
          var localName = qName.slice(nsp + 1);
          var nsPrefix = prefix === "xmlns" && localName;
        } else {
          localName = qName;
          prefix = null;
          nsPrefix = qName === "xmlns" && "";
        }
        a2.localName = localName;
        if (nsPrefix !== false) {
          if (localNSMap == null) {
            localNSMap = {};
            _copy(currentNSMap, currentNSMap = {});
          }
          currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
          a2.uri = NAMESPACE.XMLNS;
          domBuilder.startPrefixMapping(nsPrefix, value);
        }
      }
      var i2 = el.length;
      while (i2--) {
        a2 = el[i2];
        var prefix = a2.prefix;
        if (prefix) {
          if (prefix === "xml") {
            a2.uri = NAMESPACE.XML;
          }
          if (prefix !== "xmlns") {
            a2.uri = currentNSMap[prefix || ""];
          }
        }
      }
      var nsp = tagName.indexOf(":");
      if (nsp > 0) {
        prefix = el.prefix = tagName.slice(0, nsp);
        localName = el.localName = tagName.slice(nsp + 1);
      } else {
        prefix = null;
        localName = el.localName = tagName;
      }
      var ns = el.uri = currentNSMap[prefix || ""];
      domBuilder.startElement(ns, localName, tagName, el);
      if (el.closed) {
        domBuilder.endElement(ns, localName, tagName);
        if (localNSMap) {
          for (prefix in localNSMap) {
            if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
              domBuilder.endPrefixMapping(prefix);
            }
          }
        }
      } else {
        el.currentNSMap = currentNSMap;
        el.localNSMap = localNSMap;
        return true;
      }
    }
    function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
      if (/^(?:script|textarea)$/i.test(tagName)) {
        var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
        var text = source.substring(elStartEnd + 1, elEndStart);
        if (/[&<]/.test(text)) {
          if (/^script$/i.test(tagName)) {
            domBuilder.characters(text, 0, text.length);
            return elEndStart;
          }
          text = text.replace(/&#?\w+;/g, entityReplacer);
          domBuilder.characters(text, 0, text.length);
          return elEndStart;
        }
      }
      return elStartEnd + 1;
    }
    function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
      var pos = closeMap[tagName];
      if (pos == null) {
        pos = source.lastIndexOf("</" + tagName + ">");
        if (pos < elStartEnd) {
          pos = source.lastIndexOf("</" + tagName);
        }
        closeMap[tagName] = pos;
      }
      return pos < elStartEnd;
    }
    function _copy(source, target) {
      for (var n2 in source) {
        if (Object.prototype.hasOwnProperty.call(source, n2)) {
          target[n2] = source[n2];
        }
      }
    }
    function parseDCC(source, start2, domBuilder, errorHandler) {
      var next = source.charAt(start2 + 2);
      switch (next) {
        case "-":
          if (source.charAt(start2 + 3) === "-") {
            var end2 = source.indexOf("-->", start2 + 4);
            if (end2 > start2) {
              domBuilder.comment(source, start2 + 4, end2 - start2 - 4);
              return end2 + 3;
            } else {
              errorHandler.error("Unclosed comment");
              return -1;
            }
          } else {
            return -1;
          }
        default:
          if (source.substr(start2 + 3, 6) == "CDATA[") {
            var end2 = source.indexOf("]]>", start2 + 9);
            domBuilder.startCDATA();
            domBuilder.characters(source, start2 + 9, end2 - start2 - 9);
            domBuilder.endCDATA();
            return end2 + 3;
          }
          var matchs = split(source, start2);
          var len = matchs.length;
          if (len > 1 && /!doctype/i.test(matchs[0][0])) {
            var name = matchs[1][0];
            var pubid = false;
            var sysid = false;
            if (len > 3) {
              if (/^public$/i.test(matchs[2][0])) {
                pubid = matchs[3][0];
                sysid = len > 4 && matchs[4][0];
              } else if (/^system$/i.test(matchs[2][0])) {
                sysid = matchs[3][0];
              }
            }
            var lastMatch = matchs[len - 1];
            domBuilder.startDTD(name, pubid, sysid);
            domBuilder.endDTD();
            return lastMatch.index + lastMatch[0].length;
          }
      }
      return -1;
    }
    function parseInstruction(source, start2, domBuilder) {
      var end2 = source.indexOf("?>", start2);
      if (end2) {
        var match = source.substring(start2, end2).match(/^<\?(\S*)\s*([\s\S]*?)$/);
        if (match) {
          var len = match[0].length;
          domBuilder.processingInstruction(match[1], match[2]);
          return end2 + 2;
        } else {
          return -1;
        }
      }
      return -1;
    }
    function ElementAttributes() {
      this.attributeNames = {};
    }
    ElementAttributes.prototype = {
      setTagName: function(tagName) {
        if (!tagNamePattern.test(tagName)) {
          throw new Error("invalid tagName:" + tagName);
        }
        this.tagName = tagName;
      },
      addValue: function(qName, value, offset5) {
        if (!tagNamePattern.test(qName)) {
          throw new Error("invalid attribute:" + qName);
        }
        this.attributeNames[qName] = this.length;
        this[this.length++] = { qName, value, offset: offset5 };
      },
      length: 0,
      getLocalName: function(i2) {
        return this[i2].localName;
      },
      getLocator: function(i2) {
        return this[i2].locator;
      },
      getQName: function(i2) {
        return this[i2].qName;
      },
      getURI: function(i2) {
        return this[i2].uri;
      },
      getValue: function(i2) {
        return this[i2].value;
      }
    };
    function split(source, start2) {
      var match;
      var buf = [];
      var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
      reg.lastIndex = start2;
      reg.exec(source);
      while (match = reg.exec(source)) {
        buf.push(match);
        if (match[1])
          return buf;
      }
    }
    exports.XMLReader = XMLReader;
    exports.ParseError = ParseError;
  }
});

// node_modules/@xmldom/xmldom/lib/dom-parser.js
var require_dom_parser = __commonJS({
  "node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {
    var conventions = require_conventions();
    var dom = require_dom();
    var entities = require_entities();
    var sax = require_sax();
    var DOMImplementation = dom.DOMImplementation;
    var NAMESPACE = conventions.NAMESPACE;
    var ParseError = sax.ParseError;
    var XMLReader = sax.XMLReader;
    function normalizeLineEndings(input) {
      return input.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028]/g, "\n");
    }
    function DOMParser4(options) {
      this.options = options || { locator: {} };
    }
    DOMParser4.prototype.parseFromString = function(source, mimeType) {
      var options = this.options;
      var sax2 = new XMLReader();
      var domBuilder = options.domBuilder || new DOMHandler();
      var errorHandler = options.errorHandler;
      var locator = options.locator;
      var defaultNSMap = options.xmlns || {};
      var isHTML = /\/x?html?$/.test(mimeType);
      var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
      if (locator) {
        domBuilder.setDocumentLocator(locator);
      }
      sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
      sax2.domBuilder = options.domBuilder || domBuilder;
      if (isHTML) {
        defaultNSMap[""] = NAMESPACE.HTML;
      }
      defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
      var normalize = options.normalizeLineEndings || normalizeLineEndings;
      if (source && typeof source === "string") {
        sax2.parse(normalize(source), defaultNSMap, entityMap);
      } else {
        sax2.errorHandler.error("invalid doc source");
      }
      return domBuilder.doc;
    };
    function buildErrorHandler(errorImpl, domBuilder, locator) {
      if (!errorImpl) {
        if (domBuilder instanceof DOMHandler) {
          return domBuilder;
        }
        errorImpl = domBuilder;
      }
      var errorHandler = {};
      var isCallback = errorImpl instanceof Function;
      locator = locator || {};
      function build(key) {
        var fn3 = errorImpl[key];
        if (!fn3 && isCallback) {
          fn3 = errorImpl.length == 2 ? function(msg2) {
            errorImpl(key, msg2);
          } : errorImpl;
        }
        errorHandler[key] = fn3 && function(msg2) {
          fn3("[xmldom " + key + "]	" + msg2 + _locator(locator));
        } || function() {
        };
      }
      build("warning");
      build("error");
      build("fatalError");
      return errorHandler;
    }
    function DOMHandler() {
      this.cdata = false;
    }
    function position(locator, node) {
      node.lineNumber = locator.lineNumber;
      node.columnNumber = locator.columnNumber;
    }
    DOMHandler.prototype = {
      startDocument: function() {
        this.doc = new DOMImplementation().createDocument(null, null, null);
        if (this.locator) {
          this.doc.documentURI = this.locator.systemId;
        }
      },
      startElement: function(namespaceURI, localName, qName, attrs) {
        var doc = this.doc;
        var el = doc.createElementNS(namespaceURI, qName || localName);
        var len = attrs.length;
        appendElement(this, el);
        this.currentElement = el;
        this.locator && position(this.locator, el);
        for (var i2 = 0; i2 < len; i2++) {
          var namespaceURI = attrs.getURI(i2);
          var value = attrs.getValue(i2);
          var qName = attrs.getQName(i2);
          var attr = doc.createAttributeNS(namespaceURI, qName);
          this.locator && position(attrs.getLocator(i2), attr);
          attr.value = attr.nodeValue = value;
          el.setAttributeNode(attr);
        }
      },
      endElement: function(namespaceURI, localName, qName) {
        var current = this.currentElement;
        var tagName = current.tagName;
        this.currentElement = current.parentNode;
      },
      startPrefixMapping: function(prefix, uri) {
      },
      endPrefixMapping: function(prefix) {
      },
      processingInstruction: function(target, data) {
        var ins = this.doc.createProcessingInstruction(target, data);
        this.locator && position(this.locator, ins);
        appendElement(this, ins);
      },
      ignorableWhitespace: function(ch, start2, length) {
      },
      characters: function(chars, start2, length) {
        chars = _toString.apply(this, arguments);
        if (chars) {
          if (this.cdata) {
            var charNode = this.doc.createCDATASection(chars);
          } else {
            var charNode = this.doc.createTextNode(chars);
          }
          if (this.currentElement) {
            this.currentElement.appendChild(charNode);
          } else if (/^\s*$/.test(chars)) {
            this.doc.appendChild(charNode);
          }
          this.locator && position(this.locator, charNode);
        }
      },
      skippedEntity: function(name) {
      },
      endDocument: function() {
        this.doc.normalize();
      },
      setDocumentLocator: function(locator) {
        if (this.locator = locator) {
          locator.lineNumber = 0;
        }
      },
      comment: function(chars, start2, length) {
        chars = _toString.apply(this, arguments);
        var comm = this.doc.createComment(chars);
        this.locator && position(this.locator, comm);
        appendElement(this, comm);
      },
      startCDATA: function() {
        this.cdata = true;
      },
      endCDATA: function() {
        this.cdata = false;
      },
      startDTD: function(name, publicId, systemId) {
        var impl = this.doc.implementation;
        if (impl && impl.createDocumentType) {
          var dt = impl.createDocumentType(name, publicId, systemId);
          this.locator && position(this.locator, dt);
          appendElement(this, dt);
          this.doc.doctype = dt;
        }
      },
      warning: function(error2) {
        console.warn("[xmldom warning]	" + error2, _locator(this.locator));
      },
      error: function(error2) {
        console.error("[xmldom error]	" + error2, _locator(this.locator));
      },
      fatalError: function(error2) {
        throw new ParseError(error2, this.locator);
      }
    };
    function _locator(l2) {
      if (l2) {
        return "\n@" + (l2.systemId || "") + "#[line:" + l2.lineNumber + ",col:" + l2.columnNumber + "]";
      }
    }
    function _toString(chars, start2, length) {
      if (typeof chars == "string") {
        return chars.substr(start2, length);
      } else {
        if (chars.length >= start2 + length || start2) {
          return new java.lang.String(chars, start2, length) + "";
        }
        return chars;
      }
    }
    "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
      DOMHandler.prototype[key] = function() {
        return null;
      };
    });
    function appendElement(hander, node) {
      if (!hander.currentElement) {
        hander.doc.appendChild(node);
      } else {
        hander.currentElement.appendChild(node);
      }
    }
    exports.__DOMHandler = DOMHandler;
    exports.normalizeLineEndings = normalizeLineEndings;
    exports.DOMParser = DOMParser4;
  }
});

// node_modules/@xmldom/xmldom/lib/index.js
var require_lib = __commonJS({
  "node_modules/@xmldom/xmldom/lib/index.js"(exports) {
    var dom = require_dom();
    exports.DOMImplementation = dom.DOMImplementation;
    exports.XMLSerializer = dom.XMLSerializer;
    exports.DOMParser = require_dom_parser().DOMParser;
  }
});

// node_modules/xml-parser-xo/dist/cjs/index.js
var require_cjs = __commonJS({
  "node_modules/xml-parser-xo/dist/cjs/index.js"(exports, module2) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ParsingError = void 0;
    var ParsingError = class extends Error {
      constructor(message, cause) {
        super(message);
        this.cause = cause;
      }
    };
    exports.ParsingError = ParsingError;
    var parsingState;
    function nextChild() {
      return element(false) || text() || comment() || cdata() || processingInstruction(false);
    }
    function nextRootChild() {
      match(/\s*/);
      return element(true) || comment() || doctype() || processingInstruction(false);
    }
    function parseDocument() {
      const declaration = processingInstruction(true);
      const children = [];
      let documentRootNode;
      let child = nextRootChild();
      while (child) {
        if (child.node.type === "Element") {
          if (documentRootNode) {
            throw new Error("Found multiple root nodes");
          }
          documentRootNode = child.node;
        }
        if (!child.excluded) {
          children.push(child.node);
        }
        child = nextRootChild();
      }
      if (!documentRootNode) {
        throw new ParsingError("Failed to parse XML", "Root Element not found");
      }
      if (parsingState.xml.length !== 0) {
        throw new ParsingError("Failed to parse XML", "Not Well-Formed XML");
      }
      return {
        declaration: declaration ? declaration.node : null,
        root: documentRootNode,
        children
      };
    }
    function processingInstruction(matchDeclaration) {
      const m2 = matchDeclaration ? match(/^<\?(xml(-stylesheet)?)\s*/) : match(/^<\?([\w-:.]+)\s*/);
      if (!m2)
        return;
      const node = {
        name: m2[1],
        type: "ProcessingInstruction",
        attributes: {}
      };
      while (!(eos() || is("?>"))) {
        const attr = attribute();
        if (attr) {
          node.attributes[attr.name] = attr.value;
        } else {
          return;
        }
      }
      match(/\?>/);
      return {
        excluded: matchDeclaration ? false : parsingState.options.filter(node) === false,
        node
      };
    }
    function element(matchRoot) {
      const m2 = match(/^<([^?!</>\s]+)\s*/);
      if (!m2)
        return;
      const node = {
        type: "Element",
        name: m2[1],
        attributes: {},
        children: []
      };
      const excluded = matchRoot ? false : parsingState.options.filter(node) === false;
      while (!(eos() || is(">") || is("?>") || is("/>"))) {
        const attr = attribute();
        if (attr) {
          node.attributes[attr.name] = attr.value;
        } else {
          return;
        }
      }
      if (match(/^\s*\/>/)) {
        node.children = null;
        return {
          excluded,
          node
        };
      }
      match(/\??>/);
      let child = nextChild();
      while (child) {
        if (!child.excluded) {
          node.children.push(child.node);
        }
        child = nextChild();
      }
      if (parsingState.options.strictMode) {
        const closingTag = `</${node.name}>`;
        if (parsingState.xml.startsWith(closingTag)) {
          parsingState.xml = parsingState.xml.slice(closingTag.length);
        } else {
          throw new ParsingError("Failed to parse XML", `Closing tag not matching "${closingTag}"`);
        }
      } else {
        match(/^<\/[\w-:.\u00C0-\u00FF]+\s*>/);
      }
      return {
        excluded,
        node
      };
    }
    function doctype() {
      const m2 = match(/^<!DOCTYPE\s+\S+\s+SYSTEM[^>]*>/) || match(/^<!DOCTYPE\s+\S+\s+PUBLIC[^>]*>/) || match(/^<!DOCTYPE\s+\S+\s*\[[^\]]*]>/) || match(/^<!DOCTYPE\s+\S+\s*>/);
      if (m2) {
        const node = {
          type: "DocumentType",
          content: m2[0]
        };
        return {
          excluded: parsingState.options.filter(node) === false,
          node
        };
      }
    }
    function cdata() {
      if (parsingState.xml.startsWith("<![CDATA[")) {
        const endPositionStart = parsingState.xml.indexOf("]]>");
        if (endPositionStart > -1) {
          const endPositionFinish = endPositionStart + 3;
          const node = {
            type: "CDATA",
            content: parsingState.xml.substring(0, endPositionFinish)
          };
          parsingState.xml = parsingState.xml.slice(endPositionFinish);
          return {
            excluded: parsingState.options.filter(node) === false,
            node
          };
        }
      }
    }
    function comment() {
      const m2 = match(/^<!--[\s\S]*?-->/);
      if (m2) {
        const node = {
          type: "Comment",
          content: m2[0]
        };
        return {
          excluded: parsingState.options.filter(node) === false,
          node
        };
      }
    }
    function text() {
      const m2 = match(/^([^<]+)/);
      if (m2) {
        const node = {
          type: "Text",
          content: m2[1]
        };
        return {
          excluded: parsingState.options.filter(node) === false,
          node
        };
      }
    }
    function attribute() {
      const m2 = match(/([^=]+)\s*=\s*("[^"]*"|'[^']*'|[^>\s]+)\s*/);
      if (m2) {
        return {
          name: m2[1].trim(),
          value: stripQuotes(m2[2].trim())
        };
      }
    }
    function stripQuotes(val) {
      return val.replace(/^['"]|['"]$/g, "");
    }
    function match(re2) {
      const m2 = parsingState.xml.match(re2);
      if (m2) {
        parsingState.xml = parsingState.xml.slice(m2[0].length);
        return m2;
      }
    }
    function eos() {
      return parsingState.xml.length === 0;
    }
    function is(prefix) {
      return parsingState.xml.indexOf(prefix) === 0;
    }
    function parseXml(xml, options = {}) {
      xml = xml.trim();
      const filter2 = options.filter || (() => true);
      parsingState = {
        xml,
        options: Object.assign(Object.assign({}, options), { filter: filter2, strictMode: options.strictMode === true })
      };
      return parseDocument();
    }
    if (typeof module2 !== "undefined" && typeof exports === "object") {
      module2.exports = parseXml;
    }
    exports.default = parseXml;
  }
});

// node_modules/xml-formatter/dist/cjs/index.js
var require_cjs2 = __commonJS({
  "node_modules/xml-formatter/dist/cjs/index.js"(exports, module2) {
    "use strict";
    var __importDefault2 = exports && exports.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports, "__esModule", { value: true });
    var xml_parser_xo_1 = __importDefault2(require_cjs());
    function newLine(state) {
      if (!state.options.indentation && !state.options.lineSeparator)
        return;
      state.content += state.options.lineSeparator;
      let i2;
      for (i2 = 0; i2 < state.level; i2++) {
        state.content += state.options.indentation;
      }
    }
    function indent(state) {
      state.content = state.content.replace(/ +$/, "");
      let i2;
      for (i2 = 0; i2 < state.level; i2++) {
        state.content += state.options.indentation;
      }
    }
    function appendContent(state, content) {
      state.content += content;
    }
    function processNode(node, state, preserveSpace) {
      if (typeof node.content === "string") {
        processContent(node.content, state, preserveSpace);
      } else if (node.type === "Element") {
        processElementNode(node, state, preserveSpace);
      } else if (node.type === "ProcessingInstruction") {
        processProcessingIntruction(node, state);
      } else {
        throw new Error("Unknown node type: " + node.type);
      }
    }
    function processContent(content, state, preserveSpace) {
      if (!preserveSpace) {
        const trimmedContent = content.trim();
        if (state.options.lineSeparator) {
          content = trimmedContent;
        } else if (trimmedContent.length === 0) {
          content = trimmedContent;
        }
      }
      if (content.length > 0) {
        if (!preserveSpace && state.content.length > 0) {
          newLine(state);
        }
        appendContent(state, content);
      }
    }
    function isPathMatchingIgnoredPaths(path, ignoredPaths) {
      const fullPath = "/" + path.join("/");
      const pathLastPart = path[path.length - 1];
      return ignoredPaths.includes(pathLastPart) || ignoredPaths.includes(fullPath);
    }
    function processElementNode(node, state, preserveSpace) {
      state.path.push(node.name);
      if (!preserveSpace && state.content.length > 0) {
        newLine(state);
      }
      appendContent(state, "<" + node.name);
      processAttributes(state, node.attributes);
      if (node.children === null || state.options.forceSelfClosingEmptyTag && node.children.length === 0) {
        const selfClosingNodeClosingTag = state.options.whiteSpaceAtEndOfSelfclosingTag ? " />" : "/>";
        appendContent(state, selfClosingNodeClosingTag);
      } else if (node.children.length === 0) {
        appendContent(state, "></" + node.name + ">");
      } else {
        const nodeChildren = node.children;
        appendContent(state, ">");
        state.level++;
        let nodePreserveSpace = node.attributes["xml:space"] === "preserve" || preserveSpace;
        let ignoredPath = false;
        if (!nodePreserveSpace && state.options.ignoredPaths) {
          ignoredPath = isPathMatchingIgnoredPaths(state.path, state.options.ignoredPaths);
          nodePreserveSpace = ignoredPath;
        }
        if (!nodePreserveSpace && state.options.collapseContent) {
          let containsTextNodes = false;
          let containsTextNodesWithLineBreaks = false;
          let containsNonTextNodes = false;
          nodeChildren.forEach(function(child, index3) {
            if (child.type === "Text") {
              if (child.content.includes("\n")) {
                containsTextNodesWithLineBreaks = true;
                child.content = child.content.trim();
              } else if ((index3 === 0 || index3 === nodeChildren.length - 1) && !preserveSpace) {
                if (child.content.trim().length === 0) {
                  child.content = "";
                }
              }
              if (child.content.trim().length > 0 || nodeChildren.length === 1) {
                containsTextNodes = true;
              }
            } else if (child.type === "CDATA") {
              containsTextNodes = true;
            } else {
              containsNonTextNodes = true;
            }
          });
          if (containsTextNodes && (!containsNonTextNodes || !containsTextNodesWithLineBreaks)) {
            nodePreserveSpace = true;
          }
        }
        nodeChildren.forEach(function(child) {
          processNode(child, state, preserveSpace || nodePreserveSpace);
        });
        state.level--;
        if (!preserveSpace && !nodePreserveSpace) {
          newLine(state);
        }
        if (ignoredPath) {
          indent(state);
        }
        appendContent(state, "</" + node.name + ">");
      }
      state.path.pop();
    }
    function processAttributes(state, attributes) {
      Object.keys(attributes).forEach(function(attr) {
        const escaped = attributes[attr].replace(/"/g, "&quot;");
        appendContent(state, " " + attr + '="' + escaped + '"');
      });
    }
    function processProcessingIntruction(node, state) {
      if (state.content.length > 0) {
        newLine(state);
      }
      appendContent(state, "<?" + node.name);
      processAttributes(state, node.attributes);
      appendContent(state, "?>");
    }
    function formatXml(xml, options = {}) {
      options.indentation = "indentation" in options ? options.indentation : "    ";
      options.collapseContent = options.collapseContent === true;
      options.lineSeparator = "lineSeparator" in options ? options.lineSeparator : "\r\n";
      options.whiteSpaceAtEndOfSelfclosingTag = options.whiteSpaceAtEndOfSelfclosingTag === true;
      options.throwOnFailure = options.throwOnFailure !== false;
      try {
        const parsedXml = (0, xml_parser_xo_1.default)(xml, { filter: options.filter, strictMode: options.strictMode });
        const state = { content: "", level: 0, options, path: [] };
        if (parsedXml.declaration) {
          processProcessingIntruction(parsedXml.declaration, state);
        }
        parsedXml.children.forEach(function(child) {
          processNode(child, state, false);
        });
        if (!options.lineSeparator) {
          return state.content;
        }
        return state.content.replace(/\r\n/g, "\n").replace(/\n/g, options.lineSeparator);
      } catch (err) {
        if (options.throwOnFailure) {
          throw err;
        }
        return xml;
      }
    }
    formatXml.minify = (xml, options = {}) => {
      return formatXml(xml, Object.assign(Object.assign({}, options), { indentation: "", lineSeparator: "" }));
    };
    if (typeof module2 !== "undefined" && typeof exports === "object") {
      module2.exports = formatXml;
    }
    exports.default = formatXml;
  }
});

// src/components/formats/current/utils/buildFileStr.ts
function buildInkCanvasFileStr(pageData) {
  let fileStr = pageData.svgString || "<svg></svg>";
  const parser = new import_xmldom.DOMParser();
  const doc = parser.parseFromString(fileStr, "image/svg+xml");
  const svgElement = doc.documentElement;
  const existingMetadata = svgElement.getElementsByTagName("metadata");
  while (existingMetadata.length > 0) {
    existingMetadata[0].parentNode?.removeChild(existingMetadata[0]);
  }
  const metadataElement = doc.createElement("metadata");
  const inkMetaElement = doc.createElement("ink");
  inkMetaElement.setAttribute("plugin-version", String(pageData.meta.pluginVersion));
  inkMetaElement.setAttribute("file-type", pageData.meta.fileType);
  metadataElement.appendChild(inkMetaElement);
  const inkCanvasElement = doc.createElement("ink-canvas");
  inkCanvasElement.setAttribute("version", INK_CANVAS_FORMAT_VERSION);
  inkCanvasElement.textContent = JSON.stringify(pageData.inkCanvas, null, 2);
  metadataElement.appendChild(inkCanvasElement);
  svgElement.appendChild(metadataElement);
  const serializedSvg = new import_xmldom.XMLSerializer().serializeToString(svgElement);
  return (0, import_xml_formatter.default)(serializedSvg, {
    indentation: "	",
    lineSeparator: "\n"
  });
}
function buildTldrawFileStr(pageData) {
  let fileStr = pageData.svgString || "<svg></svg>";
  const parser = new import_xmldom.DOMParser();
  const doc = parser.parseFromString(fileStr, "image/svg+xml");
  const svgElement = doc.documentElement;
  const tldrawJson = pageData.tldraw;
  const existingMetadata = svgElement.getElementsByTagName("metadata");
  while (existingMetadata.length > 0) {
    existingMetadata[0].parentNode?.removeChild(existingMetadata[0]);
  }
  const metadataElement = doc.createElement("metadata");
  const inkMetaElement = doc.createElement("ink");
  inkMetaElement.setAttribute("plugin-version", String(pageData.meta.pluginVersion));
  inkMetaElement.setAttribute("file-type", pageData.meta.fileType);
  if (pageData.meta.writingLineHeight !== void 0) {
    inkMetaElement.setAttribute("writing-line-height", String(pageData.meta.writingLineHeight));
  }
  metadataElement.appendChild(inkMetaElement);
  const settingsElement = doc.createElement("tldraw");
  settingsElement.setAttribute("version", String(TLDRAW_VERSION));
  settingsElement.textContent = JSON.stringify(tldrawJson, null, 2);
  metadataElement.appendChild(settingsElement);
  svgElement.appendChild(metadataElement);
  const serializedSvg = new import_xmldom.XMLSerializer().serializeToString(svgElement);
  return (0, import_xml_formatter.default)(serializedSvg, {
    indentation: "	",
    lineSeparator: "\n"
  });
}
var import_xmldom, import_xml_formatter, buildFileStr;
var init_buildFileStr = __esm({
  "src/components/formats/current/utils/buildFileStr.ts"() {
    init_constants();
    import_xmldom = __toESM(require_lib());
    import_xml_formatter = __toESM(require_cjs2());
    init_ink_file_storage_engine();
    buildFileStr = (pageData) => {
      if (isInkCanvasFile(pageData))
        return buildInkCanvasFileStr(pageData);
      return buildTldrawFileStr(pageData);
    };
  }
});

// src/types/embed-settings.ts
function formatEmbedAspectRatio(aspectRatio) {
  return aspectRatio.toFixed(3);
}
function buildNewDrawingEmbedSettings() {
  const aspectRatio = DEFAULT_EMBED_SETTINGS.embedDisplay.aspectRatio;
  return {
    ...DEFAULT_EMBED_SETTINGS,
    embedDisplay: { ...DEFAULT_EMBED_SETTINGS.embedDisplay },
    viewBox: {
      x: 0,
      y: 0,
      width: WRITING_PAGE_WIDTH,
      height: WRITING_PAGE_WIDTH / aspectRatio
    }
  };
}
function isWritingAlignedDrawingEmbed(settings) {
  return settings.viewBox.width === WRITING_PAGE_WIDTH;
}
var DEFAULT_EMBED_SETTINGS;
var init_embed_settings = __esm({
  "src/types/embed-settings.ts"() {
    init_constants();
    DEFAULT_EMBED_SETTINGS = {
      embedDisplay: {
        width: 500,
        aspectRatio: 16 / 9
      },
      viewBox: {
        x: 0,
        y: 0,
        width: 500,
        height: 281
      }
    };
  }
});

// src/components/formats/current/utils/build-embeds.ts
function buildDrawingEmbedLine(filepath, options) {
  const s2 = options?.embedSettings ?? (options?.writingAlignedViewBox ? buildNewDrawingEmbedSettings() : DEFAULT_EMBED_SETTINGS);
  const params = new URLSearchParams({
    width: String(s2.embedDisplay.width),
    aspectRatio: formatEmbedAspectRatio(s2.embedDisplay.aspectRatio),
    viewBoxX: String(s2.viewBox.x),
    viewBoxY: String(s2.viewBox.y),
    viewBoxW: String(s2.viewBox.width),
    viewBoxH: String(s2.viewBox.height)
  });
  if (options?.pendingPaste)
    params.append("pendingPaste", "true");
  const url = `${INK_EMBED_BASE_URL}?type=inkDrawing&${params.toString()}`;
  return ` ![InkDrawing](<${filepath}>) [Edit Drawing](${url})`;
}
function buildWritingEmbedLine(filepath, options) {
  const params = new URLSearchParams();
  if (options?.aspectRatio != null && Number.isFinite(options.aspectRatio) && options.aspectRatio > 0) {
    params.append("aspectRatio", formatEmbedAspectRatio(options.aspectRatio));
  }
  if (options?.pendingPaste)
    params.append("pendingPaste", "true");
  const query = params.toString();
  const url = query ? `${INK_EMBED_BASE_URL}?type=inkWriting&${query}` : `${INK_EMBED_BASE_URL}?type=inkWriting`;
  return ` ![InkWriting](<${filepath}>) [Edit Writing](${url})`;
}
var buildDrawingEmbed, buildWritingEmbed;
var init_build_embeds = __esm({
  "src/components/formats/current/utils/build-embeds.ts"() {
    init_constants();
    init_embed_settings();
    buildDrawingEmbed = (filepath, options) => {
      const line = buildDrawingEmbedLine(filepath, options);
      return `
${line}
`;
    };
    buildWritingEmbed = (filepath, options) => {
      const line = buildWritingEmbedLine(filepath, options);
      return `
${line}
`;
    };
  }
});

// src/components/formats/current/utils/parse-settings-from-url.ts
function parseSettingsFromUrl(urlAndEmbedSettings) {
  let infoUrl = urlAndEmbedSettings;
  let embedSettings = structuredClone(DEFAULT_EMBED_SETTINGS);
  let isPendingPaste = false;
  const questionMarkIndex = urlAndEmbedSettings.indexOf("?");
  if (questionMarkIndex !== -1) {
    infoUrl = urlAndEmbedSettings.substring(0, questionMarkIndex);
    const embedSettingsStr = urlAndEmbedSettings.substring(questionMarkIndex + 1);
    const urlParams = embedSettingsStr.split("&").reduce((acc, pair) => {
      const [key, value] = pair.split("=");
      if (key && value) {
        acc[key] = decodeURIComponent(value);
      }
      return acc;
    }, {});
    if (urlParams.width) {
      embedSettings.embedDisplay.width = parseFloat(urlParams.width);
    }
    if (urlParams.aspectRatio) {
      embedSettings.embedDisplay.aspectRatio = parseFloat(urlParams.aspectRatio);
    }
    if (urlParams.viewBoxX) {
      embedSettings.viewBox.x = parseFloat(urlParams.viewBoxX);
    }
    if (urlParams.viewBoxY) {
      embedSettings.viewBox.y = parseFloat(urlParams.viewBoxY);
    }
    if (urlParams.viewBoxW) {
      embedSettings.viewBox.width = parseFloat(urlParams.viewBoxW);
    } else if (urlParams.viewBoxWidth) {
      embedSettings.viewBox.width = parseFloat(urlParams.viewBoxWidth);
    }
    if (urlParams.viewBoxH) {
      embedSettings.viewBox.height = parseFloat(urlParams.viewBoxH);
    } else if (urlParams.viewBoxHeight) {
      embedSettings.viewBox.height = parseFloat(urlParams.viewBoxHeight);
    }
    if (urlParams.pendingPaste === "true") {
      isPendingPaste = true;
    }
  }
  return { infoUrl, embedSettings, isPendingPaste };
}
var init_parse_settings_from_url = __esm({
  "src/components/formats/current/utils/parse-settings-from-url.ts"() {
    init_embed_settings();
  }
});

// node_modules/perfect-freehand/dist/esm/index.mjs
function i(e2, t3, n2, r2 = (e3) => e3) {
  return e2 * r2(0.5 - t3 * (0.5 - n2));
}
function o(e2, t3, n2) {
  let r2 = a(1, t3 / n2);
  return a(1, e2 + (a(1, 1 - r2) - e2) * (r2 * 0.275));
}
function s(e2) {
  return [-e2[0], -e2[1]];
}
function c(e2, t3) {
  return [e2[0] + t3[0], e2[1] + t3[1]];
}
function l(e2, t3, n2) {
  return e2[0] = t3[0] + n2[0], e2[1] = t3[1] + n2[1], e2;
}
function u(e2, t3) {
  return [e2[0] - t3[0], e2[1] - t3[1]];
}
function d(e2, t3, n2) {
  return e2[0] = t3[0] - n2[0], e2[1] = t3[1] - n2[1], e2;
}
function f(e2, t3) {
  return [e2[0] * t3, e2[1] * t3];
}
function p(e2, t3, n2) {
  return e2[0] = t3[0] * n2, e2[1] = t3[1] * n2, e2;
}
function m(e2, t3) {
  return [e2[0] / t3, e2[1] / t3];
}
function h(e2) {
  return [e2[1], -e2[0]];
}
function g(e2, t3) {
  let n2 = t3[0];
  return e2[0] = t3[1], e2[1] = -n2, e2;
}
function ee(e2, t3) {
  return e2[0] * t3[0] + e2[1] * t3[1];
}
function _(e2, t3) {
  return e2[0] === t3[0] && e2[1] === t3[1];
}
function v(e2) {
  return Math.hypot(e2[0], e2[1]);
}
function y(e2, t3) {
  let n2 = e2[0] - t3[0], r2 = e2[1] - t3[1];
  return n2 * n2 + r2 * r2;
}
function b(e2) {
  return m(e2, v(e2));
}
function x(e2, t3) {
  return Math.hypot(e2[1] - t3[1], e2[0] - t3[0]);
}
function S(e2, t3, n2) {
  let r2 = Math.sin(n2), i2 = Math.cos(n2), a2 = e2[0] - t3[0], o2 = e2[1] - t3[1], s2 = a2 * i2 - o2 * r2, c2 = a2 * r2 + o2 * i2;
  return [s2 + t3[0], c2 + t3[1]];
}
function C(e2, t3, n2, r2) {
  let i2 = Math.sin(r2), a2 = Math.cos(r2), o2 = t3[0] - n2[0], s2 = t3[1] - n2[1], c2 = o2 * a2 - s2 * i2, l2 = o2 * i2 + s2 * a2;
  return e2[0] = c2 + n2[0], e2[1] = l2 + n2[1], e2;
}
function w(e2, t3, n2) {
  return c(e2, f(u(t3, e2), n2));
}
function te(e2, t3, n2, r2) {
  let i2 = n2[0] - t3[0], a2 = n2[1] - t3[1];
  return e2[0] = t3[0] + i2 * r2, e2[1] = t3[1] + a2 * r2, e2;
}
function T(e2, t3, n2) {
  return c(e2, f(t3, n2));
}
function k(e2, n2) {
  let r2 = T(e2, b(h(u(e2, c(e2, [1, 1])))), -n2), i2 = [], a2 = 1 / 13;
  for (let n3 = a2; n3 <= 1; n3 += a2)
    i2.push(S(r2, e2, t * 2 * n3));
  return i2;
}
function A(e2, n2, r2) {
  let i2 = [], a2 = 1 / r2;
  for (let r3 = a2; r3 <= 1; r3 += a2)
    i2.push(S(n2, e2, t * r3));
  return i2;
}
function j(e2, t3, n2) {
  let r2 = u(t3, n2), i2 = f(r2, 0.5), a2 = f(r2, 0.51);
  return [u(e2, i2), u(e2, a2), c(e2, a2), c(e2, i2)];
}
function M(e2, n2, r2, i2) {
  let a2 = [], o2 = T(e2, n2, r2), s2 = 1 / i2;
  for (let n3 = s2; n3 < 1; n3 += s2)
    a2.push(S(o2, e2, t * 3 * n3));
  return a2;
}
function ne(e2, t3, n2) {
  return [c(e2, f(t3, n2)), c(e2, f(t3, n2 * 0.99)), u(e2, f(t3, n2 * 0.99)), u(e2, f(t3, n2))];
}
function N(e2, t3, n2) {
  return e2 === false || e2 === void 0 ? 0 : e2 === true ? Math.max(t3, n2) : e2;
}
function re(e2, t3, n2) {
  return e2.slice(0, 10).reduce((e3, r2) => {
    let i2 = r2.pressure;
    return t3 && (i2 = o(e3, r2.distance, n2)), (e3 + i2) / 2;
  }, e2[0].pressure);
}
function P(e2, n2 = {}) {
  let { size: r2 = 16, smoothing: a2 = 0.5, thinning: f2 = 0.5, simulatePressure: m2 = true, easing: _2 = (e3) => e3, start: v2 = {}, end: b2 = {}, last: x2 = false } = n2, { cap: S2 = true, easing: w2 = (e3) => e3 * (2 - e3) } = v2, { cap: T2 = true, easing: P2 = (e3) => --e3 * e3 * e3 + 1 } = b2;
  if (e2.length === 0 || r2 <= 0)
    return [];
  let F2 = e2[e2.length - 1].runningLength, I2 = N(v2.taper, r2, F2), L2 = N(b2.taper, r2, F2), R2 = (r2 * a2) ** 2, z = [], B = [], V = re(e2, m2, r2), H = i(r2, f2, e2[e2.length - 1].pressure, _2), U, W = e2[0].vector, G = e2[0].point, K = G, q = G, J = K, Y = false;
  for (let n3 = 0; n3 < e2.length; n3++) {
    let { pressure: a3 } = e2[n3], { point: s2, vector: h2, distance: v3, runningLength: b3 } = e2[n3], x3 = n3 === e2.length - 1;
    if (!x3 && F2 - b3 < 3)
      continue;
    f2 ? (m2 && (a3 = o(V, v3, r2)), H = i(r2, f2, a3, _2)) : H = r2 / 2, U === void 0 && (U = H);
    let S3 = b3 < I2 ? w2(b3 / I2) : 1, T3 = F2 - b3 < L2 ? P2((F2 - b3) / L2) : 1;
    H = Math.max(0.01, H * Math.min(S3, T3));
    let k2 = (x3 ? e2[n3] : e2[n3 + 1]).vector, A2 = x3 ? 1 : ee(h2, k2), j2 = ee(h2, W) < 0 && !Y, M2 = A2 !== null && A2 < 0;
    if (j2 || M2) {
      g(E, W), p(E, E, H);
      for (let e3 = 0; e3 <= 1; e3 += 0.07692307692307693)
        d(D, s2, E), C(D, D, s2, t * e3), q = [D[0], D[1]], z.push(q), l(O, s2, E), C(O, O, s2, t * -e3), J = [O[0], O[1]], B.push(J);
      G = q, K = J, M2 && (Y = true);
      continue;
    }
    if (Y = false, x3) {
      g(E, h2), p(E, E, H), z.push(u(s2, E)), B.push(c(s2, E));
      continue;
    }
    te(E, k2, h2, A2), g(E, E), p(E, E, H), d(D, s2, E), q = [D[0], D[1]], (n3 <= 1 || y(G, q) > R2) && (z.push(q), G = q), l(O, s2, E), J = [O[0], O[1]], (n3 <= 1 || y(K, J) > R2) && (B.push(J), K = J), V = a3, W = h2;
  }
  let X = [e2[0].point[0], e2[0].point[1]], Z = e2.length > 1 ? [e2[e2.length - 1].point[0], e2[e2.length - 1].point[1]] : c(e2[0].point, [1, 1]), Q = [], $ = [];
  if (e2.length === 1) {
    if (!(I2 || L2) || x2)
      return k(X, U || H);
  } else {
    I2 || L2 && e2.length === 1 || (S2 ? Q.push(...A(X, B[0], 13)) : Q.push(...j(X, z[0], B[0])));
    let t3 = h(s(e2[e2.length - 1].vector));
    L2 || I2 && e2.length === 1 ? $.push(Z) : T2 ? $.push(...M(Z, t3, H, 29)) : $.push(...ne(Z, t3, H));
  }
  return z.concat($, B.reverse(), Q);
}
function I(e2) {
  return e2 != null && e2 >= 0;
}
function L(e2, t3 = {}) {
  let { streamline: i2 = 0.5, size: a2 = 16, last: o2 = false } = t3;
  if (e2.length === 0)
    return [];
  let s2 = 0.15 + (1 - i2) * 0.85, l2 = Array.isArray(e2[0]) ? e2 : e2.map(({ x: e3, y: t4, pressure: r2 = n }) => [e3, t4, r2]);
  if (l2.length === 2) {
    let e3 = l2[1];
    l2 = l2.slice(0, -1);
    for (let t4 = 1; t4 < 5; t4++)
      l2.push(w(l2[0], e3, t4 / 4));
  }
  l2.length === 1 && (l2 = [...l2, [...c(l2[0], r), ...l2[0].slice(2)]]);
  let u2 = [{ point: [l2[0][0], l2[0][1]], pressure: I(l2[0][2]) ? l2[0][2] : 0.25, vector: [...r], distance: 0, runningLength: 0 }], f2 = false, p2 = 0, m2 = u2[0], h2 = l2.length - 1;
  for (let e3 = 1; e3 < l2.length; e3++) {
    let t4 = o2 && e3 === h2 ? [l2[e3][0], l2[e3][1]] : w(m2.point, l2[e3], s2);
    if (_(m2.point, t4))
      continue;
    let r2 = x(t4, m2.point);
    if (p2 += r2, e3 < h2 && !f2) {
      if (p2 < a2)
        continue;
      f2 = true;
    }
    d(F, m2.point, t4), m2 = { point: t4, pressure: I(l2[e3][2]) ? l2[e3][2] : n, vector: b(F), distance: r2, runningLength: p2 }, u2.push(m2);
  }
  return u2[0].vector = u2[1]?.vector || [0, 0], u2;
}
function R(e2, t3 = {}) {
  return P(L(e2, t3), t3);
}
var e, t, n, r, a, E, D, O, F;
var init_esm2 = __esm({
  "node_modules/perfect-freehand/dist/esm/index.mjs"() {
    ({ PI: e } = Math);
    t = e + 1e-4;
    n = 0.5;
    r = [1, 1];
    ({ min: a } = Math);
    E = [0, 0];
    D = [0, 0];
    O = [0, 0];
    F = [0, 0];
  }
});

// src/default-content-colours.ts
var DEFAULT_CONTENT_COLOUR_PRIMARY_STROKE, DEFAULT_CONTENT_COLOUR_WRITING_LINE, INK_SVG_STROKE_PATH_CLASS, INK_SVG_WRITING_LINE_CLASS;
var init_default_content_colours = __esm({
  "src/default-content-colours.ts"() {
    DEFAULT_CONTENT_COLOUR_PRIMARY_STROKE = "#000000";
    DEFAULT_CONTENT_COLOUR_WRITING_LINE = "#888888";
    INK_SVG_STROKE_PATH_CLASS = "ink-type-stroke ink-color-primary";
    INK_SVG_WRITING_LINE_CLASS = "ink-type-writing-line ink-color-writing-line";
  }
});

// src/ink-canvas/utils/svg-path-from-stroke.ts
function getSvgPathFromStroke(points, closed = true) {
  const len = points.length;
  if (len < 4)
    return "";
  let a2 = points[0];
  let b2 = points[1];
  const c2 = points[2];
  let result = `M${a2[0].toFixed(2)},${a2[1].toFixed(2)} Q${b2[0].toFixed(2)},${b2[1].toFixed(2)} ${average(b2[0], c2[0]).toFixed(2)},${average(b2[1], c2[1]).toFixed(2)} T`;
  for (let i2 = 2, max3 = len - 1; i2 < max3; i2++) {
    a2 = points[i2];
    b2 = points[i2 + 1];
    result += `${average(a2[0], b2[0]).toFixed(2)},${average(a2[1], b2[1]).toFixed(2)} `;
  }
  if (closed)
    result += "Z";
  return result;
}
function average(a2, b2) {
  return (a2 + b2) / 2;
}
var init_svg_path_from_stroke = __esm({
  "src/ink-canvas/utils/svg-path-from-stroke.ts"() {
  }
});

// src/ink-canvas/stroke-easing.ts
function penStrokePressureEasing(t3) {
  return t3 * 0.65 + Math.sin(t3 * Math.PI / 2) * 0.35;
}
function identityStrokePressureEasing(t3) {
  return t3;
}
function inkStrokeUsesPenEasing(style) {
  if (style.inputKind === "pen")
    return true;
  if (style.inputKind === "mouse")
    return false;
  return !style.simulatePressure;
}
var init_stroke_easing = __esm({
  "src/ink-canvas/stroke-easing.ts"() {
  }
});

// src/ink-canvas/camera.ts
function clampZoom(zoom) {
  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
}
function zoomAtPoint(camera, anchorScreenX, anchorScreenY, direction) {
  const factor = direction > 0 ? ZOOM_FACTOR : 1 / ZOOM_FACTOR;
  const newZoom = clampZoom(camera.zoom * factor);
  const zoomDelta = 1 / newZoom - 1 / camera.zoom;
  return {
    x: camera.x + anchorScreenX * zoomDelta,
    y: camera.y + anchorScreenY * zoomDelta,
    zoom: newZoom
  };
}
function panByScreenDelta(camera, deltaScreenX, deltaScreenY) {
  return {
    x: camera.x + deltaScreenX / camera.zoom,
    y: camera.y + deltaScreenY / camera.zoom,
    zoom: camera.zoom
  };
}
function screenToPage(camera, containerRect, screenX, screenY) {
  return {
    x: (screenX - containerRect.left) / camera.zoom - camera.x,
    y: (screenY - containerRect.top) / camera.zoom - camera.y
  };
}
function fitBoundsToViewport(viewportWidth, viewportHeight, bounds, padding = 16) {
  if (bounds.width <= 0 || bounds.height <= 0) {
    return { x: 0, y: 0, zoom: 0.3 };
  }
  const zoom = clampZoom(Math.min((viewportWidth - padding * 2) / bounds.width, (viewportHeight - padding * 2) / bounds.height, 1));
  const boundsCenterX = bounds.x + bounds.width / 2;
  const boundsCenterY = bounds.y + bounds.height / 2;
  return {
    x: viewportWidth / (2 * zoom) - boundsCenterX,
    y: viewportHeight / (2 * zoom) - boundsCenterY,
    zoom
  };
}
function embedViewBoxFromCamera(camera, viewportWidth, viewportHeight) {
  const zoom = camera.zoom > 0 ? camera.zoom : MIN_ZOOM;
  return {
    x: -camera.x,
    y: -camera.y,
    width: viewportWidth / zoom,
    height: viewportHeight / zoom
  };
}
function adjustCameraToPreservePagePointAtScreenTargets(camera, oldContainerRect, anchorScreenX, anchorScreenY, newContainerRect, targetScreenX, targetScreenY) {
  const pageX = (anchorScreenX - oldContainerRect.left) / camera.zoom - camera.x;
  const pageY = (anchorScreenY - oldContainerRect.top) / camera.zoom - camera.y;
  return {
    x: (targetScreenX - newContainerRect.left) / camera.zoom - pageX,
    y: (targetScreenY - newContainerRect.top) / camera.zoom - pageY,
    zoom: camera.zoom
  };
}
function adjustCameraToPreserveViewportCenter(camera, oldContainerRect, newContainerRect) {
  const anchorScreenX = oldContainerRect.left + oldContainerRect.width / 2;
  const anchorScreenY = oldContainerRect.top + oldContainerRect.height / 2;
  const targetScreenX = newContainerRect.left + newContainerRect.width / 2;
  const targetScreenY = newContainerRect.top + newContainerRect.height / 2;
  return adjustCameraToPreservePagePointAtScreenTargets(camera, oldContainerRect, anchorScreenX, anchorScreenY, newContainerRect, targetScreenX, targetScreenY);
}
function getRightDragZoomDelta(startX, startY, clientX, clientY) {
  const deltaY = startY - clientY;
  const deltaX = clientX - startX;
  return deltaX + deltaY;
}
var MIN_ZOOM, MAX_ZOOM, ZOOM_FACTOR;
var init_camera = __esm({
  "src/ink-canvas/camera.ts"() {
    MIN_ZOOM = 0.1;
    MAX_ZOOM = 5;
    ZOOM_FACTOR = 1.08;
  }
});

// src/ink-canvas/constants/erase-tool.ts
var ERASER_HIT_RADIUS_REFERENCE, ERASER_RING_SAMPLE_COUNT, ERASER_SWEEP_SAMPLE_SPACING_REFERENCE, INK_STROKE_PENDING_ERASE_CLASS, INK_STROKE_PENDING_ERASE_ANIMATION_MS;
var init_erase_tool = __esm({
  "src/ink-canvas/constants/erase-tool.ts"() {
    ERASER_HIT_RADIUS_REFERENCE = 15;
    ERASER_RING_SAMPLE_COUNT = 8;
    ERASER_SWEEP_SAMPLE_SPACING_REFERENCE = 8;
    INK_STROKE_PENDING_ERASE_CLASS = "ink-stroke--pending-erase";
    INK_STROKE_PENDING_ERASE_ANIMATION_MS = 1e3;
  }
});

// src/ink-canvas/stroke-zoom-scale.ts
function clampCaptureZoom(zoom) {
  return clampZoom(zoom);
}
function captureZoomLerpT(captureZoom, zoomRef = INK_STROKE_ZOOM_REFERENCE, zoomMin = INK_STROKE_ZOOM_MIN) {
  const z = clampCaptureZoom(captureZoom);
  if (z >= zoomRef)
    return 0;
  const t3 = (1 / z - 1) / (1 / zoomMin - 1);
  return Math.min(1, Math.max(0, t3));
}
function metricForCaptureZoom(referenceValue, zoomOutTarget, captureZoom, zoomRef = INK_STROKE_ZOOM_REFERENCE) {
  const z = clampCaptureZoom(captureZoom);
  if (z < zoomRef) {
    const t3 = captureZoomLerpT(z, zoomRef, INK_STROKE_ZOOM_MIN);
    return referenceValue + t3 * (zoomOutTarget - referenceValue);
  }
  return referenceValue * (zoomRef / z);
}
function numericForCaptureZoom(referenceValue, captureZoom, treatAs, zoomRef = INK_STROKE_ZOOM_REFERENCE) {
  const target = STREAMLINE_SMOOTHING_ZOOM_OUT_TARGET[treatAs];
  const value = metricForCaptureZoom(referenceValue, target, captureZoom, zoomRef);
  return Math.min(1, Math.max(0, value));
}
function screenConstantMetricForCameraZoom(referenceValue, cameraZoom, zoomRef = INK_STROKE_ZOOM_REFERENCE) {
  const z = clampCaptureZoom(cameraZoom);
  const zoomOutTarget = referenceValue * (zoomRef / INK_STROKE_ZOOM_MIN);
  return metricForCaptureZoom(referenceValue, zoomOutTarget, z, zoomRef) * z;
}
function eraserHitRadiusScreenPx(cameraZoom) {
  return screenConstantMetricForCameraZoom(ERASER_HIT_RADIUS_REFERENCE, cameraZoom);
}
function eraserSweepSpacingScreenPx(cameraZoom) {
  return screenConstantMetricForCameraZoom(ERASER_SWEEP_SAMPLE_SPACING_REFERENCE, cameraZoom);
}
var INK_STROKE_ZOOM_REFERENCE, INK_STROKE_ZOOM_MIN, STREAMLINE_SMOOTHING_ZOOM_OUT_TARGET;
var init_stroke_zoom_scale = __esm({
  "src/ink-canvas/stroke-zoom-scale.ts"() {
    init_camera();
    init_erase_tool();
    INK_STROKE_ZOOM_REFERENCE = 1;
    INK_STROKE_ZOOM_MIN = 0.1;
    STREAMLINE_SMOOTHING_ZOOM_OUT_TARGET = {
      pen: 0.2,
      mouse: 0.65
    };
  }
});

// src/ink-canvas/types.ts
function toStrokeOptions(style) {
  const easing = inkStrokeUsesPenEasing(style) ? penStrokePressureEasing : identityStrokePressureEasing;
  return {
    size: style.size,
    thinning: style.thinning,
    smoothing: style.smoothing,
    streamline: style.streamline,
    simulatePressure: style.simulatePressure,
    easing,
    last: true,
    start: { cap: true, taper: 0 },
    end: { cap: true, taper: 0 },
    captureZoom: style.captureZoom ?? INK_STROKE_ZOOM_REFERENCE
  };
}
var DEFAULT_STROKE_STYLE;
var init_types = __esm({
  "src/ink-canvas/types.ts"() {
    init_stroke_easing();
    init_stroke_zoom_scale();
    DEFAULT_STROKE_STYLE = {
      size: 8,
      thinning: 0.5,
      smoothing: 0.5,
      streamline: 0.5,
      simulatePressure: true,
      color: "currentColor"
    };
  }
});

// src/ink-canvas/svg-export.ts
function renderStrokesToSvg(strokes, snapshotJson, padding = 16) {
  if (strokes.length === 0) {
    return buildSvgString("", "0 0 1 1", snapshotJson);
  }
  const bounds = computeStrokesBounds(strokes);
  const viewBox = [
    bounds.minX - padding,
    bounds.minY - padding,
    bounds.width + padding * 2,
    bounds.height + padding * 2
  ].join(" ");
  let pathsMarkup = "";
  for (const stroke of strokes) {
    const outlinePoints = R(stroke.points, toStrokeOptions(stroke.style));
    const d2 = getSvgPathFromStroke(outlinePoints);
    pathsMarkup += buildStrokePathMarkup(d2, stroke.offset.x, stroke.offset.y);
  }
  return buildSvgString(pathsMarkup, viewBox, snapshotJson);
}
function renderWritingStrokesToSvg(strokes, snapshot, pageWidth, padding = 0) {
  const lineHeight = snapshot.writingLineHeight ?? WRITING_LINE_HEIGHT;
  let height = WRITING_MIN_PAGE_HEIGHT;
  if (strokes.length > 0) {
    const bounds = computeStrokesBounds(strokes);
    const numFilledLines = Math.ceil((bounds.maxY + padding) / lineHeight);
    height = Math.max((numFilledLines + 0.5) * lineHeight, WRITING_MIN_PAGE_HEIGHT);
  }
  const margin = pageWidth * 0.05;
  let guideMarkup = "";
  const lineCount = Math.floor(height / lineHeight);
  for (let i2 = 1; i2 <= lineCount; i2++) {
    const y2 = i2 * lineHeight;
    guideMarkup += `<line x1="${margin}" y1="${y2}" x2="${pageWidth - margin}" y2="${y2}" stroke="${DEFAULT_CONTENT_COLOUR_WRITING_LINE}" stroke-opacity="0.5" class="${INK_SVG_WRITING_LINE_CLASS}" />
`;
  }
  let pathsMarkup = "";
  for (const stroke of strokes) {
    const outlinePoints = R(stroke.points, toStrokeOptions(stroke.style));
    const d2 = getSvgPathFromStroke(outlinePoints);
    pathsMarkup += buildStrokePathMarkup(d2, stroke.offset.x, stroke.offset.y);
  }
  const viewBox = `0 0 ${pageWidth} ${height}`;
  return buildSvgString(guideMarkup + pathsMarkup, viewBox, snapshot);
}
function buildStrokePathMarkup(d2, offsetX, offsetY) {
  const pathAttrs = `d="${d2}" fill="${DEFAULT_CONTENT_COLOUR_PRIMARY_STROKE}" class="${INK_SVG_STROKE_PATH_CLASS}"`;
  const hasOffset = offsetX !== 0 || offsetY !== 0;
  if (hasOffset) {
    return `<g transform="translate(${offsetX},${offsetY})"><path ${pathAttrs} /></g>
`;
  }
  return `<path ${pathAttrs} />
`;
}
function buildSvgString(pathsMarkup, viewBox, snapshotJson) {
  const metadataJson = JSON.stringify(snapshotJson);
  return [
    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}">`,
    `<metadata>`,
    `<ink-canvas version="${INK_CANVAS_FORMAT_VERSION}">${escapeXml(metadataJson)}</ink-canvas>`,
    `</metadata>`,
    pathsMarkup,
    `</svg>`
  ].join("\n");
}
function escapeXml(str) {
  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}
function computeStrokesBounds(strokes) {
  let minX = Infinity;
  let minY = Infinity;
  let maxX = -Infinity;
  let maxY = -Infinity;
  for (const stroke of strokes) {
    const outlinePoints = R(stroke.points, toStrokeOptions(stroke.style));
    for (const [px, py] of outlinePoints) {
      const x2 = px + stroke.offset.x;
      const y2 = py + stroke.offset.y;
      if (x2 < minX)
        minX = x2;
      if (y2 < minY)
        minY = y2;
      if (x2 > maxX)
        maxX = x2;
      if (y2 > maxY)
        maxY = y2;
    }
  }
  return {
    minX,
    minY,
    maxX,
    maxY,
    width: maxX - minX,
    height: maxY - minY
  };
}
var init_svg_export = __esm({
  "src/ink-canvas/svg-export.ts"() {
    init_esm2();
    init_default_content_colours();
    init_constants();
    init_svg_path_from_stroke();
    init_types();
  }
});

// src/logic/utils/extractInkJsonFromSvg.ts
function sniffInkSvgFileType(svgString) {
  const trimmedStart = svgString.trimStart();
  if (!trimmedStart.startsWith("<"))
    return null;
  const hasInkMarker = /<ink[\s>]/i.test(svgString) || /<ink-canvas[\s>]/i.test(svgString) || /<tldraw[\s>]/i.test(svgString);
  if (!hasInkMarker)
    return null;
  const isWriting = /file-type\s*=\s*["']inkWriting["']/i.test(svgString);
  const isDrawing = /file-type\s*=\s*["']inkDrawing["']/i.test(svgString);
  if (isWriting && !isDrawing)
    return "inkWriting";
  if (isDrawing && !isWriting)
    return "inkDrawing";
  if (!isWriting && !isDrawing && /<ink-canvas[\s>]/i.test(svgString)) {
    return "inkDrawing";
  }
  return null;
}
function extractInkJsonFromSvg(svgString) {
  try {
    const parser = new import_xmldom2.DOMParser();
    const doc = parser.parseFromString(svgString, "image/svg+xml");
    const parseError = doc.getElementsByTagName("parsererror");
    if (parseError.length > 0) {
      console.warn("Failed to parse SVG as XML");
      return null;
    }
    const metadataElements = doc.getElementsByTagName("metadata");
    if (metadataElements.length === 0) {
      console.warn("No metadata element found in SVG");
      return null;
    }
    const metadataElement = metadataElements[0];
    const inkCanvasElements = metadataElement.getElementsByTagName("ink-canvas");
    if (inkCanvasElements.length > 0) {
      return extractInkCanvasFormat(metadataElement, inkCanvasElements[0], svgString);
    }
    return extractTldrawFormat(metadataElement, svgString);
  } catch (error2) {
    console.error("Error extracting ink metadata JSON:", error2);
    return null;
  }
}
function extractInkCanvasFormat(metadataElement, inkCanvasElement, svgString) {
  const jsonText = inkCanvasElement.textContent?.trim();
  if (!jsonText) {
    console.warn("No JSON content in <ink-canvas> element");
    return null;
  }
  const inkCanvasSnapshot = JSON.parse(jsonText);
  const inkElements = metadataElement.getElementsByTagName("ink");
  let fileTypeText;
  if (inkElements.length > 0) {
    fileTypeText = inkElements[0].getAttribute("file-type") || void 0;
  }
  if (!fileTypeText)
    fileTypeText = "inkDrawing";
  const pluginVersionAttr = inkElements.length > 0 ? inkElements[0].getAttribute("plugin-version") || "" : "";
  return {
    meta: {
      pluginVersion: pluginVersionAttr,
      tldrawVersion: "",
      fileType: fileTypeText
    },
    tldraw: {},
    inkCanvas: inkCanvasSnapshot,
    svgString
  };
}
function extractTldrawFormat(metadataElement, svgString) {
  const inkElements = metadataElement.getElementsByTagName("ink");
  let fileTypeText;
  if (inkElements.length > 0) {
    fileTypeText = inkElements[0].getAttribute("file-type") || void 0;
  }
  if (!fileTypeText) {
    console.warn("No filetype found in metadata");
    return null;
  }
  if (fileTypeText !== "inkDrawing" && fileTypeText !== "inkWriting") {
    console.warn("Unsupported or missing filetype in metadata");
    return null;
  }
  const tldrawElements = metadataElement.getElementsByTagName("tldraw");
  if (tldrawElements.length === 0) {
    console.warn("No tldraw element found in metadata");
    return null;
  }
  const settingsElement = tldrawElements[0];
  const jsonText = settingsElement.textContent?.trim();
  if (!jsonText) {
    console.warn("No JSON content found in metadata settings element");
    return null;
  }
  const tldrawSnapshot = JSON.parse(jsonText);
  const pluginVersionAttr = inkElements.length > 0 ? inkElements[0].getAttribute("plugin-version") || void 0 : void 0;
  const tldrawVersionAttr = settingsElement.getAttribute("version") || void 0;
  const writingLineHeightAttr = inkElements.length > 0 ? inkElements[0].getAttribute("writing-line-height") : null;
  const writingLineHeightParsed = writingLineHeightAttr ? parseInt(writingLineHeightAttr, 10) : void 0;
  const writingLineHeight = writingLineHeightParsed !== void 0 && !isNaN(writingLineHeightParsed) ? writingLineHeightParsed : void 0;
  return {
    meta: {
      pluginVersion: pluginVersionAttr || "",
      tldrawVersion: tldrawVersionAttr || "",
      fileType: fileTypeText,
      writingLineHeight
    },
    tldraw: tldrawSnapshot,
    svgString
  };
}
var import_xmldom2;
var init_extractInkJsonFromSvg = __esm({
  "src/logic/utils/extractInkJsonFromSvg.ts"() {
    import_xmldom2 = __toESM(require_lib());
  }
});

// src/ink-canvas/migrate-from-tldraw.ts
function getTldrawStoreForMigration(tldrawSnapshot) {
  const topLevel = tldrawSnapshot.store;
  if (topLevel)
    return topLevel;
  const nested = tldrawSnapshot.document?.store;
  if (nested)
    return nested;
  return void 0;
}
function readGridEnabledFromTldrawSession(tldrawSnapshot) {
  return tldrawSnapshot.session?.isGridMode !== false;
}
function migrateFromTldraw(tldrawSnapshot) {
  const snapshot = {
    version: 1,
    strokes: [],
    gridEnabled: readGridEnabledFromTldrawSession(tldrawSnapshot)
  };
  const store = getTldrawStoreForMigration(tldrawSnapshot);
  if (!store)
    return snapshot;
  const captureZoom = readCameraZoomFromStore(store);
  for (const key of Object.keys(store)) {
    const record = store[key];
    const isDrawShape = record.typeName === "shape" && record.type === "draw";
    if (!isDrawShape)
      continue;
    const drawRecord = record;
    const stroke = convertDrawShape(drawRecord, captureZoom);
    if (stroke)
      snapshot.strokes.push(stroke);
  }
  return snapshot;
}
function migrateWritingFromTldraw(tldrawSnapshot, fallbackLineHeight = WRITING_LINE_HEIGHT) {
  const snapshot = {
    version: 1,
    strokes: [],
    gridEnabled: false,
    writingLineHeight: fallbackLineHeight
  };
  const store = getTldrawStoreForMigration(tldrawSnapshot);
  if (!store)
    return snapshot;
  let writingLineHeight = fallbackLineHeight;
  const documentRecord = store["document:document"];
  if (documentRecord) {
    const meta = documentRecord.meta;
    if (meta && typeof meta.writingLineHeight === "number" && meta.writingLineHeight > 0) {
      writingLineHeight = meta.writingLineHeight;
    }
  }
  const captureZoom = readCameraZoomFromStore(store);
  for (const key of Object.keys(store)) {
    const record = store[key];
    const isDrawShape = record.typeName === "shape" && record.type === "draw";
    if (!isDrawShape)
      continue;
    const drawRecord = record;
    const stroke = convertDrawShape(drawRecord, captureZoom);
    if (stroke)
      snapshot.strokes.push(stroke);
  }
  snapshot.writingLineHeight = writingLineHeight;
  return snapshot;
}
function readCameraZoomFromStore(store) {
  for (const key of Object.keys(store)) {
    const record = store[key];
    if (record.typeName !== "camera")
      continue;
    const cam = record;
    return cam.z ?? 1;
  }
  return 1;
}
function convertDrawShape(shape, captureZoom) {
  const allPoints = [];
  for (const segment of shape.props.segments) {
    for (const pt of segment.points) {
      allPoints.push([pt.x, pt.y, pt.z ?? 0.5]);
    }
  }
  if (allPoints.length === 0)
    return null;
  const style = mapTldrawStyle(shape.props, captureZoom);
  return {
    id: shape.id,
    points: allPoints,
    style,
    offset: { x: shape.x, y: shape.y }
  };
}
function mapTldrawStyle(props, _captureZoom) {
  const basePx = TLDRAW_SIZE_TO_PX[props.size] ?? TLDRAW_SIZE_TO_PX["m"];
  const effectiveSize = 1 + basePx * 1.5;
  return buildTldrawMigrationStrokeStyle(props, effectiveSize);
}
function buildTldrawMigrationStrokeStyle(props, effectiveSize) {
  return {
    ...DEFAULT_STROKE_STYLE,
    size: effectiveSize,
    color: "currentColor",
    simulatePressure: !props.isPen,
    inputKind: props.isPen ? "pen" : "mouse",
    captureZoom: INK_STROKE_ZOOM_REFERENCE
  };
}
var TLDRAW_SIZE_TO_PX;
var init_migrate_from_tldraw = __esm({
  "src/ink-canvas/migrate-from-tldraw.ts"() {
    init_constants();
    init_types();
    init_stroke_zoom_scale();
    TLDRAW_SIZE_TO_PX = {
      s: 2,
      m: 3.5,
      l: 5,
      xl: 10
    };
  }
});

// src/logic/utils/ink-file-has-strokes.ts
function getInkStrokesFromSvg(svgString) {
  const inkFileData = extractInkJsonFromSvg(svgString);
  if (!inkFileData)
    return [];
  if (isInkCanvasFile(inkFileData) && inkFileData.inkCanvas) {
    return inkFileData.inkCanvas.strokes ?? [];
  }
  const migrated = migrateFromTldraw(inkFileData.tldraw);
  return migrated.strokes ?? [];
}
function inkFileHasStrokes(svgString) {
  return getInkStrokesFromSvg(svgString).length > 0;
}
function showLockedChrome(settingEnabled, hasStrokes) {
  return settingEnabled || hasStrokes === false;
}
var init_ink_file_has_strokes = __esm({
  "src/logic/utils/ink-file-has-strokes.ts"() {
    init_ink_file_storage_engine();
    init_extractInkJsonFromSvg();
    init_migrate_from_tldraw();
  }
});

// src/logic/utils/build-drawing-embed-settings-from-file.ts
function cloneDefaultEmbedSettings() {
  return {
    ...DEFAULT_EMBED_SETTINGS,
    embedDisplay: { ...DEFAULT_EMBED_SETTINGS.embedDisplay },
    viewBox: { ...DEFAULT_EMBED_SETTINGS.viewBox }
  };
}
function buildEmbedSettingsWithFittedViewBox(strokes) {
  const embedDisplay = { ...DEFAULT_EMBED_SETTINGS.embedDisplay };
  const viewportWidth = embedDisplay.width;
  const viewportHeight = viewportWidth / embedDisplay.aspectRatio;
  const bounds = computeStrokesBounds(strokes);
  const camera = fitBoundsToViewport(viewportWidth, viewportHeight, {
    x: bounds.minX,
    y: bounds.minY,
    width: bounds.width,
    height: bounds.height
  }, EMBED_FIT_PADDING_PX);
  return {
    ...DEFAULT_EMBED_SETTINGS,
    embedDisplay,
    viewBox: embedViewBoxFromCamera(camera, viewportWidth, viewportHeight)
  };
}
function buildDrawingEmbedSettingsFromStrokes(strokes) {
  if (strokes.length === 0)
    return null;
  const bounds = computeStrokesBounds(strokes);
  if (!Number.isFinite(bounds.width) || !Number.isFinite(bounds.height) || bounds.width <= 0 || bounds.height <= 0) {
    return null;
  }
  return buildEmbedSettingsWithFittedViewBox(strokes);
}
async function buildDrawingEmbedSettingsFromFile(plugin, file) {
  try {
    const svgString = await plugin.app.vault.read(file);
    const strokes = getInkStrokesFromSvg(svgString);
    return buildDrawingEmbedSettingsFromStrokes(strokes) ?? cloneDefaultEmbedSettings();
  } catch {
    return cloneDefaultEmbedSettings();
  }
}
var EMBED_FIT_PADDING_PX;
var init_build_drawing_embed_settings_from_file = __esm({
  "src/logic/utils/build-drawing-embed-settings-from-file.ts"() {
    init_svg_export();
    init_camera();
    init_ink_file_has_strokes();
    init_embed_settings();
    EMBED_FIT_PADDING_PX = 16;
  }
});

// src/logic/utils/writing-embed-aspect-ratio.ts
function parseSvgViewBoxAspectRatio(svgString) {
  const viewBoxMatch = svgString.match(/<svg\b[^>]*\bviewBox\s*=\s*["']([^"']+)["']/i);
  if (!viewBoxMatch)
    return null;
  const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
  if (parts.length < 4)
    return null;
  const viewBoxWidth = parts[2];
  const viewBoxHeight = parts[3];
  if (!Number.isFinite(viewBoxWidth) || !Number.isFinite(viewBoxHeight))
    return null;
  if (viewBoxWidth <= 0 || viewBoxHeight <= 0)
    return null;
  return viewBoxWidth / viewBoxHeight;
}
async function readWritingFileAspectRatio(plugin, file) {
  try {
    const svgString = await plugin.app.vault.read(file);
    return parseSvgViewBoxAspectRatio(svgString);
  } catch {
    return null;
  }
}
function patchWritingEmbedAspectRatioInEmbedSnippet(embedSnippet, aspectRatio) {
  const aspectRatioStr = formatEmbedAspectRatio(aspectRatio);
  if (/aspectRatio=[^&)]+/.test(embedSnippet)) {
    return embedSnippet.replace(/(aspectRatio=)([^&)]+)/, `$1${aspectRatioStr}`);
  }
  return embedSnippet.replace(/(\[Edit Writing\]\([^?]+)(\?[^)]*)?(\))/, (_match, p1, p2, p3) => {
    if (p2) {
      return `${p1}${p2}&aspectRatio=${aspectRatioStr}${p3}`;
    }
    return `${p1}?aspectRatio=${aspectRatioStr}${p3}`;
  });
}
var init_writing_embed_aspect_ratio = __esm({
  "src/logic/utils/writing-embed-aspect-ratio.ts"() {
    init_embed_settings();
  }
});

// src/logic/utils/migration-logic.ts
function findLegacyEmbedBlocks(markdownContent) {
  const results = [];
  const codeBlockRegex = new RegExp("```(?:" + WRITE_EMBED_KEY + "|" + DRAW_EMBED_KEY + ")\\n([\\s\\S]*?)\\n```", "g");
  let match;
  while ((match = codeBlockRegex.exec(markdownContent)) !== null) {
    const fullMatch = match[0];
    const jsonContent = match[1].trim();
    const embedType = fullMatch.startsWith("```" + WRITE_EMBED_KEY) ? "writing" : "drawing";
    try {
      const parsed = JSON.parse(jsonContent);
      if (typeof parsed === "object" && parsed !== null) {
        const embedRecord = parsed;
        const filepathValue = embedRecord["filepath"];
        if (typeof filepathValue === "string" && filepathValue.length > 0) {
          results.push({ fullMatch, embedType, filepath: filepathValue });
        }
      }
    } catch {
    }
  }
  return results;
}
function replaceLegacyBlockInMarkdown(markdown, block, newEmbed) {
  const trimmedEmbed = newEmbed.replace(/^\n+|\n+$/g, "");
  return markdown.split(block.fullMatch).join(trimmedEmbed);
}
function convertLegacyToInkCanvasFileData(legacyJson, fileType) {
  let legacyData;
  try {
    legacyData = JSON.parse(legacyJson);
  } catch {
    return null;
  }
  if (!legacyData.tldraw || !legacyData.meta)
    return null;
  const tldrawSnapshot = legacyData.tldraw;
  if (fileType === "writing") {
    const inkCanvasSnapshot2 = migrateWritingFromTldraw(tldrawSnapshot, WRITING_LINE_HEIGHT);
    const svgString2 = renderWritingStrokesToSvg(inkCanvasSnapshot2.strokes, inkCanvasSnapshot2, WRITING_PAGE_WIDTH);
    const fileData2 = buildInkCanvasWritingFileData({
      inkCanvasSnapshot: inkCanvasSnapshot2,
      svgString: svgString2
    });
    fileData2.meta.pluginVersion = PLUGIN_VERSION;
    if (legacyData.meta.transcript) {
      fileData2.meta.transcript = legacyData.meta.transcript;
    }
    if (inkCanvasSnapshot2.writingLineHeight != null) {
      fileData2.meta.writingLineHeight = inkCanvasSnapshot2.writingLineHeight;
    }
    return fileData2;
  }
  const inkCanvasSnapshot = migrateFromTldraw(tldrawSnapshot);
  const svgString = renderStrokesToSvg(inkCanvasSnapshot.strokes, inkCanvasSnapshot);
  const fileData = buildInkCanvasDrawingFileData({
    inkCanvasSnapshot,
    svgString
  });
  fileData.meta.pluginVersion = PLUGIN_VERSION;
  if (legacyData.meta.transcript) {
    fileData.meta.transcript = legacyData.meta.transcript;
  }
  return fileData;
}
function getLegacySvgPath(legacyFilePath) {
  const dotIndex = legacyFilePath.lastIndexOf(".");
  if (dotIndex < 0)
    return legacyFilePath + ".svg";
  return legacyFilePath.substring(0, dotIndex) + ".svg";
}
function isLegacyInkFilePath(filePath) {
  return filePath.endsWith(".writing") || filePath.endsWith(".drawing");
}
function getLegacyInkFileType(filePath) {
  if (filePath.endsWith(".writing"))
    return "writing";
  if (filePath.endsWith(".drawing"))
    return "drawing";
  return null;
}
function vaultHasLegacyInkFiles(vault) {
  return vault.getFiles().some((file) => file.extension === "writing" || file.extension === "drawing");
}
function addLegacyFileToMap(legacyFileMap, legacyFile, fileType) {
  if (legacyFileMap.has(legacyFile.path))
    return;
  legacyFileMap.set(legacyFile.path, {
    legacyFile,
    fileType,
    newSvgPath: getLegacySvgPath(legacyFile.path),
    referencingNotes: []
  });
}
function getTestRunSvgBasename(legacyFilePath) {
  const slashIndex = legacyFilePath.lastIndexOf("/");
  const fileName = slashIndex < 0 ? legacyFilePath : legacyFilePath.substring(slashIndex + 1);
  const dotIndex = fileName.lastIndexOf(".");
  const nameWithoutExt = dotIndex < 0 ? fileName : fileName.substring(0, dotIndex);
  return `${nameWithoutExt}.svg`;
}
function buildTestRunSvgPathMap(legacyFilePaths) {
  const usedCountByStem = /* @__PURE__ */ new Map();
  const pathMap = /* @__PURE__ */ new Map();
  for (const legacyPath of legacyFilePaths) {
    const basename = getTestRunSvgBasename(legacyPath);
    const stem = basename.slice(0, -".svg".length);
    const useCount = usedCountByStem.get(stem) ?? 0;
    usedCountByStem.set(stem, useCount + 1);
    const fileName = useCount === 0 ? basename : `${stem}_${useCount}.svg`;
    pathMap.set(legacyPath, `${INK_TEST_CONVERSIONS_FOLDER}/${fileName}`);
  }
  return pathMap;
}
function getTestRunSvgPath(legacyFilePath) {
  return buildTestRunSvgPathMap([legacyFilePath]).get(legacyFilePath);
}
function resolveMigrationOutputSvgPath(legacyFilePath, options, testRunSvgPathByLegacyPath) {
  if (options?.testRun) {
    return testRunSvgPathByLegacyPath?.get(legacyFilePath) ?? getTestRunSvgPath(legacyFilePath);
  }
  return getLegacySvgPath(legacyFilePath);
}
async function ensureVaultFolderExists(vault, folderPath) {
  if (!vault.getAbstractFileByPath(folderPath)) {
    await vault.createFolder(folderPath);
  }
}
async function buildSingleLegacyFileScanResult(vault, legacyFile) {
  const fileType = getLegacyInkFileType(legacyFile.path);
  if (!fileType)
    return null;
  const referencingNotes = [];
  for (const note of vault.getMarkdownFiles()) {
    let content;
    try {
      content = await vault.read(note);
    } catch {
      continue;
    }
    const blocks = findLegacyEmbedBlocks(content);
    if (blocks.some((block) => block.filepath === legacyFile.path)) {
      referencingNotes.push(note);
    }
  }
  return {
    legacyFiles: [{
      legacyFile,
      fileType,
      newSvgPath: getLegacySvgPath(legacyFile.path),
      referencingNotes
    }],
    affectedNotes: referencingNotes
  };
}
async function scanVaultForLegacyEmbeds(vault, onProgress) {
  const markdownFiles = vault.getMarkdownFiles();
  const total = markdownFiles.length;
  const legacyFileMap = /* @__PURE__ */ new Map();
  const affectedNoteSet = /* @__PURE__ */ new Map();
  for (const vaultFile of vault.getFiles()) {
    const fileType = getLegacyInkFileType(vaultFile.path);
    if (fileType) {
      addLegacyFileToMap(legacyFileMap, vaultFile, fileType);
    }
  }
  for (let i2 = 0; i2 < markdownFiles.length; i2++) {
    const note = markdownFiles[i2];
    let content;
    try {
      content = await vault.read(note);
    } catch {
      onProgress?.(i2 + 1, total, legacyFileMap.size);
      continue;
    }
    const blocks = findLegacyEmbedBlocks(content);
    if (blocks.length === 0) {
      onProgress?.(i2 + 1, total, legacyFileMap.size);
      continue;
    }
    affectedNoteSet.set(note.path, note);
    for (const block of blocks) {
      const legacyFile = vault.getAbstractFileByPath(block.filepath);
      if (legacyFile instanceof import_obsidian8.TFile) {
        addLegacyFileToMap(legacyFileMap, legacyFile, block.embedType);
      }
      const entry = legacyFileMap.get(block.filepath);
      if (entry && !entry.referencingNotes.find((n2) => n2.path === note.path)) {
        entry.referencingNotes.push(note);
      }
    }
    onProgress?.(i2 + 1, total, legacyFileMap.size);
  }
  return {
    legacyFiles: Array.from(legacyFileMap.values()),
    affectedNotes: Array.from(affectedNoteSet.values())
  };
}
async function executeMigration(vault, fileManager, scanResult, onProgress, options) {
  const isTestRun = options?.testRun === true;
  const shouldDeleteLegacyFiles = !isTestRun;
  const result = {
    convertedFiles: 0,
    updatedNotes: 0,
    updatedNotePaths: [],
    skipped: [],
    failed: [],
    ...isTestRun ? { testRunOutputFolder: INK_TEST_CONVERSIONS_FOLDER } : {}
  };
  const notesToUpdate = isTestRun ? [] : scanResult.affectedNotes;
  const legacyFilesToConvert = options?.singleLegacyFilePath ? scanResult.legacyFiles.filter((entry) => entry.legacyFile.path === options.singleLegacyFilePath) : scanResult.legacyFiles;
  const total = legacyFilesToConvert.length + notesToUpdate.length;
  let done = 0;
  logToVault("Migration started. Files: " + legacyFilesToConvert.length + ", Notes: " + notesToUpdate.length + (isTestRun ? " (test run)" : ""));
  if (isTestRun) {
    await ensureVaultFolderExists(vault, INK_TEST_CONVERSIONS_FOLDER);
  }
  const testRunSvgPathByLegacyPath = isTestRun ? buildTestRunSvgPathMap(legacyFilesToConvert.map((entry) => entry.legacyFile.path)) : void 0;
  const drawingEmbedSettingsBySvgPath = /* @__PURE__ */ new Map();
  const writingAspectRatioBySvgPath = /* @__PURE__ */ new Map();
  const reportProgress = () => {
    onProgress?.(done, total, {
      convertedFiles: result.convertedFiles,
      skippedCount: result.skipped.length,
      failedCount: result.failed.length
    });
  };
  for (const entry of legacyFilesToConvert) {
    try {
      const legacyJson = await vault.read(entry.legacyFile);
      const inkFileData = convertLegacyToInkCanvasFileData(legacyJson, entry.fileType);
      if (!inkFileData) {
        result.skipped.push(entry.legacyFile.path + " (could not parse)");
        done++;
        reportProgress();
        continue;
      }
      const outputSvgPath = resolveMigrationOutputSvgPath(entry.legacyFile.path, options, testRunSvgPathByLegacyPath);
      const existing = vault.getAbstractFileByPath(outputSvgPath);
      if (!isTestRun && entry.fileType === "drawing" && inkFileData.inkCanvas) {
        const embedSettings = buildDrawingEmbedSettingsFromStrokes(inkFileData.inkCanvas.strokes);
        if (embedSettings) {
          drawingEmbedSettingsBySvgPath.set(outputSvgPath, embedSettings);
        }
      }
      const svgStr = buildFileStr(inkFileData);
      if (!isTestRun && entry.fileType === "writing") {
        const writingAspectRatio = parseSvgViewBoxAspectRatio(svgStr);
        if (writingAspectRatio != null) {
          writingAspectRatioBySvgPath.set(outputSvgPath, writingAspectRatio);
        }
      }
      if (existing instanceof import_obsidian8.TFile) {
        try {
          await vault.modify(existing, svgStr);
        } catch (err) {
          const detail = err instanceof Error ? err.message : String(err);
          throw new Error("failed to overwrite existing SVG \u2013 " + detail);
        }
      } else {
        try {
          await vault.create(outputSvgPath, svgStr);
        } catch (err) {
          const detail = err instanceof Error ? err.message : String(err);
          throw new Error("failed to create SVG \u2013 " + detail);
        }
      }
      if (shouldDeleteLegacyFiles) {
        try {
          await fileManager.trashFile(entry.legacyFile);
        } catch (err) {
          const detail = err instanceof Error ? err.message : String(err);
          throw new Error("failed to delete legacy file \u2013 " + detail);
        }
      }
      result.convertedFiles++;
    } catch (err) {
      const errMessage = err instanceof Error ? err.message : String(err);
      logToVault("Migration file error: " + entry.legacyFile.path + " \u2013 " + errMessage);
      result.failed.push(entry.legacyFile.path + ": " + errMessage);
    }
    done++;
    reportProgress();
  }
  for (const note of notesToUpdate) {
    try {
      let content = await vault.read(note);
      const blocks = findLegacyEmbedBlocks(content);
      for (const block of blocks) {
        if (options?.singleLegacyFilePath && block.filepath !== options.singleLegacyFilePath) {
          continue;
        }
        const newSvgPath = resolveMigrationOutputSvgPath(block.filepath, options);
        const newEmbed = block.embedType === "writing" ? (() => {
          const aspectRatio = writingAspectRatioBySvgPath.get(newSvgPath);
          return aspectRatio != null ? buildWritingEmbed(newSvgPath, { aspectRatio }) : buildWritingEmbed(newSvgPath);
        })() : (() => {
          const embedSettings = drawingEmbedSettingsBySvgPath.get(newSvgPath);
          return embedSettings ? buildDrawingEmbed(newSvgPath, { embedSettings }) : buildDrawingEmbed(newSvgPath);
        })();
        content = replaceLegacyBlockInMarkdown(content, block, newEmbed);
      }
      await vault.modify(note, content);
      result.updatedNotes++;
      result.updatedNotePaths.push(note.path);
    } catch (err) {
      const errMessage = err instanceof Error ? err.message : String(err);
      result.failed.push(note.path + ": " + errMessage);
    }
    done++;
    reportProgress();
  }
  logToVault("Migration complete. Converted: " + result.convertedFiles + ", Failed: " + result.failed.length + ", Skipped: " + result.skipped.length);
  return result;
}
var import_obsidian8, INK_TEST_CONVERSIONS_FOLDER;
var init_migration_logic = __esm({
  "src/logic/utils/migration-logic.ts"() {
    import_obsidian8 = require("obsidian");
    init_constants();
    init_log_to_vault();
    init_build_file_data();
    init_buildFileStr();
    init_build_embeds();
    init_build_drawing_embed_settings_from_file();
    init_writing_embed_aspect_ratio();
    init_migrate_from_tldraw();
    init_svg_export();
    INK_TEST_CONVERSIONS_FOLDER = "_ink-test-conversions";
  }
});

// src/logic/utils/tldraw-svg-migration-logic.ts
function findV2InkEmbedRefs(markdownContent) {
  const results = [];
  let match;
  V2_EMBED_PATH_REGEX.lastIndex = 0;
  while ((match = V2_EMBED_PATH_REGEX.exec(markdownContent)) !== null) {
    const alt = match[1];
    const filepath = match[2].trim();
    if (!filepath)
      continue;
    results.push({
      filepath,
      embedKind: alt === "InkWriting" ? "writing" : "drawing"
    });
  }
  return results;
}
function convertTldrawInkFileDataToInkCanvas(inkFileData) {
  if (isInkCanvasFile(inkFileData))
    return null;
  if (!inkFileData.tldraw || !inkFileData.meta)
    return null;
  const fileType = inkFileData.meta.fileType;
  if (fileType !== "inkWriting" && fileType !== "inkDrawing")
    return null;
  const tldrawSnapshot = inkFileData.tldraw;
  if (fileType === "inkWriting") {
    const fallbackLineHeight = inkFileData.meta.writingLineHeight ?? WRITING_LINE_HEIGHT;
    const inkCanvasSnapshot2 = migrateWritingFromTldraw(tldrawSnapshot, fallbackLineHeight);
    const svgString2 = renderWritingStrokesToSvg(inkCanvasSnapshot2.strokes, inkCanvasSnapshot2, WRITING_PAGE_WIDTH);
    const fileData2 = buildInkCanvasWritingFileData({
      inkCanvasSnapshot: inkCanvasSnapshot2,
      svgString: svgString2
    });
    fileData2.meta.pluginVersion = PLUGIN_VERSION;
    if (inkFileData.meta.transcript) {
      fileData2.meta.transcript = inkFileData.meta.transcript;
    }
    if (inkCanvasSnapshot2.writingLineHeight != null) {
      fileData2.meta.writingLineHeight = inkCanvasSnapshot2.writingLineHeight;
    }
    return fileData2;
  }
  const inkCanvasSnapshot = migrateFromTldraw(tldrawSnapshot);
  const svgString = renderStrokesToSvg(inkCanvasSnapshot.strokes, inkCanvasSnapshot);
  const fileData = buildInkCanvasDrawingFileData({
    inkCanvasSnapshot,
    svgString
  });
  fileData.meta.pluginVersion = PLUGIN_VERSION;
  if (inkFileData.meta.transcript) {
    fileData.meta.transcript = inkFileData.meta.transcript;
  }
  return fileData;
}
function replaceV2DrawingEmbedLinesInMarkdown(markdown, svgPath, fittedSettings) {
  const escapedPath = svgPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const lineRegex = new RegExp(` !\\[InkDrawing\\]\\(<${escapedPath}>\\) \\[Edit Drawing\\]\\(([^)]+)\\)`, "g");
  return markdown.replace(lineRegex, (_match, urlPart) => {
    const { embedSettings: existing } = parseSettingsFromUrl(urlPart);
    const merged = {
      embedDisplay: { ...existing.embedDisplay },
      viewBox: { ...fittedSettings.viewBox }
    };
    const newLine = buildDrawingEmbed(svgPath, { embedSettings: merged }).trim();
    return ` ${newLine}`;
  });
}
async function isMigratableLegacyInkSvgFile(vault, file) {
  try {
    const svgString = await vault.read(file);
    if (sniffInkSvgFileType(svgString) == null)
      return false;
    const data = extractInkJsonFromSvg(svgString);
    return isMigratableLegacyInkFileData(data);
  } catch {
    return false;
  }
}
function isMigratableLegacyInkFileData(data) {
  if (!data || isInkCanvasFile(data))
    return false;
  if (!data.tldraw || !data.meta)
    return false;
  const fileType = data.meta.fileType;
  return fileType === "inkWriting" || fileType === "inkDrawing";
}
async function resolveTldrawSvgFileKind(vault, file) {
  try {
    const svgString = await vault.read(file);
    const inkFileData = extractInkJsonFromSvg(svgString);
    if (inkFileData?.meta.fileType === "inkWriting")
      return "writing";
    if (inkFileData?.meta.fileType === "inkDrawing")
      return "drawing";
  } catch {
  }
  return null;
}
function resolveEmbedPath(vault, resolveLinkPath, linkpath, sourceNotePath) {
  const normalized = (0, import_obsidian9.normalizePath)(linkpath);
  const resolved = resolveLinkPath(normalized, sourceNotePath);
  if (resolved)
    return resolved;
  const byPath = vault.getAbstractFileByPath(normalized);
  if (byPath instanceof import_obsidian9.TFile)
    return byPath.path;
  return null;
}
async function scanVaultForTldrawInkSvgFiles(vault, resolveLinkPath, onProgress) {
  const markdownFiles = vault.getMarkdownFiles();
  const svgFiles = vault.getFiles().filter((file) => file.extension === "svg");
  const total = markdownFiles.length + svgFiles.length;
  const fileMap = /* @__PURE__ */ new Map();
  const affectedNoteSet = /* @__PURE__ */ new Map();
  const pendingChecks = /* @__PURE__ */ new Map();
  let scanned = 0;
  const report = () => onProgress?.(scanned, total, fileMap.size);
  for (const note of markdownFiles) {
    let content;
    try {
      content = await vault.read(note);
    } catch {
      scanned++;
      report();
      continue;
    }
    const refs = findV2InkEmbedRefs(content);
    if (refs.length > 0) {
      affectedNoteSet.set(note.path, note);
    }
    for (const ref of refs) {
      const canonicalPath = resolveEmbedPath(vault, resolveLinkPath, ref.filepath, note.path);
      if (!canonicalPath)
        continue;
      if (!fileMap.has(canonicalPath)) {
        const svgFile = vault.getAbstractFileByPath(canonicalPath);
        if (!(svgFile instanceof import_obsidian9.TFile))
          continue;
        let checkPromise = pendingChecks.get(canonicalPath);
        if (!checkPromise) {
          checkPromise = isMigratableLegacyInkSvgFile(vault, svgFile);
          pendingChecks.set(canonicalPath, checkPromise);
        }
        const isTldraw = await checkPromise;
        if (!isTldraw)
          continue;
        fileMap.set(canonicalPath, {
          svgFile,
          fileKind: ref.embedKind,
          newSvgPath: canonicalPath,
          referencingNotes: []
        });
      }
      const entry = fileMap.get(canonicalPath);
      if (entry && !entry.referencingNotes.some((n2) => n2.path === note.path)) {
        entry.referencingNotes.push(note);
      }
    }
    scanned++;
    report();
  }
  for (const svgFile of svgFiles) {
    if (!fileMap.has(svgFile.path)) {
      let checkPromise = pendingChecks.get(svgFile.path);
      if (!checkPromise) {
        checkPromise = isMigratableLegacyInkSvgFile(vault, svgFile);
        pendingChecks.set(svgFile.path, checkPromise);
      }
      const isTldraw = await checkPromise;
      if (isTldraw) {
        const fileKind = await resolveTldrawSvgFileKind(vault, svgFile);
        if (fileKind) {
          fileMap.set(svgFile.path, {
            svgFile,
            fileKind,
            newSvgPath: svgFile.path,
            referencingNotes: []
          });
        }
      }
    }
    scanned++;
    report();
  }
  return {
    tldrawSvgFiles: Array.from(fileMap.values()),
    affectedNotes: Array.from(affectedNoteSet.values())
  };
}
async function vaultNeedsInkFormatMigration(vault, resolveLinkPath) {
  if (vaultHasLegacyInkFiles(vault)) {
    return true;
  }
  const tldrawScan = await scanVaultForTldrawInkSvgFiles(vault, resolveLinkPath);
  return tldrawScan.tldrawSvgFiles.length > 0;
}
async function buildSingleTldrawSvgScanResult(vault, svgFile, resolveLinkPath) {
  const isTldraw = await isMigratableLegacyInkSvgFile(vault, svgFile);
  if (!isTldraw)
    return null;
  const referencingNotes = [];
  let fileKind = null;
  for (const note of vault.getMarkdownFiles()) {
    let content;
    try {
      content = await vault.read(note);
    } catch {
      continue;
    }
    for (const ref of findV2InkEmbedRefs(content)) {
      const canonicalPath = resolveEmbedPath(vault, resolveLinkPath, ref.filepath, note.path);
      if (canonicalPath !== svgFile.path)
        continue;
      referencingNotes.push(note);
      fileKind = ref.embedKind;
      break;
    }
  }
  if (!fileKind) {
    const svgString = await vault.read(svgFile);
    const inkFileData = extractInkJsonFromSvg(svgString);
    if (inkFileData?.meta.fileType === "inkWriting")
      fileKind = "writing";
    else if (inkFileData?.meta.fileType === "inkDrawing")
      fileKind = "drawing";
  }
  if (!fileKind)
    return null;
  return {
    tldrawSvgFiles: [{
      svgFile,
      fileKind,
      newSvgPath: svgFile.path,
      referencingNotes
    }],
    affectedNotes: referencingNotes
  };
}
async function executeTldrawSvgMigration(vault, scanResult, onProgress) {
  const result = {
    convertedFiles: 0,
    updatedNotes: 0,
    updatedNotePaths: [],
    skipped: [],
    failed: []
  };
  const drawingEmbedSettingsBySvgPath = /* @__PURE__ */ new Map();
  const convertedPaths = /* @__PURE__ */ new Set();
  const total = scanResult.tldrawSvgFiles.length + scanResult.affectedNotes.length;
  let done = 0;
  const reportProgress = () => {
    onProgress?.(done, total, {
      convertedFiles: result.convertedFiles,
      skippedCount: result.skipped.length,
      failedCount: result.failed.length
    });
  };
  logToVault("Tldraw SVG migration started. Files: " + scanResult.tldrawSvgFiles.length + ", Notes: " + scanResult.affectedNotes.length);
  for (const entry of scanResult.tldrawSvgFiles) {
    try {
      const svgString = await vault.read(entry.svgFile);
      const inkFileData = extractInkJsonFromSvg(svgString);
      if (!inkFileData) {
        result.skipped.push(entry.svgFile.path + " (no ink JSON)");
        done++;
        reportProgress();
        continue;
      }
      const converted = convertTldrawInkFileDataToInkCanvas(inkFileData);
      if (!converted) {
        result.skipped.push(entry.svgFile.path + " (already ink-canvas or not tldraw)");
        done++;
        reportProgress();
        continue;
      }
      if (entry.fileKind === "drawing" && converted.inkCanvas) {
        const embedSettings = buildDrawingEmbedSettingsFromStrokes(converted.inkCanvas.strokes);
        if (embedSettings) {
          drawingEmbedSettingsBySvgPath.set(entry.newSvgPath, embedSettings);
        }
      }
      const out = buildFileStr(converted);
      await vault.modify(entry.svgFile, out);
      convertedPaths.add(entry.newSvgPath);
      result.convertedFiles++;
    } catch (err) {
      const errMessage = err instanceof Error ? err.message : String(err);
      logToVault("Tldraw SVG migration file error: " + entry.svgFile.path + " \u2013 " + errMessage);
      result.failed.push(entry.svgFile.path + ": " + errMessage);
    }
    done++;
    reportProgress();
  }
  for (const note of scanResult.affectedNotes) {
    try {
      let content = await vault.read(note);
      let modified = false;
      for (const [svgPath, embedSettings] of drawingEmbedSettingsBySvgPath) {
        if (!convertedPaths.has(svgPath))
          continue;
        const updated = replaceV2DrawingEmbedLinesInMarkdown(content, svgPath, embedSettings);
        if (updated !== content) {
          content = updated;
          modified = true;
        }
      }
      if (modified) {
        await vault.modify(note, content);
        result.updatedNotes++;
        result.updatedNotePaths.push(note.path);
      }
    } catch (err) {
      const errMessage = err instanceof Error ? err.message : String(err);
      result.failed.push(note.path + ": " + errMessage);
    }
    done++;
    reportProgress();
  }
  logToVault("Tldraw SVG migration complete. Converted: " + result.convertedFiles + ", Notes updated: " + result.updatedNotes);
  return result;
}
var import_obsidian9, V2_EMBED_PATH_REGEX;
var init_tldraw_svg_migration_logic = __esm({
  "src/logic/utils/tldraw-svg-migration-logic.ts"() {
    import_obsidian9 = require("obsidian");
    init_constants();
    init_log_to_vault();
    init_ink_file_storage_engine();
    init_build_file_data();
    init_buildFileStr();
    init_build_embeds();
    init_parse_settings_from_url();
    init_build_drawing_embed_settings_from_file();
    init_extractInkJsonFromSvg();
    init_migrate_from_tldraw();
    init_svg_export();
    init_migration_logic();
    V2_EMBED_PATH_REGEX = /!\[(InkWriting|InkDrawing)\]\(<([^>]+)>\)/g;
  }
});

// src/logic/utils/storage.ts
function localStorageKey(storageSuffix) {
  return `${LOCAL_STORAGE_PREFIX}${storageSuffix}`;
}
var ACTIVATE_NEXT_EMBED_STORAGE_SUFFIX, RECENT_DRAWING_FILE_PATHS_STORAGE_SUFFIX, RECENT_WRITING_FILE_PATHS_STORAGE_SUFFIX, vaultKeyedStorage, saveLocally, fetchLocally, deleteLocally, activateNextEmbed, embedShouldActivateImmediately, RECENT_PATHS_MAX_LENGTH, fetchRecentFilePaths, recordRecentFileSelection;
var init_storage = __esm({
  "src/logic/utils/storage.ts"() {
    init_constants();
    ACTIVATE_NEXT_EMBED_STORAGE_SUFFIX = "activateNextEmbed";
    RECENT_DRAWING_FILE_PATHS_STORAGE_SUFFIX = "recentDrawingFilePaths";
    RECENT_WRITING_FILE_PATHS_STORAGE_SUFFIX = "recentWritingFilePaths";
    vaultKeyedStorage = () => window.activeWindow.localStorage;
    saveLocally = (key, value) => {
      if (typeof value === "boolean") {
        value = value.toString();
      }
      vaultKeyedStorage().setItem(localStorageKey(key), value);
    };
    fetchLocally = (key) => {
      let value = vaultKeyedStorage().getItem(localStorageKey(key));
      if (value === null)
        return null;
      if (value === "true")
        value = true;
      if (value === "false")
        value = false;
      return value;
    };
    deleteLocally = (key) => {
      vaultKeyedStorage().removeItem(localStorageKey(key));
    };
    activateNextEmbed = () => {
      saveLocally(ACTIVATE_NEXT_EMBED_STORAGE_SUFFIX, true);
    };
    embedShouldActivateImmediately = () => {
      const result = fetchLocally(ACTIVATE_NEXT_EMBED_STORAGE_SUFFIX);
      deleteLocally(ACTIVATE_NEXT_EMBED_STORAGE_SUFFIX);
      return result;
    };
    RECENT_PATHS_MAX_LENGTH = 10;
    fetchRecentFilePaths = (fileType) => {
      const key = fileType === "inkDrawing" ? RECENT_DRAWING_FILE_PATHS_STORAGE_SUFFIX : RECENT_WRITING_FILE_PATHS_STORAGE_SUFFIX;
      const raw = fetchLocally(key);
      if (typeof raw !== "string")
        return [];
      try {
        const parsedUnknown = JSON.parse(raw);
        if (!Array.isArray(parsedUnknown))
          return [];
        return parsedUnknown.filter((item) => typeof item === "string").slice(0, RECENT_PATHS_MAX_LENGTH);
      } catch {
        return [];
      }
    };
    recordRecentFileSelection = (fileType, filepath) => {
      const key = fileType === "inkDrawing" ? RECENT_DRAWING_FILE_PATHS_STORAGE_SUFFIX : RECENT_WRITING_FILE_PATHS_STORAGE_SUFFIX;
      const current = fetchRecentFilePaths(fileType);
      const deduped = [filepath, ...current.filter((path) => path !== filepath)];
      const trimmed = deduped.slice(0, RECENT_PATHS_MAX_LENGTH);
      saveLocally(key, JSON.stringify(trimmed));
    };
  }
});

// src/logic/device-settings/device-settings-defaults.ts
var DEVICE_SETTINGS_STORAGE_KEY, DEFAULT_DEVICE_SETTINGS_V1;
var init_device_settings_defaults = __esm({
  "src/logic/device-settings/device-settings-defaults.ts"() {
    init_constants();
    DEVICE_SETTINGS_STORAGE_KEY = "deviceSettings_v1";
    DEFAULT_DEVICE_SETTINGS_V1 = {
      pluginVersion: PLUGIN_VERSION,
      booxConnectionEnabled: false,
      fingerDrawingEnabled: false,
      strokeInputTreatAs: {
        inkWriting: "auto",
        inkDrawing: "auto"
      },
      lastDetectedStrokeInput: null
    };
  }
});

// src/logic/device-settings/device-settings.ts
function isStrokeInputTreatAs(value) {
  return value === "auto" || value === "pen" || value === "mouse";
}
function isResolvedStrokeInputTreatAs(value) {
  return value === "pen" || value === "mouse";
}
function isLastDetectedStrokeInput(value) {
  return value === null || isResolvedStrokeInputTreatAs(value);
}
function isDeviceSettingsV1(value) {
  if (!value || typeof value !== "object")
    return false;
  const o2 = value;
  if (typeof o2.pluginVersion !== "string")
    return false;
  const treat = o2.strokeInputTreatAs;
  if (!treat || typeof treat !== "object")
    return false;
  const t3 = treat;
  return isStrokeInputTreatAs(t3.inkWriting) && isStrokeInputTreatAs(t3.inkDrawing);
}
function mergeWithDefaults(partial) {
  const base = DEFAULT_DEVICE_SETTINGS_V1;
  if (!isDeviceSettingsV1(partial)) {
    return {
      ...base,
      strokeInputTreatAs: { ...base.strokeInputTreatAs },
      lastDetectedStrokeInput: base.lastDetectedStrokeInput
    };
  }
  const lastDetected = isLastDetectedStrokeInput(partial.lastDetectedStrokeInput) ? partial.lastDetectedStrokeInput : base.lastDetectedStrokeInput;
  const booxConnectionEnabled = typeof partial.booxConnectionEnabled === "boolean" ? partial.booxConnectionEnabled : base.booxConnectionEnabled;
  const fingerDrawingEnabled = typeof partial.fingerDrawingEnabled === "boolean" ? partial.fingerDrawingEnabled : base.fingerDrawingEnabled;
  return {
    pluginVersion: PLUGIN_VERSION,
    booxConnectionEnabled,
    fingerDrawingEnabled,
    strokeInputTreatAs: {
      inkWriting: partial.strokeInputTreatAs.inkWriting,
      inkDrawing: partial.strokeInputTreatAs.inkDrawing
    },
    lastDetectedStrokeInput: lastDetected
  };
}
function shouldPersistPluginVersion(stored) {
  if (!stored || typeof stored !== "object")
    return false;
  return stored.pluginVersion !== PLUGIN_VERSION;
}
function readDeviceSettings() {
  const raw = fetchLocally(DEVICE_SETTINGS_STORAGE_KEY);
  if (typeof raw !== "string")
    return mergeWithDefaults(null);
  try {
    const parsed = JSON.parse(raw);
    const merged = mergeWithDefaults(parsed);
    if (shouldPersistPluginVersion(parsed)) {
      writeDeviceSettings(merged);
    }
    return merged;
  } catch {
    return mergeWithDefaults(null);
  }
}
function writeDeviceSettings(settings) {
  const toStore = {
    ...settings,
    pluginVersion: PLUGIN_VERSION
  };
  saveLocally(DEVICE_SETTINGS_STORAGE_KEY, JSON.stringify(toStore));
  notifyDeviceSettingsChanged();
}
function notifyDeviceSettingsChanged() {
  window.dispatchEvent(new CustomEvent(DEVICE_SETTINGS_CHANGED_EVENT));
}
function patchDeviceSettings(partial) {
  const current = readDeviceSettings();
  const next = {
    ...current,
    ...partial,
    strokeInputTreatAs: {
      ...current.strokeInputTreatAs,
      ...partial.strokeInputTreatAs ?? {}
    },
    lastDetectedStrokeInput: partial.lastDetectedStrokeInput === void 0 ? current.lastDetectedStrokeInput : partial.lastDetectedStrokeInput
  };
  writeDeviceSettings(next);
  return next;
}
function getBooxConnectionEnabled() {
  return readDeviceSettings().booxConnectionEnabled;
}
function setBooxConnectionEnabled(enabled) {
  patchDeviceSettings({ booxConnectionEnabled: enabled });
}
function resetBooxConnectionToDefault() {
  setBooxConnectionEnabled(DEFAULT_DEVICE_SETTINGS_V1.booxConnectionEnabled);
}
function getFingerDrawingEnabled() {
  return readDeviceSettings().fingerDrawingEnabled;
}
function setFingerDrawingEnabled(enabled) {
  patchDeviceSettings({ fingerDrawingEnabled: enabled });
}
function resetFingerDrawingToDefault() {
  setFingerDrawingEnabled(DEFAULT_DEVICE_SETTINGS_V1.fingerDrawingEnabled);
}
function deviceStorageAlreadyHasBooxField() {
  const raw = fetchLocally(DEVICE_SETTINGS_STORAGE_KEY);
  if (typeof raw !== "string")
    return false;
  try {
    const parsed = JSON.parse(raw);
    return !!parsed && typeof parsed === "object" && "booxConnectionEnabled" in parsed;
  } catch {
    return false;
  }
}
function migrateBooxConnectionFromVaultToDevice(vaultPluginData) {
  if (!vaultPluginData || deviceStorageAlreadyHasBooxField())
    return false;
  let vaultValue;
  if (typeof vaultPluginData.booxConnectionEnabled === "boolean") {
    vaultValue = vaultPluginData.booxConnectionEnabled;
  } else if (typeof vaultPluginData.einkBridgeEnabled === "boolean") {
    vaultValue = vaultPluginData.einkBridgeEnabled;
  }
  if (vaultValue === void 0)
    return false;
  setBooxConnectionEnabled(vaultValue);
  return true;
}
function getStrokeInputTreatAs(editorKind) {
  return readDeviceSettings().strokeInputTreatAs[editorKind];
}
function setStrokeInputTreatAs(editorKind, value) {
  patchDeviceSettings({
    strokeInputTreatAs: {
      ...readDeviceSettings().strokeInputTreatAs,
      [editorKind]: value
    }
  });
}
function getLastDetectedStrokeInput() {
  return readDeviceSettings().lastDetectedStrokeInput;
}
function setLastDetectedStrokeInput(value) {
  patchDeviceSettings({
    lastDetectedStrokeInput: value
  });
}
function resolveStrokeInputTreatAs(preference, lastDetected) {
  if (preference === "pen")
    return "pen";
  if (preference === "mouse")
    return "mouse";
  return lastDetected ?? "mouse";
}
function subscribeDeviceSettingsChanged(onChange) {
  const wrapped = () => {
    onChange();
  };
  window.addEventListener(DEVICE_SETTINGS_CHANGED_EVENT, wrapped);
  window.addEventListener("storage", wrapped);
  return () => {
    window.removeEventListener(DEVICE_SETTINGS_CHANGED_EVENT, wrapped);
    window.removeEventListener("storage", wrapped);
  };
}
var DEVICE_SETTINGS_CHANGED_EVENT;
var init_device_settings = __esm({
  "src/logic/device-settings/device-settings.ts"() {
    init_constants();
    init_storage();
    init_device_settings_defaults();
    DEVICE_SETTINGS_CHANGED_EVENT = "ddc-ink-device-settings-changed";
  }
});

// node_modules/scheduler/cjs/scheduler.production.min.js
var require_scheduler_production_min = __commonJS({
  "node_modules/scheduler/cjs/scheduler.production.min.js"(exports) {
    "use strict";
    function f2(a2, b2) {
      var c2 = a2.length;
      a2.push(b2);
      a:
        for (; 0 < c2; ) {
          var d2 = c2 - 1 >>> 1, e2 = a2[d2];
          if (0 < g2(e2, b2))
            a2[d2] = b2, a2[c2] = e2, c2 = d2;
          else
            break a;
        }
    }
    function h2(a2) {
      return a2.length === 0 ? null : a2[0];
    }
    function k2(a2) {
      if (a2.length === 0)
        return null;
      var b2 = a2[0], c2 = a2.pop();
      if (c2 !== b2) {
        a2[0] = c2;
        a:
          for (var d2 = 0, e2 = a2.length, w2 = e2 >>> 1; d2 < w2; ) {
            var m2 = 2 * (d2 + 1) - 1, C2 = a2[m2], n2 = m2 + 1, x2 = a2[n2];
            if (0 > g2(C2, c2))
              n2 < e2 && 0 > g2(x2, C2) ? (a2[d2] = x2, a2[n2] = c2, d2 = n2) : (a2[d2] = C2, a2[m2] = c2, d2 = m2);
            else if (n2 < e2 && 0 > g2(x2, c2))
              a2[d2] = x2, a2[n2] = c2, d2 = n2;
            else
              break a;
          }
      }
      return b2;
    }
    function g2(a2, b2) {
      var c2 = a2.sortIndex - b2.sortIndex;
      return c2 !== 0 ? c2 : a2.id - b2.id;
    }
    if (typeof performance === "object" && typeof performance.now === "function") {
      l2 = performance;
      exports.unstable_now = function() {
        return l2.now();
      };
    } else {
      p2 = Date, q = p2.now();
      exports.unstable_now = function() {
        return p2.now() - q;
      };
    }
    var l2;
    var p2;
    var q;
    var r2 = [];
    var t3 = [];
    var u2 = 1;
    var v2 = null;
    var y2 = 3;
    var z = false;
    var A2 = false;
    var B = false;
    var D2 = typeof setTimeout === "function" ? setTimeout : null;
    var E2 = typeof clearTimeout === "function" ? clearTimeout : null;
    var F2 = typeof setImmediate !== "undefined" ? setImmediate : null;
    typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 && navigator.scheduling.isInputPending.bind(navigator.scheduling);
    function G(a2) {
      for (var b2 = h2(t3); b2 !== null; ) {
        if (b2.callback === null)
          k2(t3);
        else if (b2.startTime <= a2)
          k2(t3), b2.sortIndex = b2.expirationTime, f2(r2, b2);
        else
          break;
        b2 = h2(t3);
      }
    }
    function H(a2) {
      B = false;
      G(a2);
      if (!A2)
        if (h2(r2) !== null)
          A2 = true, I2(J);
        else {
          var b2 = h2(t3);
          b2 !== null && K(H, b2.startTime - a2);
        }
    }
    function J(a2, b2) {
      A2 = false;
      B && (B = false, E2(L2), L2 = -1);
      z = true;
      var c2 = y2;
      try {
        G(b2);
        for (v2 = h2(r2); v2 !== null && (!(v2.expirationTime > b2) || a2 && !M2()); ) {
          var d2 = v2.callback;
          if (typeof d2 === "function") {
            v2.callback = null;
            y2 = v2.priorityLevel;
            var e2 = d2(v2.expirationTime <= b2);
            b2 = exports.unstable_now();
            typeof e2 === "function" ? v2.callback = e2 : v2 === h2(r2) && k2(r2);
            G(b2);
          } else
            k2(r2);
          v2 = h2(r2);
        }
        if (v2 !== null)
          var w2 = true;
        else {
          var m2 = h2(t3);
          m2 !== null && K(H, m2.startTime - b2);
          w2 = false;
        }
        return w2;
      } finally {
        v2 = null, y2 = c2, z = false;
      }
    }
    var N2 = false;
    var O2 = null;
    var L2 = -1;
    var P2 = 5;
    var Q = -1;
    function M2() {
      return exports.unstable_now() - Q < P2 ? false : true;
    }
    function R2() {
      if (O2 !== null) {
        var a2 = exports.unstable_now();
        Q = a2;
        var b2 = true;
        try {
          b2 = O2(true, a2);
        } finally {
          b2 ? S2() : (N2 = false, O2 = null);
        }
      } else
        N2 = false;
    }
    var S2;
    if (typeof F2 === "function")
      S2 = function() {
        F2(R2);
      };
    else if (typeof MessageChannel !== "undefined") {
      T2 = new MessageChannel(), U = T2.port2;
      T2.port1.onmessage = R2;
      S2 = function() {
        U.postMessage(null);
      };
    } else
      S2 = function() {
        D2(R2, 0);
      };
    var T2;
    var U;
    function I2(a2) {
      O2 = a2;
      N2 || (N2 = true, S2());
    }
    function K(a2, b2) {
      L2 = D2(function() {
        a2(exports.unstable_now());
      }, b2);
    }
    exports.unstable_IdlePriority = 5;
    exports.unstable_ImmediatePriority = 1;
    exports.unstable_LowPriority = 4;
    exports.unstable_NormalPriority = 3;
    exports.unstable_Profiling = null;
    exports.unstable_UserBlockingPriority = 2;
    exports.unstable_cancelCallback = function(a2) {
      a2.callback = null;
    };
    exports.unstable_continueExecution = function() {
      A2 || z || (A2 = true, I2(J));
    };
    exports.unstable_forceFrameRate = function(a2) {
      0 > a2 || 125 < a2 ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a2 ? Math.floor(1e3 / a2) : 5;
    };
    exports.unstable_getCurrentPriorityLevel = function() {
      return y2;
    };
    exports.unstable_getFirstCallbackNode = function() {
      return h2(r2);
    };
    exports.unstable_next = function(a2) {
      switch (y2) {
        case 1:
        case 2:
        case 3:
          var b2 = 3;
          break;
        default:
          b2 = y2;
      }
      var c2 = y2;
      y2 = b2;
      try {
        return a2();
      } finally {
        y2 = c2;
      }
    };
    exports.unstable_pauseExecution = function() {
    };
    exports.unstable_requestPaint = function() {
    };
    exports.unstable_runWithPriority = function(a2, b2) {
      switch (a2) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
          break;
        default:
          a2 = 3;
      }
      var c2 = y2;
      y2 = a2;
      try {
        return b2();
      } finally {
        y2 = c2;
      }
    };
    exports.unstable_scheduleCallback = function(a2, b2, c2) {
      var d2 = exports.unstable_now();
      typeof c2 === "object" && c2 !== null ? (c2 = c2.delay, c2 = typeof c2 === "number" && 0 < c2 ? d2 + c2 : d2) : c2 = d2;
      switch (a2) {
        case 1:
          var e2 = -1;
          break;
        case 2:
          e2 = 250;
          break;
        case 5:
          e2 = 1073741823;
          break;
        case 4:
          e2 = 1e4;
          break;
        default:
          e2 = 5e3;
      }
      e2 = c2 + e2;
      a2 = { id: u2++, callback: b2, priorityLevel: a2, startTime: c2, expirationTime: e2, sortIndex: -1 };
      c2 > d2 ? (a2.sortIndex = c2, f2(t3, a2), h2(r2) === null && a2 === h2(t3) && (B ? (E2(L2), L2 = -1) : B = true, K(H, c2 - d2))) : (a2.sortIndex = e2, f2(r2, a2), A2 || z || (A2 = true, I2(J)));
      return a2;
    };
    exports.unstable_shouldYield = M2;
    exports.unstable_wrapCallback = function(a2) {
      var b2 = y2;
      return function() {
        var c2 = y2;
        y2 = b2;
        try {
          return a2.apply(this, arguments);
        } finally {
          y2 = c2;
        }
      };
    };
  }
});

// node_modules/scheduler/index.js
var require_scheduler = __commonJS({
  "node_modules/scheduler/index.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_scheduler_production_min();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/react-dom/cjs/react-dom.production.min.js
var require_react_dom_production_min = __commonJS({
  "node_modules/react-dom/cjs/react-dom.production.min.js"(exports) {
    "use strict";
    var aa = require_react();
    var ca = require_scheduler();
    function p2(a2) {
      for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a2, c2 = 1; c2 < arguments.length; c2++)
        b2 += "&args[]=" + encodeURIComponent(arguments[c2]);
      return "Minified React error #" + a2 + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
    }
    var da = /* @__PURE__ */ new Set();
    var ea = {};
    function fa(a2, b2) {
      ha(a2, b2);
      ha(a2 + "Capture", b2);
    }
    function ha(a2, b2) {
      ea[a2] = b2;
      for (a2 = 0; a2 < b2.length; a2++)
        da.add(b2[a2]);
    }
    var ia = !(typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined");
    var ja = Object.prototype.hasOwnProperty;
    var ka = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/;
    var la = {};
    var ma = {};
    function oa(a2) {
      if (ja.call(ma, a2))
        return true;
      if (ja.call(la, a2))
        return false;
      if (ka.test(a2))
        return ma[a2] = true;
      la[a2] = true;
      return false;
    }
    function pa(a2, b2, c2, d2) {
      if (c2 !== null && c2.type === 0)
        return false;
      switch (typeof b2) {
        case "function":
        case "symbol":
          return true;
        case "boolean":
          if (d2)
            return false;
          if (c2 !== null)
            return !c2.acceptsBooleans;
          a2 = a2.toLowerCase().slice(0, 5);
          return a2 !== "data-" && a2 !== "aria-";
        default:
          return false;
      }
    }
    function qa(a2, b2, c2, d2) {
      if (b2 === null || typeof b2 === "undefined" || pa(a2, b2, c2, d2))
        return true;
      if (d2)
        return false;
      if (c2 !== null)
        switch (c2.type) {
          case 3:
            return !b2;
          case 4:
            return b2 === false;
          case 5:
            return isNaN(b2);
          case 6:
            return isNaN(b2) || 1 > b2;
        }
      return false;
    }
    function v2(a2, b2, c2, d2, e2, f2, g2) {
      this.acceptsBooleans = b2 === 2 || b2 === 3 || b2 === 4;
      this.attributeName = d2;
      this.attributeNamespace = e2;
      this.mustUseProperty = c2;
      this.propertyName = a2;
      this.type = b2;
      this.sanitizeURL = f2;
      this.removeEmptyString = g2;
    }
    var z = {};
    "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a2) {
      z[a2] = new v2(a2, 0, false, a2, null, false, false);
    });
    [["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a2) {
      var b2 = a2[0];
      z[b2] = new v2(b2, 1, false, a2[1], null, false, false);
    });
    ["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a2) {
      z[a2] = new v2(a2, 2, false, a2.toLowerCase(), null, false, false);
    });
    ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a2) {
      z[a2] = new v2(a2, 2, false, a2, null, false, false);
    });
    "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a2) {
      z[a2] = new v2(a2, 3, false, a2.toLowerCase(), null, false, false);
    });
    ["checked", "multiple", "muted", "selected"].forEach(function(a2) {
      z[a2] = new v2(a2, 3, true, a2, null, false, false);
    });
    ["capture", "download"].forEach(function(a2) {
      z[a2] = new v2(a2, 4, false, a2, null, false, false);
    });
    ["cols", "rows", "size", "span"].forEach(function(a2) {
      z[a2] = new v2(a2, 6, false, a2, null, false, false);
    });
    ["rowSpan", "start"].forEach(function(a2) {
      z[a2] = new v2(a2, 5, false, a2.toLowerCase(), null, false, false);
    });
    var ra = /[\-:]([a-z])/g;
    function sa(a2) {
      return a2[1].toUpperCase();
    }
    "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a2) {
      var b2 = a2.replace(ra, sa);
      z[b2] = new v2(b2, 1, false, a2, null, false, false);
    });
    "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a2) {
      var b2 = a2.replace(ra, sa);
      z[b2] = new v2(b2, 1, false, a2, "http://www.w3.org/1999/xlink", false, false);
    });
    ["xml:base", "xml:lang", "xml:space"].forEach(function(a2) {
      var b2 = a2.replace(ra, sa);
      z[b2] = new v2(b2, 1, false, a2, "http://www.w3.org/XML/1998/namespace", false, false);
    });
    ["tabIndex", "crossOrigin"].forEach(function(a2) {
      z[a2] = new v2(a2, 1, false, a2.toLowerCase(), null, false, false);
    });
    z.xlinkHref = new v2("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false);
    ["src", "href", "action", "formAction"].forEach(function(a2) {
      z[a2] = new v2(a2, 1, false, a2.toLowerCase(), null, true, true);
    });
    function ta(a2, b2, c2, d2) {
      var e2 = z.hasOwnProperty(b2) ? z[b2] : null;
      if (e2 !== null ? e2.type !== 0 : d2 || !(2 < b2.length) || b2[0] !== "o" && b2[0] !== "O" || b2[1] !== "n" && b2[1] !== "N")
        qa(b2, c2, e2, d2) && (c2 = null), d2 || e2 === null ? oa(b2) && (c2 === null ? a2.removeAttribute(b2) : a2.setAttribute(b2, "" + c2)) : e2.mustUseProperty ? a2[e2.propertyName] = c2 === null ? e2.type === 3 ? false : "" : c2 : (b2 = e2.attributeName, d2 = e2.attributeNamespace, c2 === null ? a2.removeAttribute(b2) : (e2 = e2.type, c2 = e2 === 3 || e2 === 4 && c2 === true ? "" : "" + c2, d2 ? a2.setAttributeNS(d2, b2, c2) : a2.setAttribute(b2, c2)));
    }
    var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
    var va = Symbol.for("react.element");
    var wa = Symbol.for("react.portal");
    var ya = Symbol.for("react.fragment");
    var za = Symbol.for("react.strict_mode");
    var Aa = Symbol.for("react.profiler");
    var Ba = Symbol.for("react.provider");
    var Ca = Symbol.for("react.context");
    var Da = Symbol.for("react.forward_ref");
    var Ea = Symbol.for("react.suspense");
    var Fa = Symbol.for("react.suspense_list");
    var Ga = Symbol.for("react.memo");
    var Ha = Symbol.for("react.lazy");
    Symbol.for("react.scope");
    Symbol.for("react.debug_trace_mode");
    var Ia = Symbol.for("react.offscreen");
    Symbol.for("react.legacy_hidden");
    Symbol.for("react.cache");
    Symbol.for("react.tracing_marker");
    var Ja = Symbol.iterator;
    function Ka(a2) {
      if (a2 === null || typeof a2 !== "object")
        return null;
      a2 = Ja && a2[Ja] || a2["@@iterator"];
      return typeof a2 === "function" ? a2 : null;
    }
    var A2 = Object.assign;
    var La;
    function Ma(a2) {
      if (La === void 0)
        try {
          throw Error();
        } catch (c2) {
          var b2 = c2.stack.trim().match(/\n( *(at )?)/);
          La = b2 && b2[1] || "";
        }
      return "\n" + La + a2;
    }
    var Na = false;
    function Oa(a2, b2) {
      if (!a2 || Na)
        return "";
      Na = true;
      var c2 = Error.prepareStackTrace;
      Error.prepareStackTrace = void 0;
      try {
        if (b2)
          if (b2 = function() {
            throw Error();
          }, Object.defineProperty(b2.prototype, "props", { set: function() {
            throw Error();
          } }), typeof Reflect === "object" && Reflect.construct) {
            try {
              Reflect.construct(b2, []);
            } catch (l2) {
              var d2 = l2;
            }
            Reflect.construct(a2, [], b2);
          } else {
            try {
              b2.call();
            } catch (l2) {
              d2 = l2;
            }
            a2.call(b2.prototype);
          }
        else {
          try {
            throw Error();
          } catch (l2) {
            d2 = l2;
          }
          a2();
        }
      } catch (l2) {
        if (l2 && d2 && typeof l2.stack === "string") {
          for (var e2 = l2.stack.split("\n"), f2 = d2.stack.split("\n"), g2 = e2.length - 1, h2 = f2.length - 1; 1 <= g2 && 0 <= h2 && e2[g2] !== f2[h2]; )
            h2--;
          for (; 1 <= g2 && 0 <= h2; g2--, h2--)
            if (e2[g2] !== f2[h2]) {
              if (g2 !== 1 || h2 !== 1) {
                do
                  if (g2--, h2--, 0 > h2 || e2[g2] !== f2[h2]) {
                    var k2 = "\n" + e2[g2].replace(" at new ", " at ");
                    a2.displayName && k2.includes("<anonymous>") && (k2 = k2.replace("<anonymous>", a2.displayName));
                    return k2;
                  }
                while (1 <= g2 && 0 <= h2);
              }
              break;
            }
        }
      } finally {
        Na = false, Error.prepareStackTrace = c2;
      }
      return (a2 = a2 ? a2.displayName || a2.name : "") ? Ma(a2) : "";
    }
    function Pa(a2) {
      switch (a2.tag) {
        case 5:
          return Ma(a2.type);
        case 16:
          return Ma("Lazy");
        case 13:
          return Ma("Suspense");
        case 19:
          return Ma("SuspenseList");
        case 0:
        case 2:
        case 15:
          return a2 = Oa(a2.type, false), a2;
        case 11:
          return a2 = Oa(a2.type.render, false), a2;
        case 1:
          return a2 = Oa(a2.type, true), a2;
        default:
          return "";
      }
    }
    function Qa(a2) {
      if (a2 == null)
        return null;
      if (typeof a2 === "function")
        return a2.displayName || a2.name || null;
      if (typeof a2 === "string")
        return a2;
      switch (a2) {
        case ya:
          return "Fragment";
        case wa:
          return "Portal";
        case Aa:
          return "Profiler";
        case za:
          return "StrictMode";
        case Ea:
          return "Suspense";
        case Fa:
          return "SuspenseList";
      }
      if (typeof a2 === "object")
        switch (a2.$$typeof) {
          case Ca:
            return (a2.displayName || "Context") + ".Consumer";
          case Ba:
            return (a2._context.displayName || "Context") + ".Provider";
          case Da:
            var b2 = a2.render;
            a2 = a2.displayName;
            a2 || (a2 = b2.displayName || b2.name || "", a2 = a2 !== "" ? "ForwardRef(" + a2 + ")" : "ForwardRef");
            return a2;
          case Ga:
            return b2 = a2.displayName || null, b2 !== null ? b2 : Qa(a2.type) || "Memo";
          case Ha:
            b2 = a2._payload;
            a2 = a2._init;
            try {
              return Qa(a2(b2));
            } catch (c2) {
            }
        }
      return null;
    }
    function Ra(a2) {
      var b2 = a2.type;
      switch (a2.tag) {
        case 24:
          return "Cache";
        case 9:
          return (b2.displayName || "Context") + ".Consumer";
        case 10:
          return (b2._context.displayName || "Context") + ".Provider";
        case 18:
          return "DehydratedFragment";
        case 11:
          return a2 = b2.render, a2 = a2.displayName || a2.name || "", b2.displayName || (a2 !== "" ? "ForwardRef(" + a2 + ")" : "ForwardRef");
        case 7:
          return "Fragment";
        case 5:
          return b2;
        case 4:
          return "Portal";
        case 3:
          return "Root";
        case 6:
          return "Text";
        case 16:
          return Qa(b2);
        case 8:
          return b2 === za ? "StrictMode" : "Mode";
        case 22:
          return "Offscreen";
        case 12:
          return "Profiler";
        case 21:
          return "Scope";
        case 13:
          return "Suspense";
        case 19:
          return "SuspenseList";
        case 25:
          return "TracingMarker";
        case 1:
        case 0:
        case 17:
        case 2:
        case 14:
        case 15:
          if (typeof b2 === "function")
            return b2.displayName || b2.name || null;
          if (typeof b2 === "string")
            return b2;
      }
      return null;
    }
    function Sa(a2) {
      switch (typeof a2) {
        case "boolean":
        case "number":
        case "string":
        case "undefined":
          return a2;
        case "object":
          return a2;
        default:
          return "";
      }
    }
    function Ta(a2) {
      var b2 = a2.type;
      return (a2 = a2.nodeName) && a2.toLowerCase() === "input" && (b2 === "checkbox" || b2 === "radio");
    }
    function Ua(a2) {
      var b2 = Ta(a2) ? "checked" : "value", c2 = Object.getOwnPropertyDescriptor(a2.constructor.prototype, b2), d2 = "" + a2[b2];
      if (!a2.hasOwnProperty(b2) && typeof c2 !== "undefined" && typeof c2.get === "function" && typeof c2.set === "function") {
        var e2 = c2.get, f2 = c2.set;
        Object.defineProperty(a2, b2, { configurable: true, get: function() {
          return e2.call(this);
        }, set: function(a3) {
          d2 = "" + a3;
          f2.call(this, a3);
        } });
        Object.defineProperty(a2, b2, { enumerable: c2.enumerable });
        return { getValue: function() {
          return d2;
        }, setValue: function(a3) {
          d2 = "" + a3;
        }, stopTracking: function() {
          a2._valueTracker = null;
          delete a2[b2];
        } };
      }
    }
    function Va(a2) {
      a2._valueTracker || (a2._valueTracker = Ua(a2));
    }
    function Wa(a2) {
      if (!a2)
        return false;
      var b2 = a2._valueTracker;
      if (!b2)
        return true;
      var c2 = b2.getValue();
      var d2 = "";
      a2 && (d2 = Ta(a2) ? a2.checked ? "true" : "false" : a2.value);
      a2 = d2;
      return a2 !== c2 ? (b2.setValue(a2), true) : false;
    }
    function Xa(a2) {
      a2 = a2 || (typeof document !== "undefined" ? document : void 0);
      if (typeof a2 === "undefined")
        return null;
      try {
        return a2.activeElement || a2.body;
      } catch (b2) {
        return a2.body;
      }
    }
    function Ya(a2, b2) {
      var c2 = b2.checked;
      return A2({}, b2, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: c2 != null ? c2 : a2._wrapperState.initialChecked });
    }
    function Za(a2, b2) {
      var c2 = b2.defaultValue == null ? "" : b2.defaultValue, d2 = b2.checked != null ? b2.checked : b2.defaultChecked;
      c2 = Sa(b2.value != null ? b2.value : c2);
      a2._wrapperState = { initialChecked: d2, initialValue: c2, controlled: b2.type === "checkbox" || b2.type === "radio" ? b2.checked != null : b2.value != null };
    }
    function ab(a2, b2) {
      b2 = b2.checked;
      b2 != null && ta(a2, "checked", b2, false);
    }
    function bb(a2, b2) {
      ab(a2, b2);
      var c2 = Sa(b2.value), d2 = b2.type;
      if (c2 != null)
        if (d2 === "number") {
          if (c2 === 0 && a2.value === "" || a2.value != c2)
            a2.value = "" + c2;
        } else
          a2.value !== "" + c2 && (a2.value = "" + c2);
      else if (d2 === "submit" || d2 === "reset") {
        a2.removeAttribute("value");
        return;
      }
      b2.hasOwnProperty("value") ? cb(a2, b2.type, c2) : b2.hasOwnProperty("defaultValue") && cb(a2, b2.type, Sa(b2.defaultValue));
      b2.checked == null && b2.defaultChecked != null && (a2.defaultChecked = !!b2.defaultChecked);
    }
    function db(a2, b2, c2) {
      if (b2.hasOwnProperty("value") || b2.hasOwnProperty("defaultValue")) {
        var d2 = b2.type;
        if (!(d2 !== "submit" && d2 !== "reset" || b2.value !== void 0 && b2.value !== null))
          return;
        b2 = "" + a2._wrapperState.initialValue;
        c2 || b2 === a2.value || (a2.value = b2);
        a2.defaultValue = b2;
      }
      c2 = a2.name;
      c2 !== "" && (a2.name = "");
      a2.defaultChecked = !!a2._wrapperState.initialChecked;
      c2 !== "" && (a2.name = c2);
    }
    function cb(a2, b2, c2) {
      if (b2 !== "number" || Xa(a2.ownerDocument) !== a2)
        c2 == null ? a2.defaultValue = "" + a2._wrapperState.initialValue : a2.defaultValue !== "" + c2 && (a2.defaultValue = "" + c2);
    }
    var eb = Array.isArray;
    function fb(a2, b2, c2, d2) {
      a2 = a2.options;
      if (b2) {
        b2 = {};
        for (var e2 = 0; e2 < c2.length; e2++)
          b2["$" + c2[e2]] = true;
        for (c2 = 0; c2 < a2.length; c2++)
          e2 = b2.hasOwnProperty("$" + a2[c2].value), a2[c2].selected !== e2 && (a2[c2].selected = e2), e2 && d2 && (a2[c2].defaultSelected = true);
      } else {
        c2 = "" + Sa(c2);
        b2 = null;
        for (e2 = 0; e2 < a2.length; e2++) {
          if (a2[e2].value === c2) {
            a2[e2].selected = true;
            d2 && (a2[e2].defaultSelected = true);
            return;
          }
          b2 !== null || a2[e2].disabled || (b2 = a2[e2]);
        }
        b2 !== null && (b2.selected = true);
      }
    }
    function gb(a2, b2) {
      if (b2.dangerouslySetInnerHTML != null)
        throw Error(p2(91));
      return A2({}, b2, { value: void 0, defaultValue: void 0, children: "" + a2._wrapperState.initialValue });
    }
    function hb(a2, b2) {
      var c2 = b2.value;
      if (c2 == null) {
        c2 = b2.children;
        b2 = b2.defaultValue;
        if (c2 != null) {
          if (b2 != null)
            throw Error(p2(92));
          if (eb(c2)) {
            if (1 < c2.length)
              throw Error(p2(93));
            c2 = c2[0];
          }
          b2 = c2;
        }
        b2 == null && (b2 = "");
        c2 = b2;
      }
      a2._wrapperState = { initialValue: Sa(c2) };
    }
    function ib(a2, b2) {
      var c2 = Sa(b2.value), d2 = Sa(b2.defaultValue);
      c2 != null && (c2 = "" + c2, c2 !== a2.value && (a2.value = c2), b2.defaultValue == null && a2.defaultValue !== c2 && (a2.defaultValue = c2));
      d2 != null && (a2.defaultValue = "" + d2);
    }
    function jb(a2) {
      var b2 = a2.textContent;
      b2 === a2._wrapperState.initialValue && b2 !== "" && b2 !== null && (a2.value = b2);
    }
    function kb(a2) {
      switch (a2) {
        case "svg":
          return "http://www.w3.org/2000/svg";
        case "math":
          return "http://www.w3.org/1998/Math/MathML";
        default:
          return "http://www.w3.org/1999/xhtml";
      }
    }
    function lb(a2, b2) {
      return a2 == null || a2 === "http://www.w3.org/1999/xhtml" ? kb(b2) : a2 === "http://www.w3.org/2000/svg" && b2 === "foreignObject" ? "http://www.w3.org/1999/xhtml" : a2;
    }
    var mb;
    var nb = function(a2) {
      return typeof MSApp !== "undefined" && MSApp.execUnsafeLocalFunction ? function(b2, c2, d2, e2) {
        MSApp.execUnsafeLocalFunction(function() {
          return a2(b2, c2, d2, e2);
        });
      } : a2;
    }(function(a2, b2) {
      if (a2.namespaceURI !== "http://www.w3.org/2000/svg" || "innerHTML" in a2)
        a2.innerHTML = b2;
      else {
        mb = mb || document.createElement("div");
        mb.innerHTML = "<svg>" + b2.valueOf().toString() + "</svg>";
        for (b2 = mb.firstChild; a2.firstChild; )
          a2.removeChild(a2.firstChild);
        for (; b2.firstChild; )
          a2.appendChild(b2.firstChild);
      }
    });
    function ob(a2, b2) {
      if (b2) {
        var c2 = a2.firstChild;
        if (c2 && c2 === a2.lastChild && c2.nodeType === 3) {
          c2.nodeValue = b2;
          return;
        }
      }
      a2.textContent = b2;
    }
    var pb = {
      animationIterationCount: true,
      aspectRatio: true,
      borderImageOutset: true,
      borderImageSlice: true,
      borderImageWidth: true,
      boxFlex: true,
      boxFlexGroup: true,
      boxOrdinalGroup: true,
      columnCount: true,
      columns: true,
      flex: true,
      flexGrow: true,
      flexPositive: true,
      flexShrink: true,
      flexNegative: true,
      flexOrder: true,
      gridArea: true,
      gridRow: true,
      gridRowEnd: true,
      gridRowSpan: true,
      gridRowStart: true,
      gridColumn: true,
      gridColumnEnd: true,
      gridColumnSpan: true,
      gridColumnStart: true,
      fontWeight: true,
      lineClamp: true,
      lineHeight: true,
      opacity: true,
      order: true,
      orphans: true,
      tabSize: true,
      widows: true,
      zIndex: true,
      zoom: true,
      fillOpacity: true,
      floodOpacity: true,
      stopOpacity: true,
      strokeDasharray: true,
      strokeDashoffset: true,
      strokeMiterlimit: true,
      strokeOpacity: true,
      strokeWidth: true
    };
    var qb = ["Webkit", "ms", "Moz", "O"];
    Object.keys(pb).forEach(function(a2) {
      qb.forEach(function(b2) {
        b2 = b2 + a2.charAt(0).toUpperCase() + a2.substring(1);
        pb[b2] = pb[a2];
      });
    });
    function rb(a2, b2, c2) {
      return b2 == null || typeof b2 === "boolean" || b2 === "" ? "" : c2 || typeof b2 !== "number" || b2 === 0 || pb.hasOwnProperty(a2) && pb[a2] ? ("" + b2).trim() : b2 + "px";
    }
    function sb(a2, b2) {
      a2 = a2.style;
      for (var c2 in b2)
        if (b2.hasOwnProperty(c2)) {
          var d2 = c2.indexOf("--") === 0, e2 = rb(c2, b2[c2], d2);
          c2 === "float" && (c2 = "cssFloat");
          d2 ? a2.setProperty(c2, e2) : a2[c2] = e2;
        }
    }
    var tb = A2({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true });
    function ub(a2, b2) {
      if (b2) {
        if (tb[a2] && (b2.children != null || b2.dangerouslySetInnerHTML != null))
          throw Error(p2(137, a2));
        if (b2.dangerouslySetInnerHTML != null) {
          if (b2.children != null)
            throw Error(p2(60));
          if (typeof b2.dangerouslySetInnerHTML !== "object" || !("__html" in b2.dangerouslySetInnerHTML))
            throw Error(p2(61));
        }
        if (b2.style != null && typeof b2.style !== "object")
          throw Error(p2(62));
      }
    }
    function vb(a2, b2) {
      if (a2.indexOf("-") === -1)
        return typeof b2.is === "string";
      switch (a2) {
        case "annotation-xml":
        case "color-profile":
        case "font-face":
        case "font-face-src":
        case "font-face-uri":
        case "font-face-format":
        case "font-face-name":
        case "missing-glyph":
          return false;
        default:
          return true;
      }
    }
    var wb = null;
    function xb(a2) {
      a2 = a2.target || a2.srcElement || window;
      a2.correspondingUseElement && (a2 = a2.correspondingUseElement);
      return a2.nodeType === 3 ? a2.parentNode : a2;
    }
    var yb = null;
    var zb = null;
    var Ab = null;
    function Bb(a2) {
      if (a2 = Cb(a2)) {
        if (typeof yb !== "function")
          throw Error(p2(280));
        var b2 = a2.stateNode;
        b2 && (b2 = Db(b2), yb(a2.stateNode, a2.type, b2));
      }
    }
    function Eb(a2) {
      zb ? Ab ? Ab.push(a2) : Ab = [a2] : zb = a2;
    }
    function Fb() {
      if (zb) {
        var a2 = zb, b2 = Ab;
        Ab = zb = null;
        Bb(a2);
        if (b2)
          for (a2 = 0; a2 < b2.length; a2++)
            Bb(b2[a2]);
      }
    }
    function Gb(a2, b2) {
      return a2(b2);
    }
    function Hb() {
    }
    var Ib = false;
    function Jb(a2, b2, c2) {
      if (Ib)
        return a2(b2, c2);
      Ib = true;
      try {
        return Gb(a2, b2, c2);
      } finally {
        if (Ib = false, zb !== null || Ab !== null)
          Hb(), Fb();
      }
    }
    function Kb(a2, b2) {
      var c2 = a2.stateNode;
      if (c2 === null)
        return null;
      var d2 = Db(c2);
      if (d2 === null)
        return null;
      c2 = d2[b2];
      a:
        switch (b2) {
          case "onClick":
          case "onClickCapture":
          case "onDoubleClick":
          case "onDoubleClickCapture":
          case "onMouseDown":
          case "onMouseDownCapture":
          case "onMouseMove":
          case "onMouseMoveCapture":
          case "onMouseUp":
          case "onMouseUpCapture":
          case "onMouseEnter":
            (d2 = !d2.disabled) || (a2 = a2.type, d2 = !(a2 === "button" || a2 === "input" || a2 === "select" || a2 === "textarea"));
            a2 = !d2;
            break a;
          default:
            a2 = false;
        }
      if (a2)
        return null;
      if (c2 && typeof c2 !== "function")
        throw Error(p2(231, b2, typeof c2));
      return c2;
    }
    var Lb = false;
    if (ia)
      try {
        Mb = {};
        Object.defineProperty(Mb, "passive", { get: function() {
          Lb = true;
        } });
        window.addEventListener("test", Mb, Mb);
        window.removeEventListener("test", Mb, Mb);
      } catch (a2) {
        Lb = false;
      }
    var Mb;
    function Nb(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
      var l2 = Array.prototype.slice.call(arguments, 3);
      try {
        b2.apply(c2, l2);
      } catch (m2) {
        this.onError(m2);
      }
    }
    var Ob = false;
    var Pb = null;
    var Qb = false;
    var Rb = null;
    var Sb = { onError: function(a2) {
      Ob = true;
      Pb = a2;
    } };
    function Tb(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
      Ob = false;
      Pb = null;
      Nb.apply(Sb, arguments);
    }
    function Ub(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
      Tb.apply(this, arguments);
      if (Ob) {
        if (Ob) {
          var l2 = Pb;
          Ob = false;
          Pb = null;
        } else
          throw Error(p2(198));
        Qb || (Qb = true, Rb = l2);
      }
    }
    function Vb(a2) {
      var b2 = a2, c2 = a2;
      if (a2.alternate)
        for (; b2.return; )
          b2 = b2.return;
      else {
        a2 = b2;
        do
          b2 = a2, (b2.flags & 4098) !== 0 && (c2 = b2.return), a2 = b2.return;
        while (a2);
      }
      return b2.tag === 3 ? c2 : null;
    }
    function Wb(a2) {
      if (a2.tag === 13) {
        var b2 = a2.memoizedState;
        b2 === null && (a2 = a2.alternate, a2 !== null && (b2 = a2.memoizedState));
        if (b2 !== null)
          return b2.dehydrated;
      }
      return null;
    }
    function Xb(a2) {
      if (Vb(a2) !== a2)
        throw Error(p2(188));
    }
    function Yb(a2) {
      var b2 = a2.alternate;
      if (!b2) {
        b2 = Vb(a2);
        if (b2 === null)
          throw Error(p2(188));
        return b2 !== a2 ? null : a2;
      }
      for (var c2 = a2, d2 = b2; ; ) {
        var e2 = c2.return;
        if (e2 === null)
          break;
        var f2 = e2.alternate;
        if (f2 === null) {
          d2 = e2.return;
          if (d2 !== null) {
            c2 = d2;
            continue;
          }
          break;
        }
        if (e2.child === f2.child) {
          for (f2 = e2.child; f2; ) {
            if (f2 === c2)
              return Xb(e2), a2;
            if (f2 === d2)
              return Xb(e2), b2;
            f2 = f2.sibling;
          }
          throw Error(p2(188));
        }
        if (c2.return !== d2.return)
          c2 = e2, d2 = f2;
        else {
          for (var g2 = false, h2 = e2.child; h2; ) {
            if (h2 === c2) {
              g2 = true;
              c2 = e2;
              d2 = f2;
              break;
            }
            if (h2 === d2) {
              g2 = true;
              d2 = e2;
              c2 = f2;
              break;
            }
            h2 = h2.sibling;
          }
          if (!g2) {
            for (h2 = f2.child; h2; ) {
              if (h2 === c2) {
                g2 = true;
                c2 = f2;
                d2 = e2;
                break;
              }
              if (h2 === d2) {
                g2 = true;
                d2 = f2;
                c2 = e2;
                break;
              }
              h2 = h2.sibling;
            }
            if (!g2)
              throw Error(p2(189));
          }
        }
        if (c2.alternate !== d2)
          throw Error(p2(190));
      }
      if (c2.tag !== 3)
        throw Error(p2(188));
      return c2.stateNode.current === c2 ? a2 : b2;
    }
    function Zb(a2) {
      a2 = Yb(a2);
      return a2 !== null ? $b(a2) : null;
    }
    function $b(a2) {
      if (a2.tag === 5 || a2.tag === 6)
        return a2;
      for (a2 = a2.child; a2 !== null; ) {
        var b2 = $b(a2);
        if (b2 !== null)
          return b2;
        a2 = a2.sibling;
      }
      return null;
    }
    var ac = ca.unstable_scheduleCallback;
    var bc = ca.unstable_cancelCallback;
    var cc = ca.unstable_shouldYield;
    var dc = ca.unstable_requestPaint;
    var B = ca.unstable_now;
    var ec = ca.unstable_getCurrentPriorityLevel;
    var fc = ca.unstable_ImmediatePriority;
    var gc = ca.unstable_UserBlockingPriority;
    var hc = ca.unstable_NormalPriority;
    var ic = ca.unstable_LowPriority;
    var jc = ca.unstable_IdlePriority;
    var kc = null;
    var lc = null;
    function mc(a2) {
      if (lc && typeof lc.onCommitFiberRoot === "function")
        try {
          lc.onCommitFiberRoot(kc, a2, void 0, (a2.current.flags & 128) === 128);
        } catch (b2) {
        }
    }
    var oc = Math.clz32 ? Math.clz32 : nc;
    var pc = Math.log;
    var qc = Math.LN2;
    function nc(a2) {
      a2 >>>= 0;
      return a2 === 0 ? 32 : 31 - (pc(a2) / qc | 0) | 0;
    }
    var rc = 64;
    var sc = 4194304;
    function tc(a2) {
      switch (a2 & -a2) {
        case 1:
          return 1;
        case 2:
          return 2;
        case 4:
          return 4;
        case 8:
          return 8;
        case 16:
          return 16;
        case 32:
          return 32;
        case 64:
        case 128:
        case 256:
        case 512:
        case 1024:
        case 2048:
        case 4096:
        case 8192:
        case 16384:
        case 32768:
        case 65536:
        case 131072:
        case 262144:
        case 524288:
        case 1048576:
        case 2097152:
          return a2 & 4194240;
        case 4194304:
        case 8388608:
        case 16777216:
        case 33554432:
        case 67108864:
          return a2 & 130023424;
        case 134217728:
          return 134217728;
        case 268435456:
          return 268435456;
        case 536870912:
          return 536870912;
        case 1073741824:
          return 1073741824;
        default:
          return a2;
      }
    }
    function uc(a2, b2) {
      var c2 = a2.pendingLanes;
      if (c2 === 0)
        return 0;
      var d2 = 0, e2 = a2.suspendedLanes, f2 = a2.pingedLanes, g2 = c2 & 268435455;
      if (g2 !== 0) {
        var h2 = g2 & ~e2;
        h2 !== 0 ? d2 = tc(h2) : (f2 &= g2, f2 !== 0 && (d2 = tc(f2)));
      } else
        g2 = c2 & ~e2, g2 !== 0 ? d2 = tc(g2) : f2 !== 0 && (d2 = tc(f2));
      if (d2 === 0)
        return 0;
      if (b2 !== 0 && b2 !== d2 && (b2 & e2) === 0 && (e2 = d2 & -d2, f2 = b2 & -b2, e2 >= f2 || e2 === 16 && (f2 & 4194240) !== 0))
        return b2;
      (d2 & 4) !== 0 && (d2 |= c2 & 16);
      b2 = a2.entangledLanes;
      if (b2 !== 0)
        for (a2 = a2.entanglements, b2 &= d2; 0 < b2; )
          c2 = 31 - oc(b2), e2 = 1 << c2, d2 |= a2[c2], b2 &= ~e2;
      return d2;
    }
    function vc(a2, b2) {
      switch (a2) {
        case 1:
        case 2:
        case 4:
          return b2 + 250;
        case 8:
        case 16:
        case 32:
        case 64:
        case 128:
        case 256:
        case 512:
        case 1024:
        case 2048:
        case 4096:
        case 8192:
        case 16384:
        case 32768:
        case 65536:
        case 131072:
        case 262144:
        case 524288:
        case 1048576:
        case 2097152:
          return b2 + 5e3;
        case 4194304:
        case 8388608:
        case 16777216:
        case 33554432:
        case 67108864:
          return -1;
        case 134217728:
        case 268435456:
        case 536870912:
        case 1073741824:
          return -1;
        default:
          return -1;
      }
    }
    function wc(a2, b2) {
      for (var c2 = a2.suspendedLanes, d2 = a2.pingedLanes, e2 = a2.expirationTimes, f2 = a2.pendingLanes; 0 < f2; ) {
        var g2 = 31 - oc(f2), h2 = 1 << g2, k2 = e2[g2];
        if (k2 === -1) {
          if ((h2 & c2) === 0 || (h2 & d2) !== 0)
            e2[g2] = vc(h2, b2);
        } else
          k2 <= b2 && (a2.expiredLanes |= h2);
        f2 &= ~h2;
      }
    }
    function xc(a2) {
      a2 = a2.pendingLanes & -1073741825;
      return a2 !== 0 ? a2 : a2 & 1073741824 ? 1073741824 : 0;
    }
    function yc() {
      var a2 = rc;
      rc <<= 1;
      (rc & 4194240) === 0 && (rc = 64);
      return a2;
    }
    function zc(a2) {
      for (var b2 = [], c2 = 0; 31 > c2; c2++)
        b2.push(a2);
      return b2;
    }
    function Ac(a2, b2, c2) {
      a2.pendingLanes |= b2;
      b2 !== 536870912 && (a2.suspendedLanes = 0, a2.pingedLanes = 0);
      a2 = a2.eventTimes;
      b2 = 31 - oc(b2);
      a2[b2] = c2;
    }
    function Bc(a2, b2) {
      var c2 = a2.pendingLanes & ~b2;
      a2.pendingLanes = b2;
      a2.suspendedLanes = 0;
      a2.pingedLanes = 0;
      a2.expiredLanes &= b2;
      a2.mutableReadLanes &= b2;
      a2.entangledLanes &= b2;
      b2 = a2.entanglements;
      var d2 = a2.eventTimes;
      for (a2 = a2.expirationTimes; 0 < c2; ) {
        var e2 = 31 - oc(c2), f2 = 1 << e2;
        b2[e2] = 0;
        d2[e2] = -1;
        a2[e2] = -1;
        c2 &= ~f2;
      }
    }
    function Cc(a2, b2) {
      var c2 = a2.entangledLanes |= b2;
      for (a2 = a2.entanglements; c2; ) {
        var d2 = 31 - oc(c2), e2 = 1 << d2;
        e2 & b2 | a2[d2] & b2 && (a2[d2] |= b2);
        c2 &= ~e2;
      }
    }
    var C2 = 0;
    function Dc(a2) {
      a2 &= -a2;
      return 1 < a2 ? 4 < a2 ? (a2 & 268435455) !== 0 ? 16 : 536870912 : 4 : 1;
    }
    var Ec;
    var Fc;
    var Gc;
    var Hc;
    var Ic;
    var Jc = false;
    var Kc = [];
    var Lc = null;
    var Mc = null;
    var Nc = null;
    var Oc = /* @__PURE__ */ new Map();
    var Pc = /* @__PURE__ */ new Map();
    var Qc = [];
    var Rc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");
    function Sc(a2, b2) {
      switch (a2) {
        case "focusin":
        case "focusout":
          Lc = null;
          break;
        case "dragenter":
        case "dragleave":
          Mc = null;
          break;
        case "mouseover":
        case "mouseout":
          Nc = null;
          break;
        case "pointerover":
        case "pointerout":
          Oc.delete(b2.pointerId);
          break;
        case "gotpointercapture":
        case "lostpointercapture":
          Pc.delete(b2.pointerId);
      }
    }
    function Tc(a2, b2, c2, d2, e2, f2) {
      if (a2 === null || a2.nativeEvent !== f2)
        return a2 = { blockedOn: b2, domEventName: c2, eventSystemFlags: d2, nativeEvent: f2, targetContainers: [e2] }, b2 !== null && (b2 = Cb(b2), b2 !== null && Fc(b2)), a2;
      a2.eventSystemFlags |= d2;
      b2 = a2.targetContainers;
      e2 !== null && b2.indexOf(e2) === -1 && b2.push(e2);
      return a2;
    }
    function Uc(a2, b2, c2, d2, e2) {
      switch (b2) {
        case "focusin":
          return Lc = Tc(Lc, a2, b2, c2, d2, e2), true;
        case "dragenter":
          return Mc = Tc(Mc, a2, b2, c2, d2, e2), true;
        case "mouseover":
          return Nc = Tc(Nc, a2, b2, c2, d2, e2), true;
        case "pointerover":
          var f2 = e2.pointerId;
          Oc.set(f2, Tc(Oc.get(f2) || null, a2, b2, c2, d2, e2));
          return true;
        case "gotpointercapture":
          return f2 = e2.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a2, b2, c2, d2, e2)), true;
      }
      return false;
    }
    function Vc(a2) {
      var b2 = Wc(a2.target);
      if (b2 !== null) {
        var c2 = Vb(b2);
        if (c2 !== null) {
          if (b2 = c2.tag, b2 === 13) {
            if (b2 = Wb(c2), b2 !== null) {
              a2.blockedOn = b2;
              Ic(a2.priority, function() {
                Gc(c2);
              });
              return;
            }
          } else if (b2 === 3 && c2.stateNode.current.memoizedState.isDehydrated) {
            a2.blockedOn = c2.tag === 3 ? c2.stateNode.containerInfo : null;
            return;
          }
        }
      }
      a2.blockedOn = null;
    }
    function Xc(a2) {
      if (a2.blockedOn !== null)
        return false;
      for (var b2 = a2.targetContainers; 0 < b2.length; ) {
        var c2 = Yc(a2.domEventName, a2.eventSystemFlags, b2[0], a2.nativeEvent);
        if (c2 === null) {
          c2 = a2.nativeEvent;
          var d2 = new c2.constructor(c2.type, c2);
          wb = d2;
          c2.target.dispatchEvent(d2);
          wb = null;
        } else
          return b2 = Cb(c2), b2 !== null && Fc(b2), a2.blockedOn = c2, false;
        b2.shift();
      }
      return true;
    }
    function Zc(a2, b2, c2) {
      Xc(a2) && c2.delete(b2);
    }
    function $c() {
      Jc = false;
      Lc !== null && Xc(Lc) && (Lc = null);
      Mc !== null && Xc(Mc) && (Mc = null);
      Nc !== null && Xc(Nc) && (Nc = null);
      Oc.forEach(Zc);
      Pc.forEach(Zc);
    }
    function ad(a2, b2) {
      a2.blockedOn === b2 && (a2.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c)));
    }
    function bd(a2) {
      function b2(b3) {
        return ad(b3, a2);
      }
      if (0 < Kc.length) {
        ad(Kc[0], a2);
        for (var c2 = 1; c2 < Kc.length; c2++) {
          var d2 = Kc[c2];
          d2.blockedOn === a2 && (d2.blockedOn = null);
        }
      }
      Lc !== null && ad(Lc, a2);
      Mc !== null && ad(Mc, a2);
      Nc !== null && ad(Nc, a2);
      Oc.forEach(b2);
      Pc.forEach(b2);
      for (c2 = 0; c2 < Qc.length; c2++)
        d2 = Qc[c2], d2.blockedOn === a2 && (d2.blockedOn = null);
      for (; 0 < Qc.length && (c2 = Qc[0], c2.blockedOn === null); )
        Vc(c2), c2.blockedOn === null && Qc.shift();
    }
    var cd = ua.ReactCurrentBatchConfig;
    var dd = true;
    function ed(a2, b2, c2, d2) {
      var e2 = C2, f2 = cd.transition;
      cd.transition = null;
      try {
        C2 = 1, fd(a2, b2, c2, d2);
      } finally {
        C2 = e2, cd.transition = f2;
      }
    }
    function gd(a2, b2, c2, d2) {
      var e2 = C2, f2 = cd.transition;
      cd.transition = null;
      try {
        C2 = 4, fd(a2, b2, c2, d2);
      } finally {
        C2 = e2, cd.transition = f2;
      }
    }
    function fd(a2, b2, c2, d2) {
      if (dd) {
        var e2 = Yc(a2, b2, c2, d2);
        if (e2 === null)
          hd(a2, b2, d2, id, c2), Sc(a2, d2);
        else if (Uc(e2, a2, b2, c2, d2))
          d2.stopPropagation();
        else if (Sc(a2, d2), b2 & 4 && -1 < Rc.indexOf(a2)) {
          for (; e2 !== null; ) {
            var f2 = Cb(e2);
            f2 !== null && Ec(f2);
            f2 = Yc(a2, b2, c2, d2);
            f2 === null && hd(a2, b2, d2, id, c2);
            if (f2 === e2)
              break;
            e2 = f2;
          }
          e2 !== null && d2.stopPropagation();
        } else
          hd(a2, b2, d2, null, c2);
      }
    }
    var id = null;
    function Yc(a2, b2, c2, d2) {
      id = null;
      a2 = xb(d2);
      a2 = Wc(a2);
      if (a2 !== null)
        if (b2 = Vb(a2), b2 === null)
          a2 = null;
        else if (c2 = b2.tag, c2 === 13) {
          a2 = Wb(b2);
          if (a2 !== null)
            return a2;
          a2 = null;
        } else if (c2 === 3) {
          if (b2.stateNode.current.memoizedState.isDehydrated)
            return b2.tag === 3 ? b2.stateNode.containerInfo : null;
          a2 = null;
        } else
          b2 !== a2 && (a2 = null);
      id = a2;
      return null;
    }
    function jd(a2) {
      switch (a2) {
        case "cancel":
        case "click":
        case "close":
        case "contextmenu":
        case "copy":
        case "cut":
        case "auxclick":
        case "dblclick":
        case "dragend":
        case "dragstart":
        case "drop":
        case "focusin":
        case "focusout":
        case "input":
        case "invalid":
        case "keydown":
        case "keypress":
        case "keyup":
        case "mousedown":
        case "mouseup":
        case "paste":
        case "pause":
        case "play":
        case "pointercancel":
        case "pointerdown":
        case "pointerup":
        case "ratechange":
        case "reset":
        case "resize":
        case "seeked":
        case "submit":
        case "touchcancel":
        case "touchend":
        case "touchstart":
        case "volumechange":
        case "change":
        case "selectionchange":
        case "textInput":
        case "compositionstart":
        case "compositionend":
        case "compositionupdate":
        case "beforeblur":
        case "afterblur":
        case "beforeinput":
        case "blur":
        case "fullscreenchange":
        case "focus":
        case "hashchange":
        case "popstate":
        case "select":
        case "selectstart":
          return 1;
        case "drag":
        case "dragenter":
        case "dragexit":
        case "dragleave":
        case "dragover":
        case "mousemove":
        case "mouseout":
        case "mouseover":
        case "pointermove":
        case "pointerout":
        case "pointerover":
        case "scroll":
        case "toggle":
        case "touchmove":
        case "wheel":
        case "mouseenter":
        case "mouseleave":
        case "pointerenter":
        case "pointerleave":
          return 4;
        case "message":
          switch (ec()) {
            case fc:
              return 1;
            case gc:
              return 4;
            case hc:
            case ic:
              return 16;
            case jc:
              return 536870912;
            default:
              return 16;
          }
        default:
          return 16;
      }
    }
    var kd = null;
    var ld = null;
    var md = null;
    function nd() {
      if (md)
        return md;
      var a2, b2 = ld, c2 = b2.length, d2, e2 = "value" in kd ? kd.value : kd.textContent, f2 = e2.length;
      for (a2 = 0; a2 < c2 && b2[a2] === e2[a2]; a2++)
        ;
      var g2 = c2 - a2;
      for (d2 = 1; d2 <= g2 && b2[c2 - d2] === e2[f2 - d2]; d2++)
        ;
      return md = e2.slice(a2, 1 < d2 ? 1 - d2 : void 0);
    }
    function od(a2) {
      var b2 = a2.keyCode;
      "charCode" in a2 ? (a2 = a2.charCode, a2 === 0 && b2 === 13 && (a2 = 13)) : a2 = b2;
      a2 === 10 && (a2 = 13);
      return 32 <= a2 || a2 === 13 ? a2 : 0;
    }
    function pd() {
      return true;
    }
    function qd() {
      return false;
    }
    function rd(a2) {
      function b2(b3, d2, e2, f2, g2) {
        this._reactName = b3;
        this._targetInst = e2;
        this.type = d2;
        this.nativeEvent = f2;
        this.target = g2;
        this.currentTarget = null;
        for (var c2 in a2)
          a2.hasOwnProperty(c2) && (b3 = a2[c2], this[c2] = b3 ? b3(f2) : f2[c2]);
        this.isDefaultPrevented = (f2.defaultPrevented != null ? f2.defaultPrevented : f2.returnValue === false) ? pd : qd;
        this.isPropagationStopped = qd;
        return this;
      }
      A2(b2.prototype, { preventDefault: function() {
        this.defaultPrevented = true;
        var a3 = this.nativeEvent;
        a3 && (a3.preventDefault ? a3.preventDefault() : typeof a3.returnValue !== "unknown" && (a3.returnValue = false), this.isDefaultPrevented = pd);
      }, stopPropagation: function() {
        var a3 = this.nativeEvent;
        a3 && (a3.stopPropagation ? a3.stopPropagation() : typeof a3.cancelBubble !== "unknown" && (a3.cancelBubble = true), this.isPropagationStopped = pd);
      }, persist: function() {
      }, isPersistent: pd });
      return b2;
    }
    var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a2) {
      return a2.timeStamp || Date.now();
    }, defaultPrevented: 0, isTrusted: 0 };
    var td = rd(sd);
    var ud = A2({}, sd, { view: 0, detail: 0 });
    var vd = rd(ud);
    var wd;
    var xd;
    var yd;
    var Ad = A2({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a2) {
      return a2.relatedTarget === void 0 ? a2.fromElement === a2.srcElement ? a2.toElement : a2.fromElement : a2.relatedTarget;
    }, movementX: function(a2) {
      if ("movementX" in a2)
        return a2.movementX;
      a2 !== yd && (yd && a2.type === "mousemove" ? (wd = a2.screenX - yd.screenX, xd = a2.screenY - yd.screenY) : xd = wd = 0, yd = a2);
      return wd;
    }, movementY: function(a2) {
      return "movementY" in a2 ? a2.movementY : xd;
    } });
    var Bd = rd(Ad);
    var Cd = A2({}, Ad, { dataTransfer: 0 });
    var Dd = rd(Cd);
    var Ed = A2({}, ud, { relatedTarget: 0 });
    var Fd = rd(Ed);
    var Gd = A2({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 });
    var Hd = rd(Gd);
    var Id = A2({}, sd, { clipboardData: function(a2) {
      return "clipboardData" in a2 ? a2.clipboardData : window.clipboardData;
    } });
    var Jd = rd(Id);
    var Kd = A2({}, sd, { data: 0 });
    var Ld = rd(Kd);
    var Md = {
      Esc: "Escape",
      Spacebar: " ",
      Left: "ArrowLeft",
      Up: "ArrowUp",
      Right: "ArrowRight",
      Down: "ArrowDown",
      Del: "Delete",
      Win: "OS",
      Menu: "ContextMenu",
      Apps: "ContextMenu",
      Scroll: "ScrollLock",
      MozPrintableKey: "Unidentified"
    };
    var Nd = {
      8: "Backspace",
      9: "Tab",
      12: "Clear",
      13: "Enter",
      16: "Shift",
      17: "Control",
      18: "Alt",
      19: "Pause",
      20: "CapsLock",
      27: "Escape",
      32: " ",
      33: "PageUp",
      34: "PageDown",
      35: "End",
      36: "Home",
      37: "ArrowLeft",
      38: "ArrowUp",
      39: "ArrowRight",
      40: "ArrowDown",
      45: "Insert",
      46: "Delete",
      112: "F1",
      113: "F2",
      114: "F3",
      115: "F4",
      116: "F5",
      117: "F6",
      118: "F7",
      119: "F8",
      120: "F9",
      121: "F10",
      122: "F11",
      123: "F12",
      144: "NumLock",
      145: "ScrollLock",
      224: "Meta"
    };
    var Od = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" };
    function Pd(a2) {
      var b2 = this.nativeEvent;
      return b2.getModifierState ? b2.getModifierState(a2) : (a2 = Od[a2]) ? !!b2[a2] : false;
    }
    function zd() {
      return Pd;
    }
    var Qd = A2({}, ud, { key: function(a2) {
      if (a2.key) {
        var b2 = Md[a2.key] || a2.key;
        if (b2 !== "Unidentified")
          return b2;
      }
      return a2.type === "keypress" ? (a2 = od(a2), a2 === 13 ? "Enter" : String.fromCharCode(a2)) : a2.type === "keydown" || a2.type === "keyup" ? Nd[a2.keyCode] || "Unidentified" : "";
    }, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a2) {
      return a2.type === "keypress" ? od(a2) : 0;
    }, keyCode: function(a2) {
      return a2.type === "keydown" || a2.type === "keyup" ? a2.keyCode : 0;
    }, which: function(a2) {
      return a2.type === "keypress" ? od(a2) : a2.type === "keydown" || a2.type === "keyup" ? a2.keyCode : 0;
    } });
    var Rd = rd(Qd);
    var Sd = A2({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 });
    var Td = rd(Sd);
    var Ud = A2({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd });
    var Vd = rd(Ud);
    var Wd = A2({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 });
    var Xd = rd(Wd);
    var Yd = A2({}, Ad, {
      deltaX: function(a2) {
        return "deltaX" in a2 ? a2.deltaX : "wheelDeltaX" in a2 ? -a2.wheelDeltaX : 0;
      },
      deltaY: function(a2) {
        return "deltaY" in a2 ? a2.deltaY : "wheelDeltaY" in a2 ? -a2.wheelDeltaY : "wheelDelta" in a2 ? -a2.wheelDelta : 0;
      },
      deltaZ: 0,
      deltaMode: 0
    });
    var Zd = rd(Yd);
    var $d = [9, 13, 27, 32];
    var ae = ia && "CompositionEvent" in window;
    var be = null;
    ia && "documentMode" in document && (be = document.documentMode);
    var ce = ia && "TextEvent" in window && !be;
    var de = ia && (!ae || be && 8 < be && 11 >= be);
    var ee2 = String.fromCharCode(32);
    var fe = false;
    function ge(a2, b2) {
      switch (a2) {
        case "keyup":
          return $d.indexOf(b2.keyCode) !== -1;
        case "keydown":
          return b2.keyCode !== 229;
        case "keypress":
        case "mousedown":
        case "focusout":
          return true;
        default:
          return false;
      }
    }
    function he(a2) {
      a2 = a2.detail;
      return typeof a2 === "object" && "data" in a2 ? a2.data : null;
    }
    var ie = false;
    function je(a2, b2) {
      switch (a2) {
        case "compositionend":
          return he(b2);
        case "keypress":
          if (b2.which !== 32)
            return null;
          fe = true;
          return ee2;
        case "textInput":
          return a2 = b2.data, a2 === ee2 && fe ? null : a2;
        default:
          return null;
      }
    }
    function ke(a2, b2) {
      if (ie)
        return a2 === "compositionend" || !ae && ge(a2, b2) ? (a2 = nd(), md = ld = kd = null, ie = false, a2) : null;
      switch (a2) {
        case "paste":
          return null;
        case "keypress":
          if (!(b2.ctrlKey || b2.altKey || b2.metaKey) || b2.ctrlKey && b2.altKey) {
            if (b2.char && 1 < b2.char.length)
              return b2.char;
            if (b2.which)
              return String.fromCharCode(b2.which);
          }
          return null;
        case "compositionend":
          return de && b2.locale !== "ko" ? null : b2.data;
        default:
          return null;
      }
    }
    var le = { color: true, date: true, datetime: true, "datetime-local": true, email: true, month: true, number: true, password: true, range: true, search: true, tel: true, text: true, time: true, url: true, week: true };
    function me(a2) {
      var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase();
      return b2 === "input" ? !!le[a2.type] : b2 === "textarea" ? true : false;
    }
    function ne2(a2, b2, c2, d2) {
      Eb(d2);
      b2 = oe(b2, "onChange");
      0 < b2.length && (c2 = new td("onChange", "change", null, c2, d2), a2.push({ event: c2, listeners: b2 }));
    }
    var pe = null;
    var qe = null;
    function re2(a2) {
      se(a2, 0);
    }
    function te2(a2) {
      var b2 = ue(a2);
      if (Wa(b2))
        return a2;
    }
    function ve(a2, b2) {
      if (a2 === "change")
        return b2;
    }
    var we = false;
    if (ia) {
      if (ia) {
        ye = "oninput" in document;
        if (!ye) {
          ze = document.createElement("div");
          ze.setAttribute("oninput", "return;");
          ye = typeof ze.oninput === "function";
        }
        xe = ye;
      } else
        xe = false;
      we = xe && (!document.documentMode || 9 < document.documentMode);
    }
    var xe;
    var ye;
    var ze;
    function Ae() {
      pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null);
    }
    function Be(a2) {
      if (a2.propertyName === "value" && te2(qe)) {
        var b2 = [];
        ne2(b2, qe, a2, xb(a2));
        Jb(re2, b2);
      }
    }
    function Ce(a2, b2, c2) {
      a2 === "focusin" ? (Ae(), pe = b2, qe = c2, pe.attachEvent("onpropertychange", Be)) : a2 === "focusout" && Ae();
    }
    function De(a2) {
      if (a2 === "selectionchange" || a2 === "keyup" || a2 === "keydown")
        return te2(qe);
    }
    function Ee(a2, b2) {
      if (a2 === "click")
        return te2(b2);
    }
    function Fe(a2, b2) {
      if (a2 === "input" || a2 === "change")
        return te2(b2);
    }
    function Ge(a2, b2) {
      return a2 === b2 && (a2 !== 0 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
    }
    var He = typeof Object.is === "function" ? Object.is : Ge;
    function Ie(a2, b2) {
      if (He(a2, b2))
        return true;
      if (typeof a2 !== "object" || a2 === null || typeof b2 !== "object" || b2 === null)
        return false;
      var c2 = Object.keys(a2), d2 = Object.keys(b2);
      if (c2.length !== d2.length)
        return false;
      for (d2 = 0; d2 < c2.length; d2++) {
        var e2 = c2[d2];
        if (!ja.call(b2, e2) || !He(a2[e2], b2[e2]))
          return false;
      }
      return true;
    }
    function Je(a2) {
      for (; a2 && a2.firstChild; )
        a2 = a2.firstChild;
      return a2;
    }
    function Ke(a2, b2) {
      var c2 = Je(a2);
      a2 = 0;
      for (var d2; c2; ) {
        if (c2.nodeType === 3) {
          d2 = a2 + c2.textContent.length;
          if (a2 <= b2 && d2 >= b2)
            return { node: c2, offset: b2 - a2 };
          a2 = d2;
        }
        a: {
          for (; c2; ) {
            if (c2.nextSibling) {
              c2 = c2.nextSibling;
              break a;
            }
            c2 = c2.parentNode;
          }
          c2 = void 0;
        }
        c2 = Je(c2);
      }
    }
    function Le(a2, b2) {
      return a2 && b2 ? a2 === b2 ? true : a2 && a2.nodeType === 3 ? false : b2 && b2.nodeType === 3 ? Le(a2, b2.parentNode) : "contains" in a2 ? a2.contains(b2) : a2.compareDocumentPosition ? !!(a2.compareDocumentPosition(b2) & 16) : false : false;
    }
    function Me() {
      for (var a2 = window, b2 = Xa(); b2 instanceof a2.HTMLIFrameElement; ) {
        try {
          var c2 = typeof b2.contentWindow.location.href === "string";
        } catch (d2) {
          c2 = false;
        }
        if (c2)
          a2 = b2.contentWindow;
        else
          break;
        b2 = Xa(a2.document);
      }
      return b2;
    }
    function Ne(a2) {
      var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase();
      return b2 && (b2 === "input" && (a2.type === "text" || a2.type === "search" || a2.type === "tel" || a2.type === "url" || a2.type === "password") || b2 === "textarea" || a2.contentEditable === "true");
    }
    function Oe(a2) {
      var b2 = Me(), c2 = a2.focusedElem, d2 = a2.selectionRange;
      if (b2 !== c2 && c2 && c2.ownerDocument && Le(c2.ownerDocument.documentElement, c2)) {
        if (d2 !== null && Ne(c2)) {
          if (b2 = d2.start, a2 = d2.end, a2 === void 0 && (a2 = b2), "selectionStart" in c2)
            c2.selectionStart = b2, c2.selectionEnd = Math.min(a2, c2.value.length);
          else if (a2 = (b2 = c2.ownerDocument || document) && b2.defaultView || window, a2.getSelection) {
            a2 = a2.getSelection();
            var e2 = c2.textContent.length, f2 = Math.min(d2.start, e2);
            d2 = d2.end === void 0 ? f2 : Math.min(d2.end, e2);
            !a2.extend && f2 > d2 && (e2 = d2, d2 = f2, f2 = e2);
            e2 = Ke(c2, f2);
            var g2 = Ke(c2, d2);
            e2 && g2 && (a2.rangeCount !== 1 || a2.anchorNode !== e2.node || a2.anchorOffset !== e2.offset || a2.focusNode !== g2.node || a2.focusOffset !== g2.offset) && (b2 = b2.createRange(), b2.setStart(e2.node, e2.offset), a2.removeAllRanges(), f2 > d2 ? (a2.addRange(b2), a2.extend(g2.node, g2.offset)) : (b2.setEnd(g2.node, g2.offset), a2.addRange(b2)));
          }
        }
        b2 = [];
        for (a2 = c2; a2 = a2.parentNode; )
          a2.nodeType === 1 && b2.push({ element: a2, left: a2.scrollLeft, top: a2.scrollTop });
        typeof c2.focus === "function" && c2.focus();
        for (c2 = 0; c2 < b2.length; c2++)
          a2 = b2[c2], a2.element.scrollLeft = a2.left, a2.element.scrollTop = a2.top;
      }
    }
    var Pe = ia && "documentMode" in document && 11 >= document.documentMode;
    var Qe = null;
    var Re = null;
    var Se = null;
    var Te = false;
    function Ue(a2, b2, c2) {
      var d2 = c2.window === c2 ? c2.document : c2.nodeType === 9 ? c2 : c2.ownerDocument;
      Te || Qe == null || Qe !== Xa(d2) || (d2 = Qe, "selectionStart" in d2 && Ne(d2) ? d2 = { start: d2.selectionStart, end: d2.selectionEnd } : (d2 = (d2.ownerDocument && d2.ownerDocument.defaultView || window).getSelection(), d2 = { anchorNode: d2.anchorNode, anchorOffset: d2.anchorOffset, focusNode: d2.focusNode, focusOffset: d2.focusOffset }), Se && Ie(Se, d2) || (Se = d2, d2 = oe(Re, "onSelect"), 0 < d2.length && (b2 = new td("onSelect", "select", null, b2, c2), a2.push({ event: b2, listeners: d2 }), b2.target = Qe)));
    }
    function Ve(a2, b2) {
      var c2 = {};
      c2[a2.toLowerCase()] = b2.toLowerCase();
      c2["Webkit" + a2] = "webkit" + b2;
      c2["Moz" + a2] = "moz" + b2;
      return c2;
    }
    var We = { animationend: Ve("Animation", "AnimationEnd"), animationiteration: Ve("Animation", "AnimationIteration"), animationstart: Ve("Animation", "AnimationStart"), transitionend: Ve("Transition", "TransitionEnd") };
    var Xe = {};
    var Ye = {};
    ia && (Ye = document.createElement("div").style, "AnimationEvent" in window || (delete We.animationend.animation, delete We.animationiteration.animation, delete We.animationstart.animation), "TransitionEvent" in window || delete We.transitionend.transition);
    function Ze(a2) {
      if (Xe[a2])
        return Xe[a2];
      if (!We[a2])
        return a2;
      var b2 = We[a2], c2;
      for (c2 in b2)
        if (b2.hasOwnProperty(c2) && c2 in Ye)
          return Xe[a2] = b2[c2];
      return a2;
    }
    var $e = Ze("animationend");
    var af = Ze("animationiteration");
    var bf = Ze("animationstart");
    var cf = Ze("transitionend");
    var df = /* @__PURE__ */ new Map();
    var ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
    function ff(a2, b2) {
      df.set(a2, b2);
      fa(b2, [a2]);
    }
    for (gf = 0; gf < ef.length; gf++) {
      hf = ef[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1);
      ff(jf, "on" + kf);
    }
    var hf;
    var jf;
    var kf;
    var gf;
    ff($e, "onAnimationEnd");
    ff(af, "onAnimationIteration");
    ff(bf, "onAnimationStart");
    ff("dblclick", "onDoubleClick");
    ff("focusin", "onFocus");
    ff("focusout", "onBlur");
    ff(cf, "onTransitionEnd");
    ha("onMouseEnter", ["mouseout", "mouseover"]);
    ha("onMouseLeave", ["mouseout", "mouseover"]);
    ha("onPointerEnter", ["pointerout", "pointerover"]);
    ha("onPointerLeave", ["pointerout", "pointerover"]);
    fa("onChange", "change click focusin focusout input keydown keyup selectionchange".split(" "));
    fa("onSelect", "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));
    fa("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]);
    fa("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown".split(" "));
    fa("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" "));
    fa("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" "));
    var lf = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" ");
    var mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf));
    function nf(a2, b2, c2) {
      var d2 = a2.type || "unknown-event";
      a2.currentTarget = c2;
      Ub(d2, b2, void 0, a2);
      a2.currentTarget = null;
    }
    function se(a2, b2) {
      b2 = (b2 & 4) !== 0;
      for (var c2 = 0; c2 < a2.length; c2++) {
        var d2 = a2[c2], e2 = d2.event;
        d2 = d2.listeners;
        a: {
          var f2 = void 0;
          if (b2)
            for (var g2 = d2.length - 1; 0 <= g2; g2--) {
              var h2 = d2[g2], k2 = h2.instance, l2 = h2.currentTarget;
              h2 = h2.listener;
              if (k2 !== f2 && e2.isPropagationStopped())
                break a;
              nf(e2, h2, l2);
              f2 = k2;
            }
          else
            for (g2 = 0; g2 < d2.length; g2++) {
              h2 = d2[g2];
              k2 = h2.instance;
              l2 = h2.currentTarget;
              h2 = h2.listener;
              if (k2 !== f2 && e2.isPropagationStopped())
                break a;
              nf(e2, h2, l2);
              f2 = k2;
            }
        }
      }
      if (Qb)
        throw a2 = Rb, Qb = false, Rb = null, a2;
    }
    function D2(a2, b2) {
      var c2 = b2[of];
      c2 === void 0 && (c2 = b2[of] = /* @__PURE__ */ new Set());
      var d2 = a2 + "__bubble";
      c2.has(d2) || (pf(b2, a2, 2, false), c2.add(d2));
    }
    function qf(a2, b2, c2) {
      var d2 = 0;
      b2 && (d2 |= 4);
      pf(c2, a2, d2, b2);
    }
    var rf = "_reactListening" + Math.random().toString(36).slice(2);
    function sf(a2) {
      if (!a2[rf]) {
        a2[rf] = true;
        da.forEach(function(b3) {
          b3 !== "selectionchange" && (mf.has(b3) || qf(b3, false, a2), qf(b3, true, a2));
        });
        var b2 = a2.nodeType === 9 ? a2 : a2.ownerDocument;
        b2 === null || b2[rf] || (b2[rf] = true, qf("selectionchange", false, b2));
      }
    }
    function pf(a2, b2, c2, d2) {
      switch (jd(b2)) {
        case 1:
          var e2 = ed;
          break;
        case 4:
          e2 = gd;
          break;
        default:
          e2 = fd;
      }
      c2 = e2.bind(null, b2, c2, a2);
      e2 = void 0;
      !Lb || b2 !== "touchstart" && b2 !== "touchmove" && b2 !== "wheel" || (e2 = true);
      d2 ? e2 !== void 0 ? a2.addEventListener(b2, c2, { capture: true, passive: e2 }) : a2.addEventListener(b2, c2, true) : e2 !== void 0 ? a2.addEventListener(b2, c2, { passive: e2 }) : a2.addEventListener(b2, c2, false);
    }
    function hd(a2, b2, c2, d2, e2) {
      var f2 = d2;
      if ((b2 & 1) === 0 && (b2 & 2) === 0 && d2 !== null)
        a:
          for (; ; ) {
            if (d2 === null)
              return;
            var g2 = d2.tag;
            if (g2 === 3 || g2 === 4) {
              var h2 = d2.stateNode.containerInfo;
              if (h2 === e2 || h2.nodeType === 8 && h2.parentNode === e2)
                break;
              if (g2 === 4)
                for (g2 = d2.return; g2 !== null; ) {
                  var k2 = g2.tag;
                  if (k2 === 3 || k2 === 4) {
                    if (k2 = g2.stateNode.containerInfo, k2 === e2 || k2.nodeType === 8 && k2.parentNode === e2)
                      return;
                  }
                  g2 = g2.return;
                }
              for (; h2 !== null; ) {
                g2 = Wc(h2);
                if (g2 === null)
                  return;
                k2 = g2.tag;
                if (k2 === 5 || k2 === 6) {
                  d2 = f2 = g2;
                  continue a;
                }
                h2 = h2.parentNode;
              }
            }
            d2 = d2.return;
          }
      Jb(function() {
        var d3 = f2, e3 = xb(c2), g3 = [];
        a: {
          var h3 = df.get(a2);
          if (h3 !== void 0) {
            var k3 = td, n2 = a2;
            switch (a2) {
              case "keypress":
                if (od(c2) === 0)
                  break a;
              case "keydown":
              case "keyup":
                k3 = Rd;
                break;
              case "focusin":
                n2 = "focus";
                k3 = Fd;
                break;
              case "focusout":
                n2 = "blur";
                k3 = Fd;
                break;
              case "beforeblur":
              case "afterblur":
                k3 = Fd;
                break;
              case "click":
                if (c2.button === 2)
                  break a;
              case "auxclick":
              case "dblclick":
              case "mousedown":
              case "mousemove":
              case "mouseup":
              case "mouseout":
              case "mouseover":
              case "contextmenu":
                k3 = Bd;
                break;
              case "drag":
              case "dragend":
              case "dragenter":
              case "dragexit":
              case "dragleave":
              case "dragover":
              case "dragstart":
              case "drop":
                k3 = Dd;
                break;
              case "touchcancel":
              case "touchend":
              case "touchmove":
              case "touchstart":
                k3 = Vd;
                break;
              case $e:
              case af:
              case bf:
                k3 = Hd;
                break;
              case cf:
                k3 = Xd;
                break;
              case "scroll":
                k3 = vd;
                break;
              case "wheel":
                k3 = Zd;
                break;
              case "copy":
              case "cut":
              case "paste":
                k3 = Jd;
                break;
              case "gotpointercapture":
              case "lostpointercapture":
              case "pointercancel":
              case "pointerdown":
              case "pointermove":
              case "pointerout":
              case "pointerover":
              case "pointerup":
                k3 = Td;
            }
            var t3 = (b2 & 4) !== 0, J = !t3 && a2 === "scroll", x2 = t3 ? h3 !== null ? h3 + "Capture" : null : h3;
            t3 = [];
            for (var w2 = d3, u2; w2 !== null; ) {
              u2 = w2;
              var F2 = u2.stateNode;
              u2.tag === 5 && F2 !== null && (u2 = F2, x2 !== null && (F2 = Kb(w2, x2), F2 != null && t3.push(tf(w2, F2, u2))));
              if (J)
                break;
              w2 = w2.return;
            }
            0 < t3.length && (h3 = new k3(h3, n2, null, c2, e3), g3.push({ event: h3, listeners: t3 }));
          }
        }
        if ((b2 & 7) === 0) {
          a: {
            h3 = a2 === "mouseover" || a2 === "pointerover";
            k3 = a2 === "mouseout" || a2 === "pointerout";
            if (h3 && c2 !== wb && (n2 = c2.relatedTarget || c2.fromElement) && (Wc(n2) || n2[uf]))
              break a;
            if (k3 || h3) {
              h3 = e3.window === e3 ? e3 : (h3 = e3.ownerDocument) ? h3.defaultView || h3.parentWindow : window;
              if (k3) {
                if (n2 = c2.relatedTarget || c2.toElement, k3 = d3, n2 = n2 ? Wc(n2) : null, n2 !== null && (J = Vb(n2), n2 !== J || n2.tag !== 5 && n2.tag !== 6))
                  n2 = null;
              } else
                k3 = null, n2 = d3;
              if (k3 !== n2) {
                t3 = Bd;
                F2 = "onMouseLeave";
                x2 = "onMouseEnter";
                w2 = "mouse";
                if (a2 === "pointerout" || a2 === "pointerover")
                  t3 = Td, F2 = "onPointerLeave", x2 = "onPointerEnter", w2 = "pointer";
                J = k3 == null ? h3 : ue(k3);
                u2 = n2 == null ? h3 : ue(n2);
                h3 = new t3(F2, w2 + "leave", k3, c2, e3);
                h3.target = J;
                h3.relatedTarget = u2;
                F2 = null;
                Wc(e3) === d3 && (t3 = new t3(x2, w2 + "enter", n2, c2, e3), t3.target = u2, t3.relatedTarget = J, F2 = t3);
                J = F2;
                if (k3 && n2)
                  b: {
                    t3 = k3;
                    x2 = n2;
                    w2 = 0;
                    for (u2 = t3; u2; u2 = vf(u2))
                      w2++;
                    u2 = 0;
                    for (F2 = x2; F2; F2 = vf(F2))
                      u2++;
                    for (; 0 < w2 - u2; )
                      t3 = vf(t3), w2--;
                    for (; 0 < u2 - w2; )
                      x2 = vf(x2), u2--;
                    for (; w2--; ) {
                      if (t3 === x2 || x2 !== null && t3 === x2.alternate)
                        break b;
                      t3 = vf(t3);
                      x2 = vf(x2);
                    }
                    t3 = null;
                  }
                else
                  t3 = null;
                k3 !== null && wf(g3, h3, k3, t3, false);
                n2 !== null && J !== null && wf(g3, J, n2, t3, true);
              }
            }
          }
          a: {
            h3 = d3 ? ue(d3) : window;
            k3 = h3.nodeName && h3.nodeName.toLowerCase();
            if (k3 === "select" || k3 === "input" && h3.type === "file")
              var na = ve;
            else if (me(h3))
              if (we)
                na = Fe;
              else {
                na = De;
                var xa = Ce;
              }
            else
              (k3 = h3.nodeName) && k3.toLowerCase() === "input" && (h3.type === "checkbox" || h3.type === "radio") && (na = Ee);
            if (na && (na = na(a2, d3))) {
              ne2(g3, na, c2, e3);
              break a;
            }
            xa && xa(a2, h3, d3);
            a2 === "focusout" && (xa = h3._wrapperState) && xa.controlled && h3.type === "number" && cb(h3, "number", h3.value);
          }
          xa = d3 ? ue(d3) : window;
          switch (a2) {
            case "focusin":
              if (me(xa) || xa.contentEditable === "true")
                Qe = xa, Re = d3, Se = null;
              break;
            case "focusout":
              Se = Re = Qe = null;
              break;
            case "mousedown":
              Te = true;
              break;
            case "contextmenu":
            case "mouseup":
            case "dragend":
              Te = false;
              Ue(g3, c2, e3);
              break;
            case "selectionchange":
              if (Pe)
                break;
            case "keydown":
            case "keyup":
              Ue(g3, c2, e3);
          }
          var $a;
          if (ae)
            b: {
              switch (a2) {
                case "compositionstart":
                  var ba = "onCompositionStart";
                  break b;
                case "compositionend":
                  ba = "onCompositionEnd";
                  break b;
                case "compositionupdate":
                  ba = "onCompositionUpdate";
                  break b;
              }
              ba = void 0;
            }
          else
            ie ? ge(a2, c2) && (ba = "onCompositionEnd") : a2 === "keydown" && c2.keyCode === 229 && (ba = "onCompositionStart");
          ba && (de && c2.locale !== "ko" && (ie || ba !== "onCompositionStart" ? ba === "onCompositionEnd" && ie && ($a = nd()) : (kd = e3, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d3, ba), 0 < xa.length && (ba = new Ld(ba, a2, null, c2, e3), g3.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c2), $a !== null && (ba.data = $a))));
          if ($a = ce ? je(a2, c2) : ke(a2, c2))
            d3 = oe(d3, "onBeforeInput"), 0 < d3.length && (e3 = new Ld("onBeforeInput", "beforeinput", null, c2, e3), g3.push({ event: e3, listeners: d3 }), e3.data = $a);
        }
        se(g3, b2);
      });
    }
    function tf(a2, b2, c2) {
      return { instance: a2, listener: b2, currentTarget: c2 };
    }
    function oe(a2, b2) {
      for (var c2 = b2 + "Capture", d2 = []; a2 !== null; ) {
        var e2 = a2, f2 = e2.stateNode;
        e2.tag === 5 && f2 !== null && (e2 = f2, f2 = Kb(a2, c2), f2 != null && d2.unshift(tf(a2, f2, e2)), f2 = Kb(a2, b2), f2 != null && d2.push(tf(a2, f2, e2)));
        a2 = a2.return;
      }
      return d2;
    }
    function vf(a2) {
      if (a2 === null)
        return null;
      do
        a2 = a2.return;
      while (a2 && a2.tag !== 5);
      return a2 ? a2 : null;
    }
    function wf(a2, b2, c2, d2, e2) {
      for (var f2 = b2._reactName, g2 = []; c2 !== null && c2 !== d2; ) {
        var h2 = c2, k2 = h2.alternate, l2 = h2.stateNode;
        if (k2 !== null && k2 === d2)
          break;
        h2.tag === 5 && l2 !== null && (h2 = l2, e2 ? (k2 = Kb(c2, f2), k2 != null && g2.unshift(tf(c2, k2, h2))) : e2 || (k2 = Kb(c2, f2), k2 != null && g2.push(tf(c2, k2, h2))));
        c2 = c2.return;
      }
      g2.length !== 0 && a2.push({ event: b2, listeners: g2 });
    }
    var xf = /\r\n?/g;
    var yf = /\u0000|\uFFFD/g;
    function zf(a2) {
      return (typeof a2 === "string" ? a2 : "" + a2).replace(xf, "\n").replace(yf, "");
    }
    function Af(a2, b2, c2) {
      b2 = zf(b2);
      if (zf(a2) !== b2 && c2)
        throw Error(p2(425));
    }
    function Bf() {
    }
    var Cf = null;
    var Df = null;
    function Ef(a2, b2) {
      return a2 === "textarea" || a2 === "noscript" || typeof b2.children === "string" || typeof b2.children === "number" || typeof b2.dangerouslySetInnerHTML === "object" && b2.dangerouslySetInnerHTML !== null && b2.dangerouslySetInnerHTML.__html != null;
    }
    var Ff = typeof setTimeout === "function" ? setTimeout : void 0;
    var Gf = typeof clearTimeout === "function" ? clearTimeout : void 0;
    var Hf = typeof Promise === "function" ? Promise : void 0;
    var Jf = typeof queueMicrotask === "function" ? queueMicrotask : typeof Hf !== "undefined" ? function(a2) {
      return Hf.resolve(null).then(a2).catch(If);
    } : Ff;
    function If(a2) {
      setTimeout(function() {
        throw a2;
      });
    }
    function Kf(a2, b2) {
      var c2 = b2, d2 = 0;
      do {
        var e2 = c2.nextSibling;
        a2.removeChild(c2);
        if (e2 && e2.nodeType === 8)
          if (c2 = e2.data, c2 === "/$") {
            if (d2 === 0) {
              a2.removeChild(e2);
              bd(b2);
              return;
            }
            d2--;
          } else
            c2 !== "$" && c2 !== "$?" && c2 !== "$!" || d2++;
        c2 = e2;
      } while (c2);
      bd(b2);
    }
    function Lf(a2) {
      for (; a2 != null; a2 = a2.nextSibling) {
        var b2 = a2.nodeType;
        if (b2 === 1 || b2 === 3)
          break;
        if (b2 === 8) {
          b2 = a2.data;
          if (b2 === "$" || b2 === "$!" || b2 === "$?")
            break;
          if (b2 === "/$")
            return null;
        }
      }
      return a2;
    }
    function Mf(a2) {
      a2 = a2.previousSibling;
      for (var b2 = 0; a2; ) {
        if (a2.nodeType === 8) {
          var c2 = a2.data;
          if (c2 === "$" || c2 === "$!" || c2 === "$?") {
            if (b2 === 0)
              return a2;
            b2--;
          } else
            c2 === "/$" && b2++;
        }
        a2 = a2.previousSibling;
      }
      return null;
    }
    var Nf = Math.random().toString(36).slice(2);
    var Of = "__reactFiber$" + Nf;
    var Pf = "__reactProps$" + Nf;
    var uf = "__reactContainer$" + Nf;
    var of = "__reactEvents$" + Nf;
    var Qf = "__reactListeners$" + Nf;
    var Rf = "__reactHandles$" + Nf;
    function Wc(a2) {
      var b2 = a2[Of];
      if (b2)
        return b2;
      for (var c2 = a2.parentNode; c2; ) {
        if (b2 = c2[uf] || c2[Of]) {
          c2 = b2.alternate;
          if (b2.child !== null || c2 !== null && c2.child !== null)
            for (a2 = Mf(a2); a2 !== null; ) {
              if (c2 = a2[Of])
                return c2;
              a2 = Mf(a2);
            }
          return b2;
        }
        a2 = c2;
        c2 = a2.parentNode;
      }
      return null;
    }
    function Cb(a2) {
      a2 = a2[Of] || a2[uf];
      return !a2 || a2.tag !== 5 && a2.tag !== 6 && a2.tag !== 13 && a2.tag !== 3 ? null : a2;
    }
    function ue(a2) {
      if (a2.tag === 5 || a2.tag === 6)
        return a2.stateNode;
      throw Error(p2(33));
    }
    function Db(a2) {
      return a2[Pf] || null;
    }
    var Sf = [];
    var Tf = -1;
    function Uf(a2) {
      return { current: a2 };
    }
    function E2(a2) {
      0 > Tf || (a2.current = Sf[Tf], Sf[Tf] = null, Tf--);
    }
    function G(a2, b2) {
      Tf++;
      Sf[Tf] = a2.current;
      a2.current = b2;
    }
    var Vf = {};
    var H = Uf(Vf);
    var Wf = Uf(false);
    var Xf = Vf;
    function Yf(a2, b2) {
      var c2 = a2.type.contextTypes;
      if (!c2)
        return Vf;
      var d2 = a2.stateNode;
      if (d2 && d2.__reactInternalMemoizedUnmaskedChildContext === b2)
        return d2.__reactInternalMemoizedMaskedChildContext;
      var e2 = {}, f2;
      for (f2 in c2)
        e2[f2] = b2[f2];
      d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = b2, a2.__reactInternalMemoizedMaskedChildContext = e2);
      return e2;
    }
    function Zf(a2) {
      a2 = a2.childContextTypes;
      return a2 !== null && a2 !== void 0;
    }
    function $f() {
      E2(Wf);
      E2(H);
    }
    function ag(a2, b2, c2) {
      if (H.current !== Vf)
        throw Error(p2(168));
      G(H, b2);
      G(Wf, c2);
    }
    function bg(a2, b2, c2) {
      var d2 = a2.stateNode;
      b2 = b2.childContextTypes;
      if (typeof d2.getChildContext !== "function")
        return c2;
      d2 = d2.getChildContext();
      for (var e2 in d2)
        if (!(e2 in b2))
          throw Error(p2(108, Ra(a2) || "Unknown", e2));
      return A2({}, c2, d2);
    }
    function cg(a2) {
      a2 = (a2 = a2.stateNode) && a2.__reactInternalMemoizedMergedChildContext || Vf;
      Xf = H.current;
      G(H, a2);
      G(Wf, Wf.current);
      return true;
    }
    function dg(a2, b2, c2) {
      var d2 = a2.stateNode;
      if (!d2)
        throw Error(p2(169));
      c2 ? (a2 = bg(a2, b2, Xf), d2.__reactInternalMemoizedMergedChildContext = a2, E2(Wf), E2(H), G(H, a2)) : E2(Wf);
      G(Wf, c2);
    }
    var eg = null;
    var fg = false;
    var gg = false;
    function hg(a2) {
      eg === null ? eg = [a2] : eg.push(a2);
    }
    function ig(a2) {
      fg = true;
      hg(a2);
    }
    function jg() {
      if (!gg && eg !== null) {
        gg = true;
        var a2 = 0, b2 = C2;
        try {
          var c2 = eg;
          for (C2 = 1; a2 < c2.length; a2++) {
            var d2 = c2[a2];
            do
              d2 = d2(true);
            while (d2 !== null);
          }
          eg = null;
          fg = false;
        } catch (e2) {
          throw eg !== null && (eg = eg.slice(a2 + 1)), ac(fc, jg), e2;
        } finally {
          C2 = b2, gg = false;
        }
      }
      return null;
    }
    var kg = [];
    var lg = 0;
    var mg = null;
    var ng = 0;
    var og = [];
    var pg = 0;
    var qg = null;
    var rg = 1;
    var sg = "";
    function tg(a2, b2) {
      kg[lg++] = ng;
      kg[lg++] = mg;
      mg = a2;
      ng = b2;
    }
    function ug(a2, b2, c2) {
      og[pg++] = rg;
      og[pg++] = sg;
      og[pg++] = qg;
      qg = a2;
      var d2 = rg;
      a2 = sg;
      var e2 = 32 - oc(d2) - 1;
      d2 &= ~(1 << e2);
      c2 += 1;
      var f2 = 32 - oc(b2) + e2;
      if (30 < f2) {
        var g2 = e2 - e2 % 5;
        f2 = (d2 & (1 << g2) - 1).toString(32);
        d2 >>= g2;
        e2 -= g2;
        rg = 1 << 32 - oc(b2) + e2 | c2 << e2 | d2;
        sg = f2 + a2;
      } else
        rg = 1 << f2 | c2 << e2 | d2, sg = a2;
    }
    function vg(a2) {
      a2.return !== null && (tg(a2, 1), ug(a2, 1, 0));
    }
    function wg(a2) {
      for (; a2 === mg; )
        mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null;
      for (; a2 === qg; )
        qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null;
    }
    var xg = null;
    var yg = null;
    var I2 = false;
    var zg = null;
    function Ag(a2, b2) {
      var c2 = Bg(5, null, null, 0);
      c2.elementType = "DELETED";
      c2.stateNode = b2;
      c2.return = a2;
      b2 = a2.deletions;
      b2 === null ? (a2.deletions = [c2], a2.flags |= 16) : b2.push(c2);
    }
    function Cg(a2, b2) {
      switch (a2.tag) {
        case 5:
          var c2 = a2.type;
          b2 = b2.nodeType !== 1 || c2.toLowerCase() !== b2.nodeName.toLowerCase() ? null : b2;
          return b2 !== null ? (a2.stateNode = b2, xg = a2, yg = Lf(b2.firstChild), true) : false;
        case 6:
          return b2 = a2.pendingProps === "" || b2.nodeType !== 3 ? null : b2, b2 !== null ? (a2.stateNode = b2, xg = a2, yg = null, true) : false;
        case 13:
          return b2 = b2.nodeType !== 8 ? null : b2, b2 !== null ? (c2 = qg !== null ? { id: rg, overflow: sg } : null, a2.memoizedState = { dehydrated: b2, treeContext: c2, retryLane: 1073741824 }, c2 = Bg(18, null, null, 0), c2.stateNode = b2, c2.return = a2, a2.child = c2, xg = a2, yg = null, true) : false;
        default:
          return false;
      }
    }
    function Dg(a2) {
      return (a2.mode & 1) !== 0 && (a2.flags & 128) === 0;
    }
    function Eg(a2) {
      if (I2) {
        var b2 = yg;
        if (b2) {
          var c2 = b2;
          if (!Cg(a2, b2)) {
            if (Dg(a2))
              throw Error(p2(418));
            b2 = Lf(c2.nextSibling);
            var d2 = xg;
            b2 && Cg(a2, b2) ? Ag(d2, c2) : (a2.flags = a2.flags & -4097 | 2, I2 = false, xg = a2);
          }
        } else {
          if (Dg(a2))
            throw Error(p2(418));
          a2.flags = a2.flags & -4097 | 2;
          I2 = false;
          xg = a2;
        }
      }
    }
    function Fg(a2) {
      for (a2 = a2.return; a2 !== null && a2.tag !== 5 && a2.tag !== 3 && a2.tag !== 13; )
        a2 = a2.return;
      xg = a2;
    }
    function Gg(a2) {
      if (a2 !== xg)
        return false;
      if (!I2)
        return Fg(a2), I2 = true, false;
      var b2;
      (b2 = a2.tag !== 3) && !(b2 = a2.tag !== 5) && (b2 = a2.type, b2 = b2 !== "head" && b2 !== "body" && !Ef(a2.type, a2.memoizedProps));
      if (b2 && (b2 = yg)) {
        if (Dg(a2))
          throw Hg(), Error(p2(418));
        for (; b2; )
          Ag(a2, b2), b2 = Lf(b2.nextSibling);
      }
      Fg(a2);
      if (a2.tag === 13) {
        a2 = a2.memoizedState;
        a2 = a2 !== null ? a2.dehydrated : null;
        if (!a2)
          throw Error(p2(317));
        a: {
          a2 = a2.nextSibling;
          for (b2 = 0; a2; ) {
            if (a2.nodeType === 8) {
              var c2 = a2.data;
              if (c2 === "/$") {
                if (b2 === 0) {
                  yg = Lf(a2.nextSibling);
                  break a;
                }
                b2--;
              } else
                c2 !== "$" && c2 !== "$!" && c2 !== "$?" || b2++;
            }
            a2 = a2.nextSibling;
          }
          yg = null;
        }
      } else
        yg = xg ? Lf(a2.stateNode.nextSibling) : null;
      return true;
    }
    function Hg() {
      for (var a2 = yg; a2; )
        a2 = Lf(a2.nextSibling);
    }
    function Ig() {
      yg = xg = null;
      I2 = false;
    }
    function Jg(a2) {
      zg === null ? zg = [a2] : zg.push(a2);
    }
    var Kg = ua.ReactCurrentBatchConfig;
    function Lg(a2, b2) {
      if (a2 && a2.defaultProps) {
        b2 = A2({}, b2);
        a2 = a2.defaultProps;
        for (var c2 in a2)
          b2[c2] === void 0 && (b2[c2] = a2[c2]);
        return b2;
      }
      return b2;
    }
    var Mg = Uf(null);
    var Ng = null;
    var Og = null;
    var Pg = null;
    function Qg() {
      Pg = Og = Ng = null;
    }
    function Rg(a2) {
      var b2 = Mg.current;
      E2(Mg);
      a2._currentValue = b2;
    }
    function Sg(a2, b2, c2) {
      for (; a2 !== null; ) {
        var d2 = a2.alternate;
        (a2.childLanes & b2) !== b2 ? (a2.childLanes |= b2, d2 !== null && (d2.childLanes |= b2)) : d2 !== null && (d2.childLanes & b2) !== b2 && (d2.childLanes |= b2);
        if (a2 === c2)
          break;
        a2 = a2.return;
      }
    }
    function Tg(a2, b2) {
      Ng = a2;
      Pg = Og = null;
      a2 = a2.dependencies;
      a2 !== null && a2.firstContext !== null && ((a2.lanes & b2) !== 0 && (Ug = true), a2.firstContext = null);
    }
    function Vg(a2) {
      var b2 = a2._currentValue;
      if (Pg !== a2)
        if (a2 = { context: a2, memoizedValue: b2, next: null }, Og === null) {
          if (Ng === null)
            throw Error(p2(308));
          Og = a2;
          Ng.dependencies = { lanes: 0, firstContext: a2 };
        } else
          Og = Og.next = a2;
      return b2;
    }
    var Wg = null;
    function Xg(a2) {
      Wg === null ? Wg = [a2] : Wg.push(a2);
    }
    function Yg(a2, b2, c2, d2) {
      var e2 = b2.interleaved;
      e2 === null ? (c2.next = c2, Xg(b2)) : (c2.next = e2.next, e2.next = c2);
      b2.interleaved = c2;
      return Zg(a2, d2);
    }
    function Zg(a2, b2) {
      a2.lanes |= b2;
      var c2 = a2.alternate;
      c2 !== null && (c2.lanes |= b2);
      c2 = a2;
      for (a2 = a2.return; a2 !== null; )
        a2.childLanes |= b2, c2 = a2.alternate, c2 !== null && (c2.childLanes |= b2), c2 = a2, a2 = a2.return;
      return c2.tag === 3 ? c2.stateNode : null;
    }
    var $g = false;
    function ah(a2) {
      a2.updateQueue = { baseState: a2.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null };
    }
    function bh(a2, b2) {
      a2 = a2.updateQueue;
      b2.updateQueue === a2 && (b2.updateQueue = { baseState: a2.baseState, firstBaseUpdate: a2.firstBaseUpdate, lastBaseUpdate: a2.lastBaseUpdate, shared: a2.shared, effects: a2.effects });
    }
    function ch(a2, b2) {
      return { eventTime: a2, lane: b2, tag: 0, payload: null, callback: null, next: null };
    }
    function dh(a2, b2, c2) {
      var d2 = a2.updateQueue;
      if (d2 === null)
        return null;
      d2 = d2.shared;
      if ((K & 2) !== 0) {
        var e2 = d2.pending;
        e2 === null ? b2.next = b2 : (b2.next = e2.next, e2.next = b2);
        d2.pending = b2;
        return Zg(a2, c2);
      }
      e2 = d2.interleaved;
      e2 === null ? (b2.next = b2, Xg(d2)) : (b2.next = e2.next, e2.next = b2);
      d2.interleaved = b2;
      return Zg(a2, c2);
    }
    function eh(a2, b2, c2) {
      b2 = b2.updateQueue;
      if (b2 !== null && (b2 = b2.shared, (c2 & 4194240) !== 0)) {
        var d2 = b2.lanes;
        d2 &= a2.pendingLanes;
        c2 |= d2;
        b2.lanes = c2;
        Cc(a2, c2);
      }
    }
    function fh(a2, b2) {
      var c2 = a2.updateQueue, d2 = a2.alternate;
      if (d2 !== null && (d2 = d2.updateQueue, c2 === d2)) {
        var e2 = null, f2 = null;
        c2 = c2.firstBaseUpdate;
        if (c2 !== null) {
          do {
            var g2 = { eventTime: c2.eventTime, lane: c2.lane, tag: c2.tag, payload: c2.payload, callback: c2.callback, next: null };
            f2 === null ? e2 = f2 = g2 : f2 = f2.next = g2;
            c2 = c2.next;
          } while (c2 !== null);
          f2 === null ? e2 = f2 = b2 : f2 = f2.next = b2;
        } else
          e2 = f2 = b2;
        c2 = { baseState: d2.baseState, firstBaseUpdate: e2, lastBaseUpdate: f2, shared: d2.shared, effects: d2.effects };
        a2.updateQueue = c2;
        return;
      }
      a2 = c2.lastBaseUpdate;
      a2 === null ? c2.firstBaseUpdate = b2 : a2.next = b2;
      c2.lastBaseUpdate = b2;
    }
    function gh(a2, b2, c2, d2) {
      var e2 = a2.updateQueue;
      $g = false;
      var f2 = e2.firstBaseUpdate, g2 = e2.lastBaseUpdate, h2 = e2.shared.pending;
      if (h2 !== null) {
        e2.shared.pending = null;
        var k2 = h2, l2 = k2.next;
        k2.next = null;
        g2 === null ? f2 = l2 : g2.next = l2;
        g2 = k2;
        var m2 = a2.alternate;
        m2 !== null && (m2 = m2.updateQueue, h2 = m2.lastBaseUpdate, h2 !== g2 && (h2 === null ? m2.firstBaseUpdate = l2 : h2.next = l2, m2.lastBaseUpdate = k2));
      }
      if (f2 !== null) {
        var q = e2.baseState;
        g2 = 0;
        m2 = l2 = k2 = null;
        h2 = f2;
        do {
          var r2 = h2.lane, y2 = h2.eventTime;
          if ((d2 & r2) === r2) {
            m2 !== null && (m2 = m2.next = {
              eventTime: y2,
              lane: 0,
              tag: h2.tag,
              payload: h2.payload,
              callback: h2.callback,
              next: null
            });
            a: {
              var n2 = a2, t3 = h2;
              r2 = b2;
              y2 = c2;
              switch (t3.tag) {
                case 1:
                  n2 = t3.payload;
                  if (typeof n2 === "function") {
                    q = n2.call(y2, q, r2);
                    break a;
                  }
                  q = n2;
                  break a;
                case 3:
                  n2.flags = n2.flags & -65537 | 128;
                case 0:
                  n2 = t3.payload;
                  r2 = typeof n2 === "function" ? n2.call(y2, q, r2) : n2;
                  if (r2 === null || r2 === void 0)
                    break a;
                  q = A2({}, q, r2);
                  break a;
                case 2:
                  $g = true;
              }
            }
            h2.callback !== null && h2.lane !== 0 && (a2.flags |= 64, r2 = e2.effects, r2 === null ? e2.effects = [h2] : r2.push(h2));
          } else
            y2 = { eventTime: y2, lane: r2, tag: h2.tag, payload: h2.payload, callback: h2.callback, next: null }, m2 === null ? (l2 = m2 = y2, k2 = q) : m2 = m2.next = y2, g2 |= r2;
          h2 = h2.next;
          if (h2 === null)
            if (h2 = e2.shared.pending, h2 === null)
              break;
            else
              r2 = h2, h2 = r2.next, r2.next = null, e2.lastBaseUpdate = r2, e2.shared.pending = null;
        } while (1);
        m2 === null && (k2 = q);
        e2.baseState = k2;
        e2.firstBaseUpdate = l2;
        e2.lastBaseUpdate = m2;
        b2 = e2.shared.interleaved;
        if (b2 !== null) {
          e2 = b2;
          do
            g2 |= e2.lane, e2 = e2.next;
          while (e2 !== b2);
        } else
          f2 === null && (e2.shared.lanes = 0);
        hh |= g2;
        a2.lanes = g2;
        a2.memoizedState = q;
      }
    }
    function ih(a2, b2, c2) {
      a2 = b2.effects;
      b2.effects = null;
      if (a2 !== null)
        for (b2 = 0; b2 < a2.length; b2++) {
          var d2 = a2[b2], e2 = d2.callback;
          if (e2 !== null) {
            d2.callback = null;
            d2 = c2;
            if (typeof e2 !== "function")
              throw Error(p2(191, e2));
            e2.call(d2);
          }
        }
    }
    var jh = new aa.Component().refs;
    function kh(a2, b2, c2, d2) {
      b2 = a2.memoizedState;
      c2 = c2(d2, b2);
      c2 = c2 === null || c2 === void 0 ? b2 : A2({}, b2, c2);
      a2.memoizedState = c2;
      a2.lanes === 0 && (a2.updateQueue.baseState = c2);
    }
    var nh = { isMounted: function(a2) {
      return (a2 = a2._reactInternals) ? Vb(a2) === a2 : false;
    }, enqueueSetState: function(a2, b2, c2) {
      a2 = a2._reactInternals;
      var d2 = L2(), e2 = lh(a2), f2 = ch(d2, e2);
      f2.payload = b2;
      c2 !== void 0 && c2 !== null && (f2.callback = c2);
      b2 = dh(a2, f2, e2);
      b2 !== null && (mh(b2, a2, e2, d2), eh(b2, a2, e2));
    }, enqueueReplaceState: function(a2, b2, c2) {
      a2 = a2._reactInternals;
      var d2 = L2(), e2 = lh(a2), f2 = ch(d2, e2);
      f2.tag = 1;
      f2.payload = b2;
      c2 !== void 0 && c2 !== null && (f2.callback = c2);
      b2 = dh(a2, f2, e2);
      b2 !== null && (mh(b2, a2, e2, d2), eh(b2, a2, e2));
    }, enqueueForceUpdate: function(a2, b2) {
      a2 = a2._reactInternals;
      var c2 = L2(), d2 = lh(a2), e2 = ch(c2, d2);
      e2.tag = 2;
      b2 !== void 0 && b2 !== null && (e2.callback = b2);
      b2 = dh(a2, e2, d2);
      b2 !== null && (mh(b2, a2, d2, c2), eh(b2, a2, d2));
    } };
    function oh(a2, b2, c2, d2, e2, f2, g2) {
      a2 = a2.stateNode;
      return typeof a2.shouldComponentUpdate === "function" ? a2.shouldComponentUpdate(d2, f2, g2) : b2.prototype && b2.prototype.isPureReactComponent ? !Ie(c2, d2) || !Ie(e2, f2) : true;
    }
    function ph(a2, b2, c2) {
      var d2 = false, e2 = Vf;
      var f2 = b2.contextType;
      typeof f2 === "object" && f2 !== null ? f2 = Vg(f2) : (e2 = Zf(b2) ? Xf : H.current, d2 = b2.contextTypes, f2 = (d2 = d2 !== null && d2 !== void 0) ? Yf(a2, e2) : Vf);
      b2 = new b2(c2, f2);
      a2.memoizedState = b2.state !== null && b2.state !== void 0 ? b2.state : null;
      b2.updater = nh;
      a2.stateNode = b2;
      b2._reactInternals = a2;
      d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = e2, a2.__reactInternalMemoizedMaskedChildContext = f2);
      return b2;
    }
    function qh(a2, b2, c2, d2) {
      a2 = b2.state;
      typeof b2.componentWillReceiveProps === "function" && b2.componentWillReceiveProps(c2, d2);
      typeof b2.UNSAFE_componentWillReceiveProps === "function" && b2.UNSAFE_componentWillReceiveProps(c2, d2);
      b2.state !== a2 && nh.enqueueReplaceState(b2, b2.state, null);
    }
    function rh(a2, b2, c2, d2) {
      var e2 = a2.stateNode;
      e2.props = c2;
      e2.state = a2.memoizedState;
      e2.refs = jh;
      ah(a2);
      var f2 = b2.contextType;
      typeof f2 === "object" && f2 !== null ? e2.context = Vg(f2) : (f2 = Zf(b2) ? Xf : H.current, e2.context = Yf(a2, f2));
      e2.state = a2.memoizedState;
      f2 = b2.getDerivedStateFromProps;
      typeof f2 === "function" && (kh(a2, b2, f2, c2), e2.state = a2.memoizedState);
      typeof b2.getDerivedStateFromProps === "function" || typeof e2.getSnapshotBeforeUpdate === "function" || typeof e2.UNSAFE_componentWillMount !== "function" && typeof e2.componentWillMount !== "function" || (b2 = e2.state, typeof e2.componentWillMount === "function" && e2.componentWillMount(), typeof e2.UNSAFE_componentWillMount === "function" && e2.UNSAFE_componentWillMount(), b2 !== e2.state && nh.enqueueReplaceState(e2, e2.state, null), gh(a2, c2, e2, d2), e2.state = a2.memoizedState);
      typeof e2.componentDidMount === "function" && (a2.flags |= 4194308);
    }
    function sh(a2, b2, c2) {
      a2 = c2.ref;
      if (a2 !== null && typeof a2 !== "function" && typeof a2 !== "object") {
        if (c2._owner) {
          c2 = c2._owner;
          if (c2) {
            if (c2.tag !== 1)
              throw Error(p2(309));
            var d2 = c2.stateNode;
          }
          if (!d2)
            throw Error(p2(147, a2));
          var e2 = d2, f2 = "" + a2;
          if (b2 !== null && b2.ref !== null && typeof b2.ref === "function" && b2.ref._stringRef === f2)
            return b2.ref;
          b2 = function(a3) {
            var b3 = e2.refs;
            b3 === jh && (b3 = e2.refs = {});
            a3 === null ? delete b3[f2] : b3[f2] = a3;
          };
          b2._stringRef = f2;
          return b2;
        }
        if (typeof a2 !== "string")
          throw Error(p2(284));
        if (!c2._owner)
          throw Error(p2(290, a2));
      }
      return a2;
    }
    function th(a2, b2) {
      a2 = Object.prototype.toString.call(b2);
      throw Error(p2(31, a2 === "[object Object]" ? "object with keys {" + Object.keys(b2).join(", ") + "}" : a2));
    }
    function uh(a2) {
      var b2 = a2._init;
      return b2(a2._payload);
    }
    function vh(a2) {
      function b2(b3, c3) {
        if (a2) {
          var d3 = b3.deletions;
          d3 === null ? (b3.deletions = [c3], b3.flags |= 16) : d3.push(c3);
        }
      }
      function c2(c3, d3) {
        if (!a2)
          return null;
        for (; d3 !== null; )
          b2(c3, d3), d3 = d3.sibling;
        return null;
      }
      function d2(a3, b3) {
        for (a3 = /* @__PURE__ */ new Map(); b3 !== null; )
          b3.key !== null ? a3.set(b3.key, b3) : a3.set(b3.index, b3), b3 = b3.sibling;
        return a3;
      }
      function e2(a3, b3) {
        a3 = wh(a3, b3);
        a3.index = 0;
        a3.sibling = null;
        return a3;
      }
      function f2(b3, c3, d3) {
        b3.index = d3;
        if (!a2)
          return b3.flags |= 1048576, c3;
        d3 = b3.alternate;
        if (d3 !== null)
          return d3 = d3.index, d3 < c3 ? (b3.flags |= 2, c3) : d3;
        b3.flags |= 2;
        return c3;
      }
      function g2(b3) {
        a2 && b3.alternate === null && (b3.flags |= 2);
        return b3;
      }
      function h2(a3, b3, c3, d3) {
        if (b3 === null || b3.tag !== 6)
          return b3 = xh(c3, a3.mode, d3), b3.return = a3, b3;
        b3 = e2(b3, c3);
        b3.return = a3;
        return b3;
      }
      function k2(a3, b3, c3, d3) {
        var f3 = c3.type;
        if (f3 === ya)
          return m2(a3, b3, c3.props.children, d3, c3.key);
        if (b3 !== null && (b3.elementType === f3 || typeof f3 === "object" && f3 !== null && f3.$$typeof === Ha && uh(f3) === b3.type))
          return d3 = e2(b3, c3.props), d3.ref = sh(a3, b3, c3), d3.return = a3, d3;
        d3 = yh(c3.type, c3.key, c3.props, null, a3.mode, d3);
        d3.ref = sh(a3, b3, c3);
        d3.return = a3;
        return d3;
      }
      function l2(a3, b3, c3, d3) {
        if (b3 === null || b3.tag !== 4 || b3.stateNode.containerInfo !== c3.containerInfo || b3.stateNode.implementation !== c3.implementation)
          return b3 = zh(c3, a3.mode, d3), b3.return = a3, b3;
        b3 = e2(b3, c3.children || []);
        b3.return = a3;
        return b3;
      }
      function m2(a3, b3, c3, d3, f3) {
        if (b3 === null || b3.tag !== 7)
          return b3 = Ah(c3, a3.mode, d3, f3), b3.return = a3, b3;
        b3 = e2(b3, c3);
        b3.return = a3;
        return b3;
      }
      function q(a3, b3, c3) {
        if (typeof b3 === "string" && b3 !== "" || typeof b3 === "number")
          return b3 = xh("" + b3, a3.mode, c3), b3.return = a3, b3;
        if (typeof b3 === "object" && b3 !== null) {
          switch (b3.$$typeof) {
            case va:
              return c3 = yh(b3.type, b3.key, b3.props, null, a3.mode, c3), c3.ref = sh(a3, null, b3), c3.return = a3, c3;
            case wa:
              return b3 = zh(b3, a3.mode, c3), b3.return = a3, b3;
            case Ha:
              var d3 = b3._init;
              return q(a3, d3(b3._payload), c3);
          }
          if (eb(b3) || Ka(b3))
            return b3 = Ah(b3, a3.mode, c3, null), b3.return = a3, b3;
          th(a3, b3);
        }
        return null;
      }
      function r2(a3, b3, c3, d3) {
        var e3 = b3 !== null ? b3.key : null;
        if (typeof c3 === "string" && c3 !== "" || typeof c3 === "number")
          return e3 !== null ? null : h2(a3, b3, "" + c3, d3);
        if (typeof c3 === "object" && c3 !== null) {
          switch (c3.$$typeof) {
            case va:
              return c3.key === e3 ? k2(a3, b3, c3, d3) : null;
            case wa:
              return c3.key === e3 ? l2(a3, b3, c3, d3) : null;
            case Ha:
              return e3 = c3._init, r2(a3, b3, e3(c3._payload), d3);
          }
          if (eb(c3) || Ka(c3))
            return e3 !== null ? null : m2(a3, b3, c3, d3, null);
          th(a3, c3);
        }
        return null;
      }
      function y2(a3, b3, c3, d3, e3) {
        if (typeof d3 === "string" && d3 !== "" || typeof d3 === "number")
          return a3 = a3.get(c3) || null, h2(b3, a3, "" + d3, e3);
        if (typeof d3 === "object" && d3 !== null) {
          switch (d3.$$typeof) {
            case va:
              return a3 = a3.get(d3.key === null ? c3 : d3.key) || null, k2(b3, a3, d3, e3);
            case wa:
              return a3 = a3.get(d3.key === null ? c3 : d3.key) || null, l2(b3, a3, d3, e3);
            case Ha:
              var f3 = d3._init;
              return y2(a3, b3, c3, f3(d3._payload), e3);
          }
          if (eb(d3) || Ka(d3))
            return a3 = a3.get(c3) || null, m2(b3, a3, d3, e3, null);
          th(b3, d3);
        }
        return null;
      }
      function n2(e3, g3, h3, k3) {
        for (var l3 = null, m3 = null, u2 = g3, w2 = g3 = 0, x2 = null; u2 !== null && w2 < h3.length; w2++) {
          u2.index > w2 ? (x2 = u2, u2 = null) : x2 = u2.sibling;
          var n3 = r2(e3, u2, h3[w2], k3);
          if (n3 === null) {
            u2 === null && (u2 = x2);
            break;
          }
          a2 && u2 && n3.alternate === null && b2(e3, u2);
          g3 = f2(n3, g3, w2);
          m3 === null ? l3 = n3 : m3.sibling = n3;
          m3 = n3;
          u2 = x2;
        }
        if (w2 === h3.length)
          return c2(e3, u2), I2 && tg(e3, w2), l3;
        if (u2 === null) {
          for (; w2 < h3.length; w2++)
            u2 = q(e3, h3[w2], k3), u2 !== null && (g3 = f2(u2, g3, w2), m3 === null ? l3 = u2 : m3.sibling = u2, m3 = u2);
          I2 && tg(e3, w2);
          return l3;
        }
        for (u2 = d2(e3, u2); w2 < h3.length; w2++)
          x2 = y2(u2, e3, w2, h3[w2], k3), x2 !== null && (a2 && x2.alternate !== null && u2.delete(x2.key === null ? w2 : x2.key), g3 = f2(x2, g3, w2), m3 === null ? l3 = x2 : m3.sibling = x2, m3 = x2);
        a2 && u2.forEach(function(a3) {
          return b2(e3, a3);
        });
        I2 && tg(e3, w2);
        return l3;
      }
      function t3(e3, g3, h3, k3) {
        var l3 = Ka(h3);
        if (typeof l3 !== "function")
          throw Error(p2(150));
        h3 = l3.call(h3);
        if (h3 == null)
          throw Error(p2(151));
        for (var u2 = l3 = null, m3 = g3, w2 = g3 = 0, x2 = null, n3 = h3.next(); m3 !== null && !n3.done; w2++, n3 = h3.next()) {
          m3.index > w2 ? (x2 = m3, m3 = null) : x2 = m3.sibling;
          var t4 = r2(e3, m3, n3.value, k3);
          if (t4 === null) {
            m3 === null && (m3 = x2);
            break;
          }
          a2 && m3 && t4.alternate === null && b2(e3, m3);
          g3 = f2(t4, g3, w2);
          u2 === null ? l3 = t4 : u2.sibling = t4;
          u2 = t4;
          m3 = x2;
        }
        if (n3.done)
          return c2(e3, m3), I2 && tg(e3, w2), l3;
        if (m3 === null) {
          for (; !n3.done; w2++, n3 = h3.next())
            n3 = q(e3, n3.value, k3), n3 !== null && (g3 = f2(n3, g3, w2), u2 === null ? l3 = n3 : u2.sibling = n3, u2 = n3);
          I2 && tg(e3, w2);
          return l3;
        }
        for (m3 = d2(e3, m3); !n3.done; w2++, n3 = h3.next())
          n3 = y2(m3, e3, w2, n3.value, k3), n3 !== null && (a2 && n3.alternate !== null && m3.delete(n3.key === null ? w2 : n3.key), g3 = f2(n3, g3, w2), u2 === null ? l3 = n3 : u2.sibling = n3, u2 = n3);
        a2 && m3.forEach(function(a3) {
          return b2(e3, a3);
        });
        I2 && tg(e3, w2);
        return l3;
      }
      function J(a3, d3, f3, h3) {
        typeof f3 === "object" && f3 !== null && f3.type === ya && f3.key === null && (f3 = f3.props.children);
        if (typeof f3 === "object" && f3 !== null) {
          switch (f3.$$typeof) {
            case va:
              a: {
                for (var k3 = f3.key, l3 = d3; l3 !== null; ) {
                  if (l3.key === k3) {
                    k3 = f3.type;
                    if (k3 === ya) {
                      if (l3.tag === 7) {
                        c2(a3, l3.sibling);
                        d3 = e2(l3, f3.props.children);
                        d3.return = a3;
                        a3 = d3;
                        break a;
                      }
                    } else if (l3.elementType === k3 || typeof k3 === "object" && k3 !== null && k3.$$typeof === Ha && uh(k3) === l3.type) {
                      c2(a3, l3.sibling);
                      d3 = e2(l3, f3.props);
                      d3.ref = sh(a3, l3, f3);
                      d3.return = a3;
                      a3 = d3;
                      break a;
                    }
                    c2(a3, l3);
                    break;
                  } else
                    b2(a3, l3);
                  l3 = l3.sibling;
                }
                f3.type === ya ? (d3 = Ah(f3.props.children, a3.mode, h3, f3.key), d3.return = a3, a3 = d3) : (h3 = yh(f3.type, f3.key, f3.props, null, a3.mode, h3), h3.ref = sh(a3, d3, f3), h3.return = a3, a3 = h3);
              }
              return g2(a3);
            case wa:
              a: {
                for (l3 = f3.key; d3 !== null; ) {
                  if (d3.key === l3)
                    if (d3.tag === 4 && d3.stateNode.containerInfo === f3.containerInfo && d3.stateNode.implementation === f3.implementation) {
                      c2(a3, d3.sibling);
                      d3 = e2(d3, f3.children || []);
                      d3.return = a3;
                      a3 = d3;
                      break a;
                    } else {
                      c2(a3, d3);
                      break;
                    }
                  else
                    b2(a3, d3);
                  d3 = d3.sibling;
                }
                d3 = zh(f3, a3.mode, h3);
                d3.return = a3;
                a3 = d3;
              }
              return g2(a3);
            case Ha:
              return l3 = f3._init, J(a3, d3, l3(f3._payload), h3);
          }
          if (eb(f3))
            return n2(a3, d3, f3, h3);
          if (Ka(f3))
            return t3(a3, d3, f3, h3);
          th(a3, f3);
        }
        return typeof f3 === "string" && f3 !== "" || typeof f3 === "number" ? (f3 = "" + f3, d3 !== null && d3.tag === 6 ? (c2(a3, d3.sibling), d3 = e2(d3, f3), d3.return = a3, a3 = d3) : (c2(a3, d3), d3 = xh(f3, a3.mode, h3), d3.return = a3, a3 = d3), g2(a3)) : c2(a3, d3);
      }
      return J;
    }
    var Bh = vh(true);
    var Ch = vh(false);
    var Dh = {};
    var Eh = Uf(Dh);
    var Fh = Uf(Dh);
    var Gh = Uf(Dh);
    function Hh(a2) {
      if (a2 === Dh)
        throw Error(p2(174));
      return a2;
    }
    function Ih(a2, b2) {
      G(Gh, b2);
      G(Fh, a2);
      G(Eh, Dh);
      a2 = b2.nodeType;
      switch (a2) {
        case 9:
        case 11:
          b2 = (b2 = b2.documentElement) ? b2.namespaceURI : lb(null, "");
          break;
        default:
          a2 = a2 === 8 ? b2.parentNode : b2, b2 = a2.namespaceURI || null, a2 = a2.tagName, b2 = lb(b2, a2);
      }
      E2(Eh);
      G(Eh, b2);
    }
    function Jh() {
      E2(Eh);
      E2(Fh);
      E2(Gh);
    }
    function Kh(a2) {
      Hh(Gh.current);
      var b2 = Hh(Eh.current);
      var c2 = lb(b2, a2.type);
      b2 !== c2 && (G(Fh, a2), G(Eh, c2));
    }
    function Lh(a2) {
      Fh.current === a2 && (E2(Eh), E2(Fh));
    }
    var M2 = Uf(0);
    function Mh(a2) {
      for (var b2 = a2; b2 !== null; ) {
        if (b2.tag === 13) {
          var c2 = b2.memoizedState;
          if (c2 !== null && (c2 = c2.dehydrated, c2 === null || c2.data === "$?" || c2.data === "$!"))
            return b2;
        } else if (b2.tag === 19 && b2.memoizedProps.revealOrder !== void 0) {
          if ((b2.flags & 128) !== 0)
            return b2;
        } else if (b2.child !== null) {
          b2.child.return = b2;
          b2 = b2.child;
          continue;
        }
        if (b2 === a2)
          break;
        for (; b2.sibling === null; ) {
          if (b2.return === null || b2.return === a2)
            return null;
          b2 = b2.return;
        }
        b2.sibling.return = b2.return;
        b2 = b2.sibling;
      }
      return null;
    }
    var Nh = [];
    function Oh() {
      for (var a2 = 0; a2 < Nh.length; a2++)
        Nh[a2]._workInProgressVersionPrimary = null;
      Nh.length = 0;
    }
    var Ph = ua.ReactCurrentDispatcher;
    var Qh = ua.ReactCurrentBatchConfig;
    var Rh = 0;
    var N2 = null;
    var O2 = null;
    var P2 = null;
    var Sh = false;
    var Th = false;
    var Uh = 0;
    var Vh = 0;
    function Q() {
      throw Error(p2(321));
    }
    function Wh(a2, b2) {
      if (b2 === null)
        return false;
      for (var c2 = 0; c2 < b2.length && c2 < a2.length; c2++)
        if (!He(a2[c2], b2[c2]))
          return false;
      return true;
    }
    function Xh(a2, b2, c2, d2, e2, f2) {
      Rh = f2;
      N2 = b2;
      b2.memoizedState = null;
      b2.updateQueue = null;
      b2.lanes = 0;
      Ph.current = a2 === null || a2.memoizedState === null ? Yh : Zh;
      a2 = c2(d2, e2);
      if (Th) {
        f2 = 0;
        do {
          Th = false;
          Uh = 0;
          if (25 <= f2)
            throw Error(p2(301));
          f2 += 1;
          P2 = O2 = null;
          b2.updateQueue = null;
          Ph.current = $h;
          a2 = c2(d2, e2);
        } while (Th);
      }
      Ph.current = ai;
      b2 = O2 !== null && O2.next !== null;
      Rh = 0;
      P2 = O2 = N2 = null;
      Sh = false;
      if (b2)
        throw Error(p2(300));
      return a2;
    }
    function bi() {
      var a2 = Uh !== 0;
      Uh = 0;
      return a2;
    }
    function ci() {
      var a2 = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null };
      P2 === null ? N2.memoizedState = P2 = a2 : P2 = P2.next = a2;
      return P2;
    }
    function di() {
      if (O2 === null) {
        var a2 = N2.alternate;
        a2 = a2 !== null ? a2.memoizedState : null;
      } else
        a2 = O2.next;
      var b2 = P2 === null ? N2.memoizedState : P2.next;
      if (b2 !== null)
        P2 = b2, O2 = a2;
      else {
        if (a2 === null)
          throw Error(p2(310));
        O2 = a2;
        a2 = { memoizedState: O2.memoizedState, baseState: O2.baseState, baseQueue: O2.baseQueue, queue: O2.queue, next: null };
        P2 === null ? N2.memoizedState = P2 = a2 : P2 = P2.next = a2;
      }
      return P2;
    }
    function ei(a2, b2) {
      return typeof b2 === "function" ? b2(a2) : b2;
    }
    function fi(a2) {
      var b2 = di(), c2 = b2.queue;
      if (c2 === null)
        throw Error(p2(311));
      c2.lastRenderedReducer = a2;
      var d2 = O2, e2 = d2.baseQueue, f2 = c2.pending;
      if (f2 !== null) {
        if (e2 !== null) {
          var g2 = e2.next;
          e2.next = f2.next;
          f2.next = g2;
        }
        d2.baseQueue = e2 = f2;
        c2.pending = null;
      }
      if (e2 !== null) {
        f2 = e2.next;
        d2 = d2.baseState;
        var h2 = g2 = null, k2 = null, l2 = f2;
        do {
          var m2 = l2.lane;
          if ((Rh & m2) === m2)
            k2 !== null && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d2 = l2.hasEagerState ? l2.eagerState : a2(d2, l2.action);
          else {
            var q = {
              lane: m2,
              action: l2.action,
              hasEagerState: l2.hasEagerState,
              eagerState: l2.eagerState,
              next: null
            };
            k2 === null ? (h2 = k2 = q, g2 = d2) : k2 = k2.next = q;
            N2.lanes |= m2;
            hh |= m2;
          }
          l2 = l2.next;
        } while (l2 !== null && l2 !== f2);
        k2 === null ? g2 = d2 : k2.next = h2;
        He(d2, b2.memoizedState) || (Ug = true);
        b2.memoizedState = d2;
        b2.baseState = g2;
        b2.baseQueue = k2;
        c2.lastRenderedState = d2;
      }
      a2 = c2.interleaved;
      if (a2 !== null) {
        e2 = a2;
        do
          f2 = e2.lane, N2.lanes |= f2, hh |= f2, e2 = e2.next;
        while (e2 !== a2);
      } else
        e2 === null && (c2.lanes = 0);
      return [b2.memoizedState, c2.dispatch];
    }
    function gi(a2) {
      var b2 = di(), c2 = b2.queue;
      if (c2 === null)
        throw Error(p2(311));
      c2.lastRenderedReducer = a2;
      var d2 = c2.dispatch, e2 = c2.pending, f2 = b2.memoizedState;
      if (e2 !== null) {
        c2.pending = null;
        var g2 = e2 = e2.next;
        do
          f2 = a2(f2, g2.action), g2 = g2.next;
        while (g2 !== e2);
        He(f2, b2.memoizedState) || (Ug = true);
        b2.memoizedState = f2;
        b2.baseQueue === null && (b2.baseState = f2);
        c2.lastRenderedState = f2;
      }
      return [f2, d2];
    }
    function hi() {
    }
    function ii(a2, b2) {
      var c2 = N2, d2 = di(), e2 = b2(), f2 = !He(d2.memoizedState, e2);
      f2 && (d2.memoizedState = e2, Ug = true);
      d2 = d2.queue;
      ji(ki.bind(null, c2, d2, a2), [a2]);
      if (d2.getSnapshot !== b2 || f2 || P2 !== null && P2.memoizedState.tag & 1) {
        c2.flags |= 2048;
        li(9, mi.bind(null, c2, d2, e2, b2), void 0, null);
        if (R2 === null)
          throw Error(p2(349));
        (Rh & 30) !== 0 || ni(c2, b2, e2);
      }
      return e2;
    }
    function ni(a2, b2, c2) {
      a2.flags |= 16384;
      a2 = { getSnapshot: b2, value: c2 };
      b2 = N2.updateQueue;
      b2 === null ? (b2 = { lastEffect: null, stores: null }, N2.updateQueue = b2, b2.stores = [a2]) : (c2 = b2.stores, c2 === null ? b2.stores = [a2] : c2.push(a2));
    }
    function mi(a2, b2, c2, d2) {
      b2.value = c2;
      b2.getSnapshot = d2;
      oi(b2) && pi(a2);
    }
    function ki(a2, b2, c2) {
      return c2(function() {
        oi(b2) && pi(a2);
      });
    }
    function oi(a2) {
      var b2 = a2.getSnapshot;
      a2 = a2.value;
      try {
        var c2 = b2();
        return !He(a2, c2);
      } catch (d2) {
        return true;
      }
    }
    function pi(a2) {
      var b2 = Zg(a2, 1);
      b2 !== null && mh(b2, a2, 1, -1);
    }
    function qi(a2) {
      var b2 = ci();
      typeof a2 === "function" && (a2 = a2());
      b2.memoizedState = b2.baseState = a2;
      a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: ei, lastRenderedState: a2 };
      b2.queue = a2;
      a2 = a2.dispatch = ri.bind(null, N2, a2);
      return [b2.memoizedState, a2];
    }
    function li(a2, b2, c2, d2) {
      a2 = { tag: a2, create: b2, destroy: c2, deps: d2, next: null };
      b2 = N2.updateQueue;
      b2 === null ? (b2 = { lastEffect: null, stores: null }, N2.updateQueue = b2, b2.lastEffect = a2.next = a2) : (c2 = b2.lastEffect, c2 === null ? b2.lastEffect = a2.next = a2 : (d2 = c2.next, c2.next = a2, a2.next = d2, b2.lastEffect = a2));
      return a2;
    }
    function si() {
      return di().memoizedState;
    }
    function ti(a2, b2, c2, d2) {
      var e2 = ci();
      N2.flags |= a2;
      e2.memoizedState = li(1 | b2, c2, void 0, d2 === void 0 ? null : d2);
    }
    function ui(a2, b2, c2, d2) {
      var e2 = di();
      d2 = d2 === void 0 ? null : d2;
      var f2 = void 0;
      if (O2 !== null) {
        var g2 = O2.memoizedState;
        f2 = g2.destroy;
        if (d2 !== null && Wh(d2, g2.deps)) {
          e2.memoizedState = li(b2, c2, f2, d2);
          return;
        }
      }
      N2.flags |= a2;
      e2.memoizedState = li(1 | b2, c2, f2, d2);
    }
    function vi(a2, b2) {
      return ti(8390656, 8, a2, b2);
    }
    function ji(a2, b2) {
      return ui(2048, 8, a2, b2);
    }
    function wi(a2, b2) {
      return ui(4, 2, a2, b2);
    }
    function xi(a2, b2) {
      return ui(4, 4, a2, b2);
    }
    function yi(a2, b2) {
      if (typeof b2 === "function")
        return a2 = a2(), b2(a2), function() {
          b2(null);
        };
      if (b2 !== null && b2 !== void 0)
        return a2 = a2(), b2.current = a2, function() {
          b2.current = null;
        };
    }
    function zi(a2, b2, c2) {
      c2 = c2 !== null && c2 !== void 0 ? c2.concat([a2]) : null;
      return ui(4, 4, yi.bind(null, b2, a2), c2);
    }
    function Ai() {
    }
    function Bi(a2, b2) {
      var c2 = di();
      b2 = b2 === void 0 ? null : b2;
      var d2 = c2.memoizedState;
      if (d2 !== null && b2 !== null && Wh(b2, d2[1]))
        return d2[0];
      c2.memoizedState = [a2, b2];
      return a2;
    }
    function Ci(a2, b2) {
      var c2 = di();
      b2 = b2 === void 0 ? null : b2;
      var d2 = c2.memoizedState;
      if (d2 !== null && b2 !== null && Wh(b2, d2[1]))
        return d2[0];
      a2 = a2();
      c2.memoizedState = [a2, b2];
      return a2;
    }
    function Di(a2, b2, c2) {
      if ((Rh & 21) === 0)
        return a2.baseState && (a2.baseState = false, Ug = true), a2.memoizedState = c2;
      He(c2, b2) || (c2 = yc(), N2.lanes |= c2, hh |= c2, a2.baseState = true);
      return b2;
    }
    function Ei(a2, b2) {
      var c2 = C2;
      C2 = c2 !== 0 && 4 > c2 ? c2 : 4;
      a2(true);
      var d2 = Qh.transition;
      Qh.transition = {};
      try {
        a2(false), b2();
      } finally {
        C2 = c2, Qh.transition = d2;
      }
    }
    function Fi() {
      return di().memoizedState;
    }
    function Gi(a2, b2, c2) {
      var d2 = lh(a2);
      c2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null };
      if (Hi(a2))
        Ii(b2, c2);
      else if (c2 = Yg(a2, b2, c2, d2), c2 !== null) {
        var e2 = L2();
        mh(c2, a2, d2, e2);
        Ji(c2, b2, d2);
      }
    }
    function ri(a2, b2, c2) {
      var d2 = lh(a2), e2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null };
      if (Hi(a2))
        Ii(b2, e2);
      else {
        var f2 = a2.alternate;
        if (a2.lanes === 0 && (f2 === null || f2.lanes === 0) && (f2 = b2.lastRenderedReducer, f2 !== null))
          try {
            var g2 = b2.lastRenderedState, h2 = f2(g2, c2);
            e2.hasEagerState = true;
            e2.eagerState = h2;
            if (He(h2, g2)) {
              var k2 = b2.interleaved;
              k2 === null ? (e2.next = e2, Xg(b2)) : (e2.next = k2.next, k2.next = e2);
              b2.interleaved = e2;
              return;
            }
          } catch (l2) {
          } finally {
          }
        c2 = Yg(a2, b2, e2, d2);
        c2 !== null && (e2 = L2(), mh(c2, a2, d2, e2), Ji(c2, b2, d2));
      }
    }
    function Hi(a2) {
      var b2 = a2.alternate;
      return a2 === N2 || b2 !== null && b2 === N2;
    }
    function Ii(a2, b2) {
      Th = Sh = true;
      var c2 = a2.pending;
      c2 === null ? b2.next = b2 : (b2.next = c2.next, c2.next = b2);
      a2.pending = b2;
    }
    function Ji(a2, b2, c2) {
      if ((c2 & 4194240) !== 0) {
        var d2 = b2.lanes;
        d2 &= a2.pendingLanes;
        c2 |= d2;
        b2.lanes = c2;
        Cc(a2, c2);
      }
    }
    var ai = { readContext: Vg, useCallback: Q, useContext: Q, useEffect: Q, useImperativeHandle: Q, useInsertionEffect: Q, useLayoutEffect: Q, useMemo: Q, useReducer: Q, useRef: Q, useState: Q, useDebugValue: Q, useDeferredValue: Q, useTransition: Q, useMutableSource: Q, useSyncExternalStore: Q, useId: Q, unstable_isNewReconciler: false };
    var Yh = { readContext: Vg, useCallback: function(a2, b2) {
      ci().memoizedState = [a2, b2 === void 0 ? null : b2];
      return a2;
    }, useContext: Vg, useEffect: vi, useImperativeHandle: function(a2, b2, c2) {
      c2 = c2 !== null && c2 !== void 0 ? c2.concat([a2]) : null;
      return ti(4194308, 4, yi.bind(null, b2, a2), c2);
    }, useLayoutEffect: function(a2, b2) {
      return ti(4194308, 4, a2, b2);
    }, useInsertionEffect: function(a2, b2) {
      return ti(4, 2, a2, b2);
    }, useMemo: function(a2, b2) {
      var c2 = ci();
      b2 = b2 === void 0 ? null : b2;
      a2 = a2();
      c2.memoizedState = [a2, b2];
      return a2;
    }, useReducer: function(a2, b2, c2) {
      var d2 = ci();
      b2 = c2 !== void 0 ? c2(b2) : b2;
      d2.memoizedState = d2.baseState = b2;
      a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a2, lastRenderedState: b2 };
      d2.queue = a2;
      a2 = a2.dispatch = Gi.bind(null, N2, a2);
      return [d2.memoizedState, a2];
    }, useRef: function(a2) {
      var b2 = ci();
      a2 = { current: a2 };
      return b2.memoizedState = a2;
    }, useState: qi, useDebugValue: Ai, useDeferredValue: function(a2) {
      return ci().memoizedState = a2;
    }, useTransition: function() {
      var a2 = qi(false), b2 = a2[0];
      a2 = Ei.bind(null, a2[1]);
      ci().memoizedState = a2;
      return [b2, a2];
    }, useMutableSource: function() {
    }, useSyncExternalStore: function(a2, b2, c2) {
      var d2 = N2, e2 = ci();
      if (I2) {
        if (c2 === void 0)
          throw Error(p2(407));
        c2 = c2();
      } else {
        c2 = b2();
        if (R2 === null)
          throw Error(p2(349));
        (Rh & 30) !== 0 || ni(d2, b2, c2);
      }
      e2.memoizedState = c2;
      var f2 = { value: c2, getSnapshot: b2 };
      e2.queue = f2;
      vi(ki.bind(null, d2, f2, a2), [a2]);
      d2.flags |= 2048;
      li(9, mi.bind(null, d2, f2, c2, b2), void 0, null);
      return c2;
    }, useId: function() {
      var a2 = ci(), b2 = R2.identifierPrefix;
      if (I2) {
        var c2 = sg;
        var d2 = rg;
        c2 = (d2 & ~(1 << 32 - oc(d2) - 1)).toString(32) + c2;
        b2 = ":" + b2 + "R" + c2;
        c2 = Uh++;
        0 < c2 && (b2 += "H" + c2.toString(32));
        b2 += ":";
      } else
        c2 = Vh++, b2 = ":" + b2 + "r" + c2.toString(32) + ":";
      return a2.memoizedState = b2;
    }, unstable_isNewReconciler: false };
    var Zh = {
      readContext: Vg,
      useCallback: Bi,
      useContext: Vg,
      useEffect: ji,
      useImperativeHandle: zi,
      useInsertionEffect: wi,
      useLayoutEffect: xi,
      useMemo: Ci,
      useReducer: fi,
      useRef: si,
      useState: function() {
        return fi(ei);
      },
      useDebugValue: Ai,
      useDeferredValue: function(a2) {
        var b2 = di();
        return Di(b2, O2.memoizedState, a2);
      },
      useTransition: function() {
        var a2 = fi(ei)[0], b2 = di().memoizedState;
        return [a2, b2];
      },
      useMutableSource: hi,
      useSyncExternalStore: ii,
      useId: Fi,
      unstable_isNewReconciler: false
    };
    var $h = { readContext: Vg, useCallback: Bi, useContext: Vg, useEffect: ji, useImperativeHandle: zi, useInsertionEffect: wi, useLayoutEffect: xi, useMemo: Ci, useReducer: gi, useRef: si, useState: function() {
      return gi(ei);
    }, useDebugValue: Ai, useDeferredValue: function(a2) {
      var b2 = di();
      return O2 === null ? b2.memoizedState = a2 : Di(b2, O2.memoizedState, a2);
    }, useTransition: function() {
      var a2 = gi(ei)[0], b2 = di().memoizedState;
      return [a2, b2];
    }, useMutableSource: hi, useSyncExternalStore: ii, useId: Fi, unstable_isNewReconciler: false };
    function Ki(a2, b2) {
      try {
        var c2 = "", d2 = b2;
        do
          c2 += Pa(d2), d2 = d2.return;
        while (d2);
        var e2 = c2;
      } catch (f2) {
        e2 = "\nError generating stack: " + f2.message + "\n" + f2.stack;
      }
      return { value: a2, source: b2, stack: e2, digest: null };
    }
    function Li(a2, b2, c2) {
      return { value: a2, source: null, stack: c2 != null ? c2 : null, digest: b2 != null ? b2 : null };
    }
    function Mi(a2, b2) {
      try {
        console.error(b2.value);
      } catch (c2) {
        setTimeout(function() {
          throw c2;
        });
      }
    }
    var Ni = typeof WeakMap === "function" ? WeakMap : Map;
    function Oi(a2, b2, c2) {
      c2 = ch(-1, c2);
      c2.tag = 3;
      c2.payload = { element: null };
      var d2 = b2.value;
      c2.callback = function() {
        Pi || (Pi = true, Qi = d2);
        Mi(a2, b2);
      };
      return c2;
    }
    function Ri(a2, b2, c2) {
      c2 = ch(-1, c2);
      c2.tag = 3;
      var d2 = a2.type.getDerivedStateFromError;
      if (typeof d2 === "function") {
        var e2 = b2.value;
        c2.payload = function() {
          return d2(e2);
        };
        c2.callback = function() {
          Mi(a2, b2);
        };
      }
      var f2 = a2.stateNode;
      f2 !== null && typeof f2.componentDidCatch === "function" && (c2.callback = function() {
        Mi(a2, b2);
        typeof d2 !== "function" && (Si === null ? Si = /* @__PURE__ */ new Set([this]) : Si.add(this));
        var c3 = b2.stack;
        this.componentDidCatch(b2.value, { componentStack: c3 !== null ? c3 : "" });
      });
      return c2;
    }
    function Ti(a2, b2, c2) {
      var d2 = a2.pingCache;
      if (d2 === null) {
        d2 = a2.pingCache = new Ni();
        var e2 = /* @__PURE__ */ new Set();
        d2.set(b2, e2);
      } else
        e2 = d2.get(b2), e2 === void 0 && (e2 = /* @__PURE__ */ new Set(), d2.set(b2, e2));
      e2.has(c2) || (e2.add(c2), a2 = Ui.bind(null, a2, b2, c2), b2.then(a2, a2));
    }
    function Vi(a2) {
      do {
        var b2;
        if (b2 = a2.tag === 13)
          b2 = a2.memoizedState, b2 = b2 !== null ? b2.dehydrated !== null ? true : false : true;
        if (b2)
          return a2;
        a2 = a2.return;
      } while (a2 !== null);
      return null;
    }
    function Wi(a2, b2, c2, d2, e2) {
      if ((a2.mode & 1) === 0)
        return a2 === b2 ? a2.flags |= 65536 : (a2.flags |= 128, c2.flags |= 131072, c2.flags &= -52805, c2.tag === 1 && (c2.alternate === null ? c2.tag = 17 : (b2 = ch(-1, 1), b2.tag = 2, dh(c2, b2, 1))), c2.lanes |= 1), a2;
      a2.flags |= 65536;
      a2.lanes = e2;
      return a2;
    }
    var Xi = ua.ReactCurrentOwner;
    var Ug = false;
    function Yi(a2, b2, c2, d2) {
      b2.child = a2 === null ? Ch(b2, null, c2, d2) : Bh(b2, a2.child, c2, d2);
    }
    function Zi(a2, b2, c2, d2, e2) {
      c2 = c2.render;
      var f2 = b2.ref;
      Tg(b2, e2);
      d2 = Xh(a2, b2, c2, d2, f2, e2);
      c2 = bi();
      if (a2 !== null && !Ug)
        return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e2, $i(a2, b2, e2);
      I2 && c2 && vg(b2);
      b2.flags |= 1;
      Yi(a2, b2, d2, e2);
      return b2.child;
    }
    function aj(a2, b2, c2, d2, e2) {
      if (a2 === null) {
        var f2 = c2.type;
        if (typeof f2 === "function" && !bj(f2) && f2.defaultProps === void 0 && c2.compare === null && c2.defaultProps === void 0)
          return b2.tag = 15, b2.type = f2, cj(a2, b2, f2, d2, e2);
        a2 = yh(c2.type, null, d2, b2, b2.mode, e2);
        a2.ref = b2.ref;
        a2.return = b2;
        return b2.child = a2;
      }
      f2 = a2.child;
      if ((a2.lanes & e2) === 0) {
        var g2 = f2.memoizedProps;
        c2 = c2.compare;
        c2 = c2 !== null ? c2 : Ie;
        if (c2(g2, d2) && a2.ref === b2.ref)
          return $i(a2, b2, e2);
      }
      b2.flags |= 1;
      a2 = wh(f2, d2);
      a2.ref = b2.ref;
      a2.return = b2;
      return b2.child = a2;
    }
    function cj(a2, b2, c2, d2, e2) {
      if (a2 !== null) {
        var f2 = a2.memoizedProps;
        if (Ie(f2, d2) && a2.ref === b2.ref)
          if (Ug = false, b2.pendingProps = d2 = f2, (a2.lanes & e2) !== 0)
            (a2.flags & 131072) !== 0 && (Ug = true);
          else
            return b2.lanes = a2.lanes, $i(a2, b2, e2);
      }
      return dj(a2, b2, c2, d2, e2);
    }
    function ej(a2, b2, c2) {
      var d2 = b2.pendingProps, e2 = d2.children, f2 = a2 !== null ? a2.memoizedState : null;
      if (d2.mode === "hidden")
        if ((b2.mode & 1) === 0)
          b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G(fj, gj), gj |= c2;
        else {
          if ((c2 & 1073741824) === 0)
            return a2 = f2 !== null ? f2.baseLanes | c2 : c2, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a2, cachePool: null, transitions: null }, b2.updateQueue = null, G(fj, gj), gj |= a2, null;
          b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null };
          d2 = f2 !== null ? f2.baseLanes : c2;
          G(fj, gj);
          gj |= d2;
        }
      else
        f2 !== null ? (d2 = f2.baseLanes | c2, b2.memoizedState = null) : d2 = c2, G(fj, gj), gj |= d2;
      Yi(a2, b2, e2, c2);
      return b2.child;
    }
    function hj(a2, b2) {
      var c2 = b2.ref;
      if (a2 === null && c2 !== null || a2 !== null && a2.ref !== c2)
        b2.flags |= 512, b2.flags |= 2097152;
    }
    function dj(a2, b2, c2, d2, e2) {
      var f2 = Zf(c2) ? Xf : H.current;
      f2 = Yf(b2, f2);
      Tg(b2, e2);
      c2 = Xh(a2, b2, c2, d2, f2, e2);
      d2 = bi();
      if (a2 !== null && !Ug)
        return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e2, $i(a2, b2, e2);
      I2 && d2 && vg(b2);
      b2.flags |= 1;
      Yi(a2, b2, c2, e2);
      return b2.child;
    }
    function ij(a2, b2, c2, d2, e2) {
      if (Zf(c2)) {
        var f2 = true;
        cg(b2);
      } else
        f2 = false;
      Tg(b2, e2);
      if (b2.stateNode === null)
        jj(a2, b2), ph(b2, c2, d2), rh(b2, c2, d2, e2), d2 = true;
      else if (a2 === null) {
        var g2 = b2.stateNode, h2 = b2.memoizedProps;
        g2.props = h2;
        var k2 = g2.context, l2 = c2.contextType;
        typeof l2 === "object" && l2 !== null ? l2 = Vg(l2) : (l2 = Zf(c2) ? Xf : H.current, l2 = Yf(b2, l2));
        var m2 = c2.getDerivedStateFromProps, q = typeof m2 === "function" || typeof g2.getSnapshotBeforeUpdate === "function";
        q || typeof g2.UNSAFE_componentWillReceiveProps !== "function" && typeof g2.componentWillReceiveProps !== "function" || (h2 !== d2 || k2 !== l2) && qh(b2, g2, d2, l2);
        $g = false;
        var r2 = b2.memoizedState;
        g2.state = r2;
        gh(b2, d2, g2, e2);
        k2 = b2.memoizedState;
        h2 !== d2 || r2 !== k2 || Wf.current || $g ? (typeof m2 === "function" && (kh(b2, c2, m2, d2), k2 = b2.memoizedState), (h2 = $g || oh(b2, c2, h2, d2, r2, k2, l2)) ? (q || typeof g2.UNSAFE_componentWillMount !== "function" && typeof g2.componentWillMount !== "function" || (typeof g2.componentWillMount === "function" && g2.componentWillMount(), typeof g2.UNSAFE_componentWillMount === "function" && g2.UNSAFE_componentWillMount()), typeof g2.componentDidMount === "function" && (b2.flags |= 4194308)) : (typeof g2.componentDidMount === "function" && (b2.flags |= 4194308), b2.memoizedProps = d2, b2.memoizedState = k2), g2.props = d2, g2.state = k2, g2.context = l2, d2 = h2) : (typeof g2.componentDidMount === "function" && (b2.flags |= 4194308), d2 = false);
      } else {
        g2 = b2.stateNode;
        bh(a2, b2);
        h2 = b2.memoizedProps;
        l2 = b2.type === b2.elementType ? h2 : Lg(b2.type, h2);
        g2.props = l2;
        q = b2.pendingProps;
        r2 = g2.context;
        k2 = c2.contextType;
        typeof k2 === "object" && k2 !== null ? k2 = Vg(k2) : (k2 = Zf(c2) ? Xf : H.current, k2 = Yf(b2, k2));
        var y2 = c2.getDerivedStateFromProps;
        (m2 = typeof y2 === "function" || typeof g2.getSnapshotBeforeUpdate === "function") || typeof g2.UNSAFE_componentWillReceiveProps !== "function" && typeof g2.componentWillReceiveProps !== "function" || (h2 !== q || r2 !== k2) && qh(b2, g2, d2, k2);
        $g = false;
        r2 = b2.memoizedState;
        g2.state = r2;
        gh(b2, d2, g2, e2);
        var n2 = b2.memoizedState;
        h2 !== q || r2 !== n2 || Wf.current || $g ? (typeof y2 === "function" && (kh(b2, c2, y2, d2), n2 = b2.memoizedState), (l2 = $g || oh(b2, c2, l2, d2, r2, n2, k2) || false) ? (m2 || typeof g2.UNSAFE_componentWillUpdate !== "function" && typeof g2.componentWillUpdate !== "function" || (typeof g2.componentWillUpdate === "function" && g2.componentWillUpdate(d2, n2, k2), typeof g2.UNSAFE_componentWillUpdate === "function" && g2.UNSAFE_componentWillUpdate(d2, n2, k2)), typeof g2.componentDidUpdate === "function" && (b2.flags |= 4), typeof g2.getSnapshotBeforeUpdate === "function" && (b2.flags |= 1024)) : (typeof g2.componentDidUpdate !== "function" || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), typeof g2.getSnapshotBeforeUpdate !== "function" || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), b2.memoizedProps = d2, b2.memoizedState = n2), g2.props = d2, g2.state = n2, g2.context = k2, d2 = l2) : (typeof g2.componentDidUpdate !== "function" || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), typeof g2.getSnapshotBeforeUpdate !== "function" || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), d2 = false);
      }
      return kj(a2, b2, c2, d2, f2, e2);
    }
    function kj(a2, b2, c2, d2, e2, f2) {
      hj(a2, b2);
      var g2 = (b2.flags & 128) !== 0;
      if (!d2 && !g2)
        return e2 && dg(b2, c2, false), $i(a2, b2, f2);
      d2 = b2.stateNode;
      Xi.current = b2;
      var h2 = g2 && typeof c2.getDerivedStateFromError !== "function" ? null : d2.render();
      b2.flags |= 1;
      a2 !== null && g2 ? (b2.child = Bh(b2, a2.child, null, f2), b2.child = Bh(b2, null, h2, f2)) : Yi(a2, b2, h2, f2);
      b2.memoizedState = d2.state;
      e2 && dg(b2, c2, true);
      return b2.child;
    }
    function lj(a2) {
      var b2 = a2.stateNode;
      b2.pendingContext ? ag(a2, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ag(a2, b2.context, false);
      Ih(a2, b2.containerInfo);
    }
    function mj(a2, b2, c2, d2, e2) {
      Ig();
      Jg(e2);
      b2.flags |= 256;
      Yi(a2, b2, c2, d2);
      return b2.child;
    }
    var nj = { dehydrated: null, treeContext: null, retryLane: 0 };
    function oj(a2) {
      return { baseLanes: a2, cachePool: null, transitions: null };
    }
    function pj(a2, b2, c2) {
      var d2 = b2.pendingProps, e2 = M2.current, f2 = false, g2 = (b2.flags & 128) !== 0, h2;
      (h2 = g2) || (h2 = a2 !== null && a2.memoizedState === null ? false : (e2 & 2) !== 0);
      if (h2)
        f2 = true, b2.flags &= -129;
      else if (a2 === null || a2.memoizedState !== null)
        e2 |= 1;
      G(M2, e2 & 1);
      if (a2 === null) {
        Eg(b2);
        a2 = b2.memoizedState;
        if (a2 !== null && (a2 = a2.dehydrated, a2 !== null))
          return (b2.mode & 1) === 0 ? b2.lanes = 1 : a2.data === "$!" ? b2.lanes = 8 : b2.lanes = 1073741824, null;
        g2 = d2.children;
        a2 = d2.fallback;
        return f2 ? (d2 = b2.mode, f2 = b2.child, g2 = { mode: "hidden", children: g2 }, (d2 & 1) === 0 && f2 !== null ? (f2.childLanes = 0, f2.pendingProps = g2) : f2 = qj(g2, d2, 0, null), a2 = Ah(a2, d2, c2, null), f2.return = b2, a2.return = b2, f2.sibling = a2, b2.child = f2, b2.child.memoizedState = oj(c2), b2.memoizedState = nj, a2) : rj(b2, g2);
      }
      e2 = a2.memoizedState;
      if (e2 !== null && (h2 = e2.dehydrated, h2 !== null))
        return sj(a2, b2, g2, d2, h2, e2, c2);
      if (f2) {
        f2 = d2.fallback;
        g2 = b2.mode;
        e2 = a2.child;
        h2 = e2.sibling;
        var k2 = { mode: "hidden", children: d2.children };
        (g2 & 1) === 0 && b2.child !== e2 ? (d2 = b2.child, d2.childLanes = 0, d2.pendingProps = k2, b2.deletions = null) : (d2 = wh(e2, k2), d2.subtreeFlags = e2.subtreeFlags & 14680064);
        h2 !== null ? f2 = wh(h2, f2) : (f2 = Ah(f2, g2, c2, null), f2.flags |= 2);
        f2.return = b2;
        d2.return = b2;
        d2.sibling = f2;
        b2.child = d2;
        d2 = f2;
        f2 = b2.child;
        g2 = a2.child.memoizedState;
        g2 = g2 === null ? oj(c2) : { baseLanes: g2.baseLanes | c2, cachePool: null, transitions: g2.transitions };
        f2.memoizedState = g2;
        f2.childLanes = a2.childLanes & ~c2;
        b2.memoizedState = nj;
        return d2;
      }
      f2 = a2.child;
      a2 = f2.sibling;
      d2 = wh(f2, { mode: "visible", children: d2.children });
      (b2.mode & 1) === 0 && (d2.lanes = c2);
      d2.return = b2;
      d2.sibling = null;
      a2 !== null && (c2 = b2.deletions, c2 === null ? (b2.deletions = [a2], b2.flags |= 16) : c2.push(a2));
      b2.child = d2;
      b2.memoizedState = null;
      return d2;
    }
    function rj(a2, b2) {
      b2 = qj({ mode: "visible", children: b2 }, a2.mode, 0, null);
      b2.return = a2;
      return a2.child = b2;
    }
    function tj(a2, b2, c2, d2) {
      d2 !== null && Jg(d2);
      Bh(b2, a2.child, null, c2);
      a2 = rj(b2, b2.pendingProps.children);
      a2.flags |= 2;
      b2.memoizedState = null;
      return a2;
    }
    function sj(a2, b2, c2, d2, e2, f2, g2) {
      if (c2) {
        if (b2.flags & 256)
          return b2.flags &= -257, d2 = Li(Error(p2(422))), tj(a2, b2, g2, d2);
        if (b2.memoizedState !== null)
          return b2.child = a2.child, b2.flags |= 128, null;
        f2 = d2.fallback;
        e2 = b2.mode;
        d2 = qj({ mode: "visible", children: d2.children }, e2, 0, null);
        f2 = Ah(f2, e2, g2, null);
        f2.flags |= 2;
        d2.return = b2;
        f2.return = b2;
        d2.sibling = f2;
        b2.child = d2;
        (b2.mode & 1) !== 0 && Bh(b2, a2.child, null, g2);
        b2.child.memoizedState = oj(g2);
        b2.memoizedState = nj;
        return f2;
      }
      if ((b2.mode & 1) === 0)
        return tj(a2, b2, g2, null);
      if (e2.data === "$!") {
        d2 = e2.nextSibling && e2.nextSibling.dataset;
        if (d2)
          var h2 = d2.dgst;
        d2 = h2;
        f2 = Error(p2(419));
        d2 = Li(f2, d2, void 0);
        return tj(a2, b2, g2, d2);
      }
      h2 = (g2 & a2.childLanes) !== 0;
      if (Ug || h2) {
        d2 = R2;
        if (d2 !== null) {
          switch (g2 & -g2) {
            case 4:
              e2 = 2;
              break;
            case 16:
              e2 = 8;
              break;
            case 64:
            case 128:
            case 256:
            case 512:
            case 1024:
            case 2048:
            case 4096:
            case 8192:
            case 16384:
            case 32768:
            case 65536:
            case 131072:
            case 262144:
            case 524288:
            case 1048576:
            case 2097152:
            case 4194304:
            case 8388608:
            case 16777216:
            case 33554432:
            case 67108864:
              e2 = 32;
              break;
            case 536870912:
              e2 = 268435456;
              break;
            default:
              e2 = 0;
          }
          e2 = (e2 & (d2.suspendedLanes | g2)) !== 0 ? 0 : e2;
          e2 !== 0 && e2 !== f2.retryLane && (f2.retryLane = e2, Zg(a2, e2), mh(d2, a2, e2, -1));
        }
        uj();
        d2 = Li(Error(p2(421)));
        return tj(a2, b2, g2, d2);
      }
      if (e2.data === "$?")
        return b2.flags |= 128, b2.child = a2.child, b2 = vj.bind(null, a2), e2._reactRetry = b2, null;
      a2 = f2.treeContext;
      yg = Lf(e2.nextSibling);
      xg = b2;
      I2 = true;
      zg = null;
      a2 !== null && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a2.id, sg = a2.overflow, qg = b2);
      b2 = rj(b2, d2.children);
      b2.flags |= 4096;
      return b2;
    }
    function wj(a2, b2, c2) {
      a2.lanes |= b2;
      var d2 = a2.alternate;
      d2 !== null && (d2.lanes |= b2);
      Sg(a2.return, b2, c2);
    }
    function xj(a2, b2, c2, d2, e2) {
      var f2 = a2.memoizedState;
      f2 === null ? a2.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d2, tail: c2, tailMode: e2 } : (f2.isBackwards = b2, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d2, f2.tail = c2, f2.tailMode = e2);
    }
    function yj(a2, b2, c2) {
      var d2 = b2.pendingProps, e2 = d2.revealOrder, f2 = d2.tail;
      Yi(a2, b2, d2.children, c2);
      d2 = M2.current;
      if ((d2 & 2) !== 0)
        d2 = d2 & 1 | 2, b2.flags |= 128;
      else {
        if (a2 !== null && (a2.flags & 128) !== 0)
          a:
            for (a2 = b2.child; a2 !== null; ) {
              if (a2.tag === 13)
                a2.memoizedState !== null && wj(a2, c2, b2);
              else if (a2.tag === 19)
                wj(a2, c2, b2);
              else if (a2.child !== null) {
                a2.child.return = a2;
                a2 = a2.child;
                continue;
              }
              if (a2 === b2)
                break a;
              for (; a2.sibling === null; ) {
                if (a2.return === null || a2.return === b2)
                  break a;
                a2 = a2.return;
              }
              a2.sibling.return = a2.return;
              a2 = a2.sibling;
            }
        d2 &= 1;
      }
      G(M2, d2);
      if ((b2.mode & 1) === 0)
        b2.memoizedState = null;
      else
        switch (e2) {
          case "forwards":
            c2 = b2.child;
            for (e2 = null; c2 !== null; )
              a2 = c2.alternate, a2 !== null && Mh(a2) === null && (e2 = c2), c2 = c2.sibling;
            c2 = e2;
            c2 === null ? (e2 = b2.child, b2.child = null) : (e2 = c2.sibling, c2.sibling = null);
            xj(b2, false, e2, c2, f2);
            break;
          case "backwards":
            c2 = null;
            e2 = b2.child;
            for (b2.child = null; e2 !== null; ) {
              a2 = e2.alternate;
              if (a2 !== null && Mh(a2) === null) {
                b2.child = e2;
                break;
              }
              a2 = e2.sibling;
              e2.sibling = c2;
              c2 = e2;
              e2 = a2;
            }
            xj(b2, true, c2, null, f2);
            break;
          case "together":
            xj(b2, false, null, null, void 0);
            break;
          default:
            b2.memoizedState = null;
        }
      return b2.child;
    }
    function jj(a2, b2) {
      (b2.mode & 1) === 0 && a2 !== null && (a2.alternate = null, b2.alternate = null, b2.flags |= 2);
    }
    function $i(a2, b2, c2) {
      a2 !== null && (b2.dependencies = a2.dependencies);
      hh |= b2.lanes;
      if ((c2 & b2.childLanes) === 0)
        return null;
      if (a2 !== null && b2.child !== a2.child)
        throw Error(p2(153));
      if (b2.child !== null) {
        a2 = b2.child;
        c2 = wh(a2, a2.pendingProps);
        b2.child = c2;
        for (c2.return = b2; a2.sibling !== null; )
          a2 = a2.sibling, c2 = c2.sibling = wh(a2, a2.pendingProps), c2.return = b2;
        c2.sibling = null;
      }
      return b2.child;
    }
    function zj(a2, b2, c2) {
      switch (b2.tag) {
        case 3:
          lj(b2);
          Ig();
          break;
        case 5:
          Kh(b2);
          break;
        case 1:
          Zf(b2.type) && cg(b2);
          break;
        case 4:
          Ih(b2, b2.stateNode.containerInfo);
          break;
        case 10:
          var d2 = b2.type._context, e2 = b2.memoizedProps.value;
          G(Mg, d2._currentValue);
          d2._currentValue = e2;
          break;
        case 13:
          d2 = b2.memoizedState;
          if (d2 !== null) {
            if (d2.dehydrated !== null)
              return G(M2, M2.current & 1), b2.flags |= 128, null;
            if ((c2 & b2.child.childLanes) !== 0)
              return pj(a2, b2, c2);
            G(M2, M2.current & 1);
            a2 = $i(a2, b2, c2);
            return a2 !== null ? a2.sibling : null;
          }
          G(M2, M2.current & 1);
          break;
        case 19:
          d2 = (c2 & b2.childLanes) !== 0;
          if ((a2.flags & 128) !== 0) {
            if (d2)
              return yj(a2, b2, c2);
            b2.flags |= 128;
          }
          e2 = b2.memoizedState;
          e2 !== null && (e2.rendering = null, e2.tail = null, e2.lastEffect = null);
          G(M2, M2.current);
          if (d2)
            break;
          else
            return null;
        case 22:
        case 23:
          return b2.lanes = 0, ej(a2, b2, c2);
      }
      return $i(a2, b2, c2);
    }
    var Aj;
    var Bj;
    var Cj;
    var Dj;
    Aj = function(a2, b2) {
      for (var c2 = b2.child; c2 !== null; ) {
        if (c2.tag === 5 || c2.tag === 6)
          a2.appendChild(c2.stateNode);
        else if (c2.tag !== 4 && c2.child !== null) {
          c2.child.return = c2;
          c2 = c2.child;
          continue;
        }
        if (c2 === b2)
          break;
        for (; c2.sibling === null; ) {
          if (c2.return === null || c2.return === b2)
            return;
          c2 = c2.return;
        }
        c2.sibling.return = c2.return;
        c2 = c2.sibling;
      }
    };
    Bj = function() {
    };
    Cj = function(a2, b2, c2, d2) {
      var e2 = a2.memoizedProps;
      if (e2 !== d2) {
        a2 = b2.stateNode;
        Hh(Eh.current);
        var f2 = null;
        switch (c2) {
          case "input":
            e2 = Ya(a2, e2);
            d2 = Ya(a2, d2);
            f2 = [];
            break;
          case "select":
            e2 = A2({}, e2, { value: void 0 });
            d2 = A2({}, d2, { value: void 0 });
            f2 = [];
            break;
          case "textarea":
            e2 = gb(a2, e2);
            d2 = gb(a2, d2);
            f2 = [];
            break;
          default:
            typeof e2.onClick !== "function" && typeof d2.onClick === "function" && (a2.onclick = Bf);
        }
        ub(c2, d2);
        var g2;
        c2 = null;
        for (l2 in e2)
          if (!d2.hasOwnProperty(l2) && e2.hasOwnProperty(l2) && e2[l2] != null)
            if (l2 === "style") {
              var h2 = e2[l2];
              for (g2 in h2)
                h2.hasOwnProperty(g2) && (c2 || (c2 = {}), c2[g2] = "");
            } else
              l2 !== "dangerouslySetInnerHTML" && l2 !== "children" && l2 !== "suppressContentEditableWarning" && l2 !== "suppressHydrationWarning" && l2 !== "autoFocus" && (ea.hasOwnProperty(l2) ? f2 || (f2 = []) : (f2 = f2 || []).push(l2, null));
        for (l2 in d2) {
          var k2 = d2[l2];
          h2 = e2 != null ? e2[l2] : void 0;
          if (d2.hasOwnProperty(l2) && k2 !== h2 && (k2 != null || h2 != null))
            if (l2 === "style")
              if (h2) {
                for (g2 in h2)
                  !h2.hasOwnProperty(g2) || k2 && k2.hasOwnProperty(g2) || (c2 || (c2 = {}), c2[g2] = "");
                for (g2 in k2)
                  k2.hasOwnProperty(g2) && h2[g2] !== k2[g2] && (c2 || (c2 = {}), c2[g2] = k2[g2]);
              } else
                c2 || (f2 || (f2 = []), f2.push(l2, c2)), c2 = k2;
            else
              l2 === "dangerouslySetInnerHTML" ? (k2 = k2 ? k2.__html : void 0, h2 = h2 ? h2.__html : void 0, k2 != null && h2 !== k2 && (f2 = f2 || []).push(l2, k2)) : l2 === "children" ? typeof k2 !== "string" && typeof k2 !== "number" || (f2 = f2 || []).push(l2, "" + k2) : l2 !== "suppressContentEditableWarning" && l2 !== "suppressHydrationWarning" && (ea.hasOwnProperty(l2) ? (k2 != null && l2 === "onScroll" && D2("scroll", a2), f2 || h2 === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2));
        }
        c2 && (f2 = f2 || []).push("style", c2);
        var l2 = f2;
        if (b2.updateQueue = l2)
          b2.flags |= 4;
      }
    };
    Dj = function(a2, b2, c2, d2) {
      c2 !== d2 && (b2.flags |= 4);
    };
    function Ej(a2, b2) {
      if (!I2)
        switch (a2.tailMode) {
          case "hidden":
            b2 = a2.tail;
            for (var c2 = null; b2 !== null; )
              b2.alternate !== null && (c2 = b2), b2 = b2.sibling;
            c2 === null ? a2.tail = null : c2.sibling = null;
            break;
          case "collapsed":
            c2 = a2.tail;
            for (var d2 = null; c2 !== null; )
              c2.alternate !== null && (d2 = c2), c2 = c2.sibling;
            d2 === null ? b2 || a2.tail === null ? a2.tail = null : a2.tail.sibling = null : d2.sibling = null;
        }
    }
    function S2(a2) {
      var b2 = a2.alternate !== null && a2.alternate.child === a2.child, c2 = 0, d2 = 0;
      if (b2)
        for (var e2 = a2.child; e2 !== null; )
          c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags & 14680064, d2 |= e2.flags & 14680064, e2.return = a2, e2 = e2.sibling;
      else
        for (e2 = a2.child; e2 !== null; )
          c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags, d2 |= e2.flags, e2.return = a2, e2 = e2.sibling;
      a2.subtreeFlags |= d2;
      a2.childLanes = c2;
      return b2;
    }
    function Fj(a2, b2, c2) {
      var d2 = b2.pendingProps;
      wg(b2);
      switch (b2.tag) {
        case 2:
        case 16:
        case 15:
        case 0:
        case 11:
        case 7:
        case 8:
        case 12:
        case 9:
        case 14:
          return S2(b2), null;
        case 1:
          return Zf(b2.type) && $f(), S2(b2), null;
        case 3:
          d2 = b2.stateNode;
          Jh();
          E2(Wf);
          E2(H);
          Oh();
          d2.pendingContext && (d2.context = d2.pendingContext, d2.pendingContext = null);
          if (a2 === null || a2.child === null)
            Gg(b2) ? b2.flags |= 4 : a2 === null || a2.memoizedState.isDehydrated && (b2.flags & 256) === 0 || (b2.flags |= 1024, zg !== null && (Gj(zg), zg = null));
          Bj(a2, b2);
          S2(b2);
          return null;
        case 5:
          Lh(b2);
          var e2 = Hh(Gh.current);
          c2 = b2.type;
          if (a2 !== null && b2.stateNode != null)
            Cj(a2, b2, c2, d2, e2), a2.ref !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152);
          else {
            if (!d2) {
              if (b2.stateNode === null)
                throw Error(p2(166));
              S2(b2);
              return null;
            }
            a2 = Hh(Eh.current);
            if (Gg(b2)) {
              d2 = b2.stateNode;
              c2 = b2.type;
              var f2 = b2.memoizedProps;
              d2[Of] = b2;
              d2[Pf] = f2;
              a2 = (b2.mode & 1) !== 0;
              switch (c2) {
                case "dialog":
                  D2("cancel", d2);
                  D2("close", d2);
                  break;
                case "iframe":
                case "object":
                case "embed":
                  D2("load", d2);
                  break;
                case "video":
                case "audio":
                  for (e2 = 0; e2 < lf.length; e2++)
                    D2(lf[e2], d2);
                  break;
                case "source":
                  D2("error", d2);
                  break;
                case "img":
                case "image":
                case "link":
                  D2("error", d2);
                  D2("load", d2);
                  break;
                case "details":
                  D2("toggle", d2);
                  break;
                case "input":
                  Za(d2, f2);
                  D2("invalid", d2);
                  break;
                case "select":
                  d2._wrapperState = { wasMultiple: !!f2.multiple };
                  D2("invalid", d2);
                  break;
                case "textarea":
                  hb(d2, f2), D2("invalid", d2);
              }
              ub(c2, f2);
              e2 = null;
              for (var g2 in f2)
                if (f2.hasOwnProperty(g2)) {
                  var h2 = f2[g2];
                  g2 === "children" ? typeof h2 === "string" ? d2.textContent !== h2 && (f2.suppressHydrationWarning !== true && Af(d2.textContent, h2, a2), e2 = ["children", h2]) : typeof h2 === "number" && d2.textContent !== "" + h2 && (f2.suppressHydrationWarning !== true && Af(d2.textContent, h2, a2), e2 = ["children", "" + h2]) : ea.hasOwnProperty(g2) && h2 != null && g2 === "onScroll" && D2("scroll", d2);
                }
              switch (c2) {
                case "input":
                  Va(d2);
                  db(d2, f2, true);
                  break;
                case "textarea":
                  Va(d2);
                  jb(d2);
                  break;
                case "select":
                case "option":
                  break;
                default:
                  typeof f2.onClick === "function" && (d2.onclick = Bf);
              }
              d2 = e2;
              b2.updateQueue = d2;
              d2 !== null && (b2.flags |= 4);
            } else {
              g2 = e2.nodeType === 9 ? e2 : e2.ownerDocument;
              a2 === "http://www.w3.org/1999/xhtml" && (a2 = kb(c2));
              a2 === "http://www.w3.org/1999/xhtml" ? c2 === "script" ? (a2 = g2.createElement("div"), a2.innerHTML = "<script><\/script>", a2 = a2.removeChild(a2.firstChild)) : typeof d2.is === "string" ? a2 = g2.createElement(c2, { is: d2.is }) : (a2 = g2.createElement(c2), c2 === "select" && (g2 = a2, d2.multiple ? g2.multiple = true : d2.size && (g2.size = d2.size))) : a2 = g2.createElementNS(a2, c2);
              a2[Of] = b2;
              a2[Pf] = d2;
              Aj(a2, b2, false, false);
              b2.stateNode = a2;
              a: {
                g2 = vb(c2, d2);
                switch (c2) {
                  case "dialog":
                    D2("cancel", a2);
                    D2("close", a2);
                    e2 = d2;
                    break;
                  case "iframe":
                  case "object":
                  case "embed":
                    D2("load", a2);
                    e2 = d2;
                    break;
                  case "video":
                  case "audio":
                    for (e2 = 0; e2 < lf.length; e2++)
                      D2(lf[e2], a2);
                    e2 = d2;
                    break;
                  case "source":
                    D2("error", a2);
                    e2 = d2;
                    break;
                  case "img":
                  case "image":
                  case "link":
                    D2("error", a2);
                    D2("load", a2);
                    e2 = d2;
                    break;
                  case "details":
                    D2("toggle", a2);
                    e2 = d2;
                    break;
                  case "input":
                    Za(a2, d2);
                    e2 = Ya(a2, d2);
                    D2("invalid", a2);
                    break;
                  case "option":
                    e2 = d2;
                    break;
                  case "select":
                    a2._wrapperState = { wasMultiple: !!d2.multiple };
                    e2 = A2({}, d2, { value: void 0 });
                    D2("invalid", a2);
                    break;
                  case "textarea":
                    hb(a2, d2);
                    e2 = gb(a2, d2);
                    D2("invalid", a2);
                    break;
                  default:
                    e2 = d2;
                }
                ub(c2, e2);
                h2 = e2;
                for (f2 in h2)
                  if (h2.hasOwnProperty(f2)) {
                    var k2 = h2[f2];
                    f2 === "style" ? sb(a2, k2) : f2 === "dangerouslySetInnerHTML" ? (k2 = k2 ? k2.__html : void 0, k2 != null && nb(a2, k2)) : f2 === "children" ? typeof k2 === "string" ? (c2 !== "textarea" || k2 !== "") && ob(a2, k2) : typeof k2 === "number" && ob(a2, "" + k2) : f2 !== "suppressContentEditableWarning" && f2 !== "suppressHydrationWarning" && f2 !== "autoFocus" && (ea.hasOwnProperty(f2) ? k2 != null && f2 === "onScroll" && D2("scroll", a2) : k2 != null && ta(a2, f2, k2, g2));
                  }
                switch (c2) {
                  case "input":
                    Va(a2);
                    db(a2, d2, false);
                    break;
                  case "textarea":
                    Va(a2);
                    jb(a2);
                    break;
                  case "option":
                    d2.value != null && a2.setAttribute("value", "" + Sa(d2.value));
                    break;
                  case "select":
                    a2.multiple = !!d2.multiple;
                    f2 = d2.value;
                    f2 != null ? fb(a2, !!d2.multiple, f2, false) : d2.defaultValue != null && fb(a2, !!d2.multiple, d2.defaultValue, true);
                    break;
                  default:
                    typeof e2.onClick === "function" && (a2.onclick = Bf);
                }
                switch (c2) {
                  case "button":
                  case "input":
                  case "select":
                  case "textarea":
                    d2 = !!d2.autoFocus;
                    break a;
                  case "img":
                    d2 = true;
                    break a;
                  default:
                    d2 = false;
                }
              }
              d2 && (b2.flags |= 4);
            }
            b2.ref !== null && (b2.flags |= 512, b2.flags |= 2097152);
          }
          S2(b2);
          return null;
        case 6:
          if (a2 && b2.stateNode != null)
            Dj(a2, b2, a2.memoizedProps, d2);
          else {
            if (typeof d2 !== "string" && b2.stateNode === null)
              throw Error(p2(166));
            c2 = Hh(Gh.current);
            Hh(Eh.current);
            if (Gg(b2)) {
              d2 = b2.stateNode;
              c2 = b2.memoizedProps;
              d2[Of] = b2;
              if (f2 = d2.nodeValue !== c2) {
                if (a2 = xg, a2 !== null)
                  switch (a2.tag) {
                    case 3:
                      Af(d2.nodeValue, c2, (a2.mode & 1) !== 0);
                      break;
                    case 5:
                      a2.memoizedProps.suppressHydrationWarning !== true && Af(d2.nodeValue, c2, (a2.mode & 1) !== 0);
                  }
              }
              f2 && (b2.flags |= 4);
            } else
              d2 = (c2.nodeType === 9 ? c2 : c2.ownerDocument).createTextNode(d2), d2[Of] = b2, b2.stateNode = d2;
          }
          S2(b2);
          return null;
        case 13:
          E2(M2);
          d2 = b2.memoizedState;
          if (a2 === null || a2.memoizedState !== null && a2.memoizedState.dehydrated !== null) {
            if (I2 && yg !== null && (b2.mode & 1) !== 0 && (b2.flags & 128) === 0)
              Hg(), Ig(), b2.flags |= 98560, f2 = false;
            else if (f2 = Gg(b2), d2 !== null && d2.dehydrated !== null) {
              if (a2 === null) {
                if (!f2)
                  throw Error(p2(318));
                f2 = b2.memoizedState;
                f2 = f2 !== null ? f2.dehydrated : null;
                if (!f2)
                  throw Error(p2(317));
                f2[Of] = b2;
              } else
                Ig(), (b2.flags & 128) === 0 && (b2.memoizedState = null), b2.flags |= 4;
              S2(b2);
              f2 = false;
            } else
              zg !== null && (Gj(zg), zg = null), f2 = true;
            if (!f2)
              return b2.flags & 65536 ? b2 : null;
          }
          if ((b2.flags & 128) !== 0)
            return b2.lanes = c2, b2;
          d2 = d2 !== null;
          d2 !== (a2 !== null && a2.memoizedState !== null) && d2 && (b2.child.flags |= 8192, (b2.mode & 1) !== 0 && (a2 === null || (M2.current & 1) !== 0 ? T2 === 0 && (T2 = 3) : uj()));
          b2.updateQueue !== null && (b2.flags |= 4);
          S2(b2);
          return null;
        case 4:
          return Jh(), Bj(a2, b2), a2 === null && sf(b2.stateNode.containerInfo), S2(b2), null;
        case 10:
          return Rg(b2.type._context), S2(b2), null;
        case 17:
          return Zf(b2.type) && $f(), S2(b2), null;
        case 19:
          E2(M2);
          f2 = b2.memoizedState;
          if (f2 === null)
            return S2(b2), null;
          d2 = (b2.flags & 128) !== 0;
          g2 = f2.rendering;
          if (g2 === null)
            if (d2)
              Ej(f2, false);
            else {
              if (T2 !== 0 || a2 !== null && (a2.flags & 128) !== 0)
                for (a2 = b2.child; a2 !== null; ) {
                  g2 = Mh(a2);
                  if (g2 !== null) {
                    b2.flags |= 128;
                    Ej(f2, false);
                    d2 = g2.updateQueue;
                    d2 !== null && (b2.updateQueue = d2, b2.flags |= 4);
                    b2.subtreeFlags = 0;
                    d2 = c2;
                    for (c2 = b2.child; c2 !== null; )
                      f2 = c2, a2 = d2, f2.flags &= 14680066, g2 = f2.alternate, g2 === null ? (f2.childLanes = 0, f2.lanes = a2, f2.child = null, f2.subtreeFlags = 0, f2.memoizedProps = null, f2.memoizedState = null, f2.updateQueue = null, f2.dependencies = null, f2.stateNode = null) : (f2.childLanes = g2.childLanes, f2.lanes = g2.lanes, f2.child = g2.child, f2.subtreeFlags = 0, f2.deletions = null, f2.memoizedProps = g2.memoizedProps, f2.memoizedState = g2.memoizedState, f2.updateQueue = g2.updateQueue, f2.type = g2.type, a2 = g2.dependencies, f2.dependencies = a2 === null ? null : { lanes: a2.lanes, firstContext: a2.firstContext }), c2 = c2.sibling;
                    G(M2, M2.current & 1 | 2);
                    return b2.child;
                  }
                  a2 = a2.sibling;
                }
              f2.tail !== null && B() > Hj && (b2.flags |= 128, d2 = true, Ej(f2, false), b2.lanes = 4194304);
            }
          else {
            if (!d2)
              if (a2 = Mh(g2), a2 !== null) {
                if (b2.flags |= 128, d2 = true, c2 = a2.updateQueue, c2 !== null && (b2.updateQueue = c2, b2.flags |= 4), Ej(f2, true), f2.tail === null && f2.tailMode === "hidden" && !g2.alternate && !I2)
                  return S2(b2), null;
              } else
                2 * B() - f2.renderingStartTime > Hj && c2 !== 1073741824 && (b2.flags |= 128, d2 = true, Ej(f2, false), b2.lanes = 4194304);
            f2.isBackwards ? (g2.sibling = b2.child, b2.child = g2) : (c2 = f2.last, c2 !== null ? c2.sibling = g2 : b2.child = g2, f2.last = g2);
          }
          if (f2.tail !== null)
            return b2 = f2.tail, f2.rendering = b2, f2.tail = b2.sibling, f2.renderingStartTime = B(), b2.sibling = null, c2 = M2.current, G(M2, d2 ? c2 & 1 | 2 : c2 & 1), b2;
          S2(b2);
          return null;
        case 22:
        case 23:
          return Ij(), d2 = b2.memoizedState !== null, a2 !== null && a2.memoizedState !== null !== d2 && (b2.flags |= 8192), d2 && (b2.mode & 1) !== 0 ? (gj & 1073741824) !== 0 && (S2(b2), b2.subtreeFlags & 6 && (b2.flags |= 8192)) : S2(b2), null;
        case 24:
          return null;
        case 25:
          return null;
      }
      throw Error(p2(156, b2.tag));
    }
    function Jj(a2, b2) {
      wg(b2);
      switch (b2.tag) {
        case 1:
          return Zf(b2.type) && $f(), a2 = b2.flags, a2 & 65536 ? (b2.flags = a2 & -65537 | 128, b2) : null;
        case 3:
          return Jh(), E2(Wf), E2(H), Oh(), a2 = b2.flags, (a2 & 65536) !== 0 && (a2 & 128) === 0 ? (b2.flags = a2 & -65537 | 128, b2) : null;
        case 5:
          return Lh(b2), null;
        case 13:
          E2(M2);
          a2 = b2.memoizedState;
          if (a2 !== null && a2.dehydrated !== null) {
            if (b2.alternate === null)
              throw Error(p2(340));
            Ig();
          }
          a2 = b2.flags;
          return a2 & 65536 ? (b2.flags = a2 & -65537 | 128, b2) : null;
        case 19:
          return E2(M2), null;
        case 4:
          return Jh(), null;
        case 10:
          return Rg(b2.type._context), null;
        case 22:
        case 23:
          return Ij(), null;
        case 24:
          return null;
        default:
          return null;
      }
    }
    var Kj = false;
    var U = false;
    var Lj = typeof WeakSet === "function" ? WeakSet : Set;
    var V = null;
    function Mj(a2, b2) {
      var c2 = a2.ref;
      if (c2 !== null)
        if (typeof c2 === "function")
          try {
            c2(null);
          } catch (d2) {
            W(a2, b2, d2);
          }
        else
          c2.current = null;
    }
    function Nj(a2, b2, c2) {
      try {
        c2();
      } catch (d2) {
        W(a2, b2, d2);
      }
    }
    var Oj = false;
    function Pj(a2, b2) {
      Cf = dd;
      a2 = Me();
      if (Ne(a2)) {
        if ("selectionStart" in a2)
          var c2 = { start: a2.selectionStart, end: a2.selectionEnd };
        else
          a: {
            c2 = (c2 = a2.ownerDocument) && c2.defaultView || window;
            var d2 = c2.getSelection && c2.getSelection();
            if (d2 && d2.rangeCount !== 0) {
              c2 = d2.anchorNode;
              var e2 = d2.anchorOffset, f2 = d2.focusNode;
              d2 = d2.focusOffset;
              try {
                c2.nodeType, f2.nodeType;
              } catch (F2) {
                c2 = null;
                break a;
              }
              var g2 = 0, h2 = -1, k2 = -1, l2 = 0, m2 = 0, q = a2, r2 = null;
              b:
                for (; ; ) {
                  for (var y2; ; ) {
                    q !== c2 || e2 !== 0 && q.nodeType !== 3 || (h2 = g2 + e2);
                    q !== f2 || d2 !== 0 && q.nodeType !== 3 || (k2 = g2 + d2);
                    q.nodeType === 3 && (g2 += q.nodeValue.length);
                    if ((y2 = q.firstChild) === null)
                      break;
                    r2 = q;
                    q = y2;
                  }
                  for (; ; ) {
                    if (q === a2)
                      break b;
                    r2 === c2 && ++l2 === e2 && (h2 = g2);
                    r2 === f2 && ++m2 === d2 && (k2 = g2);
                    if ((y2 = q.nextSibling) !== null)
                      break;
                    q = r2;
                    r2 = q.parentNode;
                  }
                  q = y2;
                }
              c2 = h2 === -1 || k2 === -1 ? null : { start: h2, end: k2 };
            } else
              c2 = null;
          }
        c2 = c2 || { start: 0, end: 0 };
      } else
        c2 = null;
      Df = { focusedElem: a2, selectionRange: c2 };
      dd = false;
      for (V = b2; V !== null; )
        if (b2 = V, a2 = b2.child, (b2.subtreeFlags & 1028) !== 0 && a2 !== null)
          a2.return = b2, V = a2;
        else
          for (; V !== null; ) {
            b2 = V;
            try {
              var n2 = b2.alternate;
              if ((b2.flags & 1024) !== 0)
                switch (b2.tag) {
                  case 0:
                  case 11:
                  case 15:
                    break;
                  case 1:
                    if (n2 !== null) {
                      var t3 = n2.memoizedProps, J = n2.memoizedState, x2 = b2.stateNode, w2 = x2.getSnapshotBeforeUpdate(b2.elementType === b2.type ? t3 : Lg(b2.type, t3), J);
                      x2.__reactInternalSnapshotBeforeUpdate = w2;
                    }
                    break;
                  case 3:
                    var u2 = b2.stateNode.containerInfo;
                    u2.nodeType === 1 ? u2.textContent = "" : u2.nodeType === 9 && u2.documentElement && u2.removeChild(u2.documentElement);
                    break;
                  case 5:
                  case 6:
                  case 4:
                  case 17:
                    break;
                  default:
                    throw Error(p2(163));
                }
            } catch (F2) {
              W(b2, b2.return, F2);
            }
            a2 = b2.sibling;
            if (a2 !== null) {
              a2.return = b2.return;
              V = a2;
              break;
            }
            V = b2.return;
          }
      n2 = Oj;
      Oj = false;
      return n2;
    }
    function Qj(a2, b2, c2) {
      var d2 = b2.updateQueue;
      d2 = d2 !== null ? d2.lastEffect : null;
      if (d2 !== null) {
        var e2 = d2 = d2.next;
        do {
          if ((e2.tag & a2) === a2) {
            var f2 = e2.destroy;
            e2.destroy = void 0;
            f2 !== void 0 && Nj(b2, c2, f2);
          }
          e2 = e2.next;
        } while (e2 !== d2);
      }
    }
    function Rj(a2, b2) {
      b2 = b2.updateQueue;
      b2 = b2 !== null ? b2.lastEffect : null;
      if (b2 !== null) {
        var c2 = b2 = b2.next;
        do {
          if ((c2.tag & a2) === a2) {
            var d2 = c2.create;
            c2.destroy = d2();
          }
          c2 = c2.next;
        } while (c2 !== b2);
      }
    }
    function Sj(a2) {
      var b2 = a2.ref;
      if (b2 !== null) {
        var c2 = a2.stateNode;
        switch (a2.tag) {
          case 5:
            a2 = c2;
            break;
          default:
            a2 = c2;
        }
        typeof b2 === "function" ? b2(a2) : b2.current = a2;
      }
    }
    function Tj(a2) {
      var b2 = a2.alternate;
      b2 !== null && (a2.alternate = null, Tj(b2));
      a2.child = null;
      a2.deletions = null;
      a2.sibling = null;
      a2.tag === 5 && (b2 = a2.stateNode, b2 !== null && (delete b2[Of], delete b2[Pf], delete b2[of], delete b2[Qf], delete b2[Rf]));
      a2.stateNode = null;
      a2.return = null;
      a2.dependencies = null;
      a2.memoizedProps = null;
      a2.memoizedState = null;
      a2.pendingProps = null;
      a2.stateNode = null;
      a2.updateQueue = null;
    }
    function Uj(a2) {
      return a2.tag === 5 || a2.tag === 3 || a2.tag === 4;
    }
    function Vj(a2) {
      a:
        for (; ; ) {
          for (; a2.sibling === null; ) {
            if (a2.return === null || Uj(a2.return))
              return null;
            a2 = a2.return;
          }
          a2.sibling.return = a2.return;
          for (a2 = a2.sibling; a2.tag !== 5 && a2.tag !== 6 && a2.tag !== 18; ) {
            if (a2.flags & 2)
              continue a;
            if (a2.child === null || a2.tag === 4)
              continue a;
            else
              a2.child.return = a2, a2 = a2.child;
          }
          if (!(a2.flags & 2))
            return a2.stateNode;
        }
    }
    function Wj(a2, b2, c2) {
      var d2 = a2.tag;
      if (d2 === 5 || d2 === 6)
        a2 = a2.stateNode, b2 ? c2.nodeType === 8 ? c2.parentNode.insertBefore(a2, b2) : c2.insertBefore(a2, b2) : (c2.nodeType === 8 ? (b2 = c2.parentNode, b2.insertBefore(a2, c2)) : (b2 = c2, b2.appendChild(a2)), c2 = c2._reactRootContainer, c2 !== null && c2 !== void 0 || b2.onclick !== null || (b2.onclick = Bf));
      else if (d2 !== 4 && (a2 = a2.child, a2 !== null))
        for (Wj(a2, b2, c2), a2 = a2.sibling; a2 !== null; )
          Wj(a2, b2, c2), a2 = a2.sibling;
    }
    function Xj(a2, b2, c2) {
      var d2 = a2.tag;
      if (d2 === 5 || d2 === 6)
        a2 = a2.stateNode, b2 ? c2.insertBefore(a2, b2) : c2.appendChild(a2);
      else if (d2 !== 4 && (a2 = a2.child, a2 !== null))
        for (Xj(a2, b2, c2), a2 = a2.sibling; a2 !== null; )
          Xj(a2, b2, c2), a2 = a2.sibling;
    }
    var X = null;
    var Yj = false;
    function Zj(a2, b2, c2) {
      for (c2 = c2.child; c2 !== null; )
        ak(a2, b2, c2), c2 = c2.sibling;
    }
    function ak(a2, b2, c2) {
      if (lc && typeof lc.onCommitFiberUnmount === "function")
        try {
          lc.onCommitFiberUnmount(kc, c2);
        } catch (h2) {
        }
      switch (c2.tag) {
        case 5:
          U || Mj(c2, b2);
        case 6:
          var d2 = X, e2 = Yj;
          X = null;
          Zj(a2, b2, c2);
          X = d2;
          Yj = e2;
          X !== null && (Yj ? (a2 = X, c2 = c2.stateNode, a2.nodeType === 8 ? a2.parentNode.removeChild(c2) : a2.removeChild(c2)) : X.removeChild(c2.stateNode));
          break;
        case 18:
          X !== null && (Yj ? (a2 = X, c2 = c2.stateNode, a2.nodeType === 8 ? Kf(a2.parentNode, c2) : a2.nodeType === 1 && Kf(a2, c2), bd(a2)) : Kf(X, c2.stateNode));
          break;
        case 4:
          d2 = X;
          e2 = Yj;
          X = c2.stateNode.containerInfo;
          Yj = true;
          Zj(a2, b2, c2);
          X = d2;
          Yj = e2;
          break;
        case 0:
        case 11:
        case 14:
        case 15:
          if (!U && (d2 = c2.updateQueue, d2 !== null && (d2 = d2.lastEffect, d2 !== null))) {
            e2 = d2 = d2.next;
            do {
              var f2 = e2, g2 = f2.destroy;
              f2 = f2.tag;
              g2 !== void 0 && ((f2 & 2) !== 0 ? Nj(c2, b2, g2) : (f2 & 4) !== 0 && Nj(c2, b2, g2));
              e2 = e2.next;
            } while (e2 !== d2);
          }
          Zj(a2, b2, c2);
          break;
        case 1:
          if (!U && (Mj(c2, b2), d2 = c2.stateNode, typeof d2.componentWillUnmount === "function"))
            try {
              d2.props = c2.memoizedProps, d2.state = c2.memoizedState, d2.componentWillUnmount();
            } catch (h2) {
              W(c2, b2, h2);
            }
          Zj(a2, b2, c2);
          break;
        case 21:
          Zj(a2, b2, c2);
          break;
        case 22:
          c2.mode & 1 ? (U = (d2 = U) || c2.memoizedState !== null, Zj(a2, b2, c2), U = d2) : Zj(a2, b2, c2);
          break;
        default:
          Zj(a2, b2, c2);
      }
    }
    function bk(a2) {
      var b2 = a2.updateQueue;
      if (b2 !== null) {
        a2.updateQueue = null;
        var c2 = a2.stateNode;
        c2 === null && (c2 = a2.stateNode = new Lj());
        b2.forEach(function(b3) {
          var d2 = ck.bind(null, a2, b3);
          c2.has(b3) || (c2.add(b3), b3.then(d2, d2));
        });
      }
    }
    function dk(a2, b2) {
      var c2 = b2.deletions;
      if (c2 !== null)
        for (var d2 = 0; d2 < c2.length; d2++) {
          var e2 = c2[d2];
          try {
            var f2 = a2, g2 = b2, h2 = g2;
            a:
              for (; h2 !== null; ) {
                switch (h2.tag) {
                  case 5:
                    X = h2.stateNode;
                    Yj = false;
                    break a;
                  case 3:
                    X = h2.stateNode.containerInfo;
                    Yj = true;
                    break a;
                  case 4:
                    X = h2.stateNode.containerInfo;
                    Yj = true;
                    break a;
                }
                h2 = h2.return;
              }
            if (X === null)
              throw Error(p2(160));
            ak(f2, g2, e2);
            X = null;
            Yj = false;
            var k2 = e2.alternate;
            k2 !== null && (k2.return = null);
            e2.return = null;
          } catch (l2) {
            W(e2, b2, l2);
          }
        }
      if (b2.subtreeFlags & 12854)
        for (b2 = b2.child; b2 !== null; )
          ek(b2, a2), b2 = b2.sibling;
    }
    function ek(a2, b2) {
      var c2 = a2.alternate, d2 = a2.flags;
      switch (a2.tag) {
        case 0:
        case 11:
        case 14:
        case 15:
          dk(b2, a2);
          fk(a2);
          if (d2 & 4) {
            try {
              Qj(3, a2, a2.return), Rj(3, a2);
            } catch (t3) {
              W(a2, a2.return, t3);
            }
            try {
              Qj(5, a2, a2.return);
            } catch (t3) {
              W(a2, a2.return, t3);
            }
          }
          break;
        case 1:
          dk(b2, a2);
          fk(a2);
          d2 & 512 && c2 !== null && Mj(c2, c2.return);
          break;
        case 5:
          dk(b2, a2);
          fk(a2);
          d2 & 512 && c2 !== null && Mj(c2, c2.return);
          if (a2.flags & 32) {
            var e2 = a2.stateNode;
            try {
              ob(e2, "");
            } catch (t3) {
              W(a2, a2.return, t3);
            }
          }
          if (d2 & 4 && (e2 = a2.stateNode, e2 != null)) {
            var f2 = a2.memoizedProps, g2 = c2 !== null ? c2.memoizedProps : f2, h2 = a2.type, k2 = a2.updateQueue;
            a2.updateQueue = null;
            if (k2 !== null)
              try {
                h2 === "input" && f2.type === "radio" && f2.name != null && ab(e2, f2);
                vb(h2, g2);
                var l2 = vb(h2, f2);
                for (g2 = 0; g2 < k2.length; g2 += 2) {
                  var m2 = k2[g2], q = k2[g2 + 1];
                  m2 === "style" ? sb(e2, q) : m2 === "dangerouslySetInnerHTML" ? nb(e2, q) : m2 === "children" ? ob(e2, q) : ta(e2, m2, q, l2);
                }
                switch (h2) {
                  case "input":
                    bb(e2, f2);
                    break;
                  case "textarea":
                    ib(e2, f2);
                    break;
                  case "select":
                    var r2 = e2._wrapperState.wasMultiple;
                    e2._wrapperState.wasMultiple = !!f2.multiple;
                    var y2 = f2.value;
                    y2 != null ? fb(e2, !!f2.multiple, y2, false) : r2 !== !!f2.multiple && (f2.defaultValue != null ? fb(e2, !!f2.multiple, f2.defaultValue, true) : fb(e2, !!f2.multiple, f2.multiple ? [] : "", false));
                }
                e2[Pf] = f2;
              } catch (t3) {
                W(a2, a2.return, t3);
              }
          }
          break;
        case 6:
          dk(b2, a2);
          fk(a2);
          if (d2 & 4) {
            if (a2.stateNode === null)
              throw Error(p2(162));
            e2 = a2.stateNode;
            f2 = a2.memoizedProps;
            try {
              e2.nodeValue = f2;
            } catch (t3) {
              W(a2, a2.return, t3);
            }
          }
          break;
        case 3:
          dk(b2, a2);
          fk(a2);
          if (d2 & 4 && c2 !== null && c2.memoizedState.isDehydrated)
            try {
              bd(b2.containerInfo);
            } catch (t3) {
              W(a2, a2.return, t3);
            }
          break;
        case 4:
          dk(b2, a2);
          fk(a2);
          break;
        case 13:
          dk(b2, a2);
          fk(a2);
          e2 = a2.child;
          e2.flags & 8192 && (f2 = e2.memoizedState !== null, e2.stateNode.isHidden = f2, !f2 || e2.alternate !== null && e2.alternate.memoizedState !== null || (gk = B()));
          d2 & 4 && bk(a2);
          break;
        case 22:
          m2 = c2 !== null && c2.memoizedState !== null;
          a2.mode & 1 ? (U = (l2 = U) || m2, dk(b2, a2), U = l2) : dk(b2, a2);
          fk(a2);
          if (d2 & 8192) {
            l2 = a2.memoizedState !== null;
            if ((a2.stateNode.isHidden = l2) && !m2 && (a2.mode & 1) !== 0)
              for (V = a2, m2 = a2.child; m2 !== null; ) {
                for (q = V = m2; V !== null; ) {
                  r2 = V;
                  y2 = r2.child;
                  switch (r2.tag) {
                    case 0:
                    case 11:
                    case 14:
                    case 15:
                      Qj(4, r2, r2.return);
                      break;
                    case 1:
                      Mj(r2, r2.return);
                      var n2 = r2.stateNode;
                      if (typeof n2.componentWillUnmount === "function") {
                        d2 = r2;
                        c2 = r2.return;
                        try {
                          b2 = d2, n2.props = b2.memoizedProps, n2.state = b2.memoizedState, n2.componentWillUnmount();
                        } catch (t3) {
                          W(d2, c2, t3);
                        }
                      }
                      break;
                    case 5:
                      Mj(r2, r2.return);
                      break;
                    case 22:
                      if (r2.memoizedState !== null) {
                        hk(q);
                        continue;
                      }
                  }
                  y2 !== null ? (y2.return = r2, V = y2) : hk(q);
                }
                m2 = m2.sibling;
              }
            a:
              for (m2 = null, q = a2; ; ) {
                if (q.tag === 5) {
                  if (m2 === null) {
                    m2 = q;
                    try {
                      e2 = q.stateNode, l2 ? (f2 = e2.style, typeof f2.setProperty === "function" ? f2.setProperty("display", "none", "important") : f2.display = "none") : (h2 = q.stateNode, k2 = q.memoizedProps.style, g2 = k2 !== void 0 && k2 !== null && k2.hasOwnProperty("display") ? k2.display : null, h2.style.display = rb("display", g2));
                    } catch (t3) {
                      W(a2, a2.return, t3);
                    }
                  }
                } else if (q.tag === 6) {
                  if (m2 === null)
                    try {
                      q.stateNode.nodeValue = l2 ? "" : q.memoizedProps;
                    } catch (t3) {
                      W(a2, a2.return, t3);
                    }
                } else if ((q.tag !== 22 && q.tag !== 23 || q.memoizedState === null || q === a2) && q.child !== null) {
                  q.child.return = q;
                  q = q.child;
                  continue;
                }
                if (q === a2)
                  break a;
                for (; q.sibling === null; ) {
                  if (q.return === null || q.return === a2)
                    break a;
                  m2 === q && (m2 = null);
                  q = q.return;
                }
                m2 === q && (m2 = null);
                q.sibling.return = q.return;
                q = q.sibling;
              }
          }
          break;
        case 19:
          dk(b2, a2);
          fk(a2);
          d2 & 4 && bk(a2);
          break;
        case 21:
          break;
        default:
          dk(b2, a2), fk(a2);
      }
    }
    function fk(a2) {
      var b2 = a2.flags;
      if (b2 & 2) {
        try {
          a: {
            for (var c2 = a2.return; c2 !== null; ) {
              if (Uj(c2)) {
                var d2 = c2;
                break a;
              }
              c2 = c2.return;
            }
            throw Error(p2(160));
          }
          switch (d2.tag) {
            case 5:
              var e2 = d2.stateNode;
              d2.flags & 32 && (ob(e2, ""), d2.flags &= -33);
              var f2 = Vj(a2);
              Xj(a2, f2, e2);
              break;
            case 3:
            case 4:
              var g2 = d2.stateNode.containerInfo, h2 = Vj(a2);
              Wj(a2, h2, g2);
              break;
            default:
              throw Error(p2(161));
          }
        } catch (k2) {
          W(a2, a2.return, k2);
        }
        a2.flags &= -3;
      }
      b2 & 4096 && (a2.flags &= -4097);
    }
    function ik(a2, b2, c2) {
      V = a2;
      jk(a2, b2, c2);
    }
    function jk(a2, b2, c2) {
      for (var d2 = (a2.mode & 1) !== 0; V !== null; ) {
        var e2 = V, f2 = e2.child;
        if (e2.tag === 22 && d2) {
          var g2 = e2.memoizedState !== null || Kj;
          if (!g2) {
            var h2 = e2.alternate, k2 = h2 !== null && h2.memoizedState !== null || U;
            h2 = Kj;
            var l2 = U;
            Kj = g2;
            if ((U = k2) && !l2)
              for (V = e2; V !== null; )
                g2 = V, k2 = g2.child, g2.tag === 22 && g2.memoizedState !== null ? kk(e2) : k2 !== null ? (k2.return = g2, V = k2) : kk(e2);
            for (; f2 !== null; )
              V = f2, jk(f2, b2, c2), f2 = f2.sibling;
            V = e2;
            Kj = h2;
            U = l2;
          }
          lk(a2, b2, c2);
        } else
          (e2.subtreeFlags & 8772) !== 0 && f2 !== null ? (f2.return = e2, V = f2) : lk(a2, b2, c2);
      }
    }
    function lk(a2) {
      for (; V !== null; ) {
        var b2 = V;
        if ((b2.flags & 8772) !== 0) {
          var c2 = b2.alternate;
          try {
            if ((b2.flags & 8772) !== 0)
              switch (b2.tag) {
                case 0:
                case 11:
                case 15:
                  U || Rj(5, b2);
                  break;
                case 1:
                  var d2 = b2.stateNode;
                  if (b2.flags & 4 && !U)
                    if (c2 === null)
                      d2.componentDidMount();
                    else {
                      var e2 = b2.elementType === b2.type ? c2.memoizedProps : Lg(b2.type, c2.memoizedProps);
                      d2.componentDidUpdate(e2, c2.memoizedState, d2.__reactInternalSnapshotBeforeUpdate);
                    }
                  var f2 = b2.updateQueue;
                  f2 !== null && ih(b2, f2, d2);
                  break;
                case 3:
                  var g2 = b2.updateQueue;
                  if (g2 !== null) {
                    c2 = null;
                    if (b2.child !== null)
                      switch (b2.child.tag) {
                        case 5:
                          c2 = b2.child.stateNode;
                          break;
                        case 1:
                          c2 = b2.child.stateNode;
                      }
                    ih(b2, g2, c2);
                  }
                  break;
                case 5:
                  var h2 = b2.stateNode;
                  if (c2 === null && b2.flags & 4) {
                    c2 = h2;
                    var k2 = b2.memoizedProps;
                    switch (b2.type) {
                      case "button":
                      case "input":
                      case "select":
                      case "textarea":
                        k2.autoFocus && c2.focus();
                        break;
                      case "img":
                        k2.src && (c2.src = k2.src);
                    }
                  }
                  break;
                case 6:
                  break;
                case 4:
                  break;
                case 12:
                  break;
                case 13:
                  if (b2.memoizedState === null) {
                    var l2 = b2.alternate;
                    if (l2 !== null) {
                      var m2 = l2.memoizedState;
                      if (m2 !== null) {
                        var q = m2.dehydrated;
                        q !== null && bd(q);
                      }
                    }
                  }
                  break;
                case 19:
                case 17:
                case 21:
                case 22:
                case 23:
                case 25:
                  break;
                default:
                  throw Error(p2(163));
              }
            U || b2.flags & 512 && Sj(b2);
          } catch (r2) {
            W(b2, b2.return, r2);
          }
        }
        if (b2 === a2) {
          V = null;
          break;
        }
        c2 = b2.sibling;
        if (c2 !== null) {
          c2.return = b2.return;
          V = c2;
          break;
        }
        V = b2.return;
      }
    }
    function hk(a2) {
      for (; V !== null; ) {
        var b2 = V;
        if (b2 === a2) {
          V = null;
          break;
        }
        var c2 = b2.sibling;
        if (c2 !== null) {
          c2.return = b2.return;
          V = c2;
          break;
        }
        V = b2.return;
      }
    }
    function kk(a2) {
      for (; V !== null; ) {
        var b2 = V;
        try {
          switch (b2.tag) {
            case 0:
            case 11:
            case 15:
              var c2 = b2.return;
              try {
                Rj(4, b2);
              } catch (k2) {
                W(b2, c2, k2);
              }
              break;
            case 1:
              var d2 = b2.stateNode;
              if (typeof d2.componentDidMount === "function") {
                var e2 = b2.return;
                try {
                  d2.componentDidMount();
                } catch (k2) {
                  W(b2, e2, k2);
                }
              }
              var f2 = b2.return;
              try {
                Sj(b2);
              } catch (k2) {
                W(b2, f2, k2);
              }
              break;
            case 5:
              var g2 = b2.return;
              try {
                Sj(b2);
              } catch (k2) {
                W(b2, g2, k2);
              }
          }
        } catch (k2) {
          W(b2, b2.return, k2);
        }
        if (b2 === a2) {
          V = null;
          break;
        }
        var h2 = b2.sibling;
        if (h2 !== null) {
          h2.return = b2.return;
          V = h2;
          break;
        }
        V = b2.return;
      }
    }
    var mk = Math.ceil;
    var nk = ua.ReactCurrentDispatcher;
    var ok = ua.ReactCurrentOwner;
    var pk = ua.ReactCurrentBatchConfig;
    var K = 0;
    var R2 = null;
    var Y = null;
    var Z = 0;
    var gj = 0;
    var fj = Uf(0);
    var T2 = 0;
    var qk = null;
    var hh = 0;
    var rk = 0;
    var sk = 0;
    var tk = null;
    var uk = null;
    var gk = 0;
    var Hj = Infinity;
    var vk = null;
    var Pi = false;
    var Qi = null;
    var Si = null;
    var wk = false;
    var xk = null;
    var yk = 0;
    var zk = 0;
    var Ak = null;
    var Bk = -1;
    var Ck = 0;
    function L2() {
      return (K & 6) !== 0 ? B() : Bk !== -1 ? Bk : Bk = B();
    }
    function lh(a2) {
      if ((a2.mode & 1) === 0)
        return 1;
      if ((K & 2) !== 0 && Z !== 0)
        return Z & -Z;
      if (Kg.transition !== null)
        return Ck === 0 && (Ck = yc()), Ck;
      a2 = C2;
      if (a2 !== 0)
        return a2;
      a2 = window.event;
      a2 = a2 === void 0 ? 16 : jd(a2.type);
      return a2;
    }
    function mh(a2, b2, c2, d2) {
      if (50 < zk)
        throw zk = 0, Ak = null, Error(p2(185));
      Ac(a2, c2, d2);
      if ((K & 2) === 0 || a2 !== R2)
        a2 === R2 && ((K & 2) === 0 && (rk |= c2), T2 === 4 && Dk(a2, Z)), Ek(a2, d2), c2 === 1 && K === 0 && (b2.mode & 1) === 0 && (Hj = B() + 500, fg && jg());
    }
    function Ek(a2, b2) {
      var c2 = a2.callbackNode;
      wc(a2, b2);
      var d2 = uc(a2, a2 === R2 ? Z : 0);
      if (d2 === 0)
        c2 !== null && bc(c2), a2.callbackNode = null, a2.callbackPriority = 0;
      else if (b2 = d2 & -d2, a2.callbackPriority !== b2) {
        c2 != null && bc(c2);
        if (b2 === 1)
          a2.tag === 0 ? ig(Fk.bind(null, a2)) : hg(Fk.bind(null, a2)), Jf(function() {
            (K & 6) === 0 && jg();
          }), c2 = null;
        else {
          switch (Dc(d2)) {
            case 1:
              c2 = fc;
              break;
            case 4:
              c2 = gc;
              break;
            case 16:
              c2 = hc;
              break;
            case 536870912:
              c2 = jc;
              break;
            default:
              c2 = hc;
          }
          c2 = Gk(c2, Hk.bind(null, a2));
        }
        a2.callbackPriority = b2;
        a2.callbackNode = c2;
      }
    }
    function Hk(a2, b2) {
      Bk = -1;
      Ck = 0;
      if ((K & 6) !== 0)
        throw Error(p2(327));
      var c2 = a2.callbackNode;
      if (Ik() && a2.callbackNode !== c2)
        return null;
      var d2 = uc(a2, a2 === R2 ? Z : 0);
      if (d2 === 0)
        return null;
      if ((d2 & 30) !== 0 || (d2 & a2.expiredLanes) !== 0 || b2)
        b2 = Jk(a2, d2);
      else {
        b2 = d2;
        var e2 = K;
        K |= 2;
        var f2 = Kk();
        if (R2 !== a2 || Z !== b2)
          vk = null, Hj = B() + 500, Lk(a2, b2);
        do
          try {
            Mk();
            break;
          } catch (h2) {
            Nk(a2, h2);
          }
        while (1);
        Qg();
        nk.current = f2;
        K = e2;
        Y !== null ? b2 = 0 : (R2 = null, Z = 0, b2 = T2);
      }
      if (b2 !== 0) {
        b2 === 2 && (e2 = xc(a2), e2 !== 0 && (d2 = e2, b2 = Ok(a2, e2)));
        if (b2 === 1)
          throw c2 = qk, Lk(a2, 0), Dk(a2, d2), Ek(a2, B()), c2;
        if (b2 === 6)
          Dk(a2, d2);
        else {
          e2 = a2.current.alternate;
          if ((d2 & 30) === 0 && !Pk(e2) && (b2 = Jk(a2, d2), b2 === 2 && (f2 = xc(a2), f2 !== 0 && (d2 = f2, b2 = Ok(a2, f2))), b2 === 1))
            throw c2 = qk, Lk(a2, 0), Dk(a2, d2), Ek(a2, B()), c2;
          a2.finishedWork = e2;
          a2.finishedLanes = d2;
          switch (b2) {
            case 0:
            case 1:
              throw Error(p2(345));
            case 2:
              Qk(a2, uk, vk);
              break;
            case 3:
              Dk(a2, d2);
              if ((d2 & 130023424) === d2 && (b2 = gk + 500 - B(), 10 < b2)) {
                if (uc(a2, 0) !== 0)
                  break;
                e2 = a2.suspendedLanes;
                if ((e2 & d2) !== d2) {
                  L2();
                  a2.pingedLanes |= a2.suspendedLanes & e2;
                  break;
                }
                a2.timeoutHandle = Ff(Qk.bind(null, a2, uk, vk), b2);
                break;
              }
              Qk(a2, uk, vk);
              break;
            case 4:
              Dk(a2, d2);
              if ((d2 & 4194240) === d2)
                break;
              b2 = a2.eventTimes;
              for (e2 = -1; 0 < d2; ) {
                var g2 = 31 - oc(d2);
                f2 = 1 << g2;
                g2 = b2[g2];
                g2 > e2 && (e2 = g2);
                d2 &= ~f2;
              }
              d2 = e2;
              d2 = B() - d2;
              d2 = (120 > d2 ? 120 : 480 > d2 ? 480 : 1080 > d2 ? 1080 : 1920 > d2 ? 1920 : 3e3 > d2 ? 3e3 : 4320 > d2 ? 4320 : 1960 * mk(d2 / 1960)) - d2;
              if (10 < d2) {
                a2.timeoutHandle = Ff(Qk.bind(null, a2, uk, vk), d2);
                break;
              }
              Qk(a2, uk, vk);
              break;
            case 5:
              Qk(a2, uk, vk);
              break;
            default:
              throw Error(p2(329));
          }
        }
      }
      Ek(a2, B());
      return a2.callbackNode === c2 ? Hk.bind(null, a2) : null;
    }
    function Ok(a2, b2) {
      var c2 = tk;
      a2.current.memoizedState.isDehydrated && (Lk(a2, b2).flags |= 256);
      a2 = Jk(a2, b2);
      a2 !== 2 && (b2 = uk, uk = c2, b2 !== null && Gj(b2));
      return a2;
    }
    function Gj(a2) {
      uk === null ? uk = a2 : uk.push.apply(uk, a2);
    }
    function Pk(a2) {
      for (var b2 = a2; ; ) {
        if (b2.flags & 16384) {
          var c2 = b2.updateQueue;
          if (c2 !== null && (c2 = c2.stores, c2 !== null))
            for (var d2 = 0; d2 < c2.length; d2++) {
              var e2 = c2[d2], f2 = e2.getSnapshot;
              e2 = e2.value;
              try {
                if (!He(f2(), e2))
                  return false;
              } catch (g2) {
                return false;
              }
            }
        }
        c2 = b2.child;
        if (b2.subtreeFlags & 16384 && c2 !== null)
          c2.return = b2, b2 = c2;
        else {
          if (b2 === a2)
            break;
          for (; b2.sibling === null; ) {
            if (b2.return === null || b2.return === a2)
              return true;
            b2 = b2.return;
          }
          b2.sibling.return = b2.return;
          b2 = b2.sibling;
        }
      }
      return true;
    }
    function Dk(a2, b2) {
      b2 &= ~sk;
      b2 &= ~rk;
      a2.suspendedLanes |= b2;
      a2.pingedLanes &= ~b2;
      for (a2 = a2.expirationTimes; 0 < b2; ) {
        var c2 = 31 - oc(b2), d2 = 1 << c2;
        a2[c2] = -1;
        b2 &= ~d2;
      }
    }
    function Fk(a2) {
      if ((K & 6) !== 0)
        throw Error(p2(327));
      Ik();
      var b2 = uc(a2, 0);
      if ((b2 & 1) === 0)
        return Ek(a2, B()), null;
      var c2 = Jk(a2, b2);
      if (a2.tag !== 0 && c2 === 2) {
        var d2 = xc(a2);
        d2 !== 0 && (b2 = d2, c2 = Ok(a2, d2));
      }
      if (c2 === 1)
        throw c2 = qk, Lk(a2, 0), Dk(a2, b2), Ek(a2, B()), c2;
      if (c2 === 6)
        throw Error(p2(345));
      a2.finishedWork = a2.current.alternate;
      a2.finishedLanes = b2;
      Qk(a2, uk, vk);
      Ek(a2, B());
      return null;
    }
    function Rk(a2, b2) {
      var c2 = K;
      K |= 1;
      try {
        return a2(b2);
      } finally {
        K = c2, K === 0 && (Hj = B() + 500, fg && jg());
      }
    }
    function Sk(a2) {
      xk !== null && xk.tag === 0 && (K & 6) === 0 && Ik();
      var b2 = K;
      K |= 1;
      var c2 = pk.transition, d2 = C2;
      try {
        if (pk.transition = null, C2 = 1, a2)
          return a2();
      } finally {
        C2 = d2, pk.transition = c2, K = b2, (K & 6) === 0 && jg();
      }
    }
    function Ij() {
      gj = fj.current;
      E2(fj);
    }
    function Lk(a2, b2) {
      a2.finishedWork = null;
      a2.finishedLanes = 0;
      var c2 = a2.timeoutHandle;
      c2 !== -1 && (a2.timeoutHandle = -1, Gf(c2));
      if (Y !== null)
        for (c2 = Y.return; c2 !== null; ) {
          var d2 = c2;
          wg(d2);
          switch (d2.tag) {
            case 1:
              d2 = d2.type.childContextTypes;
              d2 !== null && d2 !== void 0 && $f();
              break;
            case 3:
              Jh();
              E2(Wf);
              E2(H);
              Oh();
              break;
            case 5:
              Lh(d2);
              break;
            case 4:
              Jh();
              break;
            case 13:
              E2(M2);
              break;
            case 19:
              E2(M2);
              break;
            case 10:
              Rg(d2.type._context);
              break;
            case 22:
            case 23:
              Ij();
          }
          c2 = c2.return;
        }
      R2 = a2;
      Y = a2 = wh(a2.current, null);
      Z = gj = b2;
      T2 = 0;
      qk = null;
      sk = rk = hh = 0;
      uk = tk = null;
      if (Wg !== null) {
        for (b2 = 0; b2 < Wg.length; b2++)
          if (c2 = Wg[b2], d2 = c2.interleaved, d2 !== null) {
            c2.interleaved = null;
            var e2 = d2.next, f2 = c2.pending;
            if (f2 !== null) {
              var g2 = f2.next;
              f2.next = e2;
              d2.next = g2;
            }
            c2.pending = d2;
          }
        Wg = null;
      }
      return a2;
    }
    function Nk(a2, b2) {
      do {
        var c2 = Y;
        try {
          Qg();
          Ph.current = ai;
          if (Sh) {
            for (var d2 = N2.memoizedState; d2 !== null; ) {
              var e2 = d2.queue;
              e2 !== null && (e2.pending = null);
              d2 = d2.next;
            }
            Sh = false;
          }
          Rh = 0;
          P2 = O2 = N2 = null;
          Th = false;
          Uh = 0;
          ok.current = null;
          if (c2 === null || c2.return === null) {
            T2 = 1;
            qk = b2;
            Y = null;
            break;
          }
          a: {
            var f2 = a2, g2 = c2.return, h2 = c2, k2 = b2;
            b2 = Z;
            h2.flags |= 32768;
            if (k2 !== null && typeof k2 === "object" && typeof k2.then === "function") {
              var l2 = k2, m2 = h2, q = m2.tag;
              if ((m2.mode & 1) === 0 && (q === 0 || q === 11 || q === 15)) {
                var r2 = m2.alternate;
                r2 ? (m2.updateQueue = r2.updateQueue, m2.memoizedState = r2.memoizedState, m2.lanes = r2.lanes) : (m2.updateQueue = null, m2.memoizedState = null);
              }
              var y2 = Vi(g2);
              if (y2 !== null) {
                y2.flags &= -257;
                Wi(y2, g2, h2, f2, b2);
                y2.mode & 1 && Ti(f2, l2, b2);
                b2 = y2;
                k2 = l2;
                var n2 = b2.updateQueue;
                if (n2 === null) {
                  var t3 = /* @__PURE__ */ new Set();
                  t3.add(k2);
                  b2.updateQueue = t3;
                } else
                  n2.add(k2);
                break a;
              } else {
                if ((b2 & 1) === 0) {
                  Ti(f2, l2, b2);
                  uj();
                  break a;
                }
                k2 = Error(p2(426));
              }
            } else if (I2 && h2.mode & 1) {
              var J = Vi(g2);
              if (J !== null) {
                (J.flags & 65536) === 0 && (J.flags |= 256);
                Wi(J, g2, h2, f2, b2);
                Jg(Ki(k2, h2));
                break a;
              }
            }
            f2 = k2 = Ki(k2, h2);
            T2 !== 4 && (T2 = 2);
            tk === null ? tk = [f2] : tk.push(f2);
            f2 = g2;
            do {
              switch (f2.tag) {
                case 3:
                  f2.flags |= 65536;
                  b2 &= -b2;
                  f2.lanes |= b2;
                  var x2 = Oi(f2, k2, b2);
                  fh(f2, x2);
                  break a;
                case 1:
                  h2 = k2;
                  var w2 = f2.type, u2 = f2.stateNode;
                  if ((f2.flags & 128) === 0 && (typeof w2.getDerivedStateFromError === "function" || u2 !== null && typeof u2.componentDidCatch === "function" && (Si === null || !Si.has(u2)))) {
                    f2.flags |= 65536;
                    b2 &= -b2;
                    f2.lanes |= b2;
                    var F2 = Ri(f2, h2, b2);
                    fh(f2, F2);
                    break a;
                  }
              }
              f2 = f2.return;
            } while (f2 !== null);
          }
          Tk(c2);
        } catch (na) {
          b2 = na;
          Y === c2 && c2 !== null && (Y = c2 = c2.return);
          continue;
        }
        break;
      } while (1);
    }
    function Kk() {
      var a2 = nk.current;
      nk.current = ai;
      return a2 === null ? ai : a2;
    }
    function uj() {
      if (T2 === 0 || T2 === 3 || T2 === 2)
        T2 = 4;
      R2 === null || (hh & 268435455) === 0 && (rk & 268435455) === 0 || Dk(R2, Z);
    }
    function Jk(a2, b2) {
      var c2 = K;
      K |= 2;
      var d2 = Kk();
      if (R2 !== a2 || Z !== b2)
        vk = null, Lk(a2, b2);
      do
        try {
          Uk();
          break;
        } catch (e2) {
          Nk(a2, e2);
        }
      while (1);
      Qg();
      K = c2;
      nk.current = d2;
      if (Y !== null)
        throw Error(p2(261));
      R2 = null;
      Z = 0;
      return T2;
    }
    function Uk() {
      for (; Y !== null; )
        Vk(Y);
    }
    function Mk() {
      for (; Y !== null && !cc(); )
        Vk(Y);
    }
    function Vk(a2) {
      var b2 = Wk(a2.alternate, a2, gj);
      a2.memoizedProps = a2.pendingProps;
      b2 === null ? Tk(a2) : Y = b2;
      ok.current = null;
    }
    function Tk(a2) {
      var b2 = a2;
      do {
        var c2 = b2.alternate;
        a2 = b2.return;
        if ((b2.flags & 32768) === 0) {
          if (c2 = Fj(c2, b2, gj), c2 !== null) {
            Y = c2;
            return;
          }
        } else {
          c2 = Jj(c2, b2);
          if (c2 !== null) {
            c2.flags &= 32767;
            Y = c2;
            return;
          }
          if (a2 !== null)
            a2.flags |= 32768, a2.subtreeFlags = 0, a2.deletions = null;
          else {
            T2 = 6;
            Y = null;
            return;
          }
        }
        b2 = b2.sibling;
        if (b2 !== null) {
          Y = b2;
          return;
        }
        Y = b2 = a2;
      } while (b2 !== null);
      T2 === 0 && (T2 = 5);
    }
    function Qk(a2, b2, c2) {
      var d2 = C2, e2 = pk.transition;
      try {
        pk.transition = null, C2 = 1, Xk(a2, b2, c2, d2);
      } finally {
        pk.transition = e2, C2 = d2;
      }
      return null;
    }
    function Xk(a2, b2, c2, d2) {
      do
        Ik();
      while (xk !== null);
      if ((K & 6) !== 0)
        throw Error(p2(327));
      c2 = a2.finishedWork;
      var e2 = a2.finishedLanes;
      if (c2 === null)
        return null;
      a2.finishedWork = null;
      a2.finishedLanes = 0;
      if (c2 === a2.current)
        throw Error(p2(177));
      a2.callbackNode = null;
      a2.callbackPriority = 0;
      var f2 = c2.lanes | c2.childLanes;
      Bc(a2, f2);
      a2 === R2 && (Y = R2 = null, Z = 0);
      (c2.subtreeFlags & 2064) === 0 && (c2.flags & 2064) === 0 || wk || (wk = true, Gk(hc, function() {
        Ik();
        return null;
      }));
      f2 = (c2.flags & 15990) !== 0;
      if ((c2.subtreeFlags & 15990) !== 0 || f2) {
        f2 = pk.transition;
        pk.transition = null;
        var g2 = C2;
        C2 = 1;
        var h2 = K;
        K |= 4;
        ok.current = null;
        Pj(a2, c2);
        ek(c2, a2);
        Oe(Df);
        dd = !!Cf;
        Df = Cf = null;
        a2.current = c2;
        ik(c2, a2, e2);
        dc();
        K = h2;
        C2 = g2;
        pk.transition = f2;
      } else
        a2.current = c2;
      wk && (wk = false, xk = a2, yk = e2);
      f2 = a2.pendingLanes;
      f2 === 0 && (Si = null);
      mc(c2.stateNode, d2);
      Ek(a2, B());
      if (b2 !== null)
        for (d2 = a2.onRecoverableError, c2 = 0; c2 < b2.length; c2++)
          e2 = b2[c2], d2(e2.value, { componentStack: e2.stack, digest: e2.digest });
      if (Pi)
        throw Pi = false, a2 = Qi, Qi = null, a2;
      (yk & 1) !== 0 && a2.tag !== 0 && Ik();
      f2 = a2.pendingLanes;
      (f2 & 1) !== 0 ? a2 === Ak ? zk++ : (zk = 0, Ak = a2) : zk = 0;
      jg();
      return null;
    }
    function Ik() {
      if (xk !== null) {
        var a2 = Dc(yk), b2 = pk.transition, c2 = C2;
        try {
          pk.transition = null;
          C2 = 16 > a2 ? 16 : a2;
          if (xk === null)
            var d2 = false;
          else {
            a2 = xk;
            xk = null;
            yk = 0;
            if ((K & 6) !== 0)
              throw Error(p2(331));
            var e2 = K;
            K |= 4;
            for (V = a2.current; V !== null; ) {
              var f2 = V, g2 = f2.child;
              if ((V.flags & 16) !== 0) {
                var h2 = f2.deletions;
                if (h2 !== null) {
                  for (var k2 = 0; k2 < h2.length; k2++) {
                    var l2 = h2[k2];
                    for (V = l2; V !== null; ) {
                      var m2 = V;
                      switch (m2.tag) {
                        case 0:
                        case 11:
                        case 15:
                          Qj(8, m2, f2);
                      }
                      var q = m2.child;
                      if (q !== null)
                        q.return = m2, V = q;
                      else
                        for (; V !== null; ) {
                          m2 = V;
                          var r2 = m2.sibling, y2 = m2.return;
                          Tj(m2);
                          if (m2 === l2) {
                            V = null;
                            break;
                          }
                          if (r2 !== null) {
                            r2.return = y2;
                            V = r2;
                            break;
                          }
                          V = y2;
                        }
                    }
                  }
                  var n2 = f2.alternate;
                  if (n2 !== null) {
                    var t3 = n2.child;
                    if (t3 !== null) {
                      n2.child = null;
                      do {
                        var J = t3.sibling;
                        t3.sibling = null;
                        t3 = J;
                      } while (t3 !== null);
                    }
                  }
                  V = f2;
                }
              }
              if ((f2.subtreeFlags & 2064) !== 0 && g2 !== null)
                g2.return = f2, V = g2;
              else
                b:
                  for (; V !== null; ) {
                    f2 = V;
                    if ((f2.flags & 2048) !== 0)
                      switch (f2.tag) {
                        case 0:
                        case 11:
                        case 15:
                          Qj(9, f2, f2.return);
                      }
                    var x2 = f2.sibling;
                    if (x2 !== null) {
                      x2.return = f2.return;
                      V = x2;
                      break b;
                    }
                    V = f2.return;
                  }
            }
            var w2 = a2.current;
            for (V = w2; V !== null; ) {
              g2 = V;
              var u2 = g2.child;
              if ((g2.subtreeFlags & 2064) !== 0 && u2 !== null)
                u2.return = g2, V = u2;
              else
                b:
                  for (g2 = w2; V !== null; ) {
                    h2 = V;
                    if ((h2.flags & 2048) !== 0)
                      try {
                        switch (h2.tag) {
                          case 0:
                          case 11:
                          case 15:
                            Rj(9, h2);
                        }
                      } catch (na) {
                        W(h2, h2.return, na);
                      }
                    if (h2 === g2) {
                      V = null;
                      break b;
                    }
                    var F2 = h2.sibling;
                    if (F2 !== null) {
                      F2.return = h2.return;
                      V = F2;
                      break b;
                    }
                    V = h2.return;
                  }
            }
            K = e2;
            jg();
            if (lc && typeof lc.onPostCommitFiberRoot === "function")
              try {
                lc.onPostCommitFiberRoot(kc, a2);
              } catch (na) {
              }
            d2 = true;
          }
          return d2;
        } finally {
          C2 = c2, pk.transition = b2;
        }
      }
      return false;
    }
    function Yk(a2, b2, c2) {
      b2 = Ki(c2, b2);
      b2 = Oi(a2, b2, 1);
      a2 = dh(a2, b2, 1);
      b2 = L2();
      a2 !== null && (Ac(a2, 1, b2), Ek(a2, b2));
    }
    function W(a2, b2, c2) {
      if (a2.tag === 3)
        Yk(a2, a2, c2);
      else
        for (; b2 !== null; ) {
          if (b2.tag === 3) {
            Yk(b2, a2, c2);
            break;
          } else if (b2.tag === 1) {
            var d2 = b2.stateNode;
            if (typeof b2.type.getDerivedStateFromError === "function" || typeof d2.componentDidCatch === "function" && (Si === null || !Si.has(d2))) {
              a2 = Ki(c2, a2);
              a2 = Ri(b2, a2, 1);
              b2 = dh(b2, a2, 1);
              a2 = L2();
              b2 !== null && (Ac(b2, 1, a2), Ek(b2, a2));
              break;
            }
          }
          b2 = b2.return;
        }
    }
    function Ui(a2, b2, c2) {
      var d2 = a2.pingCache;
      d2 !== null && d2.delete(b2);
      b2 = L2();
      a2.pingedLanes |= a2.suspendedLanes & c2;
      R2 === a2 && (Z & c2) === c2 && (T2 === 4 || T2 === 3 && (Z & 130023424) === Z && 500 > B() - gk ? Lk(a2, 0) : sk |= c2);
      Ek(a2, b2);
    }
    function Zk(a2, b2) {
      b2 === 0 && ((a2.mode & 1) === 0 ? b2 = 1 : (b2 = sc, sc <<= 1, (sc & 130023424) === 0 && (sc = 4194304)));
      var c2 = L2();
      a2 = Zg(a2, b2);
      a2 !== null && (Ac(a2, b2, c2), Ek(a2, c2));
    }
    function vj(a2) {
      var b2 = a2.memoizedState, c2 = 0;
      b2 !== null && (c2 = b2.retryLane);
      Zk(a2, c2);
    }
    function ck(a2, b2) {
      var c2 = 0;
      switch (a2.tag) {
        case 13:
          var d2 = a2.stateNode;
          var e2 = a2.memoizedState;
          e2 !== null && (c2 = e2.retryLane);
          break;
        case 19:
          d2 = a2.stateNode;
          break;
        default:
          throw Error(p2(314));
      }
      d2 !== null && d2.delete(b2);
      Zk(a2, c2);
    }
    var Wk;
    Wk = function(a2, b2, c2) {
      if (a2 !== null)
        if (a2.memoizedProps !== b2.pendingProps || Wf.current)
          Ug = true;
        else {
          if ((a2.lanes & c2) === 0 && (b2.flags & 128) === 0)
            return Ug = false, zj(a2, b2, c2);
          Ug = (a2.flags & 131072) !== 0 ? true : false;
        }
      else
        Ug = false, I2 && (b2.flags & 1048576) !== 0 && ug(b2, ng, b2.index);
      b2.lanes = 0;
      switch (b2.tag) {
        case 2:
          var d2 = b2.type;
          jj(a2, b2);
          a2 = b2.pendingProps;
          var e2 = Yf(b2, H.current);
          Tg(b2, c2);
          e2 = Xh(null, b2, d2, a2, e2, c2);
          var f2 = bi();
          b2.flags |= 1;
          typeof e2 === "object" && e2 !== null && typeof e2.render === "function" && e2.$$typeof === void 0 ? (b2.tag = 1, b2.memoizedState = null, b2.updateQueue = null, Zf(d2) ? (f2 = true, cg(b2)) : f2 = false, b2.memoizedState = e2.state !== null && e2.state !== void 0 ? e2.state : null, ah(b2), e2.updater = nh, b2.stateNode = e2, e2._reactInternals = b2, rh(b2, d2, a2, c2), b2 = kj(null, b2, d2, true, f2, c2)) : (b2.tag = 0, I2 && f2 && vg(b2), Yi(null, b2, e2, c2), b2 = b2.child);
          return b2;
        case 16:
          d2 = b2.elementType;
          a: {
            jj(a2, b2);
            a2 = b2.pendingProps;
            e2 = d2._init;
            d2 = e2(d2._payload);
            b2.type = d2;
            e2 = b2.tag = $k(d2);
            a2 = Lg(d2, a2);
            switch (e2) {
              case 0:
                b2 = dj(null, b2, d2, a2, c2);
                break a;
              case 1:
                b2 = ij(null, b2, d2, a2, c2);
                break a;
              case 11:
                b2 = Zi(null, b2, d2, a2, c2);
                break a;
              case 14:
                b2 = aj(null, b2, d2, Lg(d2.type, a2), c2);
                break a;
            }
            throw Error(p2(306, d2, ""));
          }
          return b2;
        case 0:
          return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Lg(d2, e2), dj(a2, b2, d2, e2, c2);
        case 1:
          return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Lg(d2, e2), ij(a2, b2, d2, e2, c2);
        case 3:
          a: {
            lj(b2);
            if (a2 === null)
              throw Error(p2(387));
            d2 = b2.pendingProps;
            f2 = b2.memoizedState;
            e2 = f2.element;
            bh(a2, b2);
            gh(b2, d2, null, c2);
            var g2 = b2.memoizedState;
            d2 = g2.element;
            if (f2.isDehydrated)
              if (f2 = { element: d2, isDehydrated: false, cache: g2.cache, pendingSuspenseBoundaries: g2.pendingSuspenseBoundaries, transitions: g2.transitions }, b2.updateQueue.baseState = f2, b2.memoizedState = f2, b2.flags & 256) {
                e2 = Ki(Error(p2(423)), b2);
                b2 = mj(a2, b2, d2, c2, e2);
                break a;
              } else if (d2 !== e2) {
                e2 = Ki(Error(p2(424)), b2);
                b2 = mj(a2, b2, d2, c2, e2);
                break a;
              } else
                for (yg = Lf(b2.stateNode.containerInfo.firstChild), xg = b2, I2 = true, zg = null, c2 = Ch(b2, null, d2, c2), b2.child = c2; c2; )
                  c2.flags = c2.flags & -3 | 4096, c2 = c2.sibling;
            else {
              Ig();
              if (d2 === e2) {
                b2 = $i(a2, b2, c2);
                break a;
              }
              Yi(a2, b2, d2, c2);
            }
            b2 = b2.child;
          }
          return b2;
        case 5:
          return Kh(b2), a2 === null && Eg(b2), d2 = b2.type, e2 = b2.pendingProps, f2 = a2 !== null ? a2.memoizedProps : null, g2 = e2.children, Ef(d2, e2) ? g2 = null : f2 !== null && Ef(d2, f2) && (b2.flags |= 32), hj(a2, b2), Yi(a2, b2, g2, c2), b2.child;
        case 6:
          return a2 === null && Eg(b2), null;
        case 13:
          return pj(a2, b2, c2);
        case 4:
          return Ih(b2, b2.stateNode.containerInfo), d2 = b2.pendingProps, a2 === null ? b2.child = Bh(b2, null, d2, c2) : Yi(a2, b2, d2, c2), b2.child;
        case 11:
          return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Lg(d2, e2), Zi(a2, b2, d2, e2, c2);
        case 7:
          return Yi(a2, b2, b2.pendingProps, c2), b2.child;
        case 8:
          return Yi(a2, b2, b2.pendingProps.children, c2), b2.child;
        case 12:
          return Yi(a2, b2, b2.pendingProps.children, c2), b2.child;
        case 10:
          a: {
            d2 = b2.type._context;
            e2 = b2.pendingProps;
            f2 = b2.memoizedProps;
            g2 = e2.value;
            G(Mg, d2._currentValue);
            d2._currentValue = g2;
            if (f2 !== null)
              if (He(f2.value, g2)) {
                if (f2.children === e2.children && !Wf.current) {
                  b2 = $i(a2, b2, c2);
                  break a;
                }
              } else
                for (f2 = b2.child, f2 !== null && (f2.return = b2); f2 !== null; ) {
                  var h2 = f2.dependencies;
                  if (h2 !== null) {
                    g2 = f2.child;
                    for (var k2 = h2.firstContext; k2 !== null; ) {
                      if (k2.context === d2) {
                        if (f2.tag === 1) {
                          k2 = ch(-1, c2 & -c2);
                          k2.tag = 2;
                          var l2 = f2.updateQueue;
                          if (l2 !== null) {
                            l2 = l2.shared;
                            var m2 = l2.pending;
                            m2 === null ? k2.next = k2 : (k2.next = m2.next, m2.next = k2);
                            l2.pending = k2;
                          }
                        }
                        f2.lanes |= c2;
                        k2 = f2.alternate;
                        k2 !== null && (k2.lanes |= c2);
                        Sg(f2.return, c2, b2);
                        h2.lanes |= c2;
                        break;
                      }
                      k2 = k2.next;
                    }
                  } else if (f2.tag === 10)
                    g2 = f2.type === b2.type ? null : f2.child;
                  else if (f2.tag === 18) {
                    g2 = f2.return;
                    if (g2 === null)
                      throw Error(p2(341));
                    g2.lanes |= c2;
                    h2 = g2.alternate;
                    h2 !== null && (h2.lanes |= c2);
                    Sg(g2, c2, b2);
                    g2 = f2.sibling;
                  } else
                    g2 = f2.child;
                  if (g2 !== null)
                    g2.return = f2;
                  else
                    for (g2 = f2; g2 !== null; ) {
                      if (g2 === b2) {
                        g2 = null;
                        break;
                      }
                      f2 = g2.sibling;
                      if (f2 !== null) {
                        f2.return = g2.return;
                        g2 = f2;
                        break;
                      }
                      g2 = g2.return;
                    }
                  f2 = g2;
                }
            Yi(a2, b2, e2.children, c2);
            b2 = b2.child;
          }
          return b2;
        case 9:
          return e2 = b2.type, d2 = b2.pendingProps.children, Tg(b2, c2), e2 = Vg(e2), d2 = d2(e2), b2.flags |= 1, Yi(a2, b2, d2, c2), b2.child;
        case 14:
          return d2 = b2.type, e2 = Lg(d2, b2.pendingProps), e2 = Lg(d2.type, e2), aj(a2, b2, d2, e2, c2);
        case 15:
          return cj(a2, b2, b2.type, b2.pendingProps, c2);
        case 17:
          return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Lg(d2, e2), jj(a2, b2), b2.tag = 1, Zf(d2) ? (a2 = true, cg(b2)) : a2 = false, Tg(b2, c2), ph(b2, d2, e2), rh(b2, d2, e2, c2), kj(null, b2, d2, true, a2, c2);
        case 19:
          return yj(a2, b2, c2);
        case 22:
          return ej(a2, b2, c2);
      }
      throw Error(p2(156, b2.tag));
    };
    function Gk(a2, b2) {
      return ac(a2, b2);
    }
    function al(a2, b2, c2, d2) {
      this.tag = a2;
      this.key = c2;
      this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
      this.index = 0;
      this.ref = null;
      this.pendingProps = b2;
      this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
      this.mode = d2;
      this.subtreeFlags = this.flags = 0;
      this.deletions = null;
      this.childLanes = this.lanes = 0;
      this.alternate = null;
    }
    function Bg(a2, b2, c2, d2) {
      return new al(a2, b2, c2, d2);
    }
    function bj(a2) {
      a2 = a2.prototype;
      return !(!a2 || !a2.isReactComponent);
    }
    function $k(a2) {
      if (typeof a2 === "function")
        return bj(a2) ? 1 : 0;
      if (a2 !== void 0 && a2 !== null) {
        a2 = a2.$$typeof;
        if (a2 === Da)
          return 11;
        if (a2 === Ga)
          return 14;
      }
      return 2;
    }
    function wh(a2, b2) {
      var c2 = a2.alternate;
      c2 === null ? (c2 = Bg(a2.tag, b2, a2.key, a2.mode), c2.elementType = a2.elementType, c2.type = a2.type, c2.stateNode = a2.stateNode, c2.alternate = a2, a2.alternate = c2) : (c2.pendingProps = b2, c2.type = a2.type, c2.flags = 0, c2.subtreeFlags = 0, c2.deletions = null);
      c2.flags = a2.flags & 14680064;
      c2.childLanes = a2.childLanes;
      c2.lanes = a2.lanes;
      c2.child = a2.child;
      c2.memoizedProps = a2.memoizedProps;
      c2.memoizedState = a2.memoizedState;
      c2.updateQueue = a2.updateQueue;
      b2 = a2.dependencies;
      c2.dependencies = b2 === null ? null : { lanes: b2.lanes, firstContext: b2.firstContext };
      c2.sibling = a2.sibling;
      c2.index = a2.index;
      c2.ref = a2.ref;
      return c2;
    }
    function yh(a2, b2, c2, d2, e2, f2) {
      var g2 = 2;
      d2 = a2;
      if (typeof a2 === "function")
        bj(a2) && (g2 = 1);
      else if (typeof a2 === "string")
        g2 = 5;
      else
        a:
          switch (a2) {
            case ya:
              return Ah(c2.children, e2, f2, b2);
            case za:
              g2 = 8;
              e2 |= 8;
              break;
            case Aa:
              return a2 = Bg(12, c2, b2, e2 | 2), a2.elementType = Aa, a2.lanes = f2, a2;
            case Ea:
              return a2 = Bg(13, c2, b2, e2), a2.elementType = Ea, a2.lanes = f2, a2;
            case Fa:
              return a2 = Bg(19, c2, b2, e2), a2.elementType = Fa, a2.lanes = f2, a2;
            case Ia:
              return qj(c2, e2, f2, b2);
            default:
              if (typeof a2 === "object" && a2 !== null)
                switch (a2.$$typeof) {
                  case Ba:
                    g2 = 10;
                    break a;
                  case Ca:
                    g2 = 9;
                    break a;
                  case Da:
                    g2 = 11;
                    break a;
                  case Ga:
                    g2 = 14;
                    break a;
                  case Ha:
                    g2 = 16;
                    d2 = null;
                    break a;
                }
              throw Error(p2(130, a2 == null ? a2 : typeof a2, ""));
          }
      b2 = Bg(g2, c2, b2, e2);
      b2.elementType = a2;
      b2.type = d2;
      b2.lanes = f2;
      return b2;
    }
    function Ah(a2, b2, c2, d2) {
      a2 = Bg(7, a2, d2, b2);
      a2.lanes = c2;
      return a2;
    }
    function qj(a2, b2, c2, d2) {
      a2 = Bg(22, a2, d2, b2);
      a2.elementType = Ia;
      a2.lanes = c2;
      a2.stateNode = { isHidden: false };
      return a2;
    }
    function xh(a2, b2, c2) {
      a2 = Bg(6, a2, null, b2);
      a2.lanes = c2;
      return a2;
    }
    function zh(a2, b2, c2) {
      b2 = Bg(4, a2.children !== null ? a2.children : [], a2.key, b2);
      b2.lanes = c2;
      b2.stateNode = { containerInfo: a2.containerInfo, pendingChildren: null, implementation: a2.implementation };
      return b2;
    }
    function bl(a2, b2, c2, d2, e2) {
      this.tag = b2;
      this.containerInfo = a2;
      this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
      this.timeoutHandle = -1;
      this.callbackNode = this.pendingContext = this.context = null;
      this.callbackPriority = 0;
      this.eventTimes = zc(0);
      this.expirationTimes = zc(-1);
      this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
      this.entanglements = zc(0);
      this.identifierPrefix = d2;
      this.onRecoverableError = e2;
      this.mutableSourceEagerHydrationData = null;
    }
    function cl(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
      a2 = new bl(a2, b2, c2, h2, k2);
      b2 === 1 ? (b2 = 1, f2 === true && (b2 |= 8)) : b2 = 0;
      f2 = Bg(3, null, null, b2);
      a2.current = f2;
      f2.stateNode = a2;
      f2.memoizedState = { element: d2, isDehydrated: c2, cache: null, transitions: null, pendingSuspenseBoundaries: null };
      ah(f2);
      return a2;
    }
    function dl(a2, b2, c2) {
      var d2 = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
      return { $$typeof: wa, key: d2 == null ? null : "" + d2, children: a2, containerInfo: b2, implementation: c2 };
    }
    function el(a2) {
      if (!a2)
        return Vf;
      a2 = a2._reactInternals;
      a: {
        if (Vb(a2) !== a2 || a2.tag !== 1)
          throw Error(p2(170));
        var b2 = a2;
        do {
          switch (b2.tag) {
            case 3:
              b2 = b2.stateNode.context;
              break a;
            case 1:
              if (Zf(b2.type)) {
                b2 = b2.stateNode.__reactInternalMemoizedMergedChildContext;
                break a;
              }
          }
          b2 = b2.return;
        } while (b2 !== null);
        throw Error(p2(171));
      }
      if (a2.tag === 1) {
        var c2 = a2.type;
        if (Zf(c2))
          return bg(a2, c2, b2);
      }
      return b2;
    }
    function fl(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
      a2 = cl(c2, d2, true, a2, e2, f2, g2, h2, k2);
      a2.context = el(null);
      c2 = a2.current;
      d2 = L2();
      e2 = lh(c2);
      f2 = ch(d2, e2);
      f2.callback = b2 !== void 0 && b2 !== null ? b2 : null;
      dh(c2, f2, e2);
      a2.current.lanes = e2;
      Ac(a2, e2, d2);
      Ek(a2, d2);
      return a2;
    }
    function gl(a2, b2, c2, d2) {
      var e2 = b2.current, f2 = L2(), g2 = lh(e2);
      c2 = el(c2);
      b2.context === null ? b2.context = c2 : b2.pendingContext = c2;
      b2 = ch(f2, g2);
      b2.payload = { element: a2 };
      d2 = d2 === void 0 ? null : d2;
      d2 !== null && (b2.callback = d2);
      a2 = dh(e2, b2, g2);
      a2 !== null && (mh(a2, e2, g2, f2), eh(a2, e2, g2));
      return g2;
    }
    function hl(a2) {
      a2 = a2.current;
      if (!a2.child)
        return null;
      switch (a2.child.tag) {
        case 5:
          return a2.child.stateNode;
        default:
          return a2.child.stateNode;
      }
    }
    function il(a2, b2) {
      a2 = a2.memoizedState;
      if (a2 !== null && a2.dehydrated !== null) {
        var c2 = a2.retryLane;
        a2.retryLane = c2 !== 0 && c2 < b2 ? c2 : b2;
      }
    }
    function jl(a2, b2) {
      il(a2, b2);
      (a2 = a2.alternate) && il(a2, b2);
    }
    function kl() {
      return null;
    }
    var ll = typeof reportError === "function" ? reportError : function(a2) {
      console.error(a2);
    };
    function ml(a2) {
      this._internalRoot = a2;
    }
    nl.prototype.render = ml.prototype.render = function(a2) {
      var b2 = this._internalRoot;
      if (b2 === null)
        throw Error(p2(409));
      gl(a2, b2, null, null);
    };
    nl.prototype.unmount = ml.prototype.unmount = function() {
      var a2 = this._internalRoot;
      if (a2 !== null) {
        this._internalRoot = null;
        var b2 = a2.containerInfo;
        Sk(function() {
          gl(null, a2, null, null);
        });
        b2[uf] = null;
      }
    };
    function nl(a2) {
      this._internalRoot = a2;
    }
    nl.prototype.unstable_scheduleHydration = function(a2) {
      if (a2) {
        var b2 = Hc();
        a2 = { blockedOn: null, target: a2, priority: b2 };
        for (var c2 = 0; c2 < Qc.length && b2 !== 0 && b2 < Qc[c2].priority; c2++)
          ;
        Qc.splice(c2, 0, a2);
        c2 === 0 && Vc(a2);
      }
    };
    function ol(a2) {
      return !(!a2 || a2.nodeType !== 1 && a2.nodeType !== 9 && a2.nodeType !== 11);
    }
    function pl(a2) {
      return !(!a2 || a2.nodeType !== 1 && a2.nodeType !== 9 && a2.nodeType !== 11 && (a2.nodeType !== 8 || a2.nodeValue !== " react-mount-point-unstable "));
    }
    function ql() {
    }
    function rl(a2, b2, c2, d2, e2) {
      if (e2) {
        if (typeof d2 === "function") {
          var f2 = d2;
          d2 = function() {
            var a3 = hl(g2);
            f2.call(a3);
          };
        }
        var g2 = fl(b2, d2, a2, 0, null, false, false, "", ql);
        a2._reactRootContainer = g2;
        a2[uf] = g2.current;
        sf(a2.nodeType === 8 ? a2.parentNode : a2);
        Sk();
        return g2;
      }
      for (; e2 = a2.lastChild; )
        a2.removeChild(e2);
      if (typeof d2 === "function") {
        var h2 = d2;
        d2 = function() {
          var a3 = hl(k2);
          h2.call(a3);
        };
      }
      var k2 = cl(a2, 0, false, null, null, false, false, "", ql);
      a2._reactRootContainer = k2;
      a2[uf] = k2.current;
      sf(a2.nodeType === 8 ? a2.parentNode : a2);
      Sk(function() {
        gl(b2, k2, c2, d2);
      });
      return k2;
    }
    function sl(a2, b2, c2, d2, e2) {
      var f2 = c2._reactRootContainer;
      if (f2) {
        var g2 = f2;
        if (typeof e2 === "function") {
          var h2 = e2;
          e2 = function() {
            var a3 = hl(g2);
            h2.call(a3);
          };
        }
        gl(b2, g2, a2, e2);
      } else
        g2 = rl(c2, b2, a2, e2, d2);
      return hl(g2);
    }
    Ec = function(a2) {
      switch (a2.tag) {
        case 3:
          var b2 = a2.stateNode;
          if (b2.current.memoizedState.isDehydrated) {
            var c2 = tc(b2.pendingLanes);
            c2 !== 0 && (Cc(b2, c2 | 1), Ek(b2, B()), (K & 6) === 0 && (Hj = B() + 500, jg()));
          }
          break;
        case 13:
          Sk(function() {
            var b3 = Zg(a2, 1);
            if (b3 !== null) {
              var c3 = L2();
              mh(b3, a2, 1, c3);
            }
          }), jl(a2, 1);
      }
    };
    Fc = function(a2) {
      if (a2.tag === 13) {
        var b2 = Zg(a2, 134217728);
        if (b2 !== null) {
          var c2 = L2();
          mh(b2, a2, 134217728, c2);
        }
        jl(a2, 134217728);
      }
    };
    Gc = function(a2) {
      if (a2.tag === 13) {
        var b2 = lh(a2), c2 = Zg(a2, b2);
        if (c2 !== null) {
          var d2 = L2();
          mh(c2, a2, b2, d2);
        }
        jl(a2, b2);
      }
    };
    Hc = function() {
      return C2;
    };
    Ic = function(a2, b2) {
      var c2 = C2;
      try {
        return C2 = a2, b2();
      } finally {
        C2 = c2;
      }
    };
    yb = function(a2, b2, c2) {
      switch (b2) {
        case "input":
          bb(a2, c2);
          b2 = c2.name;
          if (c2.type === "radio" && b2 != null) {
            for (c2 = a2; c2.parentNode; )
              c2 = c2.parentNode;
            c2 = c2.querySelectorAll("input[name=" + JSON.stringify("" + b2) + '][type="radio"]');
            for (b2 = 0; b2 < c2.length; b2++) {
              var d2 = c2[b2];
              if (d2 !== a2 && d2.form === a2.form) {
                var e2 = Db(d2);
                if (!e2)
                  throw Error(p2(90));
                Wa(d2);
                bb(d2, e2);
              }
            }
          }
          break;
        case "textarea":
          ib(a2, c2);
          break;
        case "select":
          b2 = c2.value, b2 != null && fb(a2, !!c2.multiple, b2, false);
      }
    };
    Gb = Rk;
    Hb = Sk;
    var tl = { usingClientEntryPoint: false, Events: [Cb, ue, Db, Eb, Fb, Rk] };
    var ul = { findFiberByHostInstance: Wc, bundleType: 0, version: "18.2.0", rendererPackageName: "react-dom" };
    var vl = { bundleType: ul.bundleType, version: ul.version, rendererPackageName: ul.rendererPackageName, rendererConfig: ul.rendererConfig, overrideHookState: null, overrideHookStateDeletePath: null, overrideHookStateRenamePath: null, overrideProps: null, overridePropsDeletePath: null, overridePropsRenamePath: null, setErrorHandler: null, setSuspenseHandler: null, scheduleUpdate: null, currentDispatcherRef: ua.ReactCurrentDispatcher, findHostInstanceByFiber: function(a2) {
      a2 = Zb(a2);
      return a2 === null ? null : a2.stateNode;
    }, findFiberByHostInstance: ul.findFiberByHostInstance || kl, findHostInstancesForRefresh: null, scheduleRefresh: null, scheduleRoot: null, setRefreshHandler: null, getCurrentFiber: null, reconcilerVersion: "18.2.0-next-9e3b772b8-20220608" };
    if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined") {
      wl = __REACT_DEVTOOLS_GLOBAL_HOOK__;
      if (!wl.isDisabled && wl.supportsFiber)
        try {
          kc = wl.inject(vl), lc = wl;
        } catch (a2) {
        }
    }
    var wl;
    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = tl;
    exports.createPortal = function(a2, b2) {
      var c2 = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
      if (!ol(b2))
        throw Error(p2(200));
      return dl(a2, b2, null, c2);
    };
    exports.createRoot = function(a2, b2) {
      if (!ol(a2))
        throw Error(p2(299));
      var c2 = false, d2 = "", e2 = ll;
      b2 !== null && b2 !== void 0 && (b2.unstable_strictMode === true && (c2 = true), b2.identifierPrefix !== void 0 && (d2 = b2.identifierPrefix), b2.onRecoverableError !== void 0 && (e2 = b2.onRecoverableError));
      b2 = cl(a2, 1, false, null, null, c2, false, d2, e2);
      a2[uf] = b2.current;
      sf(a2.nodeType === 8 ? a2.parentNode : a2);
      return new ml(b2);
    };
    exports.findDOMNode = function(a2) {
      if (a2 == null)
        return null;
      if (a2.nodeType === 1)
        return a2;
      var b2 = a2._reactInternals;
      if (b2 === void 0) {
        if (typeof a2.render === "function")
          throw Error(p2(188));
        a2 = Object.keys(a2).join(",");
        throw Error(p2(268, a2));
      }
      a2 = Zb(b2);
      a2 = a2 === null ? null : a2.stateNode;
      return a2;
    };
    exports.flushSync = function(a2) {
      return Sk(a2);
    };
    exports.hydrate = function(a2, b2, c2) {
      if (!pl(b2))
        throw Error(p2(200));
      return sl(null, a2, b2, true, c2);
    };
    exports.hydrateRoot = function(a2, b2, c2) {
      if (!ol(a2))
        throw Error(p2(405));
      var d2 = c2 != null && c2.hydratedSources || null, e2 = false, f2 = "", g2 = ll;
      c2 !== null && c2 !== void 0 && (c2.unstable_strictMode === true && (e2 = true), c2.identifierPrefix !== void 0 && (f2 = c2.identifierPrefix), c2.onRecoverableError !== void 0 && (g2 = c2.onRecoverableError));
      b2 = fl(b2, null, a2, 1, c2 != null ? c2 : null, e2, false, f2, g2);
      a2[uf] = b2.current;
      sf(a2);
      if (d2)
        for (a2 = 0; a2 < d2.length; a2++)
          c2 = d2[a2], e2 = c2._getVersion, e2 = e2(c2._source), b2.mutableSourceEagerHydrationData == null ? b2.mutableSourceEagerHydrationData = [c2, e2] : b2.mutableSourceEagerHydrationData.push(c2, e2);
      return new nl(b2);
    };
    exports.render = function(a2, b2, c2) {
      if (!pl(b2))
        throw Error(p2(200));
      return sl(null, a2, b2, false, c2);
    };
    exports.unmountComponentAtNode = function(a2) {
      if (!pl(a2))
        throw Error(p2(40));
      return a2._reactRootContainer ? (Sk(function() {
        sl(null, null, a2, false, function() {
          a2._reactRootContainer = null;
          a2[uf] = null;
        });
      }), true) : false;
    };
    exports.unstable_batchedUpdates = Rk;
    exports.unstable_renderSubtreeIntoContainer = function(a2, b2, c2, d2) {
      if (!pl(c2))
        throw Error(p2(200));
      if (a2 == null || a2._reactInternals === void 0)
        throw Error(p2(38));
      return sl(a2, b2, c2, false, d2);
    };
    exports.version = "18.2.0-next-9e3b772b8-20220608";
  }
});

// node_modules/react-dom/index.js
var require_react_dom = __commonJS({
  "node_modules/react-dom/index.js"(exports, module2) {
    "use strict";
    function checkDCE() {
      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") {
        return;
      }
      if (false) {
        throw new Error("^_^");
      }
      try {
        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
      } catch (err) {
        console.error(err);
      }
    }
    if (true) {
      checkDCE();
      module2.exports = require_react_dom_production_min();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/react-dom/client.js
var require_client = __commonJS({
  "node_modules/react-dom/client.js"(exports) {
    "use strict";
    var m2 = require_react_dom();
    if (true) {
      exports.createRoot = m2.createRoot;
      exports.hydrateRoot = m2.hydrateRoot;
    } else {
      i2 = m2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
      exports.createRoot = function(c2, o2) {
        i2.usingClientEntryPoint = true;
        try {
          return m2.createRoot(c2, o2);
        } finally {
          i2.usingClientEntryPoint = false;
        }
      };
      exports.hydrateRoot = function(c2, h2, o2) {
        i2.usingClientEntryPoint = true;
        try {
          return m2.hydrateRoot(c2, h2, o2);
        } finally {
          i2.usingClientEntryPoint = false;
        }
      };
    }
    var i2;
  }
});

// src/logic/utils/embed.ts
function stringifyEmbedData(embedData) {
  return JSON.stringify(embedData, null, "	");
}
function applyCommonAncestorStyling(embedEl) {
  const parentEmbedBlockEl = embedEl.closest(".cm-embed-block");
  if (!parentEmbedBlockEl)
    return;
  parentEmbedBlockEl.classList.add("ddc_ink_embed-block");
  const parentPageScrollerEl = embedEl.closest(".cm-scroller");
  const scrollerStyle = window.getComputedStyle(parentPageScrollerEl);
  const scrollerInlineStartMargin = scrollerStyle.paddingInlineStart;
  const scrollerInlineEndMargin = scrollerStyle.paddingInlineEnd;
  const pageHasScrollerInlineStartMargin = scrollerInlineStartMargin && scrollerInlineStartMargin !== "0" && scrollerInlineStartMargin !== "0px";
  if (pageHasScrollerInlineStartMargin) {
    let style = parentEmbedBlockEl.getAttribute("style") ?? "";
    style += `; margin-inline-start: calc(-1 * ${scrollerInlineStartMargin} + 4px) !important`;
    parentEmbedBlockEl.setAttribute("style", style);
  } else {
  }
  const pageHasScrollerInlineEndMargin = scrollerInlineEndMargin && scrollerInlineEndMargin !== "0" && scrollerInlineEndMargin !== "0px";
  if (pageHasScrollerInlineEndMargin) {
    let style = parentEmbedBlockEl.getAttribute("style") ?? "";
    style += `; margin-inline-end: calc(-1 * ${scrollerInlineEndMargin} + 4px) !important`;
    parentEmbedBlockEl.setAttribute("style", style);
  } else {
  }
}
function applyReadingModeAncestorStyling(hostEl, embedKind) {
  hostEl.classList.add("ddc_ink_embed-block");
  if (embedKind !== "drawing")
    return;
  const previewContainerEl = hostEl.closest(".markdown-preview-view") ?? hostEl.closest(".markdown-rendered");
  if (!previewContainerEl)
    return;
  const previewStyle = window.getComputedStyle(previewContainerEl);
  appendNegativeHorizontalMargin(hostEl, previewStyle.paddingInlineStart, "margin-inline-start");
  appendNegativeHorizontalMargin(hostEl, previewStyle.paddingInlineEnd, "margin-inline-end");
}
function appendNegativeHorizontalMargin(targetEl, marginValue, cssProperty) {
  const hasMargin = marginValue && marginValue !== "0" && marginValue !== "0px";
  if (!hasMargin)
    return;
  let style = targetEl.getAttribute("style") ?? "";
  style += `; ${cssProperty}: calc(-1 * ${marginValue} + 4px) !important`;
  targetEl.setAttribute("style", style);
}
function removeEmbed(plugin, ctx, el) {
  const cmEditor = plugin.app.workspace.activeEditor?.editor;
  if (!cmEditor)
    return;
  const sectionInfo = ctx.getSectionInfo(el);
  if (sectionInfo?.lineStart === void 0 || sectionInfo.lineEnd === void 0)
    return;
  const editorStart = {
    line: sectionInfo.lineStart,
    ch: 0
  };
  const editorEnd = {
    line: sectionInfo.lineEnd + 1,
    ch: 0
  };
  cmEditor.replaceRange("", editorStart, editorEnd);
  cmEditor.setCursor(editorStart);
}
var init_embed = __esm({
  "src/logic/utils/embed.ts"() {
  }
});

// node_modules/core-js/internals/global-this.js
var require_global_this = __commonJS({
  "node_modules/core-js/internals/global-this.js"(exports, module2) {
    "use strict";
    var check = function(it) {
      return it && it.Math === Math && it;
    };
    module2.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || function() {
      return this;
    }() || Function("return this")();
  }
});

// node_modules/core-js/internals/fails.js
var require_fails = __commonJS({
  "node_modules/core-js/internals/fails.js"(exports, module2) {
    "use strict";
    module2.exports = function(exec) {
      try {
        return !!exec();
      } catch (error2) {
        return true;
      }
    };
  }
});

// node_modules/core-js/internals/descriptors.js
var require_descriptors = __commonJS({
  "node_modules/core-js/internals/descriptors.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    module2.exports = !fails(function() {
      return Object.defineProperty({}, 1, { get: function() {
        return 7;
      } })[1] !== 7;
    });
  }
});

// node_modules/core-js/internals/function-bind-native.js
var require_function_bind_native = __commonJS({
  "node_modules/core-js/internals/function-bind-native.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    module2.exports = !fails(function() {
      var test2 = function() {
      }.bind();
      return typeof test2 != "function" || test2.hasOwnProperty("prototype");
    });
  }
});

// node_modules/core-js/internals/function-call.js
var require_function_call = __commonJS({
  "node_modules/core-js/internals/function-call.js"(exports, module2) {
    "use strict";
    var NATIVE_BIND = require_function_bind_native();
    var call = Function.prototype.call;
    module2.exports = NATIVE_BIND ? call.bind(call) : function() {
      return call.apply(call, arguments);
    };
  }
});

// node_modules/core-js/internals/object-property-is-enumerable.js
var require_object_property_is_enumerable = __commonJS({
  "node_modules/core-js/internals/object-property-is-enumerable.js"(exports) {
    "use strict";
    var $propertyIsEnumerable = {}.propertyIsEnumerable;
    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
    exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
      var descriptor = getOwnPropertyDescriptor(this, V);
      return !!descriptor && descriptor.enumerable;
    } : $propertyIsEnumerable;
  }
});

// node_modules/core-js/internals/create-property-descriptor.js
var require_create_property_descriptor = __commonJS({
  "node_modules/core-js/internals/create-property-descriptor.js"(exports, module2) {
    "use strict";
    module2.exports = function(bitmap, value) {
      return {
        enumerable: !(bitmap & 1),
        configurable: !(bitmap & 2),
        writable: !(bitmap & 4),
        value
      };
    };
  }
});

// node_modules/core-js/internals/function-uncurry-this.js
var require_function_uncurry_this = __commonJS({
  "node_modules/core-js/internals/function-uncurry-this.js"(exports, module2) {
    "use strict";
    var NATIVE_BIND = require_function_bind_native();
    var FunctionPrototype = Function.prototype;
    var call = FunctionPrototype.call;
    var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
    module2.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn3) {
      return function() {
        return call.apply(fn3, arguments);
      };
    };
  }
});

// node_modules/core-js/internals/classof-raw.js
var require_classof_raw = __commonJS({
  "node_modules/core-js/internals/classof-raw.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var toString = uncurryThis({}.toString);
    var stringSlice = uncurryThis("".slice);
    module2.exports = function(it) {
      return stringSlice(toString(it), 8, -1);
    };
  }
});

// node_modules/core-js/internals/indexed-object.js
var require_indexed_object = __commonJS({
  "node_modules/core-js/internals/indexed-object.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var fails = require_fails();
    var classof = require_classof_raw();
    var $Object = Object;
    var split = uncurryThis("".split);
    module2.exports = fails(function() {
      return !$Object("z").propertyIsEnumerable(0);
    }) ? function(it) {
      return classof(it) === "String" ? split(it, "") : $Object(it);
    } : $Object;
  }
});

// node_modules/core-js/internals/is-null-or-undefined.js
var require_is_null_or_undefined = __commonJS({
  "node_modules/core-js/internals/is-null-or-undefined.js"(exports, module2) {
    "use strict";
    module2.exports = function(it) {
      return it === null || it === void 0;
    };
  }
});

// node_modules/core-js/internals/require-object-coercible.js
var require_require_object_coercible = __commonJS({
  "node_modules/core-js/internals/require-object-coercible.js"(exports, module2) {
    "use strict";
    var isNullOrUndefined = require_is_null_or_undefined();
    var $TypeError = TypeError;
    module2.exports = function(it) {
      if (isNullOrUndefined(it))
        throw new $TypeError("Can't call method on " + it);
      return it;
    };
  }
});

// node_modules/core-js/internals/to-indexed-object.js
var require_to_indexed_object = __commonJS({
  "node_modules/core-js/internals/to-indexed-object.js"(exports, module2) {
    "use strict";
    var IndexedObject = require_indexed_object();
    var requireObjectCoercible = require_require_object_coercible();
    module2.exports = function(it) {
      return IndexedObject(requireObjectCoercible(it));
    };
  }
});

// node_modules/core-js/internals/is-callable.js
var require_is_callable = __commonJS({
  "node_modules/core-js/internals/is-callable.js"(exports, module2) {
    "use strict";
    var documentAll = typeof document == "object" && document.all;
    module2.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) {
      return typeof argument == "function" || argument === documentAll;
    } : function(argument) {
      return typeof argument == "function";
    };
  }
});

// node_modules/core-js/internals/is-object.js
var require_is_object = __commonJS({
  "node_modules/core-js/internals/is-object.js"(exports, module2) {
    "use strict";
    var isCallable = require_is_callable();
    module2.exports = function(it) {
      return typeof it == "object" ? it !== null : isCallable(it);
    };
  }
});

// node_modules/core-js/internals/get-built-in.js
var require_get_built_in = __commonJS({
  "node_modules/core-js/internals/get-built-in.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var isCallable = require_is_callable();
    var aFunction = function(argument) {
      return isCallable(argument) ? argument : void 0;
    };
    module2.exports = function(namespace, method) {
      return arguments.length < 2 ? aFunction(globalThis2[namespace]) : globalThis2[namespace] && globalThis2[namespace][method];
    };
  }
});

// node_modules/core-js/internals/object-is-prototype-of.js
var require_object_is_prototype_of = __commonJS({
  "node_modules/core-js/internals/object-is-prototype-of.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    module2.exports = uncurryThis({}.isPrototypeOf);
  }
});

// node_modules/core-js/internals/environment-user-agent.js
var require_environment_user_agent = __commonJS({
  "node_modules/core-js/internals/environment-user-agent.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var navigator2 = globalThis2.navigator;
    var userAgent = navigator2 && navigator2.userAgent;
    module2.exports = userAgent ? String(userAgent) : "";
  }
});

// node_modules/core-js/internals/environment-v8-version.js
var require_environment_v8_version = __commonJS({
  "node_modules/core-js/internals/environment-v8-version.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var userAgent = require_environment_user_agent();
    var process2 = globalThis2.process;
    var Deno = globalThis2.Deno;
    var versions = process2 && process2.versions || Deno && Deno.version;
    var v8 = versions && versions.v8;
    var match;
    var version2;
    if (v8) {
      match = v8.split(".");
      version2 = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
    }
    if (!version2 && userAgent) {
      match = userAgent.match(/Edge\/(\d+)/);
      if (!match || match[1] >= 74) {
        match = userAgent.match(/Chrome\/(\d+)/);
        if (match)
          version2 = +match[1];
      }
    }
    module2.exports = version2;
  }
});

// node_modules/core-js/internals/symbol-constructor-detection.js
var require_symbol_constructor_detection = __commonJS({
  "node_modules/core-js/internals/symbol-constructor-detection.js"(exports, module2) {
    "use strict";
    var V8_VERSION = require_environment_v8_version();
    var fails = require_fails();
    var globalThis2 = require_global_this();
    var $String = globalThis2.String;
    module2.exports = !!Object.getOwnPropertySymbols && !fails(function() {
      var symbol = Symbol("symbol detection");
      return !$String(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION && V8_VERSION < 41;
    });
  }
});

// node_modules/core-js/internals/use-symbol-as-uid.js
var require_use_symbol_as_uid = __commonJS({
  "node_modules/core-js/internals/use-symbol-as-uid.js"(exports, module2) {
    "use strict";
    var NATIVE_SYMBOL = require_symbol_constructor_detection();
    module2.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
  }
});

// node_modules/core-js/internals/is-symbol.js
var require_is_symbol = __commonJS({
  "node_modules/core-js/internals/is-symbol.js"(exports, module2) {
    "use strict";
    var getBuiltIn = require_get_built_in();
    var isCallable = require_is_callable();
    var isPrototypeOf = require_object_is_prototype_of();
    var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
    var $Object = Object;
    module2.exports = USE_SYMBOL_AS_UID ? function(it) {
      return typeof it == "symbol";
    } : function(it) {
      var $Symbol = getBuiltIn("Symbol");
      return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
    };
  }
});

// node_modules/core-js/internals/try-to-string.js
var require_try_to_string = __commonJS({
  "node_modules/core-js/internals/try-to-string.js"(exports, module2) {
    "use strict";
    var $String = String;
    module2.exports = function(argument) {
      try {
        return $String(argument);
      } catch (error2) {
        return "Object";
      }
    };
  }
});

// node_modules/core-js/internals/a-callable.js
var require_a_callable = __commonJS({
  "node_modules/core-js/internals/a-callable.js"(exports, module2) {
    "use strict";
    var isCallable = require_is_callable();
    var tryToString = require_try_to_string();
    var $TypeError = TypeError;
    module2.exports = function(argument) {
      if (isCallable(argument))
        return argument;
      throw new $TypeError(tryToString(argument) + " is not a function");
    };
  }
});

// node_modules/core-js/internals/get-method.js
var require_get_method = __commonJS({
  "node_modules/core-js/internals/get-method.js"(exports, module2) {
    "use strict";
    var aCallable = require_a_callable();
    var isNullOrUndefined = require_is_null_or_undefined();
    module2.exports = function(V, P2) {
      var func = V[P2];
      return isNullOrUndefined(func) ? void 0 : aCallable(func);
    };
  }
});

// node_modules/core-js/internals/ordinary-to-primitive.js
var require_ordinary_to_primitive = __commonJS({
  "node_modules/core-js/internals/ordinary-to-primitive.js"(exports, module2) {
    "use strict";
    var call = require_function_call();
    var isCallable = require_is_callable();
    var isObject = require_is_object();
    var $TypeError = TypeError;
    module2.exports = function(input, pref) {
      var fn3, val;
      if (pref === "string" && isCallable(fn3 = input.toString) && !isObject(val = call(fn3, input)))
        return val;
      if (isCallable(fn3 = input.valueOf) && !isObject(val = call(fn3, input)))
        return val;
      if (pref !== "string" && isCallable(fn3 = input.toString) && !isObject(val = call(fn3, input)))
        return val;
      throw new $TypeError("Can't convert object to primitive value");
    };
  }
});

// node_modules/core-js/internals/is-pure.js
var require_is_pure = __commonJS({
  "node_modules/core-js/internals/is-pure.js"(exports, module2) {
    "use strict";
    module2.exports = false;
  }
});

// node_modules/core-js/internals/define-global-property.js
var require_define_global_property = __commonJS({
  "node_modules/core-js/internals/define-global-property.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var defineProperty = Object.defineProperty;
    module2.exports = function(key, value) {
      try {
        defineProperty(globalThis2, key, { value, configurable: true, writable: true });
      } catch (error2) {
        globalThis2[key] = value;
      }
      return value;
    };
  }
});

// node_modules/core-js/internals/shared-store.js
var require_shared_store = __commonJS({
  "node_modules/core-js/internals/shared-store.js"(exports, module2) {
    "use strict";
    var IS_PURE = require_is_pure();
    var globalThis2 = require_global_this();
    var defineGlobalProperty = require_define_global_property();
    var SHARED = "__core-js_shared__";
    var store = module2.exports = globalThis2[SHARED] || defineGlobalProperty(SHARED, {});
    (store.versions || (store.versions = [])).push({
      version: "3.39.0",
      mode: IS_PURE ? "pure" : "global",
      copyright: "\xA9 2014-2024 Denis Pushkarev (zloirock.ru)",
      license: "https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE",
      source: "https://github.com/zloirock/core-js"
    });
  }
});

// node_modules/core-js/internals/shared.js
var require_shared = __commonJS({
  "node_modules/core-js/internals/shared.js"(exports, module2) {
    "use strict";
    var store = require_shared_store();
    module2.exports = function(key, value) {
      return store[key] || (store[key] = value || {});
    };
  }
});

// node_modules/core-js/internals/to-object.js
var require_to_object = __commonJS({
  "node_modules/core-js/internals/to-object.js"(exports, module2) {
    "use strict";
    var requireObjectCoercible = require_require_object_coercible();
    var $Object = Object;
    module2.exports = function(argument) {
      return $Object(requireObjectCoercible(argument));
    };
  }
});

// node_modules/core-js/internals/has-own-property.js
var require_has_own_property = __commonJS({
  "node_modules/core-js/internals/has-own-property.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var toObject = require_to_object();
    var hasOwnProperty5 = uncurryThis({}.hasOwnProperty);
    module2.exports = Object.hasOwn || function hasOwn(it, key) {
      return hasOwnProperty5(toObject(it), key);
    };
  }
});

// node_modules/core-js/internals/uid.js
var require_uid = __commonJS({
  "node_modules/core-js/internals/uid.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var id = 0;
    var postfix = Math.random();
    var toString = uncurryThis(1 .toString);
    module2.exports = function(key) {
      return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36);
    };
  }
});

// node_modules/core-js/internals/well-known-symbol.js
var require_well_known_symbol = __commonJS({
  "node_modules/core-js/internals/well-known-symbol.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var shared = require_shared();
    var hasOwn = require_has_own_property();
    var uid = require_uid();
    var NATIVE_SYMBOL = require_symbol_constructor_detection();
    var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
    var Symbol2 = globalThis2.Symbol;
    var WellKnownSymbolsStore = shared("wks");
    var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid;
    module2.exports = function(name) {
      if (!hasOwn(WellKnownSymbolsStore, name)) {
        WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name);
      }
      return WellKnownSymbolsStore[name];
    };
  }
});

// node_modules/core-js/internals/to-primitive.js
var require_to_primitive = __commonJS({
  "node_modules/core-js/internals/to-primitive.js"(exports, module2) {
    "use strict";
    var call = require_function_call();
    var isObject = require_is_object();
    var isSymbol = require_is_symbol();
    var getMethod2 = require_get_method();
    var ordinaryToPrimitive = require_ordinary_to_primitive();
    var wellKnownSymbol = require_well_known_symbol();
    var $TypeError = TypeError;
    var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
    module2.exports = function(input, pref) {
      if (!isObject(input) || isSymbol(input))
        return input;
      var exoticToPrim = getMethod2(input, TO_PRIMITIVE);
      var result;
      if (exoticToPrim) {
        if (pref === void 0)
          pref = "default";
        result = call(exoticToPrim, input, pref);
        if (!isObject(result) || isSymbol(result))
          return result;
        throw new $TypeError("Can't convert object to primitive value");
      }
      if (pref === void 0)
        pref = "number";
      return ordinaryToPrimitive(input, pref);
    };
  }
});

// node_modules/core-js/internals/to-property-key.js
var require_to_property_key = __commonJS({
  "node_modules/core-js/internals/to-property-key.js"(exports, module2) {
    "use strict";
    var toPrimitive = require_to_primitive();
    var isSymbol = require_is_symbol();
    module2.exports = function(argument) {
      var key = toPrimitive(argument, "string");
      return isSymbol(key) ? key : key + "";
    };
  }
});

// node_modules/core-js/internals/document-create-element.js
var require_document_create_element = __commonJS({
  "node_modules/core-js/internals/document-create-element.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var isObject = require_is_object();
    var document2 = globalThis2.document;
    var EXISTS = isObject(document2) && isObject(document2.createElement);
    module2.exports = function(it) {
      return EXISTS ? document2.createElement(it) : {};
    };
  }
});

// node_modules/core-js/internals/ie8-dom-define.js
var require_ie8_dom_define = __commonJS({
  "node_modules/core-js/internals/ie8-dom-define.js"(exports, module2) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var fails = require_fails();
    var createElement60 = require_document_create_element();
    module2.exports = !DESCRIPTORS && !fails(function() {
      return Object.defineProperty(createElement60("div"), "a", {
        get: function() {
          return 7;
        }
      }).a !== 7;
    });
  }
});

// node_modules/core-js/internals/object-get-own-property-descriptor.js
var require_object_get_own_property_descriptor = __commonJS({
  "node_modules/core-js/internals/object-get-own-property-descriptor.js"(exports) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var call = require_function_call();
    var propertyIsEnumerableModule = require_object_property_is_enumerable();
    var createPropertyDescriptor = require_create_property_descriptor();
    var toIndexedObject = require_to_indexed_object();
    var toPropertyKey = require_to_property_key();
    var hasOwn = require_has_own_property();
    var IE8_DOM_DEFINE = require_ie8_dom_define();
    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O2, P2) {
      O2 = toIndexedObject(O2);
      P2 = toPropertyKey(P2);
      if (IE8_DOM_DEFINE)
        try {
          return $getOwnPropertyDescriptor(O2, P2);
        } catch (error2) {
        }
      if (hasOwn(O2, P2))
        return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O2, P2), O2[P2]);
    };
  }
});

// node_modules/core-js/internals/v8-prototype-define-bug.js
var require_v8_prototype_define_bug = __commonJS({
  "node_modules/core-js/internals/v8-prototype-define-bug.js"(exports, module2) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var fails = require_fails();
    module2.exports = DESCRIPTORS && fails(function() {
      return Object.defineProperty(function() {
      }, "prototype", {
        value: 42,
        writable: false
      }).prototype !== 42;
    });
  }
});

// node_modules/core-js/internals/an-object.js
var require_an_object = __commonJS({
  "node_modules/core-js/internals/an-object.js"(exports, module2) {
    "use strict";
    var isObject = require_is_object();
    var $String = String;
    var $TypeError = TypeError;
    module2.exports = function(argument) {
      if (isObject(argument))
        return argument;
      throw new $TypeError($String(argument) + " is not an object");
    };
  }
});

// node_modules/core-js/internals/object-define-property.js
var require_object_define_property = __commonJS({
  "node_modules/core-js/internals/object-define-property.js"(exports) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var IE8_DOM_DEFINE = require_ie8_dom_define();
    var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
    var anObject = require_an_object();
    var toPropertyKey = require_to_property_key();
    var $TypeError = TypeError;
    var $defineProperty = Object.defineProperty;
    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    var ENUMERABLE = "enumerable";
    var CONFIGURABLE = "configurable";
    var WRITABLE = "writable";
    exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O2, P2, Attributes) {
      anObject(O2);
      P2 = toPropertyKey(P2);
      anObject(Attributes);
      if (typeof O2 === "function" && P2 === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
        var current = $getOwnPropertyDescriptor(O2, P2);
        if (current && current[WRITABLE]) {
          O2[P2] = Attributes.value;
          Attributes = {
            configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
            enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
            writable: false
          };
        }
      }
      return $defineProperty(O2, P2, Attributes);
    } : $defineProperty : function defineProperty(O2, P2, Attributes) {
      anObject(O2);
      P2 = toPropertyKey(P2);
      anObject(Attributes);
      if (IE8_DOM_DEFINE)
        try {
          return $defineProperty(O2, P2, Attributes);
        } catch (error2) {
        }
      if ("get" in Attributes || "set" in Attributes)
        throw new $TypeError("Accessors not supported");
      if ("value" in Attributes)
        O2[P2] = Attributes.value;
      return O2;
    };
  }
});

// node_modules/core-js/internals/create-non-enumerable-property.js
var require_create_non_enumerable_property = __commonJS({
  "node_modules/core-js/internals/create-non-enumerable-property.js"(exports, module2) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var definePropertyModule = require_object_define_property();
    var createPropertyDescriptor = require_create_property_descriptor();
    module2.exports = DESCRIPTORS ? function(object2, key, value) {
      return definePropertyModule.f(object2, key, createPropertyDescriptor(1, value));
    } : function(object2, key, value) {
      object2[key] = value;
      return object2;
    };
  }
});

// node_modules/core-js/internals/function-name.js
var require_function_name = __commonJS({
  "node_modules/core-js/internals/function-name.js"(exports, module2) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var hasOwn = require_has_own_property();
    var FunctionPrototype = Function.prototype;
    var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
    var EXISTS = hasOwn(FunctionPrototype, "name");
    var PROPER = EXISTS && function something() {
    }.name === "something";
    var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable);
    module2.exports = {
      EXISTS,
      PROPER,
      CONFIGURABLE
    };
  }
});

// node_modules/core-js/internals/inspect-source.js
var require_inspect_source = __commonJS({
  "node_modules/core-js/internals/inspect-source.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var isCallable = require_is_callable();
    var store = require_shared_store();
    var functionToString = uncurryThis(Function.toString);
    if (!isCallable(store.inspectSource)) {
      store.inspectSource = function(it) {
        return functionToString(it);
      };
    }
    module2.exports = store.inspectSource;
  }
});

// node_modules/core-js/internals/weak-map-basic-detection.js
var require_weak_map_basic_detection = __commonJS({
  "node_modules/core-js/internals/weak-map-basic-detection.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var isCallable = require_is_callable();
    var WeakMap2 = globalThis2.WeakMap;
    module2.exports = isCallable(WeakMap2) && /native code/.test(String(WeakMap2));
  }
});

// node_modules/core-js/internals/shared-key.js
var require_shared_key = __commonJS({
  "node_modules/core-js/internals/shared-key.js"(exports, module2) {
    "use strict";
    var shared = require_shared();
    var uid = require_uid();
    var keys = shared("keys");
    module2.exports = function(key) {
      return keys[key] || (keys[key] = uid(key));
    };
  }
});

// node_modules/core-js/internals/hidden-keys.js
var require_hidden_keys = __commonJS({
  "node_modules/core-js/internals/hidden-keys.js"(exports, module2) {
    "use strict";
    module2.exports = {};
  }
});

// node_modules/core-js/internals/internal-state.js
var require_internal_state = __commonJS({
  "node_modules/core-js/internals/internal-state.js"(exports, module2) {
    "use strict";
    var NATIVE_WEAK_MAP = require_weak_map_basic_detection();
    var globalThis2 = require_global_this();
    var isObject = require_is_object();
    var createNonEnumerableProperty = require_create_non_enumerable_property();
    var hasOwn = require_has_own_property();
    var shared = require_shared_store();
    var sharedKey = require_shared_key();
    var hiddenKeys = require_hidden_keys();
    var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
    var TypeError2 = globalThis2.TypeError;
    var WeakMap2 = globalThis2.WeakMap;
    var set;
    var get;
    var has;
    var enforce = function(it) {
      return has(it) ? get(it) : set(it, {});
    };
    var getterFor = function(TYPE) {
      return function(it) {
        var state;
        if (!isObject(it) || (state = get(it)).type !== TYPE) {
          throw new TypeError2("Incompatible receiver, " + TYPE + " required");
        }
        return state;
      };
    };
    if (NATIVE_WEAK_MAP || shared.state) {
      store = shared.state || (shared.state = new WeakMap2());
      store.get = store.get;
      store.has = store.has;
      store.set = store.set;
      set = function(it, metadata) {
        if (store.has(it))
          throw new TypeError2(OBJECT_ALREADY_INITIALIZED);
        metadata.facade = it;
        store.set(it, metadata);
        return metadata;
      };
      get = function(it) {
        return store.get(it) || {};
      };
      has = function(it) {
        return store.has(it);
      };
    } else {
      STATE = sharedKey("state");
      hiddenKeys[STATE] = true;
      set = function(it, metadata) {
        if (hasOwn(it, STATE))
          throw new TypeError2(OBJECT_ALREADY_INITIALIZED);
        metadata.facade = it;
        createNonEnumerableProperty(it, STATE, metadata);
        return metadata;
      };
      get = function(it) {
        return hasOwn(it, STATE) ? it[STATE] : {};
      };
      has = function(it) {
        return hasOwn(it, STATE);
      };
    }
    var store;
    var STATE;
    module2.exports = {
      set,
      get,
      has,
      enforce,
      getterFor
    };
  }
});

// node_modules/core-js/internals/make-built-in.js
var require_make_built_in = __commonJS({
  "node_modules/core-js/internals/make-built-in.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var fails = require_fails();
    var isCallable = require_is_callable();
    var hasOwn = require_has_own_property();
    var DESCRIPTORS = require_descriptors();
    var CONFIGURABLE_FUNCTION_NAME = require_function_name().CONFIGURABLE;
    var inspectSource = require_inspect_source();
    var InternalStateModule = require_internal_state();
    var enforceInternalState = InternalStateModule.enforce;
    var getInternalState = InternalStateModule.get;
    var $String = String;
    var defineProperty = Object.defineProperty;
    var stringSlice = uncurryThis("".slice);
    var replace = uncurryThis("".replace);
    var join = uncurryThis([].join);
    var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
      return defineProperty(function() {
      }, "length", { value: 8 }).length !== 8;
    });
    var TEMPLATE = String(String).split("String");
    var makeBuiltIn = module2.exports = function(value, name, options) {
      if (stringSlice($String(name), 0, 7) === "Symbol(") {
        name = "[" + replace($String(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
      }
      if (options && options.getter)
        name = "get " + name;
      if (options && options.setter)
        name = "set " + name;
      if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
        if (DESCRIPTORS)
          defineProperty(value, "name", { value: name, configurable: true });
        else
          value.name = name;
      }
      if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) {
        defineProperty(value, "length", { value: options.arity });
      }
      try {
        if (options && hasOwn(options, "constructor") && options.constructor) {
          if (DESCRIPTORS)
            defineProperty(value, "prototype", { writable: false });
        } else if (value.prototype)
          value.prototype = void 0;
      } catch (error2) {
      }
      var state = enforceInternalState(value);
      if (!hasOwn(state, "source")) {
        state.source = join(TEMPLATE, typeof name == "string" ? name : "");
      }
      return value;
    };
    Function.prototype.toString = makeBuiltIn(function toString() {
      return isCallable(this) && getInternalState(this).source || inspectSource(this);
    }, "toString");
  }
});

// node_modules/core-js/internals/define-built-in.js
var require_define_built_in = __commonJS({
  "node_modules/core-js/internals/define-built-in.js"(exports, module2) {
    "use strict";
    var isCallable = require_is_callable();
    var definePropertyModule = require_object_define_property();
    var makeBuiltIn = require_make_built_in();
    var defineGlobalProperty = require_define_global_property();
    module2.exports = function(O2, key, value, options) {
      if (!options)
        options = {};
      var simple = options.enumerable;
      var name = options.name !== void 0 ? options.name : key;
      if (isCallable(value))
        makeBuiltIn(value, name, options);
      if (options.global) {
        if (simple)
          O2[key] = value;
        else
          defineGlobalProperty(key, value);
      } else {
        try {
          if (!options.unsafe)
            delete O2[key];
          else if (O2[key])
            simple = true;
        } catch (error2) {
        }
        if (simple)
          O2[key] = value;
        else
          definePropertyModule.f(O2, key, {
            value,
            enumerable: false,
            configurable: !options.nonConfigurable,
            writable: !options.nonWritable
          });
      }
      return O2;
    };
  }
});

// node_modules/core-js/internals/math-trunc.js
var require_math_trunc = __commonJS({
  "node_modules/core-js/internals/math-trunc.js"(exports, module2) {
    "use strict";
    var ceil = Math.ceil;
    var floor2 = Math.floor;
    module2.exports = Math.trunc || function trunc(x2) {
      var n2 = +x2;
      return (n2 > 0 ? floor2 : ceil)(n2);
    };
  }
});

// node_modules/core-js/internals/to-integer-or-infinity.js
var require_to_integer_or_infinity = __commonJS({
  "node_modules/core-js/internals/to-integer-or-infinity.js"(exports, module2) {
    "use strict";
    var trunc = require_math_trunc();
    module2.exports = function(argument) {
      var number2 = +argument;
      return number2 !== number2 || number2 === 0 ? 0 : trunc(number2);
    };
  }
});

// node_modules/core-js/internals/to-absolute-index.js
var require_to_absolute_index = __commonJS({
  "node_modules/core-js/internals/to-absolute-index.js"(exports, module2) {
    "use strict";
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var max3 = Math.max;
    var min4 = Math.min;
    module2.exports = function(index3, length) {
      var integer2 = toIntegerOrInfinity(index3);
      return integer2 < 0 ? max3(integer2 + length, 0) : min4(integer2, length);
    };
  }
});

// node_modules/core-js/internals/to-length.js
var require_to_length = __commonJS({
  "node_modules/core-js/internals/to-length.js"(exports, module2) {
    "use strict";
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var min4 = Math.min;
    module2.exports = function(argument) {
      var len = toIntegerOrInfinity(argument);
      return len > 0 ? min4(len, 9007199254740991) : 0;
    };
  }
});

// node_modules/core-js/internals/length-of-array-like.js
var require_length_of_array_like = __commonJS({
  "node_modules/core-js/internals/length-of-array-like.js"(exports, module2) {
    "use strict";
    var toLength = require_to_length();
    module2.exports = function(obj) {
      return toLength(obj.length);
    };
  }
});

// node_modules/core-js/internals/array-includes.js
var require_array_includes = __commonJS({
  "node_modules/core-js/internals/array-includes.js"(exports, module2) {
    "use strict";
    var toIndexedObject = require_to_indexed_object();
    var toAbsoluteIndex = require_to_absolute_index();
    var lengthOfArrayLike = require_length_of_array_like();
    var createMethod = function(IS_INCLUDES) {
      return function($this, el, fromIndex) {
        var O2 = toIndexedObject($this);
        var length = lengthOfArrayLike(O2);
        if (length === 0)
          return !IS_INCLUDES && -1;
        var index3 = toAbsoluteIndex(fromIndex, length);
        var value;
        if (IS_INCLUDES && el !== el)
          while (length > index3) {
            value = O2[index3++];
            if (value !== value)
              return true;
          }
        else
          for (; length > index3; index3++) {
            if ((IS_INCLUDES || index3 in O2) && O2[index3] === el)
              return IS_INCLUDES || index3 || 0;
          }
        return !IS_INCLUDES && -1;
      };
    };
    module2.exports = {
      includes: createMethod(true),
      indexOf: createMethod(false)
    };
  }
});

// node_modules/core-js/internals/object-keys-internal.js
var require_object_keys_internal = __commonJS({
  "node_modules/core-js/internals/object-keys-internal.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var hasOwn = require_has_own_property();
    var toIndexedObject = require_to_indexed_object();
    var indexOf = require_array_includes().indexOf;
    var hiddenKeys = require_hidden_keys();
    var push = uncurryThis([].push);
    module2.exports = function(object2, names) {
      var O2 = toIndexedObject(object2);
      var i2 = 0;
      var result = [];
      var key;
      for (key in O2)
        !hasOwn(hiddenKeys, key) && hasOwn(O2, key) && push(result, key);
      while (names.length > i2)
        if (hasOwn(O2, key = names[i2++])) {
          ~indexOf(result, key) || push(result, key);
        }
      return result;
    };
  }
});

// node_modules/core-js/internals/enum-bug-keys.js
var require_enum_bug_keys = __commonJS({
  "node_modules/core-js/internals/enum-bug-keys.js"(exports, module2) {
    "use strict";
    module2.exports = [
      "constructor",
      "hasOwnProperty",
      "isPrototypeOf",
      "propertyIsEnumerable",
      "toLocaleString",
      "toString",
      "valueOf"
    ];
  }
});

// node_modules/core-js/internals/object-get-own-property-names.js
var require_object_get_own_property_names = __commonJS({
  "node_modules/core-js/internals/object-get-own-property-names.js"(exports) {
    "use strict";
    var internalObjectKeys = require_object_keys_internal();
    var enumBugKeys = require_enum_bug_keys();
    var hiddenKeys = enumBugKeys.concat("length", "prototype");
    exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O2) {
      return internalObjectKeys(O2, hiddenKeys);
    };
  }
});

// node_modules/core-js/internals/object-get-own-property-symbols.js
var require_object_get_own_property_symbols = __commonJS({
  "node_modules/core-js/internals/object-get-own-property-symbols.js"(exports) {
    "use strict";
    exports.f = Object.getOwnPropertySymbols;
  }
});

// node_modules/core-js/internals/own-keys.js
var require_own_keys = __commonJS({
  "node_modules/core-js/internals/own-keys.js"(exports, module2) {
    "use strict";
    var getBuiltIn = require_get_built_in();
    var uncurryThis = require_function_uncurry_this();
    var getOwnPropertyNamesModule = require_object_get_own_property_names();
    var getOwnPropertySymbolsModule = require_object_get_own_property_symbols();
    var anObject = require_an_object();
    var concat = uncurryThis([].concat);
    module2.exports = getBuiltIn("Reflect", "ownKeys") || function ownKeys2(it) {
      var keys = getOwnPropertyNamesModule.f(anObject(it));
      var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
      return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
    };
  }
});

// node_modules/core-js/internals/copy-constructor-properties.js
var require_copy_constructor_properties = __commonJS({
  "node_modules/core-js/internals/copy-constructor-properties.js"(exports, module2) {
    "use strict";
    var hasOwn = require_has_own_property();
    var ownKeys2 = require_own_keys();
    var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor();
    var definePropertyModule = require_object_define_property();
    module2.exports = function(target, source, exceptions) {
      var keys = ownKeys2(source);
      var defineProperty = definePropertyModule.f;
      var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
      for (var i2 = 0; i2 < keys.length; i2++) {
        var key = keys[i2];
        if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
          defineProperty(target, key, getOwnPropertyDescriptor(source, key));
        }
      }
    };
  }
});

// node_modules/core-js/internals/is-forced.js
var require_is_forced = __commonJS({
  "node_modules/core-js/internals/is-forced.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    var isCallable = require_is_callable();
    var replacement = /#|\.prototype\./;
    var isForced = function(feature, detection) {
      var value = data[normalize(feature)];
      return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
    };
    var normalize = isForced.normalize = function(string2) {
      return String(string2).replace(replacement, ".").toLowerCase();
    };
    var data = isForced.data = {};
    var NATIVE = isForced.NATIVE = "N";
    var POLYFILL = isForced.POLYFILL = "P";
    module2.exports = isForced;
  }
});

// node_modules/core-js/internals/export.js
var require_export = __commonJS({
  "node_modules/core-js/internals/export.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
    var createNonEnumerableProperty = require_create_non_enumerable_property();
    var defineBuiltIn = require_define_built_in();
    var defineGlobalProperty = require_define_global_property();
    var copyConstructorProperties = require_copy_constructor_properties();
    var isForced = require_is_forced();
    module2.exports = function(options, source) {
      var TARGET = options.target;
      var GLOBAL = options.global;
      var STATIC = options.stat;
      var FORCED, target, key, targetProperty, sourceProperty, descriptor;
      if (GLOBAL) {
        target = globalThis2;
      } else if (STATIC) {
        target = globalThis2[TARGET] || defineGlobalProperty(TARGET, {});
      } else {
        target = globalThis2[TARGET] && globalThis2[TARGET].prototype;
      }
      if (target)
        for (key in source) {
          sourceProperty = source[key];
          if (options.dontCallGetSet) {
            descriptor = getOwnPropertyDescriptor(target, key);
            targetProperty = descriptor && descriptor.value;
          } else
            targetProperty = target[key];
          FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
          if (!FORCED && targetProperty !== void 0) {
            if (typeof sourceProperty == typeof targetProperty)
              continue;
            copyConstructorProperties(sourceProperty, targetProperty);
          }
          if (options.sham || targetProperty && targetProperty.sham) {
            createNonEnumerableProperty(sourceProperty, "sham", true);
          }
          defineBuiltIn(target, key, sourceProperty, options);
        }
    };
  }
});

// node_modules/core-js/internals/object-keys.js
var require_object_keys = __commonJS({
  "node_modules/core-js/internals/object-keys.js"(exports, module2) {
    "use strict";
    var internalObjectKeys = require_object_keys_internal();
    var enumBugKeys = require_enum_bug_keys();
    module2.exports = Object.keys || function keys(O2) {
      return internalObjectKeys(O2, enumBugKeys);
    };
  }
});

// node_modules/core-js/internals/object-define-properties.js
var require_object_define_properties = __commonJS({
  "node_modules/core-js/internals/object-define-properties.js"(exports) {
    "use strict";
    var DESCRIPTORS = require_descriptors();
    var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
    var definePropertyModule = require_object_define_property();
    var anObject = require_an_object();
    var toIndexedObject = require_to_indexed_object();
    var objectKeys = require_object_keys();
    exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O2, Properties) {
      anObject(O2);
      var props = toIndexedObject(Properties);
      var keys = objectKeys(Properties);
      var length = keys.length;
      var index3 = 0;
      var key;
      while (length > index3)
        definePropertyModule.f(O2, key = keys[index3++], props[key]);
      return O2;
    };
  }
});

// node_modules/core-js/internals/html.js
var require_html = __commonJS({
  "node_modules/core-js/internals/html.js"(exports, module2) {
    "use strict";
    var getBuiltIn = require_get_built_in();
    module2.exports = getBuiltIn("document", "documentElement");
  }
});

// node_modules/core-js/internals/object-create.js
var require_object_create = __commonJS({
  "node_modules/core-js/internals/object-create.js"(exports, module2) {
    "use strict";
    var anObject = require_an_object();
    var definePropertiesModule = require_object_define_properties();
    var enumBugKeys = require_enum_bug_keys();
    var hiddenKeys = require_hidden_keys();
    var html = require_html();
    var documentCreateElement = require_document_create_element();
    var sharedKey = require_shared_key();
    var GT = ">";
    var LT = "<";
    var PROTOTYPE = "prototype";
    var SCRIPT = "script";
    var IE_PROTO = sharedKey("IE_PROTO");
    var EmptyConstructor = function() {
    };
    var scriptTag = function(content) {
      return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
    };
    var NullProtoObjectViaActiveX = function(activeXDocument2) {
      activeXDocument2.write(scriptTag(""));
      activeXDocument2.close();
      var temp = activeXDocument2.parentWindow.Object;
      activeXDocument2 = null;
      return temp;
    };
    var NullProtoObjectViaIFrame = function() {
      var iframe = documentCreateElement("iframe");
      var JS = "java" + SCRIPT + ":";
      var iframeDocument;
      iframe.style.display = "none";
      html.appendChild(iframe);
      iframe.src = String(JS);
      iframeDocument = iframe.contentWindow.document;
      iframeDocument.open();
      iframeDocument.write(scriptTag("document.F=Object"));
      iframeDocument.close();
      return iframeDocument.F;
    };
    var activeXDocument;
    var NullProtoObject = function() {
      try {
        activeXDocument = new ActiveXObject("htmlfile");
      } catch (error2) {
      }
      NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
      var length = enumBugKeys.length;
      while (length--)
        delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
      return NullProtoObject();
    };
    hiddenKeys[IE_PROTO] = true;
    module2.exports = Object.create || function create(O2, Properties) {
      var result;
      if (O2 !== null) {
        EmptyConstructor[PROTOTYPE] = anObject(O2);
        result = new EmptyConstructor();
        EmptyConstructor[PROTOTYPE] = null;
        result[IE_PROTO] = O2;
      } else
        result = NullProtoObject();
      return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
    };
  }
});

// node_modules/core-js/internals/add-to-unscopables.js
var require_add_to_unscopables = __commonJS({
  "node_modules/core-js/internals/add-to-unscopables.js"(exports, module2) {
    "use strict";
    var wellKnownSymbol = require_well_known_symbol();
    var create = require_object_create();
    var defineProperty = require_object_define_property().f;
    var UNSCOPABLES = wellKnownSymbol("unscopables");
    var ArrayPrototype = Array.prototype;
    if (ArrayPrototype[UNSCOPABLES] === void 0) {
      defineProperty(ArrayPrototype, UNSCOPABLES, {
        configurable: true,
        value: create(null)
      });
    }
    module2.exports = function(key) {
      ArrayPrototype[UNSCOPABLES][key] = true;
    };
  }
});

// node_modules/core-js/modules/es.array.at.js
var require_es_array_at = __commonJS({
  "node_modules/core-js/modules/es.array.at.js"() {
    "use strict";
    var $ = require_export();
    var toObject = require_to_object();
    var lengthOfArrayLike = require_length_of_array_like();
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var addToUnscopables = require_add_to_unscopables();
    $({ target: "Array", proto: true }, {
      at: function at(index3) {
        var O2 = toObject(this);
        var len = lengthOfArrayLike(O2);
        var relativeIndex = toIntegerOrInfinity(index3);
        var k2 = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
        return k2 < 0 || k2 >= len ? void 0 : O2[k2];
      }
    });
    addToUnscopables("at");
  }
});

// node_modules/core-js/internals/entry-unbind.js
var require_entry_unbind = __commonJS({
  "node_modules/core-js/internals/entry-unbind.js"(exports, module2) {
    "use strict";
    var globalThis2 = require_global_this();
    var uncurryThis = require_function_uncurry_this();
    module2.exports = function(CONSTRUCTOR, METHOD) {
      return uncurryThis(globalThis2[CONSTRUCTOR].prototype[METHOD]);
    };
  }
});

// node_modules/core-js/es/array/at.js
var require_at = __commonJS({
  "node_modules/core-js/es/array/at.js"(exports, module2) {
    "use strict";
    require_es_array_at();
    var entryUnbind = require_entry_unbind();
    module2.exports = entryUnbind("Array", "at");
  }
});

// node_modules/core-js/stable/array/at.js
var require_at2 = __commonJS({
  "node_modules/core-js/stable/array/at.js"(exports, module2) {
    "use strict";
    var parent = require_at();
    module2.exports = parent;
  }
});

// node_modules/core-js/internals/is-array.js
var require_is_array = __commonJS({
  "node_modules/core-js/internals/is-array.js"(exports, module2) {
    "use strict";
    var classof = require_classof_raw();
    module2.exports = Array.isArray || function isArray(argument) {
      return classof(argument) === "Array";
    };
  }
});

// node_modules/core-js/internals/does-not-exceed-safe-integer.js
var require_does_not_exceed_safe_integer = __commonJS({
  "node_modules/core-js/internals/does-not-exceed-safe-integer.js"(exports, module2) {
    "use strict";
    var $TypeError = TypeError;
    var MAX_SAFE_INTEGER = 9007199254740991;
    module2.exports = function(it) {
      if (it > MAX_SAFE_INTEGER)
        throw $TypeError("Maximum allowed index exceeded");
      return it;
    };
  }
});

// node_modules/core-js/internals/function-uncurry-this-clause.js
var require_function_uncurry_this_clause = __commonJS({
  "node_modules/core-js/internals/function-uncurry-this-clause.js"(exports, module2) {
    "use strict";
    var classofRaw = require_classof_raw();
    var uncurryThis = require_function_uncurry_this();
    module2.exports = function(fn3) {
      if (classofRaw(fn3) === "Function")
        return uncurryThis(fn3);
    };
  }
});

// node_modules/core-js/internals/function-bind-context.js
var require_function_bind_context = __commonJS({
  "node_modules/core-js/internals/function-bind-context.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this_clause();
    var aCallable = require_a_callable();
    var NATIVE_BIND = require_function_bind_native();
    var bind = uncurryThis(uncurryThis.bind);
    module2.exports = function(fn3, that) {
      aCallable(fn3);
      return that === void 0 ? fn3 : NATIVE_BIND ? bind(fn3, that) : function() {
        return fn3.apply(that, arguments);
      };
    };
  }
});

// node_modules/core-js/internals/flatten-into-array.js
var require_flatten_into_array = __commonJS({
  "node_modules/core-js/internals/flatten-into-array.js"(exports, module2) {
    "use strict";
    var isArray = require_is_array();
    var lengthOfArrayLike = require_length_of_array_like();
    var doesNotExceedSafeInteger = require_does_not_exceed_safe_integer();
    var bind = require_function_bind_context();
    var flattenIntoArray = function(target, original, source, sourceLen, start2, depth, mapper, thisArg) {
      var targetIndex = start2;
      var sourceIndex = 0;
      var mapFn = mapper ? bind(mapper, thisArg) : false;
      var element, elementLen;
      while (sourceIndex < sourceLen) {
        if (sourceIndex in source) {
          element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
          if (depth > 0 && isArray(element)) {
            elementLen = lengthOfArrayLike(element);
            targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;
          } else {
            doesNotExceedSafeInteger(targetIndex + 1);
            target[targetIndex] = element;
          }
          targetIndex++;
        }
        sourceIndex++;
      }
      return targetIndex;
    };
    module2.exports = flattenIntoArray;
  }
});

// node_modules/core-js/internals/to-string-tag-support.js
var require_to_string_tag_support = __commonJS({
  "node_modules/core-js/internals/to-string-tag-support.js"(exports, module2) {
    "use strict";
    var wellKnownSymbol = require_well_known_symbol();
    var TO_STRING_TAG = wellKnownSymbol("toStringTag");
    var test2 = {};
    test2[TO_STRING_TAG] = "z";
    module2.exports = String(test2) === "[object z]";
  }
});

// node_modules/core-js/internals/classof.js
var require_classof = __commonJS({
  "node_modules/core-js/internals/classof.js"(exports, module2) {
    "use strict";
    var TO_STRING_TAG_SUPPORT = require_to_string_tag_support();
    var isCallable = require_is_callable();
    var classofRaw = require_classof_raw();
    var wellKnownSymbol = require_well_known_symbol();
    var TO_STRING_TAG = wellKnownSymbol("toStringTag");
    var $Object = Object;
    var CORRECT_ARGUMENTS = classofRaw(function() {
      return arguments;
    }()) === "Arguments";
    var tryGet = function(it, key) {
      try {
        return it[key];
      } catch (error2) {
      }
    };
    module2.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) {
      var O2, tag, result;
      return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O2 = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O2) : (result = classofRaw(O2)) === "Object" && isCallable(O2.callee) ? "Arguments" : result;
    };
  }
});

// node_modules/core-js/internals/is-constructor.js
var require_is_constructor = __commonJS({
  "node_modules/core-js/internals/is-constructor.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var fails = require_fails();
    var isCallable = require_is_callable();
    var classof = require_classof();
    var getBuiltIn = require_get_built_in();
    var inspectSource = require_inspect_source();
    var noop5 = function() {
    };
    var construct = getBuiltIn("Reflect", "construct");
    var constructorRegExp = /^\s*(?:class|function)\b/;
    var exec = uncurryThis(constructorRegExp.exec);
    var INCORRECT_TO_STRING = !constructorRegExp.test(noop5);
    var isConstructorModern = function isConstructor(argument) {
      if (!isCallable(argument))
        return false;
      try {
        construct(noop5, [], argument);
        return true;
      } catch (error2) {
        return false;
      }
    };
    var isConstructorLegacy = function isConstructor(argument) {
      if (!isCallable(argument))
        return false;
      switch (classof(argument)) {
        case "AsyncFunction":
        case "GeneratorFunction":
        case "AsyncGeneratorFunction":
          return false;
      }
      try {
        return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
      } catch (error2) {
        return true;
      }
    };
    isConstructorLegacy.sham = true;
    module2.exports = !construct || fails(function() {
      var called;
      return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
        called = true;
      }) || called;
    }) ? isConstructorLegacy : isConstructorModern;
  }
});

// node_modules/core-js/internals/array-species-constructor.js
var require_array_species_constructor = __commonJS({
  "node_modules/core-js/internals/array-species-constructor.js"(exports, module2) {
    "use strict";
    var isArray = require_is_array();
    var isConstructor = require_is_constructor();
    var isObject = require_is_object();
    var wellKnownSymbol = require_well_known_symbol();
    var SPECIES = wellKnownSymbol("species");
    var $Array = Array;
    module2.exports = function(originalArray) {
      var C2;
      if (isArray(originalArray)) {
        C2 = originalArray.constructor;
        if (isConstructor(C2) && (C2 === $Array || isArray(C2.prototype)))
          C2 = void 0;
        else if (isObject(C2)) {
          C2 = C2[SPECIES];
          if (C2 === null)
            C2 = void 0;
        }
      }
      return C2 === void 0 ? $Array : C2;
    };
  }
});

// node_modules/core-js/internals/array-species-create.js
var require_array_species_create = __commonJS({
  "node_modules/core-js/internals/array-species-create.js"(exports, module2) {
    "use strict";
    var arraySpeciesConstructor = require_array_species_constructor();
    module2.exports = function(originalArray, length) {
      return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
    };
  }
});

// node_modules/core-js/modules/es.array.flat-map.js
var require_es_array_flat_map = __commonJS({
  "node_modules/core-js/modules/es.array.flat-map.js"() {
    "use strict";
    var $ = require_export();
    var flattenIntoArray = require_flatten_into_array();
    var aCallable = require_a_callable();
    var toObject = require_to_object();
    var lengthOfArrayLike = require_length_of_array_like();
    var arraySpeciesCreate = require_array_species_create();
    $({ target: "Array", proto: true }, {
      flatMap: function flatMap(callbackfn) {
        var O2 = toObject(this);
        var sourceLen = lengthOfArrayLike(O2);
        var A2;
        aCallable(callbackfn);
        A2 = arraySpeciesCreate(O2, 0);
        A2.length = flattenIntoArray(A2, O2, O2, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : void 0);
        return A2;
      }
    });
  }
});

// node_modules/core-js/modules/es.array.unscopables.flat-map.js
var require_es_array_unscopables_flat_map = __commonJS({
  "node_modules/core-js/modules/es.array.unscopables.flat-map.js"() {
    "use strict";
    var addToUnscopables = require_add_to_unscopables();
    addToUnscopables("flatMap");
  }
});

// node_modules/core-js/es/array/flat-map.js
var require_flat_map = __commonJS({
  "node_modules/core-js/es/array/flat-map.js"(exports, module2) {
    "use strict";
    require_es_array_flat_map();
    require_es_array_unscopables_flat_map();
    var entryUnbind = require_entry_unbind();
    module2.exports = entryUnbind("Array", "flatMap");
  }
});

// node_modules/core-js/stable/array/flat-map.js
var require_flat_map2 = __commonJS({
  "node_modules/core-js/stable/array/flat-map.js"(exports, module2) {
    "use strict";
    var parent = require_flat_map();
    module2.exports = parent;
  }
});

// node_modules/core-js/modules/es.array.flat.js
var require_es_array_flat = __commonJS({
  "node_modules/core-js/modules/es.array.flat.js"() {
    "use strict";
    var $ = require_export();
    var flattenIntoArray = require_flatten_into_array();
    var toObject = require_to_object();
    var lengthOfArrayLike = require_length_of_array_like();
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var arraySpeciesCreate = require_array_species_create();
    $({ target: "Array", proto: true }, {
      flat: function flat() {
        var depthArg = arguments.length ? arguments[0] : void 0;
        var O2 = toObject(this);
        var sourceLen = lengthOfArrayLike(O2);
        var A2 = arraySpeciesCreate(O2, 0);
        A2.length = flattenIntoArray(A2, O2, O2, sourceLen, 0, depthArg === void 0 ? 1 : toIntegerOrInfinity(depthArg));
        return A2;
      }
    });
  }
});

// node_modules/core-js/modules/es.array.unscopables.flat.js
var require_es_array_unscopables_flat = __commonJS({
  "node_modules/core-js/modules/es.array.unscopables.flat.js"() {
    "use strict";
    var addToUnscopables = require_add_to_unscopables();
    addToUnscopables("flat");
  }
});

// node_modules/core-js/es/array/flat.js
var require_flat = __commonJS({
  "node_modules/core-js/es/array/flat.js"(exports, module2) {
    "use strict";
    require_es_array_flat();
    require_es_array_unscopables_flat();
    var entryUnbind = require_entry_unbind();
    module2.exports = entryUnbind("Array", "flat");
  }
});

// node_modules/core-js/stable/array/flat.js
var require_flat2 = __commonJS({
  "node_modules/core-js/stable/array/flat.js"(exports, module2) {
    "use strict";
    var parent = require_flat();
    module2.exports = parent;
  }
});

// node_modules/core-js/internals/to-string.js
var require_to_string = __commonJS({
  "node_modules/core-js/internals/to-string.js"(exports, module2) {
    "use strict";
    var classof = require_classof();
    var $String = String;
    module2.exports = function(argument) {
      if (classof(argument) === "Symbol")
        throw new TypeError("Cannot convert a Symbol value to a string");
      return $String(argument);
    };
  }
});

// node_modules/core-js/modules/es.string.at-alternative.js
var require_es_string_at_alternative = __commonJS({
  "node_modules/core-js/modules/es.string.at-alternative.js"() {
    "use strict";
    var $ = require_export();
    var uncurryThis = require_function_uncurry_this();
    var requireObjectCoercible = require_require_object_coercible();
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var toString = require_to_string();
    var fails = require_fails();
    var charAt = uncurryThis("".charAt);
    var FORCED = fails(function() {
      return "\u{20BB7}".at(-2) !== "\uD842";
    });
    $({ target: "String", proto: true, forced: FORCED }, {
      at: function at(index3) {
        var S2 = toString(requireObjectCoercible(this));
        var len = S2.length;
        var relativeIndex = toIntegerOrInfinity(index3);
        var k2 = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
        return k2 < 0 || k2 >= len ? void 0 : charAt(S2, k2);
      }
    });
  }
});

// node_modules/core-js/es/string/at.js
var require_at3 = __commonJS({
  "node_modules/core-js/es/string/at.js"(exports, module2) {
    "use strict";
    require_es_string_at_alternative();
    var entryUnbind = require_entry_unbind();
    module2.exports = entryUnbind("String", "at");
  }
});

// node_modules/core-js/stable/string/at.js
var require_at4 = __commonJS({
  "node_modules/core-js/stable/string/at.js"(exports, module2) {
    "use strict";
    var parent = require_at3();
    module2.exports = parent;
  }
});

// node_modules/core-js/internals/regexp-flags.js
var require_regexp_flags = __commonJS({
  "node_modules/core-js/internals/regexp-flags.js"(exports, module2) {
    "use strict";
    var anObject = require_an_object();
    module2.exports = function() {
      var that = anObject(this);
      var result = "";
      if (that.hasIndices)
        result += "d";
      if (that.global)
        result += "g";
      if (that.ignoreCase)
        result += "i";
      if (that.multiline)
        result += "m";
      if (that.dotAll)
        result += "s";
      if (that.unicode)
        result += "u";
      if (that.unicodeSets)
        result += "v";
      if (that.sticky)
        result += "y";
      return result;
    };
  }
});

// node_modules/core-js/internals/regexp-sticky-helpers.js
var require_regexp_sticky_helpers = __commonJS({
  "node_modules/core-js/internals/regexp-sticky-helpers.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    var globalThis2 = require_global_this();
    var $RegExp = globalThis2.RegExp;
    var UNSUPPORTED_Y = fails(function() {
      var re2 = $RegExp("a", "y");
      re2.lastIndex = 2;
      return re2.exec("abcd") !== null;
    });
    var MISSED_STICKY = UNSUPPORTED_Y || fails(function() {
      return !$RegExp("a", "y").sticky;
    });
    var BROKEN_CARET = UNSUPPORTED_Y || fails(function() {
      var re2 = $RegExp("^r", "gy");
      re2.lastIndex = 2;
      return re2.exec("str") !== null;
    });
    module2.exports = {
      BROKEN_CARET,
      MISSED_STICKY,
      UNSUPPORTED_Y
    };
  }
});

// node_modules/core-js/internals/regexp-unsupported-dot-all.js
var require_regexp_unsupported_dot_all = __commonJS({
  "node_modules/core-js/internals/regexp-unsupported-dot-all.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    var globalThis2 = require_global_this();
    var $RegExp = globalThis2.RegExp;
    module2.exports = fails(function() {
      var re2 = $RegExp(".", "s");
      return !(re2.dotAll && re2.test("\n") && re2.flags === "s");
    });
  }
});

// node_modules/core-js/internals/regexp-unsupported-ncg.js
var require_regexp_unsupported_ncg = __commonJS({
  "node_modules/core-js/internals/regexp-unsupported-ncg.js"(exports, module2) {
    "use strict";
    var fails = require_fails();
    var globalThis2 = require_global_this();
    var $RegExp = globalThis2.RegExp;
    module2.exports = fails(function() {
      var re2 = $RegExp("(?<a>b)", "g");
      return re2.exec("b").groups.a !== "b" || "b".replace(re2, "$<a>c") !== "bc";
    });
  }
});

// node_modules/core-js/internals/regexp-exec.js
var require_regexp_exec = __commonJS({
  "node_modules/core-js/internals/regexp-exec.js"(exports, module2) {
    "use strict";
    var call = require_function_call();
    var uncurryThis = require_function_uncurry_this();
    var toString = require_to_string();
    var regexpFlags = require_regexp_flags();
    var stickyHelpers = require_regexp_sticky_helpers();
    var shared = require_shared();
    var create = require_object_create();
    var getInternalState = require_internal_state().get;
    var UNSUPPORTED_DOT_ALL = require_regexp_unsupported_dot_all();
    var UNSUPPORTED_NCG = require_regexp_unsupported_ncg();
    var nativeReplace = shared("native-string-replace", String.prototype.replace);
    var nativeExec = RegExp.prototype.exec;
    var patchedExec = nativeExec;
    var charAt = uncurryThis("".charAt);
    var indexOf = uncurryThis("".indexOf);
    var replace = uncurryThis("".replace);
    var stringSlice = uncurryThis("".slice);
    var UPDATES_LAST_INDEX_WRONG = function() {
      var re1 = /a/;
      var re2 = /b*/g;
      call(nativeExec, re1, "a");
      call(nativeExec, re2, "a");
      return re1.lastIndex !== 0 || re2.lastIndex !== 0;
    }();
    var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
    var NPCG_INCLUDED = /()??/.exec("")[1] !== void 0;
    var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
    if (PATCH) {
      patchedExec = function exec(string2) {
        var re2 = this;
        var state = getInternalState(re2);
        var str = toString(string2);
        var raw = state.raw;
        var result, reCopy, lastIndex, match, i2, object2, group;
        if (raw) {
          raw.lastIndex = re2.lastIndex;
          result = call(patchedExec, raw, str);
          re2.lastIndex = raw.lastIndex;
          return result;
        }
        var groups = state.groups;
        var sticky = UNSUPPORTED_Y && re2.sticky;
        var flags = call(regexpFlags, re2);
        var source = re2.source;
        var charsAdded = 0;
        var strCopy = str;
        if (sticky) {
          flags = replace(flags, "y", "");
          if (indexOf(flags, "g") === -1) {
            flags += "g";
          }
          strCopy = stringSlice(str, re2.lastIndex);
          if (re2.lastIndex > 0 && (!re2.multiline || re2.multiline && charAt(str, re2.lastIndex - 1) !== "\n")) {
            source = "(?: " + source + ")";
            strCopy = " " + strCopy;
            charsAdded++;
          }
          reCopy = new RegExp("^(?:" + source + ")", flags);
        }
        if (NPCG_INCLUDED) {
          reCopy = new RegExp("^" + source + "$(?!\\s)", flags);
        }
        if (UPDATES_LAST_INDEX_WRONG)
          lastIndex = re2.lastIndex;
        match = call(nativeExec, sticky ? reCopy : re2, strCopy);
        if (sticky) {
          if (match) {
            match.input = stringSlice(match.input, charsAdded);
            match[0] = stringSlice(match[0], charsAdded);
            match.index = re2.lastIndex;
            re2.lastIndex += match[0].length;
          } else
            re2.lastIndex = 0;
        } else if (UPDATES_LAST_INDEX_WRONG && match) {
          re2.lastIndex = re2.global ? match.index + match[0].length : lastIndex;
        }
        if (NPCG_INCLUDED && match && match.length > 1) {
          call(nativeReplace, match[0], reCopy, function() {
            for (i2 = 1; i2 < arguments.length - 2; i2++) {
              if (arguments[i2] === void 0)
                match[i2] = void 0;
            }
          });
        }
        if (match && groups) {
          match.groups = object2 = create(null);
          for (i2 = 0; i2 < groups.length; i2++) {
            group = groups[i2];
            object2[group[0]] = match[group[1]];
          }
        }
        return match;
      };
    }
    module2.exports = patchedExec;
  }
});

// node_modules/core-js/modules/es.regexp.exec.js
var require_es_regexp_exec = __commonJS({
  "node_modules/core-js/modules/es.regexp.exec.js"() {
    "use strict";
    var $ = require_export();
    var exec = require_regexp_exec();
    $({ target: "RegExp", proto: true, forced: /./.exec !== exec }, {
      exec
    });
  }
});

// node_modules/core-js/internals/function-apply.js
var require_function_apply = __commonJS({
  "node_modules/core-js/internals/function-apply.js"(exports, module2) {
    "use strict";
    var NATIVE_BIND = require_function_bind_native();
    var FunctionPrototype = Function.prototype;
    var apply = FunctionPrototype.apply;
    var call = FunctionPrototype.call;
    module2.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
      return call.apply(apply, arguments);
    });
  }
});

// node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js
var require_fix_regexp_well_known_symbol_logic = __commonJS({
  "node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js"(exports, module2) {
    "use strict";
    require_es_regexp_exec();
    var call = require_function_call();
    var defineBuiltIn = require_define_built_in();
    var regexpExec = require_regexp_exec();
    var fails = require_fails();
    var wellKnownSymbol = require_well_known_symbol();
    var createNonEnumerableProperty = require_create_non_enumerable_property();
    var SPECIES = wellKnownSymbol("species");
    var RegExpPrototype = RegExp.prototype;
    module2.exports = function(KEY, exec, FORCED, SHAM) {
      var SYMBOL = wellKnownSymbol(KEY);
      var DELEGATES_TO_SYMBOL = !fails(function() {
        var O2 = {};
        O2[SYMBOL] = function() {
          return 7;
        };
        return ""[KEY](O2) !== 7;
      });
      var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function() {
        var execCalled = false;
        var re2 = /a/;
        if (KEY === "split") {
          re2 = {};
          re2.constructor = {};
          re2.constructor[SPECIES] = function() {
            return re2;
          };
          re2.flags = "";
          re2[SYMBOL] = /./[SYMBOL];
        }
        re2.exec = function() {
          execCalled = true;
          return null;
        };
        re2[SYMBOL]("");
        return !execCalled;
      });
      if (!DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || FORCED) {
        var nativeRegExpMethod = /./[SYMBOL];
        var methods = exec(SYMBOL, ""[KEY], function(nativeMethod, regexp, str, arg2, forceStringMethod) {
          var $exec = regexp.exec;
          if ($exec === regexpExec || $exec === RegExpPrototype.exec) {
            if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
              return { done: true, value: call(nativeRegExpMethod, regexp, str, arg2) };
            }
            return { done: true, value: call(nativeMethod, str, regexp, arg2) };
          }
          return { done: false };
        });
        defineBuiltIn(String.prototype, KEY, methods[0]);
        defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);
      }
      if (SHAM)
        createNonEnumerableProperty(RegExpPrototype[SYMBOL], "sham", true);
    };
  }
});

// node_modules/core-js/internals/string-multibyte.js
var require_string_multibyte = __commonJS({
  "node_modules/core-js/internals/string-multibyte.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var toString = require_to_string();
    var requireObjectCoercible = require_require_object_coercible();
    var charAt = uncurryThis("".charAt);
    var charCodeAt = uncurryThis("".charCodeAt);
    var stringSlice = uncurryThis("".slice);
    var createMethod = function(CONVERT_TO_STRING) {
      return function($this, pos) {
        var S2 = toString(requireObjectCoercible($this));
        var position = toIntegerOrInfinity(pos);
        var size4 = S2.length;
        var first, second;
        if (position < 0 || position >= size4)
          return CONVERT_TO_STRING ? "" : void 0;
        first = charCodeAt(S2, position);
        return first < 55296 || first > 56319 || position + 1 === size4 || (second = charCodeAt(S2, position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? charAt(S2, position) : first : CONVERT_TO_STRING ? stringSlice(S2, position, position + 2) : (first - 55296 << 10) + (second - 56320) + 65536;
      };
    };
    module2.exports = {
      codeAt: createMethod(false),
      charAt: createMethod(true)
    };
  }
});

// node_modules/core-js/internals/advance-string-index.js
var require_advance_string_index = __commonJS({
  "node_modules/core-js/internals/advance-string-index.js"(exports, module2) {
    "use strict";
    var charAt = require_string_multibyte().charAt;
    module2.exports = function(S2, index3, unicode) {
      return index3 + (unicode ? charAt(S2, index3).length : 1);
    };
  }
});

// node_modules/core-js/internals/get-substitution.js
var require_get_substitution = __commonJS({
  "node_modules/core-js/internals/get-substitution.js"(exports, module2) {
    "use strict";
    var uncurryThis = require_function_uncurry_this();
    var toObject = require_to_object();
    var floor2 = Math.floor;
    var charAt = uncurryThis("".charAt);
    var replace = uncurryThis("".replace);
    var stringSlice = uncurryThis("".slice);
    var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
    var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
    module2.exports = function(matched, str, position, captures, namedCaptures, replacement) {
      var tailPos = position + matched.length;
      var m2 = captures.length;
      var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
      if (namedCaptures !== void 0) {
        namedCaptures = toObject(namedCaptures);
        symbols = SUBSTITUTION_SYMBOLS;
      }
      return replace(replacement, symbols, function(match, ch) {
        var capture;
        switch (charAt(ch, 0)) {
          case "$":
            return "$";
          case "&":
            return matched;
          case "`":
            return stringSlice(str, 0, position);
          case "'":
            return stringSlice(str, tailPos);
          case "<":
            capture = namedCaptures[stringSlice(ch, 1, -1)];
            break;
          default:
            var n2 = +ch;
            if (n2 === 0)
              return match;
            if (n2 > m2) {
              var f2 = floor2(n2 / 10);
              if (f2 === 0)
                return match;
              if (f2 <= m2)
                return captures[f2 - 1] === void 0 ? charAt(ch, 1) : captures[f2 - 1] + charAt(ch, 1);
              return match;
            }
            capture = captures[n2 - 1];
        }
        return capture === void 0 ? "" : capture;
      });
    };
  }
});

// node_modules/core-js/internals/regexp-exec-abstract.js
var require_regexp_exec_abstract = __commonJS({
  "node_modules/core-js/internals/regexp-exec-abstract.js"(exports, module2) {
    "use strict";
    var call = require_function_call();
    var anObject = require_an_object();
    var isCallable = require_is_callable();
    var classof = require_classof_raw();
    var regexpExec = require_regexp_exec();
    var $TypeError = TypeError;
    module2.exports = function(R2, S2) {
      var exec = R2.exec;
      if (isCallable(exec)) {
        var result = call(exec, R2, S2);
        if (result !== null)
          anObject(result);
        return result;
      }
      if (classof(R2) === "RegExp")
        return call(regexpExec, R2, S2);
      throw new $TypeError("RegExp#exec called on incompatible receiver");
    };
  }
});

// node_modules/core-js/modules/es.string.replace.js
var require_es_string_replace = __commonJS({
  "node_modules/core-js/modules/es.string.replace.js"() {
    "use strict";
    var apply = require_function_apply();
    var call = require_function_call();
    var uncurryThis = require_function_uncurry_this();
    var fixRegExpWellKnownSymbolLogic = require_fix_regexp_well_known_symbol_logic();
    var fails = require_fails();
    var anObject = require_an_object();
    var isCallable = require_is_callable();
    var isNullOrUndefined = require_is_null_or_undefined();
    var toIntegerOrInfinity = require_to_integer_or_infinity();
    var toLength = require_to_length();
    var toString = require_to_string();
    var requireObjectCoercible = require_require_object_coercible();
    var advanceStringIndex = require_advance_string_index();
    var getMethod2 = require_get_method();
    var getSubstitution = require_get_substitution();
    var regExpExec = require_regexp_exec_abstract();
    var wellKnownSymbol = require_well_known_symbol();
    var REPLACE = wellKnownSymbol("replace");
    var max3 = Math.max;
    var min4 = Math.min;
    var concat = uncurryThis([].concat);
    var push = uncurryThis([].push);
    var stringIndexOf = uncurryThis("".indexOf);
    var stringSlice = uncurryThis("".slice);
    var maybeToString = function(it) {
      return it === void 0 ? it : String(it);
    };
    var REPLACE_KEEPS_$0 = function() {
      return "a".replace(/./, "$0") === "$0";
    }();
    var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = function() {
      if (/./[REPLACE]) {
        return /./[REPLACE]("a", "$0") === "";
      }
      return false;
    }();
    var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function() {
      var re2 = /./;
      re2.exec = function() {
        var result = [];
        result.groups = { a: "7" };
        return result;
      };
      return "".replace(re2, "$<a>") !== "7";
    });
    fixRegExpWellKnownSymbolLogic("replace", function(_2, nativeReplace, maybeCallNative) {
      var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? "$" : "$0";
      return [
        function replace(searchValue, replaceValue) {
          var O2 = requireObjectCoercible(this);
          var replacer = isNullOrUndefined(searchValue) ? void 0 : getMethod2(searchValue, REPLACE);
          return replacer ? call(replacer, searchValue, O2, replaceValue) : call(nativeReplace, toString(O2), searchValue, replaceValue);
        },
        function(string2, replaceValue) {
          var rx = anObject(this);
          var S2 = toString(string2);
          if (typeof replaceValue == "string" && stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 && stringIndexOf(replaceValue, "$<") === -1) {
            var res = maybeCallNative(nativeReplace, rx, S2, replaceValue);
            if (res.done)
              return res.value;
          }
          var functionalReplace = isCallable(replaceValue);
          if (!functionalReplace)
            replaceValue = toString(replaceValue);
          var global2 = rx.global;
          var fullUnicode;
          if (global2) {
            fullUnicode = rx.unicode;
            rx.lastIndex = 0;
          }
          var results = [];
          var result;
          while (true) {
            result = regExpExec(rx, S2);
            if (result === null)
              break;
            push(results, result);
            if (!global2)
              break;
            var matchStr = toString(result[0]);
            if (matchStr === "")
              rx.lastIndex = advanceStringIndex(S2, toLength(rx.lastIndex), fullUnicode);
          }
          var accumulatedResult = "";
          var nextSourcePosition = 0;
          for (var i2 = 0; i2 < results.length; i2++) {
            result = results[i2];
            var matched = toString(result[0]);
            var position = max3(min4(toIntegerOrInfinity(result.index), S2.length), 0);
            var captures = [];
            var replacement;
            for (var j2 = 1; j2 < result.length; j2++)
              push(captures, maybeToString(result[j2]));
            var namedCaptures = result.groups;
            if (functionalReplace) {
              var replacerArgs = concat([matched], captures, position, S2);
              if (namedCaptures !== void 0)
                push(replacerArgs, namedCaptures);
              replacement = toString(apply(replaceValue, void 0, replacerArgs));
            } else {
              replacement = getSubstitution(matched, S2, position, captures, namedCaptures, replaceValue);
            }
            if (position >= nextSourcePosition) {
              accumulatedResult += stringSlice(S2, nextSourcePosition, position) + replacement;
              nextSourcePosition = position + matched.length;
            }
          }
          return accumulatedResult + stringSlice(S2, nextSourcePosition);
        }
      ];
    }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
  }
});

// node_modules/core-js/internals/is-regexp.js
var require_is_regexp = __commonJS({
  "node_modules/core-js/internals/is-regexp.js"(exports, module2) {
    "use strict";
    var isObject = require_is_object();
    var classof = require_classof_raw();
    var wellKnownSymbol = require_well_known_symbol();
    var MATCH = wellKnownSymbol("match");
    module2.exports = function(it) {
      var isRegExp;
      return isObject(it) && ((isRegExp = it[MATCH]) !== void 0 ? !!isRegExp : classof(it) === "RegExp");
    };
  }
});

// node_modules/core-js/internals/regexp-get-flags.js
var require_regexp_get_flags = __commonJS({
  "node_modules/core-js/internals/regexp-get-flags.js"(exports, module2) {
    "use strict";
    var call = require_function_call();
    var hasOwn = require_has_own_property();
    var isPrototypeOf = require_object_is_prototype_of();
    var regExpFlags = require_regexp_flags();
    var RegExpPrototype = RegExp.prototype;
    module2.exports = function(R2) {
      var flags = R2.flags;
      return flags === void 0 && !("flags" in RegExpPrototype) && !hasOwn(R2, "flags") && isPrototypeOf(RegExpPrototype, R2) ? call(regExpFlags, R2) : flags;
    };
  }
});

// node_modules/core-js/modules/es.string.replace-all.js
var require_es_string_replace_all = __commonJS({
  "node_modules/core-js/modules/es.string.replace-all.js"() {
    "use strict";
    var $ = require_export();
    var call = require_function_call();
    var uncurryThis = require_function_uncurry_this();
    var requireObjectCoercible = require_require_object_coercible();
    var isCallable = require_is_callable();
    var isNullOrUndefined = require_is_null_or_undefined();
    var isRegExp = require_is_regexp();
    var toString = require_to_string();
    var getMethod2 = require_get_method();
    var getRegExpFlags = require_regexp_get_flags();
    var getSubstitution = require_get_substitution();
    var wellKnownSymbol = require_well_known_symbol();
    var IS_PURE = require_is_pure();
    var REPLACE = wellKnownSymbol("replace");
    var $TypeError = TypeError;
    var indexOf = uncurryThis("".indexOf);
    var replace = uncurryThis("".replace);
    var stringSlice = uncurryThis("".slice);
    var max3 = Math.max;
    $({ target: "String", proto: true }, {
      replaceAll: function replaceAll(searchValue, replaceValue) {
        var O2 = requireObjectCoercible(this);
        var IS_REG_EXP, flags, replacer, string2, searchString, functionalReplace, searchLength, advanceBy, position, replacement;
        var endOfLastMatch = 0;
        var result = "";
        if (!isNullOrUndefined(searchValue)) {
          IS_REG_EXP = isRegExp(searchValue);
          if (IS_REG_EXP) {
            flags = toString(requireObjectCoercible(getRegExpFlags(searchValue)));
            if (!~indexOf(flags, "g"))
              throw new $TypeError("`.replaceAll` does not allow non-global regexes");
          }
          replacer = getMethod2(searchValue, REPLACE);
          if (replacer)
            return call(replacer, searchValue, O2, replaceValue);
          if (IS_PURE && IS_REG_EXP)
            return replace(toString(O2), searchValue, replaceValue);
        }
        string2 = toString(O2);
        searchString = toString(searchValue);
        functionalReplace = isCallable(replaceValue);
        if (!functionalReplace)
          replaceValue = toString(replaceValue);
        searchLength = searchString.length;
        advanceBy = max3(1, searchLength);
        position = indexOf(string2, searchString);
        while (position !== -1) {
          replacement = functionalReplace ? toString(replaceValue(searchString, position, string2)) : getSubstitution(searchString, string2, position, [], void 0, replaceValue);
          result += stringSlice(string2, endOfLastMatch, position) + replacement;
          endOfLastMatch = position + searchLength;
          position = position + advanceBy > string2.length ? -1 : indexOf(string2, searchString, position + advanceBy);
        }
        if (endOfLastMatch < string2.length) {
          result += stringSlice(string2, endOfLastMatch);
        }
        return result;
      }
    });
  }
});

// node_modules/core-js/es/string/replace-all.js
var require_replace_all = __commonJS({
  "node_modules/core-js/es/string/replace-all.js"(exports, module2) {
    "use strict";
    require_es_regexp_exec();
    require_es_string_replace();
    require_es_string_replace_all();
    var entryUnbind = require_entry_unbind();
    module2.exports = entryUnbind("String", "replaceAll");
  }
});

// node_modules/core-js/stable/string/replace-all.js
var require_replace_all2 = __commonJS({
  "node_modules/core-js/stable/string/replace-all.js"(exports, module2) {
    "use strict";
    var parent = require_replace_all();
    module2.exports = parent;
  }
});

// node_modules/@tldraw/state/dist-esm/lib/helpers.mjs
function isChild(x2) {
  return x2 && typeof x2 === "object" && "parents" in x2;
}
function haveParentsChanged(child) {
  for (let i2 = 0, n2 = child.parents.length; i2 < n2; i2++) {
    child.parents[i2].__unsafe__getWithoutCapture(true);
    if (child.parents[i2].lastChangedEpoch !== child.parentEpochs[i2]) {
      return true;
    }
  }
  return false;
}
function equals(a2, b2) {
  const shallowEquals = a2 === b2 || Object.is(a2, b2) || Boolean(a2 && b2 && typeof a2.equals === "function" && a2.equals(b2));
  return shallowEquals;
}
function singleton(key, init) {
  const symbol = Symbol.for(`com.tldraw.state/${key}`);
  const global2 = globalThis;
  global2[symbol] ?? (global2[symbol] = init());
  return global2[symbol];
}
var detach, attach, EMPTY_ARRAY;
var init_helpers = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/helpers.mjs"() {
    detach = (parent, child) => {
      if (!parent.children.remove(child)) {
        return;
      }
      if (parent.children.isEmpty && isChild(parent)) {
        for (let i2 = 0, n2 = parent.parents.length; i2 < n2; i2++) {
          detach(parent.parents[i2], parent);
        }
      }
    };
    attach = (parent, child) => {
      if (!parent.children.add(child)) {
        return;
      }
      if (isChild(parent)) {
        for (let i2 = 0, n2 = parent.parents.length; i2 < n2; i2++) {
          attach(parent.parents[i2], parent);
        }
      }
    };
    EMPTY_ARRAY = singleton("empty_array", () => Object.freeze([]));
  }
});

// node_modules/@tldraw/state/dist-esm/lib/ArraySet.mjs
var ARRAY_SIZE_THRESHOLD, ArraySet;
var init_ArraySet = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/ArraySet.mjs"() {
    ARRAY_SIZE_THRESHOLD = 8;
    ArraySet = class {
      constructor() {
        __publicField(this, "arraySize", 0);
        __publicField(this, "array", Array(ARRAY_SIZE_THRESHOLD));
        __publicField(this, "set", null);
      }
      get isEmpty() {
        if (this.array) {
          return this.arraySize === 0;
        }
        if (this.set) {
          return this.set.size === 0;
        }
        throw new Error("no set or array");
      }
      add(elem) {
        if (this.array) {
          const idx = this.array.indexOf(elem);
          if (idx !== -1) {
            return false;
          }
          if (this.arraySize < ARRAY_SIZE_THRESHOLD) {
            this.array[this.arraySize] = elem;
            this.arraySize++;
            return true;
          } else {
            this.set = new Set(this.array);
            this.array = null;
            this.set.add(elem);
            return true;
          }
        }
        if (this.set) {
          if (this.set.has(elem)) {
            return false;
          }
          this.set.add(elem);
          return true;
        }
        throw new Error("no set or array");
      }
      remove(elem) {
        if (this.array) {
          const idx = this.array.indexOf(elem);
          if (idx === -1) {
            return false;
          }
          this.array[idx] = void 0;
          this.arraySize--;
          if (idx !== this.arraySize) {
            this.array[idx] = this.array[this.arraySize];
            this.array[this.arraySize] = void 0;
          }
          return true;
        }
        if (this.set) {
          if (!this.set.has(elem)) {
            return false;
          }
          this.set.delete(elem);
          return true;
        }
        throw new Error("no set or array");
      }
      visit(visitor) {
        if (this.array) {
          for (let i2 = 0; i2 < this.arraySize; i2++) {
            const elem = this.array[i2];
            if (typeof elem !== "undefined") {
              visitor(elem);
            }
          }
          return;
        }
        if (this.set) {
          this.set.forEach(visitor);
          return;
        }
        throw new Error("no set or array");
      }
      has(elem) {
        if (this.array) {
          return this.array.indexOf(elem) !== -1;
        } else {
          return this.set.has(elem);
        }
      }
      clear() {
        if (this.set) {
          this.set.clear();
        } else {
          this.arraySize = 0;
          this.array = [];
        }
      }
      size() {
        if (this.set) {
          return this.set.size;
        } else {
          return this.arraySize;
        }
      }
    };
  }
});

// node_modules/@tldraw/state/dist-esm/lib/types.mjs
var RESET_VALUE;
var init_types2 = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/types.mjs"() {
    RESET_VALUE = Symbol.for("com.tldraw.state/RESET_VALUE");
  }
});

// node_modules/@tldraw/state/dist-esm/lib/HistoryBuffer.mjs
var HistoryBuffer;
var init_HistoryBuffer = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/HistoryBuffer.mjs"() {
    init_types2();
    HistoryBuffer = class {
      constructor(capacity) {
        __publicField(this, "index", 0);
        __publicField(this, "buffer");
        this.capacity = capacity;
        this.buffer = new Array(capacity);
      }
      pushEntry(lastComputedEpoch, currentEpoch, diff) {
        if (diff === void 0) {
          return;
        }
        if (diff === RESET_VALUE) {
          this.clear();
          return;
        }
        this.buffer[this.index] = [lastComputedEpoch, currentEpoch, diff];
        this.index = (this.index + 1) % this.capacity;
      }
      clear() {
        this.index = 0;
        this.buffer.fill(void 0);
      }
      getChangesSince(sinceEpoch) {
        const { index: index3, capacity, buffer } = this;
        for (let i2 = 0; i2 < capacity; i2++) {
          const offset5 = (index3 - 1 + capacity - i2) % capacity;
          const elem = buffer[offset5];
          if (!elem) {
            return RESET_VALUE;
          }
          const [fromEpoch, toEpoch] = elem;
          if (i2 === 0 && sinceEpoch >= toEpoch) {
            return [];
          }
          if (fromEpoch <= sinceEpoch && sinceEpoch < toEpoch) {
            const len = i2 + 1;
            const result = new Array(len);
            for (let j2 = 0; j2 < len; j2++) {
              result[j2] = buffer[(offset5 + j2) % capacity][2];
            }
            return result;
          }
        }
        return RESET_VALUE;
      }
    };
  }
});

// node_modules/@tldraw/state/dist-esm/lib/capture.mjs
function unsafe__withoutCapture(fn3) {
  const oldStack = inst.stack;
  inst.stack = null;
  try {
    return fn3();
  } finally {
    inst.stack = oldStack;
  }
}
function startCapturingParents(child) {
  inst.stack = new CaptureStackFrame(inst.stack, child);
  child.parentSet.clear();
}
function stopCapturingParents() {
  const frame3 = inst.stack;
  inst.stack = frame3.below;
  if (frame3.offset < frame3.child.parents.length) {
    for (let i2 = frame3.offset; i2 < frame3.child.parents.length; i2++) {
      const maybeRemovedParent = frame3.child.parents[i2];
      if (!frame3.child.parentSet.has(maybeRemovedParent)) {
        detach(maybeRemovedParent, frame3.child);
      }
    }
    frame3.child.parents.length = frame3.offset;
    frame3.child.parentEpochs.length = frame3.offset;
  }
  if (frame3.maybeRemoved) {
    for (let i2 = 0; i2 < frame3.maybeRemoved.length; i2++) {
      const maybeRemovedParent = frame3.maybeRemoved[i2];
      if (!frame3.child.parentSet.has(maybeRemovedParent)) {
        detach(maybeRemovedParent, frame3.child);
      }
    }
  }
}
function maybeCaptureParent(p2) {
  if (inst.stack) {
    const wasCapturedAlready = inst.stack.child.parentSet.has(p2);
    if (wasCapturedAlready) {
      return;
    }
    inst.stack.child.parentSet.add(p2);
    if (inst.stack.child.isActivelyListening) {
      attach(p2, inst.stack.child);
    }
    if (inst.stack.offset < inst.stack.child.parents.length) {
      const maybeRemovedParent = inst.stack.child.parents[inst.stack.offset];
      if (maybeRemovedParent !== p2) {
        if (!inst.stack.maybeRemoved) {
          inst.stack.maybeRemoved = [maybeRemovedParent];
        } else {
          inst.stack.maybeRemoved.push(maybeRemovedParent);
        }
      }
    }
    inst.stack.child.parents[inst.stack.offset] = p2;
    inst.stack.child.parentEpochs[inst.stack.offset] = p2.lastChangedEpoch;
    inst.stack.offset++;
  }
}
var CaptureStackFrame, inst;
var init_capture = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/capture.mjs"() {
    init_helpers();
    CaptureStackFrame = class {
      constructor(below, child) {
        __publicField(this, "offset", 0);
        __publicField(this, "maybeRemoved");
        this.below = below;
        this.child = child;
      }
    };
    inst = singleton("capture", () => ({ stack: null }));
  }
});

// node_modules/@tldraw/state/dist-esm/lib/constants.mjs
var GLOBAL_START_EPOCH;
var init_constants2 = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/constants.mjs"() {
    GLOBAL_START_EPOCH = -1;
  }
});

// node_modules/@tldraw/state/dist-esm/lib/EffectScheduler.mjs
function react(name, fn3, options) {
  const scheduler = new EffectScheduler(name, fn3, options);
  scheduler.attach();
  scheduler.scheduleEffect();
  return () => {
    scheduler.detach();
  };
}
function reactor(name, fn3, options) {
  const scheduler = new EffectScheduler(name, fn3, options);
  return {
    scheduler,
    start: (options2) => {
      const force = options2?.force ?? false;
      scheduler.attach();
      if (force) {
        scheduler.scheduleEffect();
      } else {
        scheduler.maybeScheduleEffect();
      }
    },
    stop: () => {
      scheduler.detach();
    }
  };
}
var __EffectScheduler__, EffectScheduler;
var init_EffectScheduler = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/EffectScheduler.mjs"() {
    init_ArraySet();
    init_capture();
    init_constants2();
    init_helpers();
    init_transactions();
    __EffectScheduler__ = class {
      constructor(name, runEffect, options) {
        __publicField(this, "_isActivelyListening", false);
        __publicField(this, "lastTraversedEpoch", GLOBAL_START_EPOCH);
        __publicField(this, "lastReactedEpoch", GLOBAL_START_EPOCH);
        __publicField(this, "_scheduleCount", 0);
        __publicField(this, "parentSet", new ArraySet());
        __publicField(this, "parentEpochs", []);
        __publicField(this, "parents", []);
        __publicField(this, "_scheduleEffect");
        __publicField(this, "maybeExecute", () => {
          if (!this._isActivelyListening)
            return;
          this.execute();
        });
        this.name = name;
        this.runEffect = runEffect;
        this._scheduleEffect = options?.scheduleEffect;
      }
      get isActivelyListening() {
        return this._isActivelyListening;
      }
      get scheduleCount() {
        return this._scheduleCount;
      }
      maybeScheduleEffect() {
        if (!this._isActivelyListening)
          return;
        if (this.lastReactedEpoch === getGlobalEpoch())
          return;
        if (this.parents.length && !haveParentsChanged(this)) {
          this.lastReactedEpoch = getGlobalEpoch();
          return;
        }
        this.scheduleEffect();
      }
      scheduleEffect() {
        this._scheduleCount++;
        if (this._scheduleEffect) {
          this._scheduleEffect(this.maybeExecute);
        } else {
          this.execute();
        }
      }
      attach() {
        this._isActivelyListening = true;
        for (let i2 = 0, n2 = this.parents.length; i2 < n2; i2++) {
          attach(this.parents[i2], this);
        }
      }
      detach() {
        this._isActivelyListening = false;
        for (let i2 = 0, n2 = this.parents.length; i2 < n2; i2++) {
          detach(this.parents[i2], this);
        }
      }
      execute() {
        try {
          startCapturingParents(this);
          const currentEpoch = getGlobalEpoch();
          const result = this.runEffect(this.lastReactedEpoch);
          this.lastReactedEpoch = currentEpoch;
          return result;
        } finally {
          stopCapturingParents();
        }
      }
    };
    EffectScheduler = singleton("EffectScheduler", () => __EffectScheduler__);
  }
});

// node_modules/@tldraw/state/dist-esm/lib/transactions.mjs
function getReactionEpoch() {
  return inst2.reactionEpoch;
}
function getGlobalEpoch() {
  return inst2.globalEpoch;
}
function getIsReacting() {
  return inst2.globalIsReacting;
}
function traverse(reactors, child) {
  if (child.lastTraversedEpoch === inst2.globalEpoch) {
    return;
  }
  child.lastTraversedEpoch = inst2.globalEpoch;
  if (child instanceof EffectScheduler) {
    reactors.add(child);
  } else {
    ;
    child.children.visit((c2) => traverse(reactors, c2));
  }
}
function flushChanges(atoms) {
  if (inst2.globalIsReacting) {
    throw new Error("cannot change atoms during reaction cycle");
  }
  try {
    inst2.globalIsReacting = true;
    inst2.reactionEpoch = inst2.globalEpoch;
    const reactors = /* @__PURE__ */ new Set();
    for (const atom3 of atoms) {
      atom3.children.visit((child) => traverse(reactors, child));
    }
    for (const r2 of reactors) {
      r2.maybeScheduleEffect();
    }
    let updateDepth = 0;
    while (inst2.cleanupReactors?.size) {
      if (updateDepth++ > 1e3) {
        throw new Error("Reaction update depth limit exceeded");
      }
      const reactors2 = inst2.cleanupReactors;
      inst2.cleanupReactors = null;
      for (const r2 of reactors2) {
        r2.maybeScheduleEffect();
      }
    }
  } finally {
    inst2.cleanupReactors = null;
    inst2.globalIsReacting = false;
  }
}
function atomDidChange(atom3, previousValue) {
  if (inst2.globalIsReacting) {
    const rs = inst2.cleanupReactors ?? (inst2.cleanupReactors = /* @__PURE__ */ new Set());
    atom3.children.visit((child) => traverse(rs, child));
  } else if (!inst2.currentTransaction) {
    flushChanges([atom3]);
  } else if (!inst2.currentTransaction.initialAtomValues.has(atom3)) {
    inst2.currentTransaction.initialAtomValues.set(atom3, previousValue);
  }
}
function advanceGlobalEpoch() {
  inst2.globalEpoch++;
}
function transaction(fn3) {
  const txn = new Transaction(inst2.currentTransaction);
  inst2.currentTransaction = txn;
  try {
    let result = void 0;
    let rollback = false;
    try {
      result = fn3(() => rollback = true);
    } catch (e2) {
      txn.abort();
      throw e2;
    }
    if (rollback) {
      txn.abort();
    } else {
      txn.commit();
    }
    return result;
  } finally {
    inst2.currentTransaction = inst2.currentTransaction.parent;
  }
}
function transact(fn3) {
  if (inst2.currentTransaction) {
    return fn3();
  }
  return transaction(fn3);
}
var Transaction, inst2;
var init_transactions = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/transactions.mjs"() {
    init_EffectScheduler();
    init_constants2();
    init_helpers();
    Transaction = class {
      constructor(parent) {
        __publicField(this, "initialAtomValues", /* @__PURE__ */ new Map());
        this.parent = parent;
      }
      get isRoot() {
        return this.parent === null;
      }
      commit() {
        if (this.isRoot) {
          flushChanges(this.initialAtomValues.keys());
        } else {
          this.initialAtomValues.forEach((value, atom3) => {
            if (!this.parent.initialAtomValues.has(atom3)) {
              this.parent.initialAtomValues.set(atom3, value);
            }
          });
        }
      }
      abort() {
        inst2.globalEpoch++;
        this.initialAtomValues.forEach((value, atom3) => {
          atom3.set(value);
          atom3.historyBuffer?.clear();
        });
        this.commit();
      }
    };
    inst2 = singleton("transactions", () => ({
      globalEpoch: GLOBAL_START_EPOCH + 1,
      globalIsReacting: false,
      currentTransaction: null,
      cleanupReactors: null,
      reactionEpoch: GLOBAL_START_EPOCH + 1
    }));
  }
});

// node_modules/@tldraw/state/dist-esm/lib/Atom.mjs
function atom2(name, initialValue, options) {
  return new _Atom(name, initialValue, options);
}
var __Atom__, _Atom;
var init_Atom = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/Atom.mjs"() {
    init_ArraySet();
    init_HistoryBuffer();
    init_capture();
    init_helpers();
    init_transactions();
    init_types2();
    __Atom__ = class {
      constructor(name, current, options) {
        __publicField(this, "isEqual");
        __publicField(this, "computeDiff");
        __publicField(this, "lastChangedEpoch", getGlobalEpoch());
        __publicField(this, "children", new ArraySet());
        __publicField(this, "historyBuffer");
        this.name = name;
        this.current = current;
        this.isEqual = options?.isEqual ?? null;
        if (!options)
          return;
        if (options.historyLength) {
          this.historyBuffer = new HistoryBuffer(options.historyLength);
        }
        this.computeDiff = options.computeDiff;
      }
      __unsafe__getWithoutCapture(_ignoreErrors) {
        return this.current;
      }
      get() {
        maybeCaptureParent(this);
        return this.current;
      }
      set(value, diff) {
        if (this.isEqual?.(this.current, value) ?? equals(this.current, value)) {
          return this.current;
        }
        advanceGlobalEpoch();
        if (this.historyBuffer) {
          this.historyBuffer.pushEntry(this.lastChangedEpoch, getGlobalEpoch(), diff ?? this.computeDiff?.(this.current, value, this.lastChangedEpoch, getGlobalEpoch()) ?? RESET_VALUE);
        }
        this.lastChangedEpoch = getGlobalEpoch();
        const oldValue = this.current;
        this.current = value;
        atomDidChange(this, oldValue);
        return value;
      }
      update(updater) {
        return this.set(updater(this.current));
      }
      getDiffSince(epoch) {
        maybeCaptureParent(this);
        if (epoch >= this.lastChangedEpoch) {
          return EMPTY_ARRAY;
        }
        return this.historyBuffer?.getChangesSince(epoch) ?? RESET_VALUE;
      }
    };
    _Atom = singleton("Atom", () => __Atom__);
  }
});

// node_modules/@tldraw/state/dist-esm/lib/warnings.mjs
function logComputedGetterWarning() {
  if (didWarnComputedGetter)
    return;
  didWarnComputedGetter = true;
  console.warn(`Using \`@computed\` as a decorator for getters is deprecated and will be removed in the near future. Please refactor to use \`@computed\` as a decorator for methods.

// Before
@computed
get foo() {
	return 'foo'
}

// After
@computed
getFoo() {
	return 'foo'
}
`);
}
var didWarnComputedGetter;
var init_warnings = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/warnings.mjs"() {
    didWarnComputedGetter = false;
  }
});

// node_modules/@tldraw/state/dist-esm/lib/Computed.mjs
function withDiff(value, diff) {
  return new WithDiff(value, diff);
}
function computedMethodAnnotation(options = {}, _target, key, descriptor) {
  const originalMethod = descriptor.value;
  const derivationKey = Symbol.for("__@tldraw/state__computed__" + key);
  descriptor.value = function() {
    let d2 = this[derivationKey];
    if (!d2) {
      d2 = new _Computed(key, originalMethod.bind(this), options);
      Object.defineProperty(this, derivationKey, {
        enumerable: false,
        configurable: false,
        writable: false,
        value: d2
      });
    }
    return d2.get();
  };
  descriptor.value[isComputedMethodKey] = true;
  return descriptor;
}
function computedAnnotation(options = {}, _target, key, descriptor) {
  if (descriptor.get) {
    logComputedGetterWarning();
    return computedGetterAnnotation(options, _target, key, descriptor);
  } else {
    return computedMethodAnnotation(options, _target, key, descriptor);
  }
}
function computedGetterAnnotation(options = {}, _target, key, descriptor) {
  const originalMethod = descriptor.get;
  const derivationKey = Symbol.for("__@tldraw/state__computed__" + key);
  descriptor.get = function() {
    let d2 = this[derivationKey];
    if (!d2) {
      d2 = new _Computed(key, originalMethod.bind(this), options);
      Object.defineProperty(this, derivationKey, {
        enumerable: false,
        configurable: false,
        writable: false,
        value: d2
      });
    }
    return d2.get();
  };
  return descriptor;
}
function computed() {
  if (arguments.length === 1) {
    const options = arguments[0];
    return (target, key, descriptor) => computedAnnotation(options, target, key, descriptor);
  } else if (typeof arguments[0] === "string") {
    return new _Computed(arguments[0], arguments[1], arguments[2]);
  } else {
    return computedAnnotation(void 0, arguments[0], arguments[1], arguments[2]);
  }
}
var UNINITIALIZED, isUninitialized, WithDiff, __UNSAFE__Computed, _Computed, isComputedMethodKey;
var init_Computed = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/Computed.mjs"() {
    init_ArraySet();
    init_HistoryBuffer();
    init_capture();
    init_constants2();
    init_helpers();
    init_transactions();
    init_types2();
    init_warnings();
    UNINITIALIZED = Symbol.for("com.tldraw.state/UNINITIALIZED");
    isUninitialized = (value) => {
      return value === UNINITIALIZED;
    };
    WithDiff = singleton("WithDiff", () => class WithDiff {
      constructor(value, diff) {
        this.value = value;
        this.diff = diff;
      }
    });
    __UNSAFE__Computed = class {
      constructor(name, derive, options) {
        __publicField(this, "lastChangedEpoch", GLOBAL_START_EPOCH);
        __publicField(this, "lastTraversedEpoch", GLOBAL_START_EPOCH);
        __publicField(this, "lastCheckedEpoch", GLOBAL_START_EPOCH);
        __publicField(this, "parentSet", new ArraySet());
        __publicField(this, "parents", []);
        __publicField(this, "parentEpochs", []);
        __publicField(this, "children", new ArraySet());
        __publicField(this, "historyBuffer");
        __publicField(this, "state", UNINITIALIZED);
        __publicField(this, "error", null);
        __publicField(this, "computeDiff");
        __publicField(this, "isEqual");
        this.name = name;
        this.derive = derive;
        if (options?.historyLength) {
          this.historyBuffer = new HistoryBuffer(options.historyLength);
        }
        this.computeDiff = options?.computeDiff;
        this.isEqual = options?.isEqual ?? equals;
      }
      get isActivelyListening() {
        return !this.children.isEmpty;
      }
      __unsafe__getWithoutCapture(ignoreErrors) {
        const isNew = this.lastChangedEpoch === GLOBAL_START_EPOCH;
        const globalEpoch = getGlobalEpoch();
        if (!isNew && (this.lastCheckedEpoch === globalEpoch || this.isActivelyListening && getIsReacting() && this.lastTraversedEpoch < getReactionEpoch() || !haveParentsChanged(this))) {
          this.lastCheckedEpoch = globalEpoch;
          if (this.error) {
            if (!ignoreErrors) {
              throw this.error.thrownValue;
            } else {
              return this.state;
            }
          } else {
            return this.state;
          }
        }
        try {
          startCapturingParents(this);
          const result = this.derive(this.state, this.lastCheckedEpoch);
          const newState = result instanceof WithDiff ? result.value : result;
          const isUninitialized2 = this.state === UNINITIALIZED;
          if (isUninitialized2 || !this.isEqual(newState, this.state)) {
            if (this.historyBuffer && !isUninitialized2) {
              const diff = result instanceof WithDiff ? result.diff : void 0;
              this.historyBuffer.pushEntry(this.lastChangedEpoch, getGlobalEpoch(), diff ?? this.computeDiff?.(this.state, newState, this.lastCheckedEpoch, getGlobalEpoch()) ?? RESET_VALUE);
            }
            this.lastChangedEpoch = getGlobalEpoch();
            this.state = newState;
          }
          this.error = null;
          this.lastCheckedEpoch = getGlobalEpoch();
          return this.state;
        } catch (e2) {
          if (this.state !== UNINITIALIZED) {
            this.state = UNINITIALIZED;
            this.lastChangedEpoch = getGlobalEpoch();
          }
          this.lastCheckedEpoch = getGlobalEpoch();
          if (this.historyBuffer) {
            this.historyBuffer.clear();
          }
          this.error = { thrownValue: e2 };
          if (!ignoreErrors)
            throw e2;
          return this.state;
        } finally {
          stopCapturingParents();
        }
      }
      get() {
        try {
          return this.__unsafe__getWithoutCapture();
        } finally {
          maybeCaptureParent(this);
        }
      }
      getDiffSince(epoch) {
        this.__unsafe__getWithoutCapture(true);
        maybeCaptureParent(this);
        if (epoch >= this.lastChangedEpoch) {
          return EMPTY_ARRAY;
        }
        return this.historyBuffer?.getChangesSince(epoch) ?? RESET_VALUE;
      }
    };
    _Computed = singleton("Computed", () => __UNSAFE__Computed);
    isComputedMethodKey = "@@__isComputedMethod__@@";
  }
});

// node_modules/@tldraw/state/dist-esm/lib/isSignal.mjs
var init_isSignal = __esm({
  "node_modules/@tldraw/state/dist-esm/lib/isSignal.mjs"() {
    init_Atom();
    init_Computed();
  }
});

// node_modules/@tldraw/state/dist-esm/index.mjs
var currentApiVersion, actualApiVersion;
var init_dist_esm = __esm({
  "node_modules/@tldraw/state/dist-esm/index.mjs"() {
    init_helpers();
    init_ArraySet();
    init_Atom();
    init_Computed();
    init_EffectScheduler();
    init_capture();
    init_helpers();
    init_isSignal();
    init_transactions();
    init_types2();
    currentApiVersion = 1;
    actualApiVersion = singleton("apiVersion", () => currentApiVersion);
    if (actualApiVersion !== currentApiVersion) {
      throw new Error(`You have multiple incompatible versions of @tldraw/state in your app. Please deduplicate the package.`);
    }
  }
});

// node_modules/lodash.throttle/index.js
var require_lodash = __commonJS({
  "node_modules/lodash.throttle/index.js"(exports, module2) {
    var FUNC_ERROR_TEXT = "Expected a function";
    var NAN = 0 / 0;
    var symbolTag = "[object Symbol]";
    var reTrim = /^\s+|\s+$/g;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var freeParseInt = parseInt;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    var objectProto = Object.prototype;
    var objectToString = objectProto.toString;
    var nativeMax = Math.max;
    var nativeMin = Math.min;
    var now = function() {
      return root.Date.now();
    };
    function debounce7(func, wait, options) {
      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      wait = toNumber(wait) || 0;
      if (isObject(options)) {
        leading = !!options.leading;
        maxing = "maxWait" in options;
        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
        trailing = "trailing" in options ? !!options.trailing : trailing;
      }
      function invokeFunc(time3) {
        var args = lastArgs, thisArg = lastThis;
        lastArgs = lastThis = void 0;
        lastInvokeTime = time3;
        result = func.apply(thisArg, args);
        return result;
      }
      function leadingEdge(time3) {
        lastInvokeTime = time3;
        timerId = setTimeout(timerExpired, wait);
        return leading ? invokeFunc(time3) : result;
      }
      function remainingWait(time3) {
        var timeSinceLastCall = time3 - lastCallTime, timeSinceLastInvoke = time3 - lastInvokeTime, result2 = wait - timeSinceLastCall;
        return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
      }
      function shouldInvoke(time3) {
        var timeSinceLastCall = time3 - lastCallTime, timeSinceLastInvoke = time3 - lastInvokeTime;
        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
      }
      function timerExpired() {
        var time3 = now();
        if (shouldInvoke(time3)) {
          return trailingEdge(time3);
        }
        timerId = setTimeout(timerExpired, remainingWait(time3));
      }
      function trailingEdge(time3) {
        timerId = void 0;
        if (trailing && lastArgs) {
          return invokeFunc(time3);
        }
        lastArgs = lastThis = void 0;
        return result;
      }
      function cancel() {
        if (timerId !== void 0) {
          clearTimeout(timerId);
        }
        lastInvokeTime = 0;
        lastArgs = lastCallTime = lastThis = timerId = void 0;
      }
      function flush3() {
        return timerId === void 0 ? result : trailingEdge(now());
      }
      function debounced() {
        var time3 = now(), isInvoking = shouldInvoke(time3);
        lastArgs = arguments;
        lastThis = this;
        lastCallTime = time3;
        if (isInvoking) {
          if (timerId === void 0) {
            return leadingEdge(lastCallTime);
          }
          if (maxing) {
            timerId = setTimeout(timerExpired, wait);
            return invokeFunc(lastCallTime);
          }
        }
        if (timerId === void 0) {
          timerId = setTimeout(timerExpired, wait);
        }
        return result;
      }
      debounced.cancel = cancel;
      debounced.flush = flush3;
      return debounced;
    }
    function throttle(func, wait, options) {
      var leading = true, trailing = true;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      if (isObject(options)) {
        leading = "leading" in options ? !!options.leading : leading;
        trailing = "trailing" in options ? !!options.trailing : trailing;
      }
      return debounce7(func, wait, {
        "leading": leading,
        "maxWait": wait,
        "trailing": trailing
      });
    }
    function isObject(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function isObjectLike(value) {
      return !!value && typeof value == "object";
    }
    function isSymbol(value) {
      return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
    }
    function toNumber(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol(value)) {
        return NAN;
      }
      if (isObject(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, "");
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    module2.exports = throttle;
  }
});

// node_modules/lodash.uniq/index.js
var require_lodash2 = __commonJS({
  "node_modules/lodash.uniq/index.js"(exports, module2) {
    var LARGE_ARRAY_SIZE = 200;
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var INFINITY = 1 / 0;
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    function arrayIncludes(array2, value) {
      var length = array2 ? array2.length : 0;
      return !!length && baseIndexOf(array2, value, 0) > -1;
    }
    function arrayIncludesWith(array2, value, comparator) {
      var index3 = -1, length = array2 ? array2.length : 0;
      while (++index3 < length) {
        if (comparator(value, array2[index3])) {
          return true;
        }
      }
      return false;
    }
    function baseFindIndex(array2, predicate, fromIndex, fromRight) {
      var length = array2.length, index3 = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index3-- : ++index3 < length) {
        if (predicate(array2[index3], index3, array2)) {
          return index3;
        }
      }
      return -1;
    }
    function baseIndexOf(array2, value, fromIndex) {
      if (value !== value) {
        return baseFindIndex(array2, baseIsNaN, fromIndex);
      }
      var index3 = fromIndex - 1, length = array2.length;
      while (++index3 < length) {
        if (array2[index3] === value) {
          return index3;
        }
      }
      return -1;
    }
    function baseIsNaN(value) {
      return value !== value;
    }
    function cacheHas(cache, key) {
      return cache.has(key);
    }
    function getValue(object2, key) {
      return object2 == null ? void 0 : object2[key];
    }
    function isHostObject(value) {
      var result = false;
      if (value != null && typeof value.toString != "function") {
        try {
          result = !!(value + "");
        } catch (e2) {
        }
      }
      return result;
    }
    function setToArray(set) {
      var index3 = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index3] = value;
      });
      return result;
    }
    var arrayProto = Array.prototype;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var coreJsData = root["__core-js_shared__"];
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    var funcToString = funcProto.toString;
    var hasOwnProperty5 = objectProto.hasOwnProperty;
    var objectToString = objectProto.toString;
    var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty5).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
    var splice = arrayProto.splice;
    var Map2 = getNative(root, "Map");
    var Set2 = getNative(root, "Set");
    var nativeCreate = getNative(Object, "create");
    function Hash(entries) {
      var index3 = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
    }
    function hashDelete(key) {
      return this.has(key) && delete this.__data__[key];
    }
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty5.call(data, key) ? data[key] : void 0;
    }
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty5.call(data, key);
    }
    function hashSet(key, value) {
      var data = this.__data__;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    function ListCache(entries) {
      var index3 = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function listCacheClear() {
      this.__data__ = [];
    }
    function listCacheDelete(key) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      if (index3 < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index3 == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index3, 1);
      }
      return true;
    }
    function listCacheGet(key) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      return index3 < 0 ? void 0 : data[index3][1];
    }
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    function listCacheSet(key, value) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      if (index3 < 0) {
        data.push([key, value]);
      } else {
        data[index3][1] = value;
      }
      return this;
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    function MapCache(entries) {
      var index3 = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function mapCacheClear() {
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    function mapCacheDelete(key) {
      return getMapData(this, key)["delete"](key);
    }
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    function mapCacheSet(key, value) {
      getMapData(this, key).set(key, value);
      return this;
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    function SetCache(values) {
      var index3 = -1, length = values ? values.length : 0;
      this.__data__ = new MapCache();
      while (++index3 < length) {
        this.add(values[index3]);
      }
    }
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    function assocIndexOf(array2, key) {
      var length = array2.length;
      while (length--) {
        if (eq(array2[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    function baseUniq(array2, iteratee, comparator) {
      var index3 = -1, includes = arrayIncludes, length = array2.length, isCommon = true, result = [], seen = result;
      if (comparator) {
        isCommon = false;
        includes = arrayIncludesWith;
      } else if (length >= LARGE_ARRAY_SIZE) {
        var set = iteratee ? null : createSet(array2);
        if (set) {
          return setToArray(set);
        }
        isCommon = false;
        includes = cacheHas;
        seen = new SetCache();
      } else {
        seen = iteratee ? [] : result;
      }
      outer:
        while (++index3 < length) {
          var value = array2[index3], computed2 = iteratee ? iteratee(value) : value;
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed2 === computed2) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed2) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed2);
            }
            result.push(value);
          } else if (!includes(seen, computed2, comparator)) {
            if (seen !== result) {
              seen.push(computed2);
            }
            result.push(value);
          }
        }
      return result;
    }
    var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop5 : function(values) {
      return new Set2(values);
    };
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    function getNative(object2, key) {
      var value = getValue(object2, key);
      return baseIsNative(value) ? value : void 0;
    }
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e2) {
        }
        try {
          return func + "";
        } catch (e2) {
        }
      }
      return "";
    }
    function uniq2(array2) {
      return array2 && array2.length ? baseUniq(array2) : [];
    }
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    function isFunction(value) {
      var tag = isObject(value) ? objectToString.call(value) : "";
      return tag == funcTag || tag == genTag;
    }
    function isObject(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function noop5() {
    }
    module2.exports = uniq2;
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs
var PERFORMANCE_COLORS, PERFORMANCE_PREFIX_COLOR;
var init_perf = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs"() {
    PERFORMANCE_COLORS = {
      Good: "#40C057",
      Mid: "#FFC078",
      Poor: "#E03131"
    };
    PERFORMANCE_PREFIX_COLOR = PERFORMANCE_COLORS.Good;
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs
var PerformanceTracker;
var init_PerformanceTracker = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs"() {
    init_perf();
    PerformanceTracker = class {
      constructor() {
        __publicField(this, "startTime", 0);
        __publicField(this, "name", "");
        __publicField(this, "frames", 0);
        __publicField(this, "started", false);
        __publicField(this, "frame", null);
        __publicField(this, "recordFrame", () => {
          this.frames++;
          if (!this.started)
            return;
          this.frame = requestAnimationFrame(this.recordFrame);
        });
      }
      start(name) {
        this.name = name;
        this.frames = 0;
        this.started = true;
        if (this.frame !== null)
          cancelAnimationFrame(this.frame);
        this.frame = requestAnimationFrame(this.recordFrame);
        this.startTime = performance.now();
      }
      stop() {
        this.started = false;
        if (this.frame !== null)
          cancelAnimationFrame(this.frame);
        const duration = (performance.now() - this.startTime) / 1e3;
        const fps = duration === 0 ? 0 : Math.floor(this.frames / duration);
        const background = fps > 55 ? PERFORMANCE_COLORS.Good : fps > 30 ? PERFORMANCE_COLORS.Mid : PERFORMANCE_COLORS.Poor;
        const color = background === PERFORMANCE_COLORS.Mid ? "black" : "white";
        const capitalized = this.name[0].toUpperCase() + this.name.slice(1);
        console.debug(`%cPerf%c ${capitalized} %c${fps}%c fps`, `color: white; background: ${PERFORMANCE_PREFIX_COLOR};padding: 2px;border-radius: 3px;`, "font-weight: normal", `font-weight: bold; padding: 2px; background: ${background};color: ${color};`, "font-weight: normal");
      }
      isStarted() {
        return this.started;
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/array.mjs
function dedupe(input, equals2) {
  const result = [];
  mainLoop:
    for (const item of input) {
      for (const existing of result) {
        if (equals2 ? equals2(item, existing) : item === existing) {
          continue mainLoop;
        }
      }
      result.push(item);
    }
  return result;
}
function compact(arr) {
  return arr.filter((i2) => i2 !== void 0 && i2 !== null);
}
function last(arr) {
  return arr[arr.length - 1];
}
function minBy(arr, fn3) {
  let min4;
  let minVal = Infinity;
  for (const item of arr) {
    const val = fn3(item);
    if (val < minVal) {
      min4 = item;
      minVal = val;
    }
  }
  return min4;
}
function areArraysShallowEqual(arr1, arr2) {
  if (arr1 === arr2)
    return true;
  if (arr1.length !== arr2.length)
    return false;
  for (let i2 = 0; i2 < arr1.length; i2++) {
    if (!Object.is(arr1[i2], arr2[i2])) {
      return false;
    }
  }
  return true;
}
var init_array = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/array.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs
var WeakCache;
var init_cache = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs"() {
    WeakCache = class {
      constructor() {
        __publicField(this, "items", /* @__PURE__ */ new WeakMap());
      }
      get(item, cb) {
        if (!this.items.has(item)) {
          this.items.set(item, cb(item));
        }
        return this.items.get(item);
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/function.mjs
function omitFromStackTrace(fn3) {
  const wrappedFn = (...args) => {
    try {
      return fn3(...args);
    } catch (error2) {
      if (error2 instanceof Error && Error.captureStackTrace) {
        Error.captureStackTrace(error2, wrappedFn);
      }
      throw error2;
    }
  };
  return wrappedFn;
}
var noop;
var init_function = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/function.mjs"() {
    noop = () => {
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/control.mjs
function exhaustiveSwitchError(value, property) {
  const debugValue = property && value && typeof value === "object" && property in value ? value[property] : value;
  throw new Error(`Unknown switch case ${debugValue}`);
}
var Result, assert, assertExists;
var init_control = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/control.mjs"() {
    init_function();
    Result = {
      ok(value) {
        return { ok: true, value };
      },
      err(error2) {
        return { ok: false, error: error2 };
      }
    };
    assert = omitFromStackTrace((value, message) => {
      if (!value) {
        throw new Error(message || "Assertion Error");
      }
    });
    assertExists = omitFromStackTrace((value, message) => {
      if (value == null) {
        throw new Error(message ?? "value must be defined");
      }
      return value;
    });
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs
function debounce(callback, wait) {
  let state = void 0;
  const fn3 = (...args) => {
    if (!state) {
      state = {};
      state.promise = new Promise((resolve, reject) => {
        state.resolve = resolve;
        state.reject = reject;
      });
    }
    clearTimeout(state.timeout);
    state.latestArgs = args;
    state.timeout = setTimeout(() => {
      const s2 = state;
      state = void 0;
      try {
        s2.resolve(callback(...s2.latestArgs));
      } catch (e2) {
        s2.reject(e2);
      }
    }, wait);
    return state.promise;
  };
  fn3.cancel = () => {
    if (!state)
      return;
    clearTimeout(state.timeout);
  };
  return fn3;
}
var init_debounce = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/error.mjs
function annotateError(error2, annotations) {
  if (typeof error2 !== "object" || error2 === null)
    return;
  let currentAnnotations = annotationsByError.get(error2);
  if (!currentAnnotations) {
    currentAnnotations = { tags: {}, extras: {} };
    annotationsByError.set(error2, currentAnnotations);
  }
  if (annotations.tags) {
    currentAnnotations.tags = {
      ...currentAnnotations.tags,
      ...annotations.tags
    };
  }
  if (annotations.extras) {
    currentAnnotations.extras = {
      ...currentAnnotations.extras,
      ...annotations.extras
    };
  }
}
var annotationsByError;
var init_error = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/error.mjs"() {
    annotationsByError = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/network.mjs
async function fetch2(input, init) {
  return window.fetch(input, {
    referrerPolicy: "strict-origin-when-cross-origin",
    ...init
  });
}
var Image;
var init_network = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/network.mjs"() {
    Image = (width, height) => {
      const img = new window.Image(width, height);
      img.referrerPolicy = "strict-origin-when-cross-origin";
      return img;
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/file.mjs
var FileHelpers;
var init_file = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/file.mjs"() {
    init_network();
    FileHelpers = class {
      static async dataUrlToArrayBuffer(dataURL) {
        return fetch2(dataURL).then(function(result) {
          return result.arrayBuffer();
        });
      }
      static async blobToDataUrl(file) {
        return await new Promise((resolve, reject) => {
          if (file) {
            const reader = new FileReader();
            reader.onload = () => resolve(reader.result);
            reader.onerror = (error2) => reject(error2);
            reader.onabort = (error2) => reject(error2);
            reader.readAsDataURL(file);
          }
        });
      }
      static async blobToText(file) {
        return await new Promise((resolve, reject) => {
          if (file) {
            const reader = new FileReader();
            reader.onload = () => resolve(reader.result);
            reader.onerror = (error2) => reject(error2);
            reader.onabort = (error2) => reject(error2);
            reader.readAsText(file);
          }
        });
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs
function getHashForString(string2) {
  let hash3 = 0;
  for (let i2 = 0; i2 < string2.length; i2++) {
    hash3 = (hash3 << 5) - hash3 + string2.charCodeAt(i2);
    hash3 |= 0;
  }
  return hash3 + "";
}
var init_hash = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs
var init_iterable = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs
function isApngAnimated(buffer) {
  const view = new Uint8Array(buffer);
  if (!view || !(typeof Buffer !== "undefined" && Buffer.isBuffer(view) || view instanceof Uint8Array) || view.length < 16) {
    return false;
  }
  const isPNG = view[0] === 137 && view[1] === 80 && view[2] === 78 && view[3] === 71 && view[4] === 13 && view[5] === 10 && view[6] === 26 && view[7] === 10;
  if (!isPNG) {
    return false;
  }
  function indexOfSubstring(haystack, needle, fromIndex, upToIndex, chunksize = 1024) {
    if (!needle) {
      return -1;
    }
    needle = new RegExp(needle, "g");
    const needle_length = needle.source.length;
    const decoder = new TextDecoder();
    const full_haystack_length = haystack.length;
    if (typeof upToIndex === "undefined") {
      upToIndex = full_haystack_length;
    }
    if (fromIndex >= full_haystack_length || upToIndex <= 0 || fromIndex >= upToIndex) {
      return -1;
    }
    haystack = haystack.subarray(fromIndex, upToIndex);
    let position = -1;
    let current_index = 0;
    let full_length = 0;
    let needle_buffer = "";
    outer:
      while (current_index < haystack.length) {
        const next_index = current_index + chunksize;
        const chunk = haystack.subarray(current_index, next_index);
        const decoded = decoder.decode(chunk, { stream: true });
        const text = needle_buffer + decoded;
        let match;
        let last_index = -1;
        while ((match = needle.exec(text)) !== null) {
          last_index = match.index - needle_buffer.length;
          position = full_length + last_index;
          break outer;
        }
        current_index = next_index;
        full_length += decoded.length;
        const needle_index = last_index > -1 ? last_index + needle_length : decoded.length - needle_length;
        needle_buffer = decoded.slice(needle_index);
      }
    if (position >= 0) {
      position += fromIndex >= 0 ? fromIndex : full_haystack_length + fromIndex;
    }
    return position;
  }
  const idatIdx = indexOfSubstring(view, "IDAT", 12);
  if (idatIdx >= 12) {
    const actlIdx = indexOfSubstring(view, "acTL", 8, idatIdx);
    return actlIdx >= 8;
  }
  return false;
}
var init_apng = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs
var isAvifAnimated;
var init_avif = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs"() {
    isAvifAnimated = (buffer) => {
      const view = new Uint8Array(buffer);
      return view[3] === 44;
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs
function getDataBlocksLength(buffer, offset5) {
  let length = 0;
  while (buffer[offset5 + length]) {
    length += buffer[offset5 + length] + 1;
  }
  return length + 1;
}
function isGIF(buffer) {
  const enc = new TextDecoder("ascii");
  const header = enc.decode(buffer.slice(0, 3));
  return header === "GIF";
}
function isGifAnimated(buffer) {
  const view = new Uint8Array(buffer);
  let hasColorTable, colorTableSize;
  let offset5 = 0;
  let imagesCount = 0;
  if (!isGIF(buffer)) {
    return false;
  }
  hasColorTable = view[10] & 128;
  colorTableSize = view[10] & 7;
  offset5 += 6;
  offset5 += 7;
  offset5 += hasColorTable ? 3 * Math.pow(2, colorTableSize + 1) : 0;
  while (imagesCount < 2 && offset5 < view.length) {
    switch (view[offset5]) {
      case 44:
        imagesCount += 1;
        hasColorTable = view[offset5 + 9] & 128;
        colorTableSize = view[offset5 + 9] & 7;
        offset5 += 10;
        offset5 += hasColorTable ? 3 * Math.pow(2, colorTableSize + 1) : 0;
        offset5 += getDataBlocksLength(view, offset5 + 1) + 1;
        break;
      case 33:
        offset5 += 2;
        offset5 += getDataBlocksLength(view, offset5);
        break;
      case 59:
        offset5 = view.length;
        break;
      default:
        offset5 = view.length;
        break;
    }
  }
  return imagesCount > 1;
}
var init_gif = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs
var TABLE, crc, LEN_SIZE, CRC_SIZE, PngHelpers;
var init_png = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs"() {
    TABLE = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    if (typeof Int32Array !== "undefined") {
      TABLE = new Int32Array(TABLE);
    }
    crc = (current, previous) => {
      let crc2 = previous === 0 ? 0 : ~~previous ^ -1;
      for (let index3 = 0; index3 < current.length; index3++) {
        crc2 = TABLE[(crc2 ^ current[index3]) & 255] ^ crc2 >>> 8;
      }
      return crc2 ^ -1;
    };
    LEN_SIZE = 4;
    CRC_SIZE = 4;
    PngHelpers = class {
      static isPng(view, offset5) {
        if (view.getUint8(offset5 + 0) === 137 && view.getUint8(offset5 + 1) === 80 && view.getUint8(offset5 + 2) === 78 && view.getUint8(offset5 + 3) === 71 && view.getUint8(offset5 + 4) === 13 && view.getUint8(offset5 + 5) === 10 && view.getUint8(offset5 + 6) === 26 && view.getUint8(offset5 + 7) === 10) {
          return true;
        }
        return false;
      }
      static getChunkType(view, offset5) {
        return [
          String.fromCharCode(view.getUint8(offset5)),
          String.fromCharCode(view.getUint8(offset5 + 1)),
          String.fromCharCode(view.getUint8(offset5 + 2)),
          String.fromCharCode(view.getUint8(offset5 + 3))
        ].join("");
      }
      static readChunks(view, offset5 = 0) {
        const chunks = {};
        if (!PngHelpers.isPng(view, offset5)) {
          throw new Error("Not a PNG");
        }
        offset5 += 8;
        while (offset5 <= view.buffer.byteLength) {
          const start2 = offset5;
          const len = view.getInt32(offset5);
          offset5 += 4;
          const chunkType = PngHelpers.getChunkType(view, offset5);
          if (chunkType === "IDAT" && chunks[chunkType]) {
            offset5 += len + LEN_SIZE + CRC_SIZE;
            continue;
          }
          if (chunkType === "IEND") {
            break;
          }
          chunks[chunkType] = {
            start: start2,
            dataOffset: offset5 + 4,
            size: len
          };
          offset5 += len + LEN_SIZE + CRC_SIZE;
        }
        return chunks;
      }
      static parsePhys(view, offset5) {
        return {
          ppux: view.getUint32(offset5),
          ppuy: view.getUint32(offset5 + 4),
          unit: view.getUint8(offset5 + 4)
        };
      }
      static findChunk(view, type) {
        const chunks = PngHelpers.readChunks(view);
        return chunks[type];
      }
      static setPhysChunk(view, dpr = 1, options) {
        let offset5 = 46;
        let size4 = 0;
        const res1 = PngHelpers.findChunk(view, "pHYs");
        if (res1) {
          offset5 = res1.start;
          size4 = res1.size;
        }
        const res2 = PngHelpers.findChunk(view, "IDAT");
        if (res2) {
          offset5 = res2.start;
          size4 = 0;
        }
        const pHYsData = new ArrayBuffer(21);
        const pHYsDataView = new DataView(pHYsData);
        pHYsDataView.setUint32(0, 9);
        pHYsDataView.setUint8(4, "p".charCodeAt(0));
        pHYsDataView.setUint8(5, "H".charCodeAt(0));
        pHYsDataView.setUint8(6, "Y".charCodeAt(0));
        pHYsDataView.setUint8(7, "s".charCodeAt(0));
        const DPI_96 = 2835.5;
        pHYsDataView.setInt32(8, DPI_96 * dpr);
        pHYsDataView.setInt32(12, DPI_96 * dpr);
        pHYsDataView.setInt8(16, 1);
        const crcBit = new Uint8Array(pHYsData.slice(4, 17));
        pHYsDataView.setInt32(17, crc(crcBit));
        const startBuf = view.buffer.slice(0, offset5);
        const endBuf = view.buffer.slice(offset5 + size4);
        return new Blob([startBuf, pHYsData, endBuf], options);
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs
function isWebp(view) {
  if (!view || view.length < 12) {
    return false;
  }
  return view[8] === 87 && view[9] === 69 && view[10] === 66 && view[11] === 80;
}
function isWebpAnimated(buffer) {
  const view = new Uint8Array(buffer);
  if (!isWebp(view)) {
    return false;
  }
  if (!view || view.length < 21) {
    return false;
  }
  return (view[20] >> 1 & 1) === 1;
}
var init_webp = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs
var DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES, DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES, DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES, DEFAULT_SUPPORTED_IMAGE_TYPES, DEFAULT_SUPPORT_VIDEO_TYPES, DEFAULT_SUPPORTED_MEDIA_TYPE_LIST, MediaHelpers;
var init_media = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs"() {
    init_network();
    init_apng();
    init_avif();
    init_gif();
    init_png();
    init_webp();
    DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES = Object.freeze(["image/svg+xml"]);
    DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES = Object.freeze([
      "image/jpeg",
      "image/png",
      "image/webp"
    ]);
    DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES = Object.freeze([
      "image/gif",
      "image/apng",
      "image/avif"
    ]);
    DEFAULT_SUPPORTED_IMAGE_TYPES = Object.freeze([
      ...DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES,
      ...DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES,
      ...DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES
    ]);
    DEFAULT_SUPPORT_VIDEO_TYPES = Object.freeze([
      "video/mp4",
      "video/webm",
      "video/quicktime"
    ]);
    DEFAULT_SUPPORTED_MEDIA_TYPE_LIST = [
      ...DEFAULT_SUPPORTED_IMAGE_TYPES,
      ...DEFAULT_SUPPORT_VIDEO_TYPES
    ].join(",");
    MediaHelpers = class {
      static loadVideo(src) {
        return new Promise((resolve, reject) => {
          const video = document.createElement("video");
          video.onloadeddata = () => resolve(video);
          video.onerror = (e2) => {
            console.error(e2);
            reject(new Error("Could not load video"));
          };
          video.crossOrigin = "anonymous";
          video.src = src;
        });
      }
      static loadImage(src) {
        return new Promise((resolve, reject) => {
          const img = Image();
          img.onload = () => resolve(img);
          img.onerror = (e2) => {
            console.error(e2);
            reject(new Error("Could not load image"));
          };
          img.crossOrigin = "anonymous";
          img.referrerPolicy = "strict-origin-when-cross-origin";
          img.src = src;
        });
      }
      static async getVideoSize(blob) {
        return MediaHelpers.usingObjectURL(blob, async (url) => {
          const video = await MediaHelpers.loadVideo(url);
          return { w: video.videoWidth, h: video.videoHeight };
        });
      }
      static async getImageSize(blob) {
        const image = await MediaHelpers.usingObjectURL(blob, MediaHelpers.loadImage);
        try {
          if (blob.type === "image/png") {
            const view = new DataView(await blob.arrayBuffer());
            if (PngHelpers.isPng(view, 0)) {
              const physChunk = PngHelpers.findChunk(view, "pHYs");
              if (physChunk) {
                const physData = PngHelpers.parsePhys(view, physChunk.dataOffset);
                if (physData.unit === 0 && physData.ppux === physData.ppuy) {
                  const pixelRatio = Math.max(physData.ppux / 2834.5, 1);
                  return {
                    w: Math.round(image.naturalWidth / pixelRatio),
                    h: Math.round(image.naturalHeight / pixelRatio)
                  };
                }
              }
            }
          }
        } catch (err) {
          console.error(err);
          return { w: image.naturalWidth, h: image.naturalHeight };
        }
        return { w: image.naturalWidth, h: image.naturalHeight };
      }
      static async isAnimated(file) {
        if (file.type === "image/gif") {
          return isGifAnimated(await file.arrayBuffer());
        }
        if (file.type === "image/avif") {
          return isAvifAnimated(await file.arrayBuffer());
        }
        if (file.type === "image/webp") {
          return isWebpAnimated(await file.arrayBuffer());
        }
        if (file.type === "image/apng") {
          return isApngAnimated(await file.arrayBuffer());
        }
        return false;
      }
      static isAnimatedImageType(mimeType) {
        return DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES.includes(mimeType || "");
      }
      static isStaticImageType(mimeType) {
        return DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES.includes(mimeType || "");
      }
      static isVectorImageType(mimeType) {
        return DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES.includes(mimeType || "");
      }
      static isImageType(mimeType) {
        return DEFAULT_SUPPORTED_IMAGE_TYPES.includes(mimeType);
      }
      static async usingObjectURL(blob, fn3) {
        const url = URL.createObjectURL(blob);
        try {
          return await fn3(url);
        } finally {
          URL.revokeObjectURL(url);
        }
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/number.mjs
function lerp(a2, b2, t3) {
  return a2 + (b2 - a2) * t3;
}
function rng(seed = "") {
  let x2 = 0;
  let y2 = 0;
  let z = 0;
  let w2 = 0;
  function next() {
    const t3 = x2 ^ x2 << 11;
    x2 = y2;
    y2 = z;
    z = w2;
    w2 ^= (w2 >>> 19 ^ t3 ^ t3 >>> 8) >>> 0;
    return w2 / 4294967296 * 2;
  }
  for (let k2 = 0; k2 < seed.length + 64; k2++) {
    x2 ^= seed.charCodeAt(k2) | 0;
    next();
  }
  return next;
}
function modulate(value, rangeA, rangeB, clamp4 = false) {
  const [fromLow, fromHigh] = rangeA;
  const [v0, v1] = rangeB;
  const result = v0 + (value - fromLow) / (fromHigh - fromLow) * (v1 - v0);
  return clamp4 ? v0 < v1 ? Math.max(Math.min(result, v1), v0) : Math.max(Math.min(result, v0), v1) : result;
}
var init_number = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/number.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/object.mjs
function hasOwnProperty(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}
function getOwnProperty(obj, key) {
  if (!hasOwnProperty(obj, key)) {
    return void 0;
  }
  return obj[key];
}
function objectMapValues(object2) {
  return Object.values(object2);
}
function objectMapEntries(object2) {
  return Object.entries(object2);
}
function filterEntries(object2, predicate) {
  const result = {};
  let didChange = false;
  for (const [key, value] of objectMapEntries(object2)) {
    if (predicate(key, value)) {
      result[key] = value;
    } else {
      didChange = true;
    }
  }
  return didChange ? result : object2;
}
function mapObjectMapValues(object2, mapper) {
  const result = {};
  for (const [key, value] of objectMapEntries(object2)) {
    const newValue = mapper(key, value);
    result[key] = newValue;
  }
  return result;
}
function areObjectsShallowEqual(obj1, obj2) {
  if (obj1 === obj2)
    return true;
  const keys1 = new Set(Object.keys(obj1));
  const keys2 = new Set(Object.keys(obj2));
  if (keys1.size !== keys2.size)
    return false;
  for (const key of keys1) {
    if (!keys2.has(key))
      return false;
    if (!Object.is(obj1[key], obj2[key]))
      return false;
  }
  return true;
}
var init_object = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/object.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs
function getIntegerLength(head) {
  if (head >= "a" && head <= "z") {
    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
  } else if (head >= "A" && head <= "Z") {
    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
  } else {
    throw new Error("Invalid index key head: " + head);
  }
}
function validateInteger(int) {
  if (int.length !== getIntegerLength(int.charAt(0))) {
    throw new Error("invalid integer part of index key: " + int);
  }
}
function isNotUndefined(n2) {
  if (n2 === void 0)
    throw Error("n is undefined");
}
function incrementInteger(x2) {
  validateInteger(x2);
  const [head, ...digs] = x2.split("");
  let carry = true;
  for (let i2 = digs.length - 1; carry && i2 >= 0; i2--) {
    const d2 = DIGITS.indexOf(digs[i2]) + 1;
    if (d2 === DIGITS.length) {
      digs[i2] = "0";
    } else {
      digs[i2] = DIGITS.charAt(d2);
      carry = false;
    }
  }
  if (carry) {
    if (head === "Z")
      return "a0";
    if (head === "z")
      return void 0;
    const h2 = String.fromCharCode(head.charCodeAt(0) + 1);
    if (h2 > "a") {
      digs.push("0");
    } else {
      digs.pop();
    }
    return h2 + digs.join("");
  } else {
    return head + digs.join("");
  }
}
function decrementInteger(x2) {
  validateInteger(x2);
  const [head, ...digs] = x2.split("");
  let borrow = true;
  for (let i2 = digs.length - 1; borrow && i2 >= 0; i2--) {
    const d2 = DIGITS.indexOf(digs[i2]) - 1;
    if (d2 === -1) {
      digs[i2] = DIGITS.slice(-1);
    } else {
      digs[i2] = DIGITS.charAt(d2);
      borrow = false;
    }
  }
  if (borrow) {
    if (head === "a")
      return "Z" + DIGITS.slice(-1);
    if (head === "A")
      return void 0;
    const h2 = String.fromCharCode(head.charCodeAt(0) - 1);
    if (h2 < "Z") {
      digs.push(DIGITS.slice(-1));
    } else {
      digs.pop();
    }
    return h2 + digs.join("");
  } else {
    return head + digs.join("");
  }
}
function midpoint(a2, b2) {
  if (b2 !== void 0 && a2 >= b2) {
    throw new Error(a2 + " >= " + b2);
  }
  if (a2.slice(-1) === "0" || b2 && b2.slice(-1) === "0") {
    throw new Error("trailing zero");
  }
  if (b2) {
    let n2 = 0;
    while ((a2.charAt(n2) || "0") === b2.charAt(n2)) {
      n2++;
    }
    if (n2 > 0) {
      return b2.slice(0, n2) + midpoint(a2.slice(n2), b2.slice(n2));
    }
  }
  const digitA = a2 ? DIGITS.indexOf(a2.charAt(0)) : 0;
  const digitB = b2 !== void 0 ? DIGITS.indexOf(b2.charAt(0)) : DIGITS.length;
  if (digitB - digitA > 1) {
    const midDigit = Math.round(0.5 * (digitA + digitB));
    return DIGITS.charAt(midDigit);
  } else {
    if (b2 && b2.length > 1) {
      return b2.slice(0, 1);
    } else {
      return DIGITS.charAt(digitA) + midpoint(a2.slice(1), void 0);
    }
  }
}
function getIntegerPart(index3) {
  const integerPartLength = getIntegerLength(index3.charAt(0));
  if (integerPartLength > index3.length) {
    throw new Error("invalid index: " + index3);
  }
  return index3.slice(0, integerPartLength);
}
function validateOrder(index3) {
  if (index3 === SMALLEST_INTEGER) {
    throw new Error("invalid index: " + index3);
  }
  const i2 = getIntegerPart(index3);
  const f2 = index3.slice(i2.length);
  if (f2.slice(-1) === "0") {
    throw new Error("invalid index: " + index3);
  }
}
function generateKeyBetween(a2, b2) {
  if (a2 !== void 0)
    validateOrder(a2);
  if (b2 !== void 0)
    validateOrder(b2);
  if (a2 !== void 0 && b2 !== void 0 && a2 >= b2) {
    throw new Error(a2 + " >= " + b2);
  }
  if (a2 === void 0 && b2 === void 0) {
    return INTEGER_ZERO;
  }
  if (a2 === void 0) {
    if (b2 === void 0)
      throw Error("b is undefined");
    const ib2 = getIntegerPart(b2);
    const fb2 = b2.slice(ib2.length);
    if (ib2 === SMALLEST_INTEGER) {
      return ib2 + midpoint("", fb2);
    }
    if (ib2 < b2) {
      return ib2;
    }
    const ibl = decrementInteger(ib2);
    isNotUndefined(ibl);
    return ibl;
  }
  if (b2 === void 0) {
    const ia2 = getIntegerPart(a2);
    const fa2 = a2.slice(ia2.length);
    const i22 = incrementInteger(ia2);
    return i22 === void 0 ? ia2 + midpoint(fa2, void 0) : i22;
  }
  const ia = getIntegerPart(a2);
  const fa = a2.slice(ia.length);
  const ib = getIntegerPart(b2);
  const fb = b2.slice(ib.length);
  if (ia === ib) {
    return ia + midpoint(fa, fb);
  }
  const i2 = incrementInteger(ia);
  isNotUndefined(i2);
  return i2 < b2 ? i2 : ia + midpoint(fa, void 0);
}
function generateNKeysBetween(a2, b2, n2) {
  if (n2 === 0)
    return [];
  if (n2 === 1)
    return [generateKeyBetween(a2, b2)];
  if (b2 === void 0) {
    let c22 = generateKeyBetween(a2, b2);
    const result = [c22];
    for (let i2 = 0; i2 < n2 - 1; i2++) {
      c22 = generateKeyBetween(c22, b2);
      result.push(c22);
    }
    return result;
  }
  if (a2 === void 0) {
    let c22 = generateKeyBetween(a2, b2);
    const result = [c22];
    for (let i2 = 0; i2 < n2 - 1; i2++) {
      c22 = generateKeyBetween(a2, c22);
      result.push(c22);
    }
    result.reverse();
    return result;
  }
  const mid = Math.floor(n2 / 2);
  const c2 = generateKeyBetween(a2, b2);
  return [...generateNKeysBetween(a2, c2, mid), c2, ...generateNKeysBetween(c2, b2, n2 - mid - 1)];
}
var DIGITS, INTEGER_ZERO, SMALLEST_INTEGER;
var init_dgreensp = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs"() {
    DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    INTEGER_ZERO = "a0";
    SMALLEST_INTEGER = "A00000000000000000000000000";
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs
function getIndicesBetween(below, above, n2) {
  return generateNKeysBetween(below, above, n2);
}
function getIndicesAbove(below, n2) {
  return generateNKeysBetween(below, void 0, n2);
}
function getIndexBetween(below, above) {
  return generateNKeysBetween(below, above, 1)[0];
}
function getIndexAbove(below) {
  return generateNKeysBetween(below, void 0, 1)[0];
}
function getIndexBelow(above) {
  return generateNKeysBetween(void 0, above, 1)[0];
}
function getIndices(n2, start2 = "a1") {
  return [start2, ...generateNKeysBetween(start2, void 0, n2)];
}
function sortByIndex(a2, b2) {
  if (a2.index < b2.index) {
    return -1;
  } else if (a2.index > b2.index) {
    return 1;
  }
  return 0;
}
var ZERO_INDEX_KEY;
var init_reordering = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs"() {
    init_dgreensp();
    ZERO_INDEX_KEY = INTEGER_ZERO;
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs
function sortById(a2, b2) {
  return a2.id > b2.id ? 1 : -1;
}
var init_sort = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs
function getFromLocalStorage(key) {
  try {
    return localStorage.getItem(key);
  } catch {
    return null;
  }
}
function setInLocalStorage(key, value) {
  try {
    localStorage.setItem(key, value);
  } catch {
  }
}
function clearLocalStorage() {
  try {
    localStorage.clear();
  } catch {
  }
}
function getFromSessionStorage(key) {
  try {
    return sessionStorage.getItem(key);
  } catch {
    return null;
  }
}
function setInSessionStorage(key, value) {
  try {
    sessionStorage.setItem(key, value);
  } catch {
  }
}
function deleteFromSessionStorage(key) {
  try {
    sessionStorage.removeItem(key);
  } catch {
  }
}
function clearSessionStorage() {
  try {
    sessionStorage.clear();
  } catch {
  }
}
var init_storage2 = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs
function tick() {
  if (frame) {
    return;
  }
  const now = Date.now();
  const elapsed = now - last2;
  if (time + elapsed < targetTimePerFrame) {
    frame = requestAnimationFrame(() => {
      frame = void 0;
      tick();
    });
    return;
  }
  frame = requestAnimationFrame(() => {
    frame = void 0;
    last2 = now;
    time = Math.min(time + elapsed - targetTimePerFrame, targetTimePerFrame * 10);
    flush();
  });
}
function throttleToNextFrame(fn3) {
  if (isTest()) {
    fn3();
    return () => {
    };
  }
  if (!fpsQueue.includes(fn3)) {
    fpsQueue.push(fn3);
    if (!started) {
      started = true;
      last2 = Date.now() - targetTimePerFrame - 1;
    }
    tick();
  }
  return () => {
    const index3 = fpsQueue.indexOf(fn3);
    if (index3 > -1) {
      fpsQueue.splice(index3, 1);
    }
  };
}
var isTest, fpsQueue, targetFps, targetTimePerFrame, frame, time, last2, flush, started;
var init_throttle = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs"() {
    isTest = () => typeof process !== "undefined" && false;
    fpsQueue = [];
    targetFps = 60;
    targetTimePerFrame = Math.ceil(1e3 / targetFps);
    time = 0;
    last2 = 0;
    flush = () => {
      const queue = fpsQueue.splice(0, fpsQueue.length);
      for (const fn3 of queue) {
        fn3();
      }
    };
    started = false;
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs
var Timers;
var init_timers = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs"() {
    Timers = class {
      constructor() {
        __publicField(this, "timeouts", []);
        __publicField(this, "intervals", []);
        __publicField(this, "rafs", []);
      }
      setTimeout(handler, timeout, ...args) {
        const id = window.setTimeout(handler, timeout, args);
        this.timeouts.push(id);
        return id;
      }
      setInterval(handler, timeout, ...args) {
        const id = window.setInterval(handler, timeout, args);
        this.intervals.push(id);
        return id;
      }
      requestAnimationFrame(callback) {
        const id = window.requestAnimationFrame(callback);
        this.rafs.push(id);
        return id;
      }
      dispose() {
        this.timeouts.forEach((id) => clearTimeout(id));
        this.intervals.forEach((id) => clearInterval(id));
        this.rafs.forEach((id) => cancelAnimationFrame(id));
        this.timeouts.length = 0;
        this.intervals.length = 0;
        this.rafs.length = 0;
      }
    };
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/value.mjs
function isNonNull(value) {
  return value !== null;
}
function getStructuredClone() {
  if (typeof globalThis !== "undefined" && globalThis.structuredClone) {
    return [globalThis.structuredClone, true];
  }
  if (typeof global !== "undefined" && global.structuredClone) {
    return [global.structuredClone, true];
  }
  if (typeof window !== "undefined" && window.structuredClone) {
    return [window.structuredClone, true];
  }
  return [(i2) => i2 ? JSON.parse(JSON.stringify(i2)) : i2, false];
}
var _structuredClone, structuredClone2, isNativeStructuredClone, STRUCTURED_CLONE_OBJECT_PROTOTYPE;
var init_value = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/value.mjs"() {
    _structuredClone = getStructuredClone();
    structuredClone2 = _structuredClone[0];
    isNativeStructuredClone = _structuredClone[1];
    STRUCTURED_CLONE_OBJECT_PROTOTYPE = Object.getPrototypeOf(structuredClone2({}));
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs
var init_warn = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs"() {
  }
});

// node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/index.mjs
var import_lodash, import_lodash2;
var init_dist_esm2 = __esm({
  "node_modules/@tldraw/editor/node_modules/@tldraw/utils/dist-esm/index.mjs"() {
    import_lodash = __toESM(require_lodash(), 1);
    import_lodash2 = __toESM(require_lodash2(), 1);
    init_PerformanceTracker();
    init_array();
    init_cache();
    init_control();
    init_debounce();
    init_error();
    init_file();
    init_function();
    init_hash();
    init_iterable();
    init_media();
    init_png();
    init_network();
    init_number();
    init_object();
    init_perf();
    init_reordering();
    init_sort();
    init_storage2();
    init_throttle();
    init_timers();
    init_value();
    init_warn();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/debug-flags.mjs
function createDebugValue(name, {
  defaults: defaults2,
  shouldStoreForSession = true
}) {
  return createDebugValueBase({
    name,
    defaults: defaults2,
    shouldStoreForSession
  });
}
function createFeatureFlag(name, {
  defaults: defaults2,
  shouldStoreForSession = true
}) {
  return createDebugValueBase({
    name,
    defaults: defaults2,
    shouldStoreForSession
  });
}
function createDebugValueBase(def) {
  const defaultValue = getDefaultValue(def);
  const storedValue = def.shouldStoreForSession ? getStoredInitialValue(def.name) : null;
  const valueAtom = atom2(`debug:${def.name}`, storedValue ?? defaultValue);
  if (typeof window !== "undefined") {
    if (def.shouldStoreForSession) {
      react(`debug:${def.name}`, () => {
        const currentValue = valueAtom.get();
        if (currentValue === defaultValue) {
          deleteFromSessionStorage(`tldraw_debug:${def.name}`);
        } else {
          setInSessionStorage(`tldraw_debug:${def.name}`, JSON.stringify(currentValue));
        }
      });
    }
    Object.defineProperty(window, `tldraw${def.name.replace(/^[a-z]/, (l2) => l2.toUpperCase())}`, {
      get() {
        return valueAtom.get();
      },
      set(newValue) {
        valueAtom.set(newValue);
      },
      configurable: true
    });
  }
  return Object.assign(valueAtom, def);
}
function getStoredInitialValue(name) {
  try {
    return JSON.parse(getFromSessionStorage(`tldraw_debug:${name}`) ?? "null");
  } catch (err) {
    return null;
  }
}
function readEnv(fn3) {
  try {
    return fn3();
  } catch {
    return null;
  }
}
function getDefaultValue(def) {
  const env = readEnv(() => process.env.TLDRAW_ENV) ?? readEnv(() => process.env.VERCEL_PUBLIC_TLDRAW_ENV) ?? readEnv(() => process.env.NEXT_PUBLIC_TLDRAW_ENV) ?? "production";
  switch (env) {
    case "production":
      return def.defaults.production ?? def.defaults.all;
    case "preview":
    case "staging":
      return def.defaults.staging ?? def.defaults.all;
    default:
      return def.defaults.development ?? def.defaults.all;
  }
}
var featureFlags, pointerCaptureTrackingObject, debugFlags;
var init_debug_flags = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/debug-flags.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    featureFlags = {
      enableLicensing: createFeatureFlag("enableLicensing", {
        defaults: { all: true, production: false }
      })
    };
    pointerCaptureTrackingObject = createDebugValue("pointerCaptureTrackingObject", {
      defaults: { all: /* @__PURE__ */ new Map() },
      shouldStoreForSession: false
    });
    debugFlags = {
      logPreventDefaults: createDebugValue("logPreventDefaults", {
        defaults: { all: false }
      }),
      logPointerCaptures: createDebugValue("logPointerCaptures", {
        defaults: { all: false }
      }),
      logElementRemoves: createDebugValue("logElementRemoves", {
        defaults: { all: false }
      }),
      debugSvg: createDebugValue("debugSvg", {
        defaults: { all: false }
      }),
      showFps: createDebugValue("showFps", {
        defaults: { all: false }
      }),
      measurePerformance: createDebugValue("measurePerformance", { defaults: { all: false } }),
      throwToBlob: createDebugValue("throwToBlob", {
        defaults: { all: false }
      }),
      reconnectOnPing: createDebugValue("reconnectOnPing", {
        defaults: { all: false }
      }),
      debugCursors: createDebugValue("debugCursors", {
        defaults: { all: false }
      }),
      forceSrgb: createDebugValue("forceSrgbColors", { defaults: { all: false } }),
      debugGeometry: createDebugValue("debugGeometry", { defaults: { all: false } }),
      hideShapes: createDebugValue("hideShapes", { defaults: { all: false } }),
      editOnType: createDebugValue("editOnType", { defaults: { all: false } })
    };
    if (typeof Element !== "undefined") {
      const nativeElementRemoveChild = Element.prototype.removeChild;
      react("element removal logging", () => {
        if (debugFlags.logElementRemoves.get()) {
          Element.prototype.removeChild = function(child) {
            console.warn("[tldraw] removing child:", child);
            return nativeElementRemoveChild.call(this, child);
          };
        } else {
          Element.prototype.removeChild = nativeElementRemoveChild;
        }
      });
    }
  }
});

// node_modules/@tldraw/store/dist-esm/lib/IncrementalSetConstructor.mjs
var IncrementalSetConstructor;
var init_IncrementalSetConstructor = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/IncrementalSetConstructor.mjs"() {
    IncrementalSetConstructor = class {
      constructor(previousValue) {
        __publicField(this, "nextValue");
        __publicField(this, "diff");
        this.previousValue = previousValue;
      }
      get() {
        const numRemoved = this.diff?.removed?.size ?? 0;
        const numAdded = this.diff?.added?.size ?? 0;
        if (numRemoved === 0 && numAdded === 0) {
          return void 0;
        }
        return { value: this.nextValue, diff: this.diff };
      }
      _add(item, wasAlreadyPresent) {
        var _a;
        this.nextValue ?? (this.nextValue = new Set(this.previousValue));
        this.nextValue.add(item);
        this.diff ?? (this.diff = {});
        if (wasAlreadyPresent) {
          this.diff.removed?.delete(item);
        } else {
          (_a = this.diff).added ?? (_a.added = /* @__PURE__ */ new Set());
          this.diff.added.add(item);
        }
      }
      add(item) {
        const wasAlreadyPresent = this.previousValue.has(item);
        if (wasAlreadyPresent) {
          const wasRemoved = this.diff?.removed?.has(item);
          if (!wasRemoved)
            return;
          return this._add(item, wasAlreadyPresent);
        }
        const isCurrentlyPresent = this.nextValue?.has(item);
        if (isCurrentlyPresent)
          return;
        this._add(item, wasAlreadyPresent);
      }
      _remove(item, wasAlreadyPresent) {
        var _a;
        this.nextValue ?? (this.nextValue = new Set(this.previousValue));
        this.nextValue.delete(item);
        this.diff ?? (this.diff = {});
        if (wasAlreadyPresent) {
          (_a = this.diff).removed ?? (_a.removed = /* @__PURE__ */ new Set());
          this.diff.removed.add(item);
        } else {
          this.diff.added?.delete(item);
        }
      }
      remove(item) {
        const wasAlreadyPresent = this.previousValue.has(item);
        if (!wasAlreadyPresent) {
          const wasAdded = this.diff?.added?.has(item);
          if (!wasAdded)
            return;
          return this._remove(item, wasAlreadyPresent);
        }
        const hasAlreadyBeenRemoved = this.diff?.removed?.has(item);
        if (hasAlreadyBeenRemoved)
          return;
        this._remove(item, wasAlreadyPresent);
      }
    };
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs
var PERFORMANCE_COLORS2, PERFORMANCE_PREFIX_COLOR2;
var init_perf2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs"() {
    PERFORMANCE_COLORS2 = {
      Good: "#40C057",
      Mid: "#FFC078",
      Poor: "#E03131"
    };
    PERFORMANCE_PREFIX_COLOR2 = PERFORMANCE_COLORS2.Good;
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs
var init_PerformanceTracker2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs"() {
    init_perf2();
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/array.mjs
var init_array2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/array.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs
var WeakCache2;
var init_cache2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs"() {
    WeakCache2 = class {
      constructor() {
        __publicField(this, "items", /* @__PURE__ */ new WeakMap());
      }
      get(item, cb) {
        if (!this.items.has(item)) {
          this.items.set(item, cb(item));
        }
        return this.items.get(item);
      }
    };
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/function.mjs
function omitFromStackTrace2(fn3) {
  const wrappedFn = (...args) => {
    try {
      return fn3(...args);
    } catch (error2) {
      if (error2 instanceof Error && Error.captureStackTrace) {
        Error.captureStackTrace(error2, wrappedFn);
      }
      throw error2;
    }
  };
  return wrappedFn;
}
var init_function2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/function.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/control.mjs
function exhaustiveSwitchError2(value, property) {
  const debugValue = property && value && typeof value === "object" && property in value ? value[property] : value;
  throw new Error(`Unknown switch case ${debugValue}`);
}
var Result2, assert2, assertExists2;
var init_control2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/control.mjs"() {
    init_function2();
    Result2 = {
      ok(value) {
        return { ok: true, value };
      },
      err(error2) {
        return { ok: false, error: error2 };
      }
    };
    assert2 = omitFromStackTrace2((value, message) => {
      if (!value) {
        throw new Error(message || "Assertion Error");
      }
    });
    assertExists2 = omitFromStackTrace2((value, message) => {
      if (value == null) {
        throw new Error(message ?? "value must be defined");
      }
      return value;
    });
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs
var init_debounce2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/error.mjs
var init_error2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/error.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/network.mjs
var init_network2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/network.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/file.mjs
var init_file2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/file.mjs"() {
    init_network2();
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs
var init_hash2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs
var init_iterable2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs
var init_apng2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs
var init_avif2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs
var init_gif2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs
var TABLE2;
var init_png2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs"() {
    TABLE2 = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    if (typeof Int32Array !== "undefined") {
      TABLE2 = new Int32Array(TABLE2);
    }
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs
var init_webp2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs
var DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES2, DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES2, DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES2, DEFAULT_SUPPORTED_IMAGE_TYPES2, DEFAULT_SUPPORT_VIDEO_TYPES2, DEFAULT_SUPPORTED_MEDIA_TYPE_LIST2;
var init_media2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs"() {
    init_network2();
    init_apng2();
    init_avif2();
    init_gif2();
    init_png2();
    init_webp2();
    DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES2 = Object.freeze(["image/svg+xml"]);
    DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES2 = Object.freeze([
      "image/jpeg",
      "image/png",
      "image/webp"
    ]);
    DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES2 = Object.freeze([
      "image/gif",
      "image/apng",
      "image/avif"
    ]);
    DEFAULT_SUPPORTED_IMAGE_TYPES2 = Object.freeze([
      ...DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES2,
      ...DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES2,
      ...DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES2
    ]);
    DEFAULT_SUPPORT_VIDEO_TYPES2 = Object.freeze([
      "video/mp4",
      "video/webm",
      "video/quicktime"
    ]);
    DEFAULT_SUPPORTED_MEDIA_TYPE_LIST2 = [
      ...DEFAULT_SUPPORTED_IMAGE_TYPES2,
      ...DEFAULT_SUPPORT_VIDEO_TYPES2
    ].join(",");
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/number.mjs
var init_number2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/number.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/object.mjs
function hasOwnProperty2(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}
function getOwnProperty2(obj, key) {
  if (!hasOwnProperty2(obj, key)) {
    return void 0;
  }
  return obj[key];
}
function objectMapKeys2(object2) {
  return Object.keys(object2);
}
function objectMapValues2(object2) {
  return Object.values(object2);
}
function objectMapEntries2(object2) {
  return Object.entries(object2);
}
function objectMapFromEntries2(entries) {
  return Object.fromEntries(entries);
}
function filterEntries2(object2, predicate) {
  const result = {};
  let didChange = false;
  for (const [key, value] of objectMapEntries2(object2)) {
    if (predicate(key, value)) {
      result[key] = value;
    } else {
      didChange = true;
    }
  }
  return didChange ? result : object2;
}
var init_object2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/object.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs
var init_dgreensp2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs
var init_reordering2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs"() {
    init_dgreensp2();
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs
var init_sort2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs
var init_storage3 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs
function tick2() {
  if (frame2) {
    return;
  }
  const now = Date.now();
  const elapsed = now - last3;
  if (time2 + elapsed < targetTimePerFrame2) {
    frame2 = requestAnimationFrame(() => {
      frame2 = void 0;
      tick2();
    });
    return;
  }
  frame2 = requestAnimationFrame(() => {
    frame2 = void 0;
    last3 = now;
    time2 = Math.min(time2 + elapsed - targetTimePerFrame2, targetTimePerFrame2 * 10);
    flush2();
  });
}
function throttleToNextFrame2(fn3) {
  if (isTest2()) {
    fn3();
    return () => {
    };
  }
  if (!fpsQueue2.includes(fn3)) {
    fpsQueue2.push(fn3);
    if (!started2) {
      started2 = true;
      last3 = Date.now() - targetTimePerFrame2 - 1;
    }
    tick2();
  }
  return () => {
    const index3 = fpsQueue2.indexOf(fn3);
    if (index3 > -1) {
      fpsQueue2.splice(index3, 1);
    }
  };
}
var isTest2, fpsQueue2, targetFps2, targetTimePerFrame2, frame2, time2, last3, flush2, started2;
var init_throttle2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs"() {
    isTest2 = () => typeof process !== "undefined" && false;
    fpsQueue2 = [];
    targetFps2 = 60;
    targetTimePerFrame2 = Math.ceil(1e3 / targetFps2);
    time2 = 0;
    last3 = 0;
    flush2 = () => {
      const queue = fpsQueue2.splice(0, fpsQueue2.length);
      for (const fn3 of queue) {
        fn3();
      }
    };
    started2 = false;
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs
var init_timers2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/value.mjs
function getStructuredClone2() {
  if (typeof globalThis !== "undefined" && globalThis.structuredClone) {
    return [globalThis.structuredClone, true];
  }
  if (typeof global !== "undefined" && global.structuredClone) {
    return [global.structuredClone, true];
  }
  if (typeof window !== "undefined" && window.structuredClone) {
    return [window.structuredClone, true];
  }
  return [(i2) => i2 ? JSON.parse(JSON.stringify(i2)) : i2, false];
}
var _structuredClone2, structuredClone3, isNativeStructuredClone2, STRUCTURED_CLONE_OBJECT_PROTOTYPE2;
var init_value2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/value.mjs"() {
    _structuredClone2 = getStructuredClone2();
    structuredClone3 = _structuredClone2[0];
    isNativeStructuredClone2 = _structuredClone2[1];
    STRUCTURED_CLONE_OBJECT_PROTOTYPE2 = Object.getPrototypeOf(structuredClone3({}));
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs
var init_warn2 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs"() {
  }
});

// node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/index.mjs
var import_lodash3, import_lodash4;
var init_dist_esm3 = __esm({
  "node_modules/@tldraw/store/node_modules/@tldraw/utils/dist-esm/index.mjs"() {
    import_lodash3 = __toESM(require_lodash(), 1);
    import_lodash4 = __toESM(require_lodash2(), 1);
    init_PerformanceTracker2();
    init_array2();
    init_cache2();
    init_control2();
    init_debounce2();
    init_error2();
    init_file2();
    init_function2();
    init_hash2();
    init_iterable2();
    init_media2();
    init_png2();
    init_network2();
    init_number2();
    init_object2();
    init_perf2();
    init_reordering2();
    init_sort2();
    init_storage3();
    init_throttle2();
    init_timers2();
    init_value2();
    init_warn2();
  }
});

// node_modules/@tldraw/store/node_modules/nanoid/index.browser.js
var nanoid;
var init_index_browser = __esm({
  "node_modules/@tldraw/store/node_modules/nanoid/index.browser.js"() {
    nanoid = (size4 = 21) => crypto.getRandomValues(new Uint8Array(size4)).reduce((id, byte) => {
      byte &= 63;
      if (byte < 36) {
        id += byte.toString(36);
      } else if (byte < 62) {
        id += (byte - 26).toString(36).toUpperCase();
      } else if (byte > 62) {
        id += "-";
      } else {
        id += "_";
      }
      return id;
    }, "");
  }
});

// node_modules/@tldraw/store/dist-esm/lib/RecordType.mjs
function createRecordType(typeName, config) {
  return new RecordType(typeName, {
    createDefaultProperties: () => ({}),
    validator: config.validator,
    scope: config.scope,
    ephemeralKeys: config.ephemeralKeys
  });
}
var RecordType;
var init_RecordType = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/RecordType.mjs"() {
    init_dist_esm3();
    init_index_browser();
    RecordType = class {
      constructor(typeName, config) {
        __publicField(this, "createDefaultProperties");
        __publicField(this, "validator");
        __publicField(this, "ephemeralKeys");
        __publicField(this, "ephemeralKeySet");
        __publicField(this, "scope");
        __publicField(this, "isInstance", (record) => {
          return record?.typeName === this.typeName;
        });
        this.typeName = typeName;
        this.createDefaultProperties = config.createDefaultProperties;
        this.validator = config.validator ?? { validate: (r2) => r2 };
        this.scope = config.scope ?? "document";
        this.ephemeralKeys = config.ephemeralKeys;
        const ephemeralKeySet = /* @__PURE__ */ new Set();
        if (config.ephemeralKeys) {
          for (const [key, isEphemeral] of objectMapEntries2(config.ephemeralKeys)) {
            if (isEphemeral)
              ephemeralKeySet.add(key);
          }
        }
        this.ephemeralKeySet = ephemeralKeySet;
      }
      create(properties) {
        const result = { ...this.createDefaultProperties(), id: this.createId() };
        for (const [k2, v2] of Object.entries(properties)) {
          if (v2 !== void 0) {
            result[k2] = v2;
          }
        }
        result.typeName = this.typeName;
        return result;
      }
      clone(record) {
        return { ...structuredClone3(record), id: this.createId() };
      }
      createId(customUniquePart) {
        return this.typeName + ":" + (customUniquePart ?? nanoid());
      }
      createCustomId(id) {
        return this.typeName + ":" + id;
      }
      parseId(id) {
        if (!this.isId(id)) {
          throw new Error(`ID "${id}" is not a valid ID for type "${this.typeName}"`);
        }
        return id.slice(this.typeName.length + 1);
      }
      isId(id) {
        if (!id)
          return false;
        for (let i2 = 0; i2 < this.typeName.length; i2++) {
          if (id[i2] !== this.typeName[i2])
            return false;
        }
        return id[this.typeName.length] === ":";
      }
      withDefaultProperties(createDefaultProperties) {
        return new RecordType(this.typeName, {
          createDefaultProperties,
          validator: this.validator,
          scope: this.scope,
          ephemeralKeys: this.ephemeralKeys
        });
      }
      validate(record, recordBefore) {
        if (recordBefore && this.validator.validateUsingKnownGoodVersion) {
          return this.validator.validateUsingKnownGoodVersion(recordBefore, record);
        }
        return this.validator.validate(record);
      }
    };
  }
});

// node_modules/@tldraw/store/dist-esm/lib/RecordsDiff.mjs
function createEmptyRecordsDiff() {
  return { added: {}, updated: {}, removed: {} };
}
function reverseRecordsDiff(diff) {
  const result = { added: diff.removed, removed: diff.added, updated: {} };
  for (const [from, to] of Object.values(diff.updated)) {
    result.updated[from.id] = [to, from];
  }
  return result;
}
function isRecordsDiffEmpty(diff) {
  return Object.keys(diff.added).length === 0 && Object.keys(diff.updated).length === 0 && Object.keys(diff.removed).length === 0;
}
function squashRecordDiffs(diffs) {
  const result = { added: {}, removed: {}, updated: {} };
  squashRecordDiffsMutable(result, diffs);
  return result;
}
function squashRecordDiffsMutable(target, diffs) {
  for (const diff of diffs) {
    for (const [id, value] of objectMapEntries2(diff.added)) {
      if (target.removed[id]) {
        const original = target.removed[id];
        delete target.removed[id];
        if (original !== value) {
          target.updated[id] = [original, value];
        }
      } else {
        target.added[id] = value;
      }
    }
    for (const [id, [_from, to]] of objectMapEntries2(diff.updated)) {
      if (target.added[id]) {
        target.added[id] = to;
        delete target.updated[id];
        delete target.removed[id];
        continue;
      }
      if (target.updated[id]) {
        target.updated[id] = [target.updated[id][0], to];
        delete target.removed[id];
        continue;
      }
      target.updated[id] = diff.updated[id];
      delete target.removed[id];
    }
    for (const [id, value] of objectMapEntries2(diff.removed)) {
      if (target.added[id]) {
        delete target.added[id];
      } else if (target.updated[id]) {
        target.removed[id] = target.updated[id][0];
        delete target.updated[id];
      } else {
        target.removed[id] = value;
      }
    }
  }
}
var init_RecordsDiff = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/RecordsDiff.mjs"() {
    init_dist_esm3();
  }
});

// node_modules/lodash.isequal/index.js
var require_lodash3 = __commonJS({
  "node_modules/lodash.isequal/index.js"(exports, module2) {
    var LARGE_ARRAY_SIZE = 200;
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var COMPARE_PARTIAL_FLAG = 1;
    var COMPARE_UNORDERED_FLAG = 2;
    var MAX_SAFE_INTEGER = 9007199254740991;
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var asyncTag = "[object AsyncFunction]";
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var nullTag = "[object Null]";
    var objectTag = "[object Object]";
    var promiseTag = "[object Promise]";
    var proxyTag = "[object Proxy]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var symbolTag = "[object Symbol]";
    var undefinedTag = "[object Undefined]";
    var weakMapTag = "[object WeakMap]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var freeProcess = moduleExports && freeGlobal.process;
    var nodeUtil = function() {
      try {
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e2) {
      }
    }();
    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
    function arrayFilter(array2, predicate) {
      var index3 = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = [];
      while (++index3 < length) {
        var value = array2[index3];
        if (predicate(value, index3, array2)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    function arrayPush(array2, values) {
      var index3 = -1, length = values.length, offset5 = array2.length;
      while (++index3 < length) {
        array2[offset5 + index3] = values[index3];
      }
      return array2;
    }
    function arraySome(array2, predicate) {
      var index3 = -1, length = array2 == null ? 0 : array2.length;
      while (++index3 < length) {
        if (predicate(array2[index3], index3, array2)) {
          return true;
        }
      }
      return false;
    }
    function baseTimes(n2, iteratee) {
      var index3 = -1, result = Array(n2);
      while (++index3 < n2) {
        result[index3] = iteratee(index3);
      }
      return result;
    }
    function baseUnary(func) {
      return function(value) {
        return func(value);
      };
    }
    function cacheHas(cache, key) {
      return cache.has(key);
    }
    function getValue(object2, key) {
      return object2 == null ? void 0 : object2[key];
    }
    function mapToArray(map) {
      var index3 = -1, result = Array(map.size);
      map.forEach(function(value, key) {
        result[++index3] = [key, value];
      });
      return result;
    }
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }
    function setToArray(set) {
      var index3 = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index3] = value;
      });
      return result;
    }
    var arrayProto = Array.prototype;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var coreJsData = root["__core-js_shared__"];
    var funcToString = funcProto.toString;
    var hasOwnProperty5 = objectProto.hasOwnProperty;
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    var nativeObjectToString = objectProto.toString;
    var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty5).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
    var Buffer2 = moduleExports ? root.Buffer : void 0;
    var Symbol2 = root.Symbol;
    var Uint8Array2 = root.Uint8Array;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var splice = arrayProto.splice;
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
    var nativeKeys = overArg(Object.keys, Object);
    var DataView2 = getNative(root, "DataView");
    var Map2 = getNative(root, "Map");
    var Promise2 = getNative(root, "Promise");
    var Set2 = getNative(root, "Set");
    var WeakMap2 = getNative(root, "WeakMap");
    var nativeCreate = getNative(Object, "create");
    var dataViewCtorString = toSource(DataView2);
    var mapCtorString = toSource(Map2);
    var promiseCtorString = toSource(Promise2);
    var setCtorString = toSource(Set2);
    var weakMapCtorString = toSource(WeakMap2);
    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    function Hash(entries) {
      var index3 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }
    function hashDelete(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty5.call(data, key) ? data[key] : void 0;
    }
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty5.call(data, key);
    }
    function hashSet(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    function ListCache(entries) {
      var index3 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }
    function listCacheDelete(key) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      if (index3 < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index3 == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index3, 1);
      }
      --this.size;
      return true;
    }
    function listCacheGet(key) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      return index3 < 0 ? void 0 : data[index3][1];
    }
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    function listCacheSet(key, value) {
      var data = this.__data__, index3 = assocIndexOf(data, key);
      if (index3 < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index3][1] = value;
      }
      return this;
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    function MapCache(entries) {
      var index3 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index3 < length) {
        var entry = entries[index3];
        this.set(entry[0], entry[1]);
      }
    }
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    function mapCacheDelete(key) {
      var result = getMapData(this, key)["delete"](key);
      this.size -= result ? 1 : 0;
      return result;
    }
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    function mapCacheSet(key, value) {
      var data = getMapData(this, key), size4 = data.size;
      data.set(key, value);
      this.size += data.size == size4 ? 0 : 1;
      return this;
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    function SetCache(values) {
      var index3 = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache();
      while (++index3 < length) {
        this.add(values[index3]);
      }
    }
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    function Stack(entries) {
      var data = this.__data__ = new ListCache(entries);
      this.size = data.size;
    }
    function stackClear() {
      this.__data__ = new ListCache();
      this.size = 0;
    }
    function stackDelete(key) {
      var data = this.__data__, result = data["delete"](key);
      this.size = data.size;
      return result;
    }
    function stackGet(key) {
      return this.__data__.get(key);
    }
    function stackHas(key) {
      return this.__data__.has(key);
    }
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }
    Stack.prototype.clear = stackClear;
    Stack.prototype["delete"] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType2 = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType2, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
      for (var key in value) {
        if ((inherited || hasOwnProperty5.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType2 && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
    function assocIndexOf(array2, key) {
      var length = array2.length;
      while (length--) {
        if (eq(array2[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    function baseGetAllKeys(object2, keysFunc, symbolsFunc) {
      var result = keysFunc(object2);
      return isArray(object2) ? result : arrayPush(result, symbolsFunc(object2));
    }
    function baseGetTag(value) {
      if (value == null) {
        return value === void 0 ? undefinedTag : nullTag;
      }
      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
    }
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag;
    }
    function baseIsEqual(value, other, bitmask, customizer, stack2) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack2);
    }
    function baseIsEqualDeep(object2, other, bitmask, customizer, equalFunc, stack2) {
      var objIsArr = isArray(object2), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object2), othTag = othIsArr ? arrayTag : getTag(other);
      objTag = objTag == argsTag ? objectTag : objTag;
      othTag = othTag == argsTag ? objectTag : othTag;
      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
      if (isSameTag && isBuffer(object2)) {
        if (!isBuffer(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack2 || (stack2 = new Stack());
        return objIsArr || isTypedArray(object2) ? equalArrays(object2, other, bitmask, customizer, equalFunc, stack2) : equalByTag(object2, other, objTag, bitmask, customizer, equalFunc, stack2);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
        var objIsWrapped = objIsObj && hasOwnProperty5.call(object2, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty5.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object2.value() : object2, othUnwrapped = othIsWrapped ? other.value() : other;
          stack2 || (stack2 = new Stack());
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack2);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack2 || (stack2 = new Stack());
      return equalObjects(object2, other, bitmask, customizer, equalFunc, stack2);
    }
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    function baseIsTypedArray(value) {
      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
    }
    function baseKeys(object2) {
      if (!isPrototype(object2)) {
        return nativeKeys(object2);
      }
      var result = [];
      for (var key in Object(object2)) {
        if (hasOwnProperty5.call(object2, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    function equalArrays(array2, other, bitmask, customizer, equalFunc, stack2) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array2.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var stacked = stack2.get(array2);
      if (stacked && stack2.get(other)) {
        return stacked == other;
      }
      var index3 = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
      stack2.set(array2, other);
      stack2.set(other, array2);
      while (++index3 < arrLength) {
        var arrValue = array2[index3], othValue = other[index3];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index3, other, array2, stack2) : customizer(arrValue, othValue, index3, array2, other, stack2);
        }
        if (compared !== void 0) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        if (seen) {
          if (!arraySome(other, function(othValue2, othIndex) {
            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack2))) {
              return seen.push(othIndex);
            }
          })) {
            result = false;
            break;
          }
        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack2))) {
          result = false;
          break;
        }
      }
      stack2["delete"](array2);
      stack2["delete"](other);
      return result;
    }
    function equalByTag(object2, other, tag, bitmask, customizer, equalFunc, stack2) {
      switch (tag) {
        case dataViewTag:
          if (object2.byteLength != other.byteLength || object2.byteOffset != other.byteOffset) {
            return false;
          }
          object2 = object2.buffer;
          other = other.buffer;
        case arrayBufferTag:
          if (object2.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object2), new Uint8Array2(other))) {
            return false;
          }
          return true;
        case boolTag:
        case dateTag:
        case numberTag:
          return eq(+object2, +other);
        case errorTag:
          return object2.name == other.name && object2.message == other.message;
        case regexpTag:
        case stringTag:
          return object2 == other + "";
        case mapTag:
          var convert2 = mapToArray;
        case setTag:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
          convert2 || (convert2 = setToArray);
          if (object2.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack2.get(object2);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG;
          stack2.set(object2, other);
          var result = equalArrays(convert2(object2), convert2(other), bitmask, customizer, equalFunc, stack2);
          stack2["delete"](object2);
          return result;
        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object2) == symbolValueOf.call(other);
          }
      }
      return false;
    }
    function equalObjects(object2, other, bitmask, customizer, equalFunc, stack2) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object2), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index3 = objLength;
      while (index3--) {
        var key = objProps[index3];
        if (!(isPartial ? key in other : hasOwnProperty5.call(other, key))) {
          return false;
        }
      }
      var stacked = stack2.get(object2);
      if (stacked && stack2.get(other)) {
        return stacked == other;
      }
      var result = true;
      stack2.set(object2, other);
      stack2.set(other, object2);
      var skipCtor = isPartial;
      while (++index3 < objLength) {
        key = objProps[index3];
        var objValue = object2[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object2, stack2) : customizer(objValue, othValue, key, object2, other, stack2);
        }
        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack2) : compared)) {
          result = false;
          break;
        }
        skipCtor || (skipCtor = key == "constructor");
      }
      if (result && !skipCtor) {
        var objCtor = object2.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object2 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack2["delete"](object2);
      stack2["delete"](other);
      return result;
    }
    function getAllKeys(object2) {
      return baseGetAllKeys(object2, keys, getSymbols);
    }
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    function getNative(object2, key) {
      var value = getValue(object2, key);
      return baseIsNative(value) ? value : void 0;
    }
    function getRawTag(value) {
      var isOwn = hasOwnProperty5.call(value, symToStringTag), tag = value[symToStringTag];
      try {
        value[symToStringTag] = void 0;
        var unmasked = true;
      } catch (e2) {
      }
      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }
    var getSymbols = !nativeGetSymbols ? stubArray : function(object2) {
      if (object2 == null) {
        return [];
      }
      object2 = Object(object2);
      return arrayFilter(nativeGetSymbols(object2), function(symbol) {
        return propertyIsEnumerable.call(object2, symbol);
      });
    };
    var getTag = baseGetTag;
    if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
      getTag = function(value) {
        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag;
            case mapCtorString:
              return mapTag;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag;
            case weakMapCtorString:
              return weakMapTag;
          }
        }
        return result;
      };
    }
    function isIndex(value, length) {
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    function isPrototype(value) {
      var Ctor = value && value.constructor, proto2 = typeof Ctor == "function" && Ctor.prototype || objectProto;
      return value === proto2;
    }
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e2) {
        }
        try {
          return func + "";
        } catch (e2) {
        }
      }
      return "";
    }
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    var isArguments = baseIsArguments(function() {
      return arguments;
    }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
    };
    var isArray = Array.isArray;
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }
    var isBuffer = nativeIsBuffer || stubFalse;
    function isEqual2(value, other) {
      return baseIsEqual(value, other);
    }
    function isFunction(value) {
      if (!isObject(value)) {
        return false;
      }
      var tag = baseGetTag(value);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }
    function isLength(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }
    function isObject(value) {
      var type = typeof value;
      return value != null && (type == "object" || type == "function");
    }
    function isObjectLike(value) {
      return value != null && typeof value == "object";
    }
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
    function keys(object2) {
      return isArrayLike(object2) ? arrayLikeKeys(object2) : baseKeys(object2);
    }
    function stubArray() {
      return [];
    }
    function stubFalse() {
      return false;
    }
    module2.exports = isEqual2;
  }
});

// node_modules/@tldraw/store/dist-esm/lib/setUtils.mjs
function intersectSets(sets) {
  if (sets.length === 0)
    return /* @__PURE__ */ new Set();
  const first = sets[0];
  const rest = sets.slice(1);
  const result = /* @__PURE__ */ new Set();
  for (const val of first) {
    if (rest.every((set) => set.has(val))) {
      result.add(val);
    }
  }
  return result;
}
function diffSets(prev, next) {
  const result = {};
  for (const val of next) {
    if (!prev.has(val)) {
      result.added ?? (result.added = /* @__PURE__ */ new Set());
      result.added.add(val);
    }
  }
  for (const val of prev) {
    if (!next.has(val)) {
      result.removed ?? (result.removed = /* @__PURE__ */ new Set());
      result.removed.add(val);
    }
  }
  return result.added || result.removed ? result : void 0;
}
var init_setUtils = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/setUtils.mjs"() {
  }
});

// node_modules/@tldraw/store/dist-esm/lib/executeQuery.mjs
function objectMatchesQuery(query, object2) {
  for (const [key, _matcher] of Object.entries(query)) {
    const matcher = _matcher;
    const value = object2[key];
    if ("eq" in matcher && value !== matcher.eq)
      return false;
    if ("neq" in matcher && value === matcher.neq)
      return false;
    if ("gt" in matcher && (typeof value !== "number" || value <= matcher.gt))
      return false;
  }
  return true;
}
function executeQuery(store, typeName, query) {
  const matchIds = Object.fromEntries(Object.keys(query).map((key) => [key, /* @__PURE__ */ new Set()]));
  for (const [k2, matcher] of Object.entries(query)) {
    if ("eq" in matcher) {
      const index3 = store.index(typeName, k2);
      const ids = index3.get().get(matcher.eq);
      if (ids) {
        for (const id of ids) {
          matchIds[k2].add(id);
        }
      }
    } else if ("neq" in matcher) {
      const index3 = store.index(typeName, k2);
      for (const [value, ids] of index3.get()) {
        if (value !== matcher.neq) {
          for (const id of ids) {
            matchIds[k2].add(id);
          }
        }
      }
    } else if ("gt" in matcher) {
      const index3 = store.index(typeName, k2);
      for (const [value, ids] of index3.get()) {
        if (value > matcher.gt) {
          for (const id of ids) {
            matchIds[k2].add(id);
          }
        }
      }
    }
  }
  return intersectSets(Object.values(matchIds));
}
var init_executeQuery = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/executeQuery.mjs"() {
    init_setUtils();
  }
});

// node_modules/@tldraw/store/dist-esm/lib/StoreQueries.mjs
var import_lodash5, StoreQueries;
var init_StoreQueries = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/StoreQueries.mjs"() {
    init_dist_esm();
    init_dist_esm3();
    import_lodash5 = __toESM(require_lodash3(), 1);
    init_executeQuery();
    init_IncrementalSetConstructor();
    init_setUtils();
    StoreQueries = class {
      constructor(atoms, history) {
        __publicField(this, "indexCache", /* @__PURE__ */ new Map());
        __publicField(this, "historyCache", /* @__PURE__ */ new Map());
        this.atoms = atoms;
        this.history = history;
      }
      filterHistory(typeName) {
        if (this.historyCache.has(typeName)) {
          return this.historyCache.get(typeName);
        }
        const filtered = computed("filterHistory:" + typeName, (lastValue, lastComputedEpoch) => {
          if (isUninitialized(lastValue)) {
            return this.history.get();
          }
          const diff = this.history.getDiffSince(lastComputedEpoch);
          if (diff === RESET_VALUE)
            return this.history.get();
          const res = { added: {}, removed: {}, updated: {} };
          let numAdded = 0;
          let numRemoved = 0;
          let numUpdated = 0;
          for (const changes of diff) {
            for (const added of objectMapValues2(changes.added)) {
              if (added.typeName === typeName) {
                if (res.removed[added.id]) {
                  const original = res.removed[added.id];
                  delete res.removed[added.id];
                  numRemoved--;
                  if (original !== added) {
                    res.updated[added.id] = [original, added];
                    numUpdated++;
                  }
                } else {
                  res.added[added.id] = added;
                  numAdded++;
                }
              }
            }
            for (const [from, to] of objectMapValues2(changes.updated)) {
              if (to.typeName === typeName) {
                if (res.added[to.id]) {
                  res.added[to.id] = to;
                } else if (res.updated[to.id]) {
                  res.updated[to.id] = [res.updated[to.id][0], to];
                } else {
                  res.updated[to.id] = [from, to];
                  numUpdated++;
                }
              }
            }
            for (const removed of objectMapValues2(changes.removed)) {
              if (removed.typeName === typeName) {
                if (res.added[removed.id]) {
                  delete res.added[removed.id];
                  numAdded--;
                } else if (res.updated[removed.id]) {
                  res.removed[removed.id] = res.updated[removed.id][0];
                  delete res.updated[removed.id];
                  numUpdated--;
                  numRemoved++;
                } else {
                  res.removed[removed.id] = removed;
                  numRemoved++;
                }
              }
            }
          }
          if (numAdded || numRemoved || numUpdated) {
            return withDiff(this.history.get(), res);
          } else {
            return lastValue;
          }
        }, { historyLength: 100 });
        this.historyCache.set(typeName, filtered);
        return filtered;
      }
      index(typeName, property) {
        const cacheKey = typeName + ":" + property;
        if (this.indexCache.has(cacheKey)) {
          return this.indexCache.get(cacheKey);
        }
        const index3 = this.__uncached_createIndex(typeName, property);
        this.indexCache.set(cacheKey, index3);
        return index3;
      }
      __uncached_createIndex(typeName, property) {
        const typeHistory = this.filterHistory(typeName);
        const fromScratch = () => {
          typeHistory.get();
          const res = /* @__PURE__ */ new Map();
          for (const atom3 of objectMapValues2(this.atoms.get())) {
            const record = atom3.get();
            if (record.typeName === typeName) {
              const value = record[property];
              if (!res.has(value)) {
                res.set(value, /* @__PURE__ */ new Set());
              }
              res.get(value).add(record.id);
            }
          }
          return res;
        };
        return computed("index:" + typeName + ":" + property, (prevValue, lastComputedEpoch) => {
          if (isUninitialized(prevValue))
            return fromScratch();
          const history = typeHistory.getDiffSince(lastComputedEpoch);
          if (history === RESET_VALUE) {
            return fromScratch();
          }
          const setConstructors = /* @__PURE__ */ new Map();
          const add = (value, id) => {
            let setConstructor = setConstructors.get(value);
            if (!setConstructor)
              setConstructor = new IncrementalSetConstructor(prevValue.get(value) ?? /* @__PURE__ */ new Set());
            setConstructor.add(id);
            setConstructors.set(value, setConstructor);
          };
          const remove2 = (value, id) => {
            let set = setConstructors.get(value);
            if (!set)
              set = new IncrementalSetConstructor(prevValue.get(value) ?? /* @__PURE__ */ new Set());
            set.remove(id);
            setConstructors.set(value, set);
          };
          for (const changes of history) {
            for (const record of objectMapValues2(changes.added)) {
              if (record.typeName === typeName) {
                const value = record[property];
                add(value, record.id);
              }
            }
            for (const [from, to] of objectMapValues2(changes.updated)) {
              if (to.typeName === typeName) {
                const prev = from[property];
                const next = to[property];
                if (prev !== next) {
                  remove2(prev, to.id);
                  add(next, to.id);
                }
              }
            }
            for (const record of objectMapValues2(changes.removed)) {
              if (record.typeName === typeName) {
                const value = record[property];
                remove2(value, record.id);
              }
            }
          }
          let nextValue = void 0;
          let nextDiff = void 0;
          for (const [value, setConstructor] of setConstructors) {
            const result = setConstructor.get();
            if (!result)
              continue;
            if (!nextValue)
              nextValue = new Map(prevValue);
            if (!nextDiff)
              nextDiff = /* @__PURE__ */ new Map();
            if (result.value.size === 0) {
              nextValue.delete(value);
            } else {
              nextValue.set(value, result.value);
            }
            nextDiff.set(value, result.diff);
          }
          if (nextValue && nextDiff) {
            return withDiff(nextValue, nextDiff);
          }
          return prevValue;
        }, { historyLength: 100 });
      }
      record(typeName, queryCreator = () => ({}), name = "record:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
        const ids = this.ids(typeName, queryCreator, name);
        return computed(name, () => {
          for (const id of ids.get()) {
            return this.atoms.get()[id]?.get();
          }
          return void 0;
        });
      }
      records(typeName, queryCreator = () => ({}), name = "records:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
        const ids = this.ids(typeName, queryCreator, "ids:" + name);
        return computed(name, () => {
          return [...ids.get()].map((id) => {
            const atom3 = this.atoms.get()[id];
            if (!atom3) {
              throw new Error("no atom found for record id: " + id);
            }
            return atom3.get();
          });
        });
      }
      ids(typeName, queryCreator = () => ({}), name = "ids:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
        const typeHistory = this.filterHistory(typeName);
        const fromScratch = () => {
          typeHistory.get();
          const query = queryCreator();
          if (Object.keys(query).length === 0) {
            return new Set(objectMapValues2(this.atoms.get()).flatMap((v2) => {
              const r2 = v2.get();
              if (r2.typeName === typeName) {
                return r2.id;
              } else {
                return [];
              }
            }));
          }
          return executeQuery(this, typeName, query);
        };
        const fromScratchWithDiff = (prevValue) => {
          const nextValue = fromScratch();
          const diff = diffSets(prevValue, nextValue);
          if (diff) {
            return withDiff(nextValue, diff);
          } else {
            return prevValue;
          }
        };
        const cachedQuery = computed("ids_query:" + name, queryCreator, {
          isEqual: import_lodash5.default
        });
        return computed("query:" + name, (prevValue, lastComputedEpoch) => {
          const query = cachedQuery.get();
          if (isUninitialized(prevValue)) {
            return fromScratch();
          }
          if (lastComputedEpoch < cachedQuery.lastChangedEpoch) {
            return fromScratchWithDiff(prevValue);
          }
          const history = typeHistory.getDiffSince(lastComputedEpoch);
          if (history === RESET_VALUE) {
            return fromScratchWithDiff(prevValue);
          }
          const setConstructor = new IncrementalSetConstructor(prevValue);
          for (const changes of history) {
            for (const added of objectMapValues2(changes.added)) {
              if (added.typeName === typeName && objectMatchesQuery(query, added)) {
                setConstructor.add(added.id);
              }
            }
            for (const [_2, updated] of objectMapValues2(changes.updated)) {
              if (updated.typeName === typeName) {
                if (objectMatchesQuery(query, updated)) {
                  setConstructor.add(updated.id);
                } else {
                  setConstructor.remove(updated.id);
                }
              }
            }
            for (const removed of objectMapValues2(changes.removed)) {
              if (removed.typeName === typeName) {
                setConstructor.remove(removed.id);
              }
            }
          }
          const result = setConstructor.get();
          if (!result) {
            return prevValue;
          }
          return withDiff(result.value, result.diff);
        }, { historyLength: 50 });
      }
      exec(typeName, query) {
        const ids = executeQuery(this, typeName, query);
        if (ids.size === 0) {
          return EMPTY_ARRAY;
        }
        const atoms = this.atoms.get();
        return [...ids].map((id) => atoms[id].get());
      }
    };
  }
});

// node_modules/@tldraw/store/dist-esm/lib/StoreSideEffects.mjs
function remove(array2, item) {
  const index3 = array2.indexOf(item);
  if (index3 >= 0) {
    array2.splice(index3, 1);
  }
}
var StoreSideEffects;
var init_StoreSideEffects = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/StoreSideEffects.mjs"() {
    StoreSideEffects = class {
      constructor(store) {
        __publicField(this, "_beforeCreateHandlers", {});
        __publicField(this, "_afterCreateHandlers", {});
        __publicField(this, "_beforeChangeHandlers", {});
        __publicField(this, "_afterChangeHandlers", {});
        __publicField(this, "_beforeDeleteHandlers", {});
        __publicField(this, "_afterDeleteHandlers", {});
        __publicField(this, "_operationCompleteHandlers", []);
        __publicField(this, "_isEnabled", true);
        this.store = store;
      }
      isEnabled() {
        return this._isEnabled;
      }
      setIsEnabled(enabled) {
        this._isEnabled = enabled;
      }
      handleBeforeCreate(record, source) {
        if (!this._isEnabled)
          return record;
        const handlers = this._beforeCreateHandlers[record.typeName];
        if (handlers) {
          let r2 = record;
          for (const handler of handlers) {
            r2 = handler(r2, source);
          }
          return r2;
        }
        return record;
      }
      handleAfterCreate(record, source) {
        if (!this._isEnabled)
          return;
        const handlers = this._afterCreateHandlers[record.typeName];
        if (handlers) {
          for (const handler of handlers) {
            handler(record, source);
          }
        }
      }
      handleBeforeChange(prev, next, source) {
        if (!this._isEnabled)
          return next;
        const handlers = this._beforeChangeHandlers[next.typeName];
        if (handlers) {
          let r2 = next;
          for (const handler of handlers) {
            r2 = handler(prev, r2, source);
          }
          return r2;
        }
        return next;
      }
      handleAfterChange(prev, next, source) {
        if (!this._isEnabled)
          return;
        const handlers = this._afterChangeHandlers[next.typeName];
        if (handlers) {
          for (const handler of handlers) {
            handler(prev, next, source);
          }
        }
      }
      handleBeforeDelete(record, source) {
        if (!this._isEnabled)
          return true;
        const handlers = this._beforeDeleteHandlers[record.typeName];
        if (handlers) {
          for (const handler of handlers) {
            if (handler(record, source) === false) {
              return false;
            }
          }
        }
        return true;
      }
      handleAfterDelete(record, source) {
        if (!this._isEnabled)
          return;
        const handlers = this._afterDeleteHandlers[record.typeName];
        if (handlers) {
          for (const handler of handlers) {
            handler(record, source);
          }
        }
      }
      handleOperationComplete(source) {
        if (!this._isEnabled)
          return;
        for (const handler of this._operationCompleteHandlers) {
          handler(source);
        }
      }
      register(handlersByType) {
        const disposes = [];
        for (const [type, handlers] of Object.entries(handlersByType)) {
          if (handlers?.beforeCreate) {
            disposes.push(this.registerBeforeCreateHandler(type, handlers.beforeCreate));
          }
          if (handlers?.afterCreate) {
            disposes.push(this.registerAfterCreateHandler(type, handlers.afterCreate));
          }
          if (handlers?.beforeChange) {
            disposes.push(this.registerBeforeChangeHandler(type, handlers.beforeChange));
          }
          if (handlers?.afterChange) {
            disposes.push(this.registerAfterChangeHandler(type, handlers.afterChange));
          }
          if (handlers?.beforeDelete) {
            disposes.push(this.registerBeforeDeleteHandler(type, handlers.beforeDelete));
          }
          if (handlers?.afterDelete) {
            disposes.push(this.registerAfterDeleteHandler(type, handlers.afterDelete));
          }
        }
        return () => {
          for (const dispose of disposes)
            dispose();
        };
      }
      registerBeforeCreateHandler(typeName, handler) {
        const handlers = this._beforeCreateHandlers[typeName];
        if (!handlers)
          this._beforeCreateHandlers[typeName] = [];
        this._beforeCreateHandlers[typeName].push(handler);
        return () => remove(this._beforeCreateHandlers[typeName], handler);
      }
      registerAfterCreateHandler(typeName, handler) {
        const handlers = this._afterCreateHandlers[typeName];
        if (!handlers)
          this._afterCreateHandlers[typeName] = [];
        this._afterCreateHandlers[typeName].push(handler);
        return () => remove(this._afterCreateHandlers[typeName], handler);
      }
      registerBeforeChangeHandler(typeName, handler) {
        const handlers = this._beforeChangeHandlers[typeName];
        if (!handlers)
          this._beforeChangeHandlers[typeName] = [];
        this._beforeChangeHandlers[typeName].push(handler);
        return () => remove(this._beforeChangeHandlers[typeName], handler);
      }
      registerAfterChangeHandler(typeName, handler) {
        const handlers = this._afterChangeHandlers[typeName];
        if (!handlers)
          this._afterChangeHandlers[typeName] = [];
        this._afterChangeHandlers[typeName].push(handler);
        return () => remove(this._afterChangeHandlers[typeName], handler);
      }
      registerBeforeDeleteHandler(typeName, handler) {
        const handlers = this._beforeDeleteHandlers[typeName];
        if (!handlers)
          this._beforeDeleteHandlers[typeName] = [];
        this._beforeDeleteHandlers[typeName].push(handler);
        return () => remove(this._beforeDeleteHandlers[typeName], handler);
      }
      registerAfterDeleteHandler(typeName, handler) {
        const handlers = this._afterDeleteHandlers[typeName];
        if (!handlers)
          this._afterDeleteHandlers[typeName] = [];
        this._afterDeleteHandlers[typeName].push(handler);
        return () => remove(this._afterDeleteHandlers[typeName], handler);
      }
      registerOperationCompleteHandler(handler) {
        this._operationCompleteHandlers.push(handler);
        return () => remove(this._operationCompleteHandlers, handler);
      }
    };
  }
});

// node_modules/@tldraw/store/dist-esm/lib/devFreeze.mjs
function devFreeze(object2) {
  if (true) {
    return object2;
  }
  const proto2 = Object.getPrototypeOf(object2);
  if (proto2 && !(Array.isArray(object2) || proto2 === Object.prototype || proto2 === null || proto2 === STRUCTURED_CLONE_OBJECT_PROTOTYPE2)) {
    console.error("cannot include non-js data in a record", object2);
    throw new Error("cannot include non-js data in a record");
  }
  const propNames = Object.getOwnPropertyNames(object2);
  for (const name of propNames) {
    const value = object2[name];
    if (value && typeof value === "object") {
      devFreeze(value);
    }
  }
  return Object.freeze(object2);
}
var init_devFreeze = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/devFreeze.mjs"() {
    init_dist_esm3();
  }
});

// node_modules/@tldraw/store/dist-esm/lib/Store.mjs
function squashHistoryEntries(entries) {
  if (entries.length === 0)
    return [];
  const chunked = [];
  let chunk = [entries[0]];
  let entry;
  for (let i2 = 1, n2 = entries.length; i2 < n2; i2++) {
    entry = entries[i2];
    if (chunk[0].source !== entry.source) {
      chunked.push(chunk);
      chunk = [];
    }
    chunk.push(entry);
  }
  chunked.push(chunk);
  return devFreeze(chunked.map((chunk2) => ({
    source: chunk2[0].source,
    changes: squashRecordDiffs(chunk2.map((e2) => e2.changes))
  })));
}
function createComputedCache(name, derive, isEqual2) {
  const cache = new WeakCache2();
  return {
    get(context, id) {
      const computedCache = cache.get(context, () => {
        const store = context instanceof Store ? context : context.store;
        return store.createComputedCache(name, (record) => derive(context, record), isEqual2);
      });
      return computedCache.get(id);
    }
  };
}
var Store, HistoryAccumulator;
var init_Store = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/Store.mjs"() {
    init_dist_esm();
    init_dist_esm3();
    init_index_browser();
    init_RecordsDiff();
    init_StoreQueries();
    init_StoreSideEffects();
    init_devFreeze();
    Store = class {
      constructor(config) {
        __publicField(this, "id");
        __publicField(this, "atoms", atom2("store_atoms", {}));
        __publicField(this, "history", atom2("history", 0, {
          historyLength: 1e3
        }));
        __publicField(this, "query", new StoreQueries(this.atoms, this.history));
        __publicField(this, "listeners", /* @__PURE__ */ new Set());
        __publicField(this, "historyAccumulator", new HistoryAccumulator());
        __publicField(this, "historyReactor");
        __publicField(this, "cancelHistoryReactor", () => {
        });
        __publicField(this, "schema");
        __publicField(this, "props");
        __publicField(this, "scopedTypes");
        __publicField(this, "sideEffects", new StoreSideEffects(this));
        __publicField(this, "put", (records, phaseOverride) => {
          this.atomic(() => {
            const updates = {};
            const additions = {};
            const currentMap = this.atoms.__unsafe__getWithoutCapture();
            let map = null;
            let record;
            let didChange = false;
            const source = this.isMergingRemoteChanges ? "remote" : "user";
            for (let i2 = 0, n2 = records.length; i2 < n2; i2++) {
              record = records[i2];
              const recordAtom = (map ?? currentMap)[record.id];
              if (recordAtom) {
                const initialValue = recordAtom.__unsafe__getWithoutCapture();
                record = this.sideEffects.handleBeforeChange(initialValue, record, source);
                const validated = this.schema.validateRecord(this, record, phaseOverride ?? "updateRecord", initialValue);
                if (validated === initialValue)
                  continue;
                recordAtom.set(devFreeze(record));
                didChange = true;
                const updated = recordAtom.__unsafe__getWithoutCapture();
                updates[record.id] = [initialValue, updated];
                this.addDiffForAfterEvent(initialValue, updated);
              } else {
                record = this.sideEffects.handleBeforeCreate(record, source);
                didChange = true;
                record = this.schema.validateRecord(this, record, phaseOverride ?? "createRecord", null);
                additions[record.id] = record;
                this.addDiffForAfterEvent(null, record);
                if (!map) {
                  map = { ...currentMap };
                }
                map[record.id] = atom2("atom:" + record.id, record);
              }
            }
            if (map) {
              this.atoms.set(map);
            }
            if (!didChange)
              return;
            this.updateHistory({
              added: additions,
              updated: updates,
              removed: {}
            });
          });
        });
        __publicField(this, "remove", (ids) => {
          this.atomic(() => {
            const cancelled = /* @__PURE__ */ new Set();
            const source = this.isMergingRemoteChanges ? "remote" : "user";
            if (this.sideEffects.isEnabled()) {
              for (const id of ids) {
                const atom22 = this.atoms.__unsafe__getWithoutCapture()[id];
                if (!atom22)
                  continue;
                if (this.sideEffects.handleBeforeDelete(atom22.get(), source) === false) {
                  cancelled.add(id);
                }
              }
            }
            let removed = void 0;
            this.atoms.update((atoms) => {
              let result = void 0;
              for (const id of ids) {
                if (cancelled.has(id))
                  continue;
                if (!(id in atoms))
                  continue;
                if (!result)
                  result = { ...atoms };
                if (!removed)
                  removed = {};
                delete result[id];
                const record = atoms[id].get();
                removed[id] = record;
                this.addDiffForAfterEvent(record, null);
              }
              return result ?? atoms;
            });
            if (!removed)
              return;
            this.updateHistory({ added: {}, updated: {}, removed });
          });
        });
        __publicField(this, "get", (id) => {
          return this.atoms.get()[id]?.get();
        });
        __publicField(this, "unsafeGetWithoutCapture", (id) => {
          return this.atoms.__unsafe__getWithoutCapture()[id]?.__unsafe__getWithoutCapture();
        });
        __publicField(this, "serialize", (scope = "document") => {
          const result = {};
          for (const [id, atom22] of objectMapEntries2(this.atoms.get())) {
            const record = atom22.get();
            if (scope === "all" || this.scopedTypes[scope].has(record.typeName)) {
              result[id] = record;
            }
          }
          return result;
        });
        __publicField(this, "allRecords", () => {
          return objectMapValues2(this.atoms.get()).map((atom22) => atom22.get());
        });
        __publicField(this, "clear", () => {
          this.remove(objectMapKeys2(this.atoms.get()));
        });
        __publicField(this, "update", (id, updater) => {
          const atom22 = this.atoms.get()[id];
          if (!atom22) {
            console.error(`Record ${id} not found. This is probably an error`);
            return;
          }
          this.put([updater(atom22.__unsafe__getWithoutCapture())]);
        });
        __publicField(this, "has", (id) => {
          return !!this.atoms.get()[id];
        });
        __publicField(this, "listen", (onHistory, filters) => {
          this._flushHistory();
          const listener = {
            onHistory,
            filters: {
              source: filters?.source ?? "all",
              scope: filters?.scope ?? "all"
            }
          };
          this.listeners.add(listener);
          if (!this.historyReactor.scheduler.isActivelyListening) {
            this.historyReactor.start();
          }
          return () => {
            this.listeners.delete(listener);
            if (this.listeners.size === 0) {
              this.historyReactor.stop();
            }
          };
        });
        __publicField(this, "isMergingRemoteChanges", false);
        __publicField(this, "mergeRemoteChanges", (fn3) => {
          if (this.isMergingRemoteChanges) {
            return fn3();
          }
          if (this._isInAtomicOp) {
            throw new Error("Cannot merge remote changes while in atomic operation");
          }
          try {
            this.isMergingRemoteChanges = true;
            transact(fn3);
          } finally {
            this.isMergingRemoteChanges = false;
          }
        });
        __publicField(this, "createComputedCache", (name, derive, isEqual2) => {
          const cache = new WeakCache2();
          return {
            get: (id) => {
              const atom22 = this.atoms.get()[id];
              if (!atom22) {
                return void 0;
              }
              return cache.get(atom22, () => {
                const recordSignal = isEqual2 ? computed(atom22.name + ":equals", () => atom22.get(), { isEqual: isEqual2 }) : atom22;
                return computed(name + ":" + id, () => {
                  return derive(recordSignal.get());
                });
              }).get();
            }
          };
        });
        __publicField(this, "createSelectedComputedCache", (name, selector, derive) => {
          const cache = new WeakCache2();
          return {
            get: (id) => {
              const atom22 = this.atoms.get()[id];
              if (!atom22) {
                return void 0;
              }
              return cache.get(atom22, () => {
                const d2 = computed(name + ":" + id + ":selector", () => selector(atom22.get()));
                return computed(name + ":" + id, () => derive(d2.get()));
              }).get();
            }
          };
        });
        __publicField(this, "_integrityChecker");
        __publicField(this, "_isPossiblyCorrupted", false);
        __publicField(this, "pendingAfterEvents", null);
        __publicField(this, "_isInAtomicOp", false);
        const { initialData, schema, id } = config;
        this.id = id ?? nanoid();
        this.schema = schema;
        this.props = config.props;
        if (initialData) {
          this.atoms.set(objectMapFromEntries2(objectMapEntries2(initialData).map(([id2, record]) => [
            id2,
            atom2("atom:" + id2, devFreeze(this.schema.validateRecord(this, record, "initialize", null)))
          ])));
        }
        this.historyReactor = reactor("Store.historyReactor", () => {
          this.history.get();
          this._flushHistory();
        }, { scheduleEffect: (cb) => this.cancelHistoryReactor = throttleToNextFrame2(cb) });
        this.scopedTypes = {
          document: new Set(objectMapValues2(this.schema.types).filter((t3) => t3.scope === "document").map((t3) => t3.typeName)),
          session: new Set(objectMapValues2(this.schema.types).filter((t3) => t3.scope === "session").map((t3) => t3.typeName)),
          presence: new Set(objectMapValues2(this.schema.types).filter((t3) => t3.scope === "presence").map((t3) => t3.typeName))
        };
      }
      _flushHistory() {
        if (this.historyAccumulator.hasChanges()) {
          const entries = this.historyAccumulator.flush();
          for (const { changes, source } of entries) {
            let instanceChanges = null;
            let documentChanges = null;
            let presenceChanges = null;
            for (const { onHistory, filters } of this.listeners) {
              if (filters.source !== "all" && filters.source !== source) {
                continue;
              }
              if (filters.scope !== "all") {
                if (filters.scope === "document") {
                  documentChanges ?? (documentChanges = this.filterChangesByScope(changes, "document"));
                  if (!documentChanges)
                    continue;
                  onHistory({ changes: documentChanges, source });
                } else if (filters.scope === "session") {
                  instanceChanges ?? (instanceChanges = this.filterChangesByScope(changes, "session"));
                  if (!instanceChanges)
                    continue;
                  onHistory({ changes: instanceChanges, source });
                } else {
                  presenceChanges ?? (presenceChanges = this.filterChangesByScope(changes, "presence"));
                  if (!presenceChanges)
                    continue;
                  onHistory({ changes: presenceChanges, source });
                }
              } else {
                onHistory({ changes, source });
              }
            }
          }
        }
      }
      dispose() {
        this.cancelHistoryReactor();
      }
      filterChangesByScope(change, scope) {
        const result = {
          added: filterEntries2(change.added, (_2, r2) => this.scopedTypes[scope].has(r2.typeName)),
          updated: filterEntries2(change.updated, (_2, r2) => this.scopedTypes[scope].has(r2[1].typeName)),
          removed: filterEntries2(change.removed, (_2, r2) => this.scopedTypes[scope].has(r2.typeName))
        };
        if (Object.keys(result.added).length === 0 && Object.keys(result.updated).length === 0 && Object.keys(result.removed).length === 0) {
          return null;
        }
        return result;
      }
      updateHistory(changes) {
        this.historyAccumulator.add({
          changes,
          source: this.isMergingRemoteChanges ? "remote" : "user"
        });
        if (this.listeners.size === 0) {
          this.historyAccumulator.clear();
        }
        this.history.set(this.history.get() + 1, changes);
      }
      validate(phase2) {
        this.allRecords().forEach((record) => this.schema.validateRecord(this, record, phase2, null));
      }
      getStoreSnapshot(scope = "document") {
        return {
          store: this.serialize(scope),
          schema: this.schema.serialize()
        };
      }
      getSnapshot(scope = "document") {
        console.warn("[tldraw] `Store.getSnapshot` is deprecated and will be removed in a future release. Use `getSnapshot` from the `tldraw` package instead.");
        return this.getStoreSnapshot(scope);
      }
      migrateSnapshot(snapshot) {
        const migrationResult = this.schema.migrateStoreSnapshot(snapshot);
        if (migrationResult.type === "error") {
          throw new Error(`Failed to migrate snapshot: ${migrationResult.reason}`);
        }
        return {
          store: migrationResult.value,
          schema: this.schema.serialize()
        };
      }
      loadStoreSnapshot(snapshot) {
        const migrationResult = this.schema.migrateStoreSnapshot(snapshot);
        if (migrationResult.type === "error") {
          throw new Error(`Failed to migrate snapshot: ${migrationResult.reason}`);
        }
        const prevSideEffectsEnabled = this.sideEffects.isEnabled();
        try {
          this.sideEffects.setIsEnabled(false);
          this.atomic(() => {
            this.clear();
            this.put(Object.values(migrationResult.value));
            this.ensureStoreIsUsable();
          });
        } finally {
          this.sideEffects.setIsEnabled(prevSideEffectsEnabled);
        }
      }
      loadSnapshot(snapshot) {
        console.warn("[tldraw] `Store.loadSnapshot` is deprecated and will be removed in a future release. Use `loadSnapshot` from the 'tldraw' package instead.");
        this.loadStoreSnapshot(snapshot);
      }
      extractingChanges(fn3) {
        const changes = [];
        const dispose = this.historyAccumulator.addInterceptor((entry) => changes.push(entry.changes));
        try {
          transact(fn3);
          return squashRecordDiffs(changes);
        } finally {
          dispose();
        }
      }
      applyDiff(diff, {
        runCallbacks = true,
        ignoreEphemeralKeys = false
      } = {}) {
        this.atomic(() => {
          const toPut = objectMapValues2(diff.added);
          for (const [_from, to] of objectMapValues2(diff.updated)) {
            const type = this.schema.getType(to.typeName);
            if (ignoreEphemeralKeys && type.ephemeralKeySet.size) {
              const existing = this.get(to.id);
              if (!existing) {
                toPut.push(to);
                continue;
              }
              let changed = null;
              for (const [key, value] of Object.entries(to)) {
                if (type.ephemeralKeySet.has(key) || Object.is(value, getOwnProperty2(existing, key))) {
                  continue;
                }
                if (!changed)
                  changed = { ...existing };
                changed[key] = value;
              }
              if (changed)
                toPut.push(changed);
            } else {
              toPut.push(to);
            }
          }
          const toRemove = objectMapKeys2(diff.removed);
          if (toPut.length) {
            this.put(toPut);
          }
          if (toRemove.length) {
            this.remove(toRemove);
          }
        }, runCallbacks);
      }
      ensureStoreIsUsable() {
        this.atomic(() => {
          this._integrityChecker ?? (this._integrityChecker = this.schema.createIntegrityChecker(this));
          this._integrityChecker?.();
        });
      }
      markAsPossiblyCorrupted() {
        this._isPossiblyCorrupted = true;
      }
      isPossiblyCorrupted() {
        return this._isPossiblyCorrupted;
      }
      addDiffForAfterEvent(before, after) {
        assert2(this.pendingAfterEvents, "must be in event operation");
        if (before === after)
          return;
        if (before && after)
          assert2(before.id === after.id);
        if (!before && !after)
          return;
        const id = (before || after).id;
        const existing = this.pendingAfterEvents.get(id);
        if (existing) {
          existing.after = after;
        } else {
          this.pendingAfterEvents.set(id, { before, after });
        }
      }
      flushAtomicCallbacks() {
        let updateDepth = 0;
        const source = this.isMergingRemoteChanges ? "remote" : "user";
        while (this.pendingAfterEvents) {
          const events = this.pendingAfterEvents;
          this.pendingAfterEvents = null;
          if (!this.sideEffects.isEnabled())
            continue;
          updateDepth++;
          if (updateDepth > 100) {
            throw new Error("Maximum store update depth exceeded, bailing out");
          }
          for (const { before, after } of events.values()) {
            if (before && after) {
              this.sideEffects.handleAfterChange(before, after, source);
            } else if (before && !after) {
              this.sideEffects.handleAfterDelete(before, source);
            } else if (!before && after) {
              this.sideEffects.handleAfterCreate(after, source);
            }
          }
          if (!this.pendingAfterEvents) {
            this.sideEffects.handleOperationComplete(source);
          }
        }
      }
      atomic(fn3, runCallbacks = true) {
        return transact(() => {
          if (this._isInAtomicOp) {
            if (!this.pendingAfterEvents)
              this.pendingAfterEvents = /* @__PURE__ */ new Map();
            return fn3();
          }
          this.pendingAfterEvents = /* @__PURE__ */ new Map();
          const prevSideEffectsEnabled = this.sideEffects.isEnabled();
          this.sideEffects.setIsEnabled(runCallbacks ?? prevSideEffectsEnabled);
          this._isInAtomicOp = true;
          try {
            const result = fn3();
            this.flushAtomicCallbacks();
            return result;
          } finally {
            this.pendingAfterEvents = null;
            this.sideEffects.setIsEnabled(prevSideEffectsEnabled);
            this._isInAtomicOp = false;
          }
        });
      }
      addHistoryInterceptor(fn3) {
        return this.historyAccumulator.addInterceptor((entry) => fn3(entry, this.isMergingRemoteChanges ? "remote" : "user"));
      }
    };
    HistoryAccumulator = class {
      constructor() {
        __publicField(this, "_history", []);
        __publicField(this, "_interceptors", /* @__PURE__ */ new Set());
      }
      addInterceptor(fn3) {
        this._interceptors.add(fn3);
        return () => {
          this._interceptors.delete(fn3);
        };
      }
      add(entry) {
        this._history.push(entry);
        for (const interceptor of this._interceptors) {
          interceptor(entry);
        }
      }
      flush() {
        const history = squashHistoryEntries(this._history);
        this._history = [];
        return history;
      }
      clear() {
        this._history = [];
      }
      hasChanges() {
        return this._history.length > 0;
      }
    };
  }
});

// node_modules/@tldraw/store/dist-esm/lib/migrate.mjs
function squashDependsOn(sequence) {
  const result = [];
  for (let i2 = sequence.length - 1; i2 >= 0; i2--) {
    const elem = sequence[i2];
    if (!("id" in elem)) {
      const dependsOn = elem.dependsOn;
      const prev = result[0];
      if (prev) {
        result[0] = {
          ...prev,
          dependsOn: dependsOn.concat(prev.dependsOn ?? [])
        };
      }
    } else {
      result.unshift(elem);
    }
  }
  return result;
}
function createMigrationSequence({
  sequence,
  sequenceId,
  retroactive = true
}) {
  const migrations = {
    sequenceId,
    retroactive,
    sequence: squashDependsOn(sequence)
  };
  validateMigrations(migrations);
  return migrations;
}
function createMigrationIds(sequenceId, versions) {
  return Object.fromEntries(objectMapEntries2(versions).map(([key, version2]) => [key, `${sequenceId}/${version2}`]));
}
function createRecordMigrationSequence(opts) {
  const sequenceId = opts.sequenceId;
  return createMigrationSequence({
    sequenceId,
    retroactive: opts.retroactive ?? true,
    sequence: opts.sequence.map((m2) => "id" in m2 ? {
      ...m2,
      scope: "record",
      filter: (r2) => r2.typeName === opts.recordType && (m2.filter?.(r2) ?? true) && (opts.filter?.(r2) ?? true)
    } : m2)
  });
}
function sortMigrations(migrations) {
  const byId = new Map(migrations.map((m2) => [m2.id, m2]));
  const isProcessing = /* @__PURE__ */ new Set();
  const result = [];
  function process2(m2) {
    assert2(!isProcessing.has(m2.id), `Circular dependency in migrations: ${m2.id}`);
    isProcessing.add(m2.id);
    const { version: version2, sequenceId } = parseMigrationId(m2.id);
    const parent = byId.get(`${sequenceId}/${version2 - 1}`);
    if (parent) {
      process2(parent);
    }
    if (m2.dependsOn) {
      for (const dep of m2.dependsOn) {
        const depMigration = byId.get(dep);
        if (depMigration) {
          process2(depMigration);
        }
      }
    }
    byId.delete(m2.id);
    result.push(m2);
  }
  for (const m2 of byId.values()) {
    process2(m2);
  }
  return result;
}
function parseMigrationId(id) {
  const [sequenceId, version2] = id.split("/");
  return { sequenceId, version: parseInt(version2) };
}
function validateMigrationId(id, expectedSequenceId) {
  if (expectedSequenceId) {
    assert2(id.startsWith(expectedSequenceId + "/"), `Every migration in sequence '${expectedSequenceId}' must have an id starting with '${expectedSequenceId}/'. Got invalid id: '${id}'`);
  }
  assert2(id.match(/^(.*?)\/(0|[1-9]\d*)$/), `Invalid migration id: '${id}'`);
}
function validateMigrations(migrations) {
  assert2(!migrations.sequenceId.includes("/"), `sequenceId cannot contain a '/', got ${migrations.sequenceId}`);
  assert2(migrations.sequenceId.length, "sequenceId must be a non-empty string");
  if (migrations.sequence.length === 0) {
    return;
  }
  validateMigrationId(migrations.sequence[0].id, migrations.sequenceId);
  let n2 = parseMigrationId(migrations.sequence[0].id).version;
  assert2(n2 === 1, `Expected the first migrationId to be '${migrations.sequenceId}/1' but got '${migrations.sequence[0].id}'`);
  for (let i2 = 1; i2 < migrations.sequence.length; i2++) {
    const id = migrations.sequence[i2].id;
    validateMigrationId(id, migrations.sequenceId);
    const m2 = parseMigrationId(id).version;
    assert2(m2 === n2 + 1, `Migration id numbers must increase in increments of 1, expected ${migrations.sequenceId}/${n2 + 1} but got '${migrations.sequence[i2].id}'`);
    n2 = m2;
  }
}
var MigrationFailureReason;
var init_migrate = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/migrate.mjs"() {
    init_dist_esm3();
    MigrationFailureReason = /* @__PURE__ */ ((MigrationFailureReason2) => {
      MigrationFailureReason2["IncompatibleSubtype"] = "incompatible-subtype";
      MigrationFailureReason2["UnknownType"] = "unknown-type";
      MigrationFailureReason2["TargetVersionTooNew"] = "target-version-too-new";
      MigrationFailureReason2["TargetVersionTooOld"] = "target-version-too-old";
      MigrationFailureReason2["MigrationError"] = "migration-error";
      MigrationFailureReason2["UnrecognizedSubtype"] = "unrecognized-subtype";
      return MigrationFailureReason2;
    })(MigrationFailureReason || {});
  }
});

// node_modules/@tldraw/store/dist-esm/lib/StoreSchema.mjs
function upgradeSchema(schema) {
  if (schema.schemaVersion > 2 || schema.schemaVersion < 1)
    return Result2.err("Bad schema version");
  if (schema.schemaVersion === 2)
    return Result2.ok(schema);
  const result = {
    schemaVersion: 2,
    sequences: {}
  };
  for (const [typeName, recordVersion] of Object.entries(schema.recordVersions)) {
    result.sequences[`com.tldraw.${typeName}`] = recordVersion.version;
    if ("subTypeKey" in recordVersion) {
      for (const [subType, version2] of Object.entries(recordVersion.subTypeVersions)) {
        result.sequences[`com.tldraw.${typeName}.${subType}`] = version2;
      }
    }
  }
  return Result2.ok(result);
}
var StoreSchema;
var init_StoreSchema = __esm({
  "node_modules/@tldraw/store/dist-esm/lib/StoreSchema.mjs"() {
    init_dist_esm3();
    init_migrate();
    StoreSchema = class {
      constructor(types, options) {
        __publicField(this, "migrations", {});
        __publicField(this, "sortedMigrations");
        this.types = types;
        this.options = options;
        for (const m2 of options.migrations ?? []) {
          assert2(!this.migrations[m2.sequenceId], `Duplicate migration sequenceId ${m2.sequenceId}`);
          validateMigrations(m2);
          this.migrations[m2.sequenceId] = m2;
        }
        const allMigrations = Object.values(this.migrations).flatMap((m2) => m2.sequence);
        this.sortedMigrations = sortMigrations(allMigrations);
        for (const migration of this.sortedMigrations) {
          if (!migration.dependsOn?.length)
            continue;
          for (const dep of migration.dependsOn) {
            const depMigration = allMigrations.find((m2) => m2.id === dep);
            assert2(depMigration, `Migration '${migration.id}' depends on missing migration '${dep}'`);
          }
        }
      }
      static create(types, options) {
        return new StoreSchema(types, options ?? {});
      }
      validateRecord(store, record, phase2, recordBefore) {
        try {
          const recordType = getOwnProperty2(this.types, record.typeName);
          if (!recordType) {
            throw new Error(`Missing definition for record type ${record.typeName}`);
          }
          return recordType.validate(record, recordBefore ?? void 0);
        } catch (error2) {
          if (this.options.onValidationFailure) {
            return this.options.onValidationFailure({
              store,
              record,
              phase: phase2,
              recordBefore,
              error: error2
            });
          } else {
            throw error2;
          }
        }
      }
      getMigrationsSince(persistedSchema) {
        const upgradeResult = upgradeSchema(persistedSchema);
        if (!upgradeResult.ok) {
          return upgradeResult;
        }
        const schema = upgradeResult.value;
        const sequenceIdsToInclude = new Set(Object.keys(schema.sequences).filter((sequenceId) => this.migrations[sequenceId]));
        for (const sequenceId in this.migrations) {
          if (schema.sequences[sequenceId] === void 0 && this.migrations[sequenceId].retroactive) {
            sequenceIdsToInclude.add(sequenceId);
          }
        }
        if (sequenceIdsToInclude.size === 0) {
          return Result2.ok([]);
        }
        const allMigrationsToInclude = /* @__PURE__ */ new Set();
        for (const sequenceId of sequenceIdsToInclude) {
          const theirVersion = schema.sequences[sequenceId];
          if (typeof theirVersion !== "number" && this.migrations[sequenceId].retroactive || theirVersion === 0) {
            for (const migration of this.migrations[sequenceId].sequence) {
              allMigrationsToInclude.add(migration.id);
            }
            continue;
          }
          const theirVersionId = `${sequenceId}/${theirVersion}`;
          const idx = this.migrations[sequenceId].sequence.findIndex((m2) => m2.id === theirVersionId);
          if (idx === -1) {
            return Result2.err("Incompatible schema?");
          }
          for (const migration of this.migrations[sequenceId].sequence.slice(idx + 1)) {
            allMigrationsToInclude.add(migration.id);
          }
        }
        return Result2.ok(this.sortedMigrations.filter(({ id }) => allMigrationsToInclude.has(id)));
      }
      migratePersistedRecord(record, persistedSchema, direction = "up") {
        const migrations = this.getMigrationsSince(persistedSchema);
        if (!migrations.ok) {
          console.error("Error migrating record", migrations.error);
          return { type: "error", reason: MigrationFailureReason.MigrationError };
        }
        let migrationsToApply = migrations.value;
        if (migrationsToApply.length === 0) {
          return { type: "success", value: record };
        }
        if (migrationsToApply.some((m2) => m2.scope === "store")) {
          return {
            type: "error",
            reason: direction === "down" ? MigrationFailureReason.TargetVersionTooOld : MigrationFailureReason.TargetVersionTooNew
          };
        }
        if (direction === "down") {
          if (!migrationsToApply.every((m2) => m2.down)) {
            return {
              type: "error",
              reason: MigrationFailureReason.TargetVersionTooOld
            };
          }
          migrationsToApply = migrationsToApply.slice().reverse();
        }
        record = structuredClone3(record);
        try {
          for (const migration of migrationsToApply) {
            if (migration.scope === "store")
              throw new Error();
            const shouldApply = migration.filter ? migration.filter(record) : true;
            if (!shouldApply)
              continue;
            const result = migration[direction](record);
            if (result) {
              record = structuredClone3(result);
            }
          }
        } catch (e2) {
          console.error("Error migrating record", e2);
          return { type: "error", reason: MigrationFailureReason.MigrationError };
        }
        return { type: "success", value: record };
      }
      migrateStoreSnapshot(snapshot) {
        let { store } = snapshot;
        const migrations = this.getMigrationsSince(snapshot.schema);
        if (!migrations.ok) {
          console.error("Error migrating store", migrations.error);
          return { type: "error", reason: MigrationFailureReason.MigrationError };
        }
        const migrationsToApply = migrations.value;
        if (migrationsToApply.length === 0) {
          return { type: "success", value: store };
        }
        store = structuredClone3(store);
        try {
          for (const migration of migrationsToApply) {
            if (migration.scope === "record") {
              for (const [id, record] of Object.entries(store)) {
                const shouldApply = migration.filter ? migration.filter(record) : true;
                if (!shouldApply)
                  continue;
                const result = migration.up(record);
                if (result) {
                  store[id] = structuredClone3(result);
                }
              }
            } else if (migration.scope === "store") {
              const result = migration.up(store);
              if (result) {
                store = structuredClone3(result);
              }
            } else {
              exhaustiveSwitchError2(migration);
            }
          }
        } catch (e2) {
          console.error("Error migrating store", e2);
          return { type: "error", reason: MigrationFailureReason.MigrationError };
        }
        return { type: "success", value: store };
      }
      createIntegrityChecker(store) {
        return this.options.createIntegrityChecker?.(store) ?? void 0;
      }
      serialize() {
        return {
          schemaVersion: 2,
          sequences: Object.fromEntries(Object.values(this.migrations).map(({ sequenceId, sequence }) => [
            sequenceId,
            sequence.length ? parseMigrationId(sequence.at(-1).id).version : 0
          ]))
        };
      }
      serializeEarliestVersion() {
        return {
          schemaVersion: 2,
          sequences: Object.fromEntries(Object.values(this.migrations).map(({ sequenceId }) => [sequenceId, 0]))
        };
      }
      getType(typeName) {
        const type = getOwnProperty2(this.types, typeName);
        assert2(type, "record type does not exists");
        return type;
      }
    };
  }
});

// node_modules/@tldraw/store/dist-esm/index.mjs
var init_dist_esm4 = __esm({
  "node_modules/@tldraw/store/dist-esm/index.mjs"() {
    init_IncrementalSetConstructor();
    init_RecordType();
    init_RecordsDiff();
    init_Store();
    init_StoreQueries();
    init_StoreSchema();
    init_StoreSideEffects();
    init_devFreeze();
    init_migrate();
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs
var PERFORMANCE_COLORS3, PERFORMANCE_PREFIX_COLOR3;
var init_perf3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs"() {
    PERFORMANCE_COLORS3 = {
      Good: "#40C057",
      Mid: "#FFC078",
      Poor: "#E03131"
    };
    PERFORMANCE_PREFIX_COLOR3 = PERFORMANCE_COLORS3.Good;
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs
var init_PerformanceTracker3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs"() {
    init_perf3();
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/array.mjs
var init_array3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/array.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs
var init_cache3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/function.mjs
function omitFromStackTrace3(fn3) {
  const wrappedFn = (...args) => {
    try {
      return fn3(...args);
    } catch (error2) {
      if (error2 instanceof Error && Error.captureStackTrace) {
        Error.captureStackTrace(error2, wrappedFn);
      }
      throw error2;
    }
  };
  return wrappedFn;
}
var init_function3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/function.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/control.mjs
function exhaustiveSwitchError3(value, property) {
  const debugValue = property && value && typeof value === "object" && property in value ? value[property] : value;
  throw new Error(`Unknown switch case ${debugValue}`);
}
var assert3, assertExists3;
var init_control3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/control.mjs"() {
    init_function3();
    assert3 = omitFromStackTrace3((value, message) => {
      if (!value) {
        throw new Error(message || "Assertion Error");
      }
    });
    assertExists3 = omitFromStackTrace3((value, message) => {
      if (value == null) {
        throw new Error(message ?? "value must be defined");
      }
      return value;
    });
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs
var init_debounce3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/error.mjs
var init_error3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/error.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/network.mjs
var init_network3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/network.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/file.mjs
var init_file3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/file.mjs"() {
    init_network3();
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs
var init_hash3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs
var init_iterable3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs
var init_apng3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs
var init_avif3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs
var init_gif3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs
var TABLE3;
var init_png3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs"() {
    TABLE3 = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    if (typeof Int32Array !== "undefined") {
      TABLE3 = new Int32Array(TABLE3);
    }
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs
var init_webp3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs
var DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES3, DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES3, DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES3, DEFAULT_SUPPORTED_IMAGE_TYPES3, DEFAULT_SUPPORT_VIDEO_TYPES3, DEFAULT_SUPPORTED_MEDIA_TYPE_LIST3;
var init_media3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs"() {
    init_network3();
    init_apng3();
    init_avif3();
    init_gif3();
    init_png3();
    init_webp3();
    DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES3 = Object.freeze(["image/svg+xml"]);
    DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES3 = Object.freeze([
      "image/jpeg",
      "image/png",
      "image/webp"
    ]);
    DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES3 = Object.freeze([
      "image/gif",
      "image/apng",
      "image/avif"
    ]);
    DEFAULT_SUPPORTED_IMAGE_TYPES3 = Object.freeze([
      ...DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES3,
      ...DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES3,
      ...DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES3
    ]);
    DEFAULT_SUPPORT_VIDEO_TYPES3 = Object.freeze([
      "video/mp4",
      "video/webm",
      "video/quicktime"
    ]);
    DEFAULT_SUPPORTED_MEDIA_TYPE_LIST3 = [
      ...DEFAULT_SUPPORTED_IMAGE_TYPES3,
      ...DEFAULT_SUPPORT_VIDEO_TYPES3
    ].join(",");
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/number.mjs
var init_number3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/number.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/object.mjs
function hasOwnProperty3(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}
function getOwnProperty3(obj, key) {
  if (!hasOwnProperty3(obj, key)) {
    return void 0;
  }
  return obj[key];
}
var init_object3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/object.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs
function getIntegerLength2(head) {
  if (head >= "a" && head <= "z") {
    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
  } else if (head >= "A" && head <= "Z") {
    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
  } else {
    throw new Error("Invalid index key head: " + head);
  }
}
function getIntegerPart2(index3) {
  const integerPartLength = getIntegerLength2(index3.charAt(0));
  if (integerPartLength > index3.length) {
    throw new Error("invalid index: " + index3);
  }
  return index3.slice(0, integerPartLength);
}
function validateOrder3(index3) {
  if (index3 === SMALLEST_INTEGER2) {
    throw new Error("invalid index: " + index3);
  }
  const i2 = getIntegerPart2(index3);
  const f2 = index3.slice(i2.length);
  if (f2.slice(-1) === "0") {
    throw new Error("invalid index: " + index3);
  }
}
var SMALLEST_INTEGER2;
var init_dgreensp3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs"() {
    SMALLEST_INTEGER2 = "A00000000000000000000000000";
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs
function validateIndexKey3(key) {
  validateOrder3(key);
}
var init_reordering3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs"() {
    init_dgreensp3();
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs
var init_sort3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs
var init_storage4 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs
var targetFps3, targetTimePerFrame3;
var init_throttle3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs"() {
    targetFps3 = 60;
    targetTimePerFrame3 = Math.ceil(1e3 / targetFps3);
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs
var init_timers3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/value.mjs
function getStructuredClone3() {
  if (typeof globalThis !== "undefined" && globalThis.structuredClone) {
    return [globalThis.structuredClone, true];
  }
  if (typeof global !== "undefined" && global.structuredClone) {
    return [global.structuredClone, true];
  }
  if (typeof window !== "undefined" && window.structuredClone) {
    return [window.structuredClone, true];
  }
  return [(i2) => i2 ? JSON.parse(JSON.stringify(i2)) : i2, false];
}
var _structuredClone3, structuredClone4, isNativeStructuredClone3, STRUCTURED_CLONE_OBJECT_PROTOTYPE3;
var init_value3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/value.mjs"() {
    _structuredClone3 = getStructuredClone3();
    structuredClone4 = _structuredClone3[0];
    isNativeStructuredClone3 = _structuredClone3[1];
    STRUCTURED_CLONE_OBJECT_PROTOTYPE3 = Object.getPrototypeOf(structuredClone4({}));
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs
var init_warn3 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs"() {
  }
});

// node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/index.mjs
var import_lodash6, import_lodash7;
var init_dist_esm5 = __esm({
  "node_modules/@tldraw/validate/node_modules/@tldraw/utils/dist-esm/index.mjs"() {
    import_lodash6 = __toESM(require_lodash(), 1);
    import_lodash7 = __toESM(require_lodash2(), 1);
    init_PerformanceTracker3();
    init_array3();
    init_cache3();
    init_control3();
    init_debounce3();
    init_error3();
    init_file3();
    init_function3();
    init_hash3();
    init_iterable3();
    init_media3();
    init_png3();
    init_network3();
    init_number3();
    init_object3();
    init_perf3();
    init_reordering3();
    init_sort3();
    init_storage4();
    init_throttle3();
    init_timers3();
    init_value3();
    init_warn3();
  }
});

// node_modules/@tldraw/validate/dist-esm/lib/validation.mjs
var validation_exports = {};
__export(validation_exports, {
  ArrayOfValidator: () => ArrayOfValidator,
  DictValidator: () => DictValidator,
  ObjectValidator: () => ObjectValidator,
  UnionValidator: () => UnionValidator,
  ValidationError: () => ValidationError,
  Validator: () => Validator,
  any: () => any,
  array: () => array,
  arrayOf: () => arrayOf,
  bigint: () => bigint,
  boolean: () => boolean,
  dict: () => dict,
  httpUrl: () => httpUrl,
  indexKey: () => indexKey,
  integer: () => integer,
  jsonDict: () => jsonDict,
  jsonValue: () => jsonValue,
  linkUrl: () => linkUrl,
  literal: () => literal,
  literalEnum: () => literalEnum,
  model: () => model,
  nonZeroInteger: () => nonZeroInteger,
  nonZeroNumber: () => nonZeroNumber,
  nullable: () => nullable,
  number: () => number,
  numberUnion: () => numberUnion,
  object: () => object,
  optional: () => optional,
  positiveInteger: () => positiveInteger,
  positiveNumber: () => positiveNumber,
  setEnum: () => setEnum,
  srcUrl: () => srcUrl,
  string: () => string,
  union: () => union,
  unknown: () => unknown,
  unknownObject: () => unknownObject
});
function formatPath(path) {
  if (!path.length) {
    return null;
  }
  let formattedPath = "";
  for (const item of path) {
    if (typeof item === "number") {
      formattedPath += `.${item}`;
    } else if (item.startsWith("(")) {
      if (formattedPath.endsWith(")")) {
        formattedPath = `${formattedPath.slice(0, -1)}, ${item.slice(1)}`;
      } else {
        formattedPath += item;
      }
    } else {
      formattedPath += `.${item}`;
    }
  }
  formattedPath = formattedPath.replace(/id = [^,]+, /, "").replace(/id = [^)]+/, "");
  if (formattedPath.startsWith(".")) {
    return formattedPath.slice(1);
  }
  return formattedPath;
}
function prefixError(path, fn3) {
  try {
    return fn3();
  } catch (err) {
    if (err instanceof ValidationError) {
      throw new ValidationError(err.rawMessage, [path, ...err.path]);
    }
    throw new ValidationError(err.toString(), [path]);
  }
}
function typeToString(value) {
  if (value === null)
    return "null";
  if (Array.isArray(value))
    return "an array";
  const type = typeof value;
  switch (type) {
    case "bigint":
    case "boolean":
    case "function":
    case "number":
    case "string":
    case "symbol":
      return `a ${type}`;
    case "object":
      return `an ${type}`;
    case "undefined":
      return "undefined";
    default:
      exhaustiveSwitchError3(type);
  }
}
function typeofValidator(type) {
  return new Validator((value) => {
    if (typeof value !== type) {
      throw new ValidationError(`Expected ${type}, got ${typeToString(value)}`);
    }
    return value;
  });
}
function literal(expectedValue) {
  return new Validator((actualValue) => {
    if (actualValue !== expectedValue) {
      throw new ValidationError(`Expected ${expectedValue}, got ${JSON.stringify(actualValue)}`);
    }
    return expectedValue;
  });
}
function arrayOf(itemValidator) {
  return new ArrayOfValidator(itemValidator);
}
function object(config) {
  return new ObjectValidator(config);
}
function isPlainObject(value) {
  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === STRUCTURED_CLONE_OBJECT_PROTOTYPE3);
}
function isValidJson(value) {
  if (value === null || typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
    return true;
  }
  if (Array.isArray(value)) {
    return value.every(isValidJson);
  }
  if (isPlainObject(value)) {
    return Object.values(value).every(isValidJson);
  }
  return false;
}
function jsonDict() {
  return dict(string, jsonValue);
}
function dict(keyValidator, valueValidator) {
  return new DictValidator(keyValidator, valueValidator);
}
function union(key, config) {
  return new UnionValidator(key, config, (unknownValue, unknownVariant) => {
    throw new ValidationError(`Expected one of ${Object.keys(config).map((key2) => JSON.stringify(key2)).join(" or ")}, got ${JSON.stringify(unknownVariant)}`, [key]);
  }, false);
}
function numberUnion(key, config) {
  return new UnionValidator(key, config, (unknownValue, unknownVariant) => {
    throw new ValidationError(`Expected one of ${Object.keys(config).map((key2) => JSON.stringify(key2)).join(" or ")}, got ${JSON.stringify(unknownVariant)}`, [key]);
  }, true);
}
function model(name, validator) {
  return new Validator((value) => {
    return prefixError(name, () => validator.validate(value));
  }, (prevValue, newValue) => {
    return prefixError(name, () => {
      if (validator.validateUsingKnownGoodVersion) {
        return validator.validateUsingKnownGoodVersion(prevValue, newValue);
      } else {
        return validator.validate(newValue);
      }
    });
  });
}
function setEnum(values) {
  return new Validator((value) => {
    if (!values.has(value)) {
      const valuesString = Array.from(values, (value2) => JSON.stringify(value2)).join(" or ");
      throw new ValidationError(`Expected ${valuesString}, got ${value}`);
    }
    return value;
  });
}
function optional(validator) {
  return new Validator((value) => {
    if (value === void 0)
      return void 0;
    return validator.validate(value);
  }, (knownGoodValue, newValue) => {
    if (knownGoodValue === void 0 && newValue === void 0)
      return void 0;
    if (newValue === void 0)
      return void 0;
    if (validator.validateUsingKnownGoodVersion && knownGoodValue !== void 0) {
      return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
    }
    return validator.validate(newValue);
  });
}
function nullable(validator) {
  return new Validator((value) => {
    if (value === null)
      return null;
    return validator.validate(value);
  }, (knownGoodValue, newValue) => {
    if (newValue === null)
      return null;
    if (validator.validateUsingKnownGoodVersion && knownGoodValue !== null) {
      return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
    }
    return validator.validate(newValue);
  });
}
function literalEnum(...values) {
  return setEnum(new Set(values));
}
function parseUrl(str) {
  try {
    return new URL(str);
  } catch (error2) {
    if (str.startsWith("/") || str.startsWith("./")) {
      try {
        return new URL(str, "http://example.com");
      } catch (error22) {
        throw new ValidationError(`Expected a valid url, got ${JSON.stringify(str)}`);
      }
    }
    throw new ValidationError(`Expected a valid url, got ${JSON.stringify(str)}`);
  }
}
var ValidationError, Validator, ArrayOfValidator, ObjectValidator, UnionValidator, DictValidator, unknown, any, string, number, positiveNumber, nonZeroNumber, integer, positiveInteger, nonZeroInteger, boolean, bigint, array, unknownObject, jsonValue, validLinkProtocols, linkUrl, validSrcProtocols, srcUrl, httpUrl, indexKey;
var init_validation = __esm({
  "node_modules/@tldraw/validate/dist-esm/lib/validation.mjs"() {
    init_dist_esm5();
    ValidationError = class extends Error {
      constructor(rawMessage, path = []) {
        const formattedPath = formatPath(path);
        const indentedMessage = rawMessage.split("\n").map((line, i2) => i2 === 0 ? line : `  ${line}`).join("\n");
        super(path ? `At ${formattedPath}: ${indentedMessage}` : indentedMessage);
        __publicField(this, "name", "ValidationError");
        this.rawMessage = rawMessage;
        this.path = path;
      }
    };
    Validator = class {
      constructor(validationFn, validateUsingKnownGoodVersionFn) {
        this.validationFn = validationFn;
        this.validateUsingKnownGoodVersionFn = validateUsingKnownGoodVersionFn;
      }
      validate(value) {
        const validated = this.validationFn(value);
        if (false) {
          throw new ValidationError("Validator functions must return the same value they were passed");
        }
        return validated;
      }
      validateUsingKnownGoodVersion(knownGoodValue, newValue) {
        if (Object.is(knownGoodValue, newValue)) {
          return knownGoodValue;
        }
        if (this.validateUsingKnownGoodVersionFn) {
          return this.validateUsingKnownGoodVersionFn(knownGoodValue, newValue);
        }
        return this.validate(newValue);
      }
      isValid(value) {
        try {
          this.validate(value);
          return true;
        } catch {
          return false;
        }
      }
      nullable() {
        return nullable(this);
      }
      optional() {
        return optional(this);
      }
      refine(otherValidationFn) {
        return new Validator((value) => {
          return otherValidationFn(this.validate(value));
        }, (knownGoodValue, newValue) => {
          const validated = this.validateUsingKnownGoodVersion(knownGoodValue, newValue);
          if (Object.is(knownGoodValue, validated)) {
            return knownGoodValue;
          }
          return otherValidationFn(validated);
        });
      }
      check(nameOrCheckFn, checkFn) {
        if (typeof nameOrCheckFn === "string") {
          return this.refine((value) => {
            prefixError(`(check ${nameOrCheckFn})`, () => checkFn(value));
            return value;
          });
        } else {
          return this.refine((value) => {
            nameOrCheckFn(value);
            return value;
          });
        }
      }
    };
    ArrayOfValidator = class extends Validator {
      constructor(itemValidator) {
        super((value) => {
          const arr = array.validate(value);
          for (let i2 = 0; i2 < arr.length; i2++) {
            prefixError(i2, () => itemValidator.validate(arr[i2]));
          }
          return arr;
        }, (knownGoodValue, newValue) => {
          if (!itemValidator.validateUsingKnownGoodVersion)
            return this.validate(newValue);
          const arr = array.validate(newValue);
          let isDifferent = knownGoodValue.length !== arr.length;
          for (let i2 = 0; i2 < arr.length; i2++) {
            const item = arr[i2];
            if (i2 >= knownGoodValue.length) {
              isDifferent = true;
              prefixError(i2, () => itemValidator.validate(item));
              continue;
            }
            if (Object.is(knownGoodValue[i2], item)) {
              continue;
            }
            const checkedItem = prefixError(i2, () => itemValidator.validateUsingKnownGoodVersion(knownGoodValue[i2], item));
            if (!Object.is(checkedItem, knownGoodValue[i2])) {
              isDifferent = true;
            }
          }
          return isDifferent ? newValue : knownGoodValue;
        });
        this.itemValidator = itemValidator;
      }
      nonEmpty() {
        return this.check((value) => {
          if (value.length === 0) {
            throw new ValidationError("Expected a non-empty array");
          }
        });
      }
      lengthGreaterThan1() {
        return this.check((value) => {
          if (value.length <= 1) {
            throw new ValidationError("Expected an array with length greater than 1");
          }
        });
      }
    };
    ObjectValidator = class extends Validator {
      constructor(config, shouldAllowUnknownProperties = false) {
        super((object2) => {
          if (typeof object2 !== "object" || object2 === null) {
            throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
          }
          for (const [key, validator] of Object.entries(config)) {
            prefixError(key, () => {
              ;
              validator.validate(getOwnProperty3(object2, key));
            });
          }
          if (!shouldAllowUnknownProperties) {
            for (const key of Object.keys(object2)) {
              if (!hasOwnProperty3(config, key)) {
                throw new ValidationError(`Unexpected property`, [key]);
              }
            }
          }
          return object2;
        }, (knownGoodValue, newValue) => {
          if (typeof newValue !== "object" || newValue === null) {
            throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
          }
          let isDifferent = false;
          for (const [key, validator] of Object.entries(config)) {
            const prev = getOwnProperty3(knownGoodValue, key);
            const next = getOwnProperty3(newValue, key);
            if (Object.is(prev, next)) {
              continue;
            }
            const checked = prefixError(key, () => {
              const validatable = validator;
              if (validatable.validateUsingKnownGoodVersion) {
                return validatable.validateUsingKnownGoodVersion(prev, next);
              } else {
                return validatable.validate(next);
              }
            });
            if (!Object.is(checked, prev)) {
              isDifferent = true;
            }
          }
          if (!shouldAllowUnknownProperties) {
            for (const key of Object.keys(newValue)) {
              if (!hasOwnProperty3(config, key)) {
                throw new ValidationError(`Unexpected property`, [key]);
              }
            }
          }
          for (const key of Object.keys(knownGoodValue)) {
            if (!hasOwnProperty3(newValue, key)) {
              isDifferent = true;
              break;
            }
          }
          return isDifferent ? newValue : knownGoodValue;
        });
        this.config = config;
        this.shouldAllowUnknownProperties = shouldAllowUnknownProperties;
      }
      allowUnknownProperties() {
        return new ObjectValidator(this.config, true);
      }
      extend(extension) {
        return new ObjectValidator({ ...this.config, ...extension });
      }
    };
    UnionValidator = class extends Validator {
      constructor(key, config, unknownValueValidation, useNumberKeys) {
        super((input) => {
          this.expectObject(input);
          const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(input);
          if (matchingSchema === void 0) {
            return this.unknownValueValidation(input, variant);
          }
          return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(input));
        }, (prevValue, newValue) => {
          this.expectObject(newValue);
          this.expectObject(prevValue);
          const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(newValue);
          if (matchingSchema === void 0) {
            return this.unknownValueValidation(newValue, variant);
          }
          if (getOwnProperty3(prevValue, key) !== getOwnProperty3(newValue, key)) {
            return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(newValue));
          }
          return prefixError(`(${key} = ${variant})`, () => {
            if (matchingSchema.validateUsingKnownGoodVersion) {
              return matchingSchema.validateUsingKnownGoodVersion(prevValue, newValue);
            } else {
              return matchingSchema.validate(newValue);
            }
          });
        });
        this.key = key;
        this.config = config;
        this.unknownValueValidation = unknownValueValidation;
        this.useNumberKeys = useNumberKeys;
      }
      expectObject(value) {
        if (typeof value !== "object" || value === null) {
          throw new ValidationError(`Expected an object, got ${typeToString(value)}`, []);
        }
      }
      getMatchingSchemaAndVariant(object2) {
        const variant = getOwnProperty3(object2, this.key);
        if (!this.useNumberKeys && typeof variant !== "string") {
          throw new ValidationError(`Expected a string for key "${this.key}", got ${typeToString(variant)}`);
        } else if (this.useNumberKeys && !Number.isFinite(Number(variant))) {
          throw new ValidationError(`Expected a number for key "${this.key}", got "${variant}"`);
        }
        const matchingSchema = hasOwnProperty3(this.config, variant) ? this.config[variant] : void 0;
        return { matchingSchema, variant };
      }
      validateUnknownVariants(unknownValueValidation) {
        return new UnionValidator(this.key, this.config, unknownValueValidation, this.useNumberKeys);
      }
    };
    DictValidator = class extends Validator {
      constructor(keyValidator, valueValidator) {
        super((object2) => {
          if (typeof object2 !== "object" || object2 === null) {
            throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
          }
          for (const [key, value] of Object.entries(object2)) {
            prefixError(key, () => {
              keyValidator.validate(key);
              valueValidator.validate(value);
            });
          }
          return object2;
        }, (knownGoodValue, newValue) => {
          if (typeof newValue !== "object" || newValue === null) {
            throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
          }
          let isDifferent = false;
          for (const [key, value] of Object.entries(newValue)) {
            if (!hasOwnProperty3(knownGoodValue, key)) {
              isDifferent = true;
              prefixError(key, () => {
                keyValidator.validate(key);
                valueValidator.validate(value);
              });
              continue;
            }
            const prev = getOwnProperty3(knownGoodValue, key);
            const next = value;
            if (Object.is(prev, next)) {
              continue;
            }
            const checked = prefixError(key, () => {
              if (valueValidator.validateUsingKnownGoodVersion) {
                return valueValidator.validateUsingKnownGoodVersion(prev, next);
              } else {
                return valueValidator.validate(next);
              }
            });
            if (!Object.is(checked, prev)) {
              isDifferent = true;
            }
          }
          for (const key of Object.keys(knownGoodValue)) {
            if (!hasOwnProperty3(newValue, key)) {
              isDifferent = true;
              break;
            }
          }
          return isDifferent ? newValue : knownGoodValue;
        });
        this.keyValidator = keyValidator;
        this.valueValidator = valueValidator;
      }
    };
    unknown = new Validator((value) => value);
    any = new Validator((value) => value);
    string = typeofValidator("string");
    number = typeofValidator("number").check((number2) => {
      if (Number.isNaN(number2)) {
        throw new ValidationError("Expected a number, got NaN");
      }
      if (!Number.isFinite(number2)) {
        throw new ValidationError(`Expected a finite number, got ${number2}`);
      }
    });
    positiveNumber = number.check((value) => {
      if (value < 0)
        throw new ValidationError(`Expected a positive number, got ${value}`);
    });
    nonZeroNumber = number.check((value) => {
      if (value <= 0)
        throw new ValidationError(`Expected a non-zero positive number, got ${value}`);
    });
    integer = number.check((value) => {
      if (!Number.isInteger(value))
        throw new ValidationError(`Expected an integer, got ${value}`);
    });
    positiveInteger = integer.check((value) => {
      if (value < 0)
        throw new ValidationError(`Expected a positive integer, got ${value}`);
    });
    nonZeroInteger = integer.check((value) => {
      if (value <= 0)
        throw new ValidationError(`Expected a non-zero positive integer, got ${value}`);
    });
    boolean = typeofValidator("boolean");
    bigint = typeofValidator("bigint");
    array = new Validator((value) => {
      if (!Array.isArray(value)) {
        throw new ValidationError(`Expected an array, got ${typeToString(value)}`);
      }
      return value;
    });
    unknownObject = new Validator((value) => {
      if (typeof value !== "object" || value === null) {
        throw new ValidationError(`Expected object, got ${typeToString(value)}`);
      }
      return value;
    });
    jsonValue = new Validator((value) => {
      if (isValidJson(value)) {
        return value;
      }
      throw new ValidationError(`Expected json serializable value, got ${typeof value}`);
    }, (knownGoodValue, newValue) => {
      if (Array.isArray(knownGoodValue) && Array.isArray(newValue)) {
        let isDifferent = knownGoodValue.length !== newValue.length;
        for (let i2 = 0; i2 < newValue.length; i2++) {
          if (i2 >= knownGoodValue.length) {
            isDifferent = true;
            jsonValue.validate(newValue[i2]);
            continue;
          }
          const prev = knownGoodValue[i2];
          const next = newValue[i2];
          if (Object.is(prev, next)) {
            continue;
          }
          const checked = jsonValue.validateUsingKnownGoodVersion(prev, next);
          if (!Object.is(checked, prev)) {
            isDifferent = true;
          }
        }
        return isDifferent ? newValue : knownGoodValue;
      } else if (isPlainObject(knownGoodValue) && isPlainObject(newValue)) {
        let isDifferent = false;
        for (const key of Object.keys(newValue)) {
          if (!hasOwnProperty3(knownGoodValue, key)) {
            isDifferent = true;
            jsonValue.validate(newValue[key]);
            continue;
          }
          const prev = knownGoodValue[key];
          const next = newValue[key];
          if (Object.is(prev, next)) {
            continue;
          }
          const checked = jsonValue.validateUsingKnownGoodVersion(prev, next);
          if (!Object.is(checked, prev)) {
            isDifferent = true;
          }
        }
        for (const key of Object.keys(knownGoodValue)) {
          if (!hasOwnProperty3(newValue, key)) {
            isDifferent = true;
            break;
          }
        }
        return isDifferent ? newValue : knownGoodValue;
      } else {
        return jsonValue.validate(newValue);
      }
    });
    validLinkProtocols = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
    linkUrl = string.check((value) => {
      if (value === "")
        return;
      const url = parseUrl(value);
      if (!validLinkProtocols.has(url.protocol.toLowerCase())) {
        throw new ValidationError(`Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`);
      }
    });
    validSrcProtocols = /* @__PURE__ */ new Set(["http:", "https:", "data:", "asset:"]);
    srcUrl = string.check((value) => {
      if (value === "")
        return;
      const url = parseUrl(value);
      if (!validSrcProtocols.has(url.protocol.toLowerCase())) {
        throw new ValidationError(`Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`);
      }
    });
    httpUrl = string.check((value) => {
      if (value === "")
        return;
      const url = parseUrl(value);
      if (!url.protocol.toLowerCase().match(/^https?:$/)) {
        throw new ValidationError(`Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`);
      }
    });
    indexKey = string.refine((key) => {
      try {
        validateIndexKey3(key);
        return key;
      } catch {
        throw new ValidationError(`Expected an index key, got ${JSON.stringify(key)}`);
      }
    });
  }
});

// node_modules/@tldraw/validate/dist-esm/index.mjs
var init_dist_esm6 = __esm({
  "node_modules/@tldraw/validate/dist-esm/index.mjs"() {
    init_validation();
    init_validation();
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/id-validator.mjs
function idValidator(prefix) {
  return validation_exports.string.refine((id) => {
    if (!id.startsWith(`${prefix}:`)) {
      throw new Error(`${prefix} ID must start with "${prefix}:"`);
    }
    return id;
  });
}
var init_id_validator = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/id-validator.mjs"() {
    init_dist_esm6();
  }
});

// node_modules/@tldraw/tlschema/dist-esm/assets/TLBaseAsset.mjs
function createAssetValidator(type, props) {
  return validation_exports.object({
    id: assetIdValidator,
    typeName: validation_exports.literal("asset"),
    type: validation_exports.literal(type),
    props,
    meta: validation_exports.jsonValue
  });
}
var assetIdValidator;
var init_TLBaseAsset = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/assets/TLBaseAsset.mjs"() {
    init_dist_esm6();
    init_id_validator();
    assetIdValidator = idValidator("asset");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/geometry-types.mjs
var vecModelValidator, boxModelValidator;
var init_geometry_types = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/geometry-types.mjs"() {
    init_dist_esm6();
    vecModelValidator = validation_exports.object({
      x: validation_exports.number,
      y: validation_exports.number,
      z: validation_exports.number.optional()
    });
    boxModelValidator = validation_exports.object({
      x: validation_exports.number,
      y: validation_exports.number,
      w: validation_exports.number,
      h: validation_exports.number
    });
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs
var PERFORMANCE_COLORS4, PERFORMANCE_PREFIX_COLOR4;
var init_perf4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/perf.mjs"() {
    PERFORMANCE_COLORS4 = {
      Good: "#40C057",
      Mid: "#FFC078",
      Poor: "#E03131"
    };
    PERFORMANCE_PREFIX_COLOR4 = PERFORMANCE_COLORS4.Good;
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs
var init_PerformanceTracker4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/PerformanceTracker.mjs"() {
    init_perf4();
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/array.mjs
var init_array4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/array.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs
var init_cache4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/cache.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/function.mjs
function omitFromStackTrace4(fn3) {
  const wrappedFn = (...args) => {
    try {
      return fn3(...args);
    } catch (error2) {
      if (error2 instanceof Error && Error.captureStackTrace) {
        Error.captureStackTrace(error2, wrappedFn);
      }
      throw error2;
    }
  };
  return wrappedFn;
}
var init_function4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/function.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/control.mjs
var assert4, assertExists4;
var init_control4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/control.mjs"() {
    init_function4();
    assert4 = omitFromStackTrace4((value, message) => {
      if (!value) {
        throw new Error(message || "Assertion Error");
      }
    });
    assertExists4 = omitFromStackTrace4((value, message) => {
      if (value == null) {
        throw new Error(message ?? "value must be defined");
      }
      return value;
    });
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs
var init_debounce4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/debounce.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/error.mjs
function annotateError4(error2, annotations) {
  if (typeof error2 !== "object" || error2 === null)
    return;
  let currentAnnotations = annotationsByError2.get(error2);
  if (!currentAnnotations) {
    currentAnnotations = { tags: {}, extras: {} };
    annotationsByError2.set(error2, currentAnnotations);
  }
  if (annotations.tags) {
    currentAnnotations.tags = {
      ...currentAnnotations.tags,
      ...annotations.tags
    };
  }
  if (annotations.extras) {
    currentAnnotations.extras = {
      ...currentAnnotations.extras,
      ...annotations.extras
    };
  }
}
var annotationsByError2;
var init_error4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/error.mjs"() {
    annotationsByError2 = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/network.mjs
var init_network4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/network.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/file.mjs
var init_file4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/file.mjs"() {
    init_network4();
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs
var init_hash4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/hash.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs
var init_iterable4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/iterable.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs
var init_apng4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/apng.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs
var init_avif4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/avif.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs
var init_gif4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/gif.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs
var TABLE4;
var init_png4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/png.mjs"() {
    TABLE4 = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    if (typeof Int32Array !== "undefined") {
      TABLE4 = new Int32Array(TABLE4);
    }
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs
var init_webp4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/webp.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs
var DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES4, DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES4, DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES4, DEFAULT_SUPPORTED_IMAGE_TYPES4, DEFAULT_SUPPORT_VIDEO_TYPES4, DEFAULT_SUPPORTED_MEDIA_TYPE_LIST4;
var init_media4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/media/media.mjs"() {
    init_network4();
    init_apng4();
    init_avif4();
    init_gif4();
    init_png4();
    init_webp4();
    DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES4 = Object.freeze(["image/svg+xml"]);
    DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES4 = Object.freeze([
      "image/jpeg",
      "image/png",
      "image/webp"
    ]);
    DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES4 = Object.freeze([
      "image/gif",
      "image/apng",
      "image/avif"
    ]);
    DEFAULT_SUPPORTED_IMAGE_TYPES4 = Object.freeze([
      ...DEFAULT_SUPPORTED_STATIC_IMAGE_TYPES4,
      ...DEFAULT_SUPPORTED_VECTOR_IMAGE_TYPES4,
      ...DEFAULT_SUPPORTED_ANIMATED_IMAGE_TYPES4
    ]);
    DEFAULT_SUPPORT_VIDEO_TYPES4 = Object.freeze([
      "video/mp4",
      "video/webm",
      "video/quicktime"
    ]);
    DEFAULT_SUPPORTED_MEDIA_TYPE_LIST4 = [
      ...DEFAULT_SUPPORTED_IMAGE_TYPES4,
      ...DEFAULT_SUPPORT_VIDEO_TYPES4
    ].join(",");
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/number.mjs
var init_number4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/number.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/object.mjs
function objectMapValues4(object2) {
  return Object.values(object2);
}
function objectMapEntries4(object2) {
  return Object.entries(object2);
}
function objectMapFromEntries4(entries) {
  return Object.fromEntries(entries);
}
function filterEntries4(object2, predicate) {
  const result = {};
  let didChange = false;
  for (const [key, value] of objectMapEntries4(object2)) {
    if (predicate(key, value)) {
      result[key] = value;
    } else {
      didChange = true;
    }
  }
  return didChange ? result : object2;
}
function mapObjectMapValues4(object2, mapper) {
  const result = {};
  for (const [key, value] of objectMapEntries4(object2)) {
    const newValue = mapper(key, value);
    result[key] = newValue;
  }
  return result;
}
var init_object4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/object.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs
function getIntegerLength3(head) {
  if (head >= "a" && head <= "z") {
    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
  } else if (head >= "A" && head <= "Z") {
    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
  } else {
    throw new Error("Invalid index key head: " + head);
  }
}
function validateInteger2(int) {
  if (int.length !== getIntegerLength3(int.charAt(0))) {
    throw new Error("invalid integer part of index key: " + int);
  }
}
function isNotUndefined2(n2) {
  if (n2 === void 0)
    throw Error("n is undefined");
}
function incrementInteger2(x2) {
  validateInteger2(x2);
  const [head, ...digs] = x2.split("");
  let carry = true;
  for (let i2 = digs.length - 1; carry && i2 >= 0; i2--) {
    const d2 = DIGITS2.indexOf(digs[i2]) + 1;
    if (d2 === DIGITS2.length) {
      digs[i2] = "0";
    } else {
      digs[i2] = DIGITS2.charAt(d2);
      carry = false;
    }
  }
  if (carry) {
    if (head === "Z")
      return "a0";
    if (head === "z")
      return void 0;
    const h2 = String.fromCharCode(head.charCodeAt(0) + 1);
    if (h2 > "a") {
      digs.push("0");
    } else {
      digs.pop();
    }
    return h2 + digs.join("");
  } else {
    return head + digs.join("");
  }
}
function decrementInteger2(x2) {
  validateInteger2(x2);
  const [head, ...digs] = x2.split("");
  let borrow = true;
  for (let i2 = digs.length - 1; borrow && i2 >= 0; i2--) {
    const d2 = DIGITS2.indexOf(digs[i2]) - 1;
    if (d2 === -1) {
      digs[i2] = DIGITS2.slice(-1);
    } else {
      digs[i2] = DIGITS2.charAt(d2);
      borrow = false;
    }
  }
  if (borrow) {
    if (head === "a")
      return "Z" + DIGITS2.slice(-1);
    if (head === "A")
      return void 0;
    const h2 = String.fromCharCode(head.charCodeAt(0) - 1);
    if (h2 < "Z") {
      digs.push(DIGITS2.slice(-1));
    } else {
      digs.pop();
    }
    return h2 + digs.join("");
  } else {
    return head + digs.join("");
  }
}
function midpoint2(a2, b2) {
  if (b2 !== void 0 && a2 >= b2) {
    throw new Error(a2 + " >= " + b2);
  }
  if (a2.slice(-1) === "0" || b2 && b2.slice(-1) === "0") {
    throw new Error("trailing zero");
  }
  if (b2) {
    let n2 = 0;
    while ((a2.charAt(n2) || "0") === b2.charAt(n2)) {
      n2++;
    }
    if (n2 > 0) {
      return b2.slice(0, n2) + midpoint2(a2.slice(n2), b2.slice(n2));
    }
  }
  const digitA = a2 ? DIGITS2.indexOf(a2.charAt(0)) : 0;
  const digitB = b2 !== void 0 ? DIGITS2.indexOf(b2.charAt(0)) : DIGITS2.length;
  if (digitB - digitA > 1) {
    const midDigit = Math.round(0.5 * (digitA + digitB));
    return DIGITS2.charAt(midDigit);
  } else {
    if (b2 && b2.length > 1) {
      return b2.slice(0, 1);
    } else {
      return DIGITS2.charAt(digitA) + midpoint2(a2.slice(1), void 0);
    }
  }
}
function getIntegerPart3(index3) {
  const integerPartLength = getIntegerLength3(index3.charAt(0));
  if (integerPartLength > index3.length) {
    throw new Error("invalid index: " + index3);
  }
  return index3.slice(0, integerPartLength);
}
function validateOrder4(index3) {
  if (index3 === SMALLEST_INTEGER3) {
    throw new Error("invalid index: " + index3);
  }
  const i2 = getIntegerPart3(index3);
  const f2 = index3.slice(i2.length);
  if (f2.slice(-1) === "0") {
    throw new Error("invalid index: " + index3);
  }
}
function generateKeyBetween2(a2, b2) {
  if (a2 !== void 0)
    validateOrder4(a2);
  if (b2 !== void 0)
    validateOrder4(b2);
  if (a2 !== void 0 && b2 !== void 0 && a2 >= b2) {
    throw new Error(a2 + " >= " + b2);
  }
  if (a2 === void 0 && b2 === void 0) {
    return INTEGER_ZERO4;
  }
  if (a2 === void 0) {
    if (b2 === void 0)
      throw Error("b is undefined");
    const ib2 = getIntegerPart3(b2);
    const fb2 = b2.slice(ib2.length);
    if (ib2 === SMALLEST_INTEGER3) {
      return ib2 + midpoint2("", fb2);
    }
    if (ib2 < b2) {
      return ib2;
    }
    const ibl = decrementInteger2(ib2);
    isNotUndefined2(ibl);
    return ibl;
  }
  if (b2 === void 0) {
    const ia2 = getIntegerPart3(a2);
    const fa2 = a2.slice(ia2.length);
    const i22 = incrementInteger2(ia2);
    return i22 === void 0 ? ia2 + midpoint2(fa2, void 0) : i22;
  }
  const ia = getIntegerPart3(a2);
  const fa = a2.slice(ia.length);
  const ib = getIntegerPart3(b2);
  const fb = b2.slice(ib.length);
  if (ia === ib) {
    return ia + midpoint2(fa, fb);
  }
  const i2 = incrementInteger2(ia);
  isNotUndefined2(i2);
  return i2 < b2 ? i2 : ia + midpoint2(fa, void 0);
}
function generateNKeysBetween4(a2, b2, n2) {
  if (n2 === 0)
    return [];
  if (n2 === 1)
    return [generateKeyBetween2(a2, b2)];
  if (b2 === void 0) {
    let c22 = generateKeyBetween2(a2, b2);
    const result = [c22];
    for (let i2 = 0; i2 < n2 - 1; i2++) {
      c22 = generateKeyBetween2(c22, b2);
      result.push(c22);
    }
    return result;
  }
  if (a2 === void 0) {
    let c22 = generateKeyBetween2(a2, b2);
    const result = [c22];
    for (let i2 = 0; i2 < n2 - 1; i2++) {
      c22 = generateKeyBetween2(a2, c22);
      result.push(c22);
    }
    result.reverse();
    return result;
  }
  const mid = Math.floor(n2 / 2);
  const c2 = generateKeyBetween2(a2, b2);
  return [...generateNKeysBetween4(a2, c2, mid), c2, ...generateNKeysBetween4(c2, b2, n2 - mid - 1)];
}
var DIGITS2, INTEGER_ZERO4, SMALLEST_INTEGER3;
var init_dgreensp4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/reordering/dgreensp/dgreensp.mjs"() {
    DIGITS2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    INTEGER_ZERO4 = "a0";
    SMALLEST_INTEGER3 = "A00000000000000000000000000";
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs
function getIndices4(n2, start2 = "a1") {
  return [start2, ...generateNKeysBetween4(start2, void 0, n2)];
}
function sortByIndex4(a2, b2) {
  if (a2.index < b2.index) {
    return -1;
  } else if (a2.index > b2.index) {
    return 1;
  }
  return 0;
}
var init_reordering4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/reordering/reordering.mjs"() {
    init_dgreensp4();
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs
var init_sort4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/sort.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs
var init_storage5 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/storage.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs
var targetFps4, targetTimePerFrame4;
var init_throttle4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/throttle.mjs"() {
    targetFps4 = 60;
    targetTimePerFrame4 = Math.ceil(1e3 / targetFps4);
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs
var init_timers4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/timers.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/value.mjs
function getStructuredClone4() {
  if (typeof globalThis !== "undefined" && globalThis.structuredClone) {
    return [globalThis.structuredClone, true];
  }
  if (typeof global !== "undefined" && global.structuredClone) {
    return [global.structuredClone, true];
  }
  if (typeof window !== "undefined" && window.structuredClone) {
    return [window.structuredClone, true];
  }
  return [(i2) => i2 ? JSON.parse(JSON.stringify(i2)) : i2, false];
}
var _structuredClone4, structuredClone5, isNativeStructuredClone4, STRUCTURED_CLONE_OBJECT_PROTOTYPE4;
var init_value4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/value.mjs"() {
    _structuredClone4 = getStructuredClone4();
    structuredClone5 = _structuredClone4[0];
    isNativeStructuredClone4 = _structuredClone4[1];
    STRUCTURED_CLONE_OBJECT_PROTOTYPE4 = Object.getPrototypeOf(structuredClone5({}));
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs
var init_warn4 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/lib/warn.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/index.mjs
var import_lodash8, import_lodash9;
var init_dist_esm7 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/@tldraw/utils/dist-esm/index.mjs"() {
    import_lodash8 = __toESM(require_lodash(), 1);
    import_lodash9 = __toESM(require_lodash2(), 1);
    init_PerformanceTracker4();
    init_array4();
    init_cache4();
    init_control4();
    init_debounce4();
    init_error4();
    init_file4();
    init_function4();
    init_hash4();
    init_iterable4();
    init_media4();
    init_png4();
    init_network4();
    init_number4();
    init_object4();
    init_perf4();
    init_reordering4();
    init_sort4();
    init_storage5();
    init_throttle4();
    init_timers4();
    init_value4();
    init_warn4();
  }
});

// node_modules/@tldraw/tlschema/node_modules/nanoid/index.browser.js
var nanoid2;
var init_index_browser2 = __esm({
  "node_modules/@tldraw/tlschema/node_modules/nanoid/index.browser.js"() {
    nanoid2 = (size4 = 21) => crypto.getRandomValues(new Uint8Array(size4)).reduce((id, byte) => {
      byte &= 63;
      if (byte < 36) {
        id += byte.toString(36);
      } else if (byte < 62) {
        id += (byte - 26).toString(36).toUpperCase();
      } else if (byte > 62) {
        id += "-";
      } else {
        id += "_";
      }
      return id;
    }, "");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/TLOpacity.mjs
var opacityValidator;
var init_TLOpacity = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/TLOpacity.mjs"() {
    init_dist_esm6();
    opacityValidator = validation_exports.number.check((n2) => {
      if (n2 < 0 || n2 > 1) {
        throw new validation_exports.ValidationError("Opacity must be between 0 and 1");
      }
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLBaseShape.mjs
function createShapeValidator(type, props, meta) {
  return validation_exports.object({
    id: shapeIdValidator,
    typeName: validation_exports.literal("shape"),
    x: validation_exports.number,
    y: validation_exports.number,
    rotation: validation_exports.number,
    index: validation_exports.indexKey,
    parentId: parentIdValidator,
    type: validation_exports.literal(type),
    isLocked: validation_exports.boolean,
    opacity: opacityValidator,
    props: props ? validation_exports.object(props) : validation_exports.jsonValue,
    meta: meta ? validation_exports.object(meta) : validation_exports.jsonValue
  });
}
var parentIdValidator, shapeIdValidator;
var init_TLBaseShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLBaseShape.mjs"() {
    init_dist_esm6();
    init_TLOpacity();
    init_id_validator();
    parentIdValidator = validation_exports.string.refine((id) => {
      if (!id.startsWith("page:") && !id.startsWith("shape:")) {
        throw new Error('Parent ID must start with "page:" or "shape:"');
      }
      return id;
    });
    shapeIdValidator = idValidator("shape");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/bindings/TLBaseBinding.mjs
function createBindingValidator(type, props, meta) {
  return validation_exports.object({
    id: bindingIdValidator,
    typeName: validation_exports.literal("binding"),
    type: validation_exports.literal(type),
    fromId: shapeIdValidator,
    toId: shapeIdValidator,
    props: props ? validation_exports.object(props) : validation_exports.jsonValue,
    meta: meta ? validation_exports.object(meta) : validation_exports.jsonValue
  });
}
var bindingIdValidator;
var init_TLBaseBinding = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/bindings/TLBaseBinding.mjs"() {
    init_dist_esm6();
    init_id_validator();
    init_TLBaseShape();
    bindingIdValidator = idValidator("binding");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLBinding.mjs
function createBindingId(id) {
  return `binding:${id ?? nanoid2()}`;
}
function createBindingPropsMigrationSequence(migrations) {
  return migrations;
}
function createBindingRecordType(bindings) {
  return createRecordType("binding", {
    scope: "document",
    validator: validation_exports.model("binding", validation_exports.union("type", mapObjectMapValues4(bindings, (type, { props, meta }) => createBindingValidator(type, props, meta))))
  }).withDefaultProperties(() => ({
    meta: {}
  }));
}
var rootBindingVersions, rootBindingMigrations;
var init_TLBinding = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLBinding.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
    init_dist_esm6();
    init_index_browser2();
    init_TLBaseBinding();
    rootBindingVersions = createMigrationIds("com.tldraw.binding", {});
    rootBindingMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.binding",
      recordType: "binding",
      sequence: []
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/StyleProp.mjs
var StyleProp, EnumStyleProp;
var init_StyleProp = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/StyleProp.mjs"() {
    init_dist_esm6();
    StyleProp = class {
      constructor(id, defaultValue, type) {
        this.id = id;
        this.defaultValue = defaultValue;
        this.type = type;
      }
      static define(uniqueId2, options) {
        const { defaultValue, type = validation_exports.any } = options;
        return new StyleProp(uniqueId2, defaultValue, type);
      }
      static defineEnum(uniqueId2, options) {
        const { defaultValue, values } = options;
        return new EnumStyleProp(uniqueId2, defaultValue, values);
      }
      setDefaultValue(value) {
        this.defaultValue = value;
      }
      validate(value) {
        return this.type.validate(value);
      }
      validateUsingKnownGoodVersion(prevValue, newValue) {
        if (this.type.validateUsingKnownGoodVersion) {
          return this.type.validateUsingKnownGoodVersion(prevValue, newValue);
        } else {
          return this.validate(newValue);
        }
      }
    };
    EnumStyleProp = class extends StyleProp {
      constructor(id, defaultValue, values) {
        super(id, defaultValue, validation_exports.literalEnum(...values));
        this.values = values;
      }
    };
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLShape.mjs
function isShape(record) {
  if (!record)
    return false;
  return record.typeName === "shape";
}
function isShapeId(id) {
  if (!id)
    return false;
  return id.startsWith("shape:");
}
function createShapeId(id) {
  return `shape:${id ?? nanoid2()}`;
}
function getShapePropKeysByStyle(props) {
  const propKeysByStyle = /* @__PURE__ */ new Map();
  for (const [key, prop] of Object.entries(props)) {
    if (prop instanceof StyleProp) {
      if (propKeysByStyle.has(prop)) {
        throw new Error(`Duplicate style prop ${prop.id}. Each style prop can only be used once within a shape.`);
      }
      propKeysByStyle.set(prop, key);
    }
  }
  return propKeysByStyle;
}
function createShapePropsMigrationSequence(migrations) {
  return migrations;
}
function createShapePropsMigrationIds(shapeType, ids) {
  return mapObjectMapValues4(ids, (_k, v2) => `com.tldraw.shape.${shapeType}/${v2}`);
}
function createShapeRecordType(shapes) {
  return createRecordType("shape", {
    scope: "document",
    validator: validation_exports.model("shape", validation_exports.union("type", mapObjectMapValues4(shapes, (type, { props, meta }) => createShapeValidator(type, props, meta))))
  }).withDefaultProperties(() => ({
    x: 0,
    y: 0,
    rotation: 0,
    isLocked: false,
    opacity: 1,
    meta: {}
  }));
}
var rootShapeVersions, rootShapeMigrations;
var init_TLShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLShape.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
    init_dist_esm6();
    init_index_browser2();
    init_TLBaseShape();
    init_StyleProp();
    rootShapeVersions = createMigrationIds("com.tldraw.shape", {
      AddIsLocked: 1,
      HoistOpacity: 2,
      AddMeta: 3,
      AddWhite: 4
    });
    rootShapeMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.shape",
      recordType: "shape",
      sequence: [
        {
          id: rootShapeVersions.AddIsLocked,
          up: (record) => {
            record.isLocked = false;
          },
          down: (record) => {
            delete record.isLocked;
          }
        },
        {
          id: rootShapeVersions.HoistOpacity,
          up: (record) => {
            record.opacity = Number(record.props.opacity ?? "1");
            delete record.props.opacity;
          },
          down: (record) => {
            const opacity = record.opacity;
            delete record.opacity;
            record.props.opacity = opacity < 0.175 ? "0.1" : opacity < 0.375 ? "0.25" : opacity < 0.625 ? "0.5" : opacity < 0.875 ? "0.75" : "1";
          }
        },
        {
          id: rootShapeVersions.AddMeta,
          up: (record) => {
            record.meta = {};
          }
        },
        {
          id: rootShapeVersions.AddWhite,
          up: (_record) => {
          },
          down: (record) => {
            if (record.props.color === "white") {
              record.props.color = "black";
            }
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/recordsWithProps.mjs
function processPropsMigrations(typeName, records) {
  const result = [];
  for (const [subType, { migrations }] of Object.entries(records)) {
    const sequenceId = `com.tldraw.${typeName}.${subType}`;
    if (!migrations) {
      result.push(createMigrationSequence({
        sequenceId,
        retroactive: false,
        sequence: []
      }));
    } else if ("sequenceId" in migrations) {
      assert4(sequenceId === migrations.sequenceId, `sequenceId mismatch for ${subType} ${RecordType} migrations. Expected '${sequenceId}', got '${migrations.sequenceId}'`);
      result.push(migrations);
    } else if ("sequence" in migrations) {
      result.push(createMigrationSequence({
        sequenceId,
        retroactive: false,
        sequence: migrations.sequence.map((m2) => "id" in m2 ? createPropsMigration(typeName, subType, m2) : m2)
      }));
    } else {
      result.push(createMigrationSequence({
        sequenceId,
        retroactive: false,
        sequence: Object.keys(migrations.migrators).map((k2) => Number(k2)).sort((a2, b2) => a2 - b2).map((version2) => ({
          id: `${sequenceId}/${version2}`,
          scope: "record",
          filter: (r2) => r2.typeName === typeName && r2.type === subType,
          up: (record) => {
            const result2 = migrations.migrators[version2].up(record);
            if (result2) {
              return result2;
            }
          },
          down: (record) => {
            const result2 = migrations.migrators[version2].down(record);
            if (result2) {
              return result2;
            }
          }
        }))
      }));
    }
  }
  return result;
}
function createPropsMigration(typeName, subType, m2) {
  return {
    id: m2.id,
    dependsOn: m2.dependsOn,
    scope: "record",
    filter: (r2) => r2.typeName === typeName && r2.type === subType,
    up: (record) => {
      const result = m2.up(record.props);
      if (result) {
        record.props = result;
      }
    },
    down: typeof m2.down === "function" ? (record) => {
      const result = m2.down(record.props);
      if (result) {
        record.props = result;
      }
    } : void 0
  };
}
var init_recordsWithProps = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/recordsWithProps.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLColorStyle.mjs
function getDefaultColorTheme(opts) {
  return opts.isDarkMode ? DefaultColorThemePalette.darkMode : DefaultColorThemePalette.lightMode;
}
var defaultColorNames, DefaultColorThemePalette, DefaultColorStyle, DefaultLabelColorStyle;
var init_TLColorStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLColorStyle.mjs"() {
    init_StyleProp();
    defaultColorNames = [
      "black",
      "grey",
      "light-violet",
      "violet",
      "blue",
      "light-blue",
      "yellow",
      "orange",
      "green",
      "light-green",
      "light-red",
      "red",
      "white"
    ];
    DefaultColorThemePalette = {
      lightMode: {
        id: "light",
        text: "#000000",
        background: "rgb(249, 250, 251)",
        solid: "#fcfffe",
        black: {
          solid: "#1d1d1d",
          fill: "#1d1d1d",
          note: {
            fill: "#FCE19C",
            text: "#000000"
          },
          semi: "#e8e8e8",
          pattern: "#494949",
          highlight: {
            srgb: "#fddd00",
            p3: "color(display-p3 0.972 0.8705 0.05)"
          }
        },
        blue: {
          solid: "#4465e9",
          fill: "#4465e9",
          note: {
            fill: "#8AA3FF",
            text: "#000000"
          },
          semi: "#dce1f8",
          pattern: "#6681ee",
          highlight: {
            srgb: "#10acff",
            p3: "color(display-p3 0.308 0.6632 0.9996)"
          }
        },
        green: {
          solid: "#099268",
          fill: "#099268",
          note: {
            fill: "#6FC896",
            text: "#000000"
          },
          semi: "#d3e9e3",
          pattern: "#39a785",
          highlight: {
            srgb: "#00ffc8",
            p3: "color(display-p3 0.2536 0.984 0.7981)"
          }
        },
        grey: {
          solid: "#9fa8b2",
          fill: "#9fa8b2",
          note: {
            fill: "#C0CAD3",
            text: "#000000"
          },
          semi: "#eceef0",
          pattern: "#bcc3c9",
          highlight: {
            srgb: "#cbe7f1",
            p3: "color(display-p3 0.8163 0.9023 0.9416)"
          }
        },
        "light-blue": {
          solid: "#4ba1f1",
          fill: "#4ba1f1",
          note: {
            fill: "#9BC4FD",
            text: "#000000"
          },
          semi: "#ddedfa",
          pattern: "#6fbbf8",
          highlight: {
            srgb: "#00f4ff",
            p3: "color(display-p3 0.1512 0.9414 0.9996)"
          }
        },
        "light-green": {
          solid: "#4cb05e",
          fill: "#4cb05e",
          note: {
            fill: "#98D08A",
            text: "#000000"
          },
          semi: "#dbf0e0",
          pattern: "#65cb78",
          highlight: {
            srgb: "#65f641",
            p3: "color(display-p3 0.563 0.9495 0.3857)"
          }
        },
        "light-red": {
          solid: "#f87777",
          fill: "#f87777",
          note: {
            fill: "#F7A5A1",
            text: "#000000"
          },
          semi: "#f4dadb",
          pattern: "#fe9e9e",
          highlight: {
            srgb: "#ff7fa3",
            p3: "color(display-p3 0.9988 0.5301 0.6397)"
          }
        },
        "light-violet": {
          solid: "#e085f4",
          fill: "#e085f4",
          note: {
            fill: "#DFB0F9",
            text: "#000000"
          },
          semi: "#f5eafa",
          pattern: "#e9acf8",
          highlight: {
            srgb: "#ff88ff",
            p3: "color(display-p3 0.9676 0.5652 0.9999)"
          }
        },
        orange: {
          solid: "#e16919",
          fill: "#e16919",
          note: {
            fill: "#FAA475",
            text: "#000000"
          },
          semi: "#f8e2d4",
          pattern: "#f78438",
          highlight: {
            srgb: "#ffa500",
            p3: "color(display-p3 0.9988 0.6905 0.266)"
          }
        },
        red: {
          solid: "#e03131",
          fill: "#e03131",
          note: {
            fill: "#FC8282",
            text: "#000000"
          },
          semi: "#f4dadb",
          pattern: "#e55959",
          highlight: {
            srgb: "#ff636e",
            p3: "color(display-p3 0.9992 0.4376 0.45)"
          }
        },
        violet: {
          solid: "#ae3ec9",
          fill: "#ae3ec9",
          note: {
            fill: "#DB91FD",
            text: "#000000"
          },
          semi: "#ecdcf2",
          pattern: "#bd63d3",
          highlight: {
            srgb: "#c77cff",
            p3: "color(display-p3 0.7469 0.5089 0.9995)"
          }
        },
        yellow: {
          solid: "#f1ac4b",
          fill: "#f1ac4b",
          note: {
            fill: "#FED49A",
            text: "#000000"
          },
          semi: "#f9f0e6",
          pattern: "#fecb92",
          highlight: {
            srgb: "#fddd00",
            p3: "color(display-p3 0.972 0.8705 0.05)"
          }
        },
        white: {
          solid: "#FFFFFF",
          fill: "#FFFFFF",
          semi: "#f5f5f5",
          pattern: "#f9f9f9",
          note: {
            fill: "#FFFFFF",
            text: "#000000"
          },
          highlight: {
            srgb: "#ffffff",
            p3: "color(display-p3 1 1 1)"
          }
        }
      },
      darkMode: {
        id: "dark",
        text: "hsl(210, 17%, 98%)",
        background: "hsl(240, 5%, 6.5%)",
        solid: "#010403",
        black: {
          solid: "#f2f2f2",
          fill: "#f2f2f2",
          note: {
            fill: "#2c2c2c",
            text: "#f2f2f2"
          },
          semi: "#2c3036",
          pattern: "#989898",
          highlight: {
            srgb: "#d2b700",
            p3: "color(display-p3 0.8078 0.7225 0.0312)"
          }
        },
        blue: {
          solid: "#4f72fc",
          fill: "#4f72fc",
          note: {
            fill: "#2A3F98",
            text: "#f2f2f2"
          },
          semi: "#262d40",
          pattern: "#3a4b9e",
          highlight: {
            srgb: "#0079d2",
            p3: "color(display-p3 0.0032 0.4655 0.7991)"
          }
        },
        green: {
          solid: "#099268",
          fill: "#099268",
          note: {
            fill: "#014429",
            text: "#f2f2f2"
          },
          semi: "#253231",
          pattern: "#366a53",
          highlight: {
            srgb: "#009774",
            p3: "color(display-p3 0.0085 0.582 0.4604)"
          }
        },
        grey: {
          solid: "#9398b0",
          fill: "#9398b0",
          note: {
            fill: "#56595F",
            text: "#f2f2f2"
          },
          semi: "#33373c",
          pattern: "#7c8187",
          highlight: {
            srgb: "#9cb4cb",
            p3: "color(display-p3 0.6299 0.7012 0.7856)"
          }
        },
        "light-blue": {
          solid: "#4dabf7",
          fill: "#4dabf7",
          note: {
            fill: "#1F5495",
            text: "#f2f2f2"
          },
          semi: "#2a3642",
          pattern: "#4d7aa9",
          highlight: {
            srgb: "#00bdc8",
            p3: "color(display-p3 0.0023 0.7259 0.7735)"
          }
        },
        "light-green": {
          solid: "#40c057",
          fill: "#40c057",
          note: {
            fill: "#21581D",
            text: "#f2f2f2"
          },
          semi: "#2a3830",
          pattern: "#4e874e",
          highlight: {
            srgb: "#00a000",
            p3: "color(display-p3 0.2711 0.6172 0.0195)"
          }
        },
        "light-red": {
          solid: "#ff8787",
          fill: "#ff8787",
          note: {
            fill: "#923632",
            text: "#f2f2f2"
          },
          semi: "#3b3235",
          pattern: "#a56767",
          highlight: {
            srgb: "#db005b",
            p3: "color(display-p3 0.7849 0.0585 0.3589)"
          }
        },
        "light-violet": {
          solid: "#e599f7",
          fill: "#e599f7",
          note: {
            fill: "#762F8E",
            text: "#f2f2f2"
          },
          semi: "#383442",
          pattern: "#9770a9",
          highlight: {
            srgb: "#c400c7",
            p3: "color(display-p3 0.7024 0.0403 0.753)"
          }
        },
        orange: {
          solid: "#f76707",
          fill: "#f76707",
          note: {
            fill: "#843906",
            text: "#f2f2f2"
          },
          semi: "#3a2e2a",
          pattern: "#9f552d",
          highlight: {
            srgb: "#d07a00",
            p3: "color(display-p3 0.7699 0.4937 0.0085)"
          }
        },
        red: {
          solid: "#e03131",
          fill: "#e03131",
          note: {
            fill: "#89231A",
            text: "#f2f2f2"
          },
          semi: "#36292b",
          pattern: "#8f3734",
          highlight: {
            srgb: "#de002c",
            p3: "color(display-p3 0.7978 0.0509 0.2035)"
          }
        },
        violet: {
          solid: "#ae3ec9",
          fill: "#ae3ec9",
          note: {
            fill: "#681683",
            text: "#f2f2f2"
          },
          semi: "#31293c",
          pattern: "#763a8b",
          highlight: {
            srgb: "#9e00ee",
            p3: "color(display-p3 0.5651 0.0079 0.8986)"
          }
        },
        yellow: {
          solid: "#ffc034",
          fill: "#ffc034",
          note: {
            fill: "#98571B",
            text: "#f2f2f2"
          },
          semi: "#3c3934",
          pattern: "#fecb92",
          highlight: {
            srgb: "#d2b700",
            p3: "color(display-p3 0.8078 0.7225 0.0312)"
          }
        },
        white: {
          solid: "#f3f3f3",
          fill: "#f3f3f3",
          semi: "#f5f5f5",
          pattern: "#f9f9f9",
          note: {
            fill: "#eaeaea",
            text: "#1d1d1d"
          },
          highlight: {
            srgb: "#ffffff",
            p3: "color(display-p3 1 1 1)"
          }
        }
      }
    };
    DefaultColorStyle = StyleProp.defineEnum("tldraw:color", {
      defaultValue: "black",
      values: defaultColorNames
    });
    DefaultLabelColorStyle = StyleProp.defineEnum("tldraw:labelColor", {
      defaultValue: "black",
      values: defaultColorNames
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLDashStyle.mjs
var DefaultDashStyle;
var init_TLDashStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLDashStyle.mjs"() {
    init_StyleProp();
    DefaultDashStyle = StyleProp.defineEnum("tldraw:dash", {
      defaultValue: "draw",
      values: ["draw", "solid", "dashed", "dotted"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLFillStyle.mjs
var DefaultFillStyle;
var init_TLFillStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLFillStyle.mjs"() {
    init_StyleProp();
    DefaultFillStyle = StyleProp.defineEnum("tldraw:fill", {
      defaultValue: "none",
      values: ["none", "semi", "solid", "pattern", "fill"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLFontStyle.mjs
var DefaultFontStyle, DefaultFontFamilies;
var init_TLFontStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLFontStyle.mjs"() {
    init_StyleProp();
    DefaultFontStyle = StyleProp.defineEnum("tldraw:font", {
      defaultValue: "draw",
      values: ["draw", "sans", "serif", "mono"]
    });
    DefaultFontFamilies = {
      draw: "'tldraw_draw', sans-serif",
      sans: "'tldraw_sans', sans-serif",
      serif: "'tldraw_serif', serif",
      mono: "'tldraw_mono', monospace"
    };
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLSizeStyle.mjs
var DefaultSizeStyle;
var init_TLSizeStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLSizeStyle.mjs"() {
    init_StyleProp();
    DefaultSizeStyle = StyleProp.defineEnum("tldraw:size", {
      defaultValue: "m",
      values: ["s", "m", "l", "xl"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLArrowShape.mjs
function propsMigration(migration) {
  return createPropsMigration("shape", "arrow", migration);
}
var arrowheadTypes, ArrowShapeArrowheadStartStyle, ArrowShapeArrowheadEndStyle, arrowShapeProps, arrowShapeVersions, arrowShapeMigrations;
var init_TLArrowShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLArrowShape.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_geometry_types();
    init_TLBinding();
    init_TLShape();
    init_recordsWithProps();
    init_StyleProp();
    init_TLColorStyle();
    init_TLDashStyle();
    init_TLFillStyle();
    init_TLFontStyle();
    init_TLSizeStyle();
    arrowheadTypes = [
      "arrow",
      "triangle",
      "square",
      "dot",
      "pipe",
      "diamond",
      "inverted",
      "bar",
      "none"
    ];
    ArrowShapeArrowheadStartStyle = StyleProp.defineEnum("tldraw:arrowheadStart", {
      defaultValue: "none",
      values: arrowheadTypes
    });
    ArrowShapeArrowheadEndStyle = StyleProp.defineEnum("tldraw:arrowheadEnd", {
      defaultValue: "arrow",
      values: arrowheadTypes
    });
    arrowShapeProps = {
      labelColor: DefaultLabelColorStyle,
      color: DefaultColorStyle,
      fill: DefaultFillStyle,
      dash: DefaultDashStyle,
      size: DefaultSizeStyle,
      arrowheadStart: ArrowShapeArrowheadStartStyle,
      arrowheadEnd: ArrowShapeArrowheadEndStyle,
      font: DefaultFontStyle,
      start: vecModelValidator,
      end: vecModelValidator,
      bend: validation_exports.number,
      text: validation_exports.string,
      labelPosition: validation_exports.number,
      scale: validation_exports.nonZeroNumber
    };
    arrowShapeVersions = createShapePropsMigrationIds("arrow", {
      AddLabelColor: 1,
      AddIsPrecise: 2,
      AddLabelPosition: 3,
      ExtractBindings: 4,
      AddScale: 5
    });
    arrowShapeMigrations = createMigrationSequence({
      sequenceId: "com.tldraw.shape.arrow",
      retroactive: false,
      sequence: [
        propsMigration({
          id: arrowShapeVersions.AddLabelColor,
          up: (props) => {
            props.labelColor = "black";
          },
          down: "retired"
        }),
        propsMigration({
          id: arrowShapeVersions.AddIsPrecise,
          up: ({ start: start2, end: end2 }) => {
            if (start2.type === "binding") {
              start2.isPrecise = !(start2.normalizedAnchor.x === 0.5 && start2.normalizedAnchor.y === 0.5);
            }
            if (end2.type === "binding") {
              end2.isPrecise = !(end2.normalizedAnchor.x === 0.5 && end2.normalizedAnchor.y === 0.5);
            }
          },
          down: ({ start: start2, end: end2 }) => {
            if (start2.type === "binding") {
              if (!start2.isPrecise) {
                start2.normalizedAnchor = { x: 0.5, y: 0.5 };
              }
              delete start2.isPrecise;
            }
            if (end2.type === "binding") {
              if (!end2.isPrecise) {
                end2.normalizedAnchor = { x: 0.5, y: 0.5 };
              }
              delete end2.isPrecise;
            }
          }
        }),
        propsMigration({
          id: arrowShapeVersions.AddLabelPosition,
          up: (props) => {
            props.labelPosition = 0.5;
          },
          down: (props) => {
            delete props.labelPosition;
          }
        }),
        {
          id: arrowShapeVersions.ExtractBindings,
          scope: "store",
          up: (oldStore) => {
            const arrows = Object.values(oldStore).filter((r2) => r2.typeName === "shape" && r2.type === "arrow");
            for (const arrow5 of arrows) {
              const { start: start2, end: end2 } = arrow5.props;
              if (start2.type === "binding") {
                const id = createBindingId();
                const binding = {
                  typeName: "binding",
                  id,
                  type: "arrow",
                  fromId: arrow5.id,
                  toId: start2.boundShapeId,
                  meta: {},
                  props: {
                    terminal: "start",
                    normalizedAnchor: start2.normalizedAnchor,
                    isExact: start2.isExact,
                    isPrecise: start2.isPrecise
                  }
                };
                oldStore[id] = binding;
                arrow5.props.start = { x: 0, y: 0 };
              } else {
                delete arrow5.props.start.type;
              }
              if (end2.type === "binding") {
                const id = createBindingId();
                const binding = {
                  typeName: "binding",
                  id,
                  type: "arrow",
                  fromId: arrow5.id,
                  toId: end2.boundShapeId,
                  meta: {},
                  props: {
                    terminal: "end",
                    normalizedAnchor: end2.normalizedAnchor,
                    isExact: end2.isExact,
                    isPrecise: end2.isPrecise
                  }
                };
                oldStore[id] = binding;
                arrow5.props.end = { x: 0, y: 0 };
              } else {
                delete arrow5.props.end.type;
              }
            }
          }
        },
        propsMigration({
          id: arrowShapeVersions.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        })
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/bindings/TLArrowBinding.mjs
var arrowBindingProps, arrowBindingMigrations;
var init_TLArrowBinding = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/bindings/TLArrowBinding.mjs"() {
    init_dist_esm6();
    init_geometry_types();
    init_TLBinding();
    init_TLArrowShape();
    arrowBindingProps = {
      terminal: validation_exports.literalEnum("start", "end"),
      normalizedAnchor: vecModelValidator,
      isExact: validation_exports.boolean,
      isPrecise: validation_exports.boolean
    };
    arrowBindingMigrations = createBindingPropsMigrationSequence({
      sequence: [{ dependsOn: [arrowShapeVersions.ExtractBindings] }]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLCamera.mjs
var cameraValidator, cameraVersions, cameraMigrations, CameraRecordType;
var init_TLCamera = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLCamera.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_id_validator();
    cameraValidator = validation_exports.model("camera", validation_exports.object({
      typeName: validation_exports.literal("camera"),
      id: idValidator("camera"),
      x: validation_exports.number,
      y: validation_exports.number,
      z: validation_exports.number,
      meta: validation_exports.jsonValue
    }));
    cameraVersions = createMigrationIds("com.tldraw.camera", {
      AddMeta: 1
    });
    cameraMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.camera",
      recordType: "camera",
      sequence: [
        {
          id: cameraVersions.AddMeta,
          up: (record) => {
            ;
            record.meta = {};
          }
        }
      ]
    });
    CameraRecordType = createRecordType("camera", {
      validator: cameraValidator,
      scope: "session"
    }).withDefaultProperties(() => ({
      x: 0,
      y: 0,
      z: 1,
      meta: {}
    }));
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/TLCursor.mjs
var TL_CURSOR_TYPES, cursorTypeValidator, cursorValidator;
var init_TLCursor = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/TLCursor.mjs"() {
    init_dist_esm6();
    TL_CURSOR_TYPES = /* @__PURE__ */ new Set([
      "none",
      "default",
      "pointer",
      "cross",
      "grab",
      "rotate",
      "grabbing",
      "resize-edge",
      "resize-corner",
      "text",
      "move",
      "ew-resize",
      "ns-resize",
      "nesw-resize",
      "nwse-resize",
      "nesw-rotate",
      "nwse-rotate",
      "swne-rotate",
      "senw-rotate",
      "zoom-in",
      "zoom-out"
    ]);
    cursorTypeValidator = validation_exports.setEnum(TL_CURSOR_TYPES);
    cursorValidator = validation_exports.object({
      type: cursorTypeValidator,
      rotation: validation_exports.number
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/TLColor.mjs
var TL_CANVAS_UI_COLOR_TYPES, canvasUiColorTypeValidator;
var init_TLColor = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/TLColor.mjs"() {
    init_dist_esm6();
    TL_CANVAS_UI_COLOR_TYPES = /* @__PURE__ */ new Set([
      "accent",
      "white",
      "black",
      "selection-stroke",
      "selection-fill",
      "laser",
      "muted-1"
    ]);
    canvasUiColorTypeValidator = validation_exports.setEnum(TL_CANVAS_UI_COLOR_TYPES);
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/TLScribble.mjs
var TL_SCRIBBLE_STATES, scribbleValidator;
var init_TLScribble = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/TLScribble.mjs"() {
    init_dist_esm6();
    init_TLColor();
    init_geometry_types();
    TL_SCRIBBLE_STATES = /* @__PURE__ */ new Set(["starting", "paused", "active", "stopping"]);
    scribbleValidator = validation_exports.object({
      id: validation_exports.string,
      points: validation_exports.arrayOf(vecModelValidator),
      size: validation_exports.positiveNumber,
      color: canvasUiColorTypeValidator,
      opacity: validation_exports.number,
      state: validation_exports.setEnum(TL_SCRIBBLE_STATES),
      delay: validation_exports.number,
      shrink: validation_exports.number,
      taper: validation_exports.boolean
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLPage.mjs
function isPageId(id) {
  return PageRecordType.isId(id);
}
var pageIdValidator, pageValidator, pageVersions, pageMigrations, PageRecordType;
var init_TLPage = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLPage.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_id_validator();
    pageIdValidator = idValidator("page");
    pageValidator = validation_exports.model("page", validation_exports.object({
      typeName: validation_exports.literal("page"),
      id: pageIdValidator,
      name: validation_exports.string,
      index: validation_exports.indexKey,
      meta: validation_exports.jsonValue
    }));
    pageVersions = createMigrationIds("com.tldraw.page", {
      AddMeta: 1
    });
    pageMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.page",
      recordType: "page",
      sequence: [
        {
          id: pageVersions.AddMeta,
          up: (record) => {
            record.meta = {};
          }
        }
      ]
    });
    PageRecordType = createRecordType("page", {
      validator: pageValidator,
      scope: "document"
    }).withDefaultProperties(() => ({
      meta: {}
    }));
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLInstance.mjs
function createInstanceRecordType(stylesById) {
  const stylesForNextShapeValidators = {};
  for (const [id, style] of stylesById) {
    stylesForNextShapeValidators[id] = validation_exports.optional(style);
  }
  const instanceTypeValidator = validation_exports.model("instance", validation_exports.object({
    typeName: validation_exports.literal("instance"),
    id: idValidator("instance"),
    currentPageId: pageIdValidator,
    followingUserId: validation_exports.string.nullable(),
    brush: boxModelValidator.nullable(),
    opacityForNextShape: opacityValidator,
    stylesForNextShape: validation_exports.object(stylesForNextShapeValidators),
    cursor: cursorValidator,
    scribbles: validation_exports.arrayOf(scribbleValidator),
    isFocusMode: validation_exports.boolean,
    isDebugMode: validation_exports.boolean,
    isToolLocked: validation_exports.boolean,
    exportBackground: validation_exports.boolean,
    screenBounds: boxModelValidator,
    insets: validation_exports.arrayOf(validation_exports.boolean),
    zoomBrush: boxModelValidator.nullable(),
    isPenMode: validation_exports.boolean,
    isGridMode: validation_exports.boolean,
    chatMessage: validation_exports.string,
    isChatting: validation_exports.boolean,
    highlightedUserIds: validation_exports.arrayOf(validation_exports.string),
    isFocused: validation_exports.boolean,
    devicePixelRatio: validation_exports.number,
    isCoarsePointer: validation_exports.boolean,
    isHoveringCanvas: validation_exports.boolean.nullable(),
    openMenus: validation_exports.arrayOf(validation_exports.string),
    isChangingStyle: validation_exports.boolean,
    isReadonly: validation_exports.boolean,
    meta: validation_exports.jsonValue,
    duplicateProps: validation_exports.object({
      shapeIds: validation_exports.arrayOf(idValidator("shape")),
      offset: validation_exports.object({
        x: validation_exports.number,
        y: validation_exports.number
      })
    }).nullable()
  }));
  return createRecordType("instance", {
    validator: instanceTypeValidator,
    scope: "session",
    ephemeralKeys: {
      currentPageId: false,
      meta: false,
      followingUserId: true,
      opacityForNextShape: true,
      stylesForNextShape: true,
      brush: true,
      cursor: true,
      scribbles: true,
      isFocusMode: true,
      isDebugMode: true,
      isToolLocked: true,
      exportBackground: true,
      screenBounds: true,
      insets: true,
      zoomBrush: true,
      isPenMode: true,
      isGridMode: true,
      chatMessage: true,
      isChatting: true,
      highlightedUserIds: true,
      isFocused: true,
      devicePixelRatio: true,
      isCoarsePointer: true,
      isHoveringCanvas: true,
      openMenus: true,
      isChangingStyle: true,
      isReadonly: true,
      duplicateProps: true
    }
  }).withDefaultProperties(() => ({
    followingUserId: null,
    opacityForNextShape: 1,
    stylesForNextShape: {},
    brush: null,
    scribbles: [],
    cursor: {
      type: "default",
      rotation: 0
    },
    isFocusMode: false,
    exportBackground: false,
    isDebugMode: false,
    isToolLocked: false,
    screenBounds: { x: 0, y: 0, w: 1080, h: 720 },
    insets: [false, false, false, false],
    zoomBrush: null,
    isGridMode: false,
    isPenMode: false,
    chatMessage: "",
    isChatting: false,
    highlightedUserIds: [],
    isFocused: false,
    devicePixelRatio: typeof window === "undefined" ? 1 : window.devicePixelRatio,
    isCoarsePointer: false,
    isHoveringCanvas: null,
    openMenus: [],
    isChangingStyle: false,
    isReadonly: false,
    meta: {},
    duplicateProps: null
  }));
}
var shouldKeyBePreservedBetweenSessions, pluckPreservingValues, instanceIdValidator, instanceVersions, instanceMigrations, TLINSTANCE_ID;
var init_TLInstance = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLInstance.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
    init_dist_esm6();
    init_geometry_types();
    init_id_validator();
    init_TLCursor();
    init_TLOpacity();
    init_TLScribble();
    init_TLPage();
    shouldKeyBePreservedBetweenSessions = {
      id: false,
      typeName: false,
      currentPageId: false,
      opacityForNextShape: false,
      stylesForNextShape: false,
      followingUserId: false,
      highlightedUserIds: false,
      brush: false,
      cursor: false,
      scribbles: false,
      isFocusMode: true,
      isDebugMode: true,
      isToolLocked: true,
      exportBackground: true,
      screenBounds: true,
      insets: true,
      zoomBrush: false,
      chatMessage: false,
      isChatting: false,
      isPenMode: false,
      isGridMode: true,
      isFocused: true,
      devicePixelRatio: true,
      isCoarsePointer: true,
      isHoveringCanvas: false,
      openMenus: false,
      isChangingStyle: false,
      isReadonly: true,
      meta: false,
      duplicateProps: false
    };
    pluckPreservingValues = (val) => val ? filterEntries4(val, (key) => {
      return shouldKeyBePreservedBetweenSessions[key];
    }) : null;
    instanceIdValidator = idValidator("instance");
    instanceVersions = createMigrationIds("com.tldraw.instance", {
      AddTransparentExportBgs: 1,
      RemoveDialog: 2,
      AddToolLockMode: 3,
      RemoveExtraPropsForNextShape: 4,
      AddLabelColor: 5,
      AddFollowingUserId: 6,
      RemoveAlignJustify: 7,
      AddZoom: 8,
      AddVerticalAlign: 9,
      AddScribbleDelay: 10,
      RemoveUserId: 11,
      AddIsPenModeAndIsGridMode: 12,
      HoistOpacity: 13,
      AddChat: 14,
      AddHighlightedUserIds: 15,
      ReplacePropsForNextShapeWithStylesForNextShape: 16,
      AddMeta: 17,
      RemoveCursorColor: 18,
      AddLonelyProperties: 19,
      ReadOnlyReadonly: 20,
      AddHoveringCanvas: 21,
      AddScribbles: 22,
      AddInset: 23,
      AddDuplicateProps: 24,
      RemoveCanMoveCamera: 25
    });
    instanceMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.instance",
      recordType: "instance",
      sequence: [
        {
          id: instanceVersions.AddTransparentExportBgs,
          up: (instance) => {
            return { ...instance, exportBackground: true };
          }
        },
        {
          id: instanceVersions.RemoveDialog,
          up: ({ dialog: _2, ...instance }) => {
            return instance;
          }
        },
        {
          id: instanceVersions.AddToolLockMode,
          up: (instance) => {
            return { ...instance, isToolLocked: false };
          }
        },
        {
          id: instanceVersions.RemoveExtraPropsForNextShape,
          up: ({ propsForNextShape, ...instance }) => {
            return {
              ...instance,
              propsForNextShape: Object.fromEntries(Object.entries(propsForNextShape).filter(([key]) => [
                "color",
                "labelColor",
                "dash",
                "fill",
                "size",
                "font",
                "align",
                "verticalAlign",
                "icon",
                "geo",
                "arrowheadStart",
                "arrowheadEnd",
                "spline"
              ].includes(key)))
            };
          }
        },
        {
          id: instanceVersions.AddLabelColor,
          up: ({ propsForNextShape, ...instance }) => {
            return {
              ...instance,
              propsForNextShape: {
                ...propsForNextShape,
                labelColor: "black"
              }
            };
          }
        },
        {
          id: instanceVersions.AddFollowingUserId,
          up: (instance) => {
            return { ...instance, followingUserId: null };
          }
        },
        {
          id: instanceVersions.RemoveAlignJustify,
          up: (instance) => {
            let newAlign = instance.propsForNextShape.align;
            if (newAlign === "justify") {
              newAlign = "start";
            }
            return {
              ...instance,
              propsForNextShape: {
                ...instance.propsForNextShape,
                align: newAlign
              }
            };
          }
        },
        {
          id: instanceVersions.AddZoom,
          up: (instance) => {
            return { ...instance, zoomBrush: null };
          }
        },
        {
          id: instanceVersions.AddVerticalAlign,
          up: (instance) => {
            return {
              ...instance,
              propsForNextShape: {
                ...instance.propsForNextShape,
                verticalAlign: "middle"
              }
            };
          }
        },
        {
          id: instanceVersions.AddScribbleDelay,
          up: (instance) => {
            if (instance.scribble !== null) {
              return { ...instance, scribble: { ...instance.scribble, delay: 0 } };
            }
            return { ...instance };
          }
        },
        {
          id: instanceVersions.RemoveUserId,
          up: ({ userId: _2, ...instance }) => {
            return instance;
          }
        },
        {
          id: instanceVersions.AddIsPenModeAndIsGridMode,
          up: (instance) => {
            return { ...instance, isPenMode: false, isGridMode: false };
          }
        },
        {
          id: instanceVersions.HoistOpacity,
          up: ({ propsForNextShape: { opacity, ...propsForNextShape }, ...instance }) => {
            return { ...instance, opacityForNextShape: Number(opacity ?? "1"), propsForNextShape };
          }
        },
        {
          id: instanceVersions.AddChat,
          up: (instance) => {
            return { ...instance, chatMessage: "", isChatting: false };
          }
        },
        {
          id: instanceVersions.AddHighlightedUserIds,
          up: (instance) => {
            return { ...instance, highlightedUserIds: [] };
          }
        },
        {
          id: instanceVersions.ReplacePropsForNextShapeWithStylesForNextShape,
          up: ({ propsForNextShape: _2, ...instance }) => {
            return { ...instance, stylesForNextShape: {} };
          }
        },
        {
          id: instanceVersions.AddMeta,
          up: (record) => {
            return {
              ...record,
              meta: {}
            };
          }
        },
        {
          id: instanceVersions.RemoveCursorColor,
          up: (record) => {
            const { color: _2, ...cursor } = record.cursor;
            return {
              ...record,
              cursor
            };
          }
        },
        {
          id: instanceVersions.AddLonelyProperties,
          up: (record) => {
            return {
              ...record,
              canMoveCamera: true,
              isFocused: false,
              devicePixelRatio: 1,
              isCoarsePointer: false,
              openMenus: [],
              isChangingStyle: false,
              isReadOnly: false
            };
          }
        },
        {
          id: instanceVersions.ReadOnlyReadonly,
          up: ({ isReadOnly: _isReadOnly, ...record }) => {
            return {
              ...record,
              isReadonly: _isReadOnly
            };
          }
        },
        {
          id: instanceVersions.AddHoveringCanvas,
          up: (record) => {
            return {
              ...record,
              isHoveringCanvas: null
            };
          }
        },
        {
          id: instanceVersions.AddScribbles,
          up: ({ scribble: _2, ...record }) => {
            return {
              ...record,
              scribbles: []
            };
          }
        },
        {
          id: instanceVersions.AddInset,
          up: (record) => {
            return {
              ...record,
              insets: [false, false, false, false]
            };
          },
          down: ({ insets: _2, ...record }) => {
            return {
              ...record
            };
          }
        },
        {
          id: instanceVersions.AddDuplicateProps,
          up: (record) => {
            return {
              ...record,
              duplicateProps: null
            };
          },
          down: ({ duplicateProps: _2, ...record }) => {
            return {
              ...record
            };
          }
        },
        {
          id: instanceVersions.RemoveCanMoveCamera,
          up: ({ canMoveCamera: _2, ...record }) => {
            return {
              ...record
            };
          },
          down: (instance) => {
            return { ...instance, canMoveCamera: true };
          }
        }
      ]
    });
    TLINSTANCE_ID = "instance:instance";
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLPageState.mjs
var instancePageStateValidator, instancePageStateVersions, instancePageStateMigrations, InstancePageStateRecordType;
var init_TLPageState = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLPageState.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_id_validator();
    init_TLBaseShape();
    init_TLPage();
    instancePageStateValidator = validation_exports.model("instance_page_state", validation_exports.object({
      typeName: validation_exports.literal("instance_page_state"),
      id: idValidator("instance_page_state"),
      pageId: pageIdValidator,
      selectedShapeIds: validation_exports.arrayOf(shapeIdValidator),
      hintingShapeIds: validation_exports.arrayOf(shapeIdValidator),
      erasingShapeIds: validation_exports.arrayOf(shapeIdValidator),
      hoveredShapeId: shapeIdValidator.nullable(),
      editingShapeId: shapeIdValidator.nullable(),
      croppingShapeId: shapeIdValidator.nullable(),
      focusedGroupId: shapeIdValidator.nullable(),
      meta: validation_exports.jsonValue
    }));
    instancePageStateVersions = createMigrationIds("com.tldraw.instance_page_state", {
      AddCroppingId: 1,
      RemoveInstanceIdAndCameraId: 2,
      AddMeta: 3,
      RenameProperties: 4,
      RenamePropertiesAgain: 5
    });
    instancePageStateMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.instance_page_state",
      recordType: "instance_page_state",
      sequence: [
        {
          id: instancePageStateVersions.AddCroppingId,
          up(instance) {
            instance.croppingShapeId = null;
          }
        },
        {
          id: instancePageStateVersions.RemoveInstanceIdAndCameraId,
          up(instance) {
            delete instance.instanceId;
            delete instance.cameraId;
          }
        },
        {
          id: instancePageStateVersions.AddMeta,
          up: (record) => {
            record.meta = {};
          }
        },
        {
          id: instancePageStateVersions.RenameProperties,
          up: (_record) => {
          },
          down: (_record) => {
          }
        },
        {
          id: instancePageStateVersions.RenamePropertiesAgain,
          up: (record) => {
            record.selectedShapeIds = record.selectedIds;
            delete record.selectedIds;
            record.hintingShapeIds = record.hintingIds;
            delete record.hintingIds;
            record.erasingShapeIds = record.erasingIds;
            delete record.erasingIds;
            record.hoveredShapeId = record.hoveredId;
            delete record.hoveredId;
            record.editingShapeId = record.editingId;
            delete record.editingId;
            record.croppingShapeId = record.croppingShapeId ?? record.croppingId ?? null;
            delete record.croppingId;
            record.focusedGroupId = record.focusLayerId;
            delete record.focusLayerId;
          },
          down: (record) => {
            record.selectedIds = record.selectedShapeIds;
            delete record.selectedShapeIds;
            record.hintingIds = record.hintingShapeIds;
            delete record.hintingShapeIds;
            record.erasingIds = record.erasingShapeIds;
            delete record.erasingShapeIds;
            record.hoveredId = record.hoveredShapeId;
            delete record.hoveredShapeId;
            record.editingId = record.editingShapeId;
            delete record.editingShapeId;
            record.croppingId = record.croppingShapeId;
            delete record.croppingShapeId;
            record.focusLayerId = record.focusedGroupId;
            delete record.focusedGroupId;
          }
        }
      ]
    });
    InstancePageStateRecordType = createRecordType("instance_page_state", {
      validator: instancePageStateValidator,
      scope: "session",
      ephemeralKeys: {
        pageId: false,
        selectedShapeIds: false,
        editingShapeId: false,
        croppingShapeId: false,
        meta: false,
        hintingShapeIds: true,
        erasingShapeIds: true,
        hoveredShapeId: true,
        focusedGroupId: true
      }
    }).withDefaultProperties(() => ({
      editingShapeId: null,
      croppingShapeId: null,
      selectedShapeIds: [],
      hoveredShapeId: null,
      erasingShapeIds: [],
      hintingShapeIds: [],
      focusedGroupId: null,
      meta: {}
    }));
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLPointer.mjs
var pointerValidator, pointerVersions, pointerMigrations, PointerRecordType, TLPOINTER_ID;
var init_TLPointer = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLPointer.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_id_validator();
    pointerValidator = validation_exports.model("pointer", validation_exports.object({
      typeName: validation_exports.literal("pointer"),
      id: idValidator("pointer"),
      x: validation_exports.number,
      y: validation_exports.number,
      lastActivityTimestamp: validation_exports.number,
      meta: validation_exports.jsonValue
    }));
    pointerVersions = createMigrationIds("com.tldraw.pointer", {
      AddMeta: 1
    });
    pointerMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.pointer",
      recordType: "pointer",
      sequence: [
        {
          id: pointerVersions.AddMeta,
          up: (record) => {
            record.meta = {};
          }
        }
      ]
    });
    PointerRecordType = createRecordType("pointer", {
      validator: pointerValidator,
      scope: "session"
    }).withDefaultProperties(() => ({
      x: 0,
      y: 0,
      lastActivityTimestamp: 0,
      meta: {}
    }));
    TLPOINTER_ID = PointerRecordType.createId("pointer");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLPresence.mjs
var instancePresenceValidator, instancePresenceVersions, instancePresenceMigrations, InstancePresenceRecordType;
var init_TLPresence = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLPresence.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_geometry_types();
    init_id_validator();
    init_TLCursor();
    init_TLScribble();
    instancePresenceValidator = validation_exports.model("instance_presence", validation_exports.object({
      typeName: validation_exports.literal("instance_presence"),
      id: idValidator("instance_presence"),
      userId: validation_exports.string,
      userName: validation_exports.string,
      lastActivityTimestamp: validation_exports.number,
      followingUserId: validation_exports.string.nullable(),
      cursor: validation_exports.object({
        x: validation_exports.number,
        y: validation_exports.number,
        type: cursorTypeValidator,
        rotation: validation_exports.number
      }),
      color: validation_exports.string,
      camera: validation_exports.object({
        x: validation_exports.number,
        y: validation_exports.number,
        z: validation_exports.number
      }),
      screenBounds: boxModelValidator,
      selectedShapeIds: validation_exports.arrayOf(idValidator("shape")),
      currentPageId: idValidator("page"),
      brush: boxModelValidator.nullable(),
      scribbles: validation_exports.arrayOf(scribbleValidator),
      chatMessage: validation_exports.string,
      meta: validation_exports.jsonValue
    }));
    instancePresenceVersions = createMigrationIds("com.tldraw.instance_presence", {
      AddScribbleDelay: 1,
      RemoveInstanceId: 2,
      AddChatMessage: 3,
      AddMeta: 4,
      RenameSelectedShapeIds: 5
    });
    instancePresenceMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.instance_presence",
      recordType: "instance_presence",
      sequence: [
        {
          id: instancePresenceVersions.AddScribbleDelay,
          up: (instance) => {
            if (instance.scribble !== null) {
              instance.scribble.delay = 0;
            }
          }
        },
        {
          id: instancePresenceVersions.RemoveInstanceId,
          up: (instance) => {
            delete instance.instanceId;
          }
        },
        {
          id: instancePresenceVersions.AddChatMessage,
          up: (instance) => {
            instance.chatMessage = "";
          }
        },
        {
          id: instancePresenceVersions.AddMeta,
          up: (record) => {
            record.meta = {};
          }
        },
        {
          id: instancePresenceVersions.RenameSelectedShapeIds,
          up: (_record) => {
          }
        }
      ]
    });
    InstancePresenceRecordType = createRecordType("instance_presence", {
      validator: instancePresenceValidator,
      scope: "presence"
    }).withDefaultProperties(() => ({
      lastActivityTimestamp: 0,
      followingUserId: null,
      color: "#FF0000",
      camera: {
        x: 0,
        y: 0,
        z: 1
      },
      cursor: {
        x: 0,
        y: 0,
        type: "default",
        rotation: 0
      },
      screenBounds: {
        x: 0,
        y: 0,
        w: 1,
        h: 1
      },
      selectedShapeIds: [],
      brush: null,
      scribbles: [],
      chatMessage: "",
      meta: {}
    }));
  }
});

// node_modules/@tldraw/tlschema/dist-esm/createPresenceStateDerivation.mjs
var init_createPresenceStateDerivation = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/createPresenceStateDerivation.mjs"() {
    init_dist_esm();
    init_TLCamera();
    init_TLInstance();
    init_TLPageState();
    init_TLPointer();
    init_TLPresence();
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLDocument.mjs
var documentValidator, documentVersions, documentMigrations, DocumentRecordType, TLDOCUMENT_ID;
var init_TLDocument = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLDocument.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    documentValidator = validation_exports.model("document", validation_exports.object({
      typeName: validation_exports.literal("document"),
      id: validation_exports.literal("document:document"),
      gridSize: validation_exports.number,
      name: validation_exports.string,
      meta: validation_exports.jsonValue
    }));
    documentVersions = createMigrationIds("com.tldraw.document", {
      AddName: 1,
      AddMeta: 2
    });
    documentMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.document",
      recordType: "document",
      sequence: [
        {
          id: documentVersions.AddName,
          up: (document2) => {
            ;
            document2.name = "";
          },
          down: (document2) => {
            delete document2.name;
          }
        },
        {
          id: documentVersions.AddMeta,
          up: (record) => {
            ;
            record.meta = {};
          }
        }
      ]
    });
    DocumentRecordType = createRecordType("document", {
      validator: documentValidator,
      scope: "document"
    }).withDefaultProperties(() => ({
      gridSize: 10,
      name: "",
      meta: {}
    }));
    TLDOCUMENT_ID = DocumentRecordType.createId("document");
  }
});

// node_modules/@tldraw/tlschema/dist-esm/TLStore.mjs
function sortByIndex5(a2, b2) {
  if (a2.index < b2.index) {
    return -1;
  } else if (a2.index > b2.index) {
    return 1;
  }
  return 0;
}
function redactRecordForErrorReporting(record) {
  if (record.typeName === "asset") {
    if ("src" in record) {
      record.src = "<redacted>";
    }
    if ("src" in record.props) {
      record.props.src = "<redacted>";
    }
  }
}
function getDefaultPages() {
  return [
    PageRecordType.create({
      id: "page:page",
      name: "Page 1",
      index: "a1",
      meta: {}
    })
  ];
}
function createIntegrityChecker(store) {
  const $pageIds = store.query.ids("page");
  const ensureStoreIsUsable = () => {
    if (!store.has(TLDOCUMENT_ID)) {
      store.put([DocumentRecordType.create({ id: TLDOCUMENT_ID, name: store.props.defaultName })]);
      return ensureStoreIsUsable();
    }
    if (!store.has(TLPOINTER_ID)) {
      store.put([PointerRecordType.create({ id: TLPOINTER_ID })]);
      return ensureStoreIsUsable();
    }
    const pageIds = $pageIds.get();
    if (pageIds.size === 0) {
      store.put(getDefaultPages());
      return ensureStoreIsUsable();
    }
    const getFirstPageId = () => [...pageIds].map((id) => store.get(id)).sort(sortByIndex5)[0].id;
    const instanceState = store.get(TLINSTANCE_ID);
    if (!instanceState) {
      store.put([
        store.schema.types.instance.create({
          id: TLINSTANCE_ID,
          currentPageId: getFirstPageId(),
          exportBackground: true
        })
      ]);
      return ensureStoreIsUsable();
    } else if (!pageIds.has(instanceState.currentPageId)) {
      store.put([{ ...instanceState, currentPageId: getFirstPageId() }]);
      return ensureStoreIsUsable();
    }
    const missingPageStateIds = /* @__PURE__ */ new Set();
    const missingCameraIds = /* @__PURE__ */ new Set();
    for (const id of pageIds) {
      const pageStateId = InstancePageStateRecordType.createId(id);
      if (!store.has(pageStateId)) {
        missingPageStateIds.add(pageStateId);
      }
      const cameraId = CameraRecordType.createId(id);
      if (!store.has(cameraId)) {
        missingCameraIds.add(cameraId);
      }
    }
    if (missingPageStateIds.size > 0) {
      store.put([...missingPageStateIds].map((id) => InstancePageStateRecordType.create({
        id,
        pageId: InstancePageStateRecordType.parseId(id)
      })));
    }
    if (missingCameraIds.size > 0) {
      store.put([...missingCameraIds].map((id) => CameraRecordType.create({ id })));
    }
  };
  return ensureStoreIsUsable;
}
var onValidationFailure;
var init_TLStore = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/TLStore.mjs"() {
    init_dist_esm7();
    init_TLCamera();
    init_TLDocument();
    init_TLInstance();
    init_TLPage();
    init_TLPageState();
    init_TLPointer();
    onValidationFailure = ({ error: error2, phase: phase2, record, recordBefore }) => {
      const isExistingValidationIssue = phase2 === "initialize";
      annotateError4(error2, {
        tags: {
          origin: "store.validateRecord",
          storePhase: phase2,
          isExistingValidationIssue
        },
        extras: {
          recordBefore: recordBefore ? redactRecordForErrorReporting(structuredClone5(recordBefore)) : void 0,
          recordAfter: redactRecordForErrorReporting(structuredClone5(record))
        }
      });
      throw error2;
    };
  }
});

// node_modules/@tldraw/tlschema/dist-esm/assets/TLBookmarkAsset.mjs
var bookmarkAssetValidator, Versions, bookmarkAssetMigrations;
var init_TLBookmarkAsset = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/assets/TLBookmarkAsset.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_TLBaseAsset();
    bookmarkAssetValidator = createAssetValidator("bookmark", validation_exports.object({
      title: validation_exports.string,
      description: validation_exports.string,
      image: validation_exports.string,
      favicon: validation_exports.string,
      src: validation_exports.srcUrl.nullable()
    }));
    Versions = createMigrationIds("com.tldraw.asset.bookmark", {
      MakeUrlsValid: 1,
      AddFavicon: 2
    });
    bookmarkAssetMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.asset.bookmark",
      recordType: "asset",
      filter: (asset) => asset.type === "bookmark",
      sequence: [
        {
          id: Versions.MakeUrlsValid,
          up: (asset) => {
            if (!validation_exports.srcUrl.isValid(asset.props.src)) {
              asset.props.src = "";
            }
          },
          down: (_asset) => {
          }
        },
        {
          id: Versions.AddFavicon,
          up: (asset) => {
            if (!validation_exports.srcUrl.isValid(asset.props.favicon)) {
              asset.props.favicon = "";
            }
          },
          down: (asset) => {
            delete asset.props.favicon;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/assets/TLImageAsset.mjs
var imageAssetValidator, Versions2, imageAssetMigrations;
var init_TLImageAsset = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/assets/TLImageAsset.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_TLBaseAsset();
    imageAssetValidator = createAssetValidator("image", validation_exports.object({
      w: validation_exports.number,
      h: validation_exports.number,
      name: validation_exports.string,
      isAnimated: validation_exports.boolean,
      mimeType: validation_exports.string.nullable(),
      src: validation_exports.srcUrl.nullable(),
      fileSize: validation_exports.nonZeroNumber.optional()
    }));
    Versions2 = createMigrationIds("com.tldraw.asset.image", {
      AddIsAnimated: 1,
      RenameWidthHeight: 2,
      MakeUrlsValid: 3,
      AddFileSize: 4,
      MakeFileSizeOptional: 5
    });
    imageAssetMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.asset.image",
      recordType: "asset",
      filter: (asset) => asset.type === "image",
      sequence: [
        {
          id: Versions2.AddIsAnimated,
          up: (asset) => {
            asset.props.isAnimated = false;
          },
          down: (asset) => {
            delete asset.props.isAnimated;
          }
        },
        {
          id: Versions2.RenameWidthHeight,
          up: (asset) => {
            asset.props.w = asset.props.width;
            asset.props.h = asset.props.height;
            delete asset.props.width;
            delete asset.props.height;
          },
          down: (asset) => {
            asset.props.width = asset.props.w;
            asset.props.height = asset.props.h;
            delete asset.props.w;
            delete asset.props.h;
          }
        },
        {
          id: Versions2.MakeUrlsValid,
          up: (asset) => {
            if (!validation_exports.srcUrl.isValid(asset.props.src)) {
              asset.props.src = "";
            }
          },
          down: (_asset) => {
          }
        },
        {
          id: Versions2.AddFileSize,
          up: (asset) => {
            asset.props.fileSize = -1;
          },
          down: (asset) => {
            delete asset.props.fileSize;
          }
        },
        {
          id: Versions2.MakeFileSizeOptional,
          up: (asset) => {
            if (asset.props.fileSize === -1) {
              asset.props.fileSize = void 0;
            }
          },
          down: (asset) => {
            if (asset.props.fileSize === void 0) {
              asset.props.fileSize = -1;
            }
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/assets/TLVideoAsset.mjs
var videoAssetValidator, Versions3, videoAssetMigrations;
var init_TLVideoAsset = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/assets/TLVideoAsset.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_TLBaseAsset();
    videoAssetValidator = createAssetValidator("video", validation_exports.object({
      w: validation_exports.number,
      h: validation_exports.number,
      name: validation_exports.string,
      isAnimated: validation_exports.boolean,
      mimeType: validation_exports.string.nullable(),
      src: validation_exports.srcUrl.nullable(),
      fileSize: validation_exports.number.optional()
    }));
    Versions3 = createMigrationIds("com.tldraw.asset.video", {
      AddIsAnimated: 1,
      RenameWidthHeight: 2,
      MakeUrlsValid: 3,
      AddFileSize: 4,
      MakeFileSizeOptional: 5
    });
    videoAssetMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.asset.video",
      recordType: "asset",
      filter: (asset) => asset.type === "video",
      sequence: [
        {
          id: Versions3.AddIsAnimated,
          up: (asset) => {
            asset.props.isAnimated = false;
          },
          down: (asset) => {
            delete asset.props.isAnimated;
          }
        },
        {
          id: Versions3.RenameWidthHeight,
          up: (asset) => {
            asset.props.w = asset.props.width;
            asset.props.h = asset.props.height;
            delete asset.props.width;
            delete asset.props.height;
          },
          down: (asset) => {
            asset.props.width = asset.props.w;
            asset.props.height = asset.props.h;
            delete asset.props.w;
            delete asset.props.h;
          }
        },
        {
          id: Versions3.MakeUrlsValid,
          up: (asset) => {
            if (!validation_exports.srcUrl.isValid(asset.props.src)) {
              asset.props.src = "";
            }
          },
          down: (_asset) => {
          }
        },
        {
          id: Versions3.AddFileSize,
          up: (asset) => {
            asset.props.fileSize = -1;
          },
          down: (asset) => {
            delete asset.props.fileSize;
          }
        },
        {
          id: Versions3.MakeFileSizeOptional,
          up: (asset) => {
            if (asset.props.fileSize === -1) {
              asset.props.fileSize = void 0;
            }
          },
          down: (asset) => {
            if (asset.props.fileSize === void 0) {
              asset.props.fileSize = -1;
            }
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/records/TLAsset.mjs
var assetValidator, assetVersions, assetMigrations, AssetRecordType;
var init_TLAsset = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/records/TLAsset.mjs"() {
    init_dist_esm4();
    init_dist_esm6();
    init_TLBookmarkAsset();
    init_TLImageAsset();
    init_TLVideoAsset();
    assetValidator = validation_exports.model("asset", validation_exports.union("type", {
      image: imageAssetValidator,
      video: videoAssetValidator,
      bookmark: bookmarkAssetValidator
    }));
    assetVersions = createMigrationIds("com.tldraw.asset", {
      AddMeta: 1
    });
    assetMigrations = createRecordMigrationSequence({
      sequenceId: "com.tldraw.asset",
      recordType: "asset",
      sequence: [
        {
          id: assetVersions.AddMeta,
          up: (record) => {
            ;
            record.meta = {};
          }
        }
      ]
    });
    AssetRecordType = createRecordType("asset", {
      validator: assetValidator,
      scope: "document"
    }).withDefaultProperties(() => ({
      meta: {}
    }));
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLBookmarkShape.mjs
var bookmarkShapeProps, Versions4, bookmarkShapeMigrations;
var init_TLBookmarkShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLBookmarkShape.mjs"() {
    init_dist_esm6();
    init_TLBaseAsset();
    init_TLShape();
    bookmarkShapeProps = {
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      assetId: assetIdValidator.nullable(),
      url: validation_exports.linkUrl
    };
    Versions4 = createShapePropsMigrationIds("bookmark", {
      NullAssetId: 1,
      MakeUrlsValid: 2
    });
    bookmarkShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions4.NullAssetId,
          up: (props) => {
            if (props.assetId === void 0) {
              props.assetId = null;
            }
          },
          down: "retired"
        },
        {
          id: Versions4.MakeUrlsValid,
          up: (props) => {
            if (!validation_exports.linkUrl.isValid(props.url)) {
              props.url = "";
            }
          },
          down: (_props) => {
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLDrawShape.mjs
var DrawShapeSegment, drawShapeProps, Versions5, drawShapeMigrations;
var init_TLDrawShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLDrawShape.mjs"() {
    init_dist_esm6();
    init_geometry_types();
    init_TLShape();
    init_TLColorStyle();
    init_TLDashStyle();
    init_TLFillStyle();
    init_TLSizeStyle();
    DrawShapeSegment = validation_exports.object({
      type: validation_exports.literalEnum("free", "straight"),
      points: validation_exports.arrayOf(vecModelValidator)
    });
    drawShapeProps = {
      color: DefaultColorStyle,
      fill: DefaultFillStyle,
      dash: DefaultDashStyle,
      size: DefaultSizeStyle,
      segments: validation_exports.arrayOf(DrawShapeSegment),
      isComplete: validation_exports.boolean,
      isClosed: validation_exports.boolean,
      isPen: validation_exports.boolean,
      scale: validation_exports.nonZeroNumber
    };
    Versions5 = createShapePropsMigrationIds("draw", {
      AddInPen: 1,
      AddScale: 2
    });
    drawShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions5.AddInPen,
          up: (props) => {
            const { points } = props.segments[0];
            if (points.length === 0) {
              props.isPen = false;
              return;
            }
            let isPen = !(points[0].z === 0 || points[0].z === 0.5);
            if (points[1]) {
              isPen = isPen && !(points[1].z === 0 || points[1].z === 0.5);
            }
            props.isPen = isPen;
          },
          down: "retired"
        },
        {
          id: Versions5.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLEmbedShape.mjs
var TLDRAW_APP_RE, safeParseUrl, EMBED_DEFINITIONS, embedShapePermissionDefaults, embedShapeProps, Versions6, embedShapeMigrations;
var init_TLEmbedShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLEmbedShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    TLDRAW_APP_RE = /(^\/r\/[^/]+\/?$)/;
    safeParseUrl = (url) => {
      try {
        return new URL(url);
      } catch (err) {
        return;
      }
    };
    EMBED_DEFINITIONS = [
      {
        type: "tldraw",
        title: "tldraw",
        hostnames: ["beta.tldraw.com", "tldraw.com", "localhost:3000"],
        minWidth: 300,
        minHeight: 300,
        width: 720,
        height: 500,
        doesResize: true,
        overridePermissions: {
          "allow-top-navigation": true
        },
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(TLDRAW_APP_RE)) {
            return url;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(TLDRAW_APP_RE)) {
            return url;
          }
          return;
        }
      },
      {
        type: "figma",
        title: "Figma",
        hostnames: ["figma.com"],
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          if (!!url.match(/https:\/\/([\w\.-]+\.)?figma.com\/(file|proto)\/([0-9a-zA-Z]{22,128})(?:\/.*)?$/) && !url.includes("figma.com/embed")) {
            return `https://www.figma.com/embed?embed_host=share&url=${url}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/embed\/?$/)) {
            const outUrl = urlObj.searchParams.get("url");
            if (outUrl) {
              return outUrl;
            }
          }
          return;
        }
      },
      {
        type: "google_maps",
        title: "Google Maps",
        hostnames: ["google.*"],
        width: 720,
        height: 500,
        doesResize: true,
        overridePermissions: {
          "allow-presentation": true
        },
        toEmbedUrl: (url) => {
          if (url.includes("/maps/")) {
            const match = url.match(/@(.*),(.*),(.*)z/);
            let result;
            if (match) {
              const [, lat, lng, z] = match;
              const host = new URL(url).host.replace("www.", "");
              result = `https://${host}/maps/embed/v1/view?key=${process.env.NEXT_PUBLIC_GC_API_KEY}&center=${lat},${lng}&zoom=${z}`;
            } else {
              result = "";
            }
            return result;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (!urlObj)
            return;
          const matches = urlObj.pathname.match(/^\/maps\/embed\/v1\/view\/?$/);
          if (matches && urlObj.searchParams.has("center") && urlObj.searchParams.get("zoom")) {
            const zoom = urlObj.searchParams.get("zoom");
            const [lat, lon] = urlObj.searchParams.get("center").split(",");
            return `https://www.google.com/maps/@${lat},${lon},${zoom}z`;
          }
          return;
        }
      },
      {
        type: "val_town",
        title: "Val Town",
        hostnames: ["val.town"],
        minWidth: 260,
        minHeight: 100,
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const matches = urlObj && urlObj.pathname.match(/\/v\/(.+)\/?/);
          if (matches) {
            return `https://www.val.town/embed/${matches[1]}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const matches = urlObj && urlObj.pathname.match(/\/embed\/(.+)\/?/);
          if (matches) {
            return `https://www.val.town/v/${matches[1]}`;
          }
          return;
        }
      },
      {
        type: "codesandbox",
        title: "CodeSandbox",
        hostnames: ["codesandbox.io"],
        minWidth: 300,
        minHeight: 300,
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const matches = urlObj && urlObj.pathname.match(/\/s\/([^/]+)\/?/);
          if (matches) {
            return `https://codesandbox.io/embed/${matches[1]}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const matches = urlObj && urlObj.pathname.match(/\/embed\/([^/]+)\/?/);
          if (matches) {
            return `https://codesandbox.io/s/${matches[1]}`;
          }
          return;
        }
      },
      {
        type: "codepen",
        title: "Codepen",
        hostnames: ["codepen.io"],
        minWidth: 300,
        minHeight: 300,
        width: 520,
        height: 400,
        doesResize: true,
        toEmbedUrl: (url) => {
          const CODEPEN_URL_REGEXP = /https:\/\/codepen.io\/([^/]+)\/pen\/([^/]+)/;
          const matches = url.match(CODEPEN_URL_REGEXP);
          if (matches) {
            const [_2, user, id] = matches;
            return `https://codepen.io/${user}/embed/${id}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const CODEPEN_EMBED_REGEXP = /https:\/\/codepen.io\/([^/]+)\/embed\/([^/]+)/;
          const matches = url.match(CODEPEN_EMBED_REGEXP);
          if (matches) {
            const [_2, user, id] = matches;
            return `https://codepen.io/${user}/pen/${id}`;
          }
          return;
        }
      },
      {
        type: "scratch",
        title: "Scratch",
        hostnames: ["scratch.mit.edu"],
        width: 520,
        height: 400,
        doesResize: false,
        toEmbedUrl: (url) => {
          const SCRATCH_URL_REGEXP = /https?:\/\/scratch.mit.edu\/projects\/([^/]+)/;
          const matches = url.match(SCRATCH_URL_REGEXP);
          if (matches) {
            const [_2, id] = matches;
            return `https://scratch.mit.edu/projects/embed/${id}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const SCRATCH_EMBED_REGEXP = /https:\/\/scratch.mit.edu\/projects\/embed\/([^/]+)/;
          const matches = url.match(SCRATCH_EMBED_REGEXP);
          if (matches) {
            const [_2, id] = matches;
            return `https://scratch.mit.edu/projects/${id}`;
          }
          return;
        }
      },
      {
        type: "youtube",
        title: "YouTube",
        hostnames: ["*.youtube.com", "youtube.com", "youtu.be"],
        width: 800,
        height: 450,
        doesResize: true,
        overridePermissions: {
          "allow-presentation": true,
          "allow-popups-to-escape-sandbox": true
        },
        isAspectRatioLocked: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (!urlObj)
            return;
          const hostname = urlObj.hostname.replace(/^www./, "");
          if (hostname === "youtu.be") {
            const videoId = urlObj.pathname.split("/").filter(Boolean)[0];
            return `https://www.youtube.com/embed/${videoId}`;
          } else if ((hostname === "youtube.com" || hostname === "m.youtube.com") && urlObj.pathname.match(/^\/watch/)) {
            const videoId = urlObj.searchParams.get("v");
            return `https://www.youtube.com/embed/${videoId}`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (!urlObj)
            return;
          const hostname = urlObj.hostname.replace(/^www./, "");
          if (hostname === "youtube.com") {
            const matches = urlObj.pathname.match(/^\/embed\/([^/]+)\/?/);
            if (matches) {
              return `https://www.youtube.com/watch?v=${matches[1]}`;
            }
          }
          return;
        }
      },
      {
        type: "google_calendar",
        title: "Google Calendar",
        hostnames: ["calendar.google.*"],
        width: 720,
        height: 500,
        minWidth: 460,
        minHeight: 360,
        doesResize: true,
        instructionLink: "https://support.google.com/calendar/answer/41207?hl=en",
        overridePermissions: {
          "allow-popups-to-escape-sandbox": true
        },
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const cidQs = urlObj?.searchParams.get("cid");
          if (urlObj?.pathname.match(/\/calendar\/u\/0/) && cidQs) {
            urlObj.pathname = "/calendar/embed";
            const keys = Array.from(urlObj.searchParams.keys());
            for (const key of keys) {
              urlObj.searchParams.delete(key);
            }
            urlObj.searchParams.set("src", cidQs);
            return urlObj.href;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          const srcQs = urlObj?.searchParams.get("src");
          if (urlObj?.pathname.match(/\/calendar\/embed/) && srcQs) {
            urlObj.pathname = "/calendar/u/0";
            const keys = Array.from(urlObj.searchParams.keys());
            for (const key of keys) {
              urlObj.searchParams.delete(key);
            }
            urlObj.searchParams.set("cid", srcQs);
            return urlObj.href;
          }
          return;
        }
      },
      {
        type: "google_slides",
        title: "Google Slides",
        hostnames: ["docs.google.*"],
        width: 720,
        height: 500,
        minWidth: 460,
        minHeight: 360,
        doesResize: true,
        overridePermissions: {
          "allow-popups-to-escape-sandbox": true
        },
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj?.pathname.match(/^\/presentation/) && urlObj?.pathname.match(/\/pub\/?$/)) {
            urlObj.pathname = urlObj.pathname.replace(/\/pub$/, "/embed");
            const keys = Array.from(urlObj.searchParams.keys());
            for (const key of keys) {
              urlObj.searchParams.delete(key);
            }
            return urlObj.href;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj?.pathname.match(/^\/presentation/) && urlObj?.pathname.match(/\/embed\/?$/)) {
            urlObj.pathname = urlObj.pathname.replace(/\/embed$/, "/pub");
            const keys = Array.from(urlObj.searchParams.keys());
            for (const key of keys) {
              urlObj.searchParams.delete(key);
            }
            return urlObj.href;
          }
          return;
        }
      },
      {
        type: "github_gist",
        title: "GitHub Gist",
        hostnames: ["gist.github.com"],
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/\/([^/]+)\/([^/]+)/)) {
            if (!url.split("/").pop())
              return;
            return url;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/\/([^/]+)\/([^/]+)/)) {
            if (!url.split("/").pop())
              return;
            return url;
          }
          return;
        }
      },
      {
        type: "replit",
        title: "Replit",
        hostnames: ["replit.com"],
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/\/@([^/]+)\/([^/]+)/)) {
            return `${url}?embed=true`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/\/@([^/]+)\/([^/]+)/) && urlObj.searchParams.has("embed")) {
            urlObj.searchParams.delete("embed");
            return urlObj.href;
          }
          return;
        }
      },
      {
        type: "felt",
        title: "Felt",
        hostnames: ["felt.com"],
        width: 720,
        height: 500,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/map\//)) {
            return urlObj.origin + "/embed" + urlObj.pathname;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/embed\/map\//)) {
            urlObj.pathname = urlObj.pathname.replace(/^\/embed/, "");
            return urlObj.href;
          }
          return;
        }
      },
      {
        type: "spotify",
        title: "Spotify",
        hostnames: ["open.spotify.com"],
        width: 720,
        height: 500,
        minHeight: 500,
        overrideOutlineRadius: 12,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/(artist|album)\//)) {
            return urlObj.origin + "/embed" + urlObj.pathname;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/embed\/(artist|album)\//)) {
            return urlObj.origin + urlObj.pathname.replace(/^\/embed/, "");
          }
          return;
        }
      },
      {
        type: "vimeo",
        title: "Vimeo",
        hostnames: ["vimeo.com", "player.vimeo.com"],
        width: 640,
        height: 360,
        doesResize: true,
        isAspectRatioLocked: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hostname === "vimeo.com") {
            if (urlObj.pathname.match(/^\/[0-9]+/)) {
              return "https://player.vimeo.com/video/" + urlObj.pathname.split("/")[1] + "?title=0&byline=0";
            }
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hostname === "player.vimeo.com") {
            const matches = urlObj.pathname.match(/^\/video\/([^/]+)\/?$/);
            if (matches) {
              return "https://vimeo.com/" + matches[1];
            }
          }
          return;
        }
      },
      {
        type: "excalidraw",
        title: "Excalidraw",
        hostnames: ["excalidraw.com"],
        width: 720,
        height: 500,
        doesResize: true,
        isAspectRatioLocked: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hash.match(/#room=/)) {
            return url;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hash.match(/#room=/)) {
            return url;
          }
          return;
        }
      },
      {
        type: "observable",
        title: "Observable",
        hostnames: ["observablehq.com"],
        width: 720,
        height: 500,
        doesResize: true,
        isAspectRatioLocked: false,
        backgroundColor: "#fff",
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/@([^/]+)\/([^/]+)\/?$/)) {
            return `${urlObj.origin}/embed${urlObj.pathname}?cell=*`;
          }
          if (urlObj && urlObj.pathname.match(/^\/d\/([^/]+)\/?$/)) {
            const pathName = urlObj.pathname.replace(/^\/d/, "");
            return `${urlObj.origin}/embed${pathName}?cell=*`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.pathname.match(/^\/embed\/@([^/]+)\/([^/]+)\/?$/)) {
            return `${urlObj.origin}${urlObj.pathname.replace("/embed", "")}#cell-*`;
          }
          if (urlObj && urlObj.pathname.match(/^\/embed\/([^/]+)\/?$/)) {
            return `${urlObj.origin}${urlObj.pathname.replace("/embed", "/d")}#cell-*`;
          }
          return;
        }
      },
      {
        type: "desmos",
        title: "Desmos",
        hostnames: ["desmos.com"],
        width: 700,
        height: 450,
        doesResize: true,
        toEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hostname === "www.desmos.com" && urlObj.pathname.match(/^\/calculator\/([^/]+)\/?$/) && urlObj.search === "" && urlObj.hash === "") {
            return `${url}?embed`;
          }
          return;
        },
        fromEmbedUrl: (url) => {
          const urlObj = safeParseUrl(url);
          if (urlObj && urlObj.hostname === "www.desmos.com" && urlObj.pathname.match(/^\/calculator\/([^/]+)\/?$/) && urlObj.search === "?embed" && urlObj.hash === "") {
            return url.replace("?embed", "");
          }
          return;
        }
      }
    ];
    embedShapePermissionDefaults = {
      "allow-downloads-without-user-activation": false,
      "allow-downloads": false,
      "allow-modals": false,
      "allow-orientation-lock": false,
      "allow-pointer-lock": false,
      "allow-popups": true,
      "allow-popups-to-escape-sandbox": false,
      "allow-presentation": false,
      "allow-storage-access-by-user-activation": false,
      "allow-top-navigation": false,
      "allow-top-navigation-by-user-activation": false,
      "allow-scripts": true,
      "allow-same-origin": true,
      "allow-forms": true
    };
    embedShapeProps = {
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      url: validation_exports.string
    };
    Versions6 = createShapePropsMigrationIds("embed", {
      GenOriginalUrlInEmbed: 1,
      RemoveDoesResize: 2,
      RemoveTmpOldUrl: 3,
      RemovePermissionOverrides: 4
    });
    embedShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions6.GenOriginalUrlInEmbed,
          up: (props) => {
            try {
              const url = props.url;
              const host = new URL(url).host.replace("www.", "");
              let originalUrl;
              for (const localEmbedDef of EMBED_DEFINITIONS) {
                if (localEmbedDef.hostnames.includes(host)) {
                  try {
                    originalUrl = localEmbedDef.fromEmbedUrl(url);
                  } catch (err) {
                    console.warn(err);
                  }
                }
              }
              props.tmpOldUrl = props.url;
              props.url = originalUrl ?? "";
            } catch (e2) {
              props.url = "";
              props.tmpOldUrl = props.url;
            }
          },
          down: "retired"
        },
        {
          id: Versions6.RemoveDoesResize,
          up: (props) => {
            delete props.doesResize;
          },
          down: "retired"
        },
        {
          id: Versions6.RemoveTmpOldUrl,
          up: (props) => {
            delete props.tmpOldUrl;
          },
          down: "retired"
        },
        {
          id: Versions6.RemovePermissionOverrides,
          up: (props) => {
            delete props.overridePermissions;
          },
          down: "retired"
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLFrameShape.mjs
var frameShapeProps, frameShapeMigrations;
var init_TLFrameShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLFrameShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    frameShapeProps = {
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      name: validation_exports.string
    };
    frameShapeMigrations = createShapePropsMigrationSequence({
      sequence: []
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLHorizontalAlignStyle.mjs
var DefaultHorizontalAlignStyle;
var init_TLHorizontalAlignStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLHorizontalAlignStyle.mjs"() {
    init_StyleProp();
    DefaultHorizontalAlignStyle = StyleProp.defineEnum("tldraw:horizontalAlign", {
      defaultValue: "middle",
      values: ["start", "middle", "end", "start-legacy", "end-legacy", "middle-legacy"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLVerticalAlignStyle.mjs
var DefaultVerticalAlignStyle;
var init_TLVerticalAlignStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLVerticalAlignStyle.mjs"() {
    init_StyleProp();
    DefaultVerticalAlignStyle = StyleProp.defineEnum("tldraw:verticalAlign", {
      defaultValue: "middle",
      values: ["start", "middle", "end"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLGeoShape.mjs
var GeoShapeGeoStyle, geoShapeProps, geoShapeVersions, geoShapeMigrations;
var init_TLGeoShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLGeoShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    init_StyleProp();
    init_TLColorStyle();
    init_TLDashStyle();
    init_TLFillStyle();
    init_TLFontStyle();
    init_TLHorizontalAlignStyle();
    init_TLSizeStyle();
    init_TLVerticalAlignStyle();
    GeoShapeGeoStyle = StyleProp.defineEnum("tldraw:geo", {
      defaultValue: "rectangle",
      values: [
        "cloud",
        "rectangle",
        "ellipse",
        "triangle",
        "diamond",
        "pentagon",
        "hexagon",
        "octagon",
        "star",
        "rhombus",
        "rhombus-2",
        "oval",
        "trapezoid",
        "arrow-right",
        "arrow-left",
        "arrow-up",
        "arrow-down",
        "x-box",
        "check-box",
        "heart"
      ]
    });
    geoShapeProps = {
      geo: GeoShapeGeoStyle,
      labelColor: DefaultLabelColorStyle,
      color: DefaultColorStyle,
      fill: DefaultFillStyle,
      dash: DefaultDashStyle,
      size: DefaultSizeStyle,
      font: DefaultFontStyle,
      align: DefaultHorizontalAlignStyle,
      verticalAlign: DefaultVerticalAlignStyle,
      url: validation_exports.linkUrl,
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      growY: validation_exports.positiveNumber,
      text: validation_exports.string,
      scale: validation_exports.nonZeroNumber
    };
    geoShapeVersions = createShapePropsMigrationIds("geo", {
      AddUrlProp: 1,
      AddLabelColor: 2,
      RemoveJustify: 3,
      AddCheckBox: 4,
      AddVerticalAlign: 5,
      MigrateLegacyAlign: 6,
      AddCloud: 7,
      MakeUrlsValid: 8,
      AddScale: 9
    });
    geoShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: geoShapeVersions.AddUrlProp,
          up: (props) => {
            props.url = "";
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.AddLabelColor,
          up: (props) => {
            props.labelColor = "black";
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.RemoveJustify,
          up: (props) => {
            if (props.align === "justify") {
              props.align = "start";
            }
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.AddCheckBox,
          up: (_props) => {
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.AddVerticalAlign,
          up: (props) => {
            props.verticalAlign = "middle";
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.MigrateLegacyAlign,
          up: (props) => {
            let newAlign;
            switch (props.align) {
              case "start":
                newAlign = "start-legacy";
                break;
              case "end":
                newAlign = "end-legacy";
                break;
              default:
                newAlign = "middle-legacy";
                break;
            }
            props.align = newAlign;
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.AddCloud,
          up: (_props) => {
          },
          down: "retired"
        },
        {
          id: geoShapeVersions.MakeUrlsValid,
          up: (props) => {
            if (!validation_exports.linkUrl.isValid(props.url)) {
              props.url = "";
            }
          },
          down: (_props) => {
          }
        },
        {
          id: geoShapeVersions.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLGroupShape.mjs
var groupShapeProps, groupShapeMigrations;
var init_TLGroupShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLGroupShape.mjs"() {
    init_TLShape();
    groupShapeProps = {};
    groupShapeMigrations = createShapePropsMigrationSequence({ sequence: [] });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLHighlightShape.mjs
var highlightShapeProps, Versions7, highlightShapeMigrations;
var init_TLHighlightShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLHighlightShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    init_TLColorStyle();
    init_TLSizeStyle();
    init_TLDrawShape();
    highlightShapeProps = {
      color: DefaultColorStyle,
      size: DefaultSizeStyle,
      segments: validation_exports.arrayOf(DrawShapeSegment),
      isComplete: validation_exports.boolean,
      isPen: validation_exports.boolean,
      scale: validation_exports.nonZeroNumber
    };
    Versions7 = createShapePropsMigrationIds("highlight", {
      AddScale: 1
    });
    highlightShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions7.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLImageShape.mjs
var ImageShapeCrop, imageShapeProps, Versions8, imageShapeMigrations;
var init_TLImageShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLImageShape.mjs"() {
    init_dist_esm6();
    init_TLBaseAsset();
    init_geometry_types();
    init_TLShape();
    ImageShapeCrop = validation_exports.object({
      topLeft: vecModelValidator,
      bottomRight: vecModelValidator
    });
    imageShapeProps = {
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      playing: validation_exports.boolean,
      url: validation_exports.linkUrl,
      assetId: assetIdValidator.nullable(),
      crop: ImageShapeCrop.nullable(),
      flipX: validation_exports.boolean,
      flipY: validation_exports.boolean
    };
    Versions8 = createShapePropsMigrationIds("image", {
      AddUrlProp: 1,
      AddCropProp: 2,
      MakeUrlsValid: 3,
      AddFlipProps: 4
    });
    imageShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions8.AddUrlProp,
          up: (props) => {
            props.url = "";
          },
          down: "retired"
        },
        {
          id: Versions8.AddCropProp,
          up: (props) => {
            props.crop = null;
          },
          down: (props) => {
            delete props.crop;
          }
        },
        {
          id: Versions8.MakeUrlsValid,
          up: (props) => {
            if (!validation_exports.linkUrl.isValid(props.url)) {
              props.url = "";
            }
          },
          down: (_props) => {
          }
        },
        {
          id: Versions8.AddFlipProps,
          up: (props) => {
            props.flipX = false;
            props.flipY = false;
          },
          down: (props) => {
            delete props.flipX;
            delete props.flipY;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLLineShape.mjs
var LineShapeSplineStyle, lineShapePointValidator, lineShapeProps, lineShapeVersions, lineShapeMigrations;
var init_TLLineShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLLineShape.mjs"() {
    init_dist_esm7();
    init_dist_esm6();
    init_TLShape();
    init_StyleProp();
    init_TLColorStyle();
    init_TLDashStyle();
    init_TLSizeStyle();
    LineShapeSplineStyle = StyleProp.defineEnum("tldraw:spline", {
      defaultValue: "line",
      values: ["cubic", "line"]
    });
    lineShapePointValidator = validation_exports.object({
      id: validation_exports.string,
      index: validation_exports.indexKey,
      x: validation_exports.number,
      y: validation_exports.number
    });
    lineShapeProps = {
      color: DefaultColorStyle,
      dash: DefaultDashStyle,
      size: DefaultSizeStyle,
      spline: LineShapeSplineStyle,
      points: validation_exports.dict(validation_exports.string, lineShapePointValidator),
      scale: validation_exports.nonZeroNumber
    };
    lineShapeVersions = createShapePropsMigrationIds("line", {
      AddSnapHandles: 1,
      RemoveExtraHandleProps: 2,
      HandlesToPoints: 3,
      PointIndexIds: 4,
      AddScale: 5
    });
    lineShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: lineShapeVersions.AddSnapHandles,
          up: (props) => {
            for (const handle of Object.values(props.handles)) {
              ;
              handle.canSnap = true;
            }
          },
          down: "retired"
        },
        {
          id: lineShapeVersions.RemoveExtraHandleProps,
          up: (props) => {
            props.handles = objectMapFromEntries4(Object.values(props.handles).map((handle) => [
              handle.index,
              {
                x: handle.x,
                y: handle.y
              }
            ]));
          },
          down: (props) => {
            const handles = Object.entries(props.handles).map(([index3, handle]) => ({ index: index3, ...handle })).sort(sortByIndex4);
            props.handles = Object.fromEntries(handles.map((handle, i2) => {
              const id = i2 === 0 ? "start" : i2 === handles.length - 1 ? "end" : `handle:${handle.index}`;
              return [
                id,
                {
                  id,
                  type: "vertex",
                  canBind: false,
                  canSnap: true,
                  index: handle.index,
                  x: handle.x,
                  y: handle.y
                }
              ];
            }));
          }
        },
        {
          id: lineShapeVersions.HandlesToPoints,
          up: (props) => {
            const sortedHandles = Object.entries(props.handles).map(([index3, { x: x2, y: y2 }]) => ({ x: x2, y: y2, index: index3 })).sort(sortByIndex4);
            props.points = sortedHandles.map(({ x: x2, y: y2 }) => ({ x: x2, y: y2 }));
            delete props.handles;
          },
          down: (props) => {
            const indices = getIndices4(props.points.length);
            props.handles = Object.fromEntries(props.points.map((handle, i2) => {
              const index3 = indices[i2];
              return [
                index3,
                {
                  x: handle.x,
                  y: handle.y
                }
              ];
            }));
            delete props.points;
          }
        },
        {
          id: lineShapeVersions.PointIndexIds,
          up: (props) => {
            const indices = getIndices4(props.points.length);
            props.points = Object.fromEntries(props.points.map((point, i2) => {
              const id = indices[i2];
              return [
                id,
                {
                  id,
                  index: id,
                  x: point.x,
                  y: point.y
                }
              ];
            }));
          },
          down: (props) => {
            const sortedHandles = Object.values(props.points).sort(sortByIndex4);
            props.points = sortedHandles.map(({ x: x2, y: y2 }) => ({ x: x2, y: y2 }));
          }
        },
        {
          id: lineShapeVersions.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLNoteShape.mjs
var noteShapeProps, Versions9, noteShapeMigrations;
var init_TLNoteShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLNoteShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    init_TLColorStyle();
    init_TLFontStyle();
    init_TLHorizontalAlignStyle();
    init_TLSizeStyle();
    init_TLVerticalAlignStyle();
    noteShapeProps = {
      color: DefaultColorStyle,
      size: DefaultSizeStyle,
      font: DefaultFontStyle,
      fontSizeAdjustment: validation_exports.positiveNumber,
      align: DefaultHorizontalAlignStyle,
      verticalAlign: DefaultVerticalAlignStyle,
      growY: validation_exports.positiveNumber,
      url: validation_exports.linkUrl,
      text: validation_exports.string,
      scale: validation_exports.nonZeroNumber
    };
    Versions9 = createShapePropsMigrationIds("note", {
      AddUrlProp: 1,
      RemoveJustify: 2,
      MigrateLegacyAlign: 3,
      AddVerticalAlign: 4,
      MakeUrlsValid: 5,
      AddFontSizeAdjustment: 6,
      AddScale: 7
    });
    noteShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions9.AddUrlProp,
          up: (props) => {
            props.url = "";
          },
          down: "retired"
        },
        {
          id: Versions9.RemoveJustify,
          up: (props) => {
            if (props.align === "justify") {
              props.align = "start";
            }
          },
          down: "retired"
        },
        {
          id: Versions9.MigrateLegacyAlign,
          up: (props) => {
            switch (props.align) {
              case "start":
                props.align = "start-legacy";
                return;
              case "end":
                props.align = "end-legacy";
                return;
              default:
                props.align = "middle-legacy";
                return;
            }
          },
          down: "retired"
        },
        {
          id: Versions9.AddVerticalAlign,
          up: (props) => {
            props.verticalAlign = "middle";
          },
          down: "retired"
        },
        {
          id: Versions9.MakeUrlsValid,
          up: (props) => {
            if (!validation_exports.linkUrl.isValid(props.url)) {
              props.url = "";
            }
          },
          down: (_props) => {
          }
        },
        {
          id: Versions9.AddFontSizeAdjustment,
          up: (props) => {
            props.fontSizeAdjustment = 0;
          },
          down: (props) => {
            delete props.fontSizeAdjustment;
          }
        },
        {
          id: Versions9.AddScale,
          up: (props) => {
            props.scale = 1;
          },
          down: (props) => {
            delete props.scale;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/styles/TLTextAlignStyle.mjs
var DefaultTextAlignStyle;
var init_TLTextAlignStyle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/styles/TLTextAlignStyle.mjs"() {
    init_StyleProp();
    DefaultTextAlignStyle = StyleProp.defineEnum("tldraw:textAlign", {
      defaultValue: "start",
      values: ["start", "middle", "end"]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLTextShape.mjs
var textShapeProps, Versions10, textShapeMigrations;
var init_TLTextShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLTextShape.mjs"() {
    init_dist_esm6();
    init_TLShape();
    init_TLColorStyle();
    init_TLFontStyle();
    init_TLSizeStyle();
    init_TLTextAlignStyle();
    textShapeProps = {
      color: DefaultColorStyle,
      size: DefaultSizeStyle,
      font: DefaultFontStyle,
      textAlign: DefaultTextAlignStyle,
      w: validation_exports.nonZeroNumber,
      text: validation_exports.string,
      scale: validation_exports.nonZeroNumber,
      autoSize: validation_exports.boolean
    };
    Versions10 = createShapePropsMigrationIds("text", {
      RemoveJustify: 1,
      AddTextAlign: 2
    });
    textShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions10.RemoveJustify,
          up: (props) => {
            if (props.align === "justify") {
              props.align = "start";
            }
          },
          down: "retired"
        },
        {
          id: Versions10.AddTextAlign,
          up: (props) => {
            props.textAlign = props.align;
            delete props.align;
          },
          down: (props) => {
            props.align = props.textAlign;
            delete props.textAlign;
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/shapes/TLVideoShape.mjs
var videoShapeProps, Versions11, videoShapeMigrations;
var init_TLVideoShape = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/shapes/TLVideoShape.mjs"() {
    init_dist_esm6();
    init_TLBaseAsset();
    init_TLShape();
    videoShapeProps = {
      w: validation_exports.nonZeroNumber,
      h: validation_exports.nonZeroNumber,
      time: validation_exports.number,
      playing: validation_exports.boolean,
      url: validation_exports.linkUrl,
      assetId: assetIdValidator.nullable()
    };
    Versions11 = createShapePropsMigrationIds("video", {
      AddUrlProp: 1,
      MakeUrlsValid: 2
    });
    videoShapeMigrations = createShapePropsMigrationSequence({
      sequence: [
        {
          id: Versions11.AddUrlProp,
          up: (props) => {
            props.url = "";
          },
          down: "retired"
        },
        {
          id: Versions11.MakeUrlsValid,
          up: (props) => {
            if (!validation_exports.linkUrl.isValid(props.url)) {
              props.url = "";
            }
          },
          down: (_props) => {
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/store-migrations.mjs
var Versions12, storeMigrations;
var init_store_migrations = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/store-migrations.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
    Versions12 = createMigrationIds("com.tldraw.store", {
      RemoveCodeAndIconShapeTypes: 1,
      AddInstancePresenceType: 2,
      RemoveTLUserAndPresenceAndAddPointer: 3,
      RemoveUserDocument: 4
    });
    storeMigrations = createMigrationSequence({
      sequenceId: "com.tldraw.store",
      retroactive: false,
      sequence: [
        {
          id: Versions12.RemoveCodeAndIconShapeTypes,
          scope: "store",
          up: (store) => {
            for (const [id, record] of objectMapEntries4(store)) {
              if (record.typeName === "shape" && (record.type === "icon" || record.type === "code")) {
                delete store[id];
              }
            }
          }
        },
        {
          id: Versions12.AddInstancePresenceType,
          scope: "store",
          up(_store) {
          }
        },
        {
          id: Versions12.RemoveTLUserAndPresenceAndAddPointer,
          scope: "store",
          up: (store) => {
            for (const [id, record] of objectMapEntries4(store)) {
              if (record.typeName.match(/^(user|user_presence)$/)) {
                delete store[id];
              }
            }
          }
        },
        {
          id: Versions12.RemoveUserDocument,
          scope: "store",
          up: (store) => {
            for (const [id, record] of objectMapEntries4(store)) {
              if (record.typeName.match("user_document")) {
                delete store[id];
              }
            }
          }
        }
      ]
    });
  }
});

// node_modules/@tldraw/tlschema/dist-esm/createTLSchema.mjs
function createTLSchema({
  shapes = defaultShapeSchemas,
  bindings = defaultBindingSchemas,
  migrations
} = {}) {
  const stylesById = /* @__PURE__ */ new Map();
  for (const shape of objectMapValues4(shapes)) {
    for (const style of getShapePropKeysByStyle(shape.props ?? {}).keys()) {
      if (stylesById.has(style.id) && stylesById.get(style.id) !== style) {
        throw new Error(`Multiple StyleProp instances with the same id: ${style.id}`);
      }
      stylesById.set(style.id, style);
    }
  }
  const ShapeRecordType = createShapeRecordType(shapes);
  const BindingRecordType = createBindingRecordType(bindings);
  const InstanceRecordType = createInstanceRecordType(stylesById);
  return StoreSchema.create({
    asset: AssetRecordType,
    binding: BindingRecordType,
    camera: CameraRecordType,
    document: DocumentRecordType,
    instance: InstanceRecordType,
    instance_page_state: InstancePageStateRecordType,
    page: PageRecordType,
    instance_presence: InstancePresenceRecordType,
    pointer: PointerRecordType,
    shape: ShapeRecordType
  }, {
    migrations: [
      storeMigrations,
      assetMigrations,
      cameraMigrations,
      documentMigrations,
      instanceMigrations,
      instancePageStateMigrations,
      pageMigrations,
      instancePresenceMigrations,
      pointerMigrations,
      rootShapeMigrations,
      bookmarkAssetMigrations,
      imageAssetMigrations,
      videoAssetMigrations,
      ...processPropsMigrations("shape", shapes),
      ...processPropsMigrations("binding", bindings),
      ...migrations ?? []
    ],
    onValidationFailure,
    createIntegrityChecker
  });
}
var defaultShapeSchemas, defaultBindingSchemas;
var init_createTLSchema = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/createTLSchema.mjs"() {
    init_dist_esm4();
    init_dist_esm7();
    init_TLStore();
    init_TLBookmarkAsset();
    init_TLImageAsset();
    init_TLVideoAsset();
    init_TLArrowBinding();
    init_TLAsset();
    init_TLBinding();
    init_TLCamera();
    init_TLDocument();
    init_TLInstance();
    init_TLPage();
    init_TLPageState();
    init_TLPointer();
    init_TLPresence();
    init_TLShape();
    init_recordsWithProps();
    init_TLArrowShape();
    init_TLBookmarkShape();
    init_TLDrawShape();
    init_TLEmbedShape();
    init_TLFrameShape();
    init_TLGeoShape();
    init_TLGroupShape();
    init_TLHighlightShape();
    init_TLImageShape();
    init_TLLineShape();
    init_TLNoteShape();
    init_TLTextShape();
    init_TLVideoShape();
    init_store_migrations();
    defaultShapeSchemas = {
      arrow: { migrations: arrowShapeMigrations, props: arrowShapeProps },
      bookmark: { migrations: bookmarkShapeMigrations, props: bookmarkShapeProps },
      draw: { migrations: drawShapeMigrations, props: drawShapeProps },
      embed: { migrations: embedShapeMigrations, props: embedShapeProps },
      frame: { migrations: frameShapeMigrations, props: frameShapeProps },
      geo: { migrations: geoShapeMigrations, props: geoShapeProps },
      group: { migrations: groupShapeMigrations, props: groupShapeProps },
      highlight: { migrations: highlightShapeMigrations, props: highlightShapeProps },
      image: { migrations: imageShapeMigrations, props: imageShapeProps },
      line: { migrations: lineShapeMigrations, props: lineShapeProps },
      note: { migrations: noteShapeMigrations, props: noteShapeProps },
      text: { migrations: textShapeMigrations, props: textShapeProps },
      video: { migrations: videoShapeMigrations, props: videoShapeProps }
    };
    defaultBindingSchemas = {
      arrow: { migrations: arrowBindingMigrations, props: arrowBindingProps }
    };
  }
});

// node_modules/@tldraw/tlschema/dist-esm/misc/TLHandle.mjs
var init_TLHandle = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/misc/TLHandle.mjs"() {
  }
});

// node_modules/@tldraw/tlschema/dist-esm/translations/languages.mjs
var LANGUAGES;
var init_languages = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/translations/languages.mjs"() {
    LANGUAGES = [
      { locale: "id", label: "Bahasa Indonesia" },
      { locale: "ca", label: "Catal\xE0" },
      { locale: "cs", label: "\u010Ce\u0161tina" },
      { locale: "da", label: "Danish" },
      { locale: "de", label: "Deutsch" },
      { locale: "en", label: "English" },
      { locale: "es", label: "Espa\xF1ol" },
      { locale: "fr", label: "Fran\xE7ais" },
      { locale: "gl", label: "Galego" },
      { locale: "hr", label: "Hrvatski" },
      { locale: "it", label: "Italiano" },
      { locale: "hu", label: "Magyar" },
      { locale: "no", label: "Norwegian" },
      { locale: "pl", label: "Polski" },
      { locale: "pt-br", label: "Portugu\xEAs - Brasil" },
      { locale: "pt-pt", label: "Portugu\xEAs - Europeu" },
      { locale: "ro", label: "Rom\xE2n\u0103" },
      { locale: "ru", label: "Russian" },
      { locale: "sl", label: "Sloven\u0161\u010Dina" },
      { locale: "fi", label: "Suomi" },
      { locale: "sv", label: "Svenska" },
      { locale: "vi", label: "Ti\u1EBFng Vi\u1EC7t" },
      { locale: "tr", label: "T\xFCrk\xE7e" },
      { locale: "uk", label: "Ukrainian" },
      { locale: "he", label: "\u05E2\u05D1\u05E8\u05D9\u05EA" },
      { locale: "ar", label: "\u0639\u0631\u0628\u064A" },
      { locale: "fa", label: "\u0641\u0627\u0631\u0633\u06CC" },
      { locale: "ku", label: "\u06A9\u0648\u0631\u062F\u06CC" },
      { locale: "ne", label: "\u0928\u0947\u092A\u093E\u0932\u0940" },
      { locale: "hi-in", label: "\u0939\u093F\u0928\u094D\u0926\u0940" },
      { locale: "te", label: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41" },
      { locale: "th", label: "\u0E20\u0E32\u0E29\u0E32\u0E44\u0E17\u0E22" },
      { locale: "my", label: "\u1019\u103C\u1014\u103A\u1019\u102C\u1005\u102C" },
      { locale: "ko-kr", label: "\uD55C\uAD6D\uC5B4" },
      { locale: "ja", label: "\u65E5\u672C\u8A9E" },
      { locale: "zh-cn", label: "\u7B80\u4F53\u4E2D\u6587" },
      { locale: "zh-tw", label: "\u7E41\u9AD4\u4E2D\u6587 (\u53F0\u7063)" }
    ];
  }
});

// node_modules/@tldraw/tlschema/dist-esm/translations/translations.mjs
function getDefaultTranslationLocale() {
  const locales = typeof window !== "undefined" ? window.navigator.languages ?? ["en"] : ["en"];
  return _getDefaultTranslationLocale(locales);
}
function _getDefaultTranslationLocale(locales) {
  for (const locale of locales) {
    const supportedLocale = getSupportedLocale(locale);
    if (supportedLocale) {
      return supportedLocale;
    }
  }
  return "en";
}
function getSupportedLocale(locale) {
  const exactMatch = LANGUAGES.find((t3) => t3.locale === locale.toLowerCase());
  if (exactMatch) {
    return exactMatch.locale;
  }
  const [language, region] = locale.split(/[-_]/).map((s2) => s2.toLowerCase());
  if (region) {
    const languageMatch = LANGUAGES.find((t3) => t3.locale === language);
    if (languageMatch) {
      return languageMatch.locale;
    }
  }
  if (language in DEFAULT_LOCALE_REGIONS) {
    return DEFAULT_LOCALE_REGIONS[language];
  }
  return null;
}
var DEFAULT_LOCALE_REGIONS;
var init_translations = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/translations/translations.mjs"() {
    init_languages();
    DEFAULT_LOCALE_REGIONS = {
      zh: "zh-cn",
      pt: "pt-br",
      ko: "ko-kr",
      hi: "hi-in"
    };
  }
});

// node_modules/@tldraw/tlschema/dist-esm/index.mjs
var init_dist_esm8 = __esm({
  "node_modules/@tldraw/tlschema/dist-esm/index.mjs"() {
    init_TLBaseAsset();
    init_TLArrowBinding();
    init_TLBaseBinding();
    init_createPresenceStateDerivation();
    init_createTLSchema();
    init_TLColor();
    init_TLCursor();
    init_TLHandle();
    init_TLOpacity();
    init_TLScribble();
    init_geometry_types();
    init_id_validator();
    init_TLAsset();
    init_TLBinding();
    init_TLCamera();
    init_TLDocument();
    init_TLInstance();
    init_TLPage();
    init_TLPageState();
    init_TLPointer();
    init_TLPresence();
    init_TLShape();
    init_TLArrowShape();
    init_TLBaseShape();
    init_TLBookmarkShape();
    init_TLDrawShape();
    init_TLEmbedShape();
    init_TLFrameShape();
    init_TLGeoShape();
    init_TLGroupShape();
    init_TLHighlightShape();
    init_TLImageShape();
    init_TLLineShape();
    init_TLNoteShape();
    init_TLTextShape();
    init_TLVideoShape();
    init_StyleProp();
    init_TLColorStyle();
    init_TLDashStyle();
    init_TLFillStyle();
    init_TLFontStyle();
    init_TLHorizontalAlignStyle();
    init_TLSizeStyle();
    init_TLTextAlignStyle();
    init_TLVerticalAlignStyle();
    init_translations();
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useStateTracking.mjs
function useStateTracking(name, render2) {
  const renderRef = import_react2.default.useRef(render2);
  renderRef.current = render2;
  const [scheduler, subscribe, getSnapshot2] = import_react2.default.useMemo(() => {
    let scheduleUpdate = null;
    const subscribe2 = (cb) => {
      scheduleUpdate = cb;
      return () => {
        scheduleUpdate = null;
      };
    };
    const scheduler2 = new EffectScheduler(`useStateTracking(${name})`, () => renderRef.current?.(), {
      scheduleEffect() {
        scheduleUpdate?.();
      }
    });
    const getSnapshot22 = () => scheduler2.scheduleCount;
    return [scheduler2, subscribe2, getSnapshot22];
  }, [name]);
  import_react2.default.useSyncExternalStore(subscribe, getSnapshot2, getSnapshot2);
  import_react2.default.useEffect(() => {
    scheduler.attach();
    scheduler.maybeScheduleEffect();
    return () => {
      scheduler.detach();
    };
  }, [scheduler]);
  return scheduler.execute();
}
var import_react2;
var init_useStateTracking = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useStateTracking.mjs"() {
    init_dist_esm();
    import_react2 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/track.mjs
function track(baseComponent) {
  let compare = null;
  const $$typeof = baseComponent["$$typeof"];
  if ($$typeof === ReactMemoSymbol) {
    baseComponent = baseComponent.type;
    compare = baseComponent.compare;
  }
  if ($$typeof === ReactForwardRefSymbol) {
    return (0, import_react3.memo)((0, import_react3.forwardRef)(new Proxy(baseComponent.render, ProxyHandlers)));
  }
  return (0, import_react3.memo)(new Proxy(baseComponent, ProxyHandlers), compare);
}
var import_react3, ProxyHandlers, ReactMemoSymbol, ReactForwardRefSymbol;
var init_track = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/track.mjs"() {
    import_react3 = __toESM(require_react(), 1);
    init_useStateTracking();
    ProxyHandlers = {
      apply(Component2, thisArg, argumentsList) {
        return useStateTracking(Component2.displayName ?? Component2.name ?? "tracked(???)", () => Component2.apply(thisArg, argumentsList));
      }
    };
    ReactMemoSymbol = Symbol.for("react.memo");
    ReactForwardRefSymbol = Symbol.for("react.forward_ref");
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useAtom.mjs
var import_react4;
var init_useAtom = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useAtom.mjs"() {
    init_dist_esm();
    import_react4 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useComputed.mjs
function useComputed() {
  const name = arguments[0];
  const compute = arguments[1];
  const opts = arguments.length === 3 ? void 0 : arguments[2];
  const deps = arguments.length === 3 ? arguments[2] : arguments[3];
  return (0, import_react5.useMemo)(() => computed(`useComputed(${name})`, compute, opts), deps);
}
var import_react5;
var init_useComputed = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useComputed.mjs"() {
    init_dist_esm();
    import_react5 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useQuickReactor.mjs
function useQuickReactor(name, reactFn, deps = EMPTY_ARRAY) {
  (0, import_react6.useEffect)(() => {
    const scheduler = new EffectScheduler(name, reactFn);
    scheduler.attach();
    scheduler.execute();
    return () => {
      scheduler.detach();
    };
  }, deps);
}
var import_react6;
var init_useQuickReactor = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useQuickReactor.mjs"() {
    init_dist_esm();
    import_react6 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useReactor.mjs
var import_react7;
var init_useReactor = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useReactor.mjs"() {
    init_dist_esm();
    import_react7 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/lib/useValue.mjs
function useValue() {
  const args = arguments;
  const deps = args.length === 3 ? args[2] : [args[0]];
  const name = args.length === 3 ? args[0] : `useValue(${args[0].name})`;
  const isInRender = (0, import_react8.useRef)(true);
  isInRender.current = true;
  const $val = (0, import_react8.useMemo)(() => {
    if (args.length === 1) {
      return args[0];
    }
    return computed(name, () => {
      if (isInRender.current) {
        return args[1]();
      } else {
        try {
          return args[1]();
        } catch {
          return {};
        }
      }
    });
  }, deps);
  try {
    const { subscribe, getSnapshot: getSnapshot2 } = (0, import_react8.useMemo)(() => {
      return {
        subscribe: (listen) => {
          return react(`useValue(${name})`, () => {
            $val.get();
            listen();
          });
        },
        getSnapshot: () => $val.get()
      };
    }, [$val]);
    return (0, import_react8.useSyncExternalStore)(subscribe, getSnapshot2, getSnapshot2);
  } finally {
    isInRender.current = false;
  }
}
var import_react8;
var init_useValue = __esm({
  "node_modules/@tldraw/state-react/dist-esm/lib/useValue.mjs"() {
    init_dist_esm();
    import_react8 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/state-react/dist-esm/index.mjs
var init_dist_esm9 = __esm({
  "node_modules/@tldraw/state-react/dist-esm/index.mjs"() {
    init_track();
    init_useAtom();
    init_useComputed();
    init_useQuickReactor();
    init_useReactor();
    init_useStateTracking();
    init_useValue();
  }
});

// node_modules/react/cjs/react-jsx-runtime.production.min.js
var require_react_jsx_runtime_production_min = __commonJS({
  "node_modules/react/cjs/react-jsx-runtime.production.min.js"(exports) {
    "use strict";
    var f2 = require_react();
    var k2 = Symbol.for("react.element");
    var l2 = Symbol.for("react.fragment");
    var m2 = Object.prototype.hasOwnProperty;
    var n2 = f2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner;
    var p2 = { key: true, ref: true, __self: true, __source: true };
    function q(c2, a2, g2) {
      var b2, d2 = {}, e2 = null, h2 = null;
      g2 !== void 0 && (e2 = "" + g2);
      a2.key !== void 0 && (e2 = "" + a2.key);
      a2.ref !== void 0 && (h2 = a2.ref);
      for (b2 in a2)
        m2.call(a2, b2) && !p2.hasOwnProperty(b2) && (d2[b2] = a2[b2]);
      if (c2 && c2.defaultProps)
        for (b2 in a2 = c2.defaultProps, a2)
          d2[b2] === void 0 && (d2[b2] = a2[b2]);
      return { $$typeof: k2, type: c2, key: e2, ref: h2, props: d2, _owner: n2.current };
    }
    exports.Fragment = l2;
    exports.jsx = q;
    exports.jsxs = q;
  }
});

// node_modules/react/jsx-runtime.js
var require_jsx_runtime = __commonJS({
  "node_modules/react/jsx-runtime.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_react_jsx_runtime_production_min();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/classnames/index.js
var require_classnames = __commonJS({
  "node_modules/classnames/index.js"(exports, module2) {
    (function() {
      "use strict";
      var hasOwn = {}.hasOwnProperty;
      function classNames49() {
        var classes = "";
        for (var i2 = 0; i2 < arguments.length; i2++) {
          var arg = arguments[i2];
          if (arg) {
            classes = appendClass(classes, parseValue(arg));
          }
        }
        return classes;
      }
      function parseValue(arg) {
        if (typeof arg === "string" || typeof arg === "number") {
          return arg;
        }
        if (typeof arg !== "object") {
          return "";
        }
        if (Array.isArray(arg)) {
          return classNames49.apply(null, arg);
        }
        if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
          return arg.toString();
        }
        var classes = "";
        for (var key in arg) {
          if (hasOwn.call(arg, key) && arg[key]) {
            classes = appendClass(classes, key);
          }
        }
        return classes;
      }
      function appendClass(value, newClass) {
        if (!newClass) {
          return value;
        }
        if (value) {
          return value + " " + newClass;
        }
        return value + newClass;
      }
      if (typeof module2 !== "undefined" && module2.exports) {
        classNames49.default = classNames49;
        module2.exports = classNames49;
      } else if (typeof define === "function" && typeof define.amd === "object" && define.amd) {
        define("classnames", [], function() {
          return classNames49;
        });
      } else {
        window.classNames = classNames49;
      }
    })();
  }
});

// node_modules/@tldraw/editor/dist-esm/version.mjs
var version, publishDates;
var init_version = __esm({
  "node_modules/@tldraw/editor/dist-esm/version.mjs"() {
    version = "2.4.6";
    publishDates = {
      major: "2024-06-28T10:56:07.893Z",
      minor: "2024-07-22T16:42:50.301Z",
      patch: "2024-08-29T10:01:17.530Z"
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/ErrorBoundary.mjs
function OptionalErrorBoundary({
  children,
  fallback,
  ...props
}) {
  if (fallback === null) {
    return children;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ErrorBoundary, { fallback, ...props, children });
}
var import_jsx_runtime, React2, initialState, ErrorBoundary;
var init_ErrorBoundary = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/ErrorBoundary.mjs"() {
    import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
    React2 = __toESM(require_react(), 1);
    initialState = { error: null };
    ErrorBoundary = class extends React2.Component {
      constructor() {
        super(...arguments);
        __publicField(this, "state", initialState);
      }
      static getDerivedStateFromError(error2) {
        return { error: error2 };
      }
      componentDidCatch(error2) {
        this.props.onError?.(error2);
      }
      render() {
        const { error: error2 } = this.state;
        if (error2 !== null) {
          const { fallback: Fallback } = this.props;
          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Fallback, { error: error2 });
        }
        return this.props.children;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useEditor.mjs
function useEditor() {
  const editor = import_react9.default.useContext(EditorContext);
  if (!editor) {
    throw new Error("useEditor must be used inside of the <Tldraw /> or <TldrawEditor /> components");
  }
  return editor;
}
var import_react9, EditorContext;
var init_useEditor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useEditor.mjs"() {
    import_react9 = __toESM(require_react(), 1);
    EditorContext = (0, import_react9.createContext)(null);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultBackground.mjs
function DefaultBackground() {
  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "tl-background" });
}
var import_jsx_runtime2;
var init_DefaultBackground = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultBackground.mjs"() {
    import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useTransform.mjs
function useTransform(ref, x2, y2, scale, rotate, additionalOffset) {
  (0, import_react10.useLayoutEffect)(() => {
    const elm = ref.current;
    if (!elm)
      return;
    if (x2 === void 0)
      return;
    let trans = `translate(${x2}px, ${y2}px)`;
    if (scale !== void 0) {
      trans += ` scale(${scale})`;
    }
    if (rotate !== void 0) {
      trans += ` rotate(${rotate}rad)`;
    }
    if (additionalOffset) {
      trans += ` translate(${additionalOffset.x}px, ${additionalOffset.y}px)`;
    }
    elm.style.transform = trans;
  });
}
var import_react10;
var init_useTransform = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useTransform.mjs"() {
    import_react10 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/easings.mjs
var EASINGS;
var init_easings = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/easings.mjs"() {
    EASINGS = {
      linear: (t3) => t3,
      easeInQuad: (t3) => t3 * t3,
      easeOutQuad: (t3) => t3 * (2 - t3),
      easeInOutQuad: (t3) => t3 < 0.5 ? 2 * t3 * t3 : -1 + (4 - 2 * t3) * t3,
      easeInCubic: (t3) => t3 * t3 * t3,
      easeOutCubic: (t3) => --t3 * t3 * t3 + 1,
      easeInOutCubic: (t3) => t3 < 0.5 ? 4 * t3 * t3 * t3 : (t3 - 1) * (2 * t3 - 2) * (2 * t3 - 2) + 1,
      easeInQuart: (t3) => t3 * t3 * t3 * t3,
      easeOutQuart: (t3) => 1 - --t3 * t3 * t3 * t3,
      easeInOutQuart: (t3) => t3 < 0.5 ? 8 * t3 * t3 * t3 * t3 : 1 - 8 * --t3 * t3 * t3 * t3,
      easeInQuint: (t3) => t3 * t3 * t3 * t3 * t3,
      easeOutQuint: (t3) => 1 + --t3 * t3 * t3 * t3 * t3,
      easeInOutQuint: (t3) => t3 < 0.5 ? 16 * t3 * t3 * t3 * t3 * t3 : 1 + 16 * --t3 * t3 * t3 * t3 * t3,
      easeInSine: (t3) => 1 - Math.cos(t3 * Math.PI / 2),
      easeOutSine: (t3) => Math.sin(t3 * Math.PI / 2),
      easeInOutSine: (t3) => -(Math.cos(Math.PI * t3) - 1) / 2,
      easeInExpo: (t3) => t3 <= 0 ? 0 : Math.pow(2, 10 * t3 - 10),
      easeOutExpo: (t3) => t3 >= 1 ? 1 : 1 - Math.pow(2, -10 * t3),
      easeInOutExpo: (t3) => t3 <= 0 ? 0 : t3 >= 1 ? 1 : t3 < 0.5 ? Math.pow(2, 20 * t3 - 10) / 2 : (2 - Math.pow(2, -20 * t3 + 10)) / 2
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/Vec.mjs
var Vec, ease;
var init_Vec = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/Vec.mjs"() {
    init_easings();
    init_utils();
    Vec = class {
      constructor(x2 = 0, y2 = 0, z = 1) {
        this.x = x2;
        this.y = y2;
        this.z = z;
      }
      get pressure() {
        return this.z;
      }
      set(x2 = this.x, y2 = this.y, z = this.z) {
        this.x = x2;
        this.y = y2;
        this.z = z;
        return this;
      }
      setTo({ x: x2 = 0, y: y2 = 0, z = 1 }) {
        this.x = x2;
        this.y = y2;
        this.z = z;
        return this;
      }
      rot(r2) {
        if (r2 === 0)
          return this;
        const { x: x2, y: y2 } = this;
        const s2 = Math.sin(r2);
        const c2 = Math.cos(r2);
        this.x = x2 * c2 - y2 * s2;
        this.y = x2 * s2 + y2 * c2;
        return this;
      }
      rotWith(C2, r2) {
        if (r2 === 0)
          return this;
        const x2 = this.x - C2.x;
        const y2 = this.y - C2.y;
        const s2 = Math.sin(r2);
        const c2 = Math.cos(r2);
        this.x = C2.x + (x2 * c2 - y2 * s2);
        this.y = C2.y + (x2 * s2 + y2 * c2);
        return this;
      }
      clone() {
        const { x: x2, y: y2, z } = this;
        return new Vec(x2, y2, z);
      }
      sub(V) {
        this.x -= V.x;
        this.y -= V.y;
        return this;
      }
      subXY(x2, y2) {
        this.x -= x2;
        this.y -= y2;
        return this;
      }
      subScalar(n2) {
        this.x -= n2;
        this.y -= n2;
        return this;
      }
      add(V) {
        this.x += V.x;
        this.y += V.y;
        return this;
      }
      addXY(x2, y2) {
        this.x += x2;
        this.y += y2;
        return this;
      }
      addScalar(n2) {
        this.x += n2;
        this.y += n2;
        return this;
      }
      clamp(min4, max3) {
        this.x = Math.max(this.x, min4);
        this.y = Math.max(this.y, min4);
        if (max3 !== void 0) {
          this.x = Math.min(this.x, max3);
          this.y = Math.min(this.y, max3);
        }
        return this;
      }
      div(t3) {
        this.x /= t3;
        this.y /= t3;
        return this;
      }
      divV(V) {
        this.x /= V.x;
        this.y /= V.y;
        return this;
      }
      mul(t3) {
        this.x *= t3;
        this.y *= t3;
        return this;
      }
      mulV(V) {
        this.x *= V.x;
        this.y *= V.y;
        return this;
      }
      abs() {
        this.x = Math.abs(this.x);
        this.y = Math.abs(this.y);
        return this;
      }
      nudge(B, distance) {
        const tan = Vec.Tan(B, this);
        return this.add(tan.mul(distance));
      }
      neg() {
        this.x *= -1;
        this.y *= -1;
        return this;
      }
      cross(V) {
        this.x = this.y * V.z - this.z * V.y;
        this.y = this.z * V.x - this.x * V.z;
        return this;
      }
      dpr(V) {
        return Vec.Dpr(this, V);
      }
      cpr(V) {
        return Vec.Cpr(this, V);
      }
      len2() {
        return Vec.Len2(this);
      }
      len() {
        return Vec.Len(this);
      }
      pry(V) {
        return Vec.Pry(this, V);
      }
      per() {
        const { x: x2, y: y2 } = this;
        this.x = y2;
        this.y = -x2;
        return this;
      }
      uni() {
        return Vec.Uni(this);
      }
      tan(V) {
        return Vec.Tan(this, V);
      }
      dist(V) {
        return Vec.Dist(this, V);
      }
      distanceToLineSegment(A2, B) {
        return Vec.DistanceToLineSegment(A2, B, this);
      }
      slope(B) {
        return Vec.Slope(this, B);
      }
      snapToGrid(gridSize) {
        this.x = Math.round(this.x / gridSize) * gridSize;
        this.y = Math.round(this.y / gridSize) * gridSize;
        return this;
      }
      angle(B) {
        return Vec.Angle(this, B);
      }
      toAngle() {
        return Vec.ToAngle(this);
      }
      lrp(B, t3) {
        this.x = this.x + (B.x - this.x) * t3;
        this.y = this.y + (B.y - this.y) * t3;
        return this;
      }
      equals(B) {
        return Vec.Equals(this, B);
      }
      equalsXY(x2, y2) {
        return Vec.EqualsXY(this, x2, y2);
      }
      norm() {
        const l2 = this.len();
        this.x = l2 === 0 ? 0 : this.x / l2;
        this.y = l2 === 0 ? 0 : this.y / l2;
        return this;
      }
      toFixed() {
        return Vec.ToFixed(this);
      }
      toString() {
        return Vec.ToString(Vec.ToFixed(this));
      }
      toJson() {
        return Vec.ToJson(this);
      }
      toArray() {
        return Vec.ToArray(this);
      }
      static Add(A2, B) {
        return new Vec(A2.x + B.x, A2.y + B.y);
      }
      static AddXY(A2, x2, y2) {
        return new Vec(A2.x + x2, A2.y + y2);
      }
      static Sub(A2, B) {
        return new Vec(A2.x - B.x, A2.y - B.y);
      }
      static SubXY(A2, x2, y2) {
        return new Vec(A2.x - x2, A2.y - y2);
      }
      static AddScalar(A2, n2) {
        return new Vec(A2.x + n2, A2.y + n2);
      }
      static SubScalar(A2, n2) {
        return new Vec(A2.x - n2, A2.y - n2);
      }
      static Div(A2, t3) {
        return new Vec(A2.x / t3, A2.y / t3);
      }
      static Mul(A2, t3) {
        return new Vec(A2.x * t3, A2.y * t3);
      }
      static DivV(A2, B) {
        return new Vec(A2.x / B.x, A2.y / B.y);
      }
      static MulV(A2, B) {
        return new Vec(A2.x * B.x, A2.y * B.y);
      }
      static Neg(A2) {
        return new Vec(-A2.x, -A2.y);
      }
      static Per(A2) {
        return new Vec(A2.y, -A2.x);
      }
      static Abs(A2) {
        return new Vec(Math.abs(A2.x), Math.abs(A2.y));
      }
      static Dist(A2, B) {
        return ((A2.y - B.y) ** 2 + (A2.x - B.x) ** 2) ** 0.5;
      }
      static DistMin(A2, B, n2) {
        return (A2.x - B.x) * (A2.x - B.x) + (A2.y - B.y) * (A2.y - B.y) < n2 ** 2;
      }
      static Dist2(A2, B) {
        return (A2.x - B.x) * (A2.x - B.x) + (A2.y - B.y) * (A2.y - B.y);
      }
      static Dpr(A2, B) {
        return A2.x * B.x + A2.y * B.y;
      }
      static Cross(A2, V) {
        return new Vec(A2.y * V.z - A2.z * V.y, A2.z * V.x - A2.x * V.z);
      }
      static Cpr(A2, B) {
        return A2.x * B.y - B.x * A2.y;
      }
      static Len2(A2) {
        return A2.x * A2.x + A2.y * A2.y;
      }
      static Len(A2) {
        return (A2.x * A2.x + A2.y * A2.y) ** 0.5;
      }
      static Pry(A2, B) {
        return Vec.Dpr(A2, B) / Vec.Len(B);
      }
      static Uni(A2) {
        return Vec.Div(A2, Vec.Len(A2));
      }
      static Tan(A2, B) {
        return Vec.Uni(Vec.Sub(A2, B));
      }
      static Min(A2, B) {
        return new Vec(Math.min(A2.x, B.x), Math.min(A2.y, B.y));
      }
      static Max(A2, B) {
        return new Vec(Math.max(A2.x, B.x), Math.max(A2.y, B.y));
      }
      static From({ x: x2, y: y2, z = 1 }) {
        return new Vec(x2, y2, z);
      }
      static FromArray(v2) {
        return new Vec(v2[0], v2[1]);
      }
      static Rot(A2, r2 = 0) {
        const s2 = Math.sin(r2);
        const c2 = Math.cos(r2);
        return new Vec(A2.x * c2 - A2.y * s2, A2.x * s2 + A2.y * c2);
      }
      static RotWith(A2, C2, r2) {
        const x2 = A2.x - C2.x;
        const y2 = A2.y - C2.y;
        const s2 = Math.sin(r2);
        const c2 = Math.cos(r2);
        return new Vec(C2.x + (x2 * c2 - y2 * s2), C2.y + (x2 * s2 + y2 * c2));
      }
      static NearestPointOnLineThroughPoint(A2, u2, P2) {
        return Vec.Mul(u2, Vec.Sub(P2, A2).pry(u2)).add(A2);
      }
      static NearestPointOnLineSegment(A2, B, P2, clamp4 = true) {
        if (Vec.Equals(A2, P2))
          return Vec.From(P2);
        if (Vec.Equals(B, P2))
          return Vec.From(P2);
        const u2 = Vec.Tan(B, A2);
        const C2 = Vec.Add(A2, Vec.Mul(u2, Vec.Sub(P2, A2).pry(u2)));
        if (clamp4) {
          if (C2.x < Math.min(A2.x, B.x))
            return Vec.Cast(A2.x < B.x ? A2 : B);
          if (C2.x > Math.max(A2.x, B.x))
            return Vec.Cast(A2.x > B.x ? A2 : B);
          if (C2.y < Math.min(A2.y, B.y))
            return Vec.Cast(A2.y < B.y ? A2 : B);
          if (C2.y > Math.max(A2.y, B.y))
            return Vec.Cast(A2.y > B.y ? A2 : B);
        }
        return C2;
      }
      static DistanceToLineThroughPoint(A2, u2, P2) {
        return Vec.Dist(P2, Vec.NearestPointOnLineThroughPoint(A2, u2, P2));
      }
      static DistanceToLineSegment(A2, B, P2, clamp4 = true) {
        return Vec.Dist(P2, Vec.NearestPointOnLineSegment(A2, B, P2, clamp4));
      }
      static Snap(A2, step = 1) {
        return new Vec(Math.round(A2.x / step) * step, Math.round(A2.y / step) * step);
      }
      static Cast(A2) {
        if (A2 instanceof Vec)
          return A2;
        return Vec.From(A2);
      }
      static Slope(A2, B) {
        if (A2.x === B.y)
          return NaN;
        return (A2.y - B.y) / (A2.x - B.x);
      }
      static IsNaN(A2) {
        return isNaN(A2.x) || isNaN(A2.y);
      }
      static Angle(A2, B) {
        return Math.atan2(B.y - A2.y, B.x - A2.x);
      }
      static Lrp(A2, B, t3) {
        return Vec.Sub(B, A2).mul(t3).add(A2);
      }
      static Med(A2, B) {
        return new Vec((A2.x + B.x) / 2, (A2.y + B.y) / 2);
      }
      static Equals(A2, B) {
        return Math.abs(A2.x - B.x) < 1e-4 && Math.abs(A2.y - B.y) < 1e-4;
      }
      static EqualsXY(A2, x2, y2) {
        return A2.x === x2 && A2.y === y2;
      }
      static Clockwise(A2, B, C2) {
        return (C2.x - A2.x) * (B.y - A2.y) - (B.x - A2.x) * (C2.y - A2.y) < 0;
      }
      static Rescale(A2, n2) {
        const l2 = Vec.Len(A2);
        return new Vec(n2 * A2.x / l2, n2 * A2.y / l2);
      }
      static ScaleWithOrigin(A2, scale, origin) {
        return Vec.Sub(A2, origin).mul(scale).add(origin);
      }
      static ToFixed(A2) {
        return new Vec(toFixed(A2.x), toFixed(A2.y));
      }
      static ToInt(A2) {
        return new Vec(parseInt(A2.x.toFixed(0)), parseInt(A2.y.toFixed(0)), parseInt((A2.z ?? 0).toFixed(0)));
      }
      static ToCss(A2) {
        return `${A2.x},${A2.y}`;
      }
      static Nudge(A2, B, distance) {
        return Vec.Add(A2, Vec.Tan(B, A2).mul(distance));
      }
      static ToString(A2) {
        return `${A2.x}, ${A2.y}`;
      }
      static ToAngle(A2) {
        let r2 = Math.atan2(A2.y, A2.x);
        if (r2 < 0)
          r2 += Math.PI * 2;
        return r2;
      }
      static FromAngle(r2, length = 1) {
        return new Vec(Math.cos(r2) * length, Math.sin(r2) * length);
      }
      static ToArray(A2) {
        return [A2.x, A2.y, A2.z];
      }
      static ToJson(A2) {
        const { x: x2, y: y2, z } = A2;
        return { x: x2, y: y2, z };
      }
      static Average(arr) {
        const len = arr.length;
        const avg = new Vec(0, 0);
        if (len === 0) {
          return avg;
        }
        for (let i2 = 0; i2 < len; i2++) {
          avg.add(arr[i2]);
        }
        return avg.div(len);
      }
      static Clamp(A2, min4, max3) {
        if (max3 === void 0) {
          return new Vec(Math.min(Math.max(A2.x, min4)), Math.min(Math.max(A2.y, min4)));
        }
        return new Vec(Math.min(Math.max(A2.x, min4), max3), Math.min(Math.max(A2.y, min4), max3));
      }
      static PointsBetween(A2, B, steps = 6) {
        const results = [];
        for (let i2 = 0; i2 < steps; i2++) {
          const t3 = EASINGS.easeInQuad(i2 / (steps - 1));
          const point = Vec.Lrp(A2, B, t3);
          point.z = Math.min(1, 0.5 + Math.abs(0.5 - ease(t3)) * 0.65);
          results.push(point);
        }
        return results;
      }
      static SnapToGrid(A2, gridSize = 8) {
        return new Vec(Math.round(A2.x / gridSize) * gridSize, Math.round(A2.y / gridSize) * gridSize);
      }
    };
    ease = (t3) => t3 < 0.5 ? 2 * t3 * t3 : -1 + (4 - 2 * t3) * t3;
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/utils.mjs
function precise(A2) {
  return `${toDomPrecision(A2.x)},${toDomPrecision(A2.y)} `;
}
function average2(A2, B) {
  return `${toDomPrecision((A2.x + B.x) / 2)},${toDomPrecision((A2.y + B.y) / 2)} `;
}
function clamp(n2, min4, max3) {
  return Math.max(min4, typeof max3 !== "undefined" ? Math.min(n2, max3) : n2);
}
function toPrecision(n2, precision = 1e10) {
  if (!n2)
    return 0;
  return Math.round(n2 * precision) / precision;
}
function approximately(a2, b2, precision = 1e-6) {
  return Math.abs(a2 - b2) <= precision;
}
function perimeterOfEllipse(rx, ry) {
  const h2 = Math.pow(rx - ry, 2) / Math.pow(rx + ry, 2);
  return PI * (rx + ry) * (1 + 3 * h2 / (10 + Math.sqrt(4 - 3 * h2)));
}
function canonicalizeRotation(a2) {
  a2 = a2 % PI2;
  if (a2 < 0) {
    a2 = a2 + PI2;
  } else if (a2 === 0) {
    a2 = 0;
  }
  return a2;
}
function clockwiseAngleDist(a0, a1) {
  a0 = canonicalizeRotation(a0);
  a1 = canonicalizeRotation(a1);
  if (a0 > a1) {
    a1 += PI2;
  }
  return a1 - a0;
}
function counterClockwiseAngleDist(a0, a1) {
  return PI2 - clockwiseAngleDist(a0, a1);
}
function shortAngleDist(a0, a1) {
  const da = (a1 - a0) % PI2;
  return 2 * da % PI2 - da;
}
function clampRadians(r2) {
  return (PI2 + r2) % PI2;
}
function snapAngle(r2, segments) {
  const seg = PI2 / segments;
  let ang = Math.floor((clampRadians(r2) + seg / 2) / seg) * seg % PI2;
  if (ang < PI)
    ang += PI2;
  if (ang > PI)
    ang -= PI2;
  return ang;
}
function areAnglesCompatible(a2, b2) {
  return a2 === b2 || approximately(a2 % (Math.PI / 2) - b2 % (Math.PI / 2), 0);
}
function degreesToRadians(d2) {
  return d2 * PI / 180;
}
function radiansToDegrees(r2) {
  return r2 * 180 / PI;
}
function getPointOnCircle(center, r2, a2) {
  return new Vec(center.x, center.y).add(Vec.FromAngle(a2, r2));
}
function getPolygonVertices(width, height, sides2) {
  const cx = width / 2;
  const cy = height / 2;
  const pointsOnPerimeter = [];
  let minX = Infinity;
  let maxX = -Infinity;
  let minY = Infinity;
  let maxY = -Infinity;
  for (let i2 = 0; i2 < sides2; i2++) {
    const step = PI2 / sides2;
    const t3 = -HALF_PI + i2 * step;
    const x2 = cx + cx * Math.cos(t3);
    const y2 = cy + cy * Math.sin(t3);
    if (x2 < minX)
      minX = x2;
    if (y2 < minY)
      minY = y2;
    if (x2 > maxX)
      maxX = x2;
    if (y2 > maxY)
      maxY = y2;
    pointsOnPerimeter.push(new Vec(x2, y2));
  }
  const w2 = maxX - minX;
  const h2 = maxY - minY;
  const dx = width - w2;
  const dy = height - h2;
  if (dx !== 0 || dy !== 0) {
    for (let i2 = 0; i2 < pointsOnPerimeter.length; i2++) {
      const pt = pointsOnPerimeter[i2];
      pt.x = (pt.x - minX) / w2 * width;
      pt.y = (pt.y - minY) / h2 * height;
    }
  }
  return pointsOnPerimeter;
}
function rangesOverlap(a0, a1, b0, b1) {
  return a0 < b1 && b0 < a1;
}
function rangeIntersection(a0, a1, b0, b1) {
  const min4 = Math.max(a0, b0);
  const max3 = Math.min(a1, b1);
  if (min4 <= max3) {
    return [min4, max3];
  }
  return null;
}
function cross(x2, y2, z) {
  return (y2.x - x2.x) * (z.y - x2.y) - (z.x - x2.x) * (y2.y - x2.y);
}
function pointInPolygon(A2, points) {
  let windingNumber = 0;
  let a2;
  let b2;
  for (let i2 = 0; i2 < points.length; i2++) {
    a2 = points[i2];
    if (a2.x === A2.x && a2.y === A2.y)
      return true;
    b2 = points[(i2 + 1) % points.length];
    if (Vec.Dist(A2, a2) + Vec.Dist(A2, b2) === Vec.Dist(a2, b2))
      return true;
    if (a2.y <= A2.y) {
      if (b2.y > A2.y && cross(a2, b2, A2) > 0) {
        windingNumber += 1;
      }
    } else if (b2.y <= A2.y && cross(a2, b2, A2) < 0) {
      windingNumber -= 1;
    }
  }
  return windingNumber !== 0;
}
function toDomPrecision(v2) {
  return Math.round(v2 * 1e4) / 1e4;
}
function toFixed(v2) {
  return Math.round(v2 * 100) / 100;
}
function angleDistance(fromAngle, toAngle, direction) {
  const dist = direction < 0 ? clockwiseAngleDist(fromAngle, toAngle) : counterClockwiseAngleDist(fromAngle, toAngle);
  return dist;
}
function getPointInArcT(mAB, A2, B, P2) {
  let mAP;
  if (Math.abs(mAB) > PI) {
    mAP = shortAngleDist(A2, P2);
    const mPB = shortAngleDist(P2, B);
    if (Math.abs(mAP) < Math.abs(mPB)) {
      return mAP / mAB;
    } else {
      return (mAB - mPB) / mAB;
    }
  } else {
    mAP = shortAngleDist(A2, P2);
    const t3 = mAP / mAB;
    if (Math.sign(mAP) !== Math.sign(mAB)) {
      return Math.abs(t3) > 0.5 ? 1 : 0;
    }
    return t3;
  }
}
function getArcMeasure(A2, B, sweepFlag, largeArcFlag) {
  const m2 = 2 * ((B - A2) % PI2) % PI2 - (B - A2) % PI2;
  if (!largeArcFlag)
    return m2;
  return (PI2 - Math.abs(m2)) * (sweepFlag ? 1 : -1);
}
function centerOfCircleFromThreePoints(a2, b2, c2) {
  const u2 = -2 * (a2.x * (b2.y - c2.y) - a2.y * (b2.x - c2.x) + b2.x * c2.y - c2.x * b2.y);
  return new Vec(((a2.x * a2.x + a2.y * a2.y) * (c2.y - b2.y) + (b2.x * b2.x + b2.y * b2.y) * (a2.y - c2.y) + (c2.x * c2.x + c2.y * c2.y) * (b2.y - a2.y)) / u2, ((a2.x * a2.x + a2.y * a2.y) * (b2.x - c2.x) + (b2.x * b2.x + b2.y * b2.y) * (c2.x - a2.x) + (c2.x * c2.x + c2.y * c2.y) * (a2.x - b2.x)) / u2);
}
function getPointsOnArc(startPoint, endPoint, center, radius, numPoints) {
  if (center === null) {
    return [Vec.From(startPoint), Vec.From(endPoint)];
  }
  const results = [];
  const startAngle = Vec.Angle(center, startPoint);
  const endAngle = Vec.Angle(center, endPoint);
  const l2 = clockwiseAngleDist(startAngle, endAngle);
  for (let i2 = 0; i2 < numPoints; i2++) {
    const t3 = i2 / (numPoints - 1);
    const angle = startAngle + l2 * t3;
    const point = getPointOnCircle(center, radius, angle);
    results.push(point);
  }
  return results;
}
var PI, HALF_PI, PI2, SIN, isSafeFloat;
var init_utils = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/utils.mjs"() {
    init_Vec();
    PI = Math.PI;
    HALF_PI = PI / 2;
    PI2 = PI * 2;
    SIN = Math.sin;
    isSafeFloat = (n2) => {
      return Math.abs(n2) < Number.MAX_SAFE_INTEGER;
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultBrush.mjs
var import_jsx_runtime3, import_react11, DefaultBrush;
var init_DefaultBrush = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultBrush.mjs"() {
    import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
    import_react11 = __toESM(require_react(), 1);
    init_useTransform();
    init_utils();
    DefaultBrush = ({ brush, color, opacity, className }) => {
      const rSvg = (0, import_react11.useRef)(null);
      useTransform(rSvg, brush.x, brush.y);
      const w2 = toDomPrecision(Math.max(1, brush.w));
      const h2 = toDomPrecision(Math.max(1, brush.h));
      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { className: "tl-overlays__item", ref: rSvg, children: color ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { className: "tl-brush", opacity, children: [
        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { width: w2, height: h2, fill: color, opacity: 0.75 }),
        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { width: w2, height: h2, fill: "none", stroke: color, opacity: 0.1 })
      ] }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { className: `tl-brush tl-brush__default ${className}`, width: w2, height: h2 }) });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/constants.mjs
var DEFAULT_CAMERA_OPTIONS, DEFAULT_ANIMATION_OPTIONS, INTERNAL_POINTER_IDS, SIDES, LEFT_MOUSE_BUTTON, RIGHT_MOUSE_BUTTON, MIDDLE_MOUSE_BUTTON, STYLUS_ERASER_BUTTON, ZOOM_TO_FIT_PADDING;
var init_constants3 = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/constants.mjs"() {
    init_easings();
    DEFAULT_CAMERA_OPTIONS = {
      isLocked: false,
      wheelBehavior: "pan",
      panSpeed: 1,
      zoomSpeed: 1,
      zoomSteps: [0.1, 0.25, 0.5, 1, 2, 4, 8]
    };
    DEFAULT_ANIMATION_OPTIONS = {
      duration: 0,
      easing: EASINGS.easeInOutCubic
    };
    INTERNAL_POINTER_IDS = {
      CAMERA_MOVE: -10
    };
    SIDES = ["top", "right", "bottom", "left"];
    LEFT_MOUSE_BUTTON = 0;
    RIGHT_MOUSE_BUTTON = 2;
    MIDDLE_MOUSE_BUTTON = 1;
    STYLUS_ERASER_BUTTON = 5;
    ZOOM_TO_FIT_PADDING = 128;
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/dom.mjs
function loopToHtmlElement(elm) {
  if (elm instanceof HTMLElement)
    return elm;
  if (elm.parentElement)
    return loopToHtmlElement(elm.parentElement);
  else
    throw Error("Could not find a parent element of an HTML type!");
}
function preventDefault(event) {
  event.preventDefault();
  if (debugFlags.logPreventDefaults.get()) {
    console.warn("preventDefault called on event:", event);
  }
}
function setPointerCapture(element, event) {
  element.setPointerCapture(event.pointerId);
  if (debugFlags.logPointerCaptures.get()) {
    const trackingObj = pointerCaptureTrackingObject.get();
    trackingObj.set(element, (trackingObj.get(element) ?? 0) + 1);
    console.warn("setPointerCapture called on element:", element, event);
  }
}
function releasePointerCapture(element, event) {
  if (!element.hasPointerCapture(event.pointerId)) {
    return;
  }
  element.releasePointerCapture(event.pointerId);
  if (debugFlags.logPointerCaptures.get()) {
    const trackingObj = pointerCaptureTrackingObject.get();
    if (trackingObj.get(element) === 1) {
      trackingObj.delete(element);
    } else if (trackingObj.has(element)) {
      trackingObj.set(element, trackingObj.get(element) - 1);
    } else {
      console.warn("Release without capture");
    }
    console.warn("releasePointerCapture called on element:", element, event);
  }
}
var stopEventPropagation, setStyleProperty;
var init_dom = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/dom.mjs"() {
    init_debug_flags();
    stopEventPropagation = (e2) => e2.stopPropagation();
    setStyleProperty = (elm, property, value) => {
      if (!elm)
        return;
      elm.style.setProperty(property, value);
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/getPointerInfo.mjs
function getPointerInfo(e2) {
  ;
  e2.isKilled = true;
  return {
    point: {
      x: e2.clientX,
      y: e2.clientY,
      z: e2.pressure
    },
    shiftKey: e2.shiftKey,
    altKey: e2.altKey,
    ctrlKey: e2.metaKey || e2.ctrlKey,
    pointerId: e2.pointerId,
    button: e2.button,
    isPen: e2.pointerType === "pen"
  };
}
var init_getPointerInfo = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/getPointerInfo.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useCanvasEvents.mjs
function useCanvasEvents() {
  const editor = useEditor();
  const events = (0, import_react12.useMemo)(function canvasEvents() {
    let lastX, lastY;
    function onPointerDown(e2) {
      if (e2.isKilled)
        return;
      if (e2.button === RIGHT_MOUSE_BUTTON) {
        editor.dispatch({
          type: "pointer",
          target: "canvas",
          name: "right_click",
          ...getPointerInfo(e2)
        });
        return;
      }
      if (e2.button !== 0 && e2.button !== 1 && e2.button !== 5)
        return;
      setPointerCapture(e2.currentTarget, e2);
      editor.dispatch({
        type: "pointer",
        target: "canvas",
        name: "pointer_down",
        ...getPointerInfo(e2)
      });
    }
    function onPointerMove(e2) {
      if (e2.isKilled)
        return;
      if (e2.clientX === lastX && e2.clientY === lastY)
        return;
      lastX = e2.clientX;
      lastY = e2.clientY;
      editor.dispatch({
        type: "pointer",
        target: "canvas",
        name: "pointer_move",
        ...getPointerInfo(e2)
      });
    }
    function onPointerUp(e2) {
      if (e2.isKilled)
        return;
      if (e2.button !== 0 && e2.button !== 1 && e2.button !== 2 && e2.button !== 5)
        return;
      lastX = e2.clientX;
      lastY = e2.clientY;
      releasePointerCapture(e2.currentTarget, e2);
      editor.dispatch({
        type: "pointer",
        target: "canvas",
        name: "pointer_up",
        ...getPointerInfo(e2)
      });
    }
    function onPointerEnter(e2) {
      if (e2.isKilled)
        return;
      if (editor.getInstanceState().isPenMode && e2.pointerType !== "pen")
        return;
      const canHover = e2.pointerType === "mouse" || e2.pointerType === "pen";
      editor.updateInstanceState({ isHoveringCanvas: canHover ? true : null });
    }
    function onPointerLeave(e2) {
      if (e2.isKilled)
        return;
      if (editor.getInstanceState().isPenMode && e2.pointerType !== "pen")
        return;
      const canHover = e2.pointerType === "mouse" || e2.pointerType === "pen";
      editor.updateInstanceState({ isHoveringCanvas: canHover ? false : null });
    }
    function onTouchStart(e2) {
      ;
      e2.isKilled = true;
      preventDefault(e2);
    }
    function onTouchEnd(e2) {
      ;
      e2.isKilled = true;
      if (!(e2.target instanceof HTMLElement))
        return;
      if (e2.target.tagName !== "A" && e2.target.tagName !== "TEXTAREA" && !(editor.getEditingShape() && e2.target.className.includes("tl-text-content"))) {
        preventDefault(e2);
      }
    }
    function onDragOver(e2) {
      preventDefault(e2);
    }
    async function onDrop(e2) {
      preventDefault(e2);
      if (!e2.dataTransfer?.files?.length)
        return;
      const files = Array.from(e2.dataTransfer.files);
      await editor.putExternalContent({
        type: "files",
        files,
        point: editor.screenToPage({ x: e2.clientX, y: e2.clientY }),
        ignoreParent: false
      });
    }
    function onClick(e2) {
      stopEventPropagation(e2);
    }
    return {
      onPointerDown,
      onPointerMove,
      onPointerUp,
      onPointerEnter,
      onPointerLeave,
      onDragOver,
      onDrop,
      onTouchStart,
      onTouchEnd,
      onClick
    };
  }, [editor]);
  return events;
}
var import_react12;
var init_useCanvasEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useCanvasEvents.mjs"() {
    import_react12 = __toESM(require_react(), 1);
    init_constants3();
    init_dom();
    init_getPointerInfo();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useCoarsePointer.mjs
function useCoarsePointer() {
  const editor = useEditor();
  (0, import_react13.useEffect)(() => {
    let isCoarse = editor.getInstanceState().isCoarsePointer;
    const handlePointerDown = (e2) => {
      const isCoarseEvent = e2.pointerType !== "mouse";
      if (isCoarse === isCoarseEvent)
        return;
      isCoarse = isCoarseEvent;
      editor.updateInstanceState({ isCoarsePointer: isCoarseEvent });
    };
    window.addEventListener("pointerdown", handlePointerDown, { capture: true });
    const mql = window.matchMedia && window.matchMedia("(any-pointer: coarse)");
    const isForcedFinePointer = editor.environment.isFirefox && !editor.environment.isAndroid && !editor.environment.isIos;
    const handleMediaQueryChange = () => {
      const next = isForcedFinePointer ? false : mql.matches;
      if (isCoarse !== next)
        return;
      isCoarse = next;
      editor.updateInstanceState({ isCoarsePointer: next });
    };
    if (mql) {
      mql.addEventListener("change", handleMediaQueryChange);
      handleMediaQueryChange();
    }
    return () => {
      window.removeEventListener("pointerdown", handlePointerDown, { capture: true });
      if (mql) {
        mql.removeEventListener("change", handleMediaQueryChange);
      }
    };
  }, [editor]);
}
var import_react13;
var init_useCoarsePointer = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useCoarsePointer.mjs"() {
    import_react13 = __toESM(require_react(), 1);
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useContainer.mjs
function ContainerProvider({
  container,
  children
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerContext.Provider, { value: container, children });
}
function useContainer() {
  return assertExists((0, import_react14.useContext)(ContainerContext), "useContainer used outside of <Tldraw />");
}
var import_jsx_runtime4, import_react14, ContainerContext;
var init_useContainer = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useContainer.mjs"() {
    import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm2();
    import_react14 = __toESM(require_react(), 1);
    ContainerContext = (0, import_react14.createContext)(null);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useDocumentEvents.mjs
function useDocumentEvents() {
  const editor = useEditor();
  const container = useContainer();
  const isAppFocused = useValue("isFocused", () => editor.getIsFocused(), [editor]);
  (0, import_react15.useEffect)(() => {
    if (typeof window === "undefined" || !("matchMedia" in window))
      return;
    let remove2 = null;
    const updatePixelRatio = () => {
      if (remove2 != null) {
        remove2();
      }
      const mqString = `(resolution: ${window.devicePixelRatio}dppx)`;
      const media = matchMedia(mqString);
      const safariCb = (ev) => {
        if (ev.type === "change") {
          updatePixelRatio();
        }
      };
      if (media.addEventListener) {
        media.addEventListener("change", updatePixelRatio);
      } else if (media.addListener) {
        media.addListener(safariCb);
      }
      remove2 = () => {
        if (media.removeEventListener) {
          media.removeEventListener("change", updatePixelRatio);
        } else if (media.removeListener) {
          media.removeListener(safariCb);
        }
      };
      editor.updateInstanceState({ devicePixelRatio: window.devicePixelRatio });
    };
    updatePixelRatio();
    return () => {
      remove2?.();
    };
  }, [editor]);
  (0, import_react15.useEffect)(() => {
    if (!isAppFocused)
      return;
    const handleKeyDown = (e2) => {
      if (e2.altKey && (editor.isIn("zoom") || !editor.getPath().endsWith(".idle")) && !isFocusingInput()) {
        preventDefault(e2);
      }
      if (e2.isKilled)
        return;
      e2.isKilled = true;
      switch (e2.key) {
        case "=":
        case "-":
        case "0": {
          if (e2.metaKey || e2.ctrlKey) {
            preventDefault(e2);
            return;
          }
          break;
        }
        case "Tab": {
          if (isFocusingInput() || editor.getIsMenuOpen()) {
            return;
          }
          break;
        }
        case ",": {
          return;
        }
        case "Escape": {
          if (editor.getEditingShape() || editor.getSelectedShapeIds().length > 0) {
            e2.preventDefault();
          }
          if (editor.getOpenMenus().length > 0)
            return;
          if (!editor.inputs.keys.has("Escape")) {
            editor.inputs.keys.add("Escape");
            editor.cancel();
            editor.focus();
          }
          return;
        }
        default: {
          if (isFocusingInput() || editor.getIsMenuOpen()) {
            return;
          }
        }
      }
      const info2 = {
        type: "keyboard",
        name: e2.repeat ? "key_repeat" : "key_down",
        key: e2.key,
        code: e2.code,
        shiftKey: e2.shiftKey,
        altKey: e2.altKey,
        ctrlKey: e2.metaKey || e2.ctrlKey
      };
      editor.dispatch(info2);
    };
    const handleKeyUp = (e2) => {
      if (e2.isKilled)
        return;
      e2.isKilled = true;
      if (isFocusingInput() || editor.getIsMenuOpen()) {
        return;
      }
      if (e2.key === ",") {
        return;
      }
      const info2 = {
        type: "keyboard",
        name: "key_up",
        key: e2.key,
        code: e2.code,
        shiftKey: e2.shiftKey,
        altKey: e2.altKey,
        ctrlKey: e2.metaKey || e2.ctrlKey
      };
      editor.dispatch(info2);
    };
    function handleTouchStart(e2) {
      if (container.contains(e2.target)) {
        const touchXPosition = e2.touches[0].pageX;
        const touchXRadius = e2.touches[0].radiusX || 0;
        if (touchXPosition - touchXRadius < 10 || touchXPosition + touchXRadius > editor.getViewportScreenBounds().width - 10) {
          if (e2.target?.tagName === "BUTTON") {
            ;
            e2.target?.click();
          }
          preventDefault(e2);
        }
      }
    }
    const handleWheel = (e2) => {
      if (container.contains(e2.target) && (e2.ctrlKey || e2.metaKey)) {
        preventDefault(e2);
      }
    };
    container.addEventListener("touchstart", handleTouchStart, { passive: false });
    container.addEventListener("wheel", handleWheel, { passive: false });
    document.addEventListener("gesturestart", preventDefault);
    document.addEventListener("gesturechange", preventDefault);
    document.addEventListener("gestureend", preventDefault);
    container.addEventListener("keydown", handleKeyDown);
    container.addEventListener("keyup", handleKeyUp);
    return () => {
      container.removeEventListener("touchstart", handleTouchStart);
      container.removeEventListener("wheel", handleWheel);
      document.removeEventListener("gesturestart", preventDefault);
      document.removeEventListener("gesturechange", preventDefault);
      document.removeEventListener("gestureend", preventDefault);
      container.removeEventListener("keydown", handleKeyDown);
      container.removeEventListener("keyup", handleKeyUp);
    };
  }, [editor, container, isAppFocused]);
}
function isFocusingInput() {
  const { activeElement } = document;
  if (activeElement && (activeElement.getAttribute("contenteditable") || INPUTS.indexOf(activeElement.tagName.toLowerCase()) > -1)) {
    return true;
  }
  return false;
}
var import_react15, INPUTS;
var init_useDocumentEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useDocumentEvents.mjs"() {
    init_dist_esm9();
    import_react15 = __toESM(require_react(), 1);
    init_dom();
    init_useContainer();
    init_useEditor();
    INPUTS = ["input", "select", "button", "textarea"];
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useFixSafariDoubleTapZoomPencilEvents.mjs
function useFixSafariDoubleTapZoomPencilEvents(ref) {
  const editor = useEditor();
  (0, import_react16.useEffect)(() => {
    const elm = ref.current;
    if (!elm)
      return;
    const handleEvent = (e2) => {
      if (e2 instanceof PointerEvent && e2.pointerType === "pen") {
        ;
        e2.isKilled = true;
        const { target } = e2;
        if (IGNORED_TAGS.includes(target.tagName?.toLocaleLowerCase()) || editor.isIn("select.editing_shape")) {
          return;
        }
        preventDefault(e2);
      }
    };
    elm.addEventListener("touchstart", handleEvent);
    elm.addEventListener("touchend", handleEvent);
    return () => {
      elm.removeEventListener("touchstart", handleEvent);
      elm.removeEventListener("touchend", handleEvent);
    };
  }, [editor, ref]);
}
var import_react16, IGNORED_TAGS;
var init_useFixSafariDoubleTapZoomPencilEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useFixSafariDoubleTapZoomPencilEvents.mjs"() {
    import_react16 = __toESM(require_react(), 1);
    init_dom();
    init_useEditor();
    IGNORED_TAGS = ["textarea", "input"];
  }
});

// node_modules/@use-gesture/core/dist/maths-83bc6f64.cjs.prod.js
var require_maths_83bc6f64_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/dist/maths-83bc6f64.cjs.prod.js"(exports) {
    "use strict";
    function clamp4(v2, min4, max3) {
      return Math.max(min4, Math.min(v2, max3));
    }
    var V = {
      toVector(v2, fallback) {
        if (v2 === void 0)
          v2 = fallback;
        return Array.isArray(v2) ? v2 : [v2, v2];
      },
      add(v1, v2) {
        return [v1[0] + v2[0], v1[1] + v2[1]];
      },
      sub(v1, v2) {
        return [v1[0] - v2[0], v1[1] - v2[1]];
      },
      addTo(v1, v2) {
        v1[0] += v2[0];
        v1[1] += v2[1];
      },
      subTo(v1, v2) {
        v1[0] -= v2[0];
        v1[1] -= v2[1];
      }
    };
    function rubberband(distance, dimension, constant) {
      if (dimension === 0 || Math.abs(dimension) === Infinity)
        return Math.pow(distance, constant * 5);
      return distance * dimension * constant / (dimension + constant * distance);
    }
    function rubberbandIfOutOfBounds(position, min4, max3, constant = 0.15) {
      if (constant === 0)
        return clamp4(position, min4, max3);
      if (position < min4)
        return -rubberband(min4 - position, max3 - min4, constant) + min4;
      if (position > max3)
        return +rubberband(position - max3, max3 - min4, constant) + max3;
      return position;
    }
    function computeRubberband(bounds, [Vx, Vy], [Rx, Ry]) {
      const [[X0, X1], [Y0, Y1]] = bounds;
      return [rubberbandIfOutOfBounds(Vx, X0, X1, Rx), rubberbandIfOutOfBounds(Vy, Y0, Y1, Ry)];
    }
    exports.V = V;
    exports.computeRubberband = computeRubberband;
    exports.rubberbandIfOutOfBounds = rubberbandIfOutOfBounds;
  }
});

// node_modules/@use-gesture/core/dist/actions-89e642c9.cjs.prod.js
var require_actions_89e642c9_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/dist/actions-89e642c9.cjs.prod.js"(exports) {
    "use strict";
    var maths = require_maths_83bc6f64_cjs_prod();
    function _toPrimitive2(input, hint) {
      if (typeof input !== "object" || input === null)
        return input;
      var prim = input[Symbol.toPrimitive];
      if (prim !== void 0) {
        var res = prim.call(input, hint || "default");
        if (typeof res !== "object")
          return res;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return (hint === "string" ? String : Number)(input);
    }
    function _toPropertyKey2(arg) {
      var key = _toPrimitive2(arg, "string");
      return typeof key === "symbol" ? key : String(key);
    }
    function _defineProperty2(obj, key, value) {
      key = _toPropertyKey2(key);
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }
    function ownKeys2(e2, r2) {
      var t3 = Object.keys(e2);
      if (Object.getOwnPropertySymbols) {
        var o2 = Object.getOwnPropertySymbols(e2);
        r2 && (o2 = o2.filter(function(r3) {
          return Object.getOwnPropertyDescriptor(e2, r3).enumerable;
        })), t3.push.apply(t3, o2);
      }
      return t3;
    }
    function _objectSpread22(e2) {
      for (var r2 = 1; r2 < arguments.length; r2++) {
        var t3 = arguments[r2] != null ? arguments[r2] : {};
        r2 % 2 ? ownKeys2(Object(t3), true).forEach(function(r3) {
          _defineProperty2(e2, r3, t3[r3]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e2, Object.getOwnPropertyDescriptors(t3)) : ownKeys2(Object(t3)).forEach(function(r3) {
          Object.defineProperty(e2, r3, Object.getOwnPropertyDescriptor(t3, r3));
        });
      }
      return e2;
    }
    var EVENT_TYPE_MAP = {
      pointer: {
        start: "down",
        change: "move",
        end: "up"
      },
      mouse: {
        start: "down",
        change: "move",
        end: "up"
      },
      touch: {
        start: "start",
        change: "move",
        end: "end"
      },
      gesture: {
        start: "start",
        change: "change",
        end: "end"
      }
    };
    function capitalize(string2) {
      if (!string2)
        return "";
      return string2[0].toUpperCase() + string2.slice(1);
    }
    var actionsWithoutCaptureSupported = ["enter", "leave"];
    function hasCapture(capture = false, actionKey) {
      return capture && !actionsWithoutCaptureSupported.includes(actionKey);
    }
    function toHandlerProp(device, action = "", capture = false) {
      const deviceProps = EVENT_TYPE_MAP[device];
      const actionKey = deviceProps ? deviceProps[action] || action : action;
      return "on" + capitalize(device) + capitalize(actionKey) + (hasCapture(capture, actionKey) ? "Capture" : "");
    }
    var pointerCaptureEvents = ["gotpointercapture", "lostpointercapture"];
    function parseProp(prop) {
      let eventKey = prop.substring(2).toLowerCase();
      const passive2 = !!~eventKey.indexOf("passive");
      if (passive2)
        eventKey = eventKey.replace("passive", "");
      const captureKey = pointerCaptureEvents.includes(eventKey) ? "capturecapture" : "capture";
      const capture = !!~eventKey.indexOf(captureKey);
      if (capture)
        eventKey = eventKey.replace("capture", "");
      return {
        device: eventKey,
        capture,
        passive: passive2
      };
    }
    function toDomEventType(device, action = "") {
      const deviceProps = EVENT_TYPE_MAP[device];
      const actionKey = deviceProps ? deviceProps[action] || action : action;
      return device + actionKey;
    }
    function isTouch(event) {
      return "touches" in event;
    }
    function getPointerType(event) {
      if (isTouch(event))
        return "touch";
      if ("pointerType" in event)
        return event.pointerType;
      return "mouse";
    }
    function getCurrentTargetTouchList(event) {
      return Array.from(event.touches).filter((e2) => {
        var _event$currentTarget, _event$currentTarget$;
        return e2.target === event.currentTarget || ((_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e2.target));
      });
    }
    function getTouchList(event) {
      return event.type === "touchend" || event.type === "touchcancel" ? event.changedTouches : event.targetTouches;
    }
    function getValueEvent(event) {
      return isTouch(event) ? getTouchList(event)[0] : event;
    }
    function distanceAngle(P1, P2) {
      try {
        const dx = P2.clientX - P1.clientX;
        const dy = P2.clientY - P1.clientY;
        const cx = (P2.clientX + P1.clientX) / 2;
        const cy = (P2.clientY + P1.clientY) / 2;
        const distance = Math.hypot(dx, dy);
        const angle = -(Math.atan2(dx, dy) * 180) / Math.PI;
        const origin = [cx, cy];
        return {
          angle,
          distance,
          origin
        };
      } catch (_unused) {
      }
      return null;
    }
    function touchIds(event) {
      return getCurrentTargetTouchList(event).map((touch) => touch.identifier);
    }
    function touchDistanceAngle(event, ids) {
      const [P1, P2] = Array.from(event.touches).filter((touch) => ids.includes(touch.identifier));
      return distanceAngle(P1, P2);
    }
    function pointerId(event) {
      const valueEvent = getValueEvent(event);
      return isTouch(event) ? valueEvent.identifier : valueEvent.pointerId;
    }
    function pointerValues(event) {
      const valueEvent = getValueEvent(event);
      return [valueEvent.clientX, valueEvent.clientY];
    }
    var LINE_HEIGHT = 40;
    var PAGE_HEIGHT = 800;
    function wheelValues(event) {
      let {
        deltaX,
        deltaY,
        deltaMode
      } = event;
      if (deltaMode === 1) {
        deltaX *= LINE_HEIGHT;
        deltaY *= LINE_HEIGHT;
      } else if (deltaMode === 2) {
        deltaX *= PAGE_HEIGHT;
        deltaY *= PAGE_HEIGHT;
      }
      return [deltaX, deltaY];
    }
    function scrollValues(event) {
      var _ref, _ref2;
      const {
        scrollX,
        scrollY,
        scrollLeft,
        scrollTop
      } = event.currentTarget;
      return [(_ref = scrollX !== null && scrollX !== void 0 ? scrollX : scrollLeft) !== null && _ref !== void 0 ? _ref : 0, (_ref2 = scrollY !== null && scrollY !== void 0 ? scrollY : scrollTop) !== null && _ref2 !== void 0 ? _ref2 : 0];
    }
    function getEventDetails(event) {
      const payload = {};
      if ("buttons" in event)
        payload.buttons = event.buttons;
      if ("shiftKey" in event) {
        const {
          shiftKey,
          altKey: altKey2,
          metaKey,
          ctrlKey
        } = event;
        Object.assign(payload, {
          shiftKey,
          altKey: altKey2,
          metaKey,
          ctrlKey
        });
      }
      return payload;
    }
    function call(v2, ...args) {
      if (typeof v2 === "function") {
        return v2(...args);
      } else {
        return v2;
      }
    }
    function noop5() {
    }
    function chain(...fns) {
      if (fns.length === 0)
        return noop5;
      if (fns.length === 1)
        return fns[0];
      return function() {
        let result;
        for (const fn3 of fns) {
          result = fn3.apply(this, arguments) || result;
        }
        return result;
      };
    }
    function assignDefault(value, fallback) {
      return Object.assign({}, fallback, value || {});
    }
    var BEFORE_LAST_KINEMATICS_DELAY = 32;
    var Engine = class {
      constructor(ctrl, args, key) {
        this.ctrl = ctrl;
        this.args = args;
        this.key = key;
        if (!this.state) {
          this.state = {};
          this.computeValues([0, 0]);
          this.computeInitial();
          if (this.init)
            this.init();
          this.reset();
        }
      }
      get state() {
        return this.ctrl.state[this.key];
      }
      set state(state) {
        this.ctrl.state[this.key] = state;
      }
      get shared() {
        return this.ctrl.state.shared;
      }
      get eventStore() {
        return this.ctrl.gestureEventStores[this.key];
      }
      get timeoutStore() {
        return this.ctrl.gestureTimeoutStores[this.key];
      }
      get config() {
        return this.ctrl.config[this.key];
      }
      get sharedConfig() {
        return this.ctrl.config.shared;
      }
      get handler() {
        return this.ctrl.handlers[this.key];
      }
      reset() {
        const {
          state,
          shared,
          ingKey,
          args
        } = this;
        shared[ingKey] = state._active = state.active = state._blocked = state._force = false;
        state._step = [false, false];
        state.intentional = false;
        state._movement = [0, 0];
        state._distance = [0, 0];
        state._direction = [0, 0];
        state._delta = [0, 0];
        state._bounds = [[-Infinity, Infinity], [-Infinity, Infinity]];
        state.args = args;
        state.axis = void 0;
        state.memo = void 0;
        state.elapsedTime = state.timeDelta = 0;
        state.direction = [0, 0];
        state.distance = [0, 0];
        state.overflow = [0, 0];
        state._movementBound = [false, false];
        state.velocity = [0, 0];
        state.movement = [0, 0];
        state.delta = [0, 0];
        state.timeStamp = 0;
      }
      start(event) {
        const state = this.state;
        const config = this.config;
        if (!state._active) {
          this.reset();
          this.computeInitial();
          state._active = true;
          state.target = event.target;
          state.currentTarget = event.currentTarget;
          state.lastOffset = config.from ? call(config.from, state) : state.offset;
          state.offset = state.lastOffset;
          state.startTime = state.timeStamp = event.timeStamp;
        }
      }
      computeValues(values) {
        const state = this.state;
        state._values = values;
        state.values = this.config.transform(values);
      }
      computeInitial() {
        const state = this.state;
        state._initial = state._values;
        state.initial = state.values;
      }
      compute(event) {
        const {
          state,
          config,
          shared
        } = this;
        state.args = this.args;
        let dt = 0;
        if (event) {
          state.event = event;
          if (config.preventDefault && event.cancelable)
            state.event.preventDefault();
          state.type = event.type;
          shared.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size;
          shared.locked = !!document.pointerLockElement;
          Object.assign(shared, getEventDetails(event));
          shared.down = shared.pressed = shared.buttons % 2 === 1 || shared.touches > 0;
          dt = event.timeStamp - state.timeStamp;
          state.timeStamp = event.timeStamp;
          state.elapsedTime = state.timeStamp - state.startTime;
        }
        if (state._active) {
          const _absoluteDelta = state._delta.map(Math.abs);
          maths.V.addTo(state._distance, _absoluteDelta);
        }
        if (this.axisIntent)
          this.axisIntent(event);
        const [_m0, _m1] = state._movement;
        const [t0, t1] = config.threshold;
        const {
          _step,
          values
        } = state;
        if (config.hasCustomTransform) {
          if (_step[0] === false)
            _step[0] = Math.abs(_m0) >= t0 && values[0];
          if (_step[1] === false)
            _step[1] = Math.abs(_m1) >= t1 && values[1];
        } else {
          if (_step[0] === false)
            _step[0] = Math.abs(_m0) >= t0 && Math.sign(_m0) * t0;
          if (_step[1] === false)
            _step[1] = Math.abs(_m1) >= t1 && Math.sign(_m1) * t1;
        }
        state.intentional = _step[0] !== false || _step[1] !== false;
        if (!state.intentional)
          return;
        const movement = [0, 0];
        if (config.hasCustomTransform) {
          const [v0, v1] = values;
          movement[0] = _step[0] !== false ? v0 - _step[0] : 0;
          movement[1] = _step[1] !== false ? v1 - _step[1] : 0;
        } else {
          movement[0] = _step[0] !== false ? _m0 - _step[0] : 0;
          movement[1] = _step[1] !== false ? _m1 - _step[1] : 0;
        }
        if (this.restrictToAxis && !state._blocked)
          this.restrictToAxis(movement);
        const previousOffset = state.offset;
        const gestureIsActive = state._active && !state._blocked || state.active;
        if (gestureIsActive) {
          state.first = state._active && !state.active;
          state.last = !state._active && state.active;
          state.active = shared[this.ingKey] = state._active;
          if (event) {
            if (state.first) {
              if ("bounds" in config)
                state._bounds = call(config.bounds, state);
              if (this.setup)
                this.setup();
            }
            state.movement = movement;
            this.computeOffset();
          }
        }
        const [ox, oy] = state.offset;
        const [[x0, x1], [y0, y1]] = state._bounds;
        state.overflow = [ox < x0 ? -1 : ox > x1 ? 1 : 0, oy < y0 ? -1 : oy > y1 ? 1 : 0];
        state._movementBound[0] = state.overflow[0] ? state._movementBound[0] === false ? state._movement[0] : state._movementBound[0] : false;
        state._movementBound[1] = state.overflow[1] ? state._movementBound[1] === false ? state._movement[1] : state._movementBound[1] : false;
        const rubberband = state._active ? config.rubberband || [0, 0] : [0, 0];
        state.offset = maths.computeRubberband(state._bounds, state.offset, rubberband);
        state.delta = maths.V.sub(state.offset, previousOffset);
        this.computeMovement();
        if (gestureIsActive && (!state.last || dt > BEFORE_LAST_KINEMATICS_DELAY)) {
          state.delta = maths.V.sub(state.offset, previousOffset);
          const absoluteDelta = state.delta.map(Math.abs);
          maths.V.addTo(state.distance, absoluteDelta);
          state.direction = state.delta.map(Math.sign);
          state._direction = state._delta.map(Math.sign);
          if (!state.first && dt > 0) {
            state.velocity = [absoluteDelta[0] / dt, absoluteDelta[1] / dt];
            state.timeDelta = dt;
          }
        }
      }
      emit() {
        const state = this.state;
        const shared = this.shared;
        const config = this.config;
        if (!state._active)
          this.clean();
        if ((state._blocked || !state.intentional) && !state._force && !config.triggerAllEvents)
          return;
        const memo29 = this.handler(_objectSpread22(_objectSpread22(_objectSpread22({}, shared), state), {}, {
          [this.aliasKey]: state.values
        }));
        if (memo29 !== void 0)
          state.memo = memo29;
      }
      clean() {
        this.eventStore.clean();
        this.timeoutStore.clean();
      }
    };
    function selectAxis([dx, dy], threshold) {
      const absDx = Math.abs(dx);
      const absDy = Math.abs(dy);
      if (absDx > absDy && absDx > threshold) {
        return "x";
      }
      if (absDy > absDx && absDy > threshold) {
        return "y";
      }
      return void 0;
    }
    var CoordinatesEngine = class extends Engine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "aliasKey", "xy");
      }
      reset() {
        super.reset();
        this.state.axis = void 0;
      }
      init() {
        this.state.offset = [0, 0];
        this.state.lastOffset = [0, 0];
      }
      computeOffset() {
        this.state.offset = maths.V.add(this.state.lastOffset, this.state.movement);
      }
      computeMovement() {
        this.state.movement = maths.V.sub(this.state.offset, this.state.lastOffset);
      }
      axisIntent(event) {
        const state = this.state;
        const config = this.config;
        if (!state.axis && event) {
          const threshold = typeof config.axisThreshold === "object" ? config.axisThreshold[getPointerType(event)] : config.axisThreshold;
          state.axis = selectAxis(state._movement, threshold);
        }
        state._blocked = (config.lockDirection || !!config.axis) && !state.axis || !!config.axis && config.axis !== state.axis;
      }
      restrictToAxis(v2) {
        if (this.config.axis || this.config.lockDirection) {
          switch (this.state.axis) {
            case "x":
              v2[1] = 0;
              break;
            case "y":
              v2[0] = 0;
              break;
          }
        }
      }
    };
    var identity = (v2) => v2;
    var DEFAULT_RUBBERBAND = 0.15;
    var commonConfigResolver = {
      enabled(value = true) {
        return value;
      },
      eventOptions(value, _k, config) {
        return _objectSpread22(_objectSpread22({}, config.shared.eventOptions), value);
      },
      preventDefault(value = false) {
        return value;
      },
      triggerAllEvents(value = false) {
        return value;
      },
      rubberband(value = 0) {
        switch (value) {
          case true:
            return [DEFAULT_RUBBERBAND, DEFAULT_RUBBERBAND];
          case false:
            return [0, 0];
          default:
            return maths.V.toVector(value);
        }
      },
      from(value) {
        if (typeof value === "function")
          return value;
        if (value != null)
          return maths.V.toVector(value);
      },
      transform(value, _k, config) {
        const transform = value || config.shared.transform;
        this.hasCustomTransform = !!transform;
        return transform || identity;
      },
      threshold(value) {
        return maths.V.toVector(value, 0);
      }
    };
    var DEFAULT_AXIS_THRESHOLD = 0;
    var coordinatesConfigResolver = _objectSpread22(_objectSpread22({}, commonConfigResolver), {}, {
      axis(_v, _k, {
        axis
      }) {
        this.lockDirection = axis === "lock";
        if (!this.lockDirection)
          return axis;
      },
      axisThreshold(value = DEFAULT_AXIS_THRESHOLD) {
        return value;
      },
      bounds(value = {}) {
        if (typeof value === "function") {
          return (state) => coordinatesConfigResolver.bounds(value(state));
        }
        if ("current" in value) {
          return () => value.current;
        }
        if (typeof HTMLElement === "function" && value instanceof HTMLElement) {
          return value;
        }
        const {
          left: left2 = -Infinity,
          right: right2 = Infinity,
          top: top2 = -Infinity,
          bottom: bottom2 = Infinity
        } = value;
        return [[left2, right2], [top2, bottom2]];
      }
    });
    var KEYS_DELTA_MAP = {
      ArrowRight: (displacement, factor = 1) => [displacement * factor, 0],
      ArrowLeft: (displacement, factor = 1) => [-1 * displacement * factor, 0],
      ArrowUp: (displacement, factor = 1) => [0, -1 * displacement * factor],
      ArrowDown: (displacement, factor = 1) => [0, displacement * factor]
    };
    var DragEngine = class extends CoordinatesEngine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "dragging");
      }
      reset() {
        super.reset();
        const state = this.state;
        state._pointerId = void 0;
        state._pointerActive = false;
        state._keyboardActive = false;
        state._preventScroll = false;
        state._delayed = false;
        state.swipe = [0, 0];
        state.tap = false;
        state.canceled = false;
        state.cancel = this.cancel.bind(this);
      }
      setup() {
        const state = this.state;
        if (state._bounds instanceof HTMLElement) {
          const boundRect = state._bounds.getBoundingClientRect();
          const targetRect = state.currentTarget.getBoundingClientRect();
          const _bounds = {
            left: boundRect.left - targetRect.left + state.offset[0],
            right: boundRect.right - targetRect.right + state.offset[0],
            top: boundRect.top - targetRect.top + state.offset[1],
            bottom: boundRect.bottom - targetRect.bottom + state.offset[1]
          };
          state._bounds = coordinatesConfigResolver.bounds(_bounds);
        }
      }
      cancel() {
        const state = this.state;
        if (state.canceled)
          return;
        state.canceled = true;
        state._active = false;
        setTimeout(() => {
          this.compute();
          this.emit();
        }, 0);
      }
      setActive() {
        this.state._active = this.state._pointerActive || this.state._keyboardActive;
      }
      clean() {
        this.pointerClean();
        this.state._pointerActive = false;
        this.state._keyboardActive = false;
        super.clean();
      }
      pointerDown(event) {
        const config = this.config;
        const state = this.state;
        if (event.buttons != null && (Array.isArray(config.pointerButtons) ? !config.pointerButtons.includes(event.buttons) : config.pointerButtons !== -1 && config.pointerButtons !== event.buttons))
          return;
        const ctrlIds = this.ctrl.setEventIds(event);
        if (config.pointerCapture) {
          event.target.setPointerCapture(event.pointerId);
        }
        if (ctrlIds && ctrlIds.size > 1 && state._pointerActive)
          return;
        this.start(event);
        this.setupPointer(event);
        state._pointerId = pointerId(event);
        state._pointerActive = true;
        this.computeValues(pointerValues(event));
        this.computeInitial();
        if (config.preventScrollAxis && getPointerType(event) !== "mouse") {
          state._active = false;
          this.setupScrollPrevention(event);
        } else if (config.delay > 0) {
          this.setupDelayTrigger(event);
          if (config.triggerAllEvents) {
            this.compute(event);
            this.emit();
          }
        } else {
          this.startPointerDrag(event);
        }
      }
      startPointerDrag(event) {
        const state = this.state;
        state._active = true;
        state._preventScroll = true;
        state._delayed = false;
        this.compute(event);
        this.emit();
      }
      pointerMove(event) {
        const state = this.state;
        const config = this.config;
        if (!state._pointerActive)
          return;
        const id = pointerId(event);
        if (state._pointerId !== void 0 && id !== state._pointerId)
          return;
        const _values = pointerValues(event);
        if (document.pointerLockElement === event.target) {
          state._delta = [event.movementX, event.movementY];
        } else {
          state._delta = maths.V.sub(_values, state._values);
          this.computeValues(_values);
        }
        maths.V.addTo(state._movement, state._delta);
        this.compute(event);
        if (state._delayed && state.intentional) {
          this.timeoutStore.remove("dragDelay");
          state.active = false;
          this.startPointerDrag(event);
          return;
        }
        if (config.preventScrollAxis && !state._preventScroll) {
          if (state.axis) {
            if (state.axis === config.preventScrollAxis || config.preventScrollAxis === "xy") {
              state._active = false;
              this.clean();
              return;
            } else {
              this.timeoutStore.remove("startPointerDrag");
              this.startPointerDrag(event);
              return;
            }
          } else {
            return;
          }
        }
        this.emit();
      }
      pointerUp(event) {
        this.ctrl.setEventIds(event);
        try {
          if (this.config.pointerCapture && event.target.hasPointerCapture(event.pointerId)) {
            ;
            event.target.releasePointerCapture(event.pointerId);
          }
        } catch (_unused) {
        }
        const state = this.state;
        const config = this.config;
        if (!state._active || !state._pointerActive)
          return;
        const id = pointerId(event);
        if (state._pointerId !== void 0 && id !== state._pointerId)
          return;
        this.state._pointerActive = false;
        this.setActive();
        this.compute(event);
        const [dx, dy] = state._distance;
        state.tap = dx <= config.tapsThreshold && dy <= config.tapsThreshold;
        if (state.tap && config.filterTaps) {
          state._force = true;
        } else {
          const [_dx, _dy] = state._delta;
          const [_mx, _my] = state._movement;
          const [svx, svy] = config.swipe.velocity;
          const [sx, sy] = config.swipe.distance;
          const sdt = config.swipe.duration;
          if (state.elapsedTime < sdt) {
            const _vx = Math.abs(_dx / state.timeDelta);
            const _vy = Math.abs(_dy / state.timeDelta);
            if (_vx > svx && Math.abs(_mx) > sx)
              state.swipe[0] = Math.sign(_dx);
            if (_vy > svy && Math.abs(_my) > sy)
              state.swipe[1] = Math.sign(_dy);
          }
        }
        this.emit();
      }
      pointerClick(event) {
        if (!this.state.tap && event.detail > 0) {
          event.preventDefault();
          event.stopPropagation();
        }
      }
      setupPointer(event) {
        const config = this.config;
        const device = config.device;
        if (config.pointerLock) {
          event.currentTarget.requestPointerLock();
        }
        if (!config.pointerCapture) {
          this.eventStore.add(this.sharedConfig.window, device, "change", this.pointerMove.bind(this));
          this.eventStore.add(this.sharedConfig.window, device, "end", this.pointerUp.bind(this));
          this.eventStore.add(this.sharedConfig.window, device, "cancel", this.pointerUp.bind(this));
        }
      }
      pointerClean() {
        if (this.config.pointerLock && document.pointerLockElement === this.state.currentTarget) {
          document.exitPointerLock();
        }
      }
      preventScroll(event) {
        if (this.state._preventScroll && event.cancelable) {
          event.preventDefault();
        }
      }
      setupScrollPrevention(event) {
        this.state._preventScroll = false;
        persistEvent(event);
        const remove2 = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
          passive: false
        });
        this.eventStore.add(this.sharedConfig.window, "touch", "end", remove2);
        this.eventStore.add(this.sharedConfig.window, "touch", "cancel", remove2);
        this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, event);
      }
      setupDelayTrigger(event) {
        this.state._delayed = true;
        this.timeoutStore.add("dragDelay", () => {
          this.state._step = [0, 0];
          this.startPointerDrag(event);
        }, this.config.delay);
      }
      keyDown(event) {
        const deltaFn = KEYS_DELTA_MAP[event.key];
        if (deltaFn) {
          const state = this.state;
          const factor = event.shiftKey ? 10 : event.altKey ? 0.1 : 1;
          this.start(event);
          state._delta = deltaFn(this.config.keyboardDisplacement, factor);
          state._keyboardActive = true;
          maths.V.addTo(state._movement, state._delta);
          this.compute(event);
          this.emit();
        }
      }
      keyUp(event) {
        if (!(event.key in KEYS_DELTA_MAP))
          return;
        this.state._keyboardActive = false;
        this.setActive();
        this.compute(event);
        this.emit();
      }
      bind(bindFunction) {
        const device = this.config.device;
        bindFunction(device, "start", this.pointerDown.bind(this));
        if (this.config.pointerCapture) {
          bindFunction(device, "change", this.pointerMove.bind(this));
          bindFunction(device, "end", this.pointerUp.bind(this));
          bindFunction(device, "cancel", this.pointerUp.bind(this));
          bindFunction("lostPointerCapture", "", this.pointerUp.bind(this));
        }
        if (this.config.keys) {
          bindFunction("key", "down", this.keyDown.bind(this));
          bindFunction("key", "up", this.keyUp.bind(this));
        }
        if (this.config.filterTaps) {
          bindFunction("click", "", this.pointerClick.bind(this), {
            capture: true,
            passive: false
          });
        }
      }
    };
    function persistEvent(event) {
      "persist" in event && typeof event.persist === "function" && event.persist();
    }
    var isBrowser3 = typeof window !== "undefined" && window.document && window.document.createElement;
    function supportsTouchEvents() {
      return isBrowser3 && "ontouchstart" in window;
    }
    function isTouchScreen() {
      return supportsTouchEvents() || isBrowser3 && window.navigator.maxTouchPoints > 1;
    }
    function supportsPointerEvents() {
      return isBrowser3 && "onpointerdown" in window;
    }
    function supportsPointerLock() {
      return isBrowser3 && "exitPointerLock" in window.document;
    }
    function supportsGestureEvents() {
      try {
        return "constructor" in GestureEvent;
      } catch (e2) {
        return false;
      }
    }
    var SUPPORT = {
      isBrowser: isBrowser3,
      gesture: supportsGestureEvents(),
      touch: supportsTouchEvents(),
      touchscreen: isTouchScreen(),
      pointer: supportsPointerEvents(),
      pointerLock: supportsPointerLock()
    };
    var DEFAULT_PREVENT_SCROLL_DELAY = 250;
    var DEFAULT_DRAG_DELAY = 180;
    var DEFAULT_SWIPE_VELOCITY = 0.5;
    var DEFAULT_SWIPE_DISTANCE = 50;
    var DEFAULT_SWIPE_DURATION = 250;
    var DEFAULT_KEYBOARD_DISPLACEMENT = 10;
    var DEFAULT_DRAG_AXIS_THRESHOLD = {
      mouse: 0,
      touch: 0,
      pen: 8
    };
    var dragConfigResolver = _objectSpread22(_objectSpread22({}, coordinatesConfigResolver), {}, {
      device(_v, _k, {
        pointer: {
          touch = false,
          lock = false,
          mouse = false
        } = {}
      }) {
        this.pointerLock = lock && SUPPORT.pointerLock;
        if (SUPPORT.touch && touch)
          return "touch";
        if (this.pointerLock)
          return "mouse";
        if (SUPPORT.pointer && !mouse)
          return "pointer";
        if (SUPPORT.touch)
          return "touch";
        return "mouse";
      },
      preventScrollAxis(value, _k, {
        preventScroll
      }) {
        this.preventScrollDelay = typeof preventScroll === "number" ? preventScroll : preventScroll || preventScroll === void 0 && value ? DEFAULT_PREVENT_SCROLL_DELAY : void 0;
        if (!SUPPORT.touchscreen || preventScroll === false)
          return void 0;
        return value ? value : preventScroll !== void 0 ? "y" : void 0;
      },
      pointerCapture(_v, _k, {
        pointer: {
          capture = true,
          buttons = 1,
          keys = true
        } = {}
      }) {
        this.pointerButtons = buttons;
        this.keys = keys;
        return !this.pointerLock && this.device === "pointer" && capture;
      },
      threshold(value, _k, {
        filterTaps = false,
        tapsThreshold = 3,
        axis = void 0
      }) {
        const threshold = maths.V.toVector(value, filterTaps ? tapsThreshold : axis ? 1 : 0);
        this.filterTaps = filterTaps;
        this.tapsThreshold = tapsThreshold;
        return threshold;
      },
      swipe({
        velocity = DEFAULT_SWIPE_VELOCITY,
        distance = DEFAULT_SWIPE_DISTANCE,
        duration = DEFAULT_SWIPE_DURATION
      } = {}) {
        return {
          velocity: this.transform(maths.V.toVector(velocity)),
          distance: this.transform(maths.V.toVector(distance)),
          duration
        };
      },
      delay(value = 0) {
        switch (value) {
          case true:
            return DEFAULT_DRAG_DELAY;
          case false:
            return 0;
          default:
            return value;
        }
      },
      axisThreshold(value) {
        if (!value)
          return DEFAULT_DRAG_AXIS_THRESHOLD;
        return _objectSpread22(_objectSpread22({}, DEFAULT_DRAG_AXIS_THRESHOLD), value);
      },
      keyboardDisplacement(value = DEFAULT_KEYBOARD_DISPLACEMENT) {
        return value;
      }
    });
    function clampStateInternalMovementToBounds(state) {
      const [ox, oy] = state.overflow;
      const [dx, dy] = state._delta;
      const [dirx, diry] = state._direction;
      if (ox < 0 && dx > 0 && dirx < 0 || ox > 0 && dx < 0 && dirx > 0) {
        state._movement[0] = state._movementBound[0];
      }
      if (oy < 0 && dy > 0 && diry < 0 || oy > 0 && dy < 0 && diry > 0) {
        state._movement[1] = state._movementBound[1];
      }
    }
    var SCALE_ANGLE_RATIO_INTENT_DEG = 30;
    var PINCH_WHEEL_RATIO = 100;
    var PinchEngine = class extends Engine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "pinching");
        _defineProperty2(this, "aliasKey", "da");
      }
      init() {
        this.state.offset = [1, 0];
        this.state.lastOffset = [1, 0];
        this.state._pointerEvents = /* @__PURE__ */ new Map();
      }
      reset() {
        super.reset();
        const state = this.state;
        state._touchIds = [];
        state.canceled = false;
        state.cancel = this.cancel.bind(this);
        state.turns = 0;
      }
      computeOffset() {
        const {
          type,
          movement,
          lastOffset
        } = this.state;
        if (type === "wheel") {
          this.state.offset = maths.V.add(movement, lastOffset);
        } else {
          this.state.offset = [(1 + movement[0]) * lastOffset[0], movement[1] + lastOffset[1]];
        }
      }
      computeMovement() {
        const {
          offset: offset5,
          lastOffset
        } = this.state;
        this.state.movement = [offset5[0] / lastOffset[0], offset5[1] - lastOffset[1]];
      }
      axisIntent() {
        const state = this.state;
        const [_m0, _m1] = state._movement;
        if (!state.axis) {
          const axisMovementDifference = Math.abs(_m0) * SCALE_ANGLE_RATIO_INTENT_DEG - Math.abs(_m1);
          if (axisMovementDifference < 0)
            state.axis = "angle";
          else if (axisMovementDifference > 0)
            state.axis = "scale";
        }
      }
      restrictToAxis(v2) {
        if (this.config.lockDirection) {
          if (this.state.axis === "scale")
            v2[1] = 0;
          else if (this.state.axis === "angle")
            v2[0] = 0;
        }
      }
      cancel() {
        const state = this.state;
        if (state.canceled)
          return;
        setTimeout(() => {
          state.canceled = true;
          state._active = false;
          this.compute();
          this.emit();
        }, 0);
      }
      touchStart(event) {
        this.ctrl.setEventIds(event);
        const state = this.state;
        const ctrlTouchIds = this.ctrl.touchIds;
        if (state._active) {
          if (state._touchIds.every((id) => ctrlTouchIds.has(id)))
            return;
        }
        if (ctrlTouchIds.size < 2)
          return;
        this.start(event);
        state._touchIds = Array.from(ctrlTouchIds).slice(0, 2);
        const payload = touchDistanceAngle(event, state._touchIds);
        if (!payload)
          return;
        this.pinchStart(event, payload);
      }
      pointerStart(event) {
        if (event.buttons != null && event.buttons % 2 !== 1)
          return;
        this.ctrl.setEventIds(event);
        event.target.setPointerCapture(event.pointerId);
        const state = this.state;
        const _pointerEvents = state._pointerEvents;
        const ctrlPointerIds = this.ctrl.pointerIds;
        if (state._active) {
          if (Array.from(_pointerEvents.keys()).every((id) => ctrlPointerIds.has(id)))
            return;
        }
        if (_pointerEvents.size < 2) {
          _pointerEvents.set(event.pointerId, event);
        }
        if (state._pointerEvents.size < 2)
          return;
        this.start(event);
        const payload = distanceAngle(...Array.from(_pointerEvents.values()));
        if (!payload)
          return;
        this.pinchStart(event, payload);
      }
      pinchStart(event, payload) {
        const state = this.state;
        state.origin = payload.origin;
        this.computeValues([payload.distance, payload.angle]);
        this.computeInitial();
        this.compute(event);
        this.emit();
      }
      touchMove(event) {
        if (!this.state._active)
          return;
        const payload = touchDistanceAngle(event, this.state._touchIds);
        if (!payload)
          return;
        this.pinchMove(event, payload);
      }
      pointerMove(event) {
        const _pointerEvents = this.state._pointerEvents;
        if (_pointerEvents.has(event.pointerId)) {
          _pointerEvents.set(event.pointerId, event);
        }
        if (!this.state._active)
          return;
        const payload = distanceAngle(...Array.from(_pointerEvents.values()));
        if (!payload)
          return;
        this.pinchMove(event, payload);
      }
      pinchMove(event, payload) {
        const state = this.state;
        const prev_a = state._values[1];
        const delta_a = payload.angle - prev_a;
        let delta_turns = 0;
        if (Math.abs(delta_a) > 270)
          delta_turns += Math.sign(delta_a);
        this.computeValues([payload.distance, payload.angle - 360 * delta_turns]);
        state.origin = payload.origin;
        state.turns = delta_turns;
        state._movement = [state._values[0] / state._initial[0] - 1, state._values[1] - state._initial[1]];
        this.compute(event);
        this.emit();
      }
      touchEnd(event) {
        this.ctrl.setEventIds(event);
        if (!this.state._active)
          return;
        if (this.state._touchIds.some((id) => !this.ctrl.touchIds.has(id))) {
          this.state._active = false;
          this.compute(event);
          this.emit();
        }
      }
      pointerEnd(event) {
        const state = this.state;
        this.ctrl.setEventIds(event);
        try {
          event.target.releasePointerCapture(event.pointerId);
        } catch (_unused) {
        }
        if (state._pointerEvents.has(event.pointerId)) {
          state._pointerEvents.delete(event.pointerId);
        }
        if (!state._active)
          return;
        if (state._pointerEvents.size < 2) {
          state._active = false;
          this.compute(event);
          this.emit();
        }
      }
      gestureStart(event) {
        if (event.cancelable)
          event.preventDefault();
        const state = this.state;
        if (state._active)
          return;
        this.start(event);
        this.computeValues([event.scale, event.rotation]);
        state.origin = [event.clientX, event.clientY];
        this.compute(event);
        this.emit();
      }
      gestureMove(event) {
        if (event.cancelable)
          event.preventDefault();
        if (!this.state._active)
          return;
        const state = this.state;
        this.computeValues([event.scale, event.rotation]);
        state.origin = [event.clientX, event.clientY];
        const _previousMovement = state._movement;
        state._movement = [event.scale - 1, event.rotation];
        state._delta = maths.V.sub(state._movement, _previousMovement);
        this.compute(event);
        this.emit();
      }
      gestureEnd(event) {
        if (!this.state._active)
          return;
        this.state._active = false;
        this.compute(event);
        this.emit();
      }
      wheel(event) {
        const modifierKey = this.config.modifierKey;
        if (modifierKey && (Array.isArray(modifierKey) ? !modifierKey.find((k2) => event[k2]) : !event[modifierKey]))
          return;
        if (!this.state._active)
          this.wheelStart(event);
        else
          this.wheelChange(event);
        this.timeoutStore.add("wheelEnd", this.wheelEnd.bind(this));
      }
      wheelStart(event) {
        this.start(event);
        this.wheelChange(event);
      }
      wheelChange(event) {
        const isR3f = "uv" in event;
        if (!isR3f) {
          if (event.cancelable) {
            event.preventDefault();
          }
        }
        const state = this.state;
        state._delta = [-wheelValues(event)[1] / PINCH_WHEEL_RATIO * state.offset[0], 0];
        maths.V.addTo(state._movement, state._delta);
        clampStateInternalMovementToBounds(state);
        this.state.origin = [event.clientX, event.clientY];
        this.compute(event);
        this.emit();
      }
      wheelEnd() {
        if (!this.state._active)
          return;
        this.state._active = false;
        this.compute();
        this.emit();
      }
      bind(bindFunction) {
        const device = this.config.device;
        if (!!device) {
          bindFunction(device, "start", this[device + "Start"].bind(this));
          bindFunction(device, "change", this[device + "Move"].bind(this));
          bindFunction(device, "end", this[device + "End"].bind(this));
          bindFunction(device, "cancel", this[device + "End"].bind(this));
          bindFunction("lostPointerCapture", "", this[device + "End"].bind(this));
        }
        if (this.config.pinchOnWheel) {
          bindFunction("wheel", "", this.wheel.bind(this), {
            passive: false
          });
        }
      }
    };
    var pinchConfigResolver = _objectSpread22(_objectSpread22({}, commonConfigResolver), {}, {
      device(_v, _k, {
        shared,
        pointer: {
          touch = false
        } = {}
      }) {
        const sharedConfig = shared;
        if (sharedConfig.target && !SUPPORT.touch && SUPPORT.gesture)
          return "gesture";
        if (SUPPORT.touch && touch)
          return "touch";
        if (SUPPORT.touchscreen) {
          if (SUPPORT.pointer)
            return "pointer";
          if (SUPPORT.touch)
            return "touch";
        }
      },
      bounds(_v, _k, {
        scaleBounds = {},
        angleBounds = {}
      }) {
        const _scaleBounds = (state) => {
          const D2 = assignDefault(call(scaleBounds, state), {
            min: -Infinity,
            max: Infinity
          });
          return [D2.min, D2.max];
        };
        const _angleBounds = (state) => {
          const A2 = assignDefault(call(angleBounds, state), {
            min: -Infinity,
            max: Infinity
          });
          return [A2.min, A2.max];
        };
        if (typeof scaleBounds !== "function" && typeof angleBounds !== "function")
          return [_scaleBounds(), _angleBounds()];
        return (state) => [_scaleBounds(state), _angleBounds(state)];
      },
      threshold(value, _k, config) {
        this.lockDirection = config.axis === "lock";
        const threshold = maths.V.toVector(value, this.lockDirection ? [0.1, 3] : 0);
        return threshold;
      },
      modifierKey(value) {
        if (value === void 0)
          return "ctrlKey";
        return value;
      },
      pinchOnWheel(value = true) {
        return value;
      }
    });
    var MoveEngine = class extends CoordinatesEngine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "moving");
      }
      move(event) {
        if (this.config.mouseOnly && event.pointerType !== "mouse")
          return;
        if (!this.state._active)
          this.moveStart(event);
        else
          this.moveChange(event);
        this.timeoutStore.add("moveEnd", this.moveEnd.bind(this));
      }
      moveStart(event) {
        this.start(event);
        this.computeValues(pointerValues(event));
        this.compute(event);
        this.computeInitial();
        this.emit();
      }
      moveChange(event) {
        if (!this.state._active)
          return;
        const values = pointerValues(event);
        const state = this.state;
        state._delta = maths.V.sub(values, state._values);
        maths.V.addTo(state._movement, state._delta);
        this.computeValues(values);
        this.compute(event);
        this.emit();
      }
      moveEnd(event) {
        if (!this.state._active)
          return;
        this.state._active = false;
        this.compute(event);
        this.emit();
      }
      bind(bindFunction) {
        bindFunction("pointer", "change", this.move.bind(this));
        bindFunction("pointer", "leave", this.moveEnd.bind(this));
      }
    };
    var moveConfigResolver = _objectSpread22(_objectSpread22({}, coordinatesConfigResolver), {}, {
      mouseOnly: (value = true) => value
    });
    var ScrollEngine = class extends CoordinatesEngine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "scrolling");
      }
      scroll(event) {
        if (!this.state._active)
          this.start(event);
        this.scrollChange(event);
        this.timeoutStore.add("scrollEnd", this.scrollEnd.bind(this));
      }
      scrollChange(event) {
        if (event.cancelable)
          event.preventDefault();
        const state = this.state;
        const values = scrollValues(event);
        state._delta = maths.V.sub(values, state._values);
        maths.V.addTo(state._movement, state._delta);
        this.computeValues(values);
        this.compute(event);
        this.emit();
      }
      scrollEnd() {
        if (!this.state._active)
          return;
        this.state._active = false;
        this.compute();
        this.emit();
      }
      bind(bindFunction) {
        bindFunction("scroll", "", this.scroll.bind(this));
      }
    };
    var scrollConfigResolver = coordinatesConfigResolver;
    var WheelEngine = class extends CoordinatesEngine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "wheeling");
      }
      wheel(event) {
        if (!this.state._active)
          this.start(event);
        this.wheelChange(event);
        this.timeoutStore.add("wheelEnd", this.wheelEnd.bind(this));
      }
      wheelChange(event) {
        const state = this.state;
        state._delta = wheelValues(event);
        maths.V.addTo(state._movement, state._delta);
        clampStateInternalMovementToBounds(state);
        this.compute(event);
        this.emit();
      }
      wheelEnd() {
        if (!this.state._active)
          return;
        this.state._active = false;
        this.compute();
        this.emit();
      }
      bind(bindFunction) {
        bindFunction("wheel", "", this.wheel.bind(this));
      }
    };
    var wheelConfigResolver = coordinatesConfigResolver;
    var HoverEngine = class extends CoordinatesEngine {
      constructor(...args) {
        super(...args);
        _defineProperty2(this, "ingKey", "hovering");
      }
      enter(event) {
        if (this.config.mouseOnly && event.pointerType !== "mouse")
          return;
        this.start(event);
        this.computeValues(pointerValues(event));
        this.compute(event);
        this.emit();
      }
      leave(event) {
        if (this.config.mouseOnly && event.pointerType !== "mouse")
          return;
        const state = this.state;
        if (!state._active)
          return;
        state._active = false;
        const values = pointerValues(event);
        state._movement = state._delta = maths.V.sub(values, state._values);
        this.computeValues(values);
        this.compute(event);
        state.delta = state.movement;
        this.emit();
      }
      bind(bindFunction) {
        bindFunction("pointer", "enter", this.enter.bind(this));
        bindFunction("pointer", "leave", this.leave.bind(this));
      }
    };
    var hoverConfigResolver = _objectSpread22(_objectSpread22({}, coordinatesConfigResolver), {}, {
      mouseOnly: (value = true) => value
    });
    var EngineMap = /* @__PURE__ */ new Map();
    var ConfigResolverMap = /* @__PURE__ */ new Map();
    function registerAction2(action) {
      EngineMap.set(action.key, action.engine);
      ConfigResolverMap.set(action.key, action.resolver);
    }
    var dragAction2 = {
      key: "drag",
      engine: DragEngine,
      resolver: dragConfigResolver
    };
    var hoverAction2 = {
      key: "hover",
      engine: HoverEngine,
      resolver: hoverConfigResolver
    };
    var moveAction2 = {
      key: "move",
      engine: MoveEngine,
      resolver: moveConfigResolver
    };
    var pinchAction3 = {
      key: "pinch",
      engine: PinchEngine,
      resolver: pinchConfigResolver
    };
    var scrollAction2 = {
      key: "scroll",
      engine: ScrollEngine,
      resolver: scrollConfigResolver
    };
    var wheelAction3 = {
      key: "wheel",
      engine: WheelEngine,
      resolver: wheelConfigResolver
    };
    exports.ConfigResolverMap = ConfigResolverMap;
    exports.EngineMap = EngineMap;
    exports.SUPPORT = SUPPORT;
    exports._defineProperty = _defineProperty2;
    exports._objectSpread2 = _objectSpread22;
    exports.chain = chain;
    exports.dragAction = dragAction2;
    exports.hoverAction = hoverAction2;
    exports.isTouch = isTouch;
    exports.moveAction = moveAction2;
    exports.parseProp = parseProp;
    exports.pinchAction = pinchAction3;
    exports.registerAction = registerAction2;
    exports.scrollAction = scrollAction2;
    exports.toDomEventType = toDomEventType;
    exports.toHandlerProp = toHandlerProp;
    exports.touchIds = touchIds;
    exports.wheelAction = wheelAction3;
  }
});

// node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.prod.js
var require_use_gesture_core_actions_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.prod.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var actions_dist_useGestureCoreActions = require_actions_89e642c9_cjs_prod();
    require_maths_83bc6f64_cjs_prod();
    exports.ConfigResolverMap = actions_dist_useGestureCoreActions.ConfigResolverMap;
    exports.EngineMap = actions_dist_useGestureCoreActions.EngineMap;
    exports.dragAction = actions_dist_useGestureCoreActions.dragAction;
    exports.hoverAction = actions_dist_useGestureCoreActions.hoverAction;
    exports.moveAction = actions_dist_useGestureCoreActions.moveAction;
    exports.pinchAction = actions_dist_useGestureCoreActions.pinchAction;
    exports.registerAction = actions_dist_useGestureCoreActions.registerAction;
    exports.scrollAction = actions_dist_useGestureCoreActions.scrollAction;
    exports.wheelAction = actions_dist_useGestureCoreActions.wheelAction;
  }
});

// node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.js
var require_use_gesture_core_actions_cjs = __commonJS({
  "node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_use_gesture_core_actions_cjs_prod();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/@use-gesture/core/dist/use-gesture-core.cjs.prod.js
var require_use_gesture_core_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/dist/use-gesture-core.cjs.prod.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var actions_dist_useGestureCoreActions = require_actions_89e642c9_cjs_prod();
    require_maths_83bc6f64_cjs_prod();
    function _objectWithoutPropertiesLoose3(source, excluded) {
      if (source == null)
        return {};
      var target = {};
      var sourceKeys = Object.keys(source);
      var key, i2;
      for (i2 = 0; i2 < sourceKeys.length; i2++) {
        key = sourceKeys[i2];
        if (excluded.indexOf(key) >= 0)
          continue;
        target[key] = source[key];
      }
      return target;
    }
    function _objectWithoutProperties2(source, excluded) {
      if (source == null)
        return {};
      var target = _objectWithoutPropertiesLoose3(source, excluded);
      var key, i2;
      if (Object.getOwnPropertySymbols) {
        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
        for (i2 = 0; i2 < sourceSymbolKeys.length; i2++) {
          key = sourceSymbolKeys[i2];
          if (excluded.indexOf(key) >= 0)
            continue;
          if (!Object.prototype.propertyIsEnumerable.call(source, key))
            continue;
          target[key] = source[key];
        }
      }
      return target;
    }
    var sharedConfigResolver = {
      target(value) {
        if (value) {
          return () => "current" in value ? value.current : value;
        }
        return void 0;
      },
      enabled(value = true) {
        return value;
      },
      window(value = actions_dist_useGestureCoreActions.SUPPORT.isBrowser ? window : void 0) {
        return value;
      },
      eventOptions({
        passive: passive2 = true,
        capture = false
      } = {}) {
        return {
          passive: passive2,
          capture
        };
      },
      transform(value) {
        return value;
      }
    };
    var _excluded2 = ["target", "eventOptions", "window", "enabled", "transform"];
    function resolveWith(config = {}, resolvers) {
      const result = {};
      for (const [key, resolver] of Object.entries(resolvers)) {
        switch (typeof resolver) {
          case "function":
            {
              result[key] = resolver.call(result, config[key], key, config);
            }
            break;
          case "object":
            result[key] = resolveWith(config[key], resolver);
            break;
          case "boolean":
            if (resolver)
              result[key] = config[key];
            break;
        }
      }
      return result;
    }
    function parse2(newConfig, gestureKey, _config = {}) {
      const _ref = newConfig, {
        target,
        eventOptions,
        window: window3,
        enabled,
        transform
      } = _ref, rest = _objectWithoutProperties2(_ref, _excluded2);
      _config.shared = resolveWith({
        target,
        eventOptions,
        window: window3,
        enabled,
        transform
      }, sharedConfigResolver);
      if (gestureKey) {
        const resolver = actions_dist_useGestureCoreActions.ConfigResolverMap.get(gestureKey);
        _config[gestureKey] = resolveWith(actions_dist_useGestureCoreActions._objectSpread2({
          shared: _config.shared
        }, rest), resolver);
      } else {
        for (const key in rest) {
          const resolver = actions_dist_useGestureCoreActions.ConfigResolverMap.get(key);
          if (resolver) {
            _config[key] = resolveWith(actions_dist_useGestureCoreActions._objectSpread2({
              shared: _config.shared
            }, rest[key]), resolver);
          }
        }
      }
      return _config;
    }
    var EventStore = class {
      constructor(ctrl, gestureKey) {
        actions_dist_useGestureCoreActions._defineProperty(this, "_listeners", /* @__PURE__ */ new Set());
        this._ctrl = ctrl;
        this._gestureKey = gestureKey;
      }
      add(element, device, action, handler, options) {
        const listeners = this._listeners;
        const type = actions_dist_useGestureCoreActions.toDomEventType(device, action);
        const _options = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {};
        const eventOptions = actions_dist_useGestureCoreActions._objectSpread2(actions_dist_useGestureCoreActions._objectSpread2({}, _options), options);
        element.addEventListener(type, handler, eventOptions);
        const remove2 = () => {
          element.removeEventListener(type, handler, eventOptions);
          listeners.delete(remove2);
        };
        listeners.add(remove2);
        return remove2;
      }
      clean() {
        this._listeners.forEach((remove2) => remove2());
        this._listeners.clear();
      }
    };
    var TimeoutStore = class {
      constructor() {
        actions_dist_useGestureCoreActions._defineProperty(this, "_timeouts", /* @__PURE__ */ new Map());
      }
      add(key, callback, ms = 140, ...args) {
        this.remove(key);
        this._timeouts.set(key, window.setTimeout(callback, ms, ...args));
      }
      remove(key) {
        const timeout = this._timeouts.get(key);
        if (timeout)
          window.clearTimeout(timeout);
      }
      clean() {
        this._timeouts.forEach((timeout) => void window.clearTimeout(timeout));
        this._timeouts.clear();
      }
    };
    var Controller2 = class {
      constructor(handlers) {
        actions_dist_useGestureCoreActions._defineProperty(this, "gestures", /* @__PURE__ */ new Set());
        actions_dist_useGestureCoreActions._defineProperty(this, "_targetEventStore", new EventStore(this));
        actions_dist_useGestureCoreActions._defineProperty(this, "gestureEventStores", {});
        actions_dist_useGestureCoreActions._defineProperty(this, "gestureTimeoutStores", {});
        actions_dist_useGestureCoreActions._defineProperty(this, "handlers", {});
        actions_dist_useGestureCoreActions._defineProperty(this, "config", {});
        actions_dist_useGestureCoreActions._defineProperty(this, "pointerIds", /* @__PURE__ */ new Set());
        actions_dist_useGestureCoreActions._defineProperty(this, "touchIds", /* @__PURE__ */ new Set());
        actions_dist_useGestureCoreActions._defineProperty(this, "state", {
          shared: {
            shiftKey: false,
            metaKey: false,
            ctrlKey: false,
            altKey: false
          }
        });
        resolveGestures(this, handlers);
      }
      setEventIds(event) {
        if (actions_dist_useGestureCoreActions.isTouch(event)) {
          this.touchIds = new Set(actions_dist_useGestureCoreActions.touchIds(event));
          return this.touchIds;
        } else if ("pointerId" in event) {
          if (event.type === "pointerup" || event.type === "pointercancel")
            this.pointerIds.delete(event.pointerId);
          else if (event.type === "pointerdown")
            this.pointerIds.add(event.pointerId);
          return this.pointerIds;
        }
      }
      applyHandlers(handlers, nativeHandlers) {
        this.handlers = handlers;
        this.nativeHandlers = nativeHandlers;
      }
      applyConfig(config, gestureKey) {
        this.config = parse2(config, gestureKey, this.config);
      }
      clean() {
        this._targetEventStore.clean();
        for (const key of this.gestures) {
          this.gestureEventStores[key].clean();
          this.gestureTimeoutStores[key].clean();
        }
      }
      effect() {
        if (this.config.shared.target)
          this.bind();
        return () => this._targetEventStore.clean();
      }
      bind(...args) {
        const sharedConfig = this.config.shared;
        const props = {};
        let target;
        if (sharedConfig.target) {
          target = sharedConfig.target();
          if (!target)
            return;
        }
        if (sharedConfig.enabled) {
          for (const gestureKey of this.gestures) {
            const gestureConfig = this.config[gestureKey];
            const bindFunction = bindToProps(props, gestureConfig.eventOptions, !!target);
            if (gestureConfig.enabled) {
              const Engine = actions_dist_useGestureCoreActions.EngineMap.get(gestureKey);
              new Engine(this, args, gestureKey).bind(bindFunction);
            }
          }
          const nativeBindFunction = bindToProps(props, sharedConfig.eventOptions, !!target);
          for (const eventKey in this.nativeHandlers) {
            nativeBindFunction(eventKey, "", (event) => this.nativeHandlers[eventKey](actions_dist_useGestureCoreActions._objectSpread2(actions_dist_useGestureCoreActions._objectSpread2({}, this.state.shared), {}, {
              event,
              args
            })), void 0, true);
          }
        }
        for (const handlerProp in props) {
          props[handlerProp] = actions_dist_useGestureCoreActions.chain(...props[handlerProp]);
        }
        if (!target)
          return props;
        for (const handlerProp in props) {
          const {
            device,
            capture,
            passive: passive2
          } = actions_dist_useGestureCoreActions.parseProp(handlerProp);
          this._targetEventStore.add(target, device, "", props[handlerProp], {
            capture,
            passive: passive2
          });
        }
      }
    };
    function setupGesture(ctrl, gestureKey) {
      ctrl.gestures.add(gestureKey);
      ctrl.gestureEventStores[gestureKey] = new EventStore(ctrl, gestureKey);
      ctrl.gestureTimeoutStores[gestureKey] = new TimeoutStore();
    }
    function resolveGestures(ctrl, internalHandlers) {
      if (internalHandlers.drag)
        setupGesture(ctrl, "drag");
      if (internalHandlers.wheel)
        setupGesture(ctrl, "wheel");
      if (internalHandlers.scroll)
        setupGesture(ctrl, "scroll");
      if (internalHandlers.move)
        setupGesture(ctrl, "move");
      if (internalHandlers.pinch)
        setupGesture(ctrl, "pinch");
      if (internalHandlers.hover)
        setupGesture(ctrl, "hover");
    }
    var bindToProps = (props, eventOptions, withPassiveOption) => (device, action, handler, options = {}, isNative = false) => {
      var _options$capture, _options$passive;
      const capture = (_options$capture = options.capture) !== null && _options$capture !== void 0 ? _options$capture : eventOptions.capture;
      const passive2 = (_options$passive = options.passive) !== null && _options$passive !== void 0 ? _options$passive : eventOptions.passive;
      let handlerProp = isNative ? device : actions_dist_useGestureCoreActions.toHandlerProp(device, action, capture);
      if (withPassiveOption && passive2)
        handlerProp += "Passive";
      props[handlerProp] = props[handlerProp] || [];
      props[handlerProp].push(handler);
    };
    var RE_NOT_NATIVE = /^on(Drag|Wheel|Scroll|Move|Pinch|Hover)/;
    function sortHandlers(_handlers2) {
      const native = {};
      const handlers = {};
      const actions = /* @__PURE__ */ new Set();
      for (let key in _handlers2) {
        if (RE_NOT_NATIVE.test(key)) {
          actions.add(RegExp.lastMatch);
          handlers[key] = _handlers2[key];
        } else {
          native[key] = _handlers2[key];
        }
      }
      return [handlers, native, actions];
    }
    function registerGesture(actions, handlers, handlerKey, key, internalHandlers, config) {
      if (!actions.has(handlerKey))
        return;
      if (!actions_dist_useGestureCoreActions.EngineMap.has(key)) {
        return;
      }
      const startKey = handlerKey + "Start";
      const endKey = handlerKey + "End";
      const fn3 = (state) => {
        let memo29 = void 0;
        if (state.first && startKey in handlers)
          handlers[startKey](state);
        if (handlerKey in handlers)
          memo29 = handlers[handlerKey](state);
        if (state.last && endKey in handlers)
          handlers[endKey](state);
        return memo29;
      };
      internalHandlers[key] = fn3;
      config[key] = config[key] || {};
    }
    function parseMergedHandlers2(mergedHandlers, mergedConfig) {
      const [handlers, nativeHandlers, actions] = sortHandlers(mergedHandlers);
      const internalHandlers = {};
      registerGesture(actions, handlers, "onDrag", "drag", internalHandlers, mergedConfig);
      registerGesture(actions, handlers, "onWheel", "wheel", internalHandlers, mergedConfig);
      registerGesture(actions, handlers, "onScroll", "scroll", internalHandlers, mergedConfig);
      registerGesture(actions, handlers, "onPinch", "pinch", internalHandlers, mergedConfig);
      registerGesture(actions, handlers, "onMove", "move", internalHandlers, mergedConfig);
      registerGesture(actions, handlers, "onHover", "hover", internalHandlers, mergedConfig);
      return {
        handlers: internalHandlers,
        config: mergedConfig,
        nativeHandlers
      };
    }
    exports.Controller = Controller2;
    exports.parseMergedHandlers = parseMergedHandlers2;
  }
});

// node_modules/@use-gesture/core/dist/use-gesture-core.cjs.js
var require_use_gesture_core_cjs = __commonJS({
  "node_modules/@use-gesture/core/dist/use-gesture-core.cjs.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_use_gesture_core_cjs_prod();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.prod.js
var require_use_gesture_core_utils_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.prod.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var maths = require_maths_83bc6f64_cjs_prod();
    exports.rubberbandIfOutOfBounds = maths.rubberbandIfOutOfBounds;
  }
});

// node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.js
var require_use_gesture_core_utils_cjs = __commonJS({
  "node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_use_gesture_core_utils_cjs_prod();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.prod.js
var require_use_gesture_core_types_cjs_prod = __commonJS({
  "node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.prod.js"() {
    "use strict";
  }
});

// node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.js
var require_use_gesture_core_types_cjs = __commonJS({
  "node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.js"(exports, module2) {
    "use strict";
    if (true) {
      module2.exports = require_use_gesture_core_types_cjs_prod();
    } else {
      module2.exports = null;
    }
  }
});

// node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
var use_gesture_react_esm_exports = {};
__export(use_gesture_react_esm_exports, {
  createUseGesture: () => createUseGesture,
  useDrag: () => useDrag,
  useGesture: () => useGesture,
  useHover: () => useHover,
  useMove: () => useMove,
  usePinch: () => usePinch,
  useScroll: () => useScroll,
  useWheel: () => useWheel
});
function useRecognizers(handlers, config = {}, gestureKey, nativeHandlers) {
  const ctrl = import_react17.default.useMemo(() => new import_core.Controller(handlers), []);
  ctrl.applyHandlers(handlers, nativeHandlers);
  ctrl.applyConfig(config, gestureKey);
  import_react17.default.useEffect(ctrl.effect.bind(ctrl));
  import_react17.default.useEffect(() => {
    return ctrl.clean.bind(ctrl);
  }, []);
  if (config.target === void 0) {
    return ctrl.bind.bind(ctrl);
  }
  return void 0;
}
function useDrag(handler, config) {
  (0, import_actions.registerAction)(import_actions.dragAction);
  return useRecognizers({
    drag: handler
  }, config || {}, "drag");
}
function usePinch(handler, config) {
  (0, import_actions.registerAction)(import_actions.pinchAction);
  return useRecognizers({
    pinch: handler
  }, config || {}, "pinch");
}
function useWheel(handler, config) {
  (0, import_actions.registerAction)(import_actions.wheelAction);
  return useRecognizers({
    wheel: handler
  }, config || {}, "wheel");
}
function useScroll(handler, config) {
  (0, import_actions.registerAction)(import_actions.scrollAction);
  return useRecognizers({
    scroll: handler
  }, config || {}, "scroll");
}
function useMove(handler, config) {
  (0, import_actions.registerAction)(import_actions.moveAction);
  return useRecognizers({
    move: handler
  }, config || {}, "move");
}
function useHover(handler, config) {
  (0, import_actions.registerAction)(import_actions.hoverAction);
  return useRecognizers({
    hover: handler
  }, config || {}, "hover");
}
function createUseGesture(actions) {
  actions.forEach(import_actions.registerAction);
  return function useGesture3(_handlers2, _config) {
    const {
      handlers,
      nativeHandlers,
      config
    } = (0, import_core.parseMergedHandlers)(_handlers2, _config || {});
    return useRecognizers(handlers, config, void 0, nativeHandlers);
  };
}
function useGesture(handlers, config) {
  const hook = createUseGesture([import_actions.dragAction, import_actions.pinchAction, import_actions.scrollAction, import_actions.wheelAction, import_actions.moveAction, import_actions.hoverAction]);
  return hook(handlers, config || {});
}
var import_actions, import_react17, import_core;
var init_use_gesture_react_esm = __esm({
  "node_modules/@use-gesture/react/dist/use-gesture-react.esm.js"() {
    import_actions = __toESM(require_use_gesture_core_actions_cjs());
    __reExport(use_gesture_react_esm_exports, __toESM(require_use_gesture_core_actions_cjs()));
    import_react17 = __toESM(require_react());
    import_core = __toESM(require_use_gesture_core_cjs());
    __reExport(use_gesture_react_esm_exports, __toESM(require_use_gesture_core_utils_cjs()));
    __reExport(use_gesture_react_esm_exports, __toESM(require_use_gesture_core_types_cjs()));
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/normalizeWheel.mjs
function normalizeWheel(event) {
  let { deltaY, deltaX } = event;
  let deltaZ = 0;
  if (event.ctrlKey || event.altKey || event.metaKey) {
    deltaZ = (Math.abs(deltaY) > MAX_ZOOM_STEP ? MAX_ZOOM_STEP * Math.sign(deltaY) : deltaY) / 100;
  } else {
    if (event.shiftKey && !IS_DARWIN) {
      deltaX = deltaY;
      deltaY = 0;
    }
  }
  return { x: -deltaX, y: -deltaY, z: -deltaZ };
}
var MAX_ZOOM_STEP, IS_DARWIN;
var init_normalizeWheel = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/normalizeWheel.mjs"() {
    MAX_ZOOM_STEP = 10;
    IS_DARWIN = /Mac|iPod|iPhone|iPad/.test(typeof window === "undefined" ? "node" : window.navigator.platform);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useGestureEvents.mjs
function useGestureEvents(ref) {
  const editor = useEditor();
  const events = React5.useMemo(() => {
    let pinchState = "not sure";
    const onWheel = ({ event }) => {
      if (!editor.getInstanceState().isFocused) {
        return;
      }
      pinchState = "not sure";
      if (isWheelEndEvent(Date.now())) {
        return;
      }
      const editingShapeId = editor.getEditingShapeId();
      if (editingShapeId) {
        const shape = editor.getShape(editingShapeId);
        if (shape) {
          const util = editor.getShapeUtil(shape);
          if (util.canScroll(shape)) {
            const bounds = editor.getShapePageBounds(editingShapeId);
            if (bounds?.containsPoint(editor.inputs.currentPagePoint)) {
              return;
            }
          }
        }
      }
      preventDefault(event);
      stopEventPropagation(event);
      const delta = normalizeWheel(event);
      if (delta.x === 0 && delta.y === 0)
        return;
      const info2 = {
        type: "wheel",
        name: "wheel",
        delta,
        point: new Vec(event.clientX, event.clientY),
        shiftKey: event.shiftKey,
        altKey: event.altKey,
        ctrlKey: event.metaKey || event.ctrlKey
      };
      editor.dispatch(info2);
    };
    let initDistanceBetweenFingers = 1;
    let initZoom = 1;
    let currZoom = 1;
    let currDistanceBetweenFingers = 0;
    const initPointBetweenFingers = new Vec();
    const prevPointBetweenFingers = new Vec();
    const onPinchStart = (gesture) => {
      const elm = ref.current;
      pinchState = "not sure";
      const { event, origin, da } = gesture;
      if (event instanceof WheelEvent)
        return;
      if (!(event.target === elm || elm?.contains(event.target)))
        return;
      prevPointBetweenFingers.x = origin[0];
      prevPointBetweenFingers.y = origin[1];
      initPointBetweenFingers.x = origin[0];
      initPointBetweenFingers.y = origin[1];
      initDistanceBetweenFingers = da[0];
      initZoom = editor.getZoomLevel();
      editor.dispatch({
        type: "pinch",
        name: "pinch_start",
        point: { x: origin[0], y: origin[1], z: editor.getZoomLevel() },
        delta: { x: 0, y: 0 },
        shiftKey: event.shiftKey,
        altKey: event.altKey,
        ctrlKey: event.metaKey || event.ctrlKey
      });
    };
    const updatePinchState = (isSafariTrackpadPinch) => {
      if (isSafariTrackpadPinch) {
        pinchState = "zooming";
      }
      if (pinchState === "zooming") {
        return;
      }
      const touchDistance = Math.abs(currDistanceBetweenFingers - initDistanceBetweenFingers);
      const originDistance = Vec.Dist(initPointBetweenFingers, prevPointBetweenFingers);
      switch (pinchState) {
        case "not sure": {
          if (touchDistance > 24) {
            pinchState = "zooming";
          } else if (originDistance > 16) {
            pinchState = "panning";
          }
          break;
        }
        case "panning": {
          if (touchDistance > 64) {
            pinchState = "zooming";
          }
          break;
        }
      }
    };
    const onPinch = (gesture) => {
      const elm = ref.current;
      const { event, origin, offset: offset5, da } = gesture;
      if (event instanceof WheelEvent)
        return;
      if (!(event.target === elm || elm?.contains(event.target)))
        return;
      const isSafariTrackpadPinch = gesture.type === "gesturechange" || gesture.type === "gestureend";
      currDistanceBetweenFingers = da[0];
      const dx = origin[0] - prevPointBetweenFingers.x;
      const dy = origin[1] - prevPointBetweenFingers.y;
      prevPointBetweenFingers.x = origin[0];
      prevPointBetweenFingers.y = origin[1];
      updatePinchState(isSafariTrackpadPinch);
      switch (pinchState) {
        case "zooming": {
          currZoom = offset5[0];
          editor.dispatch({
            type: "pinch",
            name: "pinch",
            point: { x: origin[0], y: origin[1], z: currZoom },
            delta: { x: dx, y: dy },
            shiftKey: event.shiftKey,
            altKey: event.altKey,
            ctrlKey: event.metaKey || event.ctrlKey
          });
          break;
        }
        case "panning": {
          editor.dispatch({
            type: "pinch",
            name: "pinch",
            point: { x: origin[0], y: origin[1], z: initZoom },
            delta: { x: dx, y: dy },
            shiftKey: event.shiftKey,
            altKey: event.altKey,
            ctrlKey: event.metaKey || event.ctrlKey
          });
          break;
        }
      }
    };
    const onPinchEnd = (gesture) => {
      const elm = ref.current;
      const { event, origin, offset: offset5 } = gesture;
      if (event instanceof WheelEvent)
        return;
      if (!(event.target === elm || elm?.contains(event.target)))
        return;
      const scale = offset5[0];
      pinchState = "not sure";
      editor.timers.requestAnimationFrame(() => {
        editor.dispatch({
          type: "pinch",
          name: "pinch_end",
          point: { x: origin[0], y: origin[1], z: scale },
          delta: { x: origin[0], y: origin[1] },
          shiftKey: event.shiftKey,
          altKey: event.altKey,
          ctrlKey: event.metaKey || event.ctrlKey
        });
      });
    };
    return {
      onWheel,
      onPinchStart,
      onPinchEnd,
      onPinch
    };
  }, [editor, ref]);
  useGesture2(events, {
    target: ref,
    eventOptions: { passive: false },
    pinch: {
      from: () => [editor.getZoomLevel(), 0],
      scaleBounds: () => {
        return { from: editor.getZoomLevel(), max: 8, min: 0.05 };
      }
    }
  });
}
var React5, useGesture2, lastWheelTime, isWheelEndEvent;
var init_useGestureEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useGestureEvents.mjs"() {
    init_use_gesture_react_esm();
    React5 = __toESM(require_react(), 1);
    init_Vec();
    init_dom();
    init_normalizeWheel();
    init_useEditor();
    useGesture2 = createUseGesture([use_gesture_react_esm_exports.wheelAction, use_gesture_react_esm_exports.pinchAction]);
    lastWheelTime = void 0;
    isWheelEndEvent = (time3) => {
      if (lastWheelTime === void 0) {
        lastWheelTime = time3;
        return false;
      }
      if (time3 - lastWheelTime > 120 && time3 - lastWheelTime < 160) {
        lastWheelTime = time3;
        return true;
      }
      lastWheelTime = time3;
      return false;
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useHandleEvents.mjs
function getHandle(editor, id, handleId) {
  const shape = editor.getShape(id);
  const handles = editor.getShapeHandles(shape);
  return { shape, handle: handles.find((h2) => h2.id === handleId) };
}
function useHandleEvents(id, handleId) {
  const editor = useEditor();
  return React6.useMemo(() => {
    const onPointerDown = (e2) => {
      if (e2.isKilled)
        return;
      const target = loopToHtmlElement(e2.currentTarget);
      setPointerCapture(target, e2);
      const { shape, handle } = getHandle(editor, id, handleId);
      if (!handle)
        return;
      editor.dispatch({
        type: "pointer",
        target: "handle",
        handle,
        shape,
        name: "pointer_down",
        ...getPointerInfo(e2)
      });
    };
    let lastX, lastY;
    const onPointerMove = (e2) => {
      if (e2.isKilled)
        return;
      if (e2.clientX === lastX && e2.clientY === lastY)
        return;
      lastX = e2.clientX;
      lastY = e2.clientY;
      const { shape, handle } = getHandle(editor, id, handleId);
      if (!handle)
        return;
      editor.dispatch({
        type: "pointer",
        target: "handle",
        handle,
        shape,
        name: "pointer_move",
        ...getPointerInfo(e2)
      });
    };
    const onPointerUp = (e2) => {
      if (e2.isKilled)
        return;
      const target = loopToHtmlElement(e2.currentTarget);
      releasePointerCapture(target, e2);
      const { shape, handle } = getHandle(editor, id, handleId);
      if (!handle)
        return;
      editor.dispatch({
        type: "pointer",
        target: "handle",
        handle,
        shape,
        name: "pointer_up",
        ...getPointerInfo(e2)
      });
    };
    return {
      onPointerDown,
      onPointerMove,
      onPointerUp
    };
  }, [editor, id, handleId]);
}
var React6;
var init_useHandleEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useHandleEvents.mjs"() {
    React6 = __toESM(require_react(), 1);
    init_dom();
    init_getPointerInfo();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/Box.mjs
function flipSelectionHandleY(handle) {
  switch (handle) {
    case "top":
      return "bottom";
    case "bottom":
      return "top";
    case "top_left":
      return "bottom_left";
    case "top_right":
      return "bottom_right";
    case "bottom_left":
      return "top_left";
    case "bottom_right":
      return "top_right";
    default:
      return handle;
  }
}
function flipSelectionHandleX(handle) {
  switch (handle) {
    case "left":
      return "right";
    case "right":
      return "left";
    case "top_left":
      return "top_right";
    case "top_right":
      return "top_left";
    case "bottom_left":
      return "bottom_right";
    case "bottom_right":
      return "bottom_left";
    default:
      return handle;
  }
}
function isSelectionCorner(selection) {
  return selection === "top_left" || selection === "top_right" || selection === "bottom_right" || selection === "bottom_left";
}
var _Box, Box;
var init_Box = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/Box.mjs"() {
    init_Vec();
    init_utils();
    _Box = class {
      constructor(x2 = 0, y2 = 0, w2 = 0, h2 = 0) {
        __publicField(this, "x", 0);
        __publicField(this, "y", 0);
        __publicField(this, "w", 0);
        __publicField(this, "h", 0);
        this.x = x2;
        this.y = y2;
        this.w = w2;
        this.h = h2;
      }
      get point() {
        return new Vec(this.x, this.y);
      }
      set point(val) {
        this.x = val.x;
        this.y = val.y;
      }
      get minX() {
        return this.x;
      }
      set minX(n2) {
        this.x = n2;
      }
      get midX() {
        return this.x + this.w / 2;
      }
      get maxX() {
        return this.x + this.w;
      }
      get minY() {
        return this.y;
      }
      set minY(n2) {
        this.y = n2;
      }
      get midY() {
        return this.y + this.h / 2;
      }
      get maxY() {
        return this.y + this.h;
      }
      get width() {
        return this.w;
      }
      set width(n2) {
        this.w = n2;
      }
      get height() {
        return this.h;
      }
      set height(n2) {
        this.h = n2;
      }
      get aspectRatio() {
        return this.width / this.height;
      }
      get center() {
        return new Vec(this.midX, this.midY);
      }
      set center(v2) {
        this.minX = v2.x - this.width / 2;
        this.minY = v2.y - this.height / 2;
      }
      get corners() {
        return [
          new Vec(this.minX, this.minY),
          new Vec(this.maxX, this.minY),
          new Vec(this.maxX, this.maxY),
          new Vec(this.minX, this.maxY)
        ];
      }
      get cornersAndCenter() {
        return [
          new Vec(this.minX, this.minY),
          new Vec(this.maxX, this.minY),
          new Vec(this.maxX, this.maxY),
          new Vec(this.minX, this.maxY),
          this.center
        ];
      }
      get sides() {
        const { corners } = this;
        return [
          [corners[0], corners[1]],
          [corners[1], corners[2]],
          [corners[2], corners[3]],
          [corners[3], corners[0]]
        ];
      }
      get size() {
        return new Vec(this.w, this.h);
      }
      toFixed() {
        this.x = toPrecision(this.x);
        this.y = toPrecision(this.y);
        this.w = toPrecision(this.w);
        this.h = toPrecision(this.h);
        return this;
      }
      setTo(B) {
        this.x = B.x;
        this.y = B.y;
        this.w = B.w;
        this.h = B.h;
        return this;
      }
      set(x2 = 0, y2 = 0, w2 = 0, h2 = 0) {
        this.x = x2;
        this.y = y2;
        this.w = w2;
        this.h = h2;
        return this;
      }
      expand(A2) {
        const minX = Math.min(this.minX, A2.minX);
        const minY = Math.min(this.minY, A2.minY);
        const maxX = Math.max(this.maxX, A2.maxX);
        const maxY = Math.max(this.maxY, A2.maxY);
        this.x = minX;
        this.y = minY;
        this.w = maxX - minX;
        this.h = maxY - minY;
        return this;
      }
      expandBy(n2) {
        this.x -= n2;
        this.y -= n2;
        this.w += n2 * 2;
        this.h += n2 * 2;
        return this;
      }
      scale(n2) {
        this.x /= n2;
        this.y /= n2;
        this.w /= n2;
        this.h /= n2;
        return this;
      }
      clone() {
        const { x: x2, y: y2, w: w2, h: h2 } = this;
        return new _Box(x2, y2, w2, h2);
      }
      translate(delta) {
        this.x += delta.x;
        this.y += delta.y;
        return this;
      }
      snapToGrid(size4) {
        const minX = Math.round(this.minX / size4) * size4;
        const minY = Math.round(this.minY / size4) * size4;
        const maxX = Math.round(this.maxX / size4) * size4;
        const maxY = Math.round(this.maxY / size4) * size4;
        this.minX = minX;
        this.minY = minY;
        this.width = Math.max(1, maxX - minX);
        this.height = Math.max(1, maxY - minY);
      }
      collides(B) {
        return _Box.Collides(this, B);
      }
      contains(B) {
        return _Box.Contains(this, B);
      }
      includes(B) {
        return _Box.Includes(this, B);
      }
      containsPoint(V, margin = 0) {
        return _Box.ContainsPoint(this, V, margin);
      }
      getHandlePoint(handle) {
        switch (handle) {
          case "top_left":
            return new Vec(this.minX, this.minY);
          case "top_right":
            return new Vec(this.maxX, this.minY);
          case "bottom_left":
            return new Vec(this.minX, this.maxY);
          case "bottom_right":
            return new Vec(this.maxX, this.maxY);
          case "top":
            return new Vec(this.midX, this.minY);
          case "right":
            return new Vec(this.maxX, this.midY);
          case "bottom":
            return new Vec(this.midX, this.maxY);
          case "left":
            return new Vec(this.minX, this.midY);
        }
      }
      toJson() {
        return { x: this.minX, y: this.minY, w: this.w, h: this.h };
      }
      resize(handle, dx, dy) {
        const { minX: a0x, minY: a0y, maxX: a1x, maxY: a1y } = this;
        let { minX: b0x, minY: b0y, maxX: b1x, maxY: b1y } = this;
        switch (handle) {
          case "left":
          case "top_left":
          case "bottom_left": {
            b0x += dx;
            break;
          }
          case "right":
          case "top_right":
          case "bottom_right": {
            b1x += dx;
            break;
          }
        }
        switch (handle) {
          case "top":
          case "top_left":
          case "top_right": {
            b0y += dy;
            break;
          }
          case "bottom":
          case "bottom_left":
          case "bottom_right": {
            b1y += dy;
            break;
          }
        }
        const scaleX = (b1x - b0x) / (a1x - a0x);
        const scaleY = (b1y - b0y) / (a1y - a0y);
        const flipX = scaleX < 0;
        const flipY = scaleY < 0;
        if (flipX) {
          const t3 = b1x;
          b1x = b0x;
          b0x = t3;
        }
        if (flipY) {
          const t3 = b1y;
          b1y = b0y;
          b0y = t3;
        }
        this.minX = b0x;
        this.minY = b0y;
        this.width = Math.abs(b1x - b0x);
        this.height = Math.abs(b1y - b0y);
      }
      union(box) {
        const minX = Math.min(this.minX, box.x);
        const minY = Math.min(this.minY, box.y);
        const maxX = Math.max(this.maxX, box.w + box.x);
        const maxY = Math.max(this.maxY, box.h + box.y);
        this.x = minX;
        this.y = minY;
        this.width = maxX - minX;
        this.height = maxY - minY;
        return this;
      }
      static From(box) {
        return new _Box(box.x, box.y, box.w, box.h);
      }
      static FromCenter(center, size4) {
        return new _Box(center.x - size4.x / 2, center.y - size4.y / 2, size4.x, size4.y);
      }
      static FromPoints(points) {
        if (points.length === 0)
          return new _Box();
        let minX = Infinity;
        let minY = Infinity;
        let maxX = -Infinity;
        let maxY = -Infinity;
        let point;
        for (let i2 = 0, n2 = points.length; i2 < n2; i2++) {
          point = points[i2];
          minX = Math.min(point.x, minX);
          minY = Math.min(point.y, minY);
          maxX = Math.max(point.x, maxX);
          maxY = Math.max(point.y, maxY);
        }
        return new _Box(minX, minY, maxX - minX, maxY - minY);
      }
      static Expand(A2, B) {
        const minX = Math.min(B.minX, A2.minX);
        const minY = Math.min(B.minY, A2.minY);
        const maxX = Math.max(B.maxX, A2.maxX);
        const maxY = Math.max(B.maxY, A2.maxY);
        return new _Box(minX, minY, maxX - minX, maxY - minY);
      }
      static ExpandBy(A2, n2) {
        return new _Box(A2.minX - n2, A2.minY - n2, A2.width + n2 * 2, A2.height + n2 * 2);
      }
      static Resize(box, handle, dx, dy, isAspectRatioLocked = false) {
        const { minX: a0x, minY: a0y, maxX: a1x, maxY: a1y } = box;
        let { minX: b0x, minY: b0y, maxX: b1x, maxY: b1y } = box;
        switch (handle) {
          case "left":
          case "top_left":
          case "bottom_left": {
            b0x += dx;
            break;
          }
          case "right":
          case "top_right":
          case "bottom_right": {
            b1x += dx;
            break;
          }
        }
        switch (handle) {
          case "top":
          case "top_left":
          case "top_right": {
            b0y += dy;
            break;
          }
          case "bottom":
          case "bottom_left":
          case "bottom_right": {
            b1y += dy;
            break;
          }
        }
        const scaleX = (b1x - b0x) / (a1x - a0x);
        const scaleY = (b1y - b0y) / (a1y - a0y);
        const flipX = scaleX < 0;
        const flipY = scaleY < 0;
        if (isAspectRatioLocked) {
          const aspectRatio = (a1x - a0x) / (a1y - a0y);
          const bw = Math.abs(b1x - b0x);
          const bh = Math.abs(b1y - b0y);
          const tw = bw * (scaleY < 0 ? 1 : -1) * (1 / aspectRatio);
          const th = bh * (scaleX < 0 ? 1 : -1) * aspectRatio;
          const isTall = aspectRatio < bw / bh;
          switch (handle) {
            case "top_left": {
              if (isTall)
                b0y = b1y + tw;
              else
                b0x = b1x + th;
              break;
            }
            case "top_right": {
              if (isTall)
                b0y = b1y + tw;
              else
                b1x = b0x - th;
              break;
            }
            case "bottom_right": {
              if (isTall)
                b1y = b0y - tw;
              else
                b1x = b0x - th;
              break;
            }
            case "bottom_left": {
              if (isTall)
                b1y = b0y - tw;
              else
                b0x = b1x + th;
              break;
            }
            case "bottom":
            case "top": {
              const m2 = (b0x + b1x) / 2;
              const w2 = bh * aspectRatio;
              b0x = m2 - w2 / 2;
              b1x = m2 + w2 / 2;
              break;
            }
            case "left":
            case "right": {
              const m2 = (b0y + b1y) / 2;
              const h2 = bw / aspectRatio;
              b0y = m2 - h2 / 2;
              b1y = m2 + h2 / 2;
              break;
            }
          }
        }
        if (flipX) {
          const t3 = b1x;
          b1x = b0x;
          b0x = t3;
        }
        if (flipY) {
          const t3 = b1y;
          b1y = b0y;
          b0y = t3;
        }
        const final = new _Box(b0x, b0y, Math.abs(b1x - b0x), Math.abs(b1y - b0y));
        return {
          box: final,
          scaleX: +(final.width / box.width * (scaleX > 0 ? 1 : -1)).toFixed(5),
          scaleY: +(final.height / box.height * (scaleY > 0 ? 1 : -1)).toFixed(5)
        };
      }
      equals(other) {
        return _Box.Equals(this, other);
      }
      static Equals(a2, b2) {
        return b2.x === a2.x && b2.y === a2.y && b2.w === a2.w && b2.h === a2.h;
      }
      zeroFix() {
        this.w = Math.max(1, this.w);
        this.h = Math.max(1, this.h);
        return this;
      }
      static ZeroFix(other) {
        return new _Box(other.x, other.y, Math.max(1, other.w), Math.max(1, other.h));
      }
    };
    Box = _Box;
    __publicField(Box, "Collides", (A2, B) => {
      return !(A2.maxX < B.minX || A2.minX > B.maxX || A2.maxY < B.minY || A2.minY > B.maxY);
    });
    __publicField(Box, "Contains", (A2, B) => {
      return A2.minX < B.minX && A2.minY < B.minY && A2.maxY > B.maxY && A2.maxX > B.maxX;
    });
    __publicField(Box, "Includes", (A2, B) => {
      return _Box.Collides(A2, B) || _Box.Contains(A2, B);
    });
    __publicField(Box, "ContainsPoint", (A2, B, margin = 0) => {
      return !(B.x < A2.minX - margin || B.y < A2.minY - margin || B.x > A2.maxX + margin || B.y > A2.maxY + margin);
    });
    __publicField(Box, "Common", (boxes) => {
      let minX = Infinity;
      let minY = Infinity;
      let maxX = -Infinity;
      let maxY = -Infinity;
      for (let i2 = 0; i2 < boxes.length; i2++) {
        const B = boxes[i2];
        minX = Math.min(minX, B.minX);
        minY = Math.min(minY, B.minY);
        maxX = Math.max(maxX, B.maxX);
        maxY = Math.max(maxY, B.maxY);
      }
      return new _Box(minX, minY, maxX - minX, maxY - minY);
    });
    __publicField(Box, "Sides", (A2, inset = 0) => {
      const { corners } = A2;
      if (inset) {
      }
      return [
        [corners[0], corners[1]],
        [corners[1], corners[2]],
        [corners[2], corners[3]],
        [corners[3], corners[0]]
      ];
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useScreenBounds.mjs
function useScreenBounds(ref) {
  const editor = useEditor();
  (0, import_react19.useLayoutEffect)(() => {
    let prevBounds = new Box();
    function updateScreenBounds() {
      const container2 = ref.current;
      if (!container2)
        return null;
      const rect = container2.getBoundingClientRect();
      const next = new Box(rect.left || rect.x, rect.top || rect.y, Math.max(rect.width, 1), Math.max(rect.height, 1));
      if (prevBounds.equals(next))
        return;
      editor.updateViewportScreenBounds(next);
      prevBounds = next;
    }
    updateScreenBounds();
    const updateBounds = (0, import_lodash.default)(updateScreenBounds, 200, {
      trailing: true
    });
    const interval = editor.timers.setInterval(updateBounds, 1e3);
    window.addEventListener("resize", updateBounds);
    const resizeObserver = new ResizeObserver((entries) => {
      if (!entries[0].contentRect)
        return;
      updateBounds();
    });
    const container = ref.current;
    let scrollingParent = null;
    if (container) {
      resizeObserver.observe(container);
      scrollingParent = getNearestScrollableContainer(container);
      scrollingParent.addEventListener("scroll", updateBounds);
    }
    return () => {
      clearInterval(interval);
      window.removeEventListener("resize", updateBounds);
      resizeObserver.disconnect();
      scrollingParent?.removeEventListener("scroll", updateBounds);
      updateBounds.cancel();
    };
  }, [editor, ref]);
}
var import_react19, getNearestScrollableContainer;
var init_useScreenBounds = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useScreenBounds.mjs"() {
    init_dist_esm2();
    import_react19 = __toESM(require_react(), 1);
    init_Box();
    init_useEditor();
    getNearestScrollableContainer = (element) => {
      let parent = element.parentElement;
      while (parent) {
        if (parent === document.body) {
          return document;
        }
        const { overflowY } = window.getComputedStyle(parent);
        const hasScrollableContent = parent.scrollHeight > parent.clientHeight;
        if (hasScrollableContent && (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay")) {
          return parent;
        }
        parent = parent.parentElement;
      }
      return document;
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/Mat.mjs
var _Mat, Mat;
var init_Mat = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/Mat.mjs"() {
    init_Box();
    init_utils();
    init_Vec();
    _Mat = class {
      constructor(a2, b2, c2, d2, e2, f2) {
        __publicField(this, "a", 1);
        __publicField(this, "b", 0);
        __publicField(this, "c", 0);
        __publicField(this, "d", 1);
        __publicField(this, "e", 0);
        __publicField(this, "f", 0);
        this.a = a2;
        this.b = b2;
        this.c = c2;
        this.d = d2;
        this.e = e2;
        this.f = f2;
      }
      equals(m2) {
        return this === m2 || this.a === m2.a && this.b === m2.b && this.c === m2.c && this.d === m2.d && this.e === m2.e && this.f === m2.f;
      }
      identity() {
        this.a = 1;
        this.b = 0;
        this.c = 0;
        this.d = 1;
        this.e = 0;
        this.f = 0;
        return this;
      }
      multiply(m2) {
        const m22 = m2;
        const { a: a2, b: b2, c: c2, d: d2, e: e2, f: f2 } = this;
        this.a = a2 * m22.a + c2 * m22.b;
        this.c = a2 * m22.c + c2 * m22.d;
        this.e = a2 * m22.e + c2 * m22.f + e2;
        this.b = b2 * m22.a + d2 * m22.b;
        this.d = b2 * m22.c + d2 * m22.d;
        this.f = b2 * m22.e + d2 * m22.f + f2;
        return this;
      }
      rotate(r2, cx, cy) {
        if (r2 === 0)
          return this;
        if (cx === void 0)
          return this.multiply(_Mat.Rotate(r2));
        return this.translate(cx, cy).multiply(_Mat.Rotate(r2)).translate(-cx, -cy);
      }
      translate(x2, y2) {
        return this.multiply(_Mat.Translate(x2, y2));
      }
      scale(x2, y2) {
        return this.multiply(_Mat.Scale(x2, y2));
      }
      invert() {
        const { a: a2, b: b2, c: c2, d: d2, e: e2, f: f2 } = this;
        const denom = a2 * d2 - b2 * c2;
        this.a = d2 / denom;
        this.b = b2 / -denom;
        this.c = c2 / -denom;
        this.d = a2 / denom;
        this.e = (d2 * e2 - c2 * f2) / -denom;
        this.f = (b2 * e2 - a2 * f2) / denom;
        return this;
      }
      applyToPoint(point) {
        return _Mat.applyToPoint(this, point);
      }
      applyToPoints(points) {
        return _Mat.applyToPoints(this, points);
      }
      rotation() {
        return _Mat.Rotation(this);
      }
      point() {
        return _Mat.Point(this);
      }
      decomposed() {
        return _Mat.Decompose(this);
      }
      toCssString() {
        return _Mat.toCssString(this);
      }
      setTo(model2) {
        Object.assign(this, model2);
        return this;
      }
      decompose() {
        return _Mat.Decompose(this);
      }
      clone() {
        return new _Mat(this.a, this.b, this.c, this.d, this.e, this.f);
      }
      static Identity() {
        return new _Mat(1, 0, 0, 1, 0, 0);
      }
      static Translate(x2, y2) {
        return new _Mat(1, 0, 0, 1, x2, y2);
      }
      static Rotate(r2, cx, cy) {
        if (r2 === 0)
          return _Mat.Identity();
        const cosAngle = Math.cos(r2);
        const sinAngle = Math.sin(r2);
        const rotationMatrix = new _Mat(cosAngle, sinAngle, -sinAngle, cosAngle, 0, 0);
        if (cx === void 0)
          return rotationMatrix;
        return _Mat.Compose(_Mat.Translate(cx, cy), rotationMatrix, _Mat.Translate(-cx, -cy));
      }
      static Multiply(m1, m2) {
        return {
          a: m1.a * m2.a + m1.c * m2.b,
          c: m1.a * m2.c + m1.c * m2.d,
          e: m1.a * m2.e + m1.c * m2.f + m1.e,
          b: m1.b * m2.a + m1.d * m2.b,
          d: m1.b * m2.c + m1.d * m2.d,
          f: m1.b * m2.e + m1.d * m2.f + m1.f
        };
      }
      static Inverse(m2) {
        const denom = m2.a * m2.d - m2.b * m2.c;
        return {
          a: m2.d / denom,
          b: m2.b / -denom,
          c: m2.c / -denom,
          d: m2.a / denom,
          e: (m2.d * m2.e - m2.c * m2.f) / -denom,
          f: (m2.b * m2.e - m2.a * m2.f) / denom
        };
      }
      static Absolute(m2) {
        const denom = m2.a * m2.d - m2.b * m2.c;
        return {
          a: m2.d / denom,
          b: m2.b / -denom,
          c: m2.c / -denom,
          d: m2.a / denom,
          e: (m2.d * m2.e - m2.c * m2.f) / denom,
          f: (m2.b * m2.e - m2.a * m2.f) / -denom
        };
      }
      static Compose(...matrices) {
        const matrix = _Mat.Identity();
        for (let i2 = 0, n2 = matrices.length; i2 < n2; i2++) {
          matrix.multiply(matrices[i2]);
        }
        return matrix;
      }
      static Point(m2) {
        return new Vec(m2.e, m2.f);
      }
      static Rotation(m2) {
        let rotation;
        if (m2.a !== 0 || m2.c !== 0) {
          const hypotAc = (m2.a * m2.a + m2.c * m2.c) ** 0.5;
          rotation = Math.acos(m2.a / hypotAc) * (m2.c > 0 ? -1 : 1);
        } else if (m2.b !== 0 || m2.d !== 0) {
          const hypotBd = (m2.b * m2.b + m2.d * m2.d) ** 0.5;
          rotation = HALF_PI + Math.acos(m2.b / hypotBd) * (m2.d > 0 ? -1 : 1);
        } else {
          rotation = 0;
        }
        return clampRadians(rotation);
      }
      static Decompose(m2) {
        let scaleX, scaleY, rotation;
        if (m2.a !== 0 || m2.c !== 0) {
          const hypotAc = (m2.a * m2.a + m2.c * m2.c) ** 0.5;
          scaleX = hypotAc;
          scaleY = (m2.a * m2.d - m2.b * m2.c) / hypotAc;
          rotation = Math.acos(m2.a / hypotAc) * (m2.c > 0 ? -1 : 1);
        } else if (m2.b !== 0 || m2.d !== 0) {
          const hypotBd = (m2.b * m2.b + m2.d * m2.d) ** 0.5;
          scaleX = (m2.a * m2.d - m2.b * m2.c) / hypotBd;
          scaleY = hypotBd;
          rotation = HALF_PI + Math.acos(m2.b / hypotBd) * (m2.d > 0 ? -1 : 1);
        } else {
          scaleX = 0;
          scaleY = 0;
          rotation = 0;
        }
        return {
          x: m2.e,
          y: m2.f,
          scaleX,
          scaleY,
          rotation: clampRadians(rotation)
        };
      }
      static Smooth(m2, precision = 1e10) {
        m2.a = Math.round(m2.a * precision) / precision;
        m2.b = Math.round(m2.b * precision) / precision;
        m2.c = Math.round(m2.c * precision) / precision;
        m2.d = Math.round(m2.d * precision) / precision;
        m2.e = Math.round(m2.e * precision) / precision;
        m2.f = Math.round(m2.f * precision) / precision;
        return m2;
      }
      static toCssString(m2) {
        return `matrix(${toDomPrecision(m2.a)}, ${toDomPrecision(m2.b)}, ${toDomPrecision(m2.c)}, ${toDomPrecision(m2.d)}, ${toDomPrecision(m2.e)}, ${toDomPrecision(m2.f)})`;
      }
      static applyToPoint(m2, point) {
        return new Vec(m2.a * point.x + m2.c * point.y + m2.e, m2.b * point.x + m2.d * point.y + m2.f, point.z);
      }
      static applyToXY(m2, x2, y2) {
        return [m2.a * x2 + m2.c * y2 + m2.e, m2.b * x2 + m2.d * y2 + m2.f];
      }
      static applyToPoints(m2, points) {
        return points.map((point) => new Vec(m2.a * point.x + m2.c * point.y + m2.e, m2.b * point.x + m2.d * point.y + m2.f, point.z));
      }
      static applyToBounds(m2, box) {
        return new Box(m2.e + box.minX, m2.f + box.minY, box.width, box.height);
      }
      static From(m2) {
        return new _Mat(m2.a, m2.b, m2.c, m2.d, m2.e, m2.f);
      }
      static Cast(m2) {
        return m2 instanceof _Mat ? m2 : _Mat.From(m2);
      }
    };
    Mat = _Mat;
    __publicField(Mat, "Scale", (x2, y2, cx, cy) => {
      const scaleMatrix = new _Mat(x2, 0, 0, y2, 0, 0);
      if (cx === void 0)
        return scaleMatrix;
      return _Mat.Compose(_Mat.Translate(cx, cy), scaleMatrix, _Mat.Translate(-cx, -cy));
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/nearestMultiple.mjs
function gcd(a2, b2) {
  return b2 === 0 ? a2 : gcd(b2, a2 % b2);
}
function nearestMultiple(float) {
  const decimal = float.toString().split(".")[1];
  if (!decimal)
    return 1;
  const denominator = Math.pow(10, decimal.length);
  const numerator = parseInt(decimal, 10);
  return denominator / gcd(numerator, denominator);
}
var init_nearestMultiple = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/nearestMultiple.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Geometry2d.mjs
var Geometry2d;
var init_Geometry2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Geometry2d.mjs"() {
    init_Box();
    init_Vec();
    init_utils();
    Geometry2d = class {
      constructor(opts) {
        __publicField(this, "isFilled", false);
        __publicField(this, "isClosed", true);
        __publicField(this, "isLabel", false);
        __publicField(this, "debugColor");
        __publicField(this, "ignore");
        __publicField(this, "_vertices");
        __publicField(this, "_bounds");
        __publicField(this, "_area");
        __publicField(this, "_length");
        this.isFilled = opts.isFilled;
        this.isClosed = opts.isClosed;
        this.isLabel = opts.isLabel ?? false;
        this.debugColor = opts.debugColor;
        this.ignore = opts.ignore;
      }
      hitTestPoint(point, margin = 0, hitInside = false) {
        if (this.isClosed && (this.isFilled || hitInside) && pointInPolygon(point, this.vertices)) {
          return true;
        }
        return Vec.Dist2(point, this.nearestPoint(point)) <= margin * margin;
      }
      distanceToPoint(point, hitInside = false) {
        return point.dist(this.nearestPoint(point)) * (this.isClosed && (this.isFilled || hitInside) && pointInPolygon(point, this.vertices) ? -1 : 1);
      }
      distanceToLineSegment(A2, B) {
        if (A2.equals(B))
          return this.distanceToPoint(A2);
        const { vertices } = this;
        let nearest;
        let dist = Infinity;
        let d2, p2, q;
        for (let i2 = 0; i2 < vertices.length; i2++) {
          p2 = vertices[i2];
          q = Vec.NearestPointOnLineSegment(A2, B, p2, true);
          d2 = Vec.Dist2(p2, q);
          if (d2 < dist) {
            dist = d2;
            nearest = q;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return this.isClosed && this.isFilled && pointInPolygon(nearest, this.vertices) ? -dist : dist;
      }
      hitTestLineSegment(A2, B, distance = 0) {
        return this.distanceToLineSegment(A2, B) <= distance;
      }
      nearestPointOnLineSegment(A2, B) {
        const { vertices } = this;
        let nearest;
        let dist = Infinity;
        let d2, p2, q;
        for (let i2 = 0; i2 < vertices.length; i2++) {
          p2 = vertices[i2];
          q = Vec.NearestPointOnLineSegment(A2, B, p2, true);
          d2 = Vec.Dist2(p2, q);
          if (d2 < dist) {
            dist = d2;
            nearest = q;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      isPointInBounds(point, margin = 0) {
        const { bounds } = this;
        return !(point.x < bounds.minX - margin || point.y < bounds.minY - margin || point.x > bounds.maxX + margin || point.y > bounds.maxY + margin);
      }
      get vertices() {
        if (!this._vertices) {
          this._vertices = this.getVertices();
        }
        return this._vertices;
      }
      getBounds() {
        return Box.FromPoints(this.vertices);
      }
      get bounds() {
        if (!this._bounds) {
          this._bounds = this.getBounds();
        }
        return this._bounds;
      }
      get center() {
        return this.bounds.center;
      }
      get area() {
        if (!this._area) {
          this._area = this.getArea();
        }
        return this._area;
      }
      getArea() {
        if (!this.isClosed) {
          return 0;
        }
        const { vertices } = this;
        let area = 0;
        for (let i2 = 0, n2 = vertices.length; i2 < n2; i2++) {
          const curr = vertices[i2];
          const next = vertices[(i2 + 1) % n2];
          area += curr.x * next.y - next.x * curr.y;
        }
        return area / 2;
      }
      toSimpleSvgPath() {
        let path = "";
        const { vertices } = this;
        const n2 = vertices.length;
        if (n2 === 0)
          return path;
        path += `M${vertices[0].x},${vertices[0].y}`;
        for (let i2 = 1; i2 < n2; i2++) {
          path += `L${vertices[i2].x},${vertices[i2].y}`;
        }
        if (this.isClosed) {
          path += "Z";
        }
        return path;
      }
      get length() {
        if (this._length)
          return this._length;
        this._length = this.getLength();
        return this._length;
      }
      getLength() {
        const { vertices } = this;
        let n1, p1 = vertices[0], length = 0;
        for (let i2 = 1; i2 < vertices.length; i2++) {
          n1 = vertices[i2];
          length += Vec.Dist2(p1, n1);
          p1 = n1;
        }
        return Math.sqrt(length);
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Group2d.mjs
var Group2d;
var init_Group2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Group2d.mjs"() {
    init_Box();
    init_Vec();
    init_Geometry2d();
    Group2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isClosed: true, isFilled: false });
        __publicField(this, "children", []);
        __publicField(this, "ignoredChildren", []);
        for (const child of config.children) {
          if (child.ignore) {
            this.ignoredChildren.push(child);
          } else {
            this.children.push(child);
          }
        }
        if (this.children.length === 0)
          throw Error("Group2d must have at least one child");
      }
      getVertices() {
        return this.children.filter((c2) => !c2.isLabel).flatMap((c2) => c2.vertices);
      }
      nearestPoint(point) {
        let dist = Infinity;
        let nearest;
        const { children } = this;
        if (children.length === 0) {
          throw Error("no children");
        }
        let p2;
        let d2;
        for (const child of children) {
          p2 = child.nearestPoint(point);
          d2 = Vec.Dist2(p2, point);
          if (d2 < dist) {
            dist = d2;
            nearest = p2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      distanceToPoint(point, hitInside = false) {
        return Math.min(...this.children.map((c2, i2) => c2.distanceToPoint(point, hitInside || i2 > 0)));
      }
      hitTestPoint(point, margin, hitInside) {
        return !!this.children.filter((c2) => !c2.isLabel).find((c2) => c2.hitTestPoint(point, margin, hitInside));
      }
      hitTestLineSegment(A2, B, zoom) {
        return !!this.children.filter((c2) => !c2.isLabel).find((c2) => c2.hitTestLineSegment(A2, B, zoom));
      }
      getArea() {
        return this.children[0].area;
      }
      toSimpleSvgPath() {
        let path = "";
        for (const child of this.children) {
          path += child.toSimpleSvgPath();
        }
        const corners = Box.FromPoints(this.vertices).corners;
        for (let i2 = 0, n2 = corners.length; i2 < n2; i2++) {
          const corner = corners[i2];
          const prevCorner = corners[(i2 - 1 + n2) % n2];
          const prevDist = corner.dist(prevCorner);
          const nextCorner = corners[(i2 + 1) % n2];
          const nextDist = corner.dist(nextCorner);
          const A2 = corner.clone().lrp(prevCorner, 4 / prevDist);
          const B = corner;
          const C2 = corner.clone().lrp(nextCorner, 4 / nextDist);
          path += `M${A2.x},${A2.y} L${B.x},${B.y} L${C2.x},${C2.y} `;
        }
        return path;
      }
      getLength() {
        return this.children.reduce((a2, c2) => c2.isLabel ? a2 : a2 + c2.length, 0);
      }
      getSvgPathData() {
        return this.children.map((c2, i2) => c2.isLabel ? "" : c2.getSvgPathData(i2 === 0)).join(" ");
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/GeometryDebuggingView.mjs
function useTick(isEnabled = true) {
  const [_2, setTick] = (0, import_react20.useState)(0);
  const editor = useEditor();
  (0, import_react20.useEffect)(() => {
    if (!isEnabled)
      return;
    const update = () => setTick((tick3) => tick3 + 1);
    editor.on("tick", update);
    return () => {
      editor.off("tick", update);
    };
  }, [editor, isEnabled]);
}
function GeometryStroke({ geometry }) {
  if (geometry instanceof Group2d) {
    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: [...geometry.children, ...geometry.ignoredChildren].map((child, i2) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(GeometryStroke, { geometry: child }, i2)) });
  }
  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: geometry.toSimpleSvgPath() });
}
var import_jsx_runtime5, import_react20, GeometryDebuggingView;
var init_GeometryDebuggingView = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/GeometryDebuggingView.mjs"() {
    import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    init_dist_esm2();
    import_react20 = __toESM(require_react(), 1);
    init_useEditor();
    init_Group2d();
    GeometryDebuggingView = track(function GeometryDebuggingView2({
      showStroke = true,
      showVertices = true,
      showClosestPointOnOutline = true
    }) {
      const editor = useEditor();
      useTick(showClosestPointOnOutline);
      const zoomLevel = editor.getZoomLevel();
      const renderingShapes = editor.getRenderingShapes();
      const {
        inputs: { currentPagePoint }
      } = editor;
      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", {
        style: {
          position: "absolute",
          pointerEvents: "none",
          zIndex: 999999999,
          top: 0,
          left: 0,
          overflow: "visible"
        },
        children: renderingShapes.map((result) => {
          const shape = editor.getShape(result.id);
          if (shape.type === "group")
            return null;
          const geometry = editor.getShapeGeometry(shape);
          const pageTransform = editor.getShapePageTransform(shape);
          const pointInShapeSpace = editor.getPointInShapeSpace(shape, currentPagePoint);
          const nearestPointOnShape = geometry.nearestPoint(pointInShapeSpace);
          const distanceToPoint = geometry.distanceToPoint(pointInShapeSpace, true);
          const dist = Math.abs(distanceToPoint) * zoomLevel;
          const hitInside = distanceToPoint < 0;
          const { vertices } = geometry;
          return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("g", {
            transform: pageTransform.toCssString(),
            strokeLinecap: "round",
            strokeLinejoin: "round",
            children: [
              showStroke && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("g", {
                stroke: geometry.debugColor ?? "red",
                opacity: "1",
                strokeWidth: 2 / zoomLevel,
                fill: "none",
                children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(GeometryStroke, { geometry })
              }),
              showVertices && vertices.map((v2, i2) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("circle", {
                cx: v2.x,
                cy: v2.y,
                r: 2 / zoomLevel,
                fill: `hsl(${modulate(i2, [0, vertices.length - 1], [120, 200])}, 100%, 50%)`,
                stroke: "black",
                strokeWidth: 1 / zoomLevel
              }, `v${i2}`)),
              showClosestPointOnOutline && dist < 150 && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("line", {
                x1: nearestPointOnShape.x,
                y1: nearestPointOnShape.y,
                x2: pointInShapeSpace.x,
                y2: pointInShapeSpace.y,
                opacity: 1 - dist / 150,
                stroke: hitInside ? "goldenrod" : "dodgerblue",
                strokeWidth: 2 / zoomLevel
              })
            ]
          }, result.id + "_outline");
        })
      });
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/uniq.mjs
function uniq(array2) {
  return (0, import_lodash2.default)(array2);
}
var init_uniq = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/uniq.mjs"() {
    init_dist_esm2();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/usePeerIds.mjs
function usePeerIds() {
  const editor = useEditor();
  const $userIds = useComputed("userIds", () => uniq(editor.getCollaborators().map((p2) => p2.userId)).sort(), { isEqual: (a2, b2) => a2.join(",") === b2.join?.(",") }, [editor]);
  return useValue($userIds);
}
var init_usePeerIds = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/usePeerIds.mjs"() {
    init_dist_esm9();
    init_uniq();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/usePresence.mjs
function usePresence(userId) {
  const editor = useEditor();
  const latestPresence = useValue(`latestPresence:${userId}`, () => {
    return editor.getCollaborators().find((c2) => c2.userId === userId);
  }, [editor, userId]);
  return latestPresence ?? null;
}
var init_usePresence = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/usePresence.mjs"() {
    init_dist_esm9();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/LiveCollaborators.mjs
function getStateFromElapsedTime(editor, elapsed) {
  return elapsed > editor.options.collaboratorInactiveTimeoutMs ? "inactive" : elapsed > editor.options.collaboratorIdleTimeoutMs ? "idle" : "active";
}
function useCollaboratorState(editor, latestPresence) {
  const rLastActivityTimestamp = (0, import_react21.useRef)(latestPresence?.lastActivityTimestamp ?? -1);
  const [state, setState] = (0, import_react21.useState)(() => getStateFromElapsedTime(editor, Date.now() - rLastActivityTimestamp.current));
  (0, import_react21.useEffect)(() => {
    const interval = editor.timers.setInterval(() => {
      setState(getStateFromElapsedTime(editor, Date.now() - rLastActivityTimestamp.current));
    }, editor.options.collaboratorCheckIntervalMs);
    return () => clearInterval(interval);
  }, [editor]);
  if (latestPresence) {
    rLastActivityTimestamp.current = latestPresence.lastActivityTimestamp;
  }
  return state;
}
var import_jsx_runtime6, import_react21, LiveCollaborators, CollaboratorGuard, Collaborator;
var init_LiveCollaborators = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/LiveCollaborators.mjs"() {
    import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    import_react21 = __toESM(require_react(), 1);
    init_useEditor();
    init_useEditorComponents();
    init_usePeerIds();
    init_usePresence();
    LiveCollaborators = track(function Collaborators() {
      const peerIds = usePeerIds();
      return peerIds.map((id) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorGuard, { collaboratorId: id }, id));
    });
    CollaboratorGuard = track(function CollaboratorGuard2({
      collaboratorId
    }) {
      const editor = useEditor();
      const presence = usePresence(collaboratorId);
      const collaboratorState = useCollaboratorState(editor, presence);
      if (!(presence && presence.currentPageId === editor.getCurrentPageId())) {
        return null;
      }
      switch (collaboratorState) {
        case "inactive": {
          const { followingUserId, highlightedUserIds } = editor.getInstanceState();
          if (!(followingUserId === presence.userId || highlightedUserIds.includes(presence.userId))) {
            return null;
          }
          break;
        }
        case "idle": {
          const { highlightedUserIds } = editor.getInstanceState();
          if (presence.followingUserId === editor.user.getId() && !(presence.chatMessage || highlightedUserIds.includes(presence.userId))) {
            return null;
          }
          break;
        }
        case "active": {
          break;
        }
      }
      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Collaborator, { latestPresence: presence });
    });
    Collaborator = track(function Collaborator2({
      latestPresence
    }) {
      const editor = useEditor();
      const {
        CollaboratorBrush,
        CollaboratorScribble,
        CollaboratorCursor,
        CollaboratorHint,
        CollaboratorShapeIndicator
      } = useEditorComponents();
      const zoomLevel = editor.getZoomLevel();
      const viewportPageBounds = editor.getViewportPageBounds();
      const { userId, chatMessage, brush, scribbles, selectedShapeIds, userName, cursor, color } = latestPresence;
      const isCursorInViewport = !(cursor.x < viewportPageBounds.minX - 12 / zoomLevel || cursor.y < viewportPageBounds.minY - 16 / zoomLevel || cursor.x > viewportPageBounds.maxX - 12 / zoomLevel || cursor.y > viewportPageBounds.maxY - 16 / zoomLevel);
      return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
        brush && CollaboratorBrush ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorBrush, {
          className: "tl-collaborator__brush",
          brush,
          color,
          opacity: 0.1
        }, userId + "_brush") : null,
        isCursorInViewport && CollaboratorCursor ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorCursor, {
          className: "tl-collaborator__cursor",
          point: cursor,
          color,
          zoom: zoomLevel,
          name: userName !== "New User" ? userName : null,
          chatMessage
        }, userId + "_cursor") : CollaboratorHint ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorHint, {
          className: "tl-collaborator__cursor-hint",
          point: cursor,
          color,
          zoom: zoomLevel,
          viewport: viewportPageBounds
        }, userId + "_cursor_hint") : null,
        CollaboratorScribble && scribbles.length ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: scribbles.map((scribble) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorScribble, {
          className: "tl-collaborator__scribble",
          scribble,
          color,
          zoom: zoomLevel,
          opacity: scribble.color === "laser" ? 0.5 : 0.1
        }, userId + "_scribble_" + scribble.id)) }) : null,
        CollaboratorShapeIndicator && selectedShapeIds.map((shapeId) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CollaboratorShapeIndicator, {
          className: "tl-collaborator__shape-indicator",
          shapeId,
          color,
          opacity: 0.5
        }, userId + "_" + shapeId))
      ] });
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/Shape.mjs
var import_jsx_runtime7, import_react22, Shape, InnerShape, InnerShapeBackground;
var init_Shape = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/Shape.mjs"() {
    import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    import_react22 = __toESM(require_react(), 1);
    init_useEditor();
    init_useEditorComponents();
    init_Mat();
    init_dom();
    init_ErrorBoundary();
    Shape = (0, import_react22.memo)(function Shape2({
      id,
      shape,
      util,
      index: index3,
      backgroundIndex,
      opacity,
      dprMultiple
    }) {
      const editor = useEditor();
      const { ShapeErrorFallback } = useEditorComponents();
      const containerRef = (0, import_react22.useRef)(null);
      const bgContainerRef = (0, import_react22.useRef)(null);
      const memoizedStuffRef = (0, import_react22.useRef)({
        transform: "",
        clipPath: "none",
        width: 0,
        height: 0,
        x: 0,
        y: 0,
        isCulled: false
      });
      useQuickReactor("set shape stuff", () => {
        const shape2 = editor.getShape(id);
        if (!shape2)
          return;
        const prev = memoizedStuffRef.current;
        const clipPath = editor.getShapeClipPath(id) ?? "none";
        if (clipPath !== prev.clipPath) {
          setStyleProperty(containerRef.current, "clip-path", clipPath);
          setStyleProperty(bgContainerRef.current, "clip-path", clipPath);
          prev.clipPath = clipPath;
        }
        const pageTransform = editor.getShapePageTransform(id);
        const transform = Mat.toCssString(pageTransform);
        const bounds = editor.getShapeGeometry(shape2).bounds;
        if (transform !== prev.transform) {
          setStyleProperty(containerRef.current, "transform", transform);
          setStyleProperty(bgContainerRef.current, "transform", transform);
          prev.transform = transform;
        }
        const widthRemainder = bounds.w % dprMultiple;
        const heightRemainder = bounds.h % dprMultiple;
        const width = widthRemainder === 0 ? bounds.w : bounds.w + (dprMultiple - widthRemainder);
        const height = heightRemainder === 0 ? bounds.h : bounds.h + (dprMultiple - heightRemainder);
        if (width !== prev.width || height !== prev.height) {
          setStyleProperty(containerRef.current, "width", Math.max(width, dprMultiple) + "px");
          setStyleProperty(containerRef.current, "height", Math.max(height, dprMultiple) + "px");
          setStyleProperty(bgContainerRef.current, "width", Math.max(width, dprMultiple) + "px");
          setStyleProperty(bgContainerRef.current, "height", Math.max(height, dprMultiple) + "px");
          prev.width = width;
          prev.height = height;
        }
      }, [editor]);
      useQuickReactor("set opacity and z-index", () => {
        const container = containerRef.current;
        const bgContainer = bgContainerRef.current;
        setStyleProperty(container, "opacity", opacity);
        setStyleProperty(bgContainer, "opacity", opacity);
        setStyleProperty(container, "z-index", index3);
        setStyleProperty(bgContainer, "z-index", backgroundIndex);
      }, [opacity, index3, backgroundIndex]);
      useQuickReactor("set display", () => {
        const shape2 = editor.getShape(id);
        if (!shape2)
          return;
        const culledShapes = editor.getCulledShapes();
        const isCulled = culledShapes.has(id);
        if (isCulled !== memoizedStuffRef.current.isCulled) {
          setStyleProperty(containerRef.current, "display", isCulled ? "none" : "block");
          setStyleProperty(bgContainerRef.current, "display", isCulled ? "none" : "block");
          memoizedStuffRef.current.isCulled = isCulled;
        }
      }, [editor]);
      const annotateError5 = (0, import_react22.useCallback)((error2) => editor.annotateError(error2, { origin: "shape", willCrashApp: false }), [editor]);
      if (!shape)
        return null;
      const isFilledShape = "fill" in shape.props && shape.props.fill !== "none";
      return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
        util.backgroundComponent && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", {
          ref: bgContainerRef,
          className: "tl-shape tl-shape-background",
          "data-shape-type": shape.type,
          draggable: false,
          children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(OptionalErrorBoundary, { fallback: ShapeErrorFallback, onError: annotateError5, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(InnerShapeBackground, { shape, util }) })
        }),
        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", {
          ref: containerRef,
          className: "tl-shape",
          "data-shape-type": shape.type,
          "data-shape-is-filled": isFilledShape,
          draggable: false,
          children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(OptionalErrorBoundary, { fallback: ShapeErrorFallback, onError: annotateError5, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(InnerShape, { shape, util }) })
        })
      ] });
    });
    InnerShape = (0, import_react22.memo)(function InnerShape2({ shape, util }) {
      return useStateTracking("InnerShape:" + shape.type, () => util.component(util.editor.store.unsafeGetWithoutCapture(shape.id)));
    }, (prev, next) => prev.shape.props === next.shape.props && prev.shape.meta === next.shape.meta);
    InnerShapeBackground = (0, import_react22.memo)(function InnerShapeBackground2({
      shape,
      util
    }) {
      return useStateTracking("InnerShape:" + shape.type, () => util.backgroundComponent?.(util.editor.store.unsafeGetWithoutCapture(shape.id)));
    }, (prev, next) => prev.shape.props === next.shape.props && prev.shape.meta === next.shape.meta);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCanvas.mjs
function DefaultCanvas({ className }) {
  const editor = useEditor();
  const { Background, SvgDefs, ShapeIndicators } = useEditorComponents();
  const rCanvas = (0, import_react23.useRef)(null);
  const rHtmlLayer = (0, import_react23.useRef)(null);
  const rHtmlLayer2 = (0, import_react23.useRef)(null);
  const container = useContainer();
  useScreenBounds(rCanvas);
  useDocumentEvents();
  useCoarsePointer();
  useGestureEvents(rCanvas);
  useFixSafariDoubleTapZoomPencilEvents(rCanvas);
  const rMemoizedStuff = (0, import_react23.useRef)({ lodDisableTextOutline: false, allowTextOutline: true });
  useQuickReactor("position layers", function positionLayersWhenCameraMoves() {
    const { x: x2, y: y2, z } = editor.getCamera();
    if (rMemoizedStuff.current.allowTextOutline && editor.environment.isSafari) {
      container.style.setProperty("--tl-text-outline", "none");
      rMemoizedStuff.current.allowTextOutline = false;
    }
    if (rMemoizedStuff.current.allowTextOutline && z < editor.options.textShadowLod !== rMemoizedStuff.current.lodDisableTextOutline) {
      const lodDisableTextOutline = z < editor.options.textShadowLod;
      container.style.setProperty("--tl-text-outline", lodDisableTextOutline ? "none" : `var(--tl-text-outline-reference)`);
      rMemoizedStuff.current.lodDisableTextOutline = lodDisableTextOutline;
    }
    const offset5 = z >= 1 ? modulate(z, [1, 8], [0.125, 0.5], true) : modulate(z, [0.1, 1], [-2, 0.125], true);
    const transform = `scale(${toDomPrecision(z)}) translate(${toDomPrecision(x2 + offset5)}px,${toDomPrecision(y2 + offset5)}px)`;
    setStyleProperty(rHtmlLayer.current, "transform", transform);
    setStyleProperty(rHtmlLayer2.current, "transform", transform);
  }, [editor, container]);
  const events = useCanvasEvents();
  const shapeSvgDefs = useValue("shapeSvgDefs", () => {
    const shapeSvgDefsByKey = /* @__PURE__ */ new Map();
    for (const util of objectMapValues(editor.shapeUtils)) {
      if (!util)
        return;
      const defs = util.getCanvasSvgDefs();
      for (const { key, component: Component2 } of defs) {
        if (shapeSvgDefsByKey.has(key))
          continue;
        shapeSvgDefsByKey.set(key, /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Component2, {}, key));
      }
    }
    return [...shapeSvgDefsByKey.values()];
  }, [editor]);
  const hideShapes = useValue("debug_shapes", () => debugFlags.hideShapes.get(), [debugFlags]);
  const debugSvg = useValue("debug_svg", () => debugFlags.debugSvg.get(), [debugFlags]);
  const debugGeometry = useValue("debug_geometry", () => debugFlags.debugGeometry.get(), [
    debugFlags
  ]);
  const isEditingAnything = useValue("isEditingAnything", () => editor.getEditingShapeId() !== null, [editor]);
  const isSelectingAnything = useValue("isSelectingAnything", () => !!editor.getSelectedShapeIds().length, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", {
      ref: rCanvas,
      draggable: false,
      "data-iseditinganything": isEditingAnything,
      "data-isselectinganything": isSelectingAnything,
      className: (0, import_classnames.default)("tl-canvas", className),
      "data-testid": "canvas",
      ...events,
      children: [
        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("svg", { className: "tl-svg-context", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("defs", { children: [
          shapeSvgDefs,
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CursorDef, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CollaboratorHintDef, {}),
          SvgDefs && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SvgDefs, {})
        ] }) }),
        Background && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "tl-background__wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Background, {}) }),
        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(GridWrapper, {}),
        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { ref: rHtmlLayer, className: "tl-html-layer tl-shapes", draggable: false, children: [
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(OnTheCanvasWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectionBackgroundWrapper, {}),
          hideShapes ? null : debugSvg ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ShapesWithSVGs, {}) : /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ShapesToDisplay, {})
        ] }),
        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "tl-overlays", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { ref: rHtmlLayer2, className: "tl-html-layer", children: [
          debugGeometry ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(GeometryDebuggingView, {}) : null,
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(HandlesWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(BrushWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ScribbleWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ZoomBrushWrapper, {}),
          ShapeIndicators && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ShapeIndicators, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(HintedShapeIndicator, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SnapIndicatorWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectionForegroundWrapper, {}),
          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(LiveCollaborators, {})
        ] }) }),
        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MovingCameraHitTestBlocker, {})
      ]
    }),
    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(InFrontOfTheCanvasWrapper, {})
  ] });
}
function InFrontOfTheCanvasWrapper() {
  const { InFrontOfTheCanvas } = useEditorComponents();
  if (!InFrontOfTheCanvas)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(InFrontOfTheCanvas, {});
}
function GridWrapper() {
  const editor = useEditor();
  const gridSize = useValue("gridSize", () => editor.getDocumentSettings().gridSize, [editor]);
  const { x: x2, y: y2, z } = useValue("camera", () => editor.getCamera(), [editor]);
  const isGridMode = useValue("isGridMode", () => editor.getInstanceState().isGridMode, [editor]);
  const { Grid } = useEditorComponents();
  if (!(Grid && isGridMode))
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Grid, { x: x2, y: y2, z, size: gridSize });
}
function ScribbleWrapper() {
  const editor = useEditor();
  const scribbles = useValue("scribbles", () => editor.getInstanceState().scribbles, [editor]);
  const zoomLevel = useValue("zoomLevel", () => editor.getZoomLevel(), [editor]);
  const { Scribble } = useEditorComponents();
  if (!(Scribble && scribbles.length))
    return null;
  return scribbles.map((scribble) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Scribble, { className: "tl-user-scribble", scribble, zoom: zoomLevel }, scribble.id));
}
function BrushWrapper() {
  const editor = useEditor();
  const brush = useValue("brush", () => editor.getInstanceState().brush, [editor]);
  const { Brush } = useEditorComponents();
  if (!(Brush && brush))
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Brush, { className: "tl-user-brush", brush });
}
function ZoomBrushWrapper() {
  const editor = useEditor();
  const zoomBrush = useValue("zoomBrush", () => editor.getInstanceState().zoomBrush, [editor]);
  const { ZoomBrush } = useEditorComponents();
  if (!(ZoomBrush && zoomBrush))
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ZoomBrush, { className: "tl-user-brush tl-zoom-brush", brush: zoomBrush });
}
function SnapIndicatorWrapper() {
  const editor = useEditor();
  const lines = useValue("snapLines", () => editor.snaps.getIndicators(), [editor]);
  const zoomLevel = useValue("zoomLevel", () => editor.getZoomLevel(), [editor]);
  const { SnapIndicator } = useEditorComponents();
  if (!(SnapIndicator && lines.length > 0))
    return null;
  return lines.map((line) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SnapIndicator, { className: "tl-user-snapline", line, zoom: zoomLevel }, line.id));
}
function HandlesWrapper() {
  const editor = useEditor();
  const shapeIdWithHandles = useValue("handles shapeIdWithHandles", () => {
    const { isReadonly, isChangingStyle } = editor.getInstanceState();
    if (isReadonly || isChangingStyle)
      return false;
    const onlySelectedShape = editor.getOnlySelectedShape();
    if (!onlySelectedShape)
      return false;
    const handles = editor.getShapeHandles(onlySelectedShape);
    if (!handles)
      return false;
    return onlySelectedShape.id;
  }, [editor]);
  if (!shapeIdWithHandles)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(HandlesWrapperInner, { shapeId: shapeIdWithHandles });
}
function HandlesWrapperInner({ shapeId }) {
  const editor = useEditor();
  const { Handles } = useEditorComponents();
  const zoomLevel = useValue("zoomLevel", () => editor.getZoomLevel(), [editor]);
  const isCoarse = useValue("coarse pointer", () => editor.getInstanceState().isCoarsePointer, [
    editor
  ]);
  const transform = useValue("handles transform", () => editor.getShapePageTransform(shapeId), [
    editor,
    shapeId
  ]);
  const handles = useValue("handles", () => {
    const handles2 = editor.getShapeHandles(shapeId);
    if (!handles2)
      return null;
    const minDistBetweenVirtualHandlesAndRegularHandles = (isCoarse ? editor.options.coarseHandleRadius : editor.options.handleRadius) / zoomLevel * 2;
    return handles2.filter((handle) => handle.type !== "virtual" || !handles2.some((h2) => h2 !== handle && h2.type === "vertex" && Vec.Dist(handle, h2) < minDistBetweenVirtualHandlesAndRegularHandles)).sort((a2) => a2.type === "vertex" ? 1 : -1);
  }, [editor, zoomLevel, isCoarse, shapeId]);
  if (!Handles || !handles || !transform) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Handles, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("g", { transform: Mat.toCssString(transform), children: handles.map((handle) => {
    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(HandleWrapper, {
      shapeId,
      handle,
      zoom: zoomLevel,
      isCoarse
    }, handle.id);
  }) }) });
}
function HandleWrapper({
  shapeId,
  handle,
  zoom,
  isCoarse
}) {
  const events = useHandleEvents(shapeId, handle.id);
  const { Handle } = useEditorComponents();
  if (!Handle)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("g", { "aria-label": "handle", transform: `translate(${handle.x}, ${handle.y})`, ...events, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Handle, { shapeId, handle, zoom, isCoarse }) });
}
function ShapesWithSVGs() {
  const editor = useEditor();
  const renderingShapes = useValue("rendering shapes", () => editor.getRenderingShapes(), [editor]);
  const dprMultiple = useValue("dpr multiple", () => nearestMultiple(Math.floor(editor.getInstanceState().devicePixelRatio * 100) / 100), [editor]);
  return renderingShapes.map((result) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react23.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Shape, { ...result, dprMultiple }),
    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DebugSvgCopy, { id: result.id })
  ] }, result.id + "_fragment"));
}
function ReflowIfNeeded() {
  const editor = useEditor();
  const culledShapesRef = (0, import_react23.useRef)(/* @__PURE__ */ new Set());
  useQuickReactor("reflow for culled shapes", () => {
    const culledShapes = editor.getCulledShapes();
    if (culledShapesRef.current.size === culledShapes.size && [...culledShapes].every((id) => culledShapesRef.current.has(id)))
      return;
    culledShapesRef.current = culledShapes;
    const canvas = document.getElementsByClassName("tl-canvas");
    if (canvas.length === 0)
      return;
    const _height = canvas[0].offsetHeight;
  }, [editor]);
  return null;
}
function ShapesToDisplay() {
  const editor = useEditor();
  const renderingShapes = useValue("rendering shapes", () => editor.getRenderingShapes(), [editor]);
  const dprMultiple = useValue("dpr multiple", () => nearestMultiple(Math.floor(editor.getInstanceState().devicePixelRatio * 100) / 100), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
    renderingShapes.map((result) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Shape, { ...result, dprMultiple }, result.id + "_shape")),
    editor.environment.isSafari && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ReflowIfNeeded, {})
  ] });
}
function HintedShapeIndicator() {
  const editor = useEditor();
  const { ShapeIndicator } = useEditorComponents();
  const ids = useValue("hinting shape ids", () => dedupe(editor.getHintingShapeIds()), [editor]);
  if (!ids.length)
    return null;
  if (!ShapeIndicator)
    return null;
  return ids.map((id) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ShapeIndicator, { className: "tl-user-indicator__hint", shapeId: id }, id + "_hinting"));
}
function CursorDef() {
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("g", { id: "cursor", children: [
    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("g", { fill: "rgba(0,0,0,.2)", transform: "translate(-11,-11)", children: [
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m12 24.4219v-16.015l11.591 11.619h-6.781l-.411.124z" }),
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m21.0845 25.0962-3.605 1.535-4.682-11.089 3.686-1.553z" })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("g", { fill: "white", transform: "translate(-12,-12)", children: [
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m12 24.4219v-16.015l11.591 11.619h-6.781l-.411.124z" }),
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m21.0845 25.0962-3.605 1.535-4.682-11.089 3.686-1.553z" })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("g", { fill: "currentColor", transform: "translate(-12,-12)", children: [
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m19.751 24.4155-1.844.774-3.1-7.374 1.841-.775z" }),
      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "m13 10.814v11.188l2.969-2.866.428-.139h4.768z" })
    ] })
  ] });
}
function CollaboratorHintDef() {
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { id: "cursor_hint", fill: "currentColor", d: "M -2,-5 2,0 -2,5 Z" });
}
function DebugSvgCopy({ id }) {
  const editor = useEditor();
  const [image, setImage] = (0, import_react23.useState)(null);
  const isInRoot = useValue("is in root", () => {
    const shape = editor.getShape(id);
    return shape?.parentId === editor.getCurrentPageId();
  }, [editor, id]);
  (0, import_react23.useEffect)(() => {
    if (!isInRoot)
      return;
    let latest = null;
    const unsubscribe = react("shape to svg", async () => {
      const renderId = Math.random();
      latest = renderId;
      const isSingleFrame = editor.isShapeOfType(id, "frame");
      const padding = isSingleFrame ? 0 : 10;
      let bounds = editor.getShapePageBounds(id);
      if (!bounds)
        return;
      bounds = bounds.clone().expandBy(padding);
      const result = await editor.getSvgString([id], {
        padding,
        background: editor.getInstanceState().exportBackground
      });
      if (latest !== renderId || !result)
        return;
      const svgDataUrl = `data:image/svg+xml;utf8,${encodeURIComponent(result.svg)}`;
      setImage({ src: svgDataUrl, bounds });
    });
    return () => {
      latest = null;
      unsubscribe();
    };
  }, [editor, id, isInRoot]);
  if (!isInRoot || !image)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("img", {
    src: image.src,
    width: image.bounds.width,
    height: image.bounds.height,
    referrerPolicy: "no-referrer",
    style: {
      position: "absolute",
      top: 0,
      left: 0,
      transform: `translate(${image.bounds.x}px, ${image.bounds.maxY + 12}px)`,
      outline: "1px solid black",
      maxWidth: "none"
    }
  });
}
function SelectionForegroundWrapper() {
  const editor = useEditor();
  const selectionRotation = useValue("selection rotation", () => editor.getSelectionRotation(), [
    editor
  ]);
  const selectionBounds = useValue("selection bounds", () => editor.getSelectionRotatedPageBounds(), [editor]);
  const { SelectionForeground } = useEditorComponents();
  if (!selectionBounds || !SelectionForeground)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectionForeground, { bounds: selectionBounds, rotation: selectionRotation });
}
function SelectionBackgroundWrapper() {
  const editor = useEditor();
  const selectionRotation = useValue("selection rotation", () => editor.getSelectionRotation(), [
    editor
  ]);
  const selectionBounds = useValue("selection bounds", () => editor.getSelectionRotatedPageBounds(), [editor]);
  const { SelectionBackground } = useEditorComponents();
  if (!selectionBounds || !SelectionBackground)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectionBackground, { bounds: selectionBounds, rotation: selectionRotation });
}
function OnTheCanvasWrapper() {
  const { OnTheCanvas } = useEditorComponents();
  if (!OnTheCanvas)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(OnTheCanvas, {});
}
function MovingCameraHitTestBlocker() {
  const editor = useEditor();
  const cameraState = useValue("camera state", () => editor.getCameraState(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", {
    className: (0, import_classnames.default)("tl-hit-test-blocker", {
      "tl-hit-test-blocker__hidden": cameraState === "idle"
    })
  });
}
var import_jsx_runtime8, import_classnames, import_react23;
var init_DefaultCanvas = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCanvas.mjs"() {
    import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm();
    init_dist_esm9();
    init_dist_esm2();
    import_classnames = __toESM(require_classnames(), 1);
    import_react23 = __toESM(require_react(), 1);
    init_useCanvasEvents();
    init_useCoarsePointer();
    init_useContainer();
    init_useDocumentEvents();
    init_useEditor();
    init_useEditorComponents();
    init_useFixSafariDoubleTapZoomPencilEvents();
    init_useGestureEvents();
    init_useHandleEvents();
    init_useScreenBounds();
    init_Mat();
    init_Vec();
    init_utils();
    init_debug_flags();
    init_dom();
    init_nearestMultiple();
    init_GeometryDebuggingView();
    init_LiveCollaborators();
    init_Shape();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCollaboratorHint.mjs
function DefaultCollaboratorHint({
  className,
  zoom,
  point,
  color,
  viewport: viewport2,
  opacity = 1
}) {
  const rSvg = (0, import_react24.useRef)(null);
  useTransform(rSvg, clamp(point.x, viewport2.minX + 5 / zoom, viewport2.maxX - 5 / zoom), clamp(point.y, viewport2.minY + 5 / zoom, viewport2.maxY - 5 / zoom), 1 / zoom, Vec.Angle(viewport2.center, point));
  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("svg", { ref: rSvg, className: (0, import_classnames2.default)("tl-overlays__item", className), children: [
    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("use", { href: "#cursor_hint", color, strokeWidth: 3, stroke: "var(--color-background)" }),
    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("use", { href: "#cursor_hint", color, opacity })
  ] });
}
var import_jsx_runtime9, import_classnames2, import_react24;
var init_DefaultCollaboratorHint = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCollaboratorHint.mjs"() {
    import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
    import_classnames2 = __toESM(require_classnames(), 1);
    import_react24 = __toESM(require_react(), 1);
    init_useTransform();
    init_Vec();
    init_utils();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCursor.mjs
var import_jsx_runtime10, import_classnames3, import_react25, DefaultCursor;
var init_DefaultCursor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultCursor.mjs"() {
    import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
    import_classnames3 = __toESM(require_classnames(), 1);
    import_react25 = __toESM(require_react(), 1);
    init_useTransform();
    DefaultCursor = (0, import_react25.memo)(function DefaultCursor2({
      className,
      zoom,
      point,
      color,
      name,
      chatMessage
    }) {
      const rCursor = (0, import_react25.useRef)(null);
      useTransform(rCursor, point?.x, point?.y, 1 / zoom);
      if (!point)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { ref: rCursor, className: (0, import_classnames3.default)("tl-overlays__item", className), children: [
        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("svg", { className: "tl-cursor", children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("use", { href: "#cursor", color }) }),
        chatMessage ? /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
          name && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "tl-nametag-title", style: { color }, children: name }),
          /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "tl-nametag-chat", style: { backgroundColor: color }, children: chatMessage })
        ] }) : name && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "tl-nametag", style: { backgroundColor: color }, children: name })
      ] });
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useSafeId.mjs
function useSafeId() {
  return (0, import_react26.useId)().replace(/:/g, "_");
}
var import_react26;
var init_useSafeId = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useSafeId.mjs"() {
    import_react26 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultGrid.mjs
function DefaultGrid({ x: x2, y: y2, z, size: size4 }) {
  const id = `grid_${useSafeId()}`;
  const editor = useEditor();
  const { gridSteps } = editor.options;
  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("svg", { className: "tl-grid", version: "1.1", xmlns: "http://www.w3.org/2000/svg", children: [
    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("defs", { children: gridSteps.map(({ min: min4, mid, step }, i2) => {
      const s2 = step * size4 * z;
      const xo = 0.5 + x2 * z;
      const yo = 0.5 + y2 * z;
      const gxo = xo > 0 ? xo % s2 : s2 + xo % s2;
      const gyo = yo > 0 ? yo % s2 : s2 + yo % s2;
      const opacity = z < mid ? modulate(z, [min4, mid], [0, 1]) : 1;
      return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("pattern", {
        id: `${id}_${step}`,
        width: s2,
        height: s2,
        patternUnits: "userSpaceOnUse",
        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("circle", { className: "tl-grid-dot", cx: gxo, cy: gyo, r: 1, opacity })
      }, i2);
    }) }),
    gridSteps.map(({ step }, i2) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("rect", { width: "100%", height: "100%", fill: `url(#${id}_${step})` }, i2))
  ] });
}
var import_jsx_runtime11;
var init_DefaultGrid = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultGrid.mjs"() {
    import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm2();
    init_useEditor();
    init_useSafeId();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultHandle.mjs
function DefaultHandle({ handle, isCoarse, className, zoom }) {
  const editor = useEditor();
  const br = (isCoarse ? editor.options.coarseHandleRadius : editor.options.handleRadius) / zoom;
  if (handle.type === "clone") {
    const fr2 = 3 / zoom;
    const path = `M0,${-fr2} A${fr2},${fr2} 0 0,1 0,${fr2}`;
    const index3 = SIDES.indexOf(handle.id);
    return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("g", { className: (0, import_classnames4.default)(`tl-handle tl-handle__${handle.type}`, className), children: [
      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("circle", { className: "tl-handle__bg", r: br }),
      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("path", { className: "tl-handle__fg", d: path, transform: `rotate(${-90 + 90 * index3})` })
    ] });
  }
  const fr = (handle.type === "create" && isCoarse ? 3 : 4) / Math.max(zoom, 0.25);
  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("g", { className: (0, import_classnames4.default)(`tl-handle tl-handle__${handle.type}`, className), children: [
    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("circle", { className: "tl-handle__bg", r: br }),
    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("circle", { className: "tl-handle__fg", r: fr })
  ] });
}
var import_jsx_runtime12, import_classnames4;
var init_DefaultHandle = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultHandle.mjs"() {
    import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
    import_classnames4 = __toESM(require_classnames(), 1);
    init_constants3();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultHandles.mjs
var import_jsx_runtime13, DefaultHandles;
var init_DefaultHandles = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultHandles.mjs"() {
    import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
    DefaultHandles = ({ children }) => {
      return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("svg", { className: "tl-user-handles tl-overlays__item", children });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultLoadingScreen.mjs
var import_jsx_runtime14, DefaultLoadingScreen;
var init_DefaultLoadingScreen = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultLoadingScreen.mjs"() {
    import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
    init_TldrawEditor();
    init_useEditorComponents();
    DefaultLoadingScreen = () => {
      const { Spinner: Spinner2 } = useEditorComponents();
      return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(LoadingScreen, { children: Spinner2 ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Spinner2, {}) : null });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/getSvgPathFromPoints.mjs
function getSvgPathFromPoints(points, closed = true) {
  const len = points.length;
  if (len < 2) {
    return "";
  }
  let a2 = points[0];
  let b2 = points[1];
  if (len === 2) {
    return `M${precise(a2)}L${precise(b2)}`;
  }
  let result = "";
  for (let i2 = 2, max3 = len - 1; i2 < max3; i2++) {
    a2 = points[i2];
    b2 = points[i2 + 1];
    result += average2(a2, b2);
  }
  if (closed) {
    return `M${average2(points[0], points[1])}Q${precise(points[1])}${average2(points[1], points[2])}T${result}${average2(points[len - 1], points[0])}${average2(points[0], points[1])}Z`;
  } else {
    return `M${precise(points[0])}Q${precise(points[1])}${average2(points[1], points[2])}${points.length > 3 ? "T" : ""}${result}L${precise(points[len - 1])}`;
  }
}
var init_getSvgPathFromPoints = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/getSvgPathFromPoints.mjs"() {
    init_utils();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultScribble.mjs
function DefaultScribble({ scribble, zoom, color, opacity, className }) {
  if (!scribble.points.length)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("svg", { className: className ? (0, import_classnames5.default)("tl-overlays__item", className) : className, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("path", {
    className: "tl-scribble",
    d: getSvgPathFromPoints(scribble.points, false),
    stroke: color ?? `var(--color-${scribble.color})`,
    fill: "none",
    strokeWidth: 8 / zoom,
    opacity: opacity ?? scribble.opacity
  }) });
}
var import_jsx_runtime15, import_classnames5;
var init_DefaultScribble = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultScribble.mjs"() {
    import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
    import_classnames5 = __toESM(require_classnames(), 1);
    init_getSvgPathFromPoints();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSelectionBackground.mjs
function DefaultSelectionBackground({ bounds, rotation }) {
  const rDiv = React7.useRef(null);
  useTransform(rDiv, bounds.x, bounds.y, 1, rotation);
  React7.useLayoutEffect(() => {
    const div2 = rDiv.current;
    if (!div2)
      return;
    div2.style.width = toDomPrecision(Math.max(1, bounds.width)) + "px";
    div2.style.height = toDomPrecision(Math.max(1, bounds.height)) + "px";
  }, [bounds.width, bounds.height]);
  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { ref: rDiv, className: "tl-selection__bg", draggable: false });
}
var import_jsx_runtime16, React7;
var init_DefaultSelectionBackground = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSelectionBackground.mjs"() {
    import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
    React7 = __toESM(require_react(), 1);
    init_useTransform();
    init_utils();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSelectionForeground.mjs
function DefaultSelectionForeground({ bounds, rotation }) {
  const editor = useEditor();
  const rSvg = (0, import_react27.useRef)(null);
  const onlyShape = useValue("only selected shape", () => editor.getOnlySelectedShape(), [editor]);
  const expandOutlineBy = onlyShape ? editor.getShapeUtil(onlyShape).expandSelectionOutlinePx(onlyShape) : 0;
  useTransform(rSvg, bounds?.x, bounds?.y, 1, rotation, {
    x: -expandOutlineBy,
    y: -expandOutlineBy
  });
  bounds = bounds.clone().expandBy(expandOutlineBy).zeroFix();
  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("svg", {
    ref: rSvg,
    className: "tl-overlays__item tl-selection__fg",
    "data-testid": "selection-foreground",
    children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("rect", {
      className: (0, import_classnames6.default)("tl-selection__fg__outline"),
      width: toDomPrecision(bounds.width),
      height: toDomPrecision(bounds.height)
    })
  });
}
var import_jsx_runtime17, import_classnames6, import_react27;
var init_DefaultSelectionForeground = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSelectionForeground.mjs"() {
    import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    import_classnames6 = __toESM(require_classnames(), 1);
    import_react27 = __toESM(require_react(), 1);
    init_useEditor();
    init_useTransform();
    init_utils();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeErrorFallback.mjs
var import_jsx_runtime18, DefaultShapeErrorFallback;
var init_DefaultShapeErrorFallback = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeErrorFallback.mjs"() {
    import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
    DefaultShapeErrorFallback = () => {
      return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: "tl-shape-error-boundary" });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicator.mjs
var import_jsx_runtime19, import_classnames7, import_react28, EvenInnererIndicator, InnerIndicator, DefaultShapeIndicator;
var init_DefaultShapeIndicator = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicator.mjs"() {
    import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    import_classnames7 = __toESM(require_classnames(), 1);
    import_react28 = __toESM(require_react(), 1);
    init_useEditor();
    init_useEditorComponents();
    init_ErrorBoundary();
    EvenInnererIndicator = ({ shape, util }) => {
      return useStateTracking("Indicator: " + shape.type, () => util.indicator(util.editor.store.unsafeGetWithoutCapture(shape.id)));
    };
    InnerIndicator = ({ editor, id }) => {
      const shape = useValue("shape for indicator", () => editor.store.get(id), [editor, id]);
      const { ShapeIndicatorErrorFallback } = useEditorComponents();
      if (!shape || shape.isLocked)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(OptionalErrorBoundary, {
        fallback: ShapeIndicatorErrorFallback,
        onError: (error2) => editor.annotateError(error2, { origin: "react.shapeIndicator", willCrashApp: false }),
        children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(EvenInnererIndicator, { shape, util: editor.getShapeUtil(shape) }, shape.id)
      });
    };
    DefaultShapeIndicator = (0, import_react28.memo)(function DefaultShapeIndicator2({
      shapeId,
      className,
      color,
      hidden,
      opacity
    }) {
      const editor = useEditor();
      const rIndicator = (0, import_react28.useRef)(null);
      useQuickReactor("indicator transform", () => {
        const elm = rIndicator.current;
        if (!elm)
          return;
        const pageTransform = editor.getShapePageTransform(shapeId);
        if (!pageTransform)
          return;
        elm.style.setProperty("transform", pageTransform.toCssString());
      }, [editor, shapeId]);
      (0, import_react28.useLayoutEffect)(() => {
        const elm = rIndicator.current;
        if (!elm)
          return;
        elm.style.setProperty("display", hidden ? "none" : "block");
      }, [hidden]);
      return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("svg", { ref: rIndicator, className: (0, import_classnames7.default)("tl-overlays__item", className), children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("g", { className: "tl-shape-indicator", stroke: color ?? "var(--color-selected)", opacity, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(InnerIndicator, { editor, id: shapeId }) }) });
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicatorErrorFallback.mjs
var import_jsx_runtime20, DefaultShapeIndicatorErrorFallback;
var init_DefaultShapeIndicatorErrorFallback = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicatorErrorFallback.mjs"() {
    import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
    DefaultShapeIndicatorErrorFallback = () => {
      return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("circle", { cx: 4, cy: 4, r: 8, strokeWidth: "1", stroke: "red" });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicators.mjs
var import_jsx_runtime21, import_react29, DefaultShapeIndicators;
var init_DefaultShapeIndicators = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultShapeIndicators.mjs"() {
    import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    import_react29 = __toESM(require_react(), 1);
    init_useEditor();
    init_useEditorComponents();
    DefaultShapeIndicators = (0, import_react29.memo)(function DefaultShapeIndicators2() {
      const editor = useEditor();
      const rPreviousSelectedShapeIds = (0, import_react29.useRef)(/* @__PURE__ */ new Set());
      const idsToDisplay = useValue("should display selected ids", () => {
        const prev = rPreviousSelectedShapeIds.current;
        const next = /* @__PURE__ */ new Set();
        if (editor.isInAny("select.idle", "select.brushing", "select.scribble_brushing", "select.editing_shape", "select.pointing_shape", "select.pointing_selection", "select.pointing_handle") && !editor.getInstanceState().isChangingStyle) {
          const selected = editor.getSelectedShapeIds();
          for (const id of selected) {
            next.add(id);
          }
          if (editor.isInAny("select.idle", "select.editing_shape")) {
            const instanceState = editor.getInstanceState();
            if (instanceState.isHoveringCanvas && !instanceState.isCoarsePointer) {
              const hovered = editor.getHoveredShapeId();
              if (hovered)
                next.add(hovered);
            }
          }
        }
        if (prev.size !== next.size) {
          rPreviousSelectedShapeIds.current = next;
          return next;
        }
        for (const id of next) {
          if (!prev.has(id)) {
            rPreviousSelectedShapeIds.current = next;
            return next;
          }
        }
        return prev;
      }, [editor]);
      const renderingShapes = useValue("rendering shapes", () => editor.getRenderingShapes(), [editor]);
      const { ShapeIndicator } = useEditorComponents();
      if (!ShapeIndicator)
        return null;
      return renderingShapes.map(({ id }) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(ShapeIndicator, { shapeId: id, hidden: !idsToDisplay.has(id) }, id + "_indicator"));
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSnapIndictor.mjs
function PointsSnapIndicator({ points, zoom }) {
  const l2 = 2.5 / zoom;
  const minX = points.reduce((acc, p2) => Math.min(acc, p2.x), Infinity);
  const maxX = points.reduce((acc, p2) => Math.max(acc, p2.x), -Infinity);
  const minY = points.reduce((acc, p2) => Math.min(acc, p2.y), Infinity);
  const maxY = points.reduce((acc, p2) => Math.max(acc, p2.y), -Infinity);
  const useNWtoSEdireciton = points.some((p2) => p2.x === minX && p2.y === minY);
  let firstX, firstY, secondX, secondY;
  if (useNWtoSEdireciton) {
    firstX = minX;
    firstY = minY;
    secondX = maxX;
    secondY = maxY;
  } else {
    firstX = minX;
    firstY = maxY;
    secondX = maxX;
    secondY = minY;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("g", { className: "tl-snap-indicator", stroke: "lime", children: [
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", { x1: firstX, y1: firstY, x2: secondX, y2: secondY }),
    points.map((p2, i2) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("g", { transform: `translate(${p2.x},${p2.y})`, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", {
      className: "tl-snap-point",
      d: `M ${-l2},${-l2} L ${l2},${l2} M ${-l2},${l2} L ${l2},${-l2}`
    }) }, i2))
  ] });
}
function GapsSnapIndicator({ gaps, direction, zoom }) {
  const l2 = 3.5 / zoom;
  let edgeIntersection = [-Infinity, Infinity];
  let nextEdgeIntersection = null;
  const horizontal = direction === "horizontal";
  for (const gap of gaps) {
    nextEdgeIntersection = rangeIntersection(edgeIntersection[0], edgeIntersection[1], horizontal ? gap.startEdge[0].y : gap.startEdge[0].x, horizontal ? gap.startEdge[1].y : gap.startEdge[1].x);
    if (nextEdgeIntersection) {
      edgeIntersection = nextEdgeIntersection;
    } else {
      continue;
    }
    nextEdgeIntersection = rangeIntersection(edgeIntersection[0], edgeIntersection[1], horizontal ? gap.endEdge[0].y : gap.endEdge[0].x, horizontal ? gap.endEdge[1].y : gap.endEdge[1].x);
    if (nextEdgeIntersection) {
      edgeIntersection = nextEdgeIntersection;
    } else {
      continue;
    }
  }
  if (edgeIntersection === null) {
    return null;
  }
  const midPoint = (edgeIntersection[0] + edgeIntersection[1]) / 2;
  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("g", { className: "tl-snap-indicator", stroke: "cyan", children: gaps.map(({ startEdge, endEdge }, i2) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(React8.Fragment, { children: horizontal ? /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: startEdge[0].x,
      y1: midPoint - 2 * l2,
      x2: startEdge[1].x,
      y2: midPoint + 2 * l2
    }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: endEdge[0].x,
      y1: midPoint - 2 * l2,
      x2: endEdge[1].x,
      y2: midPoint + 2 * l2
    }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", { x1: startEdge[0].x, y1: midPoint, x2: endEdge[0].x, y2: midPoint }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: (startEdge[0].x + endEdge[0].x) / 2,
      y1: midPoint - l2,
      x2: (startEdge[0].x + endEdge[0].x) / 2,
      y2: midPoint + l2
    })
  ] }) : /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: midPoint - 2 * l2,
      y1: startEdge[0].y,
      x2: midPoint + 2 * l2,
      y2: startEdge[1].y
    }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: midPoint - 2 * l2,
      y1: endEdge[0].y,
      x2: midPoint + 2 * l2,
      y2: endEdge[1].y
    }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", { x1: midPoint, y1: startEdge[0].y, x2: midPoint, y2: endEdge[0].y }),
    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("line", {
      x1: midPoint - l2,
      y1: (startEdge[0].y + endEdge[0].y) / 2,
      x2: midPoint + l2,
      y2: (startEdge[0].y + endEdge[0].y) / 2
    })
  ] }) }, i2)) });
}
function DefaultSnapIndicator({ className, line, zoom }) {
  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("svg", { className: (0, import_classnames8.default)("tl-overlays__item", className), children: line.type === "points" ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(PointsSnapIndicator, { ...line, zoom }) : line.type === "gaps" ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(GapsSnapIndicator, { ...line, zoom }) : null });
}
var import_jsx_runtime22, import_classnames8, React8;
var init_DefaultSnapIndictor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSnapIndictor.mjs"() {
    import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
    import_classnames8 = __toESM(require_classnames(), 1);
    React8 = __toESM(require_react(), 1);
    init_utils();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSpinner.mjs
function DefaultSpinner() {
  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("svg", { width: 16, height: 16, viewBox: "0 0 16 16", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("g", { strokeWidth: 2, fill: "none", fillRule: "evenodd", children: [
    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("circle", { strokeOpacity: 0.25, cx: 8, cy: 8, r: 7, stroke: "currentColor" }),
    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { strokeLinecap: "round", d: "M15 8c0-4.5-4.5-7-7-7", stroke: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("animateTransform", {
      attributeName: "transform",
      type: "rotate",
      from: "0 8 8",
      to: "360 8 8",
      dur: "1s",
      repeatCount: "indefinite"
    }) })
  ] }) });
}
var import_jsx_runtime23;
var init_DefaultSpinner = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSpinner.mjs"() {
    import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSvgDefs.mjs
var DefaultSvgDefs;
var init_DefaultSvgDefs = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultSvgDefs.mjs"() {
    DefaultSvgDefs = () => {
      return null;
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useIdentity.mjs
function useIdentity(value, isEqual2) {
  const ref = (0, import_react30.useRef)(value);
  if (isEqual2(value, ref.current)) {
    return ref.current;
  }
  ref.current = value;
  return value;
}
function useShallowArrayIdentity(arr) {
  return useIdentity(arr, areArraysShallowEqual);
}
function useShallowObjectIdentity(obj) {
  return useIdentity(obj, areNullableObjectsShallowEqual);
}
var import_react30, areNullableObjectsShallowEqual;
var init_useIdentity = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useIdentity.mjs"() {
    init_dist_esm2();
    import_react30 = __toESM(require_react(), 1);
    areNullableObjectsShallowEqual = (a2, b2) => {
      a2 ?? (a2 = null);
      b2 ?? (b2 = null);
      if (a2 === b2) {
        return true;
      }
      if (!a2 || !b2) {
        return false;
      }
      return areObjectsShallowEqual(a2, b2);
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useEditorComponents.mjs
function EditorComponentsProvider({
  overrides = {},
  children
}) {
  const _overrides = useShallowObjectIdentity(overrides);
  const value = (0, import_react31.useMemo)(() => ({
    Background: DefaultBackground,
    SvgDefs: DefaultSvgDefs,
    Brush: DefaultBrush,
    ZoomBrush: DefaultBrush,
    CollaboratorBrush: DefaultBrush,
    Cursor: DefaultCursor,
    CollaboratorCursor: DefaultCursor,
    CollaboratorHint: DefaultCollaboratorHint,
    CollaboratorShapeIndicator: DefaultShapeIndicator,
    Grid: DefaultGrid,
    Scribble: DefaultScribble,
    SnapIndicator: DefaultSnapIndicator,
    Handles: DefaultHandles,
    Handle: DefaultHandle,
    CollaboratorScribble: DefaultScribble,
    ErrorFallback: DefaultErrorFallback,
    ShapeErrorFallback: DefaultShapeErrorFallback,
    ShapeIndicatorErrorFallback: DefaultShapeIndicatorErrorFallback,
    Spinner: DefaultSpinner,
    SelectionBackground: DefaultSelectionBackground,
    SelectionForeground: DefaultSelectionForeground,
    ShapeIndicators: DefaultShapeIndicators,
    ShapeIndicator: DefaultShapeIndicator,
    OnTheCanvas: null,
    InFrontOfTheCanvas: null,
    Canvas: DefaultCanvas,
    LoadingScreen: DefaultLoadingScreen,
    ..._overrides
  }), [_overrides]);
  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(EditorComponentsContext.Provider, { value, children });
}
function useEditorComponents() {
  const components = (0, import_react31.useContext)(EditorComponentsContext);
  if (!components) {
    throw new Error("useEditorComponents must be used inside of <EditorComponentsProvider />");
  }
  return components;
}
var import_jsx_runtime24, import_react31, EditorComponentsContext;
var init_useEditorComponents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useEditorComponents.mjs"() {
    import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
    import_react31 = __toESM(require_react(), 1);
    init_DefaultBackground();
    init_DefaultBrush();
    init_DefaultCanvas();
    init_DefaultCollaboratorHint();
    init_DefaultCursor();
    init_DefaultErrorFallback();
    init_DefaultGrid();
    init_DefaultHandle();
    init_DefaultHandles();
    init_DefaultLoadingScreen();
    init_DefaultScribble();
    init_DefaultSelectionBackground();
    init_DefaultSelectionForeground();
    init_DefaultShapeErrorFallback();
    init_DefaultShapeIndicator();
    init_DefaultShapeIndicatorErrorFallback();
    init_DefaultShapeIndicators();
    init_DefaultSnapIndictor();
    init_DefaultSpinner();
    init_DefaultSvgDefs();
    init_useIdentity();
    EditorComponentsContext = (0, import_react31.createContext)(null);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/runtime.mjs
var runtime;
var init_runtime = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/runtime.mjs"() {
    runtime = {
      openWindow: (url, target) => window.open(url, target, "noopener noreferrer"),
      refreshPage: () => window.location.reload(),
      hardReset: async () => await window.__tldraw__hardReset?.()
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/hardResetEditor.mjs
function hardResetEditor() {
  runtime.hardReset();
}
var init_hardResetEditor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/hardResetEditor.mjs"() {
    init_runtime();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/refreshPage.mjs
function refreshPage() {
  runtime.refreshPage();
}
var init_refreshPage = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/refreshPage.mjs"() {
    init_runtime();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultErrorFallback.mjs
var import_jsx_runtime25, import_classnames9, import_react32, BASE_ERROR_URL, DefaultErrorFallback;
var init_DefaultErrorFallback = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/default-components/DefaultErrorFallback.mjs"() {
    import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    init_dist_esm2();
    import_classnames9 = __toESM(require_classnames(), 1);
    import_react32 = __toESM(require_react(), 1);
    init_useEditor();
    init_useEditorComponents();
    init_hardResetEditor();
    init_refreshPage();
    init_ErrorBoundary();
    BASE_ERROR_URL = "https://github.com/tldraw/tldraw/issues/new";
    DefaultErrorFallback = ({ error: error2, editor }) => {
      const containerRef = (0, import_react32.useRef)(null);
      const [shouldShowError, setShouldShowError] = (0, import_react32.useState)(false);
      const [didCopy, setDidCopy] = (0, import_react32.useState)(false);
      const [shouldShowResetConfirmation, setShouldShowResetConfirmation] = (0, import_react32.useState)(false);
      let Canvas = null;
      try {
        const components = useEditorComponents();
        Canvas = components.Canvas ?? null;
      } catch (e2) {
      }
      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
      const errorStack = error2 instanceof Error ? error2.stack : null;
      const isDarkModeFromApp = useValue("isDarkMode", () => {
        try {
          if (editor) {
            return editor.user.getIsDarkMode();
          }
        } catch {
        }
        return null;
      }, [editor]);
      const [isDarkMode, setIsDarkMode] = (0, import_react32.useState)(null);
      (0, import_react32.useLayoutEffect)(() => {
        if (isDarkModeFromApp !== null) {
          setIsDarkMode(isDarkModeFromApp);
        }
        let parent = containerRef.current?.parentElement;
        let foundParentThemeClass = false;
        while (parent) {
          if (parent.classList.contains("tl-theme__dark") || parent.classList.contains("tl-theme__light")) {
            foundParentThemeClass = true;
            break;
          }
          parent = parent.parentElement;
        }
        if (foundParentThemeClass) {
          setIsDarkMode(null);
          return;
        }
        if (typeof window !== "undefined" && "matchMedia" in window) {
          setIsDarkMode(window.matchMedia("(prefers-color-scheme: dark)").matches);
        }
      }, [isDarkModeFromApp]);
      (0, import_react32.useEffect)(() => {
        if (didCopy) {
          const timeout = editor?.timers.setTimeout(() => {
            setDidCopy(false);
          }, 2e3);
          return () => clearTimeout(timeout);
        }
      }, [didCopy, editor]);
      const copyError = () => {
        const textarea = document.createElement("textarea");
        textarea.value = errorStack ?? errorMessage;
        document.body.appendChild(textarea);
        textarea.select();
        document.execCommand("copy");
        textarea.remove();
        setDidCopy(true);
      };
      const refresh = () => {
        refreshPage();
      };
      const resetLocalState = async () => {
        hardResetEditor();
      };
      const url = new URL(BASE_ERROR_URL);
      url.searchParams.set("title", errorMessage);
      url.searchParams.set("labels", `bug`);
      url.searchParams.set("body", `Hey, I ran into an error while using tldraw:

\`\`\`js
${errorStack ?? errorMessage}
\`\`\`

My browser: ${navigator.userAgent}`);
      return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", {
        ref: containerRef,
        className: (0, import_classnames9.default)("tl-container tl-error-boundary", isDarkMode === null ? "" : isDarkMode ? "tl-theme__dark" : "tl-theme__light"),
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: "tl-error-boundary__overlay" }),
          editor && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(ErrorBoundary, { onError: noop, fallback: () => null, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(EditorContext.Provider, { value: editor, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: "tl-overlay tl-error-boundary__canvas", children: Canvas ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(Canvas, {}) : null }) }) }),
          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", {
            className: (0, import_classnames9.default)("tl-modal", "tl-error-boundary__content", {
              "tl-error-boundary__content__expanded": shouldShowError && !shouldShowResetConfirmation
            }),
            children: shouldShowResetConfirmation ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_jsx_runtime25.Fragment, { children: [
              /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("h2", { children: "Are you sure?" }),
              /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("p", { children: "Resetting your data will delete your drawing and cannot be undone." }),
              /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", { className: "tl-error-boundary__content__actions", children: [
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { onClick: () => setShouldShowResetConfirmation(false), children: "Cancel" }),
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { className: "tl-error-boundary__reset", onClick: resetLocalState, children: "Reset data" })
              ] })
            ] }) : /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_jsx_runtime25.Fragment, { children: [
              /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("h2", { children: "Something's gone wrong." }),
              /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("p", { children: [
                "Sorry, we encountered an error. Please refresh the page to continue. If you keep seeing this error, you can ",
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("a", { href: url.toString(), children: "create a GitHub issue" }),
                " or",
                " ",
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("a", { href: "https://discord.gg/Cq6cPsTfNy", children: "ask for help on Discord" }),
                "."
              ] }),
              shouldShowError && /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_jsx_runtime25.Fragment, { children: [
                "Message:",
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("h4", { children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("code", { children: errorMessage }) }),
                "Stack trace:",
                /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", { className: "tl-error-boundary__content__error", children: [
                  /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("pre", { children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("code", { children: errorStack ?? errorMessage }) }),
                  /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { onClick: copyError, children: didCopy ? "Copied!" : "Copy" })
                ] })
              ] }),
              /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", { className: "tl-error-boundary__content__actions", children: [
                /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { onClick: () => setShouldShowError(!shouldShowError), children: shouldShowError ? "Hide details" : "Show details" }),
                /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", { className: "tl-error-boundary__content__actions__group", children: [
                  /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", {
                    className: "tl-error-boundary__reset",
                    onClick: () => setShouldShowResetConfirmation(true),
                    children: "Reset data"
                  }),
                  /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("button", { className: "tl-error-boundary__refresh", onClick: refresh, children: "Refresh Page" })
                ] })
              ] })
            ] })
          })
        ]
      });
    };
  }
});

// node_modules/@tldraw/editor/node_modules/nanoid/index.browser.js
var nanoid3;
var init_index_browser3 = __esm({
  "node_modules/@tldraw/editor/node_modules/nanoid/index.browser.js"() {
    nanoid3 = (size4 = 21) => crypto.getRandomValues(new Uint8Array(size4)).reduce((id, byte) => {
      byte &= 63;
      if (byte < 36) {
        id += byte.toString(36);
      } else if (byte < 62) {
        id += (byte - 26).toString(36).toUpperCase();
      } else if (byte > 62) {
        id += "-";
      } else {
        id += "_";
      }
      return id;
    }, "");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/uniqueId.mjs
function uniqueId() {
  return nanoid3();
}
var init_uniqueId = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/uniqueId.mjs"() {
    init_index_browser3();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/TLUserPreferences.mjs
function migrateSnapshot(data) {
  if (data.version < Versions13.AddAnimationSpeed) {
    data.user.animationSpeed = 1;
  }
  if (data.version < Versions13.AddIsSnapMode) {
    data.user.isSnapMode = false;
  }
  if (data.version < Versions13.MakeFieldsNullable) {
  }
  if (data.version < Versions13.AddEdgeScrollSpeed) {
    data.user.edgeScrollSpeed = 1;
  }
  if (data.version < Versions13.AddExcalidrawSelectMode) {
    data.user.isWrapMode = false;
  }
  if (data.version < Versions13.AllowSystemColorScheme) {
    if (data.user.isDarkMode === true) {
      data.user.colorScheme = "dark";
    } else if (data.user.isDarkMode === false) {
      data.user.colorScheme = "light";
    }
    delete data.user.isDarkMode;
  }
  if (data.version < Versions13.AddDynamicSizeMode) {
    data.user.isDynamicSizeMode = false;
  }
  if (data.version < Versions13.AddPasteAtCursor) {
    data.user.isPasteAtCursorMode = false;
  }
  data.version = CURRENT_VERSION;
}
function getRandomColor() {
  return USER_COLORS[Math.floor(Math.random() * USER_COLORS.length)];
}
function userPrefersReducedMotion() {
  if (typeof window !== "undefined" && "matchMedia" in window) {
    return window.matchMedia?.("(prefers-reduced-motion: reduce)")?.matches ?? false;
  }
  return false;
}
function getFreshUserPreferences() {
  return {
    id: uniqueId(),
    color: getRandomColor()
  };
}
function migrateUserPreferences(userData) {
  if (userData === null || typeof userData !== "object") {
    return getFreshUserPreferences();
  }
  if (!("version" in userData) || !("user" in userData) || typeof userData.version !== "number") {
    return getFreshUserPreferences();
  }
  const snapshot = structuredClone2(userData);
  migrateSnapshot(snapshot);
  try {
    return userTypeValidator.validate(snapshot.user);
  } catch (e2) {
    return getFreshUserPreferences();
  }
}
function loadUserPreferences() {
  const userData = JSON.parse(getFromLocalStorage(USER_DATA_KEY) || "null") ?? null;
  return migrateUserPreferences(userData);
}
function storeUserPreferences() {
  setInLocalStorage(USER_DATA_KEY, JSON.stringify({
    version: CURRENT_VERSION,
    user: globalUserPreferences.get()
  }));
}
function setUserPreferences(user) {
  userTypeValidator.validate(user);
  globalUserPreferences.set(user);
  storeUserPreferences();
  broadcastUserPreferencesChange();
}
function getBroadcastOrigin() {
  if (_broadcastOrigin === null) {
    _broadcastOrigin = uniqueId();
  }
  return _broadcastOrigin;
}
function broadcastUserPreferencesChange() {
  channel?.postMessage({
    type: broadcastEventKey,
    origin: getBroadcastOrigin(),
    data: {
      user: getUserPreferences(),
      version: CURRENT_VERSION
    }
  });
}
function getUserPreferences() {
  let prefs = globalUserPreferences.get();
  if (!prefs) {
    prefs = loadUserPreferences();
    setUserPreferences(prefs);
  }
  return prefs;
}
var USER_DATA_KEY, userTypeValidator, Versions13, CURRENT_VERSION, USER_COLORS, defaultUserPreferences, globalUserPreferences, isTest3, channel, _broadcastOrigin, broadcastEventKey;
var init_TLUserPreferences = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/TLUserPreferences.mjs"() {
    init_dist_esm();
    init_dist_esm8();
    init_dist_esm2();
    init_dist_esm6();
    init_uniqueId();
    USER_DATA_KEY = "TLDRAW_USER_DATA_v3";
    userTypeValidator = validation_exports.object({
      id: validation_exports.string,
      name: validation_exports.string.nullable().optional(),
      locale: validation_exports.string.nullable().optional(),
      color: validation_exports.string.nullable().optional(),
      colorScheme: validation_exports.literalEnum("light", "dark", "system").optional(),
      animationSpeed: validation_exports.number.nullable().optional(),
      edgeScrollSpeed: validation_exports.number.nullable().optional(),
      isSnapMode: validation_exports.boolean.nullable().optional(),
      isWrapMode: validation_exports.boolean.nullable().optional(),
      isDynamicSizeMode: validation_exports.boolean.nullable().optional(),
      isPasteAtCursorMode: validation_exports.boolean.nullable().optional()
    });
    Versions13 = {
      AddAnimationSpeed: 1,
      AddIsSnapMode: 2,
      MakeFieldsNullable: 3,
      AddEdgeScrollSpeed: 4,
      AddExcalidrawSelectMode: 5,
      AddDynamicSizeMode: 6,
      AllowSystemColorScheme: 7,
      AddPasteAtCursor: 8
    };
    CURRENT_VERSION = Math.max(...Object.values(Versions13));
    USER_COLORS = [
      "#FF802B",
      "#EC5E41",
      "#F2555A",
      "#F04F88",
      "#E34BA9",
      "#BD54C6",
      "#9D5BD2",
      "#7B66DC",
      "#02B1CC",
      "#11B3A3",
      "#39B178",
      "#55B467"
    ];
    defaultUserPreferences = Object.freeze({
      name: "New User",
      locale: getDefaultTranslationLocale(),
      color: getRandomColor(),
      edgeScrollSpeed: 1,
      animationSpeed: userPrefersReducedMotion() ? 0 : 1,
      isSnapMode: false,
      isWrapMode: false,
      isDynamicSizeMode: false,
      isPasteAtCursorMode: false,
      colorScheme: "system"
    });
    globalUserPreferences = atom2("globalUserData", null);
    isTest3 = typeof process !== "undefined" && false;
    channel = typeof BroadcastChannel !== "undefined" && !isTest3 ? new BroadcastChannel("tldraw-user-sync") : null;
    channel?.addEventListener("message", (e2) => {
      const data = e2.data;
      if (data?.type === broadcastEventKey && data?.origin !== getBroadcastOrigin()) {
        globalUserPreferences.set(migrateUserPreferences(data.data));
      }
    });
    _broadcastOrigin = null;
    broadcastEventKey = "tldraw-user-preferences-change";
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/createTLUser.mjs
function createTLUser(opts = {}) {
  return {
    userPreferences: opts.userPreferences ?? defaultLocalStorageUserPrefs,
    setUserPreferences: opts.setUserPreferences ?? setUserPreferences
  };
}
var import_react33, defaultLocalStorageUserPrefs;
var init_createTLUser = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/createTLUser.mjs"() {
    init_dist_esm();
    init_dist_esm9();
    import_react33 = __toESM(require_react(), 1);
    init_useIdentity();
    init_TLUserPreferences();
    defaultLocalStorageUserPrefs = computed("defaultLocalStorageUserPrefs", () => getUserPreferences());
  }
});

// node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({
  "node_modules/eventemitter3/index.js"(exports, module2) {
    "use strict";
    var has = Object.prototype.hasOwnProperty;
    var prefix = "~";
    function Events() {
    }
    if (Object.create) {
      Events.prototype = /* @__PURE__ */ Object.create(null);
      if (!new Events().__proto__)
        prefix = false;
    }
    function EE(fn3, context, once) {
      this.fn = fn3;
      this.context = context;
      this.once = once || false;
    }
    function addListener(emitter, event, fn3, context, once) {
      if (typeof fn3 !== "function") {
        throw new TypeError("The listener must be a function");
      }
      var listener = new EE(fn3, context || emitter, once), evt = prefix ? prefix + event : event;
      if (!emitter._events[evt])
        emitter._events[evt] = listener, emitter._eventsCount++;
      else if (!emitter._events[evt].fn)
        emitter._events[evt].push(listener);
      else
        emitter._events[evt] = [emitter._events[evt], listener];
      return emitter;
    }
    function clearEvent(emitter, evt) {
      if (--emitter._eventsCount === 0)
        emitter._events = new Events();
      else
        delete emitter._events[evt];
    }
    function EventEmitter2() {
      this._events = new Events();
      this._eventsCount = 0;
    }
    EventEmitter2.prototype.eventNames = function eventNames() {
      var names = [], events, name;
      if (this._eventsCount === 0)
        return names;
      for (name in events = this._events) {
        if (has.call(events, name))
          names.push(prefix ? name.slice(1) : name);
      }
      if (Object.getOwnPropertySymbols) {
        return names.concat(Object.getOwnPropertySymbols(events));
      }
      return names;
    };
    EventEmitter2.prototype.listeners = function listeners(event) {
      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
      if (!handlers)
        return [];
      if (handlers.fn)
        return [handlers.fn];
      for (var i2 = 0, l2 = handlers.length, ee2 = new Array(l2); i2 < l2; i2++) {
        ee2[i2] = handlers[i2].fn;
      }
      return ee2;
    };
    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
      if (!listeners)
        return 0;
      if (listeners.fn)
        return 1;
      return listeners.length;
    };
    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt])
        return false;
      var listeners = this._events[evt], len = arguments.length, args, i2;
      if (listeners.fn) {
        if (listeners.once)
          this.removeListener(event, listeners.fn, void 0, true);
        switch (len) {
          case 1:
            return listeners.fn.call(listeners.context), true;
          case 2:
            return listeners.fn.call(listeners.context, a1), true;
          case 3:
            return listeners.fn.call(listeners.context, a1, a2), true;
          case 4:
            return listeners.fn.call(listeners.context, a1, a2, a3), true;
          case 5:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
          case 6:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
        }
        for (i2 = 1, args = new Array(len - 1); i2 < len; i2++) {
          args[i2 - 1] = arguments[i2];
        }
        listeners.fn.apply(listeners.context, args);
      } else {
        var length = listeners.length, j2;
        for (i2 = 0; i2 < length; i2++) {
          if (listeners[i2].once)
            this.removeListener(event, listeners[i2].fn, void 0, true);
          switch (len) {
            case 1:
              listeners[i2].fn.call(listeners[i2].context);
              break;
            case 2:
              listeners[i2].fn.call(listeners[i2].context, a1);
              break;
            case 3:
              listeners[i2].fn.call(listeners[i2].context, a1, a2);
              break;
            case 4:
              listeners[i2].fn.call(listeners[i2].context, a1, a2, a3);
              break;
            default:
              if (!args)
                for (j2 = 1, args = new Array(len - 1); j2 < len; j2++) {
                  args[j2 - 1] = arguments[j2];
                }
              listeners[i2].fn.apply(listeners[i2].context, args);
          }
        }
      }
      return true;
    };
    EventEmitter2.prototype.on = function on(event, fn3, context) {
      return addListener(this, event, fn3, context, false);
    };
    EventEmitter2.prototype.once = function once(event, fn3, context) {
      return addListener(this, event, fn3, context, true);
    };
    EventEmitter2.prototype.removeListener = function removeListener(event, fn3, context, once) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt])
        return this;
      if (!fn3) {
        clearEvent(this, evt);
        return this;
      }
      var listeners = this._events[evt];
      if (listeners.fn) {
        if (listeners.fn === fn3 && (!once || listeners.once) && (!context || listeners.context === context)) {
          clearEvent(this, evt);
        }
      } else {
        for (var i2 = 0, events = [], length = listeners.length; i2 < length; i2++) {
          if (listeners[i2].fn !== fn3 || once && !listeners[i2].once || context && listeners[i2].context !== context) {
            events.push(listeners[i2]);
          }
        }
        if (events.length)
          this._events[evt] = events.length === 1 ? events[0] : events;
        else
          clearEvent(this, evt);
      }
      return this;
    };
    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
      var evt;
      if (event) {
        evt = prefix ? prefix + event : event;
        if (this._events[evt])
          clearEvent(this, evt);
      } else {
        this._events = new Events();
        this._eventsCount = 0;
      }
      return this;
    };
    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
    EventEmitter2.prefixed = prefix;
    EventEmitter2.EventEmitter = EventEmitter2;
    if (typeof module2 !== "undefined") {
      module2.exports = EventEmitter2;
    }
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/TLSessionStateSnapshot.mjs
function iOS() {
  if (!window2)
    return false;
  return ["iPad Simulator", "iPhone Simulator", "iPod Simulator", "iPad", "iPhone", "iPod"].includes(window2.navigator.platform) || window2.navigator.userAgent.includes("Mac") && "ontouchend" in document;
}
function migrate(snapshot) {
  if (snapshot.version < Versions14.Initial) {
  }
  snapshot.version = CURRENT_SESSION_STATE_SNAPSHOT_VERSION;
}
function migrateAndValidateSessionStateSnapshot(state) {
  if (!state || typeof state !== "object") {
    console.warn("Invalid instance state");
    return null;
  }
  if (!("version" in state) || typeof state.version !== "number") {
    console.warn("No version in instance state");
    return null;
  }
  if (state.version !== CURRENT_SESSION_STATE_SNAPSHOT_VERSION) {
    state = structuredClone2(state);
    migrate(state);
  }
  try {
    return sessionStateSnapshotValidator.validate(state);
  } catch (e2) {
    console.warn(e2);
    return null;
  }
}
function createSessionStateSnapshotSignal(store) {
  const $allPageIds = store.query.ids("page");
  return computed("sessionStateSnapshot", () => {
    const instanceState = store.get(TLINSTANCE_ID);
    if (!instanceState)
      return null;
    const allPageIds = [...$allPageIds.get()];
    return {
      version: CURRENT_SESSION_STATE_SNAPSHOT_VERSION,
      currentPageId: instanceState.currentPageId,
      exportBackground: instanceState.exportBackground,
      isFocusMode: instanceState.isFocusMode,
      isDebugMode: instanceState.isDebugMode,
      isToolLocked: instanceState.isToolLocked,
      isGridMode: instanceState.isGridMode,
      pageStates: allPageIds.map((id) => {
        const ps = store.get(InstancePageStateRecordType.createId(id));
        const camera = store.get(CameraRecordType.createId(id));
        return {
          pageId: id,
          camera: {
            x: camera?.x ?? 0,
            y: camera?.y ?? 0,
            z: camera?.z ?? 1
          },
          selectedShapeIds: ps?.selectedShapeIds ?? [],
          focusedGroupId: ps?.focusedGroupId ?? null
        };
      })
    };
  });
}
function loadSessionStateSnapshotIntoStore(store, snapshot) {
  const res = migrateAndValidateSessionStateSnapshot(snapshot);
  if (!res)
    return;
  const instanceState = store.schema.types.instance.create({
    id: TLINSTANCE_ID,
    ...pluckPreservingValues(store.get(TLINSTANCE_ID)),
    currentPageId: res.currentPageId,
    isDebugMode: res.isDebugMode,
    isFocusMode: res.isFocusMode,
    isToolLocked: res.isToolLocked,
    isGridMode: res.isGridMode,
    exportBackground: res.exportBackground
  });
  const allPageStatesAndCameras = store.allRecords().filter((r2) => r2.typeName === "instance_page_state" || r2.typeName === "camera");
  store.atomic(() => {
    store.remove(allPageStatesAndCameras.map((r2) => r2.id));
    for (const ps of res.pageStates) {
      store.put([
        CameraRecordType.create({
          id: CameraRecordType.createId(ps.pageId),
          x: ps.camera.x,
          y: ps.camera.y,
          z: ps.camera.z
        }),
        InstancePageStateRecordType.create({
          id: InstancePageStateRecordType.createId(ps.pageId),
          pageId: ps.pageId,
          selectedShapeIds: ps.selectedShapeIds,
          focusedGroupId: ps.focusedGroupId
        })
      ]);
    }
    store.put([instanceState]);
    store.ensureStoreIsUsable();
  });
}
function extractSessionStateFromLegacySnapshot(store) {
  const instanceRecords = [];
  for (const record of Object.values(store)) {
    if (record.typeName?.match(/^(instance.*|pointer|camera)$/)) {
      instanceRecords.push(record);
    }
  }
  const oldInstance = instanceRecords.filter((r2) => r2.typeName === "instance" && r2.id !== TLINSTANCE_ID)[0];
  if (!oldInstance)
    return null;
  const result = {
    version: CURRENT_SESSION_STATE_SNAPSHOT_VERSION,
    currentPageId: oldInstance.currentPageId,
    exportBackground: !!oldInstance.exportBackground,
    isFocusMode: !!oldInstance.isFocusMode,
    isDebugMode: !!oldInstance.isDebugMode,
    isToolLocked: !!oldInstance.isToolLocked,
    isGridMode: false,
    pageStates: instanceRecords.filter((r2) => r2.typeName === "instance_page_state" && r2.instanceId === oldInstance.id).map((ps) => {
      const camera = store[ps.cameraId] ?? { x: 0, y: 0, z: 1 };
      return {
        pageId: ps.pageId,
        camera: {
          x: camera.x,
          y: camera.y,
          z: camera.z
        },
        selectedShapeIds: ps.selectedShapeIds,
        focusedGroupId: ps.focusedGroupId
      };
    })
  };
  try {
    sessionStateSnapshotValidator.validate(result);
    return result;
  } catch (e2) {
    return null;
  }
}
var tabIdKey, window2, TAB_ID, Versions14, CURRENT_SESSION_STATE_SNAPSHOT_VERSION, sessionStateSnapshotValidator;
var init_TLSessionStateSnapshot = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/TLSessionStateSnapshot.mjs"() {
    init_dist_esm();
    init_dist_esm8();
    init_dist_esm2();
    init_dist_esm6();
    init_uniqueId();
    tabIdKey = "TLDRAW_TAB_ID_v2";
    window2 = globalThis.window;
    TAB_ID = window2 ? window2[tabIdKey] ?? getFromSessionStorage(tabIdKey) ?? `TLDRAW_INSTANCE_STATE_V1_` + uniqueId() : "<error>";
    if (window2) {
      window2[tabIdKey] = TAB_ID;
      if (iOS()) {
        setInSessionStorage(tabIdKey, TAB_ID);
      } else {
        deleteFromSessionStorage(tabIdKey);
      }
    }
    window2?.addEventListener("beforeunload", () => {
      setInSessionStorage(tabIdKey, TAB_ID);
    });
    Versions14 = {
      Initial: 0
    };
    CURRENT_SESSION_STATE_SNAPSHOT_VERSION = Math.max(...Object.values(Versions14));
    sessionStateSnapshotValidator = validation_exports.object({
      version: validation_exports.number,
      currentPageId: pageIdValidator,
      isFocusMode: validation_exports.boolean,
      exportBackground: validation_exports.boolean,
      isDebugMode: validation_exports.boolean,
      isToolLocked: validation_exports.boolean,
      isGridMode: validation_exports.boolean,
      pageStates: validation_exports.arrayOf(validation_exports.object({
        pageId: pageIdValidator,
        camera: validation_exports.object({
          x: validation_exports.number,
          y: validation_exports.number,
          z: validation_exports.number
        }),
        selectedShapeIds: validation_exports.arrayOf(shapeIdValidator),
        focusedGroupId: shapeIdValidator.nullable()
      }))
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/TLEditorSnapshot.mjs
function loadSnapshot(store, _snapshot) {
  let snapshot = {};
  if ("store" in _snapshot) {
    const migrationResult = store.schema.migrateStoreSnapshot(_snapshot);
    if (migrationResult.type !== "success") {
      throw new Error("Failed to migrate store snapshot: " + migrationResult.reason);
    }
    snapshot.document = {
      schema: store.schema.serialize(),
      store: filterEntries(migrationResult.value, (_2, { typeName }) => store.scopedTypes.document.has(typeName))
    };
  } else {
    snapshot = _snapshot;
  }
  const preservingInstanceState = pluckPreservingValues(store.get(TLINSTANCE_ID));
  store.atomic(() => {
    if (snapshot.document) {
      store.loadStoreSnapshot(snapshot.document);
    }
    if (preservingInstanceState) {
      store.update(TLINSTANCE_ID, (r2) => ({ ...r2, ...preservingInstanceState }));
    }
    if (snapshot.session) {
      loadSessionStateSnapshotIntoStore(store, snapshot.session);
    }
  });
}
function getSnapshot(store) {
  const sessionState$ = sessionStateCache.get(store, createSessionStateSnapshotSignal);
  const session = sessionState$.get();
  if (!session) {
    throw new Error("Session state is not ready yet");
  }
  return {
    document: store.getStoreSnapshot(),
    session
  };
}
var sessionStateCache;
var init_TLEditorSnapshot = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/TLEditorSnapshot.mjs"() {
    init_dist_esm8();
    init_dist_esm2();
    init_TLSessionStateSnapshot();
    sessionStateCache = new WeakCache();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/defaultBindings.mjs
function checkBindings(customBindings) {
  const bindings = [];
  const addedCustomBindingTypes = /* @__PURE__ */ new Set();
  for (const customBinding of customBindings) {
    if (addedCustomBindingTypes.has(customBinding.type)) {
      throw new Error(`Binding type "${customBinding.type}" is defined more than once`);
    }
    bindings.push(customBinding);
    addedCustomBindingTypes.add(customBinding.type);
  }
  return bindings;
}
var init_defaultBindings = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/defaultBindings.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/SVGContainer.mjs
function SVGContainer({ children, className = "", ...rest }) {
  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("svg", { ...rest, className: (0, import_classnames10.default)("tl-svg-container", className), children });
}
var import_jsx_runtime26, import_classnames10;
var init_SVGContainer = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/SVGContainer.mjs"() {
    import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
    import_classnames10 = __toESM(require_classnames(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/intersect.mjs
function intersectLineSegmentLineSegment(a1, a2, b1, b2) {
  const ABx = a1.x - b1.x;
  const ABy = a1.y - b1.y;
  const BVx = b2.x - b1.x;
  const BVy = b2.y - b1.y;
  const AVx = a2.x - a1.x;
  const AVy = a2.y - a1.y;
  const ua_t = BVx * ABy - BVy * ABx;
  const ub_t = AVx * ABy - AVy * ABx;
  const u_b = BVy * AVx - BVx * AVy;
  if (ua_t === 0 || ub_t === 0)
    return null;
  if (u_b === 0)
    return null;
  if (u_b !== 0) {
    const ua = ua_t / u_b;
    const ub = ub_t / u_b;
    if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
      return Vec.AddXY(a1, ua * AVx, ua * AVy);
    }
  }
  return null;
}
function intersectLineSegmentCircle(a1, a2, c2, r2) {
  const a3 = (a2.x - a1.x) * (a2.x - a1.x) + (a2.y - a1.y) * (a2.y - a1.y);
  const b2 = 2 * ((a2.x - a1.x) * (a1.x - c2.x) + (a2.y - a1.y) * (a1.y - c2.y));
  const cc = c2.x * c2.x + c2.y * c2.y + a1.x * a1.x + a1.y * a1.y - 2 * (c2.x * a1.x + c2.y * a1.y) - r2 * r2;
  const deter = b2 * b2 - 4 * a3 * cc;
  if (deter < 0)
    return null;
  if (deter === 0)
    return null;
  const e2 = Math.sqrt(deter);
  const u1 = (-b2 + e2) / (2 * a3);
  const u2 = (-b2 - e2) / (2 * a3);
  if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
    return null;
  }
  const result = [];
  if (0 <= u1 && u1 <= 1)
    result.push(Vec.Lrp(a1, a2, u1));
  if (0 <= u2 && u2 <= 1)
    result.push(Vec.Lrp(a1, a2, u2));
  if (result.length === 0)
    return null;
  return result;
}
function intersectLineSegmentPolyline(a1, a2, points) {
  const result = [];
  let segmentIntersection;
  for (let i2 = 0, n2 = points.length - 1; i2 < n2; i2++) {
    segmentIntersection = intersectLineSegmentLineSegment(a1, a2, points[i2], points[i2 + 1]);
    if (segmentIntersection)
      result.push(segmentIntersection);
  }
  if (result.length === 0)
    return null;
  return result;
}
function intersectLineSegmentPolygon(a1, a2, points) {
  const result = [];
  let segmentIntersection;
  for (let i2 = 1, n2 = points.length; i2 < n2 + 1; i2++) {
    segmentIntersection = intersectLineSegmentLineSegment(a1, a2, points[i2 - 1], points[i2 % points.length]);
    if (segmentIntersection)
      result.push(segmentIntersection);
  }
  if (result.length === 0)
    return null;
  return result;
}
function intersectCircleCircle(c1, r1, c2, r2) {
  let dx = c2.x - c1.x;
  let dy = c2.y - c1.y;
  const d2 = Math.sqrt(dx * dx + dy * dy), x2 = (d2 * d2 - r2 * r2 + r1 * r1) / (2 * d2), y2 = Math.sqrt(r1 * r1 - x2 * x2);
  dx /= d2;
  dy /= d2;
  return [
    new Vec(c1.x + dx * x2 - dy * y2, c1.y + dy * x2 + dx * y2),
    new Vec(c1.x + dx * x2 + dy * y2, c1.y + dy * x2 - dx * y2)
  ];
}
function intersectCirclePolygon(c2, r2, points) {
  const result = [];
  let a2, b2, int;
  for (let i2 = 0, n2 = points.length; i2 < n2; i2++) {
    a2 = points[i2];
    b2 = points[(i2 + 1) % points.length];
    int = intersectLineSegmentCircle(a2, b2, c2, r2);
    if (int)
      result.push(...int);
  }
  if (result.length === 0)
    return null;
  return result;
}
function intersectCirclePolyline(c2, r2, points) {
  const result = [];
  let a2, b2, int;
  for (let i2 = 1, n2 = points.length; i2 < n2; i2++) {
    a2 = points[i2 - 1];
    b2 = points[i2];
    int = intersectLineSegmentCircle(a2, b2, c2, r2);
    if (int)
      result.push(...int);
  }
  if (result.length === 0)
    return null;
  return result;
}
function ccw(A2, B, C2) {
  return (C2.y - A2.y) * (B.x - A2.x) > (B.y - A2.y) * (C2.x - A2.x);
}
function linesIntersect(A2, B, C2, D2) {
  return ccw(A2, C2, D2) !== ccw(B, C2, D2) && ccw(A2, B, C2) !== ccw(A2, B, D2);
}
function intersectPolygonPolygon(polygonA, polygonB) {
  const result = /* @__PURE__ */ new Map();
  let a2, b2, c2, d2;
  for (let i2 = 0, n2 = polygonA.length; i2 < n2; i2++) {
    a2 = polygonA[i2];
    if (pointInPolygon(a2, polygonB)) {
      const id = getPointId(a2);
      if (!result.has(id)) {
        result.set(id, a2);
      }
    }
  }
  for (let i2 = 0, n2 = polygonB.length; i2 < n2; i2++) {
    a2 = polygonB[i2];
    if (pointInPolygon(a2, polygonA)) {
      const id = getPointId(a2);
      if (!result.has(id)) {
        result.set(id, a2);
      }
    }
  }
  for (let i2 = 0, n2 = polygonA.length; i2 < n2; i2++) {
    a2 = polygonA[i2];
    b2 = polygonA[(i2 + 1) % polygonA.length];
    for (let j2 = 0, m2 = polygonB.length; j2 < m2; j2++) {
      c2 = polygonB[j2];
      d2 = polygonB[(j2 + 1) % polygonB.length];
      const intersection = intersectLineSegmentLineSegment(a2, b2, c2, d2);
      if (intersection !== null) {
        const id = getPointId(intersection);
        if (!result.has(id)) {
          result.set(id, intersection);
        }
      }
    }
  }
  if (result.size === 0)
    return null;
  return orderClockwise([...result.values()]);
}
function getPointId(point) {
  return `${point.x},${point.y}`;
}
function orderClockwise(points) {
  const C2 = Vec.Average(points);
  return points.sort((A2, B) => Vec.Angle(C2, A2) - Vec.Angle(C2, B));
}
function polygonsIntersect(a2, b2) {
  let a0, a1, b0, b1;
  for (let i2 = 0, n2 = a2.length; i2 < n2; i2++) {
    a0 = a2[i2];
    a1 = a2[(i2 + 1) % n2];
    for (let j2 = 0, m2 = b2.length; j2 < m2; j2++) {
      b0 = b2[j2];
      b1 = b2[(j2 + 1) % m2];
      if (linesIntersect(a0, a1, b0, b1))
        return true;
    }
  }
  return false;
}
function polygonIntersectsPolyline(polygon, polyline) {
  let a2, b2, c2, d2;
  for (let i2 = 0, n2 = polygon.length; i2 < n2; i2++) {
    a2 = polygon[i2];
    b2 = polygon[(i2 + 1) % n2];
    for (let j2 = 1, m2 = polyline.length; j2 < m2; j2++) {
      c2 = polyline[j2 - 1];
      d2 = polyline[j2];
      if (linesIntersect(a2, b2, c2, d2))
        return true;
    }
  }
  return false;
}
var init_intersect = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/intersect.mjs"() {
    init_utils();
    init_Vec();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Edge2d.mjs
var Edge2d;
var init_Edge2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Edge2d.mjs"() {
    init_Vec();
    init_intersect();
    init_Geometry2d();
    Edge2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isClosed: false, isFilled: false });
        __publicField(this, "start");
        __publicField(this, "end");
        __publicField(this, "d");
        __publicField(this, "u");
        __publicField(this, "ul");
        const { start: start2, end: end2 } = config;
        this.start = start2;
        this.end = end2;
        this.d = start2.clone().sub(end2);
        this.u = this.d.clone().uni();
        this.ul = this.u.len();
      }
      getLength() {
        return this.d.len();
      }
      midPoint() {
        return this.start.lrp(this.end, 0.5);
      }
      getVertices() {
        return [this.start, this.end];
      }
      nearestPoint(point) {
        const { start: start2, end: end2, u: u2, ul: l2 } = this;
        if (l2 === 0)
          return start2;
        const k2 = Vec.Sub(point, start2).dpr(u2) / l2;
        const cx = start2.x + u2.x * k2;
        if (cx < Math.min(start2.x, end2.x))
          return start2.x < end2.x ? start2 : end2;
        if (cx > Math.max(start2.x, end2.x))
          return start2.x > end2.x ? start2 : end2;
        const cy = start2.y + u2.y * k2;
        if (cy < Math.min(start2.y, end2.y))
          return start2.y < end2.y ? start2 : end2;
        if (cy > Math.max(start2.y, end2.y))
          return start2.y > end2.y ? start2 : end2;
        return new Vec(cx, cy);
      }
      hitTestLineSegment(A2, B, distance = 0) {
        return linesIntersect(A2, B, this.start, this.end) || this.distanceToLineSegment(A2, B) <= distance;
      }
      getSvgPathData(first = true) {
        const { start: start2, end: end2 } = this;
        return `${first ? `M${start2.toFixed()}` : ``} L${end2.toFixed()}`;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Polyline2d.mjs
var Polyline2d;
var init_Polyline2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Polyline2d.mjs"() {
    init_Vec();
    init_Edge2d();
    init_Geometry2d();
    Polyline2d = class extends Geometry2d {
      constructor(config) {
        super({ isClosed: false, isFilled: false, ...config });
        __publicField(this, "points");
        __publicField(this, "_segments");
        const { points } = config;
        this.points = points;
      }
      get segments() {
        if (!this._segments) {
          this._segments = [];
          const { vertices } = this;
          for (let i2 = 0, n2 = vertices.length - 1; i2 < n2; i2++) {
            const start2 = vertices[i2];
            const end2 = vertices[i2 + 1];
            this._segments.push(new Edge2d({ start: start2, end: end2 }));
          }
          if (this.isClosed) {
            this._segments.push(new Edge2d({ start: vertices[vertices.length - 1], end: vertices[0] }));
          }
        }
        return this._segments;
      }
      getLength() {
        return this.segments.reduce((acc, segment) => acc + segment.length, 0);
      }
      getVertices() {
        return this.points;
      }
      nearestPoint(A2) {
        const { segments } = this;
        let nearest = this.points[0];
        let dist = Infinity;
        let p2;
        let d2;
        for (let i2 = 0; i2 < segments.length; i2++) {
          p2 = segments[i2].nearestPoint(A2);
          d2 = Vec.Dist2(p2, A2);
          if (d2 < dist) {
            nearest = p2;
            dist = d2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      hitTestLineSegment(A2, B, distance = 0) {
        const { segments } = this;
        for (let i2 = 0, n2 = segments.length; i2 < n2; i2++) {
          if (segments[i2].hitTestLineSegment(A2, B, distance)) {
            return true;
          }
        }
        return false;
      }
      getSvgPathData() {
        const { vertices } = this;
        if (vertices.length < 2)
          return "";
        return vertices.reduce((acc, vertex, i2) => {
          if (i2 === 0)
            return `M ${vertex.x} ${vertex.y}`;
          return `${acc} L ${vertex.x} ${vertex.y}`;
        }, "");
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Polygon2d.mjs
var Polygon2d;
var init_Polygon2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Polygon2d.mjs"() {
    init_Polyline2d();
    Polygon2d = class extends Polyline2d {
      constructor(config) {
        super({ ...config });
        this.isClosed = true;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Rectangle2d.mjs
var Rectangle2d;
var init_Rectangle2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Rectangle2d.mjs"() {
    init_Box();
    init_Vec();
    init_Polygon2d();
    Rectangle2d = class extends Polygon2d {
      constructor(config) {
        const { x: x2 = 0, y: y2 = 0, width, height } = config;
        super({
          ...config,
          points: [
            new Vec(x2, y2),
            new Vec(x2 + width, y2),
            new Vec(x2 + width, y2 + height),
            new Vec(x2, y2 + height)
          ]
        });
        __publicField(this, "x");
        __publicField(this, "y");
        __publicField(this, "w");
        __publicField(this, "h");
        this.x = x2;
        this.y = y2;
        this.w = width;
        this.h = height;
      }
      getBounds() {
        return new Box(this.x, this.y, this.w, this.h);
      }
      getSvgPathData() {
        const { x: x2, y: y2, w: w2, h: h2 } = this;
        return `M${x2},${y2} h${w2} v${h2} h-${w2}z`;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/ShapeUtil.mjs
var ShapeUtil;
var init_ShapeUtil = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/ShapeUtil.mjs"() {
    ShapeUtil = class {
      constructor(editor) {
        __publicField(this, "canSnap", () => true);
        __publicField(this, "canScroll", () => false);
        __publicField(this, "canEdit", () => false);
        __publicField(this, "canResize", () => true);
        __publicField(this, "canEditInReadOnly", () => false);
        __publicField(this, "canCrop", () => false);
        __publicField(this, "canBeLaidOut", () => true);
        __publicField(this, "hideResizeHandles", () => false);
        __publicField(this, "hideRotateHandle", () => false);
        __publicField(this, "hideSelectionBoundsBg", () => false);
        __publicField(this, "hideSelectionBoundsFg", () => false);
        __publicField(this, "isAspectRatioLocked", () => false);
        __publicField(this, "onBeforeCreate");
        __publicField(this, "onBeforeUpdate");
        __publicField(this, "onDragShapesOver");
        __publicField(this, "onDragShapesOut");
        __publicField(this, "onDropShapesOver");
        __publicField(this, "onResizeStart");
        __publicField(this, "onResize");
        __publicField(this, "onResizeEnd");
        __publicField(this, "onTranslateStart");
        __publicField(this, "onTranslate");
        __publicField(this, "onTranslateEnd");
        __publicField(this, "onHandleDrag");
        __publicField(this, "onRotateStart");
        __publicField(this, "onRotate");
        __publicField(this, "onRotateEnd");
        __publicField(this, "onBindingChange");
        __publicField(this, "onChildrenChange");
        __publicField(this, "onDoubleClickHandle");
        __publicField(this, "onDoubleClickEdge");
        __publicField(this, "onDoubleClick");
        __publicField(this, "onClick");
        __publicField(this, "onEditEnd");
        this.editor = editor;
      }
      canBind(opts) {
        return true;
      }
      providesBackgroundForChildren(shape) {
        return false;
      }
      canReceiveNewChildrenOfType(shape, type) {
        return false;
      }
      canDropShapes(shape, shapes) {
        return false;
      }
      expandSelectionOutlinePx(shape) {
        return 0;
      }
      getCanvasSvgDefs() {
        return [];
      }
      getBoundsSnapGeometry(shape) {
        return {};
      }
      getHandleSnapGeometry(shape) {
        return {};
      }
    };
    __publicField(ShapeUtil, "props");
    __publicField(ShapeUtil, "migrations");
    __publicField(ShapeUtil, "type");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/shared/getPerfectDashProps.mjs
function getPerfectDashProps(totalLength, strokeWidth, opts = {}) {
  const {
    closed = false,
    snap = 1,
    start: start2 = "outset",
    end: end2 = "outset",
    lengthRatio = 2,
    style = "dashed"
  } = opts;
  let dashLength = 0;
  let dashCount = 0;
  let ratio = 1;
  let gapLength = 0;
  let strokeDashoffset = 0;
  switch (style) {
    case "dashed": {
      ratio = 1;
      dashLength = Math.min(strokeWidth * lengthRatio, totalLength / 4);
      break;
    }
    case "dotted": {
      ratio = 100;
      dashLength = strokeWidth / ratio;
      break;
    }
    default: {
      return {
        strokeDasharray: "none",
        strokeDashoffset: "none"
      };
    }
  }
  if (!closed) {
    if (start2 === "outset") {
      totalLength += dashLength / 2;
      strokeDashoffset += dashLength / 2;
    } else if (start2 === "skip") {
      totalLength -= dashLength;
      strokeDashoffset -= dashLength;
    }
    if (end2 === "outset") {
      totalLength += dashLength / 2;
    } else if (end2 === "skip") {
      totalLength -= dashLength;
    }
  }
  dashCount = Math.floor(totalLength / dashLength / (2 * ratio));
  dashCount -= dashCount % snap;
  if (dashCount < 3 && style === "dashed") {
    if (totalLength / strokeWidth < 5) {
      dashLength = totalLength;
      dashCount = 1;
      gapLength = 0;
    } else {
      dashLength = totalLength * 0.333;
      gapLength = totalLength * 0.333;
    }
  } else {
    dashCount = Math.max(dashCount, 3);
    dashLength = totalLength / dashCount / (2 * ratio);
    if (closed) {
      strokeDashoffset = dashLength / 2;
      gapLength = (totalLength - dashCount * dashLength) / dashCount;
    } else {
      gapLength = (totalLength - dashCount * dashLength) / Math.max(1, dashCount - 1);
    }
  }
  return {
    strokeDasharray: [dashLength, gapLength].join(" "),
    strokeDashoffset: strokeDashoffset.toString()
  };
}
var init_getPerfectDashProps = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/shared/getPerfectDashProps.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/group/DashedOutlineBox.mjs
function DashedOutlineBox({ bounds, className }) {
  const editor = useEditor();
  const zoomLevel = useValue("zoom level", () => editor.getZoomLevel(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("g", { className, pointerEvents: "none", strokeLinecap: "round", strokeLinejoin: "round", children: bounds.sides.map((side, i2) => {
    const { strokeDasharray, strokeDashoffset } = getPerfectDashProps(side[0].dist(side[1]), 1 / zoomLevel, {
      style: "dashed",
      lengthRatio: 4
    });
    return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("line", {
      x1: side[0].x,
      y1: side[0].y,
      x2: side[1].x,
      y2: side[1].y,
      strokeDasharray,
      strokeDashoffset
    }, i2);
  }) });
}
var import_jsx_runtime27;
var init_DashedOutlineBox = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/group/DashedOutlineBox.mjs"() {
    import_jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    init_useEditor();
    init_getPerfectDashProps();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/group/GroupShapeUtil.mjs
var import_jsx_runtime28, GroupShapeUtil;
var init_GroupShapeUtil = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/group/GroupShapeUtil.mjs"() {
    import_jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm8();
    init_SVGContainer();
    init_Group2d();
    init_Polygon2d();
    init_Polyline2d();
    init_Rectangle2d();
    init_ShapeUtil();
    init_DashedOutlineBox();
    GroupShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "hideSelectionBoundsFg", () => true);
        __publicField(this, "canBind", () => false);
        __publicField(this, "onChildrenChange", (group) => {
          const children = this.editor.getSortedChildIdsForParent(group.id);
          if (children.length === 0) {
            if (this.editor.getCurrentPageState().focusedGroupId === group.id) {
              this.editor.popFocusedGroupId();
            }
            this.editor.deleteShapes([group.id]);
            return;
          } else if (children.length === 1) {
            if (this.editor.getCurrentPageState().focusedGroupId === group.id) {
              this.editor.popFocusedGroupId();
            }
            this.editor.reparentShapes(children, group.parentId);
            this.editor.deleteShapes([group.id]);
            return;
          }
        });
      }
      getDefaultProps() {
        return {};
      }
      getGeometry(shape) {
        const children = this.editor.getSortedChildIdsForParent(shape.id);
        if (children.length === 0) {
          return new Rectangle2d({ width: 1, height: 1, isFilled: false });
        }
        return new Group2d({
          children: children.map((childId) => {
            const shape2 = this.editor.getShape(childId);
            const geometry = this.editor.getShapeGeometry(childId);
            const points = this.editor.getShapeLocalTransform(shape2).applyToPoints(geometry.vertices);
            if (geometry.isClosed) {
              return new Polygon2d({
                points,
                isFilled: true
              });
            }
            return new Polyline2d({
              points
            });
          })
        });
      }
      component(shape) {
        const isErasing = this.editor.getErasingShapeIds().includes(shape.id);
        const { hintingShapeIds } = this.editor.getCurrentPageState();
        const isHintingOtherGroup = hintingShapeIds.length > 0 && hintingShapeIds.some((id) => id !== shape.id && this.editor.isShapeOfType(this.editor.getShape(id), "group"));
        const isFocused = this.editor.getCurrentPageState().focusedGroupId !== shape.id;
        if (!isErasing && (isFocused || isHintingOtherGroup)) {
          return null;
        }
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(SVGContainer, { id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(DashedOutlineBox, { className: "tl-group", bounds }) });
      }
      indicator(shape) {
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(DashedOutlineBox, { className: "", bounds });
      }
    };
    __publicField(GroupShapeUtil, "type", "group");
    __publicField(GroupShapeUtil, "props", groupShapeProps);
    __publicField(GroupShapeUtil, "migrations", groupShapeMigrations);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/defaultShapes.mjs
function checkShapesAndAddCore(customShapes) {
  const shapes = [...coreShapes];
  const addedCustomShapeTypes = /* @__PURE__ */ new Set();
  for (const customShape of customShapes) {
    if (coreShapeTypes.has(customShape.type)) {
      throw new Error(`Shape type "${customShape.type}" is a core shapes type and cannot be overridden`);
    }
    if (addedCustomShapeTypes.has(customShape.type)) {
      throw new Error(`Shape type "${customShape.type}" is defined more than once`);
    }
    shapes.push(customShape);
    addedCustomShapeTypes.add(customShape.type);
  }
  return shapes;
}
var coreShapes, coreShapeTypes;
var init_defaultShapes = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/defaultShapes.mjs"() {
    init_GroupShapeUtil();
    coreShapes = [
      GroupShapeUtil
    ];
    coreShapeTypes = new Set(coreShapes.map((s2) => s2.type));
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/options.mjs
var defaultTldrawOptions;
var init_options = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/options.mjs"() {
    defaultTldrawOptions = {
      maxShapesPerPage: 4e3,
      maxPages: 40,
      animationMediumMs: 320,
      followChaseViewportSnap: 2,
      doubleClickDurationMs: 450,
      multiClickDurationMs: 200,
      coarseDragDistanceSquared: 36,
      dragDistanceSquared: 16,
      defaultSvgPadding: 32,
      cameraSlideFriction: 0.09,
      maxPointsPerDrawShape: 500,
      gridSteps: [
        { min: -1, mid: 0.15, step: 64 },
        { min: 0.05, mid: 0.375, step: 16 },
        { min: 0.15, mid: 1, step: 4 },
        { min: 0.7, mid: 2.5, step: 1 }
      ],
      collaboratorInactiveTimeoutMs: 6e4,
      collaboratorIdleTimeoutMs: 3e3,
      collaboratorCheckIntervalMs: 1200,
      cameraMovingTimeoutMs: 64,
      hitTestMargin: 8,
      edgeScrollDelay: 200,
      edgeScrollEaseDuration: 200,
      edgeScrollSpeed: 25,
      edgeScrollDistance: 8,
      coarsePointerWidth: 12,
      coarseHandleRadius: 20,
      handleRadius: 12,
      longPressDurationMs: 500,
      textShadowLod: 0.35,
      adjacentShapeMargin: 10,
      flattenImageBoundsExpand: 64,
      flattenImageBoundsPadding: 16
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/SharedStylesMap.mjs
function sharedStyleEquals(a2, b2) {
  if (!b2)
    return false;
  switch (a2.type) {
    case "mixed":
      return b2.type === "mixed";
    case "shared":
      return b2.type === "shared" && a2.value === b2.value;
    default:
      throw exhaustiveSwitchError(a2);
  }
}
var ReadonlySharedStyleMap, SharedStyleMap;
var init_SharedStylesMap = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/SharedStylesMap.mjs"() {
    init_dist_esm2();
    ReadonlySharedStyleMap = class {
      constructor(entries) {
        __publicField(this, "map");
        this.map = new Map(entries);
      }
      get(prop) {
        return this.map.get(prop);
      }
      getAsKnownValue(prop) {
        const value = this.get(prop);
        if (!value)
          return void 0;
        if (value.type === "mixed")
          return void 0;
        return value.value;
      }
      get size() {
        return this.map.size;
      }
      equals(other) {
        if (this.size !== other.size)
          return false;
        const checkedKeys = /* @__PURE__ */ new Set();
        for (const [styleProp, value] of this) {
          if (!sharedStyleEquals(value, other.get(styleProp)))
            return false;
          checkedKeys.add(styleProp);
        }
        for (const [styleProp, value] of other) {
          if (checkedKeys.has(styleProp))
            continue;
          if (!sharedStyleEquals(value, this.get(styleProp)))
            return false;
        }
        return true;
      }
      keys() {
        return this.map.keys();
      }
      values() {
        return this.map.values();
      }
      entries() {
        return this.map.entries();
      }
      [Symbol.iterator]() {
        return this.map[Symbol.iterator]();
      }
    };
    SharedStyleMap = class extends ReadonlySharedStyleMap {
      set(prop, value) {
        this.map.set(prop, value);
      }
      applyValue(prop, value) {
        const existingValue = this.get(prop);
        if (!existingValue) {
          this.set(prop, { type: "shared", value });
          return;
        }
        switch (existingValue.type) {
          case "mixed":
            return;
          case "shared":
            if (existingValue.value !== value) {
              this.set(prop, { type: "mixed" });
            }
            return;
          default:
            exhaustiveSwitchError(existingValue, "type");
        }
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/assets.mjs
function dataUrlToFile(url, filename, mimeType) {
  return fetch2(url).then(function(res) {
    return res.arrayBuffer();
  }).then(function(buf) {
    return new File([buf], filename, { type: mimeType });
  });
}
function getDefaultCdnBaseUrl() {
  return `${CDN_BASE_URL}/${version}`;
}
var CDN_BASE_URL;
var init_assets = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/assets.mjs"() {
    init_dist_esm2();
    init_version();
    CDN_BASE_URL = "https://cdn.tldraw.com";
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/getIncrementedName.mjs
function getIncrementedName(name, others) {
  let result = name;
  const set = new Set(others);
  while (set.has(result)) {
    result = /^.*(\d+)$/.exec(result)?.[1] ? result.replace(/(\d+)(?=\D?)$/, (m2) => {
      return (+m2 + 1).toString();
    }) : `${result} 1`;
  }
  return result;
}
var init_getIncrementedName = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/getIncrementedName.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/reorderShapes.mjs
function getReorderingShapesChanges(editor, operation, ids) {
  if (ids.length === 0)
    return [];
  const parents = /* @__PURE__ */ new Map();
  for (const shape of compact(ids.map((id) => editor.getShape(id)))) {
    const { parentId } = shape;
    if (!parents.has(parentId)) {
      parents.set(parentId, {
        children: compact(editor.getSortedChildIdsForParent(parentId).map((id) => editor.getShape(id))),
        moving: /* @__PURE__ */ new Set()
      });
    }
    parents.get(parentId).moving.add(shape);
  }
  const changes = [];
  switch (operation) {
    case "toBack": {
      parents.forEach(({ moving, children }) => reorderToBack(moving, children, changes));
      break;
    }
    case "toFront": {
      parents.forEach(({ moving, children }) => reorderToFront(moving, children, changes));
      break;
    }
    case "forward": {
      parents.forEach(({ moving, children }) => reorderForward(moving, children, changes));
      break;
    }
    case "backward": {
      parents.forEach(({ moving, children }) => reorderBackward(moving, children, changes));
      break;
    }
  }
  return changes;
}
function reorderToBack(moving, children, changes) {
  const len = children.length;
  if (moving.size === len)
    return;
  let below;
  let above;
  for (let i2 = 0; i2 < len; i2++) {
    const shape = children[i2];
    if (moving.has(shape)) {
      below = shape.index;
      moving.delete(shape);
    } else {
      above = shape.index;
      break;
    }
  }
  if (moving.size === 0) {
    return;
  } else {
    const indices = getIndicesBetween(below, above, moving.size);
    changes.push(...Array.from(moving.values()).sort(sortByIndex).map((shape, i2) => ({ ...shape, index: indices[i2] })));
  }
}
function reorderToFront(moving, children, changes) {
  const len = children.length;
  if (moving.size === len)
    return;
  let below;
  let above;
  for (let i2 = len - 1; i2 > -1; i2--) {
    const shape = children[i2];
    if (moving.has(shape)) {
      above = shape.index;
      moving.delete(shape);
    } else {
      below = shape.index;
      break;
    }
  }
  if (moving.size === 0) {
    return;
  } else {
    const indices = getIndicesBetween(below, above, moving.size);
    changes.push(...Array.from(moving.values()).sort(sortByIndex).map((shape, i2) => ({ ...shape, index: indices[i2] })));
  }
}
function reorderForward(moving, children, changes) {
  const len = children.length;
  if (moving.size === len)
    return;
  let state = { name: "skipping" };
  for (let i2 = 0; i2 < len; i2++) {
    const isMoving = moving.has(children[i2]);
    switch (state.name) {
      case "skipping": {
        if (!isMoving)
          continue;
        state = { name: "selecting", selectIndex: i2 };
        break;
      }
      case "selecting": {
        if (isMoving)
          continue;
        const { selectIndex } = state;
        getIndicesBetween(children[i2].index, children[i2 + 1]?.index, i2 - selectIndex).forEach((index3, k2) => changes.push({ ...children[selectIndex + k2], index: index3 }));
        state = { name: "skipping" };
        break;
      }
    }
  }
}
function reorderBackward(moving, children, changes) {
  const len = children.length;
  if (moving.size === len)
    return;
  let state = { name: "skipping" };
  for (let i2 = len - 1; i2 > -1; i2--) {
    const isMoving = moving.has(children[i2]);
    switch (state.name) {
      case "skipping": {
        if (!isMoving)
          continue;
        state = { name: "selecting", selectIndex: i2 };
        break;
      }
      case "selecting": {
        if (isMoving)
          continue;
        getIndicesBetween(children[i2 - 1]?.index, children[i2].index, state.selectIndex - i2).forEach((index3, k2) => {
          changes.push({ ...children[i2 + k2 + 1], index: index3 });
        });
        state = { name: "skipping" };
        break;
      }
    }
  }
}
var init_reorderShapes = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/reorderShapes.mjs"() {
    init_dist_esm2();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/rotation.mjs
function getRotationSnapshot({ editor }) {
  const selectedShapes = editor.getSelectedShapes();
  const selectionRotation = editor.getSelectionRotation();
  const selectionBounds = editor.getSelectionRotatedPageBounds();
  const {
    inputs: { originPagePoint }
  } = editor;
  if (!selectionBounds) {
    return null;
  }
  const selectionPageCenter = selectionBounds.center.clone().rotWith(selectionBounds.point, selectionRotation);
  return {
    selectionPageCenter,
    initialCursorAngle: selectionPageCenter.angle(originPagePoint),
    initialSelectionRotation: selectionRotation,
    shapeSnapshots: selectedShapes.map((shape) => ({
      shape: structuredClone2(shape),
      initialPagePoint: editor.getShapePageTransform(shape.id).point()
    }))
  };
}
function applyRotationToSnapshotShapes({
  delta,
  editor,
  snapshot,
  stage
}) {
  const { selectionPageCenter, shapeSnapshots } = snapshot;
  editor.updateShapes(shapeSnapshots.map(({ shape, initialPagePoint }) => {
    const parentTransform = isShapeId(shape.parentId) ? editor.getShapePageTransform(shape.parentId) : Mat.Identity();
    const newPagePoint = Vec.RotWith(initialPagePoint, selectionPageCenter, delta);
    const newLocalPoint = Mat.applyToPoint(Mat.Inverse(parentTransform), newPagePoint);
    const newRotation = canonicalizeRotation(shape.rotation + delta);
    return {
      id: shape.id,
      type: shape.type,
      x: newLocalPoint.x,
      y: newLocalPoint.y,
      rotation: newRotation
    };
  }));
  const changes = [];
  shapeSnapshots.forEach(({ shape }) => {
    const current = editor.getShape(shape.id);
    if (!current)
      return;
    const util = editor.getShapeUtil(shape);
    if (stage === "start" || stage === "one-off") {
      const changeStart = util.onRotateStart?.(shape);
      if (changeStart)
        changes.push(changeStart);
    }
    const changeUpdate = util.onRotate?.(shape, current);
    if (changeUpdate)
      changes.push(changeUpdate);
    if (stage === "end" || stage === "one-off") {
      const changeEnd = util.onRotateEnd?.(shape, current);
      if (changeEnd)
        changes.push(changeEnd);
    }
  });
  if (changes.length > 0) {
    editor.updateShapes(changes);
  }
}
var init_rotation = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/rotation.mjs"() {
    init_dist_esm8();
    init_dist_esm2();
    init_Mat();
    init_utils();
    init_Vec();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/bindingsIndex.mjs
var bindingsIndex;
var init_bindingsIndex = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/bindingsIndex.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    bindingsIndex = (editor) => {
      const { store } = editor;
      const bindingsHistory = store.query.filterHistory("binding");
      const bindingsQuery = store.query.records("binding");
      function fromScratch() {
        const allBindings = bindingsQuery.get();
        const shape2Binding = /* @__PURE__ */ new Map();
        for (const binding of allBindings) {
          const { fromId, toId } = binding;
          const bindingsForFromShape = shape2Binding.get(fromId);
          if (!bindingsForFromShape) {
            shape2Binding.set(fromId, [binding]);
          } else {
            bindingsForFromShape.push(binding);
          }
          const bindingsForToShape = shape2Binding.get(toId);
          if (!bindingsForToShape) {
            shape2Binding.set(toId, [binding]);
          } else {
            bindingsForToShape.push(binding);
          }
        }
        return shape2Binding;
      }
      return computed("arrowBindingsIndex", (_lastValue, lastComputedEpoch) => {
        if (isUninitialized(_lastValue)) {
          return fromScratch();
        }
        const lastValue = _lastValue;
        const diff = bindingsHistory.getDiffSince(lastComputedEpoch);
        if (diff === RESET_VALUE) {
          return fromScratch();
        }
        let nextValue = void 0;
        function removingBinding(binding) {
          nextValue ?? (nextValue = new Map(lastValue));
          const prevFrom = nextValue.get(binding.fromId);
          const nextFrom = prevFrom?.filter((b2) => b2.id !== binding.id);
          if (!nextFrom?.length) {
            nextValue.delete(binding.fromId);
          } else {
            nextValue.set(binding.fromId, nextFrom);
          }
          const prevTo = nextValue.get(binding.toId);
          const nextTo = prevTo?.filter((b2) => b2.id !== binding.id);
          if (!nextTo?.length) {
            nextValue.delete(binding.toId);
          } else {
            nextValue.set(binding.toId, nextTo);
          }
        }
        function ensureNewArray(shapeId) {
          nextValue ?? (nextValue = new Map(lastValue));
          let result = nextValue.get(shapeId);
          if (!result) {
            result = [];
            nextValue.set(shapeId, result);
          } else if (result === lastValue.get(shapeId)) {
            result = result.slice(0);
            nextValue.set(shapeId, result);
          }
          return result;
        }
        function addBinding(binding) {
          ensureNewArray(binding.fromId).push(binding);
          ensureNewArray(binding.toId).push(binding);
        }
        for (const changes of diff) {
          for (const newBinding of objectMapValues(changes.added)) {
            addBinding(newBinding);
          }
          for (const [prev, next] of objectMapValues(changes.updated)) {
            removingBinding(prev);
            addBinding(next);
          }
          for (const prev of objectMapValues(changes.removed)) {
            removingBinding(prev);
          }
        }
        return nextValue ?? lastValue;
      });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/notVisibleShapes.mjs
function isShapeNotVisible(editor, id, viewportPageBounds) {
  const maskedPageBounds = editor.getShapeMaskedPageBounds(id);
  if (maskedPageBounds === void 0)
    return true;
  return !viewportPageBounds.includes(maskedPageBounds);
}
var notVisibleShapes;
var init_notVisibleShapes = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/notVisibleShapes.mjs"() {
    init_dist_esm();
    notVisibleShapes = (editor) => {
      function fromScratch(editor2) {
        const shapes = editor2.getCurrentPageShapeIds();
        const viewportPageBounds = editor2.getViewportPageBounds();
        const notVisibleShapes2 = /* @__PURE__ */ new Set();
        shapes.forEach((id) => {
          if (isShapeNotVisible(editor2, id, viewportPageBounds)) {
            notVisibleShapes2.add(id);
          }
        });
        return notVisibleShapes2;
      }
      return computed("getCulledShapes", (prevValue) => {
        if (isUninitialized(prevValue)) {
          return fromScratch(editor);
        }
        const nextValue = fromScratch(editor);
        if (prevValue.size !== nextValue.size)
          return nextValue;
        for (const prev of prevValue) {
          if (!nextValue.has(prev)) {
            return nextValue;
          }
        }
        return prevValue;
      });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/parentsToChildren.mjs
var parentsToChildren;
var init_parentsToChildren = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/parentsToChildren.mjs"() {
    init_dist_esm();
    init_dist_esm8();
    init_dist_esm2();
    parentsToChildren = (store) => {
      const shapeIdsQuery = store.query.ids("shape");
      const shapeHistory = store.query.filterHistory("shape");
      function fromScratch() {
        const result = {};
        const shapeIds = shapeIdsQuery.get();
        const shapes = Array(shapeIds.size);
        shapeIds.forEach((id) => shapes.push(store.get(id)));
        shapes.sort(sortByIndex);
        shapes.forEach((shape) => {
          if (!result[shape.parentId]) {
            result[shape.parentId] = [];
          }
          result[shape.parentId].push(shape.id);
        });
        return result;
      }
      return computed("parentsToChildrenWithIndexes", (lastValue, lastComputedEpoch) => {
        if (isUninitialized(lastValue)) {
          return fromScratch();
        }
        const diff = shapeHistory.getDiffSince(lastComputedEpoch);
        if (diff === RESET_VALUE) {
          return fromScratch();
        }
        if (diff.length === 0)
          return lastValue;
        let newValue = null;
        const ensureNewArray = (parentId) => {
          if (!newValue) {
            newValue = { ...lastValue };
          }
          if (!newValue[parentId]) {
            newValue[parentId] = [];
          } else if (newValue[parentId] === lastValue[parentId]) {
            newValue[parentId] = [...newValue[parentId]];
          }
        };
        const toSort = /* @__PURE__ */ new Set();
        let changes;
        for (let i2 = 0, n2 = diff.length; i2 < n2; i2++) {
          changes = diff[i2];
          for (const record of Object.values(changes.added)) {
            if (!isShape(record))
              continue;
            ensureNewArray(record.parentId);
            newValue[record.parentId].push(record.id);
            toSort.add(newValue[record.parentId]);
          }
          for (const [from, to] of Object.values(changes.updated)) {
            if (!isShape(to))
              continue;
            if (!isShape(from))
              continue;
            if (from.parentId !== to.parentId) {
              ensureNewArray(from.parentId);
              ensureNewArray(to.parentId);
              newValue[from.parentId].splice(newValue[from.parentId].indexOf(to.id), 1);
              newValue[to.parentId].push(to.id);
              toSort.add(newValue[to.parentId]);
            } else if (from.index !== to.index) {
              ensureNewArray(to.parentId);
              const idx = newValue[to.parentId].indexOf(to.id);
              newValue[to.parentId][idx] = to.id;
              toSort.add(newValue[to.parentId]);
            }
          }
          for (const record of Object.values(changes.removed)) {
            if (!isShape(record))
              continue;
            ensureNewArray(record.parentId);
            newValue[record.parentId].splice(newValue[record.parentId].indexOf(record.id), 1);
          }
        }
        for (const arr of toSort) {
          const shapesInArr = compact(arr.map((id) => store.get(id)));
          shapesInArr.sort(sortByIndex);
          arr.splice(0, arr.length, ...shapesInArr.map((shape) => shape.id));
        }
        return newValue ?? lastValue;
      });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/shapeIdsInCurrentPage.mjs
var isShapeInPage, deriveShapeIdsInCurrentPage;
var init_shapeIdsInCurrentPage = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/derivations/shapeIdsInCurrentPage.mjs"() {
    init_dist_esm();
    init_dist_esm4();
    init_dist_esm8();
    isShapeInPage = (store, pageId, shape) => {
      while (!isPageId(shape.parentId)) {
        const parent = store.get(shape.parentId);
        if (!parent)
          return false;
        shape = parent;
      }
      return shape.parentId === pageId;
    };
    deriveShapeIdsInCurrentPage = (store, getCurrentPageId) => {
      const shapesIndex = store.query.ids("shape");
      let lastPageId = null;
      function fromScratch() {
        const currentPageId = getCurrentPageId();
        lastPageId = currentPageId;
        return new Set([...shapesIndex.get()].filter((id) => isShapeInPage(store, currentPageId, store.get(id))));
      }
      return computed("_shapeIdsInCurrentPage", (prevValue, lastComputedEpoch) => {
        if (isUninitialized(prevValue)) {
          return fromScratch();
        }
        const currentPageId = getCurrentPageId();
        if (currentPageId !== lastPageId) {
          return fromScratch();
        }
        const diff = store.history.getDiffSince(lastComputedEpoch);
        if (diff === RESET_VALUE) {
          return fromScratch();
        }
        const builder = new IncrementalSetConstructor(prevValue);
        for (const changes of diff) {
          for (const record of Object.values(changes.added)) {
            if (isShape(record) && isShapeInPage(store, currentPageId, record)) {
              builder.add(record.id);
            }
          }
          for (const [_from, to] of Object.values(changes.updated)) {
            if (isShape(to)) {
              if (isShapeInPage(store, currentPageId, to)) {
                builder.add(to.id);
              } else {
                builder.remove(to.id);
              }
            }
          }
          for (const id of Object.keys(changes.removed)) {
            if (isShapeId(id)) {
              builder.remove(id);
            }
          }
        }
        const result = builder.get();
        if (!result) {
          return prevValue;
        }
        return withDiff(result.value, result.diff);
      });
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/types/SvgExportContext.mjs
function SvgExportContextProvider({
  context,
  editor,
  children
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(EditorContext.Provider, { value: editor, children: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(Context.Provider, { value: context, children }) });
}
function useSvgExportContext() {
  const ctx = (0, import_react34.useContext)(Context);
  if (!ctx)
    return null;
  return { isDarkMode: ctx.isDarkMode };
}
var import_jsx_runtime29, import_react34, Context;
var init_SvgExportContext = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/types/SvgExportContext.mjs"() {
    import_jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
    import_react34 = __toESM(require_react(), 1);
    init_useEditor();
    Context = (0, import_react34.createContext)(null);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/getSvgJsx.mjs
async function getSvgJsx(editor, shapes, opts = {}) {
  const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
  if (ids.length === 0)
    return;
  if (!window.document)
    throw Error("No document");
  const {
    scale = 1,
    background = false,
    padding = editor.options.defaultSvgPadding,
    preserveAspectRatio = false
  } = opts;
  const isDarkMode = opts.darkMode ?? editor.user.getIsDarkMode();
  const theme = getDefaultColorTheme({ isDarkMode });
  const shapeIdsToInclude = editor.getShapeAndDescendantIds(ids);
  const renderingShapes = editor.getUnorderedRenderingShapes(false).filter(({ id }) => shapeIdsToInclude.has(id));
  let bbox = null;
  if (opts.bounds) {
    bbox = opts.bounds;
  } else {
    for (const { id } of renderingShapes) {
      const maskedPageBounds = editor.getShapeMaskedPageBounds(id);
      if (!maskedPageBounds)
        continue;
      if (bbox) {
        bbox.union(maskedPageBounds);
      } else {
        bbox = maskedPageBounds.clone();
      }
    }
  }
  if (!bbox)
    return;
  const singleFrameShapeId = ids.length === 1 && editor.isShapeOfType(editor.getShape(ids[0]), "frame") ? ids[0] : null;
  if (!singleFrameShapeId) {
    bbox.expandBy(padding);
  }
  const w2 = bbox.width * scale;
  const h2 = bbox.height * scale;
  try {
    document.body.focus?.();
  } catch (e2) {
  }
  const defChildren = [];
  const exportDefPromisesById = /* @__PURE__ */ new Map();
  const exportContext = {
    isDarkMode,
    addExportDef: (def) => {
      if (exportDefPromisesById.has(def.key))
        return;
      const promise = (async () => {
        const element = await def.getElement();
        if (!element)
          return;
        defChildren.push(/* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_react35.Fragment, { children: element }, defChildren.length));
      })();
      exportDefPromisesById.set(def.key, promise);
    }
  };
  const unorderedShapeElements = (await Promise.all(renderingShapes.map(async ({ id, opacity, index: index3, backgroundIndex }) => {
    if (id === singleFrameShapeId)
      return [];
    const shape = editor.getShape(id);
    if (editor.isShapeOfType(shape, "group"))
      return [];
    const util = editor.getShapeUtil(shape);
    let toSvgResult = await util.toSvg?.(shape, exportContext);
    let toBackgroundSvgResult = await util.toBackgroundSvg?.(shape, exportContext);
    if (!toSvgResult && !toBackgroundSvgResult) {
      const bounds = editor.getShapePageBounds(shape);
      toSvgResult = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("rect", {
        width: bounds.w,
        height: bounds.h,
        fill: theme.solid,
        stroke: theme.grey.pattern,
        strokeWidth: 1
      });
    }
    let pageTransform = editor.getShapePageTransform(shape).toCssString();
    if ("scale" in shape.props) {
      if (shape.props.scale !== 1) {
        pageTransform = `${pageTransform} scale(${shape.props.scale}, ${shape.props.scale})`;
      }
    }
    if (toSvgResult) {
      toSvgResult = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("g", { transform: pageTransform, opacity, children: toSvgResult }, shape.id);
    }
    if (toBackgroundSvgResult) {
      toBackgroundSvgResult = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("g", { transform: pageTransform, opacity, children: toBackgroundSvgResult }, `bg_${shape.id}`);
    }
    const pageMask = editor.getShapeMask(shape.id);
    if (pageMask) {
      const pageMaskId = `mask_${shape.id.replace(":", "_")}`;
      defChildren.push(/* @__PURE__ */ (0, import_jsx_runtime30.jsx)("clipPath", { id: pageMaskId, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("path", { d: `M${pageMask.map(({ x: x2, y: y2 }) => `${x2},${y2}`).join("L")}Z` }) }, defChildren.length));
      if (toSvgResult) {
        toSvgResult = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("g", { clipPath: `url(#${pageMaskId})`, children: toSvgResult }, shape.id);
      }
      if (toBackgroundSvgResult) {
        toBackgroundSvgResult = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("g", { clipPath: `url(#${pageMaskId})`, children: toBackgroundSvgResult }, `bg_${shape.id}`);
      }
    }
    const elements = [];
    if (toSvgResult) {
      elements.push({ zIndex: index3, element: toSvgResult });
    }
    if (toBackgroundSvgResult) {
      elements.push({ zIndex: backgroundIndex, element: toBackgroundSvgResult });
    }
    return elements;
  }))).flat();
  await Promise.all(exportDefPromisesById.values());
  const svg = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(SvgExportContextProvider, { editor, context: exportContext, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)("svg", {
    preserveAspectRatio: preserveAspectRatio ? preserveAspectRatio : void 0,
    direction: "ltr",
    width: w2,
    height: h2,
    viewBox: `${bbox.minX} ${bbox.minY} ${bbox.width} ${bbox.height}`,
    strokeLinecap: "round",
    strokeLinejoin: "round",
    style: {
      backgroundColor: background ? singleFrameShapeId ? theme.solid : theme.background : "transparent"
    },
    children: [
      /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("defs", { children: defChildren }),
      unorderedShapeElements.sort((a2, b2) => a2.zIndex - b2.zIndex).map(({ element }) => element)
    ]
  }) });
  return { jsx: svg, width: w2, height: h2 };
}
var import_jsx_runtime30, import_react35;
var init_getSvgJsx = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/getSvgJsx.mjs"() {
    import_jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm8();
    import_react35 = __toESM(require_react(), 1);
    init_SvgExportContext();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/ClickManager.mjs
var MAX_CLICK_DISTANCE, ClickManager;
var init_ClickManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/ClickManager.mjs"() {
    init_Vec();
    init_uniqueId();
    MAX_CLICK_DISTANCE = 40;
    ClickManager = class {
      constructor(editor) {
        __publicField(this, "_clickId", "");
        __publicField(this, "_clickTimeout");
        __publicField(this, "_clickScreenPoint");
        __publicField(this, "_previousScreenPoint");
        __publicField(this, "_getClickTimeout", (state, id = uniqueId()) => {
          this._clickId = id;
          clearTimeout(this._clickTimeout);
          this._clickTimeout = this.editor.timers.setTimeout(() => {
            if (this._clickState === state && this._clickId === id) {
              switch (this._clickState) {
                case "pendingTriple": {
                  this.editor.dispatch({
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "double_click",
                    phase: "settle"
                  });
                  break;
                }
                case "pendingQuadruple": {
                  this.editor.dispatch({
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "triple_click",
                    phase: "settle"
                  });
                  break;
                }
                case "pendingOverflow": {
                  this.editor.dispatch({
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "quadruple_click",
                    phase: "settle"
                  });
                  break;
                }
                default: {
                }
              }
              this._clickState = "idle";
            }
          }, state === "idle" || state === "pendingDouble" ? this.editor.options.doubleClickDurationMs : this.editor.options.multiClickDurationMs);
        });
        __publicField(this, "_clickState", "idle");
        __publicField(this, "lastPointerInfo", {});
        __publicField(this, "handlePointerEvent", (info2) => {
          switch (info2.name) {
            case "pointer_down": {
              if (!this._clickState)
                return info2;
              this._clickScreenPoint = Vec.From(info2.point);
              if (this._previousScreenPoint && Vec.Dist2(this._previousScreenPoint, this._clickScreenPoint) > MAX_CLICK_DISTANCE ** 2) {
                this._clickState = "idle";
              }
              this._previousScreenPoint = this._clickScreenPoint;
              this.lastPointerInfo = info2;
              switch (this._clickState) {
                case "pendingDouble": {
                  this._clickState = "pendingTriple";
                  this._clickTimeout = this._getClickTimeout(this._clickState);
                  return {
                    ...info2,
                    type: "click",
                    name: "double_click",
                    phase: "down"
                  };
                }
                case "pendingTriple": {
                  this._clickState = "pendingQuadruple";
                  this._clickTimeout = this._getClickTimeout(this._clickState);
                  return {
                    ...info2,
                    type: "click",
                    name: "triple_click",
                    phase: "down"
                  };
                }
                case "pendingQuadruple": {
                  this._clickState = "pendingOverflow";
                  this._clickTimeout = this._getClickTimeout(this._clickState);
                  return {
                    ...info2,
                    type: "click",
                    name: "quadruple_click",
                    phase: "down"
                  };
                }
                case "idle": {
                  this._clickState = "pendingDouble";
                  break;
                }
                case "pendingOverflow": {
                  this._clickState = "overflow";
                  break;
                }
                default: {
                }
              }
              this._clickTimeout = this._getClickTimeout(this._clickState);
              return info2;
            }
            case "pointer_up": {
              if (!this._clickState)
                return info2;
              this._clickScreenPoint = Vec.From(info2.point);
              switch (this._clickState) {
                case "pendingTriple": {
                  return {
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "double_click",
                    phase: "up"
                  };
                }
                case "pendingQuadruple": {
                  return {
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "triple_click",
                    phase: "up"
                  };
                }
                case "pendingOverflow": {
                  return {
                    ...this.lastPointerInfo,
                    type: "click",
                    name: "quadruple_click",
                    phase: "up"
                  };
                }
                default: {
                }
              }
              return info2;
            }
            case "pointer_move": {
              if (this._clickState !== "idle" && this._clickScreenPoint && Vec.Dist2(this._clickScreenPoint, this.editor.inputs.currentScreenPoint) > (this.editor.getInstanceState().isCoarsePointer ? this.editor.options.coarseDragDistanceSquared : this.editor.options.dragDistanceSquared)) {
                this.cancelDoubleClickTimeout();
              }
              return info2;
            }
          }
          return info2;
        });
        __publicField(this, "cancelDoubleClickTimeout", () => {
          this._clickTimeout = clearTimeout(this._clickTimeout);
          this._clickState = "idle";
        });
        this.editor = editor;
      }
      get clickState() {
        return this._clickState;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/EdgeScrollManager.mjs
var EdgeScrollManager;
var init_EdgeScrollManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/EdgeScrollManager.mjs"() {
    init_Vec();
    init_easings();
    EdgeScrollManager = class {
      constructor(editor) {
        __publicField(this, "_isEdgeScrolling", false);
        __publicField(this, "_edgeScrollDuration", -1);
        this.editor = editor;
      }
      updateEdgeScrolling(elapsed) {
        const { editor } = this;
        const edgeScrollProximityFactor = this.getEdgeScroll();
        if (edgeScrollProximityFactor.x === 0 && edgeScrollProximityFactor.y === 0) {
          if (this._isEdgeScrolling) {
            this._isEdgeScrolling = false;
            this._edgeScrollDuration = 0;
          }
        } else {
          if (!this._isEdgeScrolling) {
            this._isEdgeScrolling = true;
            this._edgeScrollDuration = 0;
          }
          this._edgeScrollDuration += elapsed;
          if (this._edgeScrollDuration > editor.options.edgeScrollDelay) {
            const eased = editor.options.edgeScrollEaseDuration > 0 ? EASINGS.easeInCubic(Math.min(1, this._edgeScrollDuration / (editor.options.edgeScrollDelay + editor.options.edgeScrollEaseDuration))) : 1;
            this.moveCameraWhenCloseToEdge({
              x: edgeScrollProximityFactor.x * eased,
              y: edgeScrollProximityFactor.y * eased
            });
          }
        }
      }
      getEdgeProximityFactors(position, dimension, isCoarse, insetStart, insetEnd) {
        const { editor } = this;
        const dist = editor.options.edgeScrollDistance;
        const pw = isCoarse ? editor.options.coarsePointerWidth : 0;
        const pMin = position - pw;
        const pMax = position + pw;
        const min4 = insetStart ? 0 : dist;
        const max3 = insetEnd ? dimension : dimension - dist;
        if (pMin < min4) {
          return Math.min(1, (min4 - pMin) / dist);
        } else if (pMax > max3) {
          return -Math.min(1, (pMax - max3) / dist);
        }
        return 0;
      }
      getEdgeScroll() {
        const { editor } = this;
        const {
          inputs: {
            currentScreenPoint: { x: x2, y: y2 }
          }
        } = editor;
        const screenBounds = editor.getViewportScreenBounds();
        const {
          isCoarsePointer,
          insets: [t3, r2, b2, l2]
        } = editor.getInstanceState();
        const proximityFactorX = this.getEdgeProximityFactors(x2, screenBounds.w, isCoarsePointer, l2, r2);
        const proximityFactorY = this.getEdgeProximityFactors(y2, screenBounds.h, isCoarsePointer, t3, b2);
        return {
          x: proximityFactorX,
          y: proximityFactorY
        };
      }
      moveCameraWhenCloseToEdge(proximityFactor) {
        const { editor } = this;
        if (!editor.inputs.isDragging || editor.inputs.isPanning || editor.getCameraOptions().isLocked)
          return;
        if (proximityFactor.x === 0 && proximityFactor.y === 0)
          return;
        const screenBounds = editor.getViewportScreenBounds();
        const screenSizeFactorX = screenBounds.w < 1e3 ? 0.612 : 1;
        const screenSizeFactorY = screenBounds.h < 1e3 ? 0.612 : 1;
        const zoomLevel = editor.getZoomLevel();
        const pxSpeed = editor.user.getEdgeScrollSpeed() * editor.options.edgeScrollSpeed;
        const scrollDeltaX = pxSpeed * proximityFactor.x * screenSizeFactorX / zoomLevel;
        const scrollDeltaY = pxSpeed * proximityFactor.y * screenSizeFactorY / zoomLevel;
        const { x: x2, y: y2, z } = editor.getCamera();
        editor.setCamera(new Vec(x2 + scrollDeltaX, y2 + scrollDeltaY, z));
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/EnvironmentManager.mjs
var EnvironmentManager;
var init_EnvironmentManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/EnvironmentManager.mjs"() {
    EnvironmentManager = class {
      constructor(editor) {
        __publicField(this, "isSafari");
        __publicField(this, "isIos");
        __publicField(this, "isChromeForIos");
        __publicField(this, "isFirefox");
        __publicField(this, "isAndroid");
        this.editor = editor;
        if (typeof window !== "undefined" && "navigator" in window) {
          this.isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
          this.isIos = !!navigator.userAgent.match(/iPad/i) || !!navigator.userAgent.match(/iPhone/i);
          this.isChromeForIos = /crios.*safari/i.test(navigator.userAgent);
          this.isFirefox = /firefox/i.test(navigator.userAgent);
          this.isAndroid = /android/i.test(navigator.userAgent);
        } else {
          this.isSafari = false;
          this.isIos = false;
          this.isChromeForIos = false;
          this.isFirefox = false;
          this.isAndroid = false;
        }
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/FocusManager.mjs
var FocusManager;
var init_FocusManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/FocusManager.mjs"() {
    FocusManager = class {
      constructor(editor, autoFocus) {
        __publicField(this, "disposeSideEffectListener");
        this.editor = editor;
        this.disposeSideEffectListener = editor.sideEffects.registerAfterChangeHandler("instance", (prev, next) => {
          if (prev.isFocused !== next.isFocused) {
            next.isFocused ? this.focus() : this.blur();
            this.updateContainerClass();
          }
        });
        const currentFocusState = editor.getInstanceState().isFocused;
        if (autoFocus !== currentFocusState) {
          editor.updateInstanceState({ isFocused: !!autoFocus });
        }
        this.updateContainerClass();
      }
      updateContainerClass() {
        const container = this.editor.getContainer();
        const instanceState = this.editor.getInstanceState();
        if (instanceState.isFocused) {
          container.classList.add("tl-container__focused");
        } else {
          container.classList.remove("tl-container__focused");
        }
      }
      focus() {
        this.editor.getContainer().focus();
      }
      blur() {
        this.editor.complete();
        this.editor.getContainer().blur();
      }
      dispose() {
        this.disposeSideEffectListener?.();
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/Stack.mjs
function stack(items) {
  if (items) {
    let result = EMPTY_STACK_ITEM;
    while (items.length) {
      result = result.push(items.pop());
    }
    return result;
  }
  return EMPTY_STACK_ITEM;
}
var EmptyStackItem, EMPTY_STACK_ITEM, StackItem;
var init_Stack = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/Stack.mjs"() {
    init_dist_esm();
    EmptyStackItem = class {
      constructor() {
        __publicField(this, "length", 0);
        __publicField(this, "head", null);
        __publicField(this, "tail", this);
      }
      push(head) {
        return new StackItem(head, this);
      }
      toArray() {
        return EMPTY_ARRAY;
      }
      [Symbol.iterator]() {
        return {
          next() {
            return { value: void 0, done: true };
          }
        };
      }
    };
    EMPTY_STACK_ITEM = new EmptyStackItem();
    StackItem = class {
      constructor(head, tail) {
        __publicField(this, "length");
        this.head = head;
        this.tail = tail;
        this.length = tail.length + 1;
      }
      push(head) {
        return new StackItem(head, this);
      }
      toArray() {
        return Array.from(this);
      }
      [Symbol.iterator]() {
        let stack2 = this;
        return {
          next() {
            if (stack2.length) {
              const value = stack2.head;
              stack2 = stack2.tail;
              return { value, done: false };
            } else {
              return { value: void 0, done: true };
            }
          }
        };
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/HistoryManager.mjs
var HistoryManager, modeToState, PendingDiff;
var init_HistoryManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/HistoryManager.mjs"() {
    init_dist_esm();
    init_dist_esm4();
    init_dist_esm2();
    init_uniqueId();
    init_Stack();
    HistoryManager = class {
      constructor(opts) {
        __publicField(this, "store");
        __publicField(this, "dispose");
        __publicField(this, "state", "recording");
        __publicField(this, "pendingDiff", new PendingDiff());
        __publicField(this, "stacks", atom2("HistoryManager.stacks", {
          undos: stack(),
          redos: stack()
        }, {
          isEqual: (a2, b2) => a2.undos === b2.undos && a2.redos === b2.redos
        }));
        __publicField(this, "annotateError");
        __publicField(this, "_isInBatch", false);
        __publicField(this, "batch", (fn3, opts) => {
          const previousState = this.state;
          if (previousState !== "paused" && opts?.history) {
            this.state = modeToState[opts.history];
          }
          try {
            if (this._isInBatch) {
              transact(fn3);
              return this;
            }
            this._isInBatch = true;
            try {
              transact(fn3);
            } catch (error2) {
              this.annotateError(error2);
              throw error2;
            } finally {
              this._isInBatch = false;
            }
            return this;
          } finally {
            this.state = previousState;
          }
        });
        __publicField(this, "_undo", ({
          pushToRedoStack,
          toMark = void 0
        }) => {
          const previousState = this.state;
          this.state = "paused";
          try {
            let { undos, redos } = this.stacks.get();
            const pendingDiff = this.pendingDiff.clear();
            const isPendingDiffEmpty = isRecordsDiffEmpty(pendingDiff);
            const diffToUndo = reverseRecordsDiff(pendingDiff);
            if (pushToRedoStack && !isPendingDiffEmpty) {
              redos = redos.push({ type: "diff", diff: pendingDiff });
            }
            let didFindMark = false;
            if (isPendingDiffEmpty) {
              while (undos.head?.type === "stop") {
                const mark = undos.head;
                undos = undos.tail;
                if (pushToRedoStack) {
                  redos = redos.push(mark);
                }
                if (mark.id === toMark) {
                  didFindMark = true;
                  break;
                }
              }
            }
            if (!didFindMark) {
              loop:
                while (undos.head) {
                  const undo = undos.head;
                  undos = undos.tail;
                  if (pushToRedoStack) {
                    redos = redos.push(undo);
                  }
                  switch (undo.type) {
                    case "diff":
                      squashRecordDiffsMutable(diffToUndo, [reverseRecordsDiff(undo.diff)]);
                      break;
                    case "stop":
                      if (!toMark)
                        break loop;
                      if (undo.id === toMark)
                        break loop;
                      break;
                    default:
                      exhaustiveSwitchError(undo);
                  }
                }
            }
            this.store.applyDiff(diffToUndo, { ignoreEphemeralKeys: true });
            this.store.ensureStoreIsUsable();
            this.stacks.set({ undos, redos });
          } finally {
            this.state = previousState;
          }
          return this;
        });
        __publicField(this, "undo", () => {
          this._undo({ pushToRedoStack: true });
          return this;
        });
        __publicField(this, "redo", () => {
          const previousState = this.state;
          this.state = "paused";
          try {
            this.flushPendingDiff();
            let { undos, redos } = this.stacks.get();
            if (redos.length === 0) {
              return this;
            }
            while (redos.head?.type === "stop") {
              undos = undos.push(redos.head);
              redos = redos.tail;
            }
            const diffToRedo = createEmptyRecordsDiff();
            while (redos.head) {
              const redo = redos.head;
              undos = undos.push(redo);
              redos = redos.tail;
              if (redo.type === "diff") {
                squashRecordDiffsMutable(diffToRedo, [redo.diff]);
              } else {
                break;
              }
            }
            this.store.applyDiff(diffToRedo, { ignoreEphemeralKeys: true });
            this.store.ensureStoreIsUsable();
            this.stacks.set({ undos, redos });
          } finally {
            this.state = previousState;
          }
          return this;
        });
        __publicField(this, "bail", () => {
          this._undo({ pushToRedoStack: false });
          return this;
        });
        __publicField(this, "bailToMark", (id) => {
          this._undo({ pushToRedoStack: false, toMark: id });
          return this;
        });
        __publicField(this, "squashToMark", (id) => {
          let top2 = this.stacks.get().undos;
          const popped = [];
          while (top2.head && !(top2.head.type === "stop" && top2.head.id === id)) {
            if (top2.head.type === "diff") {
              popped.push(top2.head.diff);
            }
            top2 = top2.tail;
          }
          if (!top2.head || top2.head?.id !== id) {
            console.error("Could not find mark to squash to: ", id);
            return this;
          }
          if (popped.length === 0) {
            return this;
          }
          const diff = createEmptyRecordsDiff();
          squashRecordDiffsMutable(diff, popped.reverse());
          this.stacks.update(({ redos }) => ({
            undos: top2.push({
              type: "diff",
              diff
            }),
            redos
          }));
          return this;
        });
        __publicField(this, "mark", (id = uniqueId()) => {
          transact(() => {
            this.flushPendingDiff();
            this.stacks.update(({ undos, redos }) => ({ undos: undos.push({ type: "stop", id }), redos }));
          });
          return id;
        });
        this.store = opts.store;
        this.annotateError = opts.annotateError ?? noop;
        this.dispose = this.store.addHistoryInterceptor((entry, source) => {
          if (source !== "user")
            return;
          switch (this.state) {
            case "recording":
              this.pendingDiff.apply(entry.changes);
              this.stacks.update(({ undos }) => ({ undos, redos: stack() }));
              break;
            case "recordingPreserveRedoStack":
              this.pendingDiff.apply(entry.changes);
              break;
            case "paused":
              break;
            default:
              exhaustiveSwitchError(this.state);
          }
        });
      }
      flushPendingDiff() {
        if (this.pendingDiff.isEmpty())
          return;
        const diff = this.pendingDiff.clear();
        this.stacks.update(({ undos, redos }) => ({
          undos: undos.push({ type: "diff", diff }),
          redos
        }));
      }
      getNumUndos() {
        return this.stacks.get().undos.length + (this.pendingDiff.isEmpty() ? 0 : 1);
      }
      getNumRedos() {
        return this.stacks.get().redos.length;
      }
      clear() {
        this.stacks.set({ undos: stack(), redos: stack() });
        this.pendingDiff.clear();
      }
      debug() {
        const { undos, redos } = this.stacks.get();
        return {
          undos: undos.toArray(),
          redos: redos.toArray(),
          pendingDiff: this.pendingDiff.debug(),
          state: this.state
        };
      }
    };
    modeToState = {
      record: "recording",
      "record-preserveRedoStack": "recordingPreserveRedoStack",
      ignore: "paused"
    };
    PendingDiff = class {
      constructor() {
        __publicField(this, "diff", createEmptyRecordsDiff());
        __publicField(this, "isEmptyAtom", atom2("PendingDiff.isEmpty", true));
      }
      clear() {
        const diff = this.diff;
        this.diff = createEmptyRecordsDiff();
        this.isEmptyAtom.set(true);
        return diff;
      }
      isEmpty() {
        return this.isEmptyAtom.get();
      }
      apply(diff) {
        squashRecordDiffsMutable(this.diff, [diff]);
        this.isEmptyAtom.set(isRecordsDiffEmpty(this.diff));
      }
      debug() {
        return { diff: this.diff, isEmpty: this.isEmpty() };
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/ScribbleManager.mjs
var ScribbleManager;
var init_ScribbleManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/ScribbleManager.mjs"() {
    init_Vec();
    init_uniqueId();
    ScribbleManager = class {
      constructor(editor) {
        __publicField(this, "scribbleItems", /* @__PURE__ */ new Map());
        __publicField(this, "state", "paused");
        __publicField(this, "addScribble", (scribble, id = uniqueId()) => {
          const item = {
            id,
            scribble: {
              id,
              size: 20,
              color: "accent",
              opacity: 0.8,
              delay: 0,
              points: [],
              shrink: 0.1,
              taper: true,
              ...scribble,
              state: "starting"
            },
            timeoutMs: 0,
            delayRemaining: scribble.delay ?? 0,
            prev: null,
            next: null
          };
          this.scribbleItems.set(id, item);
          return item;
        });
        __publicField(this, "stop", (id) => {
          const item = this.scribbleItems.get(id);
          if (!item)
            throw Error(`Scribble with id ${id} not found`);
          item.delayRemaining = Math.min(item.delayRemaining, 200);
          item.scribble.state = "stopping";
          return item;
        });
        __publicField(this, "addPoint", (id, x2, y2) => {
          const item = this.scribbleItems.get(id);
          if (!item)
            throw Error(`Scribble with id ${id} not found`);
          const { prev } = item;
          const point = { x: x2, y: y2, z: 0.5 };
          if (!prev || Vec.Dist(prev, point) >= 1) {
            item.next = point;
          }
          return item;
        });
        __publicField(this, "tick", (elapsed) => {
          if (this.scribbleItems.size === 0)
            return;
          this.editor.run(() => {
            this.scribbleItems.forEach((item) => {
              if (item.scribble.state === "starting") {
                const { next: next2, prev: prev2 } = item;
                if (next2 && next2 !== prev2) {
                  item.prev = next2;
                  item.scribble.points.push(next2);
                }
                if (item.scribble.points.length > 8) {
                  item.scribble.state = "active";
                }
                return;
              }
              if (item.delayRemaining > 0) {
                item.delayRemaining = Math.max(0, item.delayRemaining - elapsed);
              }
              item.timeoutMs += elapsed;
              if (item.timeoutMs >= 16) {
                item.timeoutMs = 0;
              }
              const { delayRemaining, timeoutMs, prev, next, scribble } = item;
              switch (scribble.state) {
                case "active": {
                  if (next && next !== prev) {
                    item.prev = next;
                    scribble.points.push(next);
                    if (delayRemaining === 0) {
                      if (scribble.points.length > 8) {
                        scribble.points.shift();
                      }
                    }
                  } else {
                    if (timeoutMs === 0) {
                      if (scribble.points.length > 1) {
                        scribble.points.shift();
                      } else {
                        item.delayRemaining = scribble.delay;
                      }
                    }
                  }
                  break;
                }
                case "stopping": {
                  if (item.delayRemaining === 0) {
                    if (timeoutMs === 0) {
                      if (scribble.points.length === 1) {
                        this.scribbleItems.delete(item.id);
                        return;
                      }
                      if (scribble.shrink) {
                        scribble.size = Math.max(1, scribble.size * (1 - scribble.shrink));
                      }
                      scribble.points.shift();
                    }
                  }
                  break;
                }
                case "paused": {
                  break;
                }
              }
            });
            this.editor.updateInstanceState({
              scribbles: Array.from(this.scribbleItems.values()).map(({ scribble }) => ({
                ...scribble,
                points: [...scribble.points]
              })).slice(-5)
            });
          });
        });
        this.editor = editor;
      }
      reset() {
        this.editor.updateInstanceState({ scribbles: [] });
        this.scribbleItems.clear();
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/BoundsSnaps.mjs
function findAdjacentGaps(gaps, shapeId, gapLength, direction, intersection) {
  const matches = gaps.filter((gap) => (direction === "forward" ? gap.startNode.id === shapeId : gap.endNode.id === shapeId) && round(gap.length) === round(gapLength) && rangeIntersection(gap.breadthIntersection[0], gap.breadthIntersection[1], intersection[0], intersection[1]));
  if (matches.length === 0)
    return [];
  const nextNodes = /* @__PURE__ */ new Set();
  matches.forEach((match) => {
    const node = direction === "forward" ? match.endNode.id : match.startNode.id;
    if (!nextNodes.has(node)) {
      nextNodes.add(node);
      const foundGaps = findAdjacentGaps(gaps, node, gapLength, direction, rangeIntersection(match.breadthIntersection[0], match.breadthIntersection[1], intersection[0], intersection[1]));
      matches.push(...foundGaps);
    }
  });
  return matches;
}
function dedupeGapSnaps(snaps) {
  snaps.sort((a2, b2) => b2.gaps.length - a2.gaps.length);
  for (let i2 = snaps.length - 1; i2 > 0; i2--) {
    const snap = snaps[i2];
    for (let j2 = i2 - 1; j2 >= 0; j2--) {
      const otherSnap = snaps[j2];
      if (otherSnap.direction === snap.direction && snap.gaps.every((gap) => otherSnap.gaps.some((otherGap) => round(gap.startEdge[0].x) === round(otherGap.startEdge[0].x) && round(gap.startEdge[0].y) === round(otherGap.startEdge[0].y) && round(gap.startEdge[1].x) === round(otherGap.startEdge[1].x) && round(gap.startEdge[1].y) === round(otherGap.startEdge[1].y)) && otherSnap.gaps.some((otherGap) => round(gap.endEdge[0].x) === round(otherGap.endEdge[0].x) && round(gap.endEdge[0].y) === round(otherGap.endEdge[0].y) && round(gap.endEdge[1].x) === round(otherGap.endEdge[1].x) && round(gap.endEdge[1].y) === round(otherGap.endEdge[1].y)))) {
        snaps.splice(i2, 1);
        break;
      }
    }
  }
}
function getResizeSnapPointsForHandle(handle, selectionPageBounds) {
  const { minX, maxX, minY, maxY } = selectionPageBounds;
  const result = [];
  switch (handle) {
    case "top":
    case "left":
    case "top_left":
    case "any":
      result.push({
        id: "top_left",
        handle: "top_left",
        x: minX,
        y: minY
      });
  }
  switch (handle) {
    case "top":
    case "right":
    case "top_right":
    case "any":
      result.push({
        id: "top_right",
        handle: "top_right",
        x: maxX,
        y: minY
      });
  }
  switch (handle) {
    case "bottom":
    case "right":
    case "bottom_right":
    case "any":
      result.push({
        id: "bottom_right",
        handle: "bottom_right",
        x: maxX,
        y: maxY
      });
  }
  switch (handle) {
    case "bottom":
    case "left":
    case "bottom_left":
    case "any":
      result.push({
        id: "bottom_left",
        handle: "bottom_left",
        x: minX,
        y: maxY
      });
  }
  return result;
}
var __defProp2, __getOwnPropDesc2, __decorateClass, round, BoundsSnaps;
var init_BoundsSnaps = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/BoundsSnaps.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    init_Box();
    init_Mat();
    init_Vec();
    init_utils();
    init_uniqueId();
    __defProp2 = Object.defineProperty;
    __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    __decorateClass = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc2(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp2(target, key, result);
      return result;
    };
    round = (x2) => {
      const decimalPlacesTolerance = 8;
      return Math.round(x2 * 10 ** decimalPlacesTolerance) / 10 ** decimalPlacesTolerance;
    };
    BoundsSnaps = class {
      constructor(manager) {
        __publicField(this, "editor");
        this.manager = manager;
        this.editor = manager.editor;
      }
      getSnapPointsCache() {
        const { editor } = this;
        return editor.store.createComputedCache("snapPoints", (shape) => {
          const pageTransform = editor.getShapePageTransform(shape.id);
          if (!pageTransform)
            return void 0;
          const boundsSnapGeometry = editor.getShapeUtil(shape).getBoundsSnapGeometry(shape);
          const snapPoints = boundsSnapGeometry.points ?? editor.getShapeGeometry(shape).bounds.cornersAndCenter;
          if (!pageTransform || !snapPoints)
            return void 0;
          return snapPoints.map((point, i2) => {
            const { x: x2, y: y2 } = Mat.applyToPoint(pageTransform, point);
            return { x: x2, y: y2, id: `${shape.id}:${i2}` };
          });
        });
      }
      getSnapPoints(shapeId) {
        return this.getSnapPointsCache().get(shapeId) ?? [];
      }
      getSnappablePoints() {
        const snapPointsCache = this.getSnapPointsCache();
        const snappableShapes = this.manager.getSnappableShapes();
        const result = [];
        for (const shapeId of snappableShapes) {
          const snapPoints = snapPointsCache.get(shapeId);
          if (snapPoints) {
            result.push(...snapPoints);
          }
        }
        return result;
      }
      getSnappableGapNodes() {
        return Array.from(this.manager.getSnappableShapes(), (shapeId) => ({
          id: shapeId,
          pageBounds: assertExists(this.editor.getShapePageBounds(shapeId))
        }));
      }
      getVisibleGaps() {
        const horizontal = [];
        const vertical = [];
        let startNode, endNode;
        const sortedShapesOnCurrentPageHorizontal = this.getSnappableGapNodes().sort((a2, b2) => {
          return a2.pageBounds.minX - b2.pageBounds.minX;
        });
        for (let i2 = 0; i2 < sortedShapesOnCurrentPageHorizontal.length; i2++) {
          startNode = sortedShapesOnCurrentPageHorizontal[i2];
          for (let j2 = i2 + 1; j2 < sortedShapesOnCurrentPageHorizontal.length; j2++) {
            endNode = sortedShapesOnCurrentPageHorizontal[j2];
            if (startNode.pageBounds.maxX < endNode.pageBounds.minX && rangesOverlap(startNode.pageBounds.minY, startNode.pageBounds.maxY, endNode.pageBounds.minY, endNode.pageBounds.maxY)) {
              horizontal.push({
                startNode,
                endNode,
                startEdge: [
                  new Vec(startNode.pageBounds.maxX, startNode.pageBounds.minY),
                  new Vec(startNode.pageBounds.maxX, startNode.pageBounds.maxY)
                ],
                endEdge: [
                  new Vec(endNode.pageBounds.minX, endNode.pageBounds.minY),
                  new Vec(endNode.pageBounds.minX, endNode.pageBounds.maxY)
                ],
                length: endNode.pageBounds.minX - startNode.pageBounds.maxX,
                breadthIntersection: rangeIntersection(startNode.pageBounds.minY, startNode.pageBounds.maxY, endNode.pageBounds.minY, endNode.pageBounds.maxY)
              });
            }
          }
        }
        const sortedShapesOnCurrentPageVertical = sortedShapesOnCurrentPageHorizontal.sort((a2, b2) => {
          return a2.pageBounds.minY - b2.pageBounds.minY;
        });
        for (let i2 = 0; i2 < sortedShapesOnCurrentPageVertical.length; i2++) {
          startNode = sortedShapesOnCurrentPageVertical[i2];
          for (let j2 = i2 + 1; j2 < sortedShapesOnCurrentPageVertical.length; j2++) {
            endNode = sortedShapesOnCurrentPageVertical[j2];
            if (startNode.pageBounds.maxY < endNode.pageBounds.minY && rangesOverlap(startNode.pageBounds.minX, startNode.pageBounds.maxX, endNode.pageBounds.minX, endNode.pageBounds.maxX)) {
              vertical.push({
                startNode,
                endNode,
                startEdge: [
                  new Vec(startNode.pageBounds.minX, startNode.pageBounds.maxY),
                  new Vec(startNode.pageBounds.maxX, startNode.pageBounds.maxY)
                ],
                endEdge: [
                  new Vec(endNode.pageBounds.minX, endNode.pageBounds.minY),
                  new Vec(endNode.pageBounds.maxX, endNode.pageBounds.minY)
                ],
                length: endNode.pageBounds.minY - startNode.pageBounds.maxY,
                breadthIntersection: rangeIntersection(startNode.pageBounds.minX, startNode.pageBounds.maxX, endNode.pageBounds.minX, endNode.pageBounds.maxX)
              });
            }
          }
        }
        return { horizontal, vertical };
      }
      snapTranslateShapes({
        lockedAxis,
        initialSelectionPageBounds,
        initialSelectionSnapPoints,
        dragDelta
      }) {
        const snapThreshold = this.manager.getSnapThreshold();
        const visibleSnapPointsNotInSelection = this.getSnappablePoints();
        const selectionPageBounds = initialSelectionPageBounds.clone().translate(dragDelta);
        const selectionSnapPoints = initialSelectionSnapPoints.map(({ x: x2, y: y2 }, i2) => ({
          id: "selection:" + i2,
          x: x2 + dragDelta.x,
          y: y2 + dragDelta.y
        }));
        const otherNodeSnapPoints = visibleSnapPointsNotInSelection;
        const nearestSnapsX = [];
        const nearestSnapsY = [];
        const minOffset = new Vec(snapThreshold, snapThreshold);
        this.collectPointSnaps({
          minOffset,
          nearestSnapsX,
          nearestSnapsY,
          otherNodeSnapPoints,
          selectionSnapPoints
        });
        this.collectGapSnaps({
          selectionPageBounds,
          nearestSnapsX,
          nearestSnapsY,
          minOffset
        });
        const nudge = new Vec(lockedAxis === "x" ? 0 : nearestSnapsX[0]?.nudge ?? 0, lockedAxis === "y" ? 0 : nearestSnapsY[0]?.nudge ?? 0);
        minOffset.x = 0;
        minOffset.y = 0;
        nearestSnapsX.length = 0;
        nearestSnapsY.length = 0;
        selectionSnapPoints.forEach((s2) => {
          s2.x += nudge.x;
          s2.y += nudge.y;
        });
        selectionPageBounds.translate(nudge);
        this.collectPointSnaps({
          minOffset,
          nearestSnapsX,
          nearestSnapsY,
          otherNodeSnapPoints,
          selectionSnapPoints
        });
        this.collectGapSnaps({
          selectionPageBounds,
          nearestSnapsX,
          nearestSnapsY,
          minOffset
        });
        const pointSnapsLines = this.getPointSnapLines({
          nearestSnapsX,
          nearestSnapsY
        });
        const gapSnapLines = this.getGapSnapLines({
          selectionPageBounds,
          nearestSnapsX,
          nearestSnapsY
        });
        this.manager.setIndicators([...gapSnapLines, ...pointSnapsLines]);
        return { nudge };
      }
      snapResizeShapes({
        initialSelectionPageBounds,
        dragDelta,
        handle: originalHandle,
        isAspectRatioLocked,
        isResizingFromCenter
      }) {
        const snapThreshold = this.manager.getSnapThreshold();
        const {
          box: unsnappedResizedPageBounds,
          scaleX,
          scaleY
        } = Box.Resize(initialSelectionPageBounds, originalHandle, isResizingFromCenter ? dragDelta.x * 2 : dragDelta.x, isResizingFromCenter ? dragDelta.y * 2 : dragDelta.y, isAspectRatioLocked);
        let handle = originalHandle;
        if (scaleX < 0) {
          handle = flipSelectionHandleX(handle);
        }
        if (scaleY < 0) {
          handle = flipSelectionHandleY(handle);
        }
        if (isResizingFromCenter) {
          unsnappedResizedPageBounds.center = initialSelectionPageBounds.center;
        }
        const isXLocked = handle === "top" || handle === "bottom";
        const isYLocked = handle === "left" || handle === "right";
        const selectionSnapPoints = getResizeSnapPointsForHandle(handle, unsnappedResizedPageBounds);
        const otherNodeSnapPoints = this.getSnappablePoints();
        const nearestSnapsX = [];
        const nearestSnapsY = [];
        const minOffset = new Vec(snapThreshold, snapThreshold);
        this.collectPointSnaps({
          minOffset,
          nearestSnapsX,
          nearestSnapsY,
          otherNodeSnapPoints,
          selectionSnapPoints
        });
        const nudge = new Vec(isXLocked ? 0 : nearestSnapsX[0]?.nudge ?? 0, isYLocked ? 0 : nearestSnapsY[0]?.nudge ?? 0);
        if (isAspectRatioLocked && isSelectionCorner(handle) && nudge.len() !== 0) {
          const primaryNudgeAxis = nearestSnapsX.length && nearestSnapsY.length ? Math.abs(nudge.x) < Math.abs(nudge.y) ? "x" : "y" : nearestSnapsX.length ? "x" : "y";
          const ratio = initialSelectionPageBounds.aspectRatio;
          if (primaryNudgeAxis === "x") {
            nearestSnapsY.length = 0;
            nudge.y = nudge.x / ratio;
            if (handle === "bottom_left" || handle === "top_right") {
              nudge.y = -nudge.y;
            }
          } else {
            nearestSnapsX.length = 0;
            nudge.x = nudge.y * ratio;
            if (handle === "bottom_left" || handle === "top_right") {
              nudge.x = -nudge.x;
            }
          }
        }
        const snappedDelta = Vec.Add(dragDelta, nudge);
        const { box: snappedResizedPageBounds } = Box.Resize(initialSelectionPageBounds, originalHandle, isResizingFromCenter ? snappedDelta.x * 2 : snappedDelta.x, isResizingFromCenter ? snappedDelta.y * 2 : snappedDelta.y, isAspectRatioLocked);
        if (isResizingFromCenter) {
          snappedResizedPageBounds.center = initialSelectionPageBounds.center;
        }
        const snappedSelectionPoints = getResizeSnapPointsForHandle("any", snappedResizedPageBounds);
        nearestSnapsX.length = 0;
        nearestSnapsY.length = 0;
        minOffset.x = 0;
        minOffset.y = 0;
        this.collectPointSnaps({
          minOffset,
          nearestSnapsX,
          nearestSnapsY,
          otherNodeSnapPoints,
          selectionSnapPoints: snappedSelectionPoints
        });
        const pointSnaps = this.getPointSnapLines({
          nearestSnapsX,
          nearestSnapsY
        });
        this.manager.setIndicators([...pointSnaps]);
        return { nudge };
      }
      collectPointSnaps({
        selectionSnapPoints,
        otherNodeSnapPoints,
        minOffset,
        nearestSnapsX,
        nearestSnapsY
      }) {
        for (const thisSnapPoint of selectionSnapPoints) {
          for (const otherSnapPoint of otherNodeSnapPoints) {
            const offset5 = Vec.Sub(thisSnapPoint, otherSnapPoint);
            const offsetX = Math.abs(offset5.x);
            const offsetY = Math.abs(offset5.y);
            if (round(offsetX) <= round(minOffset.x)) {
              if (round(offsetX) < round(minOffset.x)) {
                nearestSnapsX.length = 0;
              }
              nearestSnapsX.push({
                type: "points",
                points: { thisPoint: thisSnapPoint, otherPoint: otherSnapPoint },
                nudge: otherSnapPoint.x - thisSnapPoint.x
              });
              minOffset.x = offsetX;
            }
            if (round(offsetY) <= round(minOffset.y)) {
              if (round(offsetY) < round(minOffset.y)) {
                nearestSnapsY.length = 0;
              }
              nearestSnapsY.push({
                type: "points",
                points: { thisPoint: thisSnapPoint, otherPoint: otherSnapPoint },
                nudge: otherSnapPoint.y - thisSnapPoint.y
              });
              minOffset.y = offsetY;
            }
          }
        }
      }
      collectGapSnaps({
        selectionPageBounds,
        minOffset,
        nearestSnapsX,
        nearestSnapsY
      }) {
        const { horizontal, vertical } = this.getVisibleGaps();
        for (const gap of horizontal) {
          if (!rangesOverlap(gap.breadthIntersection[0], gap.breadthIntersection[1], selectionPageBounds.minY, selectionPageBounds.maxY)) {
            continue;
          }
          const gapMidX = gap.startEdge[0].x + gap.length / 2;
          const centerNudge = gapMidX - selectionPageBounds.center.x;
          const gapIsLargerThanSelection = gap.length > selectionPageBounds.width;
          if (gapIsLargerThanSelection && round(Math.abs(centerNudge)) <= round(minOffset.x)) {
            if (round(Math.abs(centerNudge)) < round(minOffset.x)) {
              nearestSnapsX.length = 0;
            }
            minOffset.x = Math.abs(centerNudge);
            const snap = {
              type: "gap_center",
              gap,
              nudge: centerNudge
            };
            const otherCenterSnap = nearestSnapsX.find(({ type }) => type === "gap_center");
            const gapBreadthsOverlap = otherCenterSnap && rangeIntersection(gap.breadthIntersection[0], gap.breadthIntersection[1], otherCenterSnap.gap.breadthIntersection[0], otherCenterSnap.gap.breadthIntersection[1]);
            if (otherCenterSnap && otherCenterSnap.gap.length > gap.length && gapBreadthsOverlap) {
              nearestSnapsX[nearestSnapsX.indexOf(otherCenterSnap)] = snap;
            } else if (!otherCenterSnap || !gapBreadthsOverlap) {
              nearestSnapsX.push(snap);
            }
          }
          const duplicationLeftX = gap.startNode.pageBounds.minX - gap.length;
          const selectionRightX = selectionPageBounds.maxX;
          const duplicationLeftNudge = duplicationLeftX - selectionRightX;
          if (round(Math.abs(duplicationLeftNudge)) <= round(minOffset.x)) {
            if (round(Math.abs(duplicationLeftNudge)) < round(minOffset.x)) {
              nearestSnapsX.length = 0;
            }
            minOffset.x = Math.abs(duplicationLeftNudge);
            nearestSnapsX.push({
              type: "gap_duplicate",
              gap,
              protrusionDirection: "left",
              nudge: duplicationLeftNudge
            });
          }
          const duplicationRightX = gap.endNode.pageBounds.maxX + gap.length;
          const selectionLeftX = selectionPageBounds.minX;
          const duplicationRightNudge = duplicationRightX - selectionLeftX;
          if (round(Math.abs(duplicationRightNudge)) <= round(minOffset.x)) {
            if (round(Math.abs(duplicationRightNudge)) < round(minOffset.x)) {
              nearestSnapsX.length = 0;
            }
            minOffset.x = Math.abs(duplicationRightNudge);
            nearestSnapsX.push({
              type: "gap_duplicate",
              gap,
              protrusionDirection: "right",
              nudge: duplicationRightNudge
            });
          }
        }
        for (const gap of vertical) {
          if (!rangesOverlap(gap.breadthIntersection[0], gap.breadthIntersection[1], selectionPageBounds.minX, selectionPageBounds.maxX)) {
            continue;
          }
          const gapMidY = gap.startEdge[0].y + gap.length / 2;
          const centerNudge = gapMidY - selectionPageBounds.center.y;
          const gapIsLargerThanSelection = gap.length > selectionPageBounds.height;
          if (gapIsLargerThanSelection && round(Math.abs(centerNudge)) <= round(minOffset.y)) {
            if (round(Math.abs(centerNudge)) < round(minOffset.y)) {
              nearestSnapsY.length = 0;
            }
            minOffset.y = Math.abs(centerNudge);
            const snap = {
              type: "gap_center",
              gap,
              nudge: centerNudge
            };
            const otherCenterSnap = nearestSnapsY.find(({ type }) => type === "gap_center");
            const gapBreadthsOverlap = otherCenterSnap && rangesOverlap(otherCenterSnap.gap.breadthIntersection[0], otherCenterSnap.gap.breadthIntersection[1], gap.breadthIntersection[0], gap.breadthIntersection[1]);
            if (otherCenterSnap && otherCenterSnap.gap.length > gap.length && gapBreadthsOverlap) {
              nearestSnapsY[nearestSnapsY.indexOf(otherCenterSnap)] = snap;
            } else if (!otherCenterSnap || !gapBreadthsOverlap) {
              nearestSnapsY.push(snap);
            }
            continue;
          }
          const duplicationTopY = gap.startNode.pageBounds.minY - gap.length;
          const selectionBottomY = selectionPageBounds.maxY;
          const duplicationTopNudge = duplicationTopY - selectionBottomY;
          if (round(Math.abs(duplicationTopNudge)) <= round(minOffset.y)) {
            if (round(Math.abs(duplicationTopNudge)) < round(minOffset.y)) {
              nearestSnapsY.length = 0;
            }
            minOffset.y = Math.abs(duplicationTopNudge);
            nearestSnapsY.push({
              type: "gap_duplicate",
              gap,
              protrusionDirection: "top",
              nudge: duplicationTopNudge
            });
          }
          const duplicationBottomY = gap.endNode.pageBounds.maxY + gap.length;
          const selectionTopY = selectionPageBounds.minY;
          const duplicationBottomNudge = duplicationBottomY - selectionTopY;
          if (round(Math.abs(duplicationBottomNudge)) <= round(minOffset.y)) {
            if (round(Math.abs(duplicationBottomNudge)) < round(minOffset.y)) {
              nearestSnapsY.length = 0;
            }
            minOffset.y = Math.abs(duplicationBottomNudge);
            nearestSnapsY.push({
              type: "gap_duplicate",
              gap,
              protrusionDirection: "bottom",
              nudge: duplicationBottomNudge
            });
          }
        }
      }
      getPointSnapLines({
        nearestSnapsX,
        nearestSnapsY
      }) {
        const snapGroupsX = {};
        const snapGroupsY = {};
        if (nearestSnapsX.length > 0) {
          for (const snap of nearestSnapsX) {
            if (snap.type === "points") {
              const key = round(snap.points.otherPoint.x);
              if (!snapGroupsX[key]) {
                snapGroupsX[key] = [];
              }
              snapGroupsX[key].push(snap.points);
            }
          }
        }
        if (nearestSnapsY.length > 0) {
          for (const snap of nearestSnapsY) {
            if (snap.type === "points") {
              const key = round(snap.points.otherPoint.y);
              if (!snapGroupsY[key]) {
                snapGroupsY[key] = [];
              }
              snapGroupsY[key].push(snap.points);
            }
          }
        }
        return Object.values(snapGroupsX).concat(Object.values(snapGroupsY)).map((snapGroup) => ({
          id: uniqueId(),
          type: "points",
          points: dedupe(snapGroup.map((snap) => Vec.From(snap.otherPoint)).concat(snapGroup.map((snap) => Vec.From(snap.thisPoint))), (a2, b2) => a2.equals(b2))
        }));
      }
      getGapSnapLines({
        selectionPageBounds,
        nearestSnapsX,
        nearestSnapsY
      }) {
        const { vertical, horizontal } = this.getVisibleGaps();
        const selectionSides = {
          top: selectionPageBounds.sides[0],
          right: selectionPageBounds.sides[1],
          bottom: [selectionPageBounds.corners[3], selectionPageBounds.corners[2]],
          left: [selectionPageBounds.corners[0], selectionPageBounds.corners[3]]
        };
        const result = [];
        if (nearestSnapsX.length > 0) {
          for (const snap of nearestSnapsX) {
            if (snap.type === "points")
              continue;
            const {
              gap: { breadthIntersection, startEdge, startNode, endNode, length, endEdge }
            } = snap;
            switch (snap.type) {
              case "gap_center": {
                const newGapsLength = (length - selectionPageBounds.width) / 2;
                const gapBreadthIntersection = rangeIntersection(breadthIntersection[0], breadthIntersection[1], selectionPageBounds.minY, selectionPageBounds.maxY);
                result.push({
                  type: "gaps",
                  direction: "horizontal",
                  id: uniqueId(),
                  gaps: [
                    ...findAdjacentGaps(horizontal, startNode.id, newGapsLength, "backward", gapBreadthIntersection),
                    {
                      startEdge,
                      endEdge: selectionSides.left
                    },
                    {
                      startEdge: selectionSides.right,
                      endEdge
                    },
                    ...findAdjacentGaps(horizontal, endNode.id, newGapsLength, "forward", gapBreadthIntersection)
                  ]
                });
                break;
              }
              case "gap_duplicate": {
                const gapBreadthIntersection = rangeIntersection(breadthIntersection[0], breadthIntersection[1], selectionPageBounds.minY, selectionPageBounds.maxY);
                result.push({
                  type: "gaps",
                  direction: "horizontal",
                  id: uniqueId(),
                  gaps: snap.protrusionDirection === "left" ? [
                    {
                      startEdge: selectionSides.right,
                      endEdge: startEdge.map((v2) => v2.clone().addXY(-startNode.pageBounds.width, 0))
                    },
                    { startEdge, endEdge },
                    ...findAdjacentGaps(horizontal, endNode.id, length, "forward", gapBreadthIntersection)
                  ] : [
                    ...findAdjacentGaps(horizontal, startNode.id, length, "backward", gapBreadthIntersection),
                    { startEdge, endEdge },
                    {
                      startEdge: endEdge.map((v2) => v2.clone().addXY(snap.gap.endNode.pageBounds.width, 0)),
                      endEdge: selectionSides.left
                    }
                  ]
                });
                break;
              }
            }
          }
        }
        if (nearestSnapsY.length > 0) {
          for (const snap of nearestSnapsY) {
            if (snap.type === "points")
              continue;
            const {
              gap: { breadthIntersection, startEdge, startNode, endNode, length, endEdge }
            } = snap;
            switch (snap.type) {
              case "gap_center": {
                const newGapsLength = (length - selectionPageBounds.height) / 2;
                const gapBreadthIntersection = rangeIntersection(breadthIntersection[0], breadthIntersection[1], selectionPageBounds.minX, selectionPageBounds.maxX);
                result.push({
                  type: "gaps",
                  direction: "vertical",
                  id: uniqueId(),
                  gaps: [
                    ...findAdjacentGaps(vertical, startNode.id, newGapsLength, "backward", gapBreadthIntersection),
                    {
                      startEdge,
                      endEdge: selectionSides.top
                    },
                    {
                      startEdge: selectionSides.bottom,
                      endEdge
                    },
                    ...findAdjacentGaps(vertical, snap.gap.endNode.id, newGapsLength, "forward", gapBreadthIntersection)
                  ]
                });
                break;
              }
              case "gap_duplicate":
                {
                  const gapBreadthIntersection = rangeIntersection(breadthIntersection[0], breadthIntersection[1], selectionPageBounds.minX, selectionPageBounds.maxX);
                  result.push({
                    type: "gaps",
                    direction: "vertical",
                    id: uniqueId(),
                    gaps: snap.protrusionDirection === "top" ? [
                      {
                        startEdge: selectionSides.bottom,
                        endEdge: startEdge.map((v2) => v2.clone().addXY(0, -startNode.pageBounds.height))
                      },
                      { startEdge, endEdge },
                      ...findAdjacentGaps(vertical, endNode.id, length, "forward", gapBreadthIntersection)
                    ] : [
                      ...findAdjacentGaps(vertical, startNode.id, length, "backward", gapBreadthIntersection),
                      { startEdge, endEdge },
                      {
                        startEdge: endEdge.map((v2) => v2.clone().addXY(0, endNode.pageBounds.height)),
                        endEdge: selectionSides.top
                      }
                    ]
                  });
                }
                break;
            }
          }
        }
        dedupeGapSnaps(result);
        return result;
      }
    };
    __decorateClass([
      computed
    ], BoundsSnaps.prototype, "getSnapPointsCache", 1);
    __decorateClass([
      computed
    ], BoundsSnaps.prototype, "getSnappablePoints", 1);
    __decorateClass([
      computed
    ], BoundsSnaps.prototype, "getSnappableGapNodes", 1);
    __decorateClass([
      computed
    ], BoundsSnaps.prototype, "getVisibleGaps", 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/HandleSnaps.mjs
var __defProp3, __getOwnPropDesc3, __decorateClass2, defaultGetSelfSnapOutline, defaultGetSelfSnapPoints, HandleSnaps;
var init_HandleSnaps = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/HandleSnaps.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    init_Vec();
    init_uniqueId();
    __defProp3 = Object.defineProperty;
    __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
    __decorateClass2 = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc3(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp3(target, key, result);
      return result;
    };
    defaultGetSelfSnapOutline = () => null;
    defaultGetSelfSnapPoints = () => [];
    HandleSnaps = class {
      constructor(manager) {
        __publicField(this, "editor");
        this.manager = manager;
        this.editor = manager.editor;
      }
      getSnapGeometryCache() {
        const { editor } = this;
        return editor.store.createComputedCache("handle snap geometry", (shape) => {
          const snapGeometry = editor.getShapeUtil(shape).getHandleSnapGeometry(shape);
          return {
            outline: snapGeometry.outline === void 0 ? editor.getShapeGeometry(shape) : snapGeometry.outline,
            points: snapGeometry.points ?? [],
            getSelfSnapOutline: snapGeometry.getSelfSnapOutline ?? defaultGetSelfSnapOutline,
            getSelfSnapPoints: snapGeometry.getSelfSnapPoints ?? defaultGetSelfSnapPoints
          };
        });
      }
      *iterateSnapPointsInPageSpace(currentShapeId, currentHandle) {
        const selfSnapPoints = this.getSnapGeometryCache().get(currentShapeId)?.getSelfSnapPoints(currentHandle);
        if (selfSnapPoints && selfSnapPoints.length) {
          const shapePageTransform = assertExists(this.editor.getShapePageTransform(currentShapeId));
          for (const point of selfSnapPoints) {
            yield shapePageTransform.applyToPoint(point);
          }
        }
        for (const shapeId of this.manager.getSnappableShapes()) {
          if (shapeId === currentShapeId)
            continue;
          const snapPoints = this.getSnapGeometryCache().get(shapeId)?.points;
          if (!snapPoints || !snapPoints.length)
            continue;
          const shapePageTransform = assertExists(this.editor.getShapePageTransform(shapeId));
          for (const point of snapPoints) {
            yield shapePageTransform.applyToPoint(point);
          }
        }
      }
      *iterateSnapOutlines(currentShapeId, currentHandle) {
        const selfSnapOutline = this.getSnapGeometryCache().get(currentShapeId)?.getSelfSnapOutline(currentHandle);
        if (selfSnapOutline) {
          yield { shapeId: currentShapeId, outline: selfSnapOutline };
        }
        for (const shapeId of this.manager.getSnappableShapes()) {
          if (shapeId === currentShapeId)
            continue;
          const snapOutline = this.getSnapGeometryCache().get(shapeId)?.outline;
          if (!snapOutline)
            continue;
          yield { shapeId, outline: snapOutline };
        }
      }
      getHandleSnapPosition({
        currentShapeId,
        handle,
        handleInPageSpace
      }) {
        const snapThreshold = this.manager.getSnapThreshold();
        let minDistanceForSnapPoint = snapThreshold;
        let nearestSnapPoint = null;
        for (const snapPoint of this.iterateSnapPointsInPageSpace(currentShapeId, handle)) {
          if (Vec.DistMin(handleInPageSpace, snapPoint, minDistanceForSnapPoint)) {
            minDistanceForSnapPoint = Vec.Dist(handleInPageSpace, snapPoint);
            nearestSnapPoint = snapPoint;
          }
        }
        if (nearestSnapPoint)
          return nearestSnapPoint;
        let minDistanceForOutline = snapThreshold;
        let nearestPointOnOutline = null;
        for (const { shapeId, outline } of this.iterateSnapOutlines(currentShapeId, handle)) {
          const shapePageTransform = assertExists(this.editor.getShapePageTransform(shapeId));
          const pointInShapeSpace = this.editor.getPointInShapeSpace(shapeId, handleInPageSpace);
          const nearestShapePointInShapeSpace = outline.nearestPoint(pointInShapeSpace);
          const nearestInPageSpace = shapePageTransform.applyToPoint(nearestShapePointInShapeSpace);
          if (Vec.DistMin(handleInPageSpace, nearestInPageSpace, minDistanceForOutline)) {
            minDistanceForOutline = Vec.Dist(handleInPageSpace, nearestInPageSpace);
            nearestPointOnOutline = nearestInPageSpace;
          }
        }
        if (nearestPointOnOutline)
          return nearestPointOnOutline;
        return null;
      }
      snapHandle({
        currentShapeId,
        handle
      }) {
        const currentShapeTransform = assertExists(this.editor.getShapePageTransform(currentShapeId));
        const handleInPageSpace = currentShapeTransform.applyToPoint(handle);
        const snapPosition = this.getHandleSnapPosition({ currentShapeId, handle, handleInPageSpace });
        if (snapPosition) {
          this.manager.setIndicators([
            {
              id: uniqueId(),
              type: "points",
              points: [snapPosition]
            }
          ]);
          return { nudge: Vec.Sub(snapPosition, handleInPageSpace) };
        }
        return null;
      }
    };
    __decorateClass2([
      computed
    ], HandleSnaps.prototype, "getSnapGeometryCache", 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/SnapManager.mjs
var __defProp4, __getOwnPropDesc4, __decorateClass3, SnapManager;
var init_SnapManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/SnapManager/SnapManager.mjs"() {
    init_dist_esm();
    init_dist_esm8();
    init_BoundsSnaps();
    init_HandleSnaps();
    __defProp4 = Object.defineProperty;
    __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
    __decorateClass3 = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc4(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp4(target, key, result);
      return result;
    };
    SnapManager = class {
      constructor(editor) {
        __publicField(this, "shapeBounds");
        __publicField(this, "handles");
        __publicField(this, "_snapIndicators", atom2("snapLines", void 0));
        this.editor = editor;
        this.shapeBounds = new BoundsSnaps(this);
        this.handles = new HandleSnaps(this);
      }
      getIndicators() {
        return this._snapIndicators.get() ?? EMPTY_ARRAY;
      }
      clearIndicators() {
        if (this.getIndicators().length) {
          this._snapIndicators.set(void 0);
        }
      }
      setIndicators(indicators) {
        this._snapIndicators.set(indicators);
      }
      getSnapThreshold() {
        return 8 / this.editor.getZoomLevel();
      }
      getSnappableShapes() {
        const { editor } = this;
        const renderingBounds = editor.getViewportPageBounds();
        const selectedShapeIds = editor.getSelectedShapeIds();
        const snappableShapes = /* @__PURE__ */ new Set();
        const collectSnappableShapesFromParent = (parentId) => {
          if (isShapeId(parentId)) {
            const parent = editor.getShape(parentId);
            if (parent && editor.isShapeOfType(parent, "frame")) {
              snappableShapes.add(parentId);
            }
          }
          const sortedChildIds = editor.getSortedChildIdsForParent(parentId);
          for (const childId of sortedChildIds) {
            if (selectedShapeIds.includes(childId))
              continue;
            const childShape = editor.getShape(childId);
            if (!childShape)
              continue;
            const util = editor.getShapeUtil(childShape);
            if (!util.canSnap(childShape))
              continue;
            const pageBounds = editor.getShapePageBounds(childId);
            if (!(pageBounds && renderingBounds.includes(pageBounds)))
              continue;
            if (editor.isShapeOfType(childShape, "group")) {
              collectSnappableShapesFromParent(childId);
              continue;
            }
            snappableShapes.add(childId);
          }
        };
        collectSnappableShapesFromParent(this.getCurrentCommonAncestor() ?? editor.getCurrentPageId());
        return snappableShapes;
      }
      getCurrentCommonAncestor() {
        return this.editor.findCommonAncestor(this.editor.getSelectedShapes());
      }
    };
    __decorateClass3([
      computed
    ], SnapManager.prototype, "getSnapThreshold", 1);
    __decorateClass3([
      computed
    ], SnapManager.prototype, "getSnappableShapes", 1);
    __decorateClass3([
      computed
    ], SnapManager.prototype, "getCurrentCommonAncestor", 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/TextManager.mjs
function normalizeTextForDom(text) {
  return text.replace(fixNewLines, "\n").split("\n").map((x2) => x2 || " ").join("\n");
}
var fixNewLines, textAlignmentsForLtr, spaceCharacterRegex, TextManager;
var init_TextManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/TextManager.mjs"() {
    fixNewLines = /\r?\n|\r/g;
    textAlignmentsForLtr = {
      start: "left",
      "start-legacy": "left",
      middle: "center",
      "middle-legacy": "center",
      end: "right",
      "end-legacy": "right"
    };
    spaceCharacterRegex = /\s/;
    TextManager = class {
      constructor(editor) {
        __publicField(this, "baseElm");
        __publicField(this, "measureText", (textToMeasure, opts) => {
          const elm = this.baseElm?.cloneNode();
          this.baseElm.insertAdjacentElement("afterend", elm);
          elm.setAttribute("dir", "auto");
          elm.style.setProperty("unicode-bidi", "plaintext");
          elm.style.setProperty("font-family", opts.fontFamily);
          elm.style.setProperty("font-style", opts.fontStyle);
          elm.style.setProperty("font-weight", opts.fontWeight);
          elm.style.setProperty("font-size", opts.fontSize + "px");
          elm.style.setProperty("line-height", opts.lineHeight * opts.fontSize + "px");
          elm.style.setProperty("max-width", opts.maxWidth === null ? null : opts.maxWidth + "px");
          elm.style.setProperty("min-width", opts.minWidth === null ? null : opts.minWidth + "px");
          elm.style.setProperty("padding", opts.padding);
          elm.style.setProperty("overflow-wrap", opts.disableOverflowWrapBreaking ? "normal" : "break-word");
          elm.textContent = normalizeTextForDom(textToMeasure);
          const scrollWidth = elm.scrollWidth;
          const rect = elm.getBoundingClientRect();
          elm.remove();
          return {
            x: 0,
            y: 0,
            w: rect.width,
            h: rect.height,
            scrollWidth
          };
        });
        this.editor = editor;
        const container = this.editor.getContainer();
        const elm = document.createElement("div");
        elm.classList.add("tl-text");
        elm.classList.add("tl-text-measure");
        elm.tabIndex = -1;
        container.appendChild(elm);
        this.baseElm = elm;
        editor.disposables.add(() => {
          elm.remove();
        });
      }
      measureElementTextNodeSpans(element, { shouldTruncateToFirstLine = false } = {}) {
        const spans = [];
        const elmBounds = element.getBoundingClientRect();
        const offsetX = -elmBounds.left;
        const offsetY = -elmBounds.top;
        const range = new Range();
        const textNode = element.childNodes[0];
        let idx = 0;
        let currentSpan = null;
        let prevCharWasSpaceCharacter = null;
        let prevCharTop = 0;
        let prevCharLeftForRTLTest = 0;
        let didTruncate = false;
        for (const childNode of element.childNodes) {
          if (childNode.nodeType !== Node.TEXT_NODE)
            continue;
          for (const char of childNode.textContent ?? "") {
            range.setStart(textNode, idx);
            range.setEnd(textNode, idx + char.length);
            const rects = range.getClientRects();
            const rect = rects[rects.length - 1];
            const top2 = rect.top + offsetY;
            const left2 = rect.left + offsetX;
            const right2 = rect.right + offsetX;
            const isRTL2 = left2 < prevCharLeftForRTLTest;
            const isSpaceCharacter = spaceCharacterRegex.test(char);
            if (isSpaceCharacter !== prevCharWasSpaceCharacter || top2 !== prevCharTop || !currentSpan) {
              if (currentSpan) {
                if (shouldTruncateToFirstLine && top2 !== prevCharTop) {
                  didTruncate = true;
                  break;
                }
                spans.push(currentSpan);
              }
              currentSpan = {
                box: { x: left2, y: top2, w: rect.width, h: rect.height },
                text: char
              };
              prevCharLeftForRTLTest = left2;
            } else {
              if (isRTL2) {
                currentSpan.box.x = left2;
              }
              currentSpan.box.w = isRTL2 ? currentSpan.box.w + rect.width : right2 - currentSpan.box.x;
              currentSpan.text += char;
            }
            if (char === "\n") {
              prevCharLeftForRTLTest = 0;
            }
            prevCharWasSpaceCharacter = isSpaceCharacter;
            prevCharTop = top2;
            idx += char.length;
          }
        }
        if (currentSpan) {
          spans.push(currentSpan);
        }
        return { spans, didTruncate };
      }
      measureTextSpans(textToMeasure, opts) {
        if (textToMeasure === "")
          return [];
        const elm = this.baseElm?.cloneNode();
        this.baseElm.insertAdjacentElement("afterend", elm);
        const elementWidth = Math.ceil(opts.width - opts.padding * 2);
        elm.setAttribute("dir", "auto");
        elm.style.setProperty("unicode-bidi", "plaintext");
        elm.style.setProperty("width", `${elementWidth}px`);
        elm.style.setProperty("height", "min-content");
        elm.style.setProperty("font-size", `${opts.fontSize}px`);
        elm.style.setProperty("font-family", opts.fontFamily);
        elm.style.setProperty("font-weight", opts.fontWeight);
        elm.style.setProperty("line-height", `${opts.lineHeight * opts.fontSize}px`);
        elm.style.setProperty("text-align", textAlignmentsForLtr[opts.textAlign]);
        const shouldTruncateToFirstLine = opts.overflow === "truncate-ellipsis" || opts.overflow === "truncate-clip";
        if (shouldTruncateToFirstLine) {
          elm.style.setProperty("overflow-wrap", "anywhere");
          elm.style.setProperty("word-break", "break-all");
        }
        const normalizedText = normalizeTextForDom(textToMeasure);
        elm.textContent = normalizedText;
        const { spans, didTruncate } = this.measureElementTextNodeSpans(elm, {
          shouldTruncateToFirstLine
        });
        if (opts.overflow === "truncate-ellipsis" && didTruncate) {
          elm.textContent = "\u2026";
          const ellipsisWidth = Math.ceil(this.measureElementTextNodeSpans(elm).spans[0].box.w);
          elm.style.setProperty("width", `${elementWidth - ellipsisWidth}px`);
          elm.textContent = normalizedText;
          const truncatedSpans = this.measureElementTextNodeSpans(elm, {
            shouldTruncateToFirstLine: true
          }).spans;
          const lastSpan = truncatedSpans[truncatedSpans.length - 1];
          truncatedSpans.push({
            text: "\u2026",
            box: {
              x: Math.min(lastSpan.box.x + lastSpan.box.w, opts.width - opts.padding - ellipsisWidth),
              y: lastSpan.box.y,
              w: ellipsisWidth,
              h: lastSpan.box.h
            }
          });
          return truncatedSpans;
        }
        elm.remove();
        return spans;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/TickManager.mjs
var throttleToNextFrame5, TickManager;
var init_TickManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/TickManager.mjs"() {
    init_dist_esm2();
    init_Vec();
    throttleToNextFrame5 = typeof process !== "undefined" && false ? function mockThrottle(cb) {
      const frame3 = requestAnimationFrame(cb);
      return () => cancelAnimationFrame(frame3);
    } : throttleToNextFrame;
    TickManager = class {
      constructor(editor) {
        __publicField(this, "cancelRaf");
        __publicField(this, "isPaused", true);
        __publicField(this, "now", 0);
        __publicField(this, "start", () => {
          this.isPaused = false;
          this.cancelRaf?.();
          this.cancelRaf = throttleToNextFrame5(this.tick);
          this.now = Date.now();
        });
        __publicField(this, "tick", () => {
          if (this.isPaused) {
            return;
          }
          const now = Date.now();
          const elapsed = now - this.now;
          this.now = now;
          this.updatePointerVelocity(elapsed);
          this.editor.emit("frame", elapsed);
          this.editor.emit("tick", elapsed);
          this.cancelRaf = throttleToNextFrame5(this.tick);
        });
        __publicField(this, "dispose", () => {
          this.isPaused = true;
          this.cancelRaf?.();
        });
        __publicField(this, "prevPoint", new Vec());
        __publicField(this, "updatePointerVelocity", (elapsed) => {
          const {
            prevPoint,
            editor: {
              inputs: { currentScreenPoint, pointerVelocity }
            }
          } = this;
          if (elapsed === 0)
            return;
          const delta = Vec.Sub(currentScreenPoint, prevPoint);
          this.prevPoint = currentScreenPoint.clone();
          const length = delta.len();
          const direction = length ? delta.div(length) : new Vec(0, 0);
          const next = pointerVelocity.clone().lrp(direction.mul(length / elapsed), 0.5);
          if (Math.abs(next.x) < 0.01)
            next.x = 0;
          if (Math.abs(next.y) < 0.01)
            next.y = 0;
          if (!pointerVelocity.equals(next)) {
            this.editor.inputs.pointerVelocity = next;
          }
        });
        this.editor = editor;
        this.editor.disposables.add(this.dispose);
        this.start();
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/managers/UserPreferencesManager.mjs
var __defProp5, __getOwnPropDesc5, __decorateClass4, UserPreferencesManager;
var init_UserPreferencesManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/managers/UserPreferencesManager.mjs"() {
    init_dist_esm();
    init_TLUserPreferences();
    __defProp5 = Object.defineProperty;
    __getOwnPropDesc5 = Object.getOwnPropertyDescriptor;
    __decorateClass4 = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc5(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp5(target, key, result);
      return result;
    };
    UserPreferencesManager = class {
      constructor(user, inferDarkMode) {
        __publicField(this, "systemColorScheme", atom2("systemColorScheme", "light"));
        __publicField(this, "updateUserPreferences", (userPreferences) => {
          this.user.setUserPreferences({
            ...this.user.userPreferences.get(),
            ...userPreferences
          });
        });
        this.user = user;
        this.inferDarkMode = inferDarkMode;
        if (typeof window === "undefined" || !("matchMedia" in window))
          return;
        const darkModeMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
        if (darkModeMediaQuery?.matches) {
          this.systemColorScheme.set("dark");
        }
        darkModeMediaQuery?.addEventListener("change", (e2) => {
          if (e2.matches) {
            this.systemColorScheme.set("dark");
          } else {
            this.systemColorScheme.set("light");
          }
        });
      }
      getUserPreferences() {
        return {
          id: this.getId(),
          name: this.getName(),
          locale: this.getLocale(),
          color: this.getColor(),
          animationSpeed: this.getAnimationSpeed(),
          isSnapMode: this.getIsSnapMode(),
          colorScheme: this.user.userPreferences.get().colorScheme,
          isDarkMode: this.getIsDarkMode(),
          isWrapMode: this.getIsWrapMode(),
          isDynamicResizeMode: this.getIsDynamicResizeMode()
        };
      }
      getIsDarkMode() {
        switch (this.user.userPreferences.get().colorScheme) {
          case "dark":
            return true;
          case "light":
            return false;
          case "system":
            return this.systemColorScheme.get() === "dark";
          default:
            return this.inferDarkMode ? this.systemColorScheme.get() === "dark" : false;
        }
      }
      getEdgeScrollSpeed() {
        return this.user.userPreferences.get().edgeScrollSpeed ?? defaultUserPreferences.edgeScrollSpeed;
      }
      getAnimationSpeed() {
        return this.user.userPreferences.get().animationSpeed ?? defaultUserPreferences.animationSpeed;
      }
      getId() {
        return this.user.userPreferences.get().id;
      }
      getName() {
        return this.user.userPreferences.get().name ?? defaultUserPreferences.name;
      }
      getLocale() {
        return this.user.userPreferences.get().locale ?? defaultUserPreferences.locale;
      }
      getColor() {
        return this.user.userPreferences.get().color ?? defaultUserPreferences.color;
      }
      getIsSnapMode() {
        return this.user.userPreferences.get().isSnapMode ?? defaultUserPreferences.isSnapMode;
      }
      getIsWrapMode() {
        return this.user.userPreferences.get().isWrapMode ?? defaultUserPreferences.isWrapMode;
      }
      getIsDynamicResizeMode() {
        return this.user.userPreferences.get().isDynamicSizeMode ?? defaultUserPreferences.isDynamicSizeMode;
      }
      getIsPasteAtCursorMode() {
        return this.user.userPreferences.get().isPasteAtCursorMode ?? defaultUserPreferences.isPasteAtCursorMode;
      }
    };
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getUserPreferences", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getIsDarkMode", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getEdgeScrollSpeed", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getAnimationSpeed", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getId", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getName", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getLocale", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getColor", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getIsSnapMode", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getIsWrapMode", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getIsDynamicResizeMode", 1);
    __decorateClass4([
      computed
    ], UserPreferencesManager.prototype, "getIsPasteAtCursorMode", 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/types/event-types.mjs
var EVENT_NAME_MAP;
var init_event_types = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/types/event-types.mjs"() {
    EVENT_NAME_MAP = {
      wheel: "onWheel",
      pointer_down: "onPointerDown",
      pointer_move: "onPointerMove",
      long_press: "onLongPress",
      pointer_up: "onPointerUp",
      right_click: "onRightClick",
      middle_click: "onMiddleClick",
      key_down: "onKeyDown",
      key_up: "onKeyUp",
      key_repeat: "onKeyRepeat",
      cancel: "onCancel",
      complete: "onComplete",
      interrupt: "onInterrupt",
      double_click: "onDoubleClick",
      triple_click: "onTripleClick",
      quadruple_click: "onQuadrupleClick",
      tick: "onTick"
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/tools/StateNode.mjs
var STATE_NODES_TO_MEASURE, StateNode;
var init_StateNode = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/tools/StateNode.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    init_debug_flags();
    init_event_types();
    STATE_NODES_TO_MEASURE = [
      "brushing",
      "cropping",
      "dragging",
      "dragging_handle",
      "drawing",
      "erasing",
      "lasering",
      "resizing",
      "rotating",
      "scribble_brushing",
      "translating"
    ];
    StateNode = class {
      constructor(editor, parent) {
        __publicField(this, "performanceTracker");
        __publicField(this, "id");
        __publicField(this, "type");
        __publicField(this, "shapeType");
        __publicField(this, "initial");
        __publicField(this, "children");
        __publicField(this, "isLockable");
        __publicField(this, "parent");
        __publicField(this, "_path");
        __publicField(this, "_current");
        __publicField(this, "_isActive");
        __publicField(this, "transition", (id, info2 = {}) => {
          const path = id.split(".");
          let currState = this;
          for (let i2 = 0; i2 < path.length; i2++) {
            const id2 = path[i2];
            const prevChildState = currState.getCurrent();
            const nextChildState = currState.children?.[id2];
            if (!nextChildState) {
              throw Error(`${currState.id} - no child state exists with the id ${id2}.`);
            }
            if (prevChildState?.id !== nextChildState.id) {
              prevChildState?.exit(info2, id2);
              currState._current.set(nextChildState);
              nextChildState.enter(info2, prevChildState?.id || "initial");
              if (!nextChildState.getIsActive())
                break;
            }
            currState = nextChildState;
          }
          return this;
        });
        __publicField(this, "handleEvent", (info2) => {
          const cbName = EVENT_NAME_MAP[info2.name];
          const currentActiveChild = this._current.__unsafe__getWithoutCapture();
          this[cbName]?.(info2);
          if (this._isActive.__unsafe__getWithoutCapture() && currentActiveChild && currentActiveChild === this._current.__unsafe__getWithoutCapture()) {
            currentActiveChild.handleEvent(info2);
          }
        });
        __publicField(this, "enter", (info2, from) => {
          if (debugFlags.measurePerformance.get() && STATE_NODES_TO_MEASURE.includes(this.id)) {
            this.performanceTracker.start(this.id);
          }
          this._isActive.set(true);
          this.onEnter?.(info2, from);
          if (this.children && this.initial && this.getIsActive()) {
            const initial = this.children[this.initial];
            this._current.set(initial);
            initial.enter(info2, from);
          }
        });
        __publicField(this, "exit", (info2, from) => {
          if (debugFlags.measurePerformance.get() && this.performanceTracker.isStarted()) {
            this.performanceTracker.stop();
          }
          this._isActive.set(false);
          this.onExit?.(info2, from);
          if (!this.getIsActive()) {
            this.getCurrent()?.exit(info2, from);
          }
        });
        __publicField(this, "_currentToolIdMask", atom2("curent tool id mask", void 0));
        __publicField(this, "onWheel");
        __publicField(this, "onPointerDown");
        __publicField(this, "onPointerMove");
        __publicField(this, "onLongPress");
        __publicField(this, "onPointerUp");
        __publicField(this, "onDoubleClick");
        __publicField(this, "onTripleClick");
        __publicField(this, "onQuadrupleClick");
        __publicField(this, "onRightClick");
        __publicField(this, "onMiddleClick");
        __publicField(this, "onKeyDown");
        __publicField(this, "onKeyUp");
        __publicField(this, "onKeyRepeat");
        __publicField(this, "onCancel");
        __publicField(this, "onComplete");
        __publicField(this, "onInterrupt");
        __publicField(this, "onTick");
        __publicField(this, "onEnter");
        __publicField(this, "onExit");
        this.editor = editor;
        const { id, children, initial, isLockable } = this.constructor;
        this.id = id;
        this._isActive = atom2("toolIsActive" + this.id, false);
        this._current = atom2("toolState" + this.id, void 0);
        this._path = computed("toolPath" + this.id, () => {
          const current = this.getCurrent();
          return this.id + (current ? `.${current.getPath()}` : "");
        });
        this.parent = parent ?? {};
        if (this.parent) {
          if (children && initial) {
            this.type = "branch";
            this.initial = initial;
            this.children = Object.fromEntries(children().map((Ctor) => [Ctor.id, new Ctor(this.editor, this)]));
            this._current.set(this.children[this.initial]);
          } else {
            this.type = "leaf";
          }
        } else {
          this.type = "root";
          if (children && initial) {
            this.initial = initial;
            this.children = Object.fromEntries(children().map((Ctor) => [Ctor.id, new Ctor(this.editor, this)]));
            this._current.set(this.children[this.initial]);
          }
        }
        this.isLockable = isLockable;
        this.performanceTracker = new PerformanceTracker();
      }
      getPath() {
        return this._path.get();
      }
      getCurrent() {
        return this._current.get();
      }
      getIsActive() {
        return this._isActive.get();
      }
      getCurrentToolIdMask() {
        return this._currentToolIdMask.get();
      }
      setCurrentToolIdMask(id) {
        this._currentToolIdMask.set(id);
      }
    };
    __publicField(StateNode, "id");
    __publicField(StateNode, "initial");
    __publicField(StateNode, "children");
    __publicField(StateNode, "isLockable", true);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/tools/RootState.mjs
var RootState;
var init_RootState = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/tools/RootState.mjs"() {
    init_StateNode();
    RootState = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onKeyDown", (info2) => {
          switch (info2.code) {
            case "KeyZ": {
              if (!(info2.shiftKey || info2.ctrlKey)) {
                const currentTool = this.getCurrent();
                if (currentTool && currentTool.getCurrent()?.id === "idle" && this.children["zoom"]) {
                  this.editor.setCurrentTool("zoom", { ...info2, onInteractionEnd: currentTool.id });
                }
              }
              break;
            }
          }
        });
      }
    };
    __publicField(RootState, "id", "root");
    __publicField(RootState, "initial", "");
    __publicField(RootState, "children", () => []);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/Editor.mjs
function alertMaxShapes(editor, pageId = editor.getCurrentPageId()) {
  const name = editor.getPage(pageId).name;
  editor.emit("max-shapes", { name, pageId, count: editor.options.maxShapesPerPage });
}
function applyPartialToRecordWithProps(prev, partial) {
  if (!partial)
    return prev;
  let next = null;
  const entries = Object.entries(partial);
  for (let i2 = 0, n2 = entries.length; i2 < n2; i2++) {
    const [k2, v2] = entries[i2];
    if (v2 === void 0)
      continue;
    if (k2 === "id" || k2 === "type" || k2 === "typeName")
      continue;
    if (v2 === prev[k2])
      continue;
    if (!next)
      next = { ...prev };
    if (k2 === "props" || k2 === "meta") {
      next[k2] = { ...prev[k2] };
      for (const [nextKey, nextValue] of Object.entries(v2)) {
        if (nextValue !== void 0) {
          ;
          next[k2][nextKey] = nextValue;
        }
      }
      continue;
    }
    ;
    next[k2] = v2;
  }
  if (!next)
    return prev;
  return next;
}
function pushShapeWithDescendants(editor, id, result) {
  const shape = editor.getShape(id);
  if (!shape)
    return;
  result.push(shape);
  const childIds = editor.getSortedChildIdsForParent(id);
  for (let i2 = 0, n2 = childIds.length; i2 < n2; i2++) {
    pushShapeWithDescendants(editor, childIds[i2], result);
  }
}
function withIsolatedShapes(editor, shapeIds, callback) {
  let result;
  editor.run(() => {
    const changes = editor.store.extractingChanges(() => {
      const bindingsWithBoth = /* @__PURE__ */ new Set();
      const bindingsToRemove = /* @__PURE__ */ new Set();
      for (const shapeId of shapeIds) {
        const shape = editor.getShape(shapeId);
        if (!shape)
          continue;
        for (const binding of editor.getBindingsInvolvingShape(shapeId)) {
          const hasFrom = shapeIds.has(binding.fromId);
          const hasTo = shapeIds.has(binding.toId);
          if (hasFrom && hasTo) {
            bindingsWithBoth.add(binding.id);
            continue;
          }
          if (!hasFrom || !hasTo) {
            bindingsToRemove.add(binding.id);
          }
        }
      }
      editor.deleteBindings([...bindingsToRemove], { isolateShapes: true });
      try {
        result = Result.ok(callback(bindingsWithBoth));
      } catch (error2) {
        result = Result.err(error2);
      }
    });
    editor.store.applyDiff(reverseRecordsDiff(changes));
  }, { history: "ignore" });
  if (result.ok) {
    return result.value;
  } else {
    throw result.error;
  }
}
function getCameraFitXFitY(editor, cameraOptions) {
  if (!cameraOptions.constraints)
    throw Error("Should have constraints here");
  const {
    padding: { x: px, y: py }
  } = cameraOptions.constraints;
  const vsb = editor.getViewportScreenBounds();
  const bounds = Box.From(cameraOptions.constraints.bounds);
  const zx = (vsb.w - px * 2) / bounds.w;
  const zy = (vsb.h - py * 2) / bounds.h;
  return { zx, zy };
}
var import_eventemitter3, import_react_dom, import_client, __defProp6, __getOwnPropDesc6, __decorateClass5, Editor;
var init_Editor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/Editor.mjs"() {
    init_dist_esm();
    init_dist_esm4();
    init_dist_esm8();
    init_dist_esm2();
    import_eventemitter3 = __toESM(require_eventemitter3(), 1);
    import_react_dom = __toESM(require_react_dom(), 1);
    import_client = __toESM(require_client(), 1);
    init_TLEditorSnapshot();
    init_createTLUser();
    init_defaultBindings();
    init_defaultShapes();
    init_constants3();
    init_options();
    init_Box();
    init_Mat();
    init_Vec();
    init_easings();
    init_Group2d();
    init_intersect();
    init_utils();
    init_SharedStylesMap();
    init_assets();
    init_debug_flags();
    init_getIncrementedName();
    init_reorderShapes();
    init_rotation();
    init_uniqueId();
    init_bindingsIndex();
    init_notVisibleShapes();
    init_parentsToChildren();
    init_shapeIdsInCurrentPage();
    init_getSvgJsx();
    init_ClickManager();
    init_EdgeScrollManager();
    init_EnvironmentManager();
    init_FocusManager();
    init_HistoryManager();
    init_ScribbleManager();
    init_SnapManager();
    init_TextManager();
    init_TickManager();
    init_UserPreferencesManager();
    init_RootState();
    __defProp6 = Object.defineProperty;
    __getOwnPropDesc6 = Object.getOwnPropertyDescriptor;
    __decorateClass5 = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc6(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp6(target, key, result);
      return result;
    };
    Editor = class extends import_eventemitter3.default {
      constructor({
        store,
        user,
        shapeUtils,
        bindingUtils,
        tools,
        getContainer,
        cameraOptions,
        initialState: initialState2,
        autoFocus,
        inferDarkMode,
        options
      }) {
        super();
        __publicField(this, "options");
        __publicField(this, "store");
        __publicField(this, "root");
        __publicField(this, "disposables", /* @__PURE__ */ new Set());
        __publicField(this, "isDisposed", false);
        __publicField(this, "_tickManager");
        __publicField(this, "snaps");
        __publicField(this, "timers");
        __publicField(this, "user");
        __publicField(this, "textMeasure");
        __publicField(this, "environment");
        __publicField(this, "scribbles");
        __publicField(this, "sideEffects");
        __publicField(this, "edgeScrollManager");
        __publicField(this, "focusManager");
        __publicField(this, "getContainer");
        __publicField(this, "shapeUtils");
        __publicField(this, "styleProps");
        __publicField(this, "bindingUtils");
        __publicField(this, "history");
        __publicField(this, "_shouldIgnoreShapeLock", false);
        __publicField(this, "_crashingError", null);
        __publicField(this, "_updateInstanceState", (partial, opts) => {
          this.run(() => {
            this.store.put([
              {
                ...this.getInstanceState(),
                ...partial
              }
            ]);
          }, opts);
        });
        __publicField(this, "_isChangingStyleTimeout", -1);
        __publicField(this, "setCursor", (cursor) => {
          this.updateInstanceState({ cursor: { ...this.getInstanceState().cursor, ...cursor } });
          return this;
        });
        __publicField(this, "_updateCurrentPageState", (partial) => {
          this.store.update(partial.id ?? this.getCurrentPageState().id, (state) => ({
            ...state,
            ...partial
          }));
        });
        __publicField(this, "_cameraOptions", atom2("camera options", DEFAULT_CAMERA_OPTIONS));
        __publicField(this, "_viewportAnimation", null);
        __publicField(this, "_willSetInitialBounds", true);
        __publicField(this, "_isLockedOnFollowingUser", atom2("isLockedOnFollowingUser", false));
        __publicField(this, "_cameraState", atom2("camera state", "idle"));
        __publicField(this, "_cameraStateTimeoutRemaining", 0);
        __publicField(this, "_decayCameraStateTimeout", (elapsed) => {
          this._cameraStateTimeoutRemaining -= elapsed;
          if (this._cameraStateTimeoutRemaining > 0)
            return;
          this.off("tick", this._decayCameraStateTimeout);
          this._cameraState.set("idle");
        });
        __publicField(this, "_tickCameraState", () => {
          this._cameraStateTimeoutRemaining = this.options.cameraMovingTimeoutMs;
          if (this._cameraState.__unsafe__getWithoutCapture() !== "idle")
            return;
          this._cameraState.set("moving");
          this.on("tick", this._decayCameraStateTimeout);
        });
        __publicField(this, "_currentPageShapeIds");
        __publicField(this, "_parentIdsToChildIds");
        __publicField(this, "animatingShapes", /* @__PURE__ */ new Map());
        __publicField(this, "_updateShapes", (_partials) => {
          if (this.getInstanceState().isReadonly)
            return;
          this.run(() => {
            const updates = [];
            let shape;
            let updated;
            for (let i2 = 0, n2 = _partials.length; i2 < n2; i2++) {
              const partial = _partials[i2];
              if (!partial)
                continue;
              shape = this.getShape(partial.id);
              if (!shape)
                continue;
              updated = applyPartialToRecordWithProps(shape, partial);
              if (updated === shape)
                continue;
              updated = this.getShapeUtil(shape).onBeforeUpdate?.(shape, updated) ?? updated;
              updates.push(updated);
            }
            this.store.put(updates);
          });
        });
        __publicField(this, "externalAssetContentHandlers", {
          file: null,
          url: null
        });
        __publicField(this, "externalContentHandlers", {
          text: null,
          files: null,
          embed: null,
          "svg-text": null,
          url: null
        });
        __publicField(this, "inputs", {
          originPagePoint: new Vec(),
          originScreenPoint: new Vec(),
          previousPagePoint: new Vec(),
          previousScreenPoint: new Vec(),
          currentPagePoint: new Vec(),
          currentScreenPoint: new Vec(),
          keys: /* @__PURE__ */ new Set(),
          buttons: /* @__PURE__ */ new Set(),
          isPen: false,
          shiftKey: false,
          ctrlKey: false,
          altKey: false,
          isDragging: false,
          isPointing: false,
          isPinching: false,
          isEditing: false,
          isPanning: false,
          pointerVelocity: new Vec()
        });
        __publicField(this, "_clickManager", new ClickManager(this));
        __publicField(this, "_prevCursor", "default");
        __publicField(this, "_shiftKeyTimeout", -1);
        __publicField(this, "_setShiftKeyTimeout", () => {
          this.inputs.shiftKey = false;
          this.dispatch({
            type: "keyboard",
            name: "key_up",
            key: "Shift",
            shiftKey: this.inputs.shiftKey,
            ctrlKey: this.inputs.ctrlKey,
            altKey: this.inputs.altKey,
            code: "ShiftLeft"
          });
        });
        __publicField(this, "_altKeyTimeout", -1);
        __publicField(this, "_setAltKeyTimeout", () => {
          this.inputs.altKey = false;
          this.dispatch({
            type: "keyboard",
            name: "key_up",
            key: "Alt",
            shiftKey: this.inputs.shiftKey,
            ctrlKey: this.inputs.ctrlKey,
            altKey: this.inputs.altKey,
            code: "AltLeft"
          });
        });
        __publicField(this, "_ctrlKeyTimeout", -1);
        __publicField(this, "_setCtrlKeyTimeout", () => {
          this.inputs.ctrlKey = false;
          this.dispatch({
            type: "keyboard",
            name: "key_up",
            key: "Ctrl",
            shiftKey: this.inputs.shiftKey,
            ctrlKey: this.inputs.ctrlKey,
            altKey: this.inputs.altKey,
            code: "ControlLeft"
          });
        });
        __publicField(this, "_restoreToolId", "select");
        __publicField(this, "_pinchStart", 1);
        __publicField(this, "_didPinch", false);
        __publicField(this, "_selectedShapeIdsAtPointerDown", []);
        __publicField(this, "_longPressTimeout", -1);
        __publicField(this, "capturedPointerId", null);
        __publicField(this, "performanceTracker");
        __publicField(this, "performanceTrackerTimeout", -1);
        __publicField(this, "dispatch", (info2) => {
          this._pendingEventsForNextTick.push(info2);
          if (!(info2.type === "pointer" && info2.name === "pointer_move" || info2.type === "wheel" || info2.type === "pinch")) {
            this._flushEventsForTick(0);
          }
          return this;
        });
        __publicField(this, "_pendingEventsForNextTick", []);
        __publicField(this, "_flushEventForTick", (info2) => {
          if (this.getCrashingError())
            return this;
          const { inputs } = this;
          const { type } = info2;
          if (info2.type === "misc") {
            if (info2.name === "cancel" || info2.name === "complete") {
              this.inputs.isDragging = false;
              if (this.inputs.isPanning) {
                this.inputs.isPanning = false;
                this.setCursor({ type: this._prevCursor, rotation: 0 });
              }
            }
            this.root.handleEvent(info2);
            return;
          }
          if (info2.shiftKey) {
            clearTimeout(this._shiftKeyTimeout);
            this._shiftKeyTimeout = -1;
            inputs.shiftKey = true;
          } else if (!info2.shiftKey && inputs.shiftKey && this._shiftKeyTimeout === -1) {
            this._shiftKeyTimeout = this.timers.setTimeout(this._setShiftKeyTimeout, 150);
          }
          if (info2.altKey) {
            clearTimeout(this._altKeyTimeout);
            this._altKeyTimeout = -1;
            inputs.altKey = true;
          } else if (!info2.altKey && inputs.altKey && this._altKeyTimeout === -1) {
            this._altKeyTimeout = this.timers.setTimeout(this._setAltKeyTimeout, 150);
          }
          if (info2.ctrlKey) {
            clearTimeout(this._ctrlKeyTimeout);
            this._ctrlKeyTimeout = -1;
            inputs.ctrlKey = true;
          } else if (!info2.ctrlKey && inputs.ctrlKey && this._ctrlKeyTimeout === -1) {
            this._ctrlKeyTimeout = this.timers.setTimeout(this._setCtrlKeyTimeout, 150);
          }
          const { originPagePoint, currentPagePoint } = inputs;
          if (!inputs.isPointing) {
            inputs.isDragging = false;
          }
          const instanceState = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
          const pageState = this.store.get(this._getCurrentPageStateId());
          const cameraOptions = this._cameraOptions.__unsafe__getWithoutCapture();
          switch (type) {
            case "pinch": {
              if (cameraOptions.isLocked)
                return;
              clearTimeout(this._longPressTimeout);
              this._updateInputsFromEvent(info2);
              switch (info2.name) {
                case "pinch_start": {
                  if (inputs.isPinching)
                    return;
                  if (!inputs.isEditing) {
                    this._pinchStart = this.getCamera().z;
                    if (!this._selectedShapeIdsAtPointerDown.length) {
                      this._selectedShapeIdsAtPointerDown = [...pageState.selectedShapeIds];
                    }
                    this._didPinch = true;
                    inputs.isPinching = true;
                    this.interrupt();
                  }
                  return;
                }
                case "pinch": {
                  if (!inputs.isPinching)
                    return;
                  const {
                    point: { z = 1 },
                    delta: { x: dx, y: dy }
                  } = info2;
                  const { x: x2, y: y2 } = Vec.SubXY(info2.point, instanceState.screenBounds.x, instanceState.screenBounds.y);
                  this.stopCameraAnimation();
                  if (instanceState.followingUserId) {
                    this.stopFollowingUser();
                  }
                  const { x: cx, y: cy, z: cz } = unsafe__withoutCapture(() => this.getCamera());
                  const { panSpeed, zoomSpeed } = cameraOptions;
                  this._setCamera(new Vec(cx + dx * panSpeed / cz - x2 / cz + x2 / (z * zoomSpeed), cy + dy * panSpeed / cz - y2 / cz + y2 / (z * zoomSpeed), z * zoomSpeed), { immediate: true });
                  return;
                }
                case "pinch_end": {
                  if (!inputs.isPinching)
                    return this;
                  inputs.isPinching = false;
                  const { _selectedShapeIdsAtPointerDown: shapesToReselect } = this;
                  this.setSelectedShapes(this._selectedShapeIdsAtPointerDown);
                  this._selectedShapeIdsAtPointerDown = [];
                  if (this._didPinch) {
                    this._didPinch = false;
                    if (shapesToReselect.length > 0) {
                      this.once("tick", () => {
                        if (!this._didPinch) {
                          this.setSelectedShapes(shapesToReselect);
                        }
                      });
                    }
                  }
                  return;
                }
              }
            }
            case "wheel": {
              if (cameraOptions.isLocked)
                return;
              this._updateInputsFromEvent(info2);
              if (this.getIsMenuOpen()) {
              } else {
                const { panSpeed, zoomSpeed, wheelBehavior } = cameraOptions;
                if (wheelBehavior !== "none") {
                  this.stopCameraAnimation();
                  if (instanceState.followingUserId) {
                    this.stopFollowingUser();
                  }
                  const { x: cx, y: cy, z: cz } = unsafe__withoutCapture(() => this.getCamera());
                  const { x: dx, y: dy, z: dz = 0 } = info2.delta;
                  let behavior = wheelBehavior;
                  if (inputs.ctrlKey)
                    behavior = wheelBehavior === "pan" ? "zoom" : "pan";
                  switch (behavior) {
                    case "zoom": {
                      const { x: x2, y: y2 } = this.inputs.currentScreenPoint;
                      let delta = dz;
                      if (wheelBehavior === "zoom") {
                        if (Math.abs(dy) > 10) {
                          delta = 10 * Math.sign(dy) / 100;
                        } else {
                          delta = dy / 100;
                        }
                      }
                      const zoom = cz + (delta ?? 0) * zoomSpeed * cz;
                      this._setCamera(new Vec(cx + (x2 / zoom - x2) - (x2 / cz - x2), cy + (y2 / zoom - y2) - (y2 / cz - y2), zoom), { immediate: true });
                      this.maybeTrackPerformance("Zooming");
                      return;
                    }
                    case "pan": {
                      this._setCamera(new Vec(cx + dx * panSpeed / cz, cy + dy * panSpeed / cz, cz), {
                        immediate: true
                      });
                      this.maybeTrackPerformance("Panning");
                      return;
                    }
                  }
                }
              }
              break;
            }
            case "pointer": {
              if (inputs.isPinching)
                return;
              this._updateInputsFromEvent(info2);
              const { isPen } = info2;
              const { isPenMode } = instanceState;
              switch (info2.name) {
                case "pointer_down": {
                  if (isPenMode && !isPen)
                    return;
                  this.clearOpenMenus();
                  if (!this.inputs.isPanning) {
                    this._longPressTimeout = this.timers.setTimeout(() => {
                      this.dispatch({
                        ...info2,
                        point: this.inputs.currentScreenPoint,
                        name: "long_press"
                      });
                    }, this.options.longPressDurationMs);
                  }
                  this._selectedShapeIdsAtPointerDown = this.getSelectedShapeIds();
                  if (info2.button === LEFT_MOUSE_BUTTON)
                    this.capturedPointerId = info2.pointerId;
                  inputs.buttons.add(info2.button);
                  inputs.isPointing = true;
                  inputs.isDragging = false;
                  if (!isPenMode && isPen)
                    this.updateInstanceState({ isPenMode: true });
                  if (info2.button === STYLUS_ERASER_BUTTON) {
                    this._restoreToolId = this.getCurrentToolId();
                    this.complete();
                    this.setCurrentTool("eraser");
                  } else if (info2.button === MIDDLE_MOUSE_BUTTON) {
                    if (!this.inputs.isPanning) {
                      this._prevCursor = this.getInstanceState().cursor.type;
                    }
                    this.inputs.isPanning = true;
                    clearTimeout(this._longPressTimeout);
                  }
                  if (this.inputs.isPanning) {
                    this.stopCameraAnimation();
                    this.setCursor({ type: "grabbing", rotation: 0 });
                    return this;
                  }
                  break;
                }
                case "pointer_move": {
                  if (!isPen && isPenMode)
                    return;
                  const { x: cx, y: cy, z: cz } = unsafe__withoutCapture(() => this.getCamera());
                  if (this.inputs.isPanning && this.inputs.isPointing) {
                    const { currentScreenPoint, previousScreenPoint } = this.inputs;
                    const { panSpeed } = cameraOptions;
                    const offset5 = Vec.Sub(currentScreenPoint, previousScreenPoint);
                    this.setCamera(new Vec(cx + offset5.x * panSpeed / cz, cy + offset5.y * panSpeed / cz, cz), { immediate: true });
                    this.maybeTrackPerformance("Panning");
                    return;
                  }
                  if (inputs.isPointing && !inputs.isDragging && Vec.Dist2(originPagePoint, currentPagePoint) * this.getZoomLevel() > (instanceState.isCoarsePointer ? this.options.coarseDragDistanceSquared : this.options.dragDistanceSquared) / cz) {
                    inputs.isDragging = true;
                    clearTimeout(this._longPressTimeout);
                  }
                  break;
                }
                case "pointer_up": {
                  inputs.isDragging = false;
                  inputs.isPointing = false;
                  clearTimeout(this._longPressTimeout);
                  inputs.buttons.delete(info2.button);
                  if (this.getIsMenuOpen())
                    return;
                  if (instanceState.isPenMode && !isPen)
                    return;
                  if (this.capturedPointerId === info2.pointerId) {
                    this.capturedPointerId = null;
                    info2.button = 0;
                  }
                  if (inputs.isPanning) {
                    if (!inputs.keys.has("Space")) {
                      inputs.isPanning = false;
                    }
                    const slideDirection = this.inputs.pointerVelocity;
                    const slideSpeed = Math.min(2, slideDirection.len());
                    switch (info2.button) {
                      case LEFT_MOUSE_BUTTON: {
                        this.setCursor({ type: "grab", rotation: 0 });
                        break;
                      }
                      case MIDDLE_MOUSE_BUTTON: {
                        if (this.inputs.keys.has(" ")) {
                          this.setCursor({ type: "grab", rotation: 0 });
                        } else {
                          this.setCursor({ type: this._prevCursor, rotation: 0 });
                        }
                      }
                    }
                    if (slideSpeed > 0) {
                      this.slideCamera({ speed: slideSpeed, direction: slideDirection });
                    }
                  } else {
                    if (info2.button === STYLUS_ERASER_BUTTON) {
                      this.complete();
                      this.setCurrentTool(this._restoreToolId);
                    }
                  }
                  break;
                }
              }
              break;
            }
            case "keyboard": {
              if (info2.key === "ShiftRight")
                info2.key = "ShiftLeft";
              if (info2.key === "AltRight")
                info2.key = "AltLeft";
              if (info2.code === "ControlRight")
                info2.code = "ControlLeft";
              switch (info2.name) {
                case "key_down": {
                  inputs.keys.add(info2.code);
                  if (info2.code === "Space" && !info2.ctrlKey) {
                    if (!this.inputs.isPanning) {
                      this._prevCursor = instanceState.cursor.type;
                    }
                    this.inputs.isPanning = true;
                    clearTimeout(this._longPressTimeout);
                    this.setCursor({ type: this.inputs.isPointing ? "grabbing" : "grab", rotation: 0 });
                  }
                  break;
                }
                case "key_up": {
                  inputs.keys.delete(info2.code);
                  if (info2.code === "Space") {
                    if (this.inputs.buttons.has(MIDDLE_MOUSE_BUTTON)) {
                    } else {
                      this.inputs.isPanning = false;
                      this.setCursor({ type: this._prevCursor, rotation: 0 });
                    }
                  }
                  break;
                }
                case "key_repeat": {
                  break;
                }
              }
              break;
            }
          }
          if (info2.type === "pointer") {
            if (info2.button === MIDDLE_MOUSE_BUTTON) {
              info2.name = "middle_click";
            } else if (info2.button === RIGHT_MOUSE_BUTTON) {
              info2.name = "right_click";
            }
            const { isPenMode } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
            if (info2.isPen === isPenMode) {
              const clickInfo = this._clickManager.handlePointerEvent(info2);
              if (info2.name !== clickInfo.name) {
                this.root.handleEvent(info2);
                this.emit("event", info2);
                this.root.handleEvent(clickInfo);
                this.emit("event", clickInfo);
                return;
              }
            }
          }
          this.root.handleEvent(info2);
          this.emit("event", info2);
          return this;
        });
        this.options = { ...defaultTldrawOptions, ...options };
        this.store = store;
        this.disposables.add(this.store.dispose.bind(this.store));
        this.history = new HistoryManager({
          store,
          annotateError: (error2) => {
            this.annotateError(error2, { origin: "history.batch", willCrashApp: true });
            this.crash(error2);
          }
        });
        this.snaps = new SnapManager(this);
        this.timers = new Timers();
        this.disposables.add(this.timers.dispose.bind(this.timers));
        this._cameraOptions.set({ ...DEFAULT_CAMERA_OPTIONS, ...cameraOptions });
        this.user = new UserPreferencesManager(user ?? createTLUser(), inferDarkMode ?? false);
        this.getContainer = getContainer ?? (() => document.body);
        this.textMeasure = new TextManager(this);
        this._tickManager = new TickManager(this);
        class NewRoot extends RootState {
        }
        __publicField(NewRoot, "initial", initialState2 ?? "");
        this.root = new NewRoot(this);
        this.root.children = {};
        const allShapeUtils = checkShapesAndAddCore(shapeUtils);
        const _shapeUtils = {};
        const _styleProps = {};
        const allStylesById = /* @__PURE__ */ new Map();
        for (const Util of allShapeUtils) {
          const util = new Util(this);
          _shapeUtils[Util.type] = util;
          const propKeysByStyle = getShapePropKeysByStyle(Util.props ?? {});
          _styleProps[Util.type] = propKeysByStyle;
          for (const style of propKeysByStyle.keys()) {
            if (!allStylesById.has(style.id)) {
              allStylesById.set(style.id, style);
            } else if (allStylesById.get(style.id) !== style) {
              throw Error(`Multiple style props with id "${style.id}" in use. Style prop IDs must be unique.`);
            }
          }
        }
        this.shapeUtils = _shapeUtils;
        this.styleProps = _styleProps;
        const allBindingUtils = checkBindings(bindingUtils);
        const _bindingUtils = {};
        for (const Util of allBindingUtils) {
          const util = new Util(this);
          _bindingUtils[Util.type] = util;
        }
        this.bindingUtils = _bindingUtils;
        for (const Tool of [...tools]) {
          if (hasOwnProperty(this.root.children, Tool.id)) {
            throw Error(`Can't override tool with id "${Tool.id}"`);
          }
          this.root.children[Tool.id] = new Tool(this, this.root);
        }
        this.environment = new EnvironmentManager(this);
        this.scribbles = new ScribbleManager(this);
        const cleanupInstancePageState = (prevPageState, shapesNoLongerInPage) => {
          let nextPageState = null;
          const selectedShapeIds = prevPageState.selectedShapeIds.filter((id) => !shapesNoLongerInPage.has(id));
          if (selectedShapeIds.length !== prevPageState.selectedShapeIds.length) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.selectedShapeIds = selectedShapeIds;
          }
          const erasingShapeIds = prevPageState.erasingShapeIds.filter((id) => !shapesNoLongerInPage.has(id));
          if (erasingShapeIds.length !== prevPageState.erasingShapeIds.length) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.erasingShapeIds = erasingShapeIds;
          }
          if (prevPageState.hoveredShapeId && shapesNoLongerInPage.has(prevPageState.hoveredShapeId)) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.hoveredShapeId = null;
          }
          if (prevPageState.editingShapeId && shapesNoLongerInPage.has(prevPageState.editingShapeId)) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.editingShapeId = null;
          }
          const hintingShapeIds = prevPageState.hintingShapeIds.filter((id) => !shapesNoLongerInPage.has(id));
          if (hintingShapeIds.length !== prevPageState.hintingShapeIds.length) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.hintingShapeIds = hintingShapeIds;
          }
          if (prevPageState.focusedGroupId && shapesNoLongerInPage.has(prevPageState.focusedGroupId)) {
            if (!nextPageState)
              nextPageState = { ...prevPageState };
            nextPageState.focusedGroupId = null;
          }
          return nextPageState;
        };
        this.sideEffects = this.store.sideEffects;
        let deletedBindings = /* @__PURE__ */ new Map();
        const deletedShapeIds = /* @__PURE__ */ new Set();
        const invalidParents = /* @__PURE__ */ new Set();
        let invalidBindingTypes = /* @__PURE__ */ new Set();
        this.disposables.add(this.sideEffects.registerOperationCompleteHandler(() => {
          deletedShapeIds.clear();
          for (const parentId of invalidParents) {
            invalidParents.delete(parentId);
            const parent = this.getShape(parentId);
            if (!parent)
              continue;
            const util = this.getShapeUtil(parent);
            const changes = util.onChildrenChange?.(parent);
            if (changes?.length) {
              this.updateShapes(changes);
            }
          }
          if (invalidBindingTypes.size) {
            const t3 = invalidBindingTypes;
            invalidBindingTypes = /* @__PURE__ */ new Set();
            for (const type of t3) {
              const util = this.getBindingUtil(type);
              util.onOperationComplete?.();
            }
          }
          if (deletedBindings.size) {
            const t3 = deletedBindings;
            deletedBindings = /* @__PURE__ */ new Map();
            for (const opts of t3.values()) {
              this.getBindingUtil(opts.binding).onAfterDelete?.(opts);
            }
          }
          this.emit("update");
        }));
        this.disposables.add(this.sideEffects.register({
          shape: {
            afterChange: (shapeBefore, shapeAfter) => {
              for (const binding of this.getBindingsInvolvingShape(shapeAfter)) {
                invalidBindingTypes.add(binding.type);
                if (binding.fromId === shapeAfter.id) {
                  this.getBindingUtil(binding).onAfterChangeFromShape?.({
                    binding,
                    shapeBefore,
                    shapeAfter
                  });
                }
                if (binding.toId === shapeAfter.id) {
                  this.getBindingUtil(binding).onAfterChangeToShape?.({
                    binding,
                    shapeBefore,
                    shapeAfter
                  });
                }
              }
              if (shapeBefore.parentId !== shapeAfter.parentId) {
                const notifyBindingAncestryChange = (id) => {
                  const descendantShape = this.getShape(id);
                  if (!descendantShape)
                    return;
                  for (const binding of this.getBindingsInvolvingShape(descendantShape)) {
                    invalidBindingTypes.add(binding.type);
                    if (binding.fromId === descendantShape.id) {
                      this.getBindingUtil(binding).onAfterChangeFromShape?.({
                        binding,
                        shapeBefore: descendantShape,
                        shapeAfter: descendantShape
                      });
                    }
                    if (binding.toId === descendantShape.id) {
                      this.getBindingUtil(binding).onAfterChangeToShape?.({
                        binding,
                        shapeBefore: descendantShape,
                        shapeAfter: descendantShape
                      });
                    }
                  }
                };
                notifyBindingAncestryChange(shapeAfter.id);
                this.visitDescendants(shapeAfter.id, notifyBindingAncestryChange);
              }
              if (shapeBefore.parentId !== shapeAfter.parentId && isPageId(shapeAfter.parentId)) {
                const allMovingIds = /* @__PURE__ */ new Set([shapeBefore.id]);
                this.visitDescendants(shapeBefore.id, (id) => {
                  allMovingIds.add(id);
                });
                for (const instancePageState of this.getPageStates()) {
                  if (instancePageState.pageId === shapeAfter.parentId)
                    continue;
                  const nextPageState = cleanupInstancePageState(instancePageState, allMovingIds);
                  if (nextPageState) {
                    this.store.put([nextPageState]);
                  }
                }
              }
              if (shapeBefore.parentId && isShapeId(shapeBefore.parentId)) {
                invalidParents.add(shapeBefore.parentId);
              }
              if (shapeAfter.parentId !== shapeBefore.parentId && isShapeId(shapeAfter.parentId)) {
                invalidParents.add(shapeAfter.parentId);
              }
            },
            beforeDelete: (shape) => {
              if (deletedShapeIds.has(shape.id))
                return;
              if (shape.parentId && isShapeId(shape.parentId)) {
                invalidParents.add(shape.parentId);
              }
              deletedShapeIds.add(shape.id);
              const deleteBindingIds = [];
              for (const binding of this.getBindingsInvolvingShape(shape)) {
                invalidBindingTypes.add(binding.type);
                deleteBindingIds.push(binding.id);
                const util = this.getBindingUtil(binding);
                if (binding.fromId === shape.id) {
                  util.onBeforeIsolateToShape?.({ binding, removedShape: shape });
                  util.onBeforeDeleteFromShape?.({ binding, shape });
                } else {
                  util.onBeforeIsolateFromShape?.({ binding, removedShape: shape });
                  util.onBeforeDeleteToShape?.({ binding, shape });
                }
              }
              if (deleteBindingIds.length) {
                this.deleteBindings(deleteBindingIds);
              }
              const deletedIds = /* @__PURE__ */ new Set([shape.id]);
              const updates = compact(this.getPageStates().map((pageState) => {
                return cleanupInstancePageState(pageState, deletedIds);
              }));
              if (updates.length) {
                this.store.put(updates);
              }
            }
          },
          binding: {
            beforeCreate: (binding) => {
              const next = this.getBindingUtil(binding).onBeforeCreate?.({ binding });
              if (next)
                return next;
              return binding;
            },
            afterCreate: (binding) => {
              invalidBindingTypes.add(binding.type);
              this.getBindingUtil(binding).onAfterCreate?.({ binding });
            },
            beforeChange: (bindingBefore, bindingAfter) => {
              const updated = this.getBindingUtil(bindingAfter).onBeforeChange?.({
                bindingBefore,
                bindingAfter
              });
              if (updated)
                return updated;
              return bindingAfter;
            },
            afterChange: (bindingBefore, bindingAfter) => {
              invalidBindingTypes.add(bindingAfter.type);
              this.getBindingUtil(bindingAfter).onAfterChange?.({ bindingBefore, bindingAfter });
            },
            beforeDelete: (binding) => {
              this.getBindingUtil(binding).onBeforeDelete?.({ binding });
            },
            afterDelete: (binding) => {
              this.getBindingUtil(binding).onAfterDelete?.({ binding });
              invalidBindingTypes.add(binding.type);
            }
          },
          page: {
            afterCreate: (record) => {
              const cameraId = CameraRecordType.createId(record.id);
              const _pageStateId = InstancePageStateRecordType.createId(record.id);
              if (!this.store.has(cameraId)) {
                this.store.put([CameraRecordType.create({ id: cameraId })]);
              }
              if (!this.store.has(_pageStateId)) {
                this.store.put([
                  InstancePageStateRecordType.create({ id: _pageStateId, pageId: record.id })
                ]);
              }
            },
            afterDelete: (record, source) => {
              if (this.getInstanceState()?.currentPageId === record.id) {
                const backupPageId = this.getPages().find((p2) => p2.id !== record.id)?.id;
                if (backupPageId) {
                  this.store.put([{ ...this.getInstanceState(), currentPageId: backupPageId }]);
                } else if (source === "user") {
                  this.store.ensureStoreIsUsable();
                }
              }
              const cameraId = CameraRecordType.createId(record.id);
              const instance_PageStateId = InstancePageStateRecordType.createId(record.id);
              this.store.remove([cameraId, instance_PageStateId]);
            }
          },
          instance: {
            afterChange: (prev, next, source) => {
              if (!this.store.has(next.currentPageId)) {
                const backupPageId = this.store.has(prev.currentPageId) ? prev.currentPageId : this.getPages()[0]?.id;
                if (backupPageId) {
                  this.store.update(next.id, (instance) => ({
                    ...instance,
                    currentPageId: backupPageId
                  }));
                } else if (source === "user") {
                  this.store.ensureStoreIsUsable();
                }
              }
            }
          },
          instance_page_state: {
            afterChange: (prev, next) => {
              if (prev?.selectedShapeIds !== next?.selectedShapeIds) {
                const filtered = next.selectedShapeIds.filter((id) => {
                  let parentId = this.getShape(id)?.parentId;
                  while (isShapeId(parentId)) {
                    if (next.selectedShapeIds.includes(parentId)) {
                      return false;
                    }
                    parentId = this.getShape(parentId)?.parentId;
                  }
                  return true;
                });
                let nextFocusedGroupId = null;
                if (filtered.length > 0) {
                  const commonGroupAncestor = this.findCommonAncestor(compact(filtered.map((id) => this.getShape(id))), (shape) => this.isShapeOfType(shape, "group"));
                  if (commonGroupAncestor) {
                    nextFocusedGroupId = commonGroupAncestor;
                  }
                } else {
                  if (next?.focusedGroupId) {
                    nextFocusedGroupId = next.focusedGroupId;
                  }
                }
                if (filtered.length !== next.selectedShapeIds.length || nextFocusedGroupId !== next.focusedGroupId) {
                  this.store.put([
                    {
                      ...next,
                      selectedShapeIds: filtered,
                      focusedGroupId: nextFocusedGroupId ?? null
                    }
                  ]);
                }
              }
            }
          }
        }));
        this._currentPageShapeIds = deriveShapeIdsInCurrentPage(this.store, () => this.getCurrentPageId());
        this._parentIdsToChildIds = parentsToChildren(this.store);
        this.disposables.add(this.store.listen((changes) => {
          this.emit("change", changes);
        }));
        this.disposables.add(this.history.dispose);
        this.run(() => {
          this.store.ensureStoreIsUsable();
          this._updateCurrentPageState({
            editingShapeId: null,
            hoveredShapeId: null,
            erasingShapeIds: []
          });
        }, { history: "ignore" });
        if (initialState2 && this.root.children[initialState2] === void 0) {
          throw Error(`No state found for initialState "${initialState2}".`);
        }
        this.root.enter(void 0, "initial");
        this.edgeScrollManager = new EdgeScrollManager(this);
        this.focusManager = new FocusManager(this, autoFocus);
        this.disposables.add(this.focusManager.dispose.bind(this.focusManager));
        if (this.getInstanceState().followingUserId) {
          this.stopFollowingUser();
        }
        this.on("tick", this._flushEventsForTick);
        this.timers.requestAnimationFrame(() => {
          this._tickManager.start();
        });
        this.performanceTracker = new PerformanceTracker();
      }
      dispose() {
        this.disposables.forEach((dispose) => dispose());
        this.disposables.clear();
        this.isDisposed = true;
      }
      getShapeUtil(arg) {
        const type = typeof arg === "string" ? arg : arg.type;
        const shapeUtil = getOwnProperty(this.shapeUtils, type);
        assert(shapeUtil, `No shape util found for type "${type}"`);
        return shapeUtil;
      }
      getBindingUtil(arg) {
        const type = typeof arg === "string" ? arg : arg.type;
        const bindingUtil = getOwnProperty(this.bindingUtils, type);
        assert(bindingUtil, `No binding util found for type "${type}"`);
        return bindingUtil;
      }
      undo() {
        this._flushEventsForTick(0);
        this.complete();
        this.history.undo();
        return this;
      }
      getCanUndo() {
        return this.history.getNumUndos() > 0;
      }
      redo() {
        this._flushEventsForTick(0);
        this.complete();
        this.history.redo();
        return this;
      }
      clearHistory() {
        this.history.clear();
        return this;
      }
      getCanRedo() {
        return this.history.getNumRedos() > 0;
      }
      mark(markId) {
        this.history.mark(markId);
        return this;
      }
      squashToMark(markId) {
        this.history.squashToMark(markId);
        return this;
      }
      bail() {
        this.history.bail();
        return this;
      }
      bailToMark(id) {
        this.history.bailToMark(id);
        return this;
      }
      run(fn3, opts) {
        const previousIgnoreShapeLock = this._shouldIgnoreShapeLock;
        this._shouldIgnoreShapeLock = opts?.ignoreShapeLock ?? previousIgnoreShapeLock;
        try {
          this.history.batch(fn3, opts);
        } finally {
          this._shouldIgnoreShapeLock = previousIgnoreShapeLock;
        }
        return this;
      }
      batch(fn3, opts) {
        return this.run(fn3, opts);
      }
      annotateError(error2, {
        origin,
        willCrashApp,
        tags,
        extras
      }) {
        const defaultAnnotations = this.createErrorAnnotations(origin, willCrashApp);
        annotateError(error2, {
          tags: { ...defaultAnnotations.tags, ...tags },
          extras: { ...defaultAnnotations.extras, ...extras }
        });
        if (willCrashApp) {
          this.store.markAsPossiblyCorrupted();
        }
        return this;
      }
      createErrorAnnotations(origin, willCrashApp) {
        try {
          const editingShapeId = this.getEditingShapeId();
          return {
            tags: {
              origin,
              willCrashApp
            },
            extras: {
              activeStateNode: this.root.getPath(),
              selectedShapes: this.getSelectedShapes(),
              editingShape: editingShapeId ? this.getShape(editingShapeId) : void 0,
              inputs: this.inputs
            }
          };
        } catch {
          return {
            tags: {
              origin,
              willCrashApp
            },
            extras: {}
          };
        }
      }
      getCrashingError() {
        return this._crashingError;
      }
      crash(error2) {
        this._crashingError = error2;
        this.store.markAsPossiblyCorrupted();
        this.emit("crash", { error: error2 });
        return this;
      }
      getPath() {
        return this.root.getPath().split("root.")[1];
      }
      isIn(path) {
        const ids = path.split(".").reverse();
        let state = this.root;
        while (ids.length > 0) {
          const id = ids.pop();
          if (!id)
            return true;
          const current = state.getCurrent();
          if (current?.id === id) {
            if (ids.length === 0)
              return true;
            state = current;
            continue;
          } else
            return false;
        }
        return false;
      }
      isInAny(...paths) {
        return paths.some((path) => this.isIn(path));
      }
      setCurrentTool(id, info2 = {}) {
        this.root.transition(id, info2);
        return this;
      }
      getCurrentTool() {
        return this.root.getCurrent();
      }
      getCurrentToolId() {
        const currentTool = this.getCurrentTool();
        if (!currentTool)
          return "";
        return currentTool.getCurrentToolIdMask() ?? currentTool.id;
      }
      getStateDescendant(path) {
        const ids = path.split(".").reverse();
        let state = this.root;
        while (ids.length > 0) {
          const id = ids.pop();
          if (!id)
            return state;
          const childState = state.children?.[id];
          if (!childState)
            return void 0;
          state = childState;
        }
        return state;
      }
      getDocumentSettings() {
        return this.store.get(TLDOCUMENT_ID);
      }
      updateDocumentSettings(settings) {
        this.run(() => {
          this.store.put([{ ...this.getDocumentSettings(), ...settings }]);
        }, { history: "ignore" });
        return this;
      }
      getInstanceState() {
        return this.store.get(TLINSTANCE_ID);
      }
      updateInstanceState(partial, historyOptions) {
        this._updateInstanceState(partial, { history: "ignore", ...historyOptions });
        if (partial.isChangingStyle !== void 0) {
          clearTimeout(this._isChangingStyleTimeout);
          if (partial.isChangingStyle === true) {
            this._isChangingStyleTimeout = this.timers.setTimeout(() => {
              this._updateInstanceState({ isChangingStyle: false }, { history: "ignore" });
            }, 2e3);
          }
        }
        return this;
      }
      getOpenMenus() {
        return this.getInstanceState().openMenus;
      }
      addOpenMenu(id) {
        const menus = new Set(this.getOpenMenus());
        if (!menus.has(id)) {
          menus.add(id);
          this.updateInstanceState({ openMenus: [...menus] });
        }
        return this;
      }
      deleteOpenMenu(id) {
        const menus = new Set(this.getOpenMenus());
        if (menus.has(id)) {
          menus.delete(id);
          this.updateInstanceState({ openMenus: [...menus] });
        }
        return this;
      }
      clearOpenMenus() {
        if (this.getOpenMenus().length) {
          this.updateInstanceState({ openMenus: [] });
        }
        return this;
      }
      getIsMenuOpen() {
        return this.getOpenMenus().length > 0;
      }
      getPageStates() {
        return this._getPageStatesQuery().get();
      }
      _getPageStatesQuery() {
        return this.store.query.records("instance_page_state");
      }
      getCurrentPageState() {
        return this.store.get(this._getCurrentPageStateId());
      }
      _getCurrentPageStateId() {
        return InstancePageStateRecordType.createId(this.getCurrentPageId());
      }
      updateCurrentPageState(partial) {
        this._updateCurrentPageState(partial);
        return this;
      }
      getSelectedShapeIds() {
        return this.getCurrentPageState().selectedShapeIds;
      }
      getSelectedShapes() {
        const { selectedShapeIds } = this.getCurrentPageState();
        return compact(selectedShapeIds.map((id) => this.store.get(id)));
      }
      setSelectedShapes(shapes) {
        return this.run(() => {
          const ids = shapes.map((shape) => typeof shape === "string" ? shape : shape.id);
          const { selectedShapeIds: prevSelectedShapeIds } = this.getCurrentPageState();
          const prevSet = new Set(prevSelectedShapeIds);
          if (ids.length === prevSet.size && ids.every((id) => prevSet.has(id)))
            return null;
          this.store.put([{ ...this.getCurrentPageState(), selectedShapeIds: ids }]);
        }, { history: "record-preserveRedoStack" });
      }
      isAncestorSelected(shape) {
        const id = typeof shape === "string" ? shape : shape?.id ?? null;
        const _shape = this.getShape(id);
        if (!_shape)
          return false;
        const selectedShapeIds = this.getSelectedShapeIds();
        return !!this.findShapeAncestor(_shape, (parent) => selectedShapeIds.includes(parent.id));
      }
      select(...shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((shape) => shape.id);
        this.setSelectedShapes(ids);
        return this;
      }
      deselect(...shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((shape) => shape.id);
        const selectedShapeIds = this.getSelectedShapeIds();
        if (selectedShapeIds.length > 0 && ids.length > 0) {
          this.setSelectedShapes(selectedShapeIds.filter((id) => !ids.includes(id)));
        }
        return this;
      }
      selectAll() {
        const ids = this.getSortedChildIdsForParent(this.getCurrentPageId());
        if (ids.length <= 0)
          return this;
        this.setSelectedShapes(this._getUnlockedShapeIds(ids));
        return this;
      }
      selectNone() {
        if (this.getSelectedShapeIds().length > 0) {
          this.setSelectedShapes([]);
        }
        return this;
      }
      getOnlySelectedShapeId() {
        return this.getOnlySelectedShape()?.id ?? null;
      }
      getOnlySelectedShape() {
        const selectedShapes = this.getSelectedShapes();
        return selectedShapes.length === 1 ? selectedShapes[0] : null;
      }
      getSelectionPageBounds() {
        const selectedShapeIds = this.getCurrentPageState().selectedShapeIds;
        if (selectedShapeIds.length === 0)
          return null;
        return Box.Common(compact(selectedShapeIds.map((id) => this.getShapePageBounds(id))));
      }
      getSelectionRotation() {
        const selectedShapeIds = this.getSelectedShapeIds();
        let foundFirst = false;
        let rotation = 0;
        for (let i2 = 0, n2 = selectedShapeIds.length; i2 < n2; i2++) {
          const pageTransform = this.getShapePageTransform(selectedShapeIds[i2]);
          if (!pageTransform)
            continue;
          if (foundFirst) {
            if (pageTransform.rotation() !== rotation) {
              return 0;
            }
          } else {
            foundFirst = true;
            rotation = pageTransform.rotation();
          }
        }
        return rotation;
      }
      getSelectionRotatedPageBounds() {
        const selectedShapeIds = this.getSelectedShapeIds();
        if (selectedShapeIds.length === 0) {
          return void 0;
        }
        const selectionRotation = this.getSelectionRotation();
        if (selectionRotation === 0) {
          return this.getSelectionPageBounds();
        }
        if (selectedShapeIds.length === 1) {
          const bounds = this.getShapeGeometry(selectedShapeIds[0]).bounds.clone();
          const pageTransform = this.getShapePageTransform(selectedShapeIds[0]);
          bounds.point = pageTransform.applyToPoint(bounds.point);
          return bounds;
        }
        const boxFromRotatedVertices = Box.FromPoints(this.getSelectedShapeIds().flatMap((id) => {
          const pageTransform = this.getShapePageTransform(id);
          if (!pageTransform)
            return [];
          return pageTransform.applyToPoints(this.getShapeGeometry(id).bounds.corners);
        }).map((p2) => p2.rot(-selectionRotation)));
        boxFromRotatedVertices.point = boxFromRotatedVertices.point.rot(selectionRotation);
        return boxFromRotatedVertices;
      }
      getSelectionRotatedScreenBounds() {
        const bounds = this.getSelectionRotatedPageBounds();
        if (!bounds)
          return void 0;
        const { x: x2, y: y2 } = this.pageToScreen(bounds.point);
        const zoom = this.getZoomLevel();
        return new Box(x2, y2, bounds.width * zoom, bounds.height * zoom);
      }
      getFocusedGroupId() {
        return this.getCurrentPageState().focusedGroupId ?? this.getCurrentPageId();
      }
      getFocusedGroup() {
        const focusedGroupId = this.getFocusedGroupId();
        return focusedGroupId ? this.getShape(focusedGroupId) : void 0;
      }
      setFocusedGroup(shape) {
        const id = typeof shape === "string" ? shape : shape?.id ?? null;
        if (id !== null) {
          const shape2 = this.getShape(id);
          if (!shape2) {
            throw Error(`Editor.setFocusedGroup: Shape with id ${id} does not exist`);
          }
          if (!this.isShapeOfType(shape2, "group")) {
            throw Error(`Editor.setFocusedGroup: Cannot set focused group to shape of type ${shape2.type}`);
          }
        }
        if (id === this.getFocusedGroupId())
          return this;
        return this.run(() => {
          this.store.update(this.getCurrentPageState().id, (s2) => ({ ...s2, focusedGroupId: id }));
        }, { history: "record-preserveRedoStack" });
      }
      popFocusedGroupId() {
        const focusedGroup = this.getFocusedGroup();
        if (focusedGroup) {
          const match = this.findShapeAncestor(focusedGroup, (shape) => this.isShapeOfType(shape, "group"));
          this.setFocusedGroup(match?.id ?? null);
          this.select(focusedGroup.id);
        } else {
          this.setFocusedGroup(null);
          this.selectNone();
        }
        return this;
      }
      getEditingShapeId() {
        return this.getCurrentPageState().editingShapeId;
      }
      getEditingShape() {
        const editingShapeId = this.getEditingShapeId();
        return editingShapeId ? this.getShape(editingShapeId) : void 0;
      }
      setEditingShape(shape) {
        const id = typeof shape === "string" ? shape : shape?.id ?? null;
        if (id !== this.getEditingShapeId()) {
          if (id) {
            const shape2 = this.getShape(id);
            if (shape2 && this.getShapeUtil(shape2).canEdit(shape2)) {
              this.run(() => {
                this._updateCurrentPageState({ editingShapeId: id });
              }, { history: "ignore" });
              return this;
            }
          }
          this.run(() => {
            this._updateCurrentPageState({ editingShapeId: null });
          }, { history: "ignore" });
        }
        return this;
      }
      getHoveredShapeId() {
        return this.getCurrentPageState().hoveredShapeId;
      }
      getHoveredShape() {
        const hoveredShapeId = this.getHoveredShapeId();
        return hoveredShapeId ? this.getShape(hoveredShapeId) : void 0;
      }
      setHoveredShape(shape) {
        const id = typeof shape === "string" ? shape : shape?.id ?? null;
        if (id === this.getHoveredShapeId())
          return this;
        this.run(() => {
          this.updateCurrentPageState({ hoveredShapeId: id });
        }, { history: "ignore" });
        return this;
      }
      getHintingShapeIds() {
        return this.getCurrentPageState().hintingShapeIds;
      }
      getHintingShape() {
        const hintingShapeIds = this.getHintingShapeIds();
        return compact(hintingShapeIds.map((id) => this.getShape(id)));
      }
      setHintingShapes(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((shape) => shape.id);
        this.run(() => {
          this._updateCurrentPageState({ hintingShapeIds: dedupe(ids) });
        }, { history: "ignore" });
        return this;
      }
      getErasingShapeIds() {
        return this.getCurrentPageState().erasingShapeIds;
      }
      getErasingShapes() {
        const erasingShapeIds = this.getErasingShapeIds();
        return compact(erasingShapeIds.map((id) => this.getShape(id)));
      }
      setErasingShapes(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((shape) => shape.id);
        ids.sort();
        const erasingShapeIds = this.getErasingShapeIds();
        this.run(() => {
          if (ids.length === erasingShapeIds.length) {
            for (let i2 = 0; i2 < ids.length; i2++) {
              if (ids[i2] !== erasingShapeIds[i2]) {
                this._updateCurrentPageState({ erasingShapeIds: ids });
                break;
              }
            }
          } else {
            this._updateCurrentPageState({ erasingShapeIds: ids });
          }
        }, { history: "ignore" });
        return this;
      }
      getCroppingShapeId() {
        return this.getCurrentPageState().croppingShapeId;
      }
      setCroppingShape(shape) {
        const id = typeof shape === "string" ? shape : shape?.id ?? null;
        if (id !== this.getCroppingShapeId()) {
          this.run(() => {
            if (!id) {
              this.updateCurrentPageState({ croppingShapeId: null });
            } else {
              const shape2 = this.getShape(id);
              const util = this.getShapeUtil(shape2);
              if (shape2 && util.canCrop(shape2)) {
                this.updateCurrentPageState({ croppingShapeId: id });
              }
            }
          }, { history: "ignore" });
        }
        return this;
      }
      _unsafe_getCameraId() {
        return CameraRecordType.createId(this.getCurrentPageId());
      }
      getCamera() {
        const baseCamera = this.store.get(this._unsafe_getCameraId());
        if (this._isLockedOnFollowingUser.get()) {
          const followingCamera = this.getCameraForFollowing();
          if (followingCamera) {
            return { ...baseCamera, ...followingCamera };
          }
        }
        return baseCamera;
      }
      getViewportPageBoundsForFollowing() {
        const followingUserId = this.getInstanceState().followingUserId;
        if (!followingUserId)
          return null;
        const leaderPresence = this.getCollaborators().find((c2) => c2.userId === followingUserId);
        if (!leaderPresence)
          return null;
        const { w: lw, h: lh } = leaderPresence.screenBounds;
        const { x: lx, y: ly, z: lz2 } = leaderPresence.camera;
        const theirViewport = new Box(-lx, -ly, lw / lz2, lh / lz2);
        const ourViewport = this.getViewportScreenBounds().clone();
        const ourAspectRatio = ourViewport.width / ourViewport.height;
        ourViewport.width = theirViewport.width;
        ourViewport.height = ourViewport.width / ourAspectRatio;
        if (ourViewport.height < theirViewport.height) {
          ourViewport.height = theirViewport.height;
          ourViewport.width = ourViewport.height * ourAspectRatio;
        }
        ourViewport.center = theirViewport.center;
        return ourViewport;
      }
      getCameraForFollowing() {
        const viewport2 = this.getViewportPageBoundsForFollowing();
        if (!viewport2)
          return null;
        return {
          x: -viewport2.x,
          y: -viewport2.y,
          z: this.getViewportScreenBounds().w / viewport2.width
        };
      }
      getZoomLevel() {
        return this.getCamera().z;
      }
      getInitialZoom() {
        const cameraOptions = this.getCameraOptions();
        if (!cameraOptions.constraints)
          return 1;
        if (cameraOptions.constraints.initialZoom === "default")
          return 1;
        const { zx, zy } = getCameraFitXFitY(this, cameraOptions);
        switch (cameraOptions.constraints.initialZoom) {
          case "fit-min": {
            return Math.max(zx, zy);
          }
          case "fit-max": {
            return Math.min(zx, zy);
          }
          case "fit-x": {
            return zx;
          }
          case "fit-y": {
            return zy;
          }
          case "fit-min-100": {
            return Math.min(1, Math.max(zx, zy));
          }
          case "fit-max-100": {
            return Math.min(1, Math.min(zx, zy));
          }
          case "fit-x-100": {
            return Math.min(1, zx);
          }
          case "fit-y-100": {
            return Math.min(1, zy);
          }
          default: {
            throw exhaustiveSwitchError(cameraOptions.constraints.initialZoom);
          }
        }
      }
      getBaseZoom() {
        const cameraOptions = this.getCameraOptions();
        if (!cameraOptions.constraints)
          return 1;
        if (cameraOptions.constraints.baseZoom === "default")
          return 1;
        const { zx, zy } = getCameraFitXFitY(this, cameraOptions);
        switch (cameraOptions.constraints.baseZoom) {
          case "fit-min": {
            return Math.max(zx, zy);
          }
          case "fit-max": {
            return Math.min(zx, zy);
          }
          case "fit-x": {
            return zx;
          }
          case "fit-y": {
            return zy;
          }
          case "fit-min-100": {
            return Math.min(1, Math.max(zx, zy));
          }
          case "fit-max-100": {
            return Math.min(1, Math.min(zx, zy));
          }
          case "fit-x-100": {
            return Math.min(1, zx);
          }
          case "fit-y-100": {
            return Math.min(1, zy);
          }
          default: {
            throw exhaustiveSwitchError(cameraOptions.constraints.baseZoom);
          }
        }
      }
      getCameraOptions() {
        return this._cameraOptions.get();
      }
      setCameraOptions(options) {
        const next = structuredClone2({
          ...this._cameraOptions.__unsafe__getWithoutCapture(),
          ...options
        });
        if (next.zoomSteps?.length < 1)
          next.zoomSteps = [1];
        this._cameraOptions.set(next);
        return this;
      }
      getConstrainedCamera(point, opts) {
        const currentCamera = this.getCamera();
        let { x: x2, y: y2, z = currentCamera.z } = point;
        if (!opts?.force) {
          const cameraOptions = this.getCameraOptions();
          const zoomMin = cameraOptions.zoomSteps[0];
          const zoomMax = last(cameraOptions.zoomSteps);
          const vsb = this.getViewportScreenBounds();
          if (cameraOptions.constraints) {
            const { constraints } = cameraOptions;
            const py = Math.min(constraints.padding.y, vsb.w / 2);
            const px = Math.min(constraints.padding.x, vsb.h / 2);
            const bounds = Box.From(cameraOptions.constraints.bounds);
            const zx = (vsb.w - px * 2) / bounds.w;
            const zy = (vsb.h - py * 2) / bounds.h;
            const baseZoom = this.getBaseZoom();
            const maxZ = zoomMax * baseZoom;
            const minZ = zoomMin * baseZoom;
            if (opts?.reset) {
              z = this.getInitialZoom();
            }
            if (z < minZ || z > maxZ) {
              const { x: cx, y: cy, z: cz } = currentCamera;
              const cxA = -cx + vsb.w / cz / 2;
              const cyA = -cy + vsb.h / cz / 2;
              z = clamp(z, minZ, maxZ);
              const cxB = -cx + vsb.w / z / 2;
              const cyB = -cy + vsb.h / z / 2;
              x2 = cx + cxB - cxA;
              y2 = cy + cyB - cyA;
            }
            const minX = px / z - bounds.x;
            const minY = py / z - bounds.y;
            const freeW = (vsb.w - px * 2) / z - bounds.w;
            const freeH = (vsb.h - py * 2) / z - bounds.h;
            const originX = minX + freeW * constraints.origin.x;
            const originY = minY + freeH * constraints.origin.y;
            const behaviorX = typeof constraints.behavior === "string" ? constraints.behavior : constraints.behavior.x;
            const behaviorY = typeof constraints.behavior === "string" ? constraints.behavior : constraints.behavior.y;
            if (opts?.reset) {
              x2 = originX;
              y2 = originY;
            } else {
              switch (behaviorX) {
                case "fixed": {
                  x2 = originX;
                  break;
                }
                case "contain": {
                  if (z < zx)
                    x2 = originX;
                  else
                    x2 = clamp(x2, minX + freeW, minX);
                  break;
                }
                case "inside": {
                  if (z < zx)
                    x2 = clamp(x2, minX, (vsb.w - px) / z - bounds.w);
                  else
                    x2 = clamp(x2, minX + freeW, minX);
                  break;
                }
                case "outside": {
                  x2 = clamp(x2, px / z - bounds.w, (vsb.w - px) / z);
                  break;
                }
                case "free": {
                  break;
                }
                default: {
                  throw exhaustiveSwitchError(behaviorX);
                }
              }
              switch (behaviorY) {
                case "fixed": {
                  y2 = originY;
                  break;
                }
                case "contain": {
                  if (z < zy)
                    y2 = originY;
                  else
                    y2 = clamp(y2, minY + freeH, minY);
                  break;
                }
                case "inside": {
                  if (z < zy)
                    y2 = clamp(y2, minY, (vsb.h - py) / z - bounds.h);
                  else
                    y2 = clamp(y2, minY + freeH, minY);
                  break;
                }
                case "outside": {
                  y2 = clamp(y2, py / z - bounds.h, (vsb.h - py) / z);
                  break;
                }
                case "free": {
                  break;
                }
                default: {
                  throw exhaustiveSwitchError(behaviorY);
                }
              }
            }
          } else {
            if (z > zoomMax || z < zoomMin) {
              const { x: cx, y: cy, z: cz } = currentCamera;
              z = clamp(z, zoomMin, zoomMax);
              x2 = cx + (-cx + vsb.w / z / 2) - (-cx + vsb.w / cz / 2);
              y2 = cy + (-cy + vsb.h / z / 2) - (-cy + vsb.h / cz / 2);
            }
          }
        }
        return { x: x2, y: y2, z };
      }
      _setCamera(point, opts) {
        const currentCamera = this.getCamera();
        const { x: x2, y: y2, z } = this.getConstrainedCamera(point, opts);
        if (currentCamera.x === x2 && currentCamera.y === y2 && currentCamera.z === z) {
          return this;
        }
        transact(() => {
          const camera = { ...currentCamera, x: x2, y: y2, z };
          this.run(() => {
            this.store.put([camera]);
          }, { history: "ignore" });
          const { currentScreenPoint, currentPagePoint } = this.inputs;
          const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
          if (currentScreenPoint.x / z - x2 !== currentPagePoint.x || currentScreenPoint.y / z - y2 !== currentPagePoint.y) {
            const event = {
              type: "pointer",
              target: "canvas",
              name: "pointer_move",
              point: Vec.AddXY(currentScreenPoint, screenBounds.x, screenBounds.y),
              pointerId: INTERNAL_POINTER_IDS.CAMERA_MOVE,
              ctrlKey: this.inputs.ctrlKey,
              altKey: this.inputs.altKey,
              shiftKey: this.inputs.shiftKey,
              button: 0,
              isPen: this.getInstanceState().isPenMode ?? false
            };
            if (opts?.immediate) {
              this._flushEventForTick(event);
            } else {
              this.dispatch(event);
            }
          }
          this._tickCameraState();
        });
        return this;
      }
      setCamera(point, opts) {
        const { isLocked } = this._cameraOptions.__unsafe__getWithoutCapture();
        if (isLocked && !opts?.force)
          return this;
        this.stopCameraAnimation();
        if (this.getInstanceState().followingUserId) {
          this.stopFollowingUser();
        }
        const _point = Vec.Cast(point);
        if (!Number.isFinite(_point.x))
          _point.x = 0;
        if (!Number.isFinite(_point.y))
          _point.y = 0;
        if (_point.z === void 0 || !Number.isFinite(_point.z))
          point.z = this.getZoomLevel();
        const camera = this.getConstrainedCamera(_point, opts);
        if (opts?.animation) {
          const { width, height } = this.getViewportScreenBounds();
          this._animateToViewport(new Box(-camera.x, -camera.y, width / camera.z, height / camera.z), opts);
        } else {
          this._setCamera(camera, {
            ...opts,
            force: true
          });
        }
        return this;
      }
      centerOnPoint(point, opts) {
        const { isLocked } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const { width: pw, height: ph } = this.getViewportPageBounds();
        this.setCamera(new Vec(-(point.x - pw / 2), -(point.y - ph / 2), this.getCamera().z), opts);
        return this;
      }
      zoomToFit(opts) {
        const ids = [...this.getCurrentPageShapeIds()];
        if (ids.length <= 0)
          return this;
        const pageBounds = Box.Common(compact(ids.map((id) => this.getShapePageBounds(id))));
        this.zoomToBounds(pageBounds, opts);
        return this;
      }
      resetZoom(point = this.getViewportScreenCenter(), opts) {
        const { isLocked, constraints } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const currentCamera = this.getCamera();
        const { x: cx, y: cy, z: cz } = currentCamera;
        const { x: x2, y: y2 } = point;
        let z = 1;
        if (constraints) {
          const initialZoom = this.getInitialZoom();
          if (cz !== initialZoom) {
            z = initialZoom;
          }
        }
        this.setCamera(new Vec(cx + (x2 / z - x2) - (x2 / cz - x2), cy + (y2 / z - y2) - (y2 / cz - y2), z), opts);
        return this;
      }
      zoomIn(point = this.getViewportScreenCenter(), opts) {
        const { isLocked } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const { x: cx, y: cy, z: cz } = this.getCamera();
        const { zoomSteps } = this.getCameraOptions();
        if (zoomSteps !== null && zoomSteps.length > 1) {
          const baseZoom = this.getBaseZoom();
          let zoom = last(zoomSteps) * baseZoom;
          for (let i2 = 1; i2 < zoomSteps.length; i2++) {
            const z1 = zoomSteps[i2 - 1] * baseZoom;
            const z2 = zoomSteps[i2] * baseZoom;
            if (z2 - cz <= (z2 - z1) / 2)
              continue;
            zoom = z2;
            break;
          }
          this.setCamera(new Vec(cx + (point.x / zoom - point.x) - (point.x / cz - point.x), cy + (point.y / zoom - point.y) - (point.y / cz - point.y), zoom), opts);
        }
        return this;
      }
      zoomOut(point = this.getViewportScreenCenter(), opts) {
        const { isLocked } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const { zoomSteps } = this.getCameraOptions();
        if (zoomSteps !== null && zoomSteps.length > 1) {
          const baseZoom = this.getBaseZoom();
          const { x: cx, y: cy, z: cz } = this.getCamera();
          let zoom = zoomSteps[0] * baseZoom;
          for (let i2 = zoomSteps.length - 1; i2 > 0; i2--) {
            const z1 = zoomSteps[i2 - 1] * baseZoom;
            const z2 = zoomSteps[i2] * baseZoom;
            if (z2 - cz >= (z2 - z1) / 2)
              continue;
            zoom = z1;
            break;
          }
          this.setCamera(new Vec(cx + (point.x / zoom - point.x) - (point.x / cz - point.x), cy + (point.y / zoom - point.y) - (point.y / cz - point.y), zoom), opts);
        }
        return this;
      }
      zoomToSelection(opts) {
        const { isLocked } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const selectionPageBounds = this.getSelectionPageBounds();
        if (selectionPageBounds) {
          this.zoomToBounds(selectionPageBounds, {
            targetZoom: Math.max(1, this.getZoomLevel()),
            ...opts
          });
        }
        return this;
      }
      zoomToBounds(bounds, opts) {
        const cameraOptions = this._cameraOptions.__unsafe__getWithoutCapture();
        if (cameraOptions.isLocked && !opts?.force)
          return this;
        const viewportScreenBounds = this.getViewportScreenBounds();
        const inset = opts?.inset ?? Math.min(ZOOM_TO_FIT_PADDING, viewportScreenBounds.width * 0.28);
        const baseZoom = this.getBaseZoom();
        const zoomMin = cameraOptions.zoomSteps[0];
        const zoomMax = last(cameraOptions.zoomSteps);
        let zoom = clamp(Math.min((viewportScreenBounds.width - inset) / bounds.w, (viewportScreenBounds.height - inset) / bounds.h), zoomMin * baseZoom, zoomMax * baseZoom);
        if (opts?.targetZoom !== void 0) {
          zoom = Math.min(opts.targetZoom, zoom);
        }
        this.setCamera(new Vec(-bounds.x + (viewportScreenBounds.width - bounds.w * zoom) / 2 / zoom, -bounds.y + (viewportScreenBounds.height - bounds.h * zoom) / 2 / zoom, zoom), opts);
        return this;
      }
      stopCameraAnimation() {
        this.emit("stop-camera-animation");
        return this;
      }
      _animateViewport(ms) {
        if (!this._viewportAnimation)
          return;
        this._viewportAnimation.elapsed += ms;
        const { elapsed, easing, duration, start: start2, end: end2 } = this._viewportAnimation;
        if (elapsed > duration) {
          this.off("tick", this._animateViewport);
          this._viewportAnimation = null;
          this._setCamera(new Vec(-end2.x, -end2.y, this.getViewportScreenBounds().width / end2.width));
          return;
        }
        const remaining = duration - elapsed;
        const t3 = easing(1 - remaining / duration);
        const left2 = start2.minX + (end2.minX - start2.minX) * t3;
        const top2 = start2.minY + (end2.minY - start2.minY) * t3;
        const right2 = start2.maxX + (end2.maxX - start2.maxX) * t3;
        this._setCamera(new Vec(-left2, -top2, this.getViewportScreenBounds().width / (right2 - left2)), {
          force: true
        });
      }
      _animateToViewport(targetViewportPage, opts = { animation: DEFAULT_ANIMATION_OPTIONS }) {
        const { animation, ...rest } = opts;
        if (!animation)
          return;
        const { duration = 0, easing = EASINGS.easeInOutCubic } = animation;
        const animationSpeed = this.user.getAnimationSpeed();
        const viewportPageBounds = this.getViewportPageBounds();
        this.stopCameraAnimation();
        if (this.getInstanceState().followingUserId) {
          this.stopFollowingUser();
        }
        if (duration === 0 || animationSpeed === 0) {
          return this._setCamera(new Vec(-targetViewportPage.x, -targetViewportPage.y, this.getViewportScreenBounds().width / targetViewportPage.width), { ...rest });
        }
        this._viewportAnimation = {
          elapsed: 0,
          duration: duration / animationSpeed,
          easing,
          start: viewportPageBounds.clone(),
          end: targetViewportPage.clone()
        };
        this.once("stop-camera-animation", () => {
          this.off("tick", this._animateViewport);
          this._viewportAnimation = null;
        });
        this.on("tick", this._animateViewport);
        return this;
      }
      slideCamera(opts = {}) {
        const { isLocked } = this.getCameraOptions();
        if (isLocked && !opts?.force)
          return this;
        const animationSpeed = this.user.getAnimationSpeed();
        if (animationSpeed === 0)
          return this;
        this.stopCameraAnimation();
        const {
          speed,
          friction = this.options.cameraSlideFriction,
          direction,
          speedThreshold = 0.01
        } = opts;
        let currentSpeed = Math.min(speed, 1);
        const cancel = () => {
          this.off("tick", moveCamera);
          this.off("stop-camera-animation", cancel);
        };
        this.once("stop-camera-animation", cancel);
        const moveCamera = (elapsed) => {
          const { x: cx, y: cy, z: cz } = this.getCamera();
          const movementVec = Vec.Mul(direction, currentSpeed * elapsed / cz);
          currentSpeed *= 1 - friction;
          if (currentSpeed < speedThreshold) {
            cancel();
          } else {
            this._setCamera(new Vec(cx + movementVec.x, cy + movementVec.y, cz));
          }
        };
        this.on("tick", moveCamera);
        return this;
      }
      zoomToUser(userId, opts = { animation: { duration: 500 } }) {
        const presence = this.getCollaborators().find((c2) => c2.userId === userId);
        if (!presence)
          return this;
        this.run(() => {
          if (this.getInstanceState().followingUserId !== null) {
            this.stopFollowingUser();
          }
          const isOnSamePage = presence.currentPageId === this.getCurrentPageId();
          if (!isOnSamePage) {
            this.setCurrentPage(presence.currentPageId);
          }
          if (opts && opts.animation && !isOnSamePage) {
            opts.animation = void 0;
          }
          this.centerOnPoint(presence.cursor, opts);
          const { highlightedUserIds } = this.getInstanceState();
          this.updateInstanceState({ highlightedUserIds: [...highlightedUserIds, userId] });
          this.timers.setTimeout(() => {
            const highlightedUserIds2 = [...this.getInstanceState().highlightedUserIds];
            const index3 = highlightedUserIds2.indexOf(userId);
            if (index3 < 0)
              return;
            highlightedUserIds2.splice(index3, 1);
            this.updateInstanceState({ highlightedUserIds: highlightedUserIds2 });
          }, this.options.collaboratorIdleTimeoutMs);
        });
        return this;
      }
      updateViewportScreenBounds(screenBounds, center = false) {
        screenBounds.width = Math.max(screenBounds.width, 1);
        screenBounds.height = Math.max(screenBounds.height, 1);
        const insets = [
          screenBounds.minY !== 0,
          !approximately(document.body.scrollWidth, screenBounds.maxX, 1),
          !approximately(document.body.scrollHeight, screenBounds.maxY, 1),
          screenBounds.minX !== 0
        ];
        const { screenBounds: prevScreenBounds, insets: prevInsets } = this.getInstanceState();
        if (screenBounds.equals(prevScreenBounds) && insets.every((v2, i2) => v2 === prevInsets[i2])) {
          return this;
        }
        const { _willSetInitialBounds } = this;
        this._willSetInitialBounds = false;
        if (_willSetInitialBounds) {
          this.updateInstanceState({ screenBounds: screenBounds.toJson(), insets });
          this.setCamera(this.getCamera());
        } else {
          if (center && !this.getInstanceState().followingUserId) {
            const before = this.getViewportPageBounds().center;
            this.updateInstanceState({ screenBounds: screenBounds.toJson(), insets });
            this.centerOnPoint(before);
          } else {
            this.updateInstanceState({ screenBounds: screenBounds.toJson(), insets });
            this._setCamera(Vec.From({ ...this.getCamera() }));
          }
        }
        this._tickCameraState();
        return this;
      }
      getViewportScreenBounds() {
        const { x: x2, y: y2, w: w2, h: h2 } = this.getInstanceState().screenBounds;
        return new Box(x2, y2, w2, h2);
      }
      getViewportScreenCenter() {
        const viewportScreenBounds = this.getViewportScreenBounds();
        return new Vec(viewportScreenBounds.midX - viewportScreenBounds.minX, viewportScreenBounds.midY - viewportScreenBounds.minY);
      }
      getViewportPageBounds() {
        const { w: w2, h: h2 } = this.getViewportScreenBounds();
        const { x: cx, y: cy, z: cz } = this.getCamera();
        return new Box(-cx, -cy, w2 / cz, h2 / cz);
      }
      screenToPage(point) {
        const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
        const { x: cx, y: cy, z: cz = 1 } = this.getCamera();
        return new Vec((point.x - screenBounds.x) / cz - cx, (point.y - screenBounds.y) / cz - cy, point.z ?? 0.5);
      }
      pageToScreen(point) {
        const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
        const { x: cx, y: cy, z: cz = 1 } = this.getCamera();
        return new Vec((point.x + cx) * cz + screenBounds.x, (point.y + cy) * cz + screenBounds.y, point.z ?? 0.5);
      }
      pageToViewport(point) {
        const { x: cx, y: cy, z: cz = 1 } = this.getCamera();
        return new Vec((point.x + cx) * cz, (point.y + cy) * cz, point.z ?? 0.5);
      }
      _getCollaboratorsQuery() {
        return this.store.query.records("instance_presence", () => ({
          userId: { neq: this.user.getId() }
        }));
      }
      getCollaborators() {
        const allPresenceRecords = this._getCollaboratorsQuery().get();
        if (!allPresenceRecords.length)
          return EMPTY_ARRAY;
        const userIds = [...new Set(allPresenceRecords.map((c2) => c2.userId))].sort();
        return userIds.map((id) => {
          const latestPresence = allPresenceRecords.filter((c2) => c2.userId === id).sort((a2, b2) => b2.lastActivityTimestamp - a2.lastActivityTimestamp)[0];
          return latestPresence;
        });
      }
      getCollaboratorsOnCurrentPage() {
        const currentPageId = this.getCurrentPageId();
        return this.getCollaborators().filter((c2) => c2.currentPageId === currentPageId);
      }
      startFollowingUser(userId) {
        this.stopFollowingUser();
        const leaderPresences = this._getCollaboratorsQuery().get().filter((p2) => p2.userId === userId);
        if (!leaderPresences.length) {
          console.warn("User not found");
          return this;
        }
        const thisUserId = this.user.getId();
        if (!thisUserId) {
          console.warn("You should set the userId for the current instance before following a user");
        }
        if (leaderPresences.some((p2) => p2.followingUserId === thisUserId)) {
          return this;
        }
        const latestLeaderPresence = computed("latestLeaderPresence", () => {
          return this.getCollaborators().find((p2) => p2.userId === userId);
        });
        transact(() => {
          this.updateInstanceState({ followingUserId: userId }, { history: "ignore" });
          const dispose = react("update current page", () => {
            const leaderPresence = latestLeaderPresence.get();
            if (!leaderPresence) {
              this.stopFollowingUser();
              return;
            }
            if (leaderPresence.currentPageId !== this.getCurrentPageId() && this.getPage(leaderPresence.currentPageId)) {
              this.run(() => {
                this.store.put([
                  { ...this.getInstanceState(), currentPageId: leaderPresence.currentPageId }
                ]);
                this._isLockedOnFollowingUser.set(true);
              }, { history: "ignore" });
            }
          });
          const cancel = () => {
            dispose();
            this._isLockedOnFollowingUser.set(false);
            this.off("frame", moveTowardsUser);
            this.off("stop-following", cancel);
          };
          const moveTowardsUser = () => {
            const leaderPresence = latestLeaderPresence.get();
            if (!leaderPresence) {
              this.stopFollowingUser();
              return;
            }
            if (this._isLockedOnFollowingUser.get())
              return;
            const animationSpeed = this.user.getAnimationSpeed();
            if (animationSpeed === 0) {
              this._isLockedOnFollowingUser.set(true);
              return;
            }
            const targetViewport = this.getViewportPageBoundsForFollowing();
            if (!targetViewport) {
              this.stopFollowingUser();
              return;
            }
            const currentViewport = this.getViewportPageBounds();
            const diffX = Math.abs(targetViewport.minX - currentViewport.minX) + Math.abs(targetViewport.maxX - currentViewport.maxX);
            const diffY = Math.abs(targetViewport.minY - currentViewport.minY) + Math.abs(targetViewport.maxY - currentViewport.maxY);
            if (diffX < this.options.followChaseViewportSnap && diffY < this.options.followChaseViewportSnap) {
              this._isLockedOnFollowingUser.set(true);
              return;
            }
            const t3 = clamp(animationSpeed * 0.5, 0.1, 0.8);
            const nextViewport = new Box(lerp(currentViewport.minX, targetViewport.minX, t3), lerp(currentViewport.minY, targetViewport.minY, t3), lerp(currentViewport.width, targetViewport.width, t3), lerp(currentViewport.height, targetViewport.height, t3));
            const nextCamera = new Vec(-nextViewport.x, -nextViewport.y, this.getViewportScreenBounds().width / nextViewport.width);
            this.stopCameraAnimation();
            this._setCamera(nextCamera);
          };
          this.once("stop-following", cancel);
          this.addListener("frame", moveTowardsUser);
          moveTowardsUser();
        });
        return this;
      }
      stopFollowingUser() {
        this.run(() => {
          this.store.put([this.getCamera()]);
          this._isLockedOnFollowingUser.set(false);
          this.updateInstanceState({ followingUserId: null });
          this.emit("stop-following");
        }, { history: "ignore" });
        return this;
      }
      getUnorderedRenderingShapes(useEditorState) {
        const renderingShapes = [];
        let nextIndex = this.options.maxShapesPerPage * 2;
        let nextBackgroundIndex = this.options.maxShapesPerPage;
        const erasingShapeIds = this.getErasingShapeIds();
        const addShapeById = (id, opacity, isAncestorErasing) => {
          const shape = this.getShape(id);
          if (!shape)
            return;
          opacity *= shape.opacity;
          let isShapeErasing = false;
          const util = this.getShapeUtil(shape);
          if (useEditorState) {
            isShapeErasing = !isAncestorErasing && erasingShapeIds.includes(id);
            if (isShapeErasing) {
              opacity *= 0.32;
            }
          }
          renderingShapes.push({
            id,
            shape,
            util,
            index: nextIndex,
            backgroundIndex: nextBackgroundIndex,
            opacity
          });
          nextIndex += 1;
          nextBackgroundIndex += 1;
          const childIds = this.getSortedChildIdsForParent(id);
          if (!childIds.length)
            return;
          let backgroundIndexToRestore = null;
          if (util.providesBackgroundForChildren(shape)) {
            backgroundIndexToRestore = nextBackgroundIndex;
            nextBackgroundIndex = nextIndex;
            nextIndex += this.options.maxShapesPerPage;
          }
          for (const childId of childIds) {
            addShapeById(childId, opacity, isAncestorErasing || isShapeErasing);
          }
          if (backgroundIndexToRestore !== null) {
            nextBackgroundIndex = backgroundIndexToRestore;
          }
        };
        const pages = useEditorState ? [this.getCurrentPage()] : this.getPages();
        for (const page of pages) {
          for (const childId of this.getSortedChildIdsForParent(page.id)) {
            addShapeById(childId, 1, false);
          }
        }
        return renderingShapes;
      }
      getCameraState() {
        return this._cameraState.get();
      }
      getRenderingShapes() {
        const renderingShapes = this.getUnorderedRenderingShapes(true);
        return renderingShapes.sort(sortById);
      }
      _getAllPagesQuery() {
        return this.store.query.records("page");
      }
      getPages() {
        return this._getAllPagesQuery().get().sort(sortByIndex);
      }
      getCurrentPage() {
        return this.getPage(this.getCurrentPageId());
      }
      getCurrentPageId() {
        return this.getInstanceState().currentPageId;
      }
      getPage(page) {
        return this.store.get(typeof page === "string" ? page : page.id);
      }
      getCurrentPageShapeIds() {
        return this._currentPageShapeIds.get();
      }
      getCurrentPageShapeIdsSorted() {
        return Array.from(this.getCurrentPageShapeIds()).sort();
      }
      getPageShapeIds(page) {
        const pageId = typeof page === "string" ? page : page.id;
        const result = this.store.query.exec("shape", { parentId: { eq: pageId } });
        return this.getShapeAndDescendantIds(result.map((s2) => s2.id));
      }
      setCurrentPage(page) {
        const pageId = typeof page === "string" ? page : page.id;
        if (!this.store.has(pageId)) {
          console.error("Tried to set the current page id to a page that doesn't exist.");
          return this;
        }
        this.stopFollowingUser();
        this.complete();
        return this.run(() => {
          this.store.put([{ ...this.getInstanceState(), currentPageId: pageId }]);
        }, { history: "record-preserveRedoStack" });
      }
      updatePage(partial) {
        if (this.getInstanceState().isReadonly)
          return this;
        const prev = this.getPage(partial.id);
        if (!prev)
          return this;
        return this.run(() => this.store.update(partial.id, (page) => ({ ...page, ...partial })));
      }
      createPage(page) {
        this.run(() => {
          if (this.getInstanceState().isReadonly)
            return;
          if (this.getPages().length >= this.options.maxPages)
            return;
          const pages = this.getPages();
          const name = getIncrementedName(page.name ?? "Page 1", pages.map((p2) => p2.name));
          let index3 = page.index;
          if (!index3 || pages.some((p2) => p2.index === index3)) {
            index3 = getIndexAbove(pages[pages.length - 1].index);
          }
          const newPage = PageRecordType.create({
            meta: {},
            ...page,
            name,
            index: index3
          });
          this.store.put([newPage]);
        });
        return this;
      }
      deletePage(page) {
        const id = typeof page === "string" ? page : page.id;
        this.run(() => {
          if (this.getInstanceState().isReadonly)
            return;
          const pages = this.getPages();
          if (pages.length === 1)
            return;
          const deletedPage = this.getPage(id);
          if (!deletedPage)
            return;
          if (id === this.getCurrentPageId()) {
            const index3 = pages.findIndex((page2) => page2.id === id);
            const next = pages[index3 - 1] ?? pages[index3 + 1];
            this.setCurrentPage(next.id);
          }
          this.store.remove([deletedPage.id]);
        });
        return this;
      }
      duplicatePage(page, createId = PageRecordType.createId()) {
        if (this.getPages().length >= this.options.maxPages)
          return this;
        const id = typeof page === "string" ? page : page.id;
        const freshPage = this.getPage(id);
        if (!freshPage)
          return this;
        const prevCamera = { ...this.getCamera() };
        const content = this.getContentFromCurrentPage(this.getSortedChildIdsForParent(freshPage.id));
        this.run(() => {
          const pages = this.getPages();
          const index3 = getIndexBetween(freshPage.index, pages[pages.indexOf(freshPage) + 1]?.index);
          this.createPage({ name: freshPage.name + " Copy", id: createId, index: index3 });
          this.setCurrentPage(createId);
          this.setCamera(prevCamera);
          if (content) {
            return this.putContentOntoCurrentPage(content);
          }
        });
        return this;
      }
      renamePage(page, name) {
        const id = typeof page === "string" ? page : page.id;
        if (this.getInstanceState().isReadonly)
          return this;
        this.updatePage({ id, name });
        return this;
      }
      _getAllAssetsQuery() {
        return this.store.query.records("asset");
      }
      getAssets() {
        return this._getAllAssetsQuery().get();
      }
      createAssets(assets) {
        if (this.getInstanceState().isReadonly)
          return this;
        if (assets.length <= 0)
          return this;
        this.run(() => this.store.put(assets), { history: "ignore" });
        return this;
      }
      updateAssets(assets) {
        if (this.getInstanceState().isReadonly)
          return this;
        if (assets.length <= 0)
          return this;
        this.run(() => {
          this.store.put(assets.map((partial) => ({
            ...this.store.get(partial.id),
            ...partial
          })));
        }, { history: "ignore" });
        return this;
      }
      deleteAssets(assets) {
        if (this.getInstanceState().isReadonly)
          return this;
        const ids = typeof assets[0] === "string" ? assets : assets.map((a2) => a2.id);
        if (ids.length <= 0)
          return this;
        this.run(() => this.store.remove(ids), { history: "ignore" });
        return this;
      }
      getAsset(asset) {
        return this.store.get(typeof asset === "string" ? asset : asset.id);
      }
      async resolveAssetUrl(assetId, context) {
        if (!assetId)
          return null;
        const asset = this.getAsset(assetId);
        if (!asset)
          return null;
        const { screenScale = 1, shouldResolveToOriginal = false } = context;
        const zoomStepFunction = (zoom) => Math.pow(2, Math.ceil(Math.log2(zoom)));
        const steppedScreenScale = Math.max(0.125, zoomStepFunction(screenScale));
        const networkEffectiveType = "connection" in navigator ? navigator.connection.effectiveType : null;
        const dpr = this.getInstanceState().devicePixelRatio;
        return await this.store.props.assets.resolve(asset, {
          screenScale: screenScale || 1,
          steppedScreenScale,
          dpr,
          networkEffectiveType,
          shouldResolveToOriginal
        });
      }
      async uploadAsset(asset, file) {
        return await this.store.props.assets.upload(asset, file);
      }
      _getShapeGeometryCache() {
        return this.store.createComputedCache("bounds", (shape) => this.getShapeUtil(shape).getGeometry(shape), (a2, b2) => a2.props === b2.props);
      }
      getShapeGeometry(shape) {
        return this._getShapeGeometryCache().get(typeof shape === "string" ? shape : shape.id);
      }
      _getShapeHandlesCache() {
        return this.store.createComputedCache("handles", (shape) => {
          return this.getShapeUtil(shape).getHandles?.(shape);
        });
      }
      getShapeHandles(shape) {
        return this._getShapeHandlesCache().get(typeof shape === "string" ? shape : shape.id);
      }
      getShapeLocalTransform(shape) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        if (!freshShape)
          throw Error("Editor.getTransform: shape not found");
        return Mat.Identity().translate(freshShape.x, freshShape.y).rotate(freshShape.rotation);
      }
      _getShapePageTransformCache() {
        return this.store.createComputedCache("pageTransformCache", (shape) => {
          if (isPageId(shape.parentId)) {
            return this.getShapeLocalTransform(shape);
          }
          const parentTransform = this._getShapePageTransformCache().get(shape.parentId) ?? Mat.Identity();
          return Mat.Compose(parentTransform, this.getShapeLocalTransform(shape));
        });
      }
      getShapeParentTransform(shape) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        if (!freshShape || isPageId(freshShape.parentId))
          return Mat.Identity();
        return this._getShapePageTransformCache().get(freshShape.parentId) ?? Mat.Identity();
      }
      getShapePageTransform(shape) {
        const id = typeof shape === "string" ? shape : shape.id;
        return this._getShapePageTransformCache().get(id) ?? Mat.Identity();
      }
      _getShapePageBoundsCache() {
        return this.store.createComputedCache("pageBoundsCache", (shape) => {
          const pageTransform = this._getShapePageTransformCache().get(shape.id);
          if (!pageTransform)
            return new Box();
          const result = Box.FromPoints(Mat.applyToPoints(pageTransform, this.getShapeGeometry(shape).vertices));
          return result;
        });
      }
      getShapePageBounds(shape) {
        return this._getShapePageBoundsCache().get(typeof shape === "string" ? shape : shape.id);
      }
      _getShapeClipPathCache() {
        return this.store.createComputedCache("clipPathCache", (shape) => {
          const pageMask = this._getShapeMaskCache().get(shape.id);
          if (!pageMask)
            return void 0;
          if (pageMask.length === 0) {
            return `polygon(0px 0px, 0px 0px, 0px 0px)`;
          }
          const pageTransform = this._getShapePageTransformCache().get(shape.id);
          if (!pageTransform)
            return void 0;
          const localMask = Mat.applyToPoints(Mat.Inverse(pageTransform), pageMask);
          return `polygon(${localMask.map((p2) => `${p2.x}px ${p2.y}px`).join(",")})`;
        });
      }
      getShapeClipPath(shape) {
        return this._getShapeClipPathCache().get(typeof shape === "string" ? shape : shape.id);
      }
      _getShapeMaskCache() {
        return this.store.createComputedCache("pageMaskCache", (shape) => {
          if (isPageId(shape.parentId))
            return void 0;
          const frameAncestors = this.getShapeAncestors(shape.id).filter((shape2) => this.isShapeOfType(shape2, "frame"));
          if (frameAncestors.length === 0)
            return void 0;
          const pageMask = frameAncestors.map((s2) => this._getShapePageTransformCache().get(s2.id).applyToPoints(this.getShapeGeometry(s2).vertices)).reduce((acc, b2) => {
            if (!(b2 && acc))
              return void 0;
            const intersection = intersectPolygonPolygon(acc, b2);
            if (intersection) {
              return intersection.map(Vec.Cast);
            }
            return [];
          });
          return pageMask;
        });
      }
      getShapeMask(shape) {
        return this._getShapeMaskCache().get(typeof shape === "string" ? shape : shape.id);
      }
      getShapeMaskedPageBounds(shape) {
        if (typeof shape !== "string")
          shape = shape.id;
        return this._getShapeMaskedPageBoundsCache().get(shape);
      }
      _getShapeMaskedPageBoundsCache() {
        return this.store.createComputedCache("shapeMaskedPageBoundsCache", (shape) => {
          const pageBounds = this._getShapePageBoundsCache().get(shape.id);
          if (!pageBounds)
            return;
          const pageMask = this._getShapeMaskCache().get(shape.id);
          if (pageMask) {
            if (pageMask.length === 0)
              return void 0;
            const { corners } = pageBounds;
            if (corners.every((p2, i2) => p2 && Vec.Equals(p2, pageMask[i2])))
              return pageBounds.clone();
            const intersection = intersectPolygonPolygon(pageMask, corners);
            if (!intersection)
              return;
            return Box.FromPoints(intersection);
          }
          return pageBounds;
        });
      }
      getShapeAncestors(shape, acc = []) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        if (!freshShape)
          return acc;
        const parentId = freshShape.parentId;
        if (isPageId(parentId)) {
          acc.reverse();
          return acc;
        }
        const parent = this.store.get(parentId);
        if (!parent)
          return acc;
        acc.push(parent);
        return this.getShapeAncestors(parent, acc);
      }
      findShapeAncestor(shape, predicate) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        if (!freshShape)
          return;
        const parentId = freshShape.parentId;
        if (isPageId(parentId))
          return;
        const parent = this.getShape(parentId);
        if (!parent)
          return;
        return predicate(parent) ? parent : this.findShapeAncestor(parent, predicate);
      }
      hasAncestor(shape, ancestorId) {
        const id = typeof shape === "string" ? shape : shape?.id;
        const freshShape = id && this.getShape(id);
        if (!freshShape)
          return false;
        if (freshShape.parentId === ancestorId)
          return true;
        return this.hasAncestor(this.getShapeParent(freshShape), ancestorId);
      }
      findCommonAncestor(shapes, predicate) {
        if (shapes.length === 0) {
          return;
        }
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const freshShapes = compact(ids.map((id) => this.getShape(id)));
        if (freshShapes.length === 1) {
          const parentId = freshShapes[0].parentId;
          if (isPageId(parentId)) {
            return;
          }
          return predicate ? this.findShapeAncestor(freshShapes[0], predicate)?.id : parentId;
        }
        const [nodeA, ...others] = freshShapes;
        let ancestor = this.getShapeParent(nodeA);
        while (ancestor) {
          if (predicate && !predicate(ancestor)) {
            ancestor = this.getShapeParent(ancestor);
            continue;
          }
          if (others.every((shape) => this.hasAncestor(shape, ancestor.id))) {
            return ancestor.id;
          }
          ancestor = this.getShapeParent(ancestor);
        }
        return void 0;
      }
      isShapeOrAncestorLocked(arg) {
        const shape = typeof arg === "string" ? this.getShape(arg) : arg;
        if (shape === void 0)
          return false;
        if (shape.isLocked)
          return true;
        return this.isShapeOrAncestorLocked(this.getShapeParent(shape));
      }
      _notVisibleShapes() {
        return notVisibleShapes(this);
      }
      getCulledShapes() {
        const notVisibleShapes2 = this._notVisibleShapes().get();
        const selectedShapeIds = this.getSelectedShapeIds();
        const editingId = this.getEditingShapeId();
        const culledShapes = new Set(notVisibleShapes2);
        if (editingId) {
          culledShapes.delete(editingId);
        }
        selectedShapeIds.forEach((id) => {
          culledShapes.delete(id);
        });
        return culledShapes;
      }
      getCurrentPageBounds() {
        let commonBounds;
        this.getCurrentPageShapeIdsSorted().forEach((shapeId) => {
          const bounds = this.getShapeMaskedPageBounds(shapeId);
          if (!bounds)
            return;
          if (!commonBounds) {
            commonBounds = bounds.clone();
          } else {
            commonBounds = commonBounds.expand(bounds);
          }
        });
        return commonBounds;
      }
      getSelectedShapeAtPoint(point) {
        const selectedShapeIds = this.getSelectedShapeIds();
        return this.getCurrentPageShapesSorted().filter((shape) => shape.type !== "group" && selectedShapeIds.includes(shape.id)).reverse().find((shape) => this.isPointInShape(shape, point, { hitInside: true, margin: 0 }));
      }
      getShapeAtPoint(point, opts = {}) {
        const zoomLevel = this.getZoomLevel();
        const viewportPageBounds = this.getViewportPageBounds();
        const {
          filter: filter2,
          margin = 0,
          hitLocked = false,
          hitLabels = false,
          hitInside = false,
          hitFrameInside = false
        } = opts;
        let inHollowSmallestArea = Infinity;
        let inHollowSmallestAreaHit = null;
        let inMarginClosestToEdgeDistance = Infinity;
        let inMarginClosestToEdgeHit = null;
        const shapesToCheck = (opts.renderingOnly ? this.getCurrentPageRenderingShapesSorted() : this.getCurrentPageShapesSorted()).filter((shape) => {
          if (shape.isLocked && !hitLocked || this.isShapeOfType(shape, "group"))
            return false;
          const pageMask = this.getShapeMask(shape);
          if (pageMask && !pointInPolygon(point, pageMask))
            return false;
          if (filter2)
            return filter2(shape);
          return true;
        });
        for (let i2 = shapesToCheck.length - 1; i2 >= 0; i2--) {
          const shape = shapesToCheck[i2];
          const geometry = this.getShapeGeometry(shape);
          const isGroup = geometry instanceof Group2d;
          const pointInShapeSpace = this.getPointInShapeSpace(shape, point);
          if (this.isShapeOfType(shape, "arrow") || this.isShapeOfType(shape, "geo") && shape.props.fill === "none") {
            if (shape.props.text.trim()) {
              for (const childGeometry of geometry.children) {
                if (childGeometry.isLabel && childGeometry.isPointInBounds(pointInShapeSpace)) {
                  return shape;
                }
              }
            }
          }
          if (this.isShapeOfType(shape, "frame")) {
            const distance2 = geometry.distanceToPoint(pointInShapeSpace, hitInside);
            if (Math.abs(distance2) <= margin) {
              return inMarginClosestToEdgeHit || shape;
            }
            if (geometry.hitTestPoint(pointInShapeSpace, 0, true)) {
              return inMarginClosestToEdgeHit || inHollowSmallestAreaHit || (hitFrameInside ? shape : void 0);
            }
            continue;
          }
          let distance;
          if (isGroup) {
            let minDistance = Infinity;
            for (const childGeometry of geometry.children) {
              if (childGeometry.isLabel && !hitLabels)
                continue;
              const tDistance = childGeometry.distanceToPoint(pointInShapeSpace, hitInside);
              if (tDistance < minDistance) {
                minDistance = tDistance;
              }
            }
            distance = minDistance;
          } else {
            if (margin === 0 && (geometry.bounds.w < 1 || geometry.bounds.h < 1)) {
              distance = geometry.distanceToPoint(pointInShapeSpace, hitInside);
            } else {
              if (geometry.bounds.containsPoint(pointInShapeSpace, margin)) {
                distance = geometry.distanceToPoint(pointInShapeSpace, hitInside);
              } else {
                distance = Infinity;
              }
            }
          }
          if (geometry.isClosed) {
            if (distance <= margin) {
              if (geometry.isFilled || isGroup && geometry.children[0].isFilled) {
                return inMarginClosestToEdgeHit || shape;
              } else {
                if (this.getShapePageBounds(shape).contains(viewportPageBounds))
                  continue;
                if (Math.abs(distance) < margin) {
                  if (Math.abs(distance) < inMarginClosestToEdgeDistance) {
                    inMarginClosestToEdgeDistance = Math.abs(distance);
                    inMarginClosestToEdgeHit = shape;
                  }
                } else if (!inMarginClosestToEdgeHit) {
                  const { area } = geometry;
                  if (area < inHollowSmallestArea) {
                    inHollowSmallestArea = area;
                    inHollowSmallestAreaHit = shape;
                  }
                }
              }
            }
          } else {
            if (distance < this.options.hitTestMargin / zoomLevel) {
              return shape;
            }
          }
        }
        return inMarginClosestToEdgeHit || inHollowSmallestAreaHit || void 0;
      }
      getShapesAtPoint(point, opts = {}) {
        return this.getCurrentPageShapes().filter((shape) => this.isPointInShape(shape, point, opts));
      }
      isPointInShape(shape, point, opts = {}) {
        const { hitInside = false, margin = 0 } = opts;
        const id = typeof shape === "string" ? shape : shape.id;
        const pageMask = this.getShapeMask(id);
        if (pageMask && !pointInPolygon(point, pageMask))
          return false;
        return this.getShapeGeometry(id).hitTestPoint(this.getPointInShapeSpace(shape, point), margin, hitInside);
      }
      getPointInShapeSpace(shape, point) {
        const id = typeof shape === "string" ? shape : shape.id;
        return this._getShapePageTransformCache().get(id).clone().invert().applyToPoint(point);
      }
      getPointInParentSpace(shape, point) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        if (!freshShape)
          return new Vec(0, 0);
        if (isPageId(freshShape.parentId))
          return Vec.From(point);
        const parentTransform = this.getShapePageTransform(freshShape.parentId);
        if (!parentTransform)
          return Vec.From(point);
        return parentTransform.clone().invert().applyToPoint(point);
      }
      getCurrentPageShapes() {
        return Array.from(this.getCurrentPageShapeIds(), (id) => this.store.get(id));
      }
      getCurrentPageShapesSorted() {
        const result = [];
        const topLevelShapes = this.getSortedChildIdsForParent(this.getCurrentPageId());
        for (let i2 = 0, n2 = topLevelShapes.length; i2 < n2; i2++) {
          pushShapeWithDescendants(this, topLevelShapes[i2], result);
        }
        return result;
      }
      getCurrentPageRenderingShapesSorted() {
        const culledShapes = this.getCulledShapes();
        return this.getCurrentPageShapesSorted().filter(({ id }) => !culledShapes.has(id));
      }
      isShapeOfType(arg, type) {
        const shape = typeof arg === "string" ? this.getShape(arg) : arg;
        if (!shape)
          return false;
        return shape.type === type;
      }
      getShape(shape) {
        const id = typeof shape === "string" ? shape : shape.id;
        if (!isShapeId(id))
          return void 0;
        return this.store.get(id);
      }
      getShapeParent(shape) {
        const id = typeof shape === "string" ? shape : shape?.id;
        if (!id)
          return void 0;
        const freshShape = this.getShape(id);
        if (freshShape === void 0 || !isShapeId(freshShape.parentId))
          return void 0;
        return this.store.get(freshShape.parentId);
      }
      getShapeNearestSibling(siblingShape, targetShape) {
        if (!targetShape) {
          return void 0;
        }
        if (targetShape.parentId === siblingShape.parentId) {
          return targetShape;
        }
        const ancestor = this.findShapeAncestor(targetShape, (ancestor2) => ancestor2.parentId === siblingShape.parentId);
        return ancestor;
      }
      isShapeInPage(shape, pageId = this.getCurrentPageId()) {
        const id = typeof shape === "string" ? shape : shape.id;
        const shapeToCheck = this.getShape(id);
        if (!shapeToCheck)
          return false;
        let shapeIsInPage = false;
        if (shapeToCheck.parentId === pageId) {
          shapeIsInPage = true;
        } else {
          let parent = this.getShape(shapeToCheck.parentId);
          isInPageSearch:
            while (parent) {
              if (parent.parentId === pageId) {
                shapeIsInPage = true;
                break isInPageSearch;
              }
              parent = this.getShape(parent.parentId);
            }
        }
        return shapeIsInPage;
      }
      getAncestorPageId(shape) {
        const id = typeof shape === "string" ? shape : shape?.id;
        const _shape = id && this.getShape(id);
        if (!_shape)
          return void 0;
        if (isPageId(_shape.parentId)) {
          return _shape.parentId;
        } else {
          return this.getAncestorPageId(this.getShape(_shape.parentId));
        }
      }
      reparentShapes(shapes, parentId, insertIndex) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (ids.length === 0)
          return this;
        const changes = [];
        const parentTransform = isPageId(parentId) ? Mat.Identity() : this.getShapePageTransform(parentId);
        const parentPageRotation = parentTransform.rotation();
        let indices = [];
        const sibs = compact(this.getSortedChildIdsForParent(parentId).map((id) => this.getShape(id)));
        if (insertIndex) {
          const sibWithInsertIndex = sibs.find((s2) => s2.index === insertIndex);
          if (sibWithInsertIndex) {
            const sibAbove = sibs[sibs.indexOf(sibWithInsertIndex) + 1];
            if (sibAbove) {
              indices = getIndicesBetween(insertIndex, sibAbove.index, ids.length);
            } else {
              indices = getIndicesAbove(insertIndex, ids.length);
            }
          } else {
            const sibAbove = sibs.sort(sortByIndex).find((s2) => s2.index > insertIndex);
            if (sibAbove) {
              indices = getIndicesBetween(insertIndex, sibAbove.index, ids.length);
            } else {
              indices = getIndicesAbove(insertIndex, ids.length);
            }
          }
        } else {
          const sib = sibs.length && sibs[sibs.length - 1];
          indices = sib ? getIndicesAbove(sib.index, ids.length) : getIndices(ids.length);
        }
        const invertedParentTransform = parentTransform.clone().invert();
        const shapesToReparent = compact(ids.map((id) => this.getShape(id)));
        this.run(() => {
          for (let i2 = 0; i2 < shapesToReparent.length; i2++) {
            const shape = shapesToReparent[i2];
            const pageTransform = this.getShapePageTransform(shape);
            if (!pageTransform)
              continue;
            const pagePoint = pageTransform.point();
            if (!pagePoint)
              continue;
            const newPoint = invertedParentTransform.applyToPoint(pagePoint);
            const newRotation = pageTransform.rotation() - parentPageRotation;
            changes.push({
              id: shape.id,
              type: shape.type,
              parentId,
              x: newPoint.x,
              y: newPoint.y,
              rotation: newRotation,
              index: indices[i2]
            });
          }
          this.updateShapes(changes);
        }, { ignoreShapeLock: true });
        return this;
      }
      getHighestIndexForParent(parent) {
        const parentId = typeof parent === "string" ? parent : parent.id;
        const children = this._parentIdsToChildIds.get()[parentId];
        if (!children || children.length === 0) {
          return "a1";
        }
        const shape = this.getShape(children[children.length - 1]);
        return getIndexAbove(shape.index);
      }
      getSortedChildIdsForParent(parent) {
        const parentId = typeof parent === "string" ? parent : parent.id;
        const ids = this._parentIdsToChildIds.get()[parentId];
        if (!ids)
          return EMPTY_ARRAY;
        return ids;
      }
      visitDescendants(parent, visitor) {
        const parentId = typeof parent === "string" ? parent : parent.id;
        const children = this.getSortedChildIdsForParent(parentId);
        for (const id of children) {
          if (visitor(id) === false)
            continue;
          this.visitDescendants(id, visitor);
        }
        return this;
      }
      getShapeAndDescendantIds(ids) {
        const shapeIds = /* @__PURE__ */ new Set();
        for (const shape of ids.map((id) => this.getShape(id)).sort(sortByIndex)) {
          shapeIds.add(shape.id);
          this.visitDescendants(shape, (descendantId) => {
            shapeIds.add(descendantId);
          });
        }
        return shapeIds;
      }
      getDroppingOverShape(point, droppingShapes = []) {
        const currentPageShapesSorted = this.getCurrentPageShapesSorted();
        for (let i2 = currentPageShapesSorted.length - 1; i2 >= 0; i2--) {
          const shape = currentPageShapesSorted[i2];
          if (this.getSelectedShapeIds().includes(shape.id) || !this.getShapeUtil(shape).canDropShapes(shape, droppingShapes) || droppingShapes.find((s2) => s2.id === shape.id || this.hasAncestor(shape, s2.id))) {
            continue;
          }
          const maskedPageBounds = this.getShapeMaskedPageBounds(shape.id);
          if (maskedPageBounds && maskedPageBounds.containsPoint(point) && this.getShapeGeometry(shape).hitTestPoint(this.getPointInShapeSpace(shape, point), 0, true)) {
            return shape;
          }
        }
      }
      getOutermostSelectableShape(shape, filter2) {
        const id = typeof shape === "string" ? shape : shape.id;
        const freshShape = this.getShape(id);
        let match = freshShape;
        let node = freshShape;
        const focusedGroup = this.getFocusedGroup();
        while (node) {
          if (this.isShapeOfType(node, "group") && focusedGroup?.id !== node.id && !this.hasAncestor(focusedGroup, node.id) && (filter2?.(node) ?? true)) {
            match = node;
          } else if (focusedGroup?.id === node.id) {
            break;
          }
          node = this.getShapeParent(node);
        }
        return match;
      }
      _getBindingsIndexCache() {
        const index3 = bindingsIndex(this);
        return this.store.createComputedCache("bindingsIndex", (shape) => {
          return index3.get().get(shape.id);
        });
      }
      getBinding(id) {
        return this.store.get(id);
      }
      getBindingsFromShape(shape, type) {
        const id = typeof shape === "string" ? shape : shape.id;
        return this.getBindingsInvolvingShape(id).filter((b2) => b2.fromId === id && b2.type === type);
      }
      getBindingsToShape(shape, type) {
        const id = typeof shape === "string" ? shape : shape.id;
        return this.getBindingsInvolvingShape(id).filter((b2) => b2.toId === id && b2.type === type);
      }
      getBindingsInvolvingShape(shape, type) {
        const id = typeof shape === "string" ? shape : shape.id;
        const result = this._getBindingsIndexCache().get(id) ?? EMPTY_ARRAY;
        if (!type)
          return result;
        return result.filter((b2) => b2.type === type);
      }
      createBindings(partials) {
        const bindings = [];
        for (const partial of partials) {
          const fromShape = this.getShape(partial.fromId);
          const toShape = this.getShape(partial.toId);
          if (!fromShape || !toShape)
            continue;
          if (!this.canBindShapes({ fromShape, toShape, binding: partial }))
            continue;
          const util = this.getBindingUtil(partial.type);
          const defaultProps2 = util.getDefaultProps();
          const binding = this.store.schema.types.binding.create({
            ...partial,
            id: partial.id ?? createBindingId(),
            props: {
              ...defaultProps2,
              ...partial.props
            }
          });
          bindings.push(binding);
        }
        this.store.put(bindings);
        return this;
      }
      createBinding(partial) {
        return this.createBindings([partial]);
      }
      updateBindings(partials) {
        const updated = [];
        for (const partial of partials) {
          if (!partial)
            continue;
          const current = this.getBinding(partial.id);
          if (!current)
            continue;
          const updatedBinding = applyPartialToRecordWithProps(current, partial);
          if (updatedBinding === current)
            continue;
          const fromShape = this.getShape(updatedBinding.fromId);
          const toShape = this.getShape(updatedBinding.toId);
          if (!fromShape || !toShape)
            continue;
          if (!this.canBindShapes({ fromShape, toShape, binding: updatedBinding }))
            continue;
          updated.push(updatedBinding);
        }
        this.store.put(updated);
        return this;
      }
      updateBinding(partial) {
        return this.updateBindings([partial]);
      }
      deleteBindings(bindings, { isolateShapes = false } = {}) {
        const ids = bindings.map((binding) => typeof binding === "string" ? binding : binding.id);
        if (isolateShapes) {
          this.store.atomic(() => {
            for (const id of ids) {
              const binding = this.getBinding(id);
              if (!binding)
                continue;
              const util = this.getBindingUtil(binding);
              util.onBeforeIsolateFromShape?.({ binding, removedShape: this.getShape(binding.toId) });
              util.onBeforeIsolateToShape?.({ binding, removedShape: this.getShape(binding.fromId) });
              this.store.remove([id]);
            }
          });
        } else {
          this.store.remove(ids);
        }
        return this;
      }
      deleteBinding(binding, opts) {
        return this.deleteBindings([binding], opts);
      }
      canBindShapes({
        fromShape,
        toShape,
        binding
      }) {
        const fromShapeType = typeof fromShape === "string" ? fromShape : fromShape.type;
        const toShapeType = typeof toShape === "string" ? toShape : toShape.type;
        const bindingType = typeof binding === "string" ? binding : binding.type;
        const canBindOpts = { fromShapeType, toShapeType, bindingType };
        if (fromShapeType === toShapeType) {
          return this.getShapeUtil(fromShapeType).canBind(canBindOpts);
        }
        return this.getShapeUtil(fromShapeType).canBind(canBindOpts) && this.getShapeUtil(toShapeType).canBind(canBindOpts);
      }
      rotateShapesBy(shapes, delta) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (ids.length <= 0)
          return this;
        const snapshot = getRotationSnapshot({ editor: this });
        if (!snapshot)
          return this;
        applyRotationToSnapshotShapes({ delta, snapshot, editor: this, stage: "one-off" });
        return this;
      }
      getChangesToTranslateShape(initialShape, newShapeCoords) {
        let workingShape = initialShape;
        const util = this.getShapeUtil(initialShape);
        workingShape = applyPartialToRecordWithProps(workingShape, util.onTranslateStart?.(workingShape) ?? void 0);
        workingShape = applyPartialToRecordWithProps(workingShape, {
          id: initialShape.id,
          type: initialShape.type,
          x: newShapeCoords.x,
          y: newShapeCoords.y
        });
        workingShape = applyPartialToRecordWithProps(workingShape, util.onTranslate?.(initialShape, workingShape) ?? void 0);
        workingShape = applyPartialToRecordWithProps(workingShape, util.onTranslateEnd?.(initialShape, workingShape) ?? void 0);
        return workingShape;
      }
      nudgeShapes(shapes, offset5) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (ids.length <= 0)
          return this;
        const changes = [];
        for (const id of ids) {
          const shape = this.getShape(id);
          const localDelta = Vec.From(offset5);
          const parentTransform = this.getShapeParentTransform(shape);
          if (parentTransform)
            localDelta.rot(-parentTransform.rotation());
          changes.push(this.getChangesToTranslateShape(shape, localDelta.add(shape)));
        }
        this.updateShapes(changes);
        return this;
      }
      duplicateShapes(shapes, offset5) {
        this.run(() => {
          const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
          if (ids.length <= 0)
            return this;
          const initialIds = new Set(ids);
          const shapeIdSet = this.getShapeAndDescendantIds(ids);
          const orderedShapeIds = [...shapeIdSet].reverse();
          const shapeIds = /* @__PURE__ */ new Map();
          for (const shapeId of shapeIdSet) {
            shapeIds.set(shapeId, createShapeId());
          }
          const { shapesToCreate, bindingsToCreate } = withIsolatedShapes(this, shapeIdSet, (bindingIdsToMaintain) => {
            const bindingsToCreate2 = [];
            for (const originalId of bindingIdsToMaintain) {
              const originalBinding = this.getBinding(originalId);
              if (!originalBinding)
                continue;
              const duplicatedId = createBindingId();
              bindingsToCreate2.push({
                ...originalBinding,
                id: duplicatedId,
                fromId: assertExists(shapeIds.get(originalBinding.fromId)),
                toId: assertExists(shapeIds.get(originalBinding.toId))
              });
            }
            const shapesToCreate2 = [];
            for (const originalId of orderedShapeIds) {
              const duplicatedId = assertExists(shapeIds.get(originalId));
              const originalShape = this.getShape(originalId);
              if (!originalShape)
                continue;
              let ox = 0;
              let oy = 0;
              if (offset5 && initialIds.has(originalId)) {
                const parentTransform = this.getShapeParentTransform(originalShape);
                const vec = new Vec(offset5.x, offset5.y).rot(-parentTransform.rotation());
                ox = vec.x;
                oy = vec.y;
              }
              const parentId = originalShape.parentId;
              const siblings = this.getSortedChildIdsForParent(parentId);
              const currentIndex = siblings.indexOf(originalShape.id);
              const siblingAboveId = siblings[currentIndex + 1];
              const siblingAbove = siblingAboveId ? this.getShape(siblingAboveId) : null;
              const index3 = siblingAbove ? getIndexBetween(originalShape.index, siblingAbove.index) : getIndexAbove(originalShape.index);
              shapesToCreate2.push({
                ...originalShape,
                id: duplicatedId,
                x: originalShape.x + ox,
                y: originalShape.y + oy,
                index: index3,
                parentId: shapeIds.get(originalShape.parentId) ?? originalShape.parentId
              });
            }
            return { shapesToCreate: shapesToCreate2, bindingsToCreate: bindingsToCreate2 };
          });
          const maxShapesReached = shapesToCreate.length + this.getCurrentPageShapeIds().size > this.options.maxShapesPerPage;
          if (maxShapesReached) {
            alertMaxShapes(this);
            return;
          }
          this.createShapes(shapesToCreate);
          this.createBindings(bindingsToCreate);
          this.setSelectedShapes(compact(ids.map((id) => shapeIds.get(id))));
          if (offset5 !== void 0) {
            const selectionPageBounds = this.getSelectionPageBounds();
            const viewportPageBounds = this.getViewportPageBounds();
            if (selectionPageBounds && !viewportPageBounds.contains(selectionPageBounds)) {
              this.centerOnPoint(selectionPageBounds.center, {
                animation: { duration: this.options.animationMediumMs }
              });
            }
          }
        });
        return this;
      }
      moveShapesToPage(shapes, pageId) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (ids.length === 0)
          return this;
        if (this.getInstanceState().isReadonly)
          return this;
        const currentPageId = this.getCurrentPageId();
        if (pageId === currentPageId)
          return this;
        if (!this.store.has(pageId))
          return this;
        const content = this.getContentFromCurrentPage(ids);
        if (!content)
          return this;
        if (this.getPageShapeIds(pageId).size + content.shapes.length > this.options.maxShapesPerPage) {
          alertMaxShapes(this, pageId);
          return this;
        }
        const fromPageZ = this.getCamera().z;
        this.run(() => {
          this.deleteShapes(ids);
          this.setCurrentPage(pageId);
          this.setFocusedGroup(null);
          this.selectNone();
          this.putContentOntoCurrentPage(content, {
            select: true,
            preserveIds: true,
            preservePosition: true
          });
          this.setCamera({ ...this.getCamera(), z: fromPageZ });
          this.centerOnPoint(this.getSelectionRotatedPageBounds().center);
        });
        return this;
      }
      toggleLock(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly || ids.length === 0)
          return this;
        let allLocked = true, allUnlocked = true;
        const shapesToToggle = [];
        for (const id of ids) {
          const shape = this.getShape(id);
          if (shape) {
            shapesToToggle.push(shape);
            if (shape.isLocked) {
              allUnlocked = false;
            } else {
              allLocked = false;
            }
          }
        }
        this.run(() => {
          if (allUnlocked) {
            this.updateShapes(shapesToToggle.map((shape) => ({ id: shape.id, type: shape.type, isLocked: true })));
            this.setSelectedShapes([]);
          } else if (allLocked) {
            this.updateShapes(shapesToToggle.map((shape) => ({ id: shape.id, type: shape.type, isLocked: false })));
          } else {
            this.updateShapes(shapesToToggle.map((shape) => ({ id: shape.id, type: shape.type, isLocked: true })));
          }
        });
        return this;
      }
      sendToBack(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const changes = getReorderingShapesChanges(this, "toBack", ids);
        if (changes)
          this.updateShapes(changes);
        return this;
      }
      sendBackward(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const changes = getReorderingShapesChanges(this, "backward", ids);
        if (changes)
          this.updateShapes(changes);
        return this;
      }
      bringForward(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const changes = getReorderingShapesChanges(this, "forward", ids);
        if (changes)
          this.updateShapes(changes);
        return this;
      }
      bringToFront(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const changes = getReorderingShapesChanges(this, "toFront", ids);
        if (changes)
          this.updateShapes(changes);
        return this;
      }
      flipShapes(shapes, operation) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        let shapesToFlip = compact(ids.map((id) => this.getShape(id)));
        if (!shapesToFlip.length)
          return this;
        shapesToFlip = compact(shapesToFlip.map((shape) => {
          if (this.isShapeOfType(shape, "group")) {
            return this.getSortedChildIdsForParent(shape.id).map((id) => this.getShape(id));
          }
          return shape;
        }).flat());
        const scaleOriginPage = Box.Common(compact(shapesToFlip.map((id) => this.getShapePageBounds(id)))).center;
        this.run(() => {
          for (const shape of shapesToFlip) {
            const bounds = this.getShapeGeometry(shape).bounds;
            const initialPageTransform = this.getShapePageTransform(shape.id);
            if (!initialPageTransform)
              continue;
            this.resizeShape(shape.id, { x: operation === "horizontal" ? -1 : 1, y: operation === "vertical" ? -1 : 1 }, {
              initialBounds: bounds,
              initialPageTransform,
              initialShape: shape,
              mode: "scale_shape",
              isAspectRatioLocked: this.getShapeUtil(shape).isAspectRatioLocked(shape),
              scaleOrigin: scaleOriginPage,
              scaleAxisRotation: 0
            });
          }
        });
        return this;
      }
      stackShapes(shapes, operation, gap) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        const shapesToStack = ids.map((id) => this.getShape(id)).filter((shape) => {
          if (!shape)
            return false;
          return this.getShapeUtil(shape).canBeLaidOut(shape);
        });
        const len = shapesToStack.length;
        if (gap === 0 && len < 3 || len < 2)
          return this;
        const pageBounds = Object.fromEntries(shapesToStack.map((shape) => [shape.id, this.getShapePageBounds(shape)]));
        let val;
        let min4;
        let max3;
        let dim;
        if (operation === "horizontal") {
          val = "x";
          min4 = "minX";
          max3 = "maxX";
          dim = "width";
        } else {
          val = "y";
          min4 = "minY";
          max3 = "maxY";
          dim = "height";
        }
        let shapeGap;
        if (gap === 0) {
          const gaps = [];
          shapesToStack.sort((a2, b2) => pageBounds[a2.id][min4] - pageBounds[b2.id][min4]);
          for (let i2 = 0; i2 < len - 1; i2++) {
            const shape = shapesToStack[i2];
            const nextShape = shapesToStack[i2 + 1];
            const bounds = pageBounds[shape.id];
            const nextBounds = pageBounds[nextShape.id];
            const gap2 = nextBounds[min4] - bounds[max3];
            const current = gaps.find((g2) => g2.gap === gap2);
            if (current) {
              current.count++;
            } else {
              gaps.push({ gap: gap2, count: 1 });
            }
          }
          let maxCount = 0;
          gaps.forEach((g2) => {
            if (g2.count > maxCount) {
              maxCount = g2.count;
              shapeGap = g2.gap;
            }
          });
          if (maxCount === 1) {
            shapeGap = Math.max(0, gaps.reduce((a2, c2) => a2 + c2.gap * c2.count, 0) / (len - 1));
          }
        } else {
          shapeGap = gap;
        }
        const changes = [];
        let v2 = pageBounds[shapesToStack[0].id][max3];
        shapesToStack.forEach((shape, i2) => {
          if (i2 === 0)
            return;
          const delta = { x: 0, y: 0 };
          delta[val] = v2 + shapeGap - pageBounds[shape.id][val];
          const parent = this.getShapeParent(shape);
          const localDelta = parent ? Vec.Rot(delta, -this.getShapePageTransform(parent).decompose().rotation) : delta;
          const translateStartChanges = this.getShapeUtil(shape).onTranslateStart?.(shape);
          changes.push(translateStartChanges ? {
            ...translateStartChanges,
            [val]: shape[val] + localDelta[val]
          } : {
            id: shape.id,
            type: shape.type,
            [val]: shape[val] + localDelta[val]
          });
          v2 += pageBounds[shape.id][dim] + shapeGap;
        });
        this.updateShapes(changes);
        return this;
      }
      packShapes(shapes, gap) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        if (ids.length < 2)
          return this;
        const shapesToPack = ids.map((id) => this.getShape(id)).filter((shape2) => {
          if (!shape2)
            return false;
          return this.getShapeUtil(shape2).canBeLaidOut(shape2);
        });
        const shapePageBounds = {};
        const nextShapePageBounds = {};
        let shape, bounds, area = 0;
        for (let i2 = 0; i2 < shapesToPack.length; i2++) {
          shape = shapesToPack[i2];
          bounds = this.getShapePageBounds(shape);
          shapePageBounds[shape.id] = bounds;
          nextShapePageBounds[shape.id] = bounds.clone();
          area += bounds.width * bounds.height;
        }
        const commonBounds = Box.Common(compact(Object.values(shapePageBounds)));
        const maxWidth2 = commonBounds.width;
        shapesToPack.sort((a2, b2) => shapePageBounds[b2.id].height - shapePageBounds[a2.id].height);
        const startWidth = Math.max(Math.ceil(Math.sqrt(area / 0.95)), maxWidth2);
        const spaces = [new Box(commonBounds.x, commonBounds.y, startWidth, Infinity)];
        let width = 0;
        let height = 0;
        let space;
        let last22;
        for (let i2 = 0; i2 < shapesToPack.length; i2++) {
          shape = shapesToPack[i2];
          bounds = nextShapePageBounds[shape.id];
          for (let i22 = spaces.length - 1; i22 >= 0; i22--) {
            space = spaces[i22];
            if (bounds.width > space.width || bounds.height > space.height)
              continue;
            bounds.x = space.x;
            bounds.y = space.y;
            height = Math.max(height, bounds.maxY);
            width = Math.max(width, bounds.maxX);
            if (bounds.width === space.width && bounds.height === space.height) {
              last22 = spaces.pop();
              if (i22 < spaces.length)
                spaces[i22] = last22;
            } else if (bounds.height === space.height) {
              space.x += bounds.width + gap;
              space.width -= bounds.width + gap;
            } else if (bounds.width === space.width) {
              space.y += bounds.height + gap;
              space.height -= bounds.height + gap;
            } else {
              spaces.push(new Box(space.x + (bounds.width + gap), space.y, space.width - (bounds.width + gap), bounds.height));
              space.y += bounds.height + gap;
              space.height -= bounds.height + gap;
            }
            break;
          }
        }
        const commonAfter = Box.Common(Object.values(nextShapePageBounds));
        const centerDelta = Vec.Sub(commonBounds.center, commonAfter.center);
        let nextBounds;
        const changes = [];
        for (let i2 = 0; i2 < shapesToPack.length; i2++) {
          shape = shapesToPack[i2];
          bounds = shapePageBounds[shape.id];
          nextBounds = nextShapePageBounds[shape.id];
          const delta = Vec.Sub(nextBounds.point, bounds.point).add(centerDelta);
          const parentTransform = this.getShapeParentTransform(shape);
          if (parentTransform)
            delta.rot(-parentTransform.rotation());
          const change = {
            id: shape.id,
            type: shape.type,
            x: shape.x + delta.x,
            y: shape.y + delta.y
          };
          const translateStartChange = this.getShapeUtil(shape).onTranslateStart?.({
            ...shape,
            ...change
          });
          if (translateStartChange) {
            changes.push({ ...change, ...translateStartChange });
          } else {
            changes.push(change);
          }
        }
        if (changes.length) {
          this.updateShapes(changes);
        }
        return this;
      }
      alignShapes(shapes, operation) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        if (ids.length < 2)
          return this;
        const shapesToAlign = compact(ids.map((id) => this.getShape(id)));
        const shapePageBounds = Object.fromEntries(shapesToAlign.map((shape) => [shape.id, this.getShapePageBounds(shape)]));
        const commonBounds = Box.Common(compact(Object.values(shapePageBounds)));
        const changes = [];
        shapesToAlign.forEach((shape) => {
          const pageBounds = shapePageBounds[shape.id];
          if (!pageBounds)
            return;
          const delta = { x: 0, y: 0 };
          switch (operation) {
            case "top": {
              delta.y = commonBounds.minY - pageBounds.minY;
              break;
            }
            case "center-vertical": {
              delta.y = commonBounds.midY - pageBounds.minY - pageBounds.height / 2;
              break;
            }
            case "bottom": {
              delta.y = commonBounds.maxY - pageBounds.minY - pageBounds.height;
              break;
            }
            case "left": {
              delta.x = commonBounds.minX - pageBounds.minX;
              break;
            }
            case "center-horizontal": {
              delta.x = commonBounds.midX - pageBounds.minX - pageBounds.width / 2;
              break;
            }
            case "right": {
              delta.x = commonBounds.maxX - pageBounds.minX - pageBounds.width;
              break;
            }
          }
          const parent = this.getShapeParent(shape);
          const localDelta = parent ? Vec.Rot(delta, -this.getShapePageTransform(parent).decompose().rotation) : delta;
          changes.push(this.getChangesToTranslateShape(shape, Vec.Add(shape, localDelta)));
        });
        this.updateShapes(changes);
        return this;
      }
      distributeShapes(shapes, operation) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        if (ids.length < 3)
          return this;
        const len = ids.length;
        const shapesToDistribute = compact(ids.map((id) => this.getShape(id)));
        const pageBounds = Object.fromEntries(shapesToDistribute.map((shape) => [shape.id, this.getShapePageBounds(shape)]));
        let val;
        let min4;
        let max3;
        let mid;
        let dim;
        if (operation === "horizontal") {
          val = "x";
          min4 = "minX";
          max3 = "maxX";
          mid = "midX";
          dim = "width";
        } else {
          val = "y";
          min4 = "minY";
          max3 = "maxY";
          mid = "midY";
          dim = "height";
        }
        const changes = [];
        const first = shapesToDistribute.sort((a2, b2) => pageBounds[a2.id][min4] - pageBounds[b2.id][min4])[0];
        const last22 = shapesToDistribute.sort((a2, b2) => pageBounds[b2.id][max3] - pageBounds[a2.id][max3])[0];
        const midFirst = pageBounds[first.id][mid];
        const step = (pageBounds[last22.id][mid] - midFirst) / (len - 1);
        const v2 = midFirst + step;
        shapesToDistribute.filter((shape) => shape !== first && shape !== last22).sort((a2, b2) => pageBounds[a2.id][mid] - pageBounds[b2.id][mid]).forEach((shape, i2) => {
          const delta = { x: 0, y: 0 };
          delta[val] = v2 + step * i2 - pageBounds[shape.id][dim] / 2 - pageBounds[shape.id][val];
          const parent = this.getShapeParent(shape);
          const localDelta = parent ? Vec.Rot(delta, -this.getShapePageTransform(parent).rotation()) : delta;
          changes.push(this.getChangesToTranslateShape(shape, Vec.Add(shape, localDelta)));
        });
        this.updateShapes(changes);
        return this;
      }
      stretchShapes(shapes, operation) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (this.getInstanceState().isReadonly)
          return this;
        if (ids.length < 2)
          return this;
        const shapesToStretch = compact(ids.map((id) => this.getShape(id)));
        const shapeBounds = Object.fromEntries(ids.map((id) => [id, this.getShapeGeometry(id).bounds]));
        const shapePageBounds = Object.fromEntries(ids.map((id) => [id, this.getShapePageBounds(id)]));
        const commonBounds = Box.Common(compact(Object.values(shapePageBounds)));
        switch (operation) {
          case "vertical": {
            this.run(() => {
              for (const shape of shapesToStretch) {
                const pageRotation = this.getShapePageTransform(shape).rotation();
                if (pageRotation % PI2)
                  continue;
                const bounds = shapeBounds[shape.id];
                const pageBounds = shapePageBounds[shape.id];
                const localOffset = new Vec(0, commonBounds.minY - pageBounds.minY);
                const parentTransform = this.getShapeParentTransform(shape);
                if (parentTransform)
                  localOffset.rot(-parentTransform.rotation());
                const { x: x2, y: y2 } = Vec.Add(localOffset, shape);
                this.updateShapes([{ id: shape.id, type: shape.type, x: x2, y: y2 }]);
                const scale = new Vec(1, commonBounds.height / pageBounds.height);
                this.resizeShape(shape.id, scale, {
                  initialBounds: bounds,
                  scaleOrigin: new Vec(pageBounds.center.x, commonBounds.minY),
                  isAspectRatioLocked: this.getShapeUtil(shape).isAspectRatioLocked(shape),
                  scaleAxisRotation: 0
                });
              }
            });
            break;
          }
          case "horizontal": {
            this.run(() => {
              for (const shape of shapesToStretch) {
                const bounds = shapeBounds[shape.id];
                const pageBounds = shapePageBounds[shape.id];
                const pageRotation = this.getShapePageTransform(shape).rotation();
                if (pageRotation % PI2)
                  continue;
                const localOffset = new Vec(commonBounds.minX - pageBounds.minX, 0);
                const parentTransform = this.getShapeParentTransform(shape);
                if (parentTransform)
                  localOffset.rot(-parentTransform.rotation());
                const { x: x2, y: y2 } = Vec.Add(localOffset, shape);
                this.updateShapes([{ id: shape.id, type: shape.type, x: x2, y: y2 }]);
                const scale = new Vec(commonBounds.width / pageBounds.width, 1);
                this.resizeShape(shape.id, scale, {
                  initialBounds: bounds,
                  scaleOrigin: new Vec(commonBounds.minX, pageBounds.center.y),
                  isAspectRatioLocked: this.getShapeUtil(shape).isAspectRatioLocked(shape),
                  scaleAxisRotation: 0
                });
              }
            });
            break;
          }
        }
        return this;
      }
      resizeShape(shape, scale, options = {}) {
        const id = typeof shape === "string" ? shape : shape.id;
        if (this.getInstanceState().isReadonly)
          return this;
        if (!Number.isFinite(scale.x))
          scale = new Vec(1, scale.y);
        if (!Number.isFinite(scale.y))
          scale = new Vec(scale.x, 1);
        const initialShape = options.initialShape ?? this.getShape(id);
        if (!initialShape)
          return this;
        const scaleOrigin = options.scaleOrigin ?? this.getShapePageBounds(id)?.center;
        if (!scaleOrigin)
          return this;
        const pageTransform = options.initialPageTransform ? Mat.Cast(options.initialPageTransform) : this.getShapePageTransform(id);
        if (!pageTransform)
          return this;
        const pageRotation = pageTransform.rotation();
        if (pageRotation == null)
          return this;
        const scaleAxisRotation = options.scaleAxisRotation ?? pageRotation;
        const initialBounds = options.initialBounds ?? this.getShapeGeometry(id).bounds;
        if (!initialBounds)
          return this;
        const isAspectRatioLocked = options.isAspectRatioLocked ?? this.getShapeUtil(initialShape).isAspectRatioLocked(initialShape);
        if (!areAnglesCompatible(pageRotation, scaleAxisRotation)) {
          return this._resizeUnalignedShape(id, scale, {
            ...options,
            initialBounds,
            scaleOrigin,
            scaleAxisRotation,
            initialPageTransform: pageTransform,
            isAspectRatioLocked,
            initialShape
          });
        }
        const util = this.getShapeUtil(initialShape);
        if (isAspectRatioLocked) {
          if (Math.abs(scale.x) > Math.abs(scale.y)) {
            scale = new Vec(scale.x, Math.sign(scale.y) * Math.abs(scale.x));
          } else {
            scale = new Vec(Math.sign(scale.x) * Math.abs(scale.y), scale.y);
          }
        }
        if (util.onResize && util.canResize(initialShape)) {
          const newPagePoint = this._scalePagePoint(Mat.applyToPoint(pageTransform, new Vec(0, 0)), scaleOrigin, scale, scaleAxisRotation);
          const newLocalPoint = this.getPointInParentSpace(initialShape.id, newPagePoint);
          const myScale = new Vec(scale.x, scale.y);
          const areWidthAndHeightAlignedWithCorrectAxis = approximately((pageRotation - scaleAxisRotation) % Math.PI, 0);
          myScale.x = areWidthAndHeightAlignedWithCorrectAxis ? scale.x : scale.y;
          myScale.y = areWidthAndHeightAlignedWithCorrectAxis ? scale.y : scale.x;
          const initialPagePoint = Mat.applyToPoint(pageTransform, new Vec());
          const { x: x2, y: y2 } = this.getPointInParentSpace(initialShape.id, initialPagePoint);
          let workingShape = initialShape;
          if (!options.skipStartAndEndCallbacks) {
            workingShape = applyPartialToRecordWithProps(initialShape, util.onResizeStart?.(initialShape) ?? void 0);
          }
          workingShape = applyPartialToRecordWithProps(workingShape, {
            id,
            type: initialShape.type,
            x: newLocalPoint.x,
            y: newLocalPoint.y,
            ...util.onResize({ ...initialShape, x: x2, y: y2 }, {
              newPoint: newLocalPoint,
              handle: options.dragHandle ?? "bottom_right",
              mode: options.mode ?? "scale_shape",
              scaleX: myScale.x,
              scaleY: myScale.y,
              initialBounds,
              initialShape
            })
          });
          if (!options.skipStartAndEndCallbacks) {
            workingShape = applyPartialToRecordWithProps(workingShape, util.onResizeEnd?.(initialShape, workingShape) ?? void 0);
          }
          this.updateShapes([workingShape]);
        } else {
          const initialPageCenter = Mat.applyToPoint(pageTransform, initialBounds.center);
          const newPageCenter = this._scalePagePoint(initialPageCenter, scaleOrigin, scale, scaleAxisRotation);
          const initialPageCenterInParentSpace = this.getPointInParentSpace(initialShape.id, initialPageCenter);
          const newPageCenterInParentSpace = this.getPointInParentSpace(initialShape.id, newPageCenter);
          const delta = Vec.Sub(newPageCenterInParentSpace, initialPageCenterInParentSpace);
          this.updateShapes([
            {
              id,
              type: initialShape.type,
              x: initialShape.x + delta.x,
              y: initialShape.y + delta.y
            }
          ]);
        }
        return this;
      }
      _scalePagePoint(point, scaleOrigin, scale, scaleAxisRotation) {
        const relativePoint = Vec.RotWith(point, scaleOrigin, -scaleAxisRotation).sub(scaleOrigin);
        const newRelativePagePoint = Vec.MulV(relativePoint, scale);
        const destination = Vec.Add(newRelativePagePoint, scaleOrigin).rotWith(scaleOrigin, scaleAxisRotation);
        return destination;
      }
      _resizeUnalignedShape(id, scale, options) {
        const { type } = options.initialShape;
        const shapeScale = new Vec(scale.x, scale.y);
        if (Math.abs(scale.x) > Math.abs(scale.y)) {
          shapeScale.x = Math.sign(scale.x) * Math.abs(scale.y);
        } else {
          shapeScale.y = Math.sign(scale.y) * Math.abs(scale.x);
        }
        this.resizeShape(id, shapeScale, {
          initialShape: options.initialShape,
          initialBounds: options.initialBounds,
          isAspectRatioLocked: options.isAspectRatioLocked
        });
        if (Math.sign(scale.x) * Math.sign(scale.y) < 0) {
          let { rotation } = Mat.Decompose(options.initialPageTransform);
          rotation -= 2 * rotation;
          this.updateShapes([{ id, type, rotation }]);
        }
        const preScaleShapePageCenter = Mat.applyToPoint(options.initialPageTransform, options.initialBounds.center);
        const postScaleShapePageCenter = this._scalePagePoint(preScaleShapePageCenter, options.scaleOrigin, scale, options.scaleAxisRotation);
        const pageBounds = this.getShapePageBounds(id);
        const pageTransform = this.getShapePageTransform(id);
        const currentPageCenter = pageBounds.center;
        const shapePageTransformOrigin = pageTransform.point();
        if (!currentPageCenter || !shapePageTransformOrigin)
          return this;
        const pageDelta = Vec.Sub(postScaleShapePageCenter, currentPageCenter);
        const postScaleShapePagePoint = Vec.Add(shapePageTransformOrigin, pageDelta);
        const { x: x2, y: y2 } = this.getPointInParentSpace(id, postScaleShapePagePoint);
        this.updateShapes([{ id, type, x: x2, y: y2 }]);
        return this;
      }
      getInitialMetaForShape(_shape) {
        return {};
      }
      createShape(shape) {
        this.createShapes([shape]);
        return this;
      }
      createShapes(shapes) {
        if (!Array.isArray(shapes)) {
          throw Error("Editor.createShapes: must provide an array of shapes or shape partials");
        }
        if (this.getInstanceState().isReadonly)
          return this;
        if (shapes.length <= 0)
          return this;
        const currentPageShapeIds = this.getCurrentPageShapeIds();
        const maxShapesReached = shapes.length + currentPageShapeIds.size > this.options.maxShapesPerPage;
        if (maxShapesReached) {
          alertMaxShapes(this);
          return this;
        }
        const focusedGroupId = this.getFocusedGroupId();
        this.run(() => {
          const currentPageShapesSorted = this.getCurrentPageShapesSorted();
          const partials = shapes.map((partial) => {
            if (!partial.id) {
              partial = { id: createShapeId(), ...partial };
            }
            if (!partial.parentId || !(this.store.has(partial.parentId) || shapes.some((p2) => p2.id === partial.parentId))) {
              let parentId = this.getFocusedGroupId();
              for (let i2 = currentPageShapesSorted.length - 1; i2 >= 0; i2--) {
                const parent = currentPageShapesSorted[i2];
                if (this.getShapeUtil(parent).canReceiveNewChildrenOfType(parent, partial.type) && this.isPointInShape(parent, { x: partial.x ?? 0, y: partial.y ?? 0 }, {
                  margin: 0,
                  hitInside: true
                })) {
                  parentId = parent.id;
                  break;
                }
              }
              const prevParentId = partial.parentId;
              if (parentId === partial.id) {
                parentId = focusedGroupId;
              }
              if (parentId !== prevParentId) {
                partial = { ...partial };
                partial.parentId = parentId;
                if (isShapeId(parentId)) {
                  const point = this.getPointInShapeSpace(this.getShape(parentId), {
                    x: partial.x ?? 0,
                    y: partial.y ?? 0
                  });
                  partial.x = point.x;
                  partial.y = point.y;
                  partial.rotation = -this.getShapePageTransform(parentId).rotation() + (partial.rotation ?? 0);
                }
              }
            }
            return partial;
          });
          const parentIndices = /* @__PURE__ */ new Map();
          const shapeRecordsToCreate = [];
          const { opacityForNextShape } = this.getInstanceState();
          for (const partial of partials) {
            const util = this.getShapeUtil(partial);
            let index3 = partial.index;
            if (!index3) {
              const parentId = partial.parentId ?? focusedGroupId;
              if (!parentIndices.has(parentId)) {
                parentIndices.set(parentId, this.getHighestIndexForParent(parentId));
              }
              index3 = parentIndices.get(parentId);
              parentIndices.set(parentId, getIndexAbove(index3));
            }
            const initialProps = util.getDefaultProps();
            for (const [style, propKey] of this.styleProps[partial.type]) {
              ;
              initialProps[propKey] = this.getStyleForNextShape(style);
            }
            let shapeRecordToCreate = this.store.schema.types.shape.create({
              ...partial,
              index: index3,
              opacity: partial.opacity ?? opacityForNextShape,
              parentId: partial.parentId ?? focusedGroupId,
              props: "props" in partial ? { ...initialProps, ...partial.props } : initialProps
            });
            if (shapeRecordToCreate.index === void 0) {
              throw Error("no index!");
            }
            const next = this.getShapeUtil(shapeRecordToCreate).onBeforeCreate?.(shapeRecordToCreate);
            if (next) {
              shapeRecordToCreate = next;
            }
            shapeRecordsToCreate.push(shapeRecordToCreate);
          }
          shapeRecordsToCreate.forEach((shape) => {
            shape.meta = {
              ...this.getInitialMetaForShape(shape),
              ...shape.meta
            };
          });
          this.store.put(shapeRecordsToCreate);
        });
        return this;
      }
      animateShape(partial, opts = { animation: DEFAULT_ANIMATION_OPTIONS }) {
        return this.animateShapes([partial], opts);
      }
      animateShapes(partials, opts = { animation: DEFAULT_ANIMATION_OPTIONS }) {
        if (!opts.animation)
          return this;
        const { duration = 500, easing = EASINGS.linear } = opts.animation;
        const animationId = uniqueId();
        let remaining = duration;
        let t3;
        const animations = [];
        let partial, result;
        for (let i2 = 0, n2 = partials.length; i2 < n2; i2++) {
          partial = partials[i2];
          if (!partial)
            continue;
          const shape = this.getShape(partial.id);
          if (!shape)
            continue;
          result = {
            start: structuredClone2(shape),
            end: applyPartialToRecordWithProps(structuredClone2(shape), partial)
          };
          animations.push(result);
          this.animatingShapes.set(shape.id, animationId);
        }
        const handleTick = (elapsed) => {
          remaining -= elapsed;
          if (remaining < 0) {
            const { animatingShapes: animatingShapes2 } = this;
            const partialsToUpdate = partials.filter((p2) => p2 && animatingShapes2.get(p2.id) === animationId);
            if (partialsToUpdate.length) {
              this.updateShapes(partialsToUpdate);
            }
            this.off("tick", handleTick);
            return;
          }
          t3 = easing(1 - remaining / duration);
          const { animatingShapes } = this;
          const updates = [];
          let animationIdForShape;
          for (let i2 = 0, n2 = animations.length; i2 < n2; i2++) {
            const { start: start2, end: end2 } = animations[i2];
            animationIdForShape = animatingShapes.get(start2.id);
            if (animationIdForShape !== animationId)
              continue;
            updates.push({
              ...end2,
              x: start2.x + (end2.x - start2.x) * t3,
              y: start2.y + (end2.y - start2.y) * t3,
              opacity: start2.opacity + (end2.opacity - start2.opacity) * t3,
              rotation: start2.rotation + (end2.rotation - start2.rotation) * t3,
              props: this.getShapeUtil(end2).getInterpolatedProps?.(start2, end2, t3) ?? end2.props
            });
          }
          this._updateShapes(updates);
        };
        this.on("tick", handleTick);
        return this;
      }
      groupShapes(shapes, options = {}) {
        const { groupId = createShapeId(), select = true } = options;
        if (!Array.isArray(shapes)) {
          throw Error("Editor.groupShapes: must provide an array of shapes or shape ids");
        }
        if (this.getInstanceState().isReadonly)
          return this;
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (ids.length <= 1)
          return this;
        const shapesToGroup = compact((this._shouldIgnoreShapeLock ? ids : this._getUnlockedShapeIds(ids)).map((id) => this.getShape(id)));
        const sortedShapeIds = shapesToGroup.sort(sortByIndex).map((s2) => s2.id);
        const pageBounds = Box.Common(compact(shapesToGroup.map((id) => this.getShapePageBounds(id))));
        const { x: x2, y: y2 } = pageBounds.point;
        const parentId = this.findCommonAncestor(shapesToGroup) ?? this.getCurrentPageId();
        if (this.getCurrentToolId() !== "select")
          return this;
        if (!this.isIn("select.idle")) {
          this.cancel();
        }
        const shapesWithRootParent = shapesToGroup.filter((shape) => shape.parentId === parentId).sort(sortByIndex);
        const highestIndex = shapesWithRootParent[shapesWithRootParent.length - 1]?.index;
        this.run(() => {
          this.createShapes([
            {
              id: groupId,
              type: "group",
              parentId,
              index: highestIndex,
              x: x2,
              y: y2,
              opacity: 1,
              props: {}
            }
          ]);
          this.reparentShapes(sortedShapeIds, groupId);
          if (select) {
            this.select(groupId);
          }
        });
        return this;
      }
      ungroupShapes(shapes, options = {}) {
        if (this.getInstanceState().isReadonly)
          return this;
        const { select = true } = options;
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        const shapesToUngroup = compact((this._shouldIgnoreShapeLock ? ids : this._getUnlockedShapeIds(ids)).map((id) => this.getShape(id)));
        if (shapesToUngroup.length === 0)
          return this;
        if (this.getCurrentToolId() !== "select")
          return this;
        if (!this.isIn("select.idle")) {
          this.cancel();
        }
        const idsToSelect = /* @__PURE__ */ new Set();
        const groups = [];
        shapesToUngroup.forEach((shape) => {
          if (this.isShapeOfType(shape, "group")) {
            groups.push(shape);
          } else {
            idsToSelect.add(shape.id);
          }
        });
        if (groups.length === 0)
          return this;
        this.run(() => {
          let group;
          for (let i2 = 0, n2 = groups.length; i2 < n2; i2++) {
            group = groups[i2];
            const childIds = this.getSortedChildIdsForParent(group.id);
            for (let j2 = 0, n22 = childIds.length; j2 < n22; j2++) {
              idsToSelect.add(childIds[j2]);
            }
            this.reparentShapes(childIds, group.parentId, group.index);
          }
          this.deleteShapes(groups.map((group2) => group2.id));
          if (select) {
            this.select(...idsToSelect);
          }
        });
        return this;
      }
      updateShape(partial) {
        this.updateShapes([partial]);
        return this;
      }
      updateShapes(partials) {
        const compactedPartials = Array(partials.length);
        for (let i2 = 0, n2 = partials.length; i2 < n2; i2++) {
          const partial = partials[i2];
          if (!partial)
            continue;
          const shape = this.getShape(partial.id);
          if (!shape)
            continue;
          if (!this._shouldIgnoreShapeLock) {
            if (shape.isLocked) {
              if (!(Object.hasOwn(partial, "isLocked") && !partial.isLocked)) {
                continue;
              }
            } else if (this.isShapeOrAncestorLocked(shape)) {
              continue;
            }
          }
          this.animatingShapes.delete(partial.id);
          compactedPartials.push(partial);
        }
        this._updateShapes(compactedPartials);
        return this;
      }
      _getUnlockedShapeIds(ids) {
        return ids.filter((id) => !this.getShape(id)?.isLocked);
      }
      deleteShapes(_ids) {
        if (this.getInstanceState().isReadonly)
          return this;
        if (!Array.isArray(_ids)) {
          throw Error("Editor.deleteShapes: must provide an array of shapes or shapeIds");
        }
        const shapeIds = typeof _ids[0] === "string" ? _ids : _ids.map((s2) => s2.id);
        const shapeIdsToDelete = this._shouldIgnoreShapeLock ? shapeIds : this._getUnlockedShapeIds(shapeIds);
        if (shapeIdsToDelete.length === 0)
          return this;
        const allShapeIdsToDelete = new Set(shapeIdsToDelete);
        for (const id of shapeIdsToDelete) {
          this.visitDescendants(id, (childId) => {
            allShapeIdsToDelete.add(childId);
          });
        }
        return this.run(() => this.store.remove([...allShapeIdsToDelete]));
      }
      deleteShape(_id) {
        this.deleteShapes([typeof _id === "string" ? _id : _id.id]);
        return this;
      }
      _extractSharedStyles(shape, sharedStyleMap) {
        if (this.isShapeOfType(shape, "group")) {
          const childIds = this._parentIdsToChildIds.get()[shape.id];
          if (!childIds)
            return;
          for (let i2 = 0, n2 = childIds.length; i2 < n2; i2++) {
            this._extractSharedStyles(this.getShape(childIds[i2]), sharedStyleMap);
          }
        } else {
          for (const [style, propKey] of this.styleProps[shape.type]) {
            sharedStyleMap.applyValue(style, getOwnProperty(shape.props, propKey));
          }
        }
      }
      _getSelectionSharedStyles() {
        const selectedShapes = this.getSelectedShapes();
        const sharedStyles = new SharedStyleMap();
        for (const selectedShape of selectedShapes) {
          this._extractSharedStyles(selectedShape, sharedStyles);
        }
        return sharedStyles;
      }
      getStyleForNextShape(style) {
        const value = this.getInstanceState().stylesForNextShape[style.id];
        return value === void 0 ? style.defaultValue : value;
      }
      getShapeStyleIfExists(shape, style) {
        const styleKey = this.styleProps[shape.type].get(style);
        if (styleKey === void 0)
          return void 0;
        return getOwnProperty(shape.props, styleKey);
      }
      getSharedStyles() {
        if (this.isIn("select") && this.getSelectedShapeIds().length > 0) {
          return this._getSelectionSharedStyles();
        }
        const currentTool = this.root.getCurrent();
        const styles3 = new SharedStyleMap();
        if (!currentTool)
          return styles3;
        if (currentTool.shapeType) {
          for (const style of this.styleProps[currentTool.shapeType].keys()) {
            styles3.applyValue(style, this.getStyleForNextShape(style));
          }
        }
        return styles3;
      }
      getSharedOpacity() {
        if (this.isIn("select") && this.getSelectedShapeIds().length > 0) {
          const shapesToCheck = [];
          const addShape = (shapeId) => {
            const shape = this.getShape(shapeId);
            if (!shape)
              return;
            if (this.isShapeOfType(shape, "group")) {
              for (const childId of this.getSortedChildIdsForParent(shape.id)) {
                addShape(childId);
              }
            } else {
              shapesToCheck.push(shape);
            }
          };
          for (const shapeId of this.getSelectedShapeIds()) {
            addShape(shapeId);
          }
          let opacity = null;
          for (const shape of shapesToCheck) {
            if (opacity === null) {
              opacity = shape.opacity;
            } else if (opacity !== shape.opacity) {
              return { type: "mixed" };
            }
          }
          if (opacity !== null)
            return { type: "shared", value: opacity };
        }
        return { type: "shared", value: this.getInstanceState().opacityForNextShape };
      }
      setOpacityForNextShapes(opacity, historyOptions) {
        this.updateInstanceState({ opacityForNextShape: opacity }, historyOptions);
        return this;
      }
      setOpacityForSelectedShapes(opacity) {
        const selectedShapes = this.getSelectedShapes();
        if (selectedShapes.length > 0) {
          const shapesToUpdate = [];
          const addShapeById = (shape) => {
            if (this.isShapeOfType(shape, "group")) {
              const childIds = this.getSortedChildIdsForParent(shape);
              for (const childId of childIds) {
                addShapeById(this.getShape(childId));
              }
            } else {
              shapesToUpdate.push(shape);
            }
          };
          for (const id of selectedShapes) {
            addShapeById(id);
          }
          this.updateShapes(shapesToUpdate.map((shape) => {
            return {
              id: shape.id,
              type: shape.type,
              opacity
            };
          }));
        }
        return this;
      }
      setStyleForNextShapes(style, value, historyOptions) {
        const stylesForNextShape = this.getInstanceState().stylesForNextShape;
        this.updateInstanceState({ stylesForNextShape: { ...stylesForNextShape, [style.id]: value } }, historyOptions);
        return this;
      }
      setStyleForSelectedShapes(style, value) {
        const selectedShapes = this.getSelectedShapes();
        if (selectedShapes.length > 0) {
          const updates = [];
          const addShapeById = (shape) => {
            if (this.isShapeOfType(shape, "group")) {
              const childIds = this.getSortedChildIdsForParent(shape.id);
              for (const childId of childIds) {
                addShapeById(this.getShape(childId));
              }
            } else {
              const util = this.getShapeUtil(shape);
              const stylePropKey = this.styleProps[shape.type].get(style);
              if (stylePropKey) {
                const shapePartial = {
                  id: shape.id,
                  type: shape.type,
                  props: { [stylePropKey]: value }
                };
                updates.push({
                  util,
                  originalShape: shape,
                  updatePartial: shapePartial
                });
              }
            }
          };
          for (const shape of selectedShapes) {
            addShapeById(shape);
          }
          this.updateShapes(updates.map(({ updatePartial }) => updatePartial));
        }
        return this;
      }
      registerExternalAssetHandler(type, handler) {
        this.externalAssetContentHandlers[type] = handler;
        return this;
      }
      async getAssetForExternalContent(info2) {
        return await this.externalAssetContentHandlers[info2.type]?.(info2);
      }
      hasExternalAssetHandler(type) {
        return !!this.externalAssetContentHandlers[type];
      }
      registerExternalContentHandler(type, handler) {
        this.externalContentHandlers[type] = handler;
        return this;
      }
      async putExternalContent(info2) {
        return this.externalContentHandlers[info2.type]?.(info2);
      }
      getContentFromCurrentPage(shapes) {
        const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s2) => s2.id);
        if (!ids)
          return;
        if (ids.length === 0)
          return;
        const shapeIds = this.getShapeAndDescendantIds(ids);
        return withIsolatedShapes(this, shapeIds, (bindingIdsToKeep) => {
          const bindings = [];
          for (const id of bindingIdsToKeep) {
            const binding = this.getBinding(id);
            if (!binding)
              continue;
            bindings.push(binding);
          }
          const rootShapeIds = [];
          const shapes2 = [];
          for (const shapeId of shapeIds) {
            const shape = this.getShape(shapeId);
            if (!shape)
              continue;
            const isRootShape = !shapeIds.has(shape.parentId);
            if (isRootShape) {
              const pageTransform = this.getShapePageTransform(shape.id);
              const pagePoint = pageTransform.point();
              shapes2.push({
                ...shape,
                x: pagePoint.x,
                y: pagePoint.y,
                rotation: pageTransform.rotation(),
                parentId: this.getCurrentPageId()
              });
              rootShapeIds.push(shape.id);
            } else {
              shapes2.push(shape);
            }
          }
          const assets = [];
          const seenAssetIds = /* @__PURE__ */ new Set();
          for (const shape of shapes2) {
            if (!("assetId" in shape.props))
              continue;
            const assetId = shape.props.assetId;
            if (!assetId || seenAssetIds.has(assetId))
              continue;
            seenAssetIds.add(assetId);
            const asset = this.getAsset(assetId);
            if (!asset)
              continue;
            assets.push(asset);
          }
          return {
            schema: this.store.schema.serialize(),
            shapes: shapes2,
            rootShapeIds,
            bindings,
            assets
          };
        });
      }
      async resolveAssetsInContent(content) {
        if (!content)
          return void 0;
        const assets = [];
        await Promise.allSettled(content.assets.map(async (asset) => {
          if ((asset.type === "image" || asset.type === "video") && !asset.props.src?.startsWith("data:image") && !asset.props.src?.startsWith("http")) {
            const assetWithDataUrl = structuredClone2(asset);
            const objectUrl = await this.store.props.assets.resolve(asset, {
              screenScale: 1,
              steppedScreenScale: 1,
              dpr: 1,
              networkEffectiveType: null,
              shouldResolveToOriginal: true
            });
            assetWithDataUrl.props.src = await FileHelpers.blobToDataUrl(await fetch2(objectUrl).then((r2) => r2.blob()));
            assets.push(assetWithDataUrl);
          } else {
            assets.push(asset);
          }
        }));
        content.assets = assets;
        return content;
      }
      putContentOntoCurrentPage(content, options = {}) {
        if (this.getInstanceState().isReadonly)
          return this;
        if (!content.schema) {
          throw Error("Could not put content:\ncontent is missing a schema.");
        }
        const { select = false, preserveIds = false, preservePosition = false } = options;
        let { point = void 0 } = options;
        const currentPageId = this.getCurrentPageId();
        const { rootShapeIds } = content;
        const assets = [];
        const shapes = [];
        const bindings = [];
        const store = {
          store: {
            ...Object.fromEntries(content.assets.map((asset) => [asset.id, asset])),
            ...Object.fromEntries(content.shapes.map((shape) => [shape.id, shape])),
            ...Object.fromEntries(content.bindings?.map((bindings2) => [bindings2.id, bindings2]) ?? [])
          },
          schema: content.schema
        };
        const result = this.store.schema.migrateStoreSnapshot(store);
        if (result.type === "error") {
          throw Error("Could not put content: could not migrate content");
        }
        for (const record of Object.values(result.value)) {
          switch (record.typeName) {
            case "asset": {
              assets.push(record);
              break;
            }
            case "shape": {
              shapes.push(record);
              break;
            }
            case "binding": {
              bindings.push(record);
              break;
            }
          }
        }
        const shapeIdMap = new Map(preserveIds ? shapes.map((shape) => [shape.id, shape.id]) : shapes.map((shape) => [shape.id, createShapeId()]));
        const bindingIdMap = new Map(preserveIds ? bindings.map((binding) => [binding.id, binding.id]) : bindings.map((binding) => [binding.id, createBindingId()]));
        let pasteParentId = this.getCurrentPageId();
        let lowestDepth = Infinity;
        let lowestAncestors = [];
        for (const shape of this.getSelectedShapes()) {
          if (lowestDepth === 0)
            break;
          const isFrame = this.isShapeOfType(shape, "frame");
          const ancestors = this.getShapeAncestors(shape);
          if (isFrame)
            ancestors.push(shape);
          const depth = isFrame ? ancestors.length + 1 : ancestors.length;
          if (depth < lowestDepth) {
            lowestDepth = depth;
            lowestAncestors = ancestors;
            pasteParentId = isFrame ? shape.id : shape.parentId;
          } else if (depth === lowestDepth) {
            if (lowestAncestors.length !== ancestors.length) {
              throw Error(`Ancestors: ${lowestAncestors.length} !== ${ancestors.length}`);
            }
            if (lowestAncestors.length === 0) {
              pasteParentId = currentPageId;
              break;
            } else {
              pasteParentId = currentPageId;
              for (let i2 = 0; i2 < lowestAncestors.length; i2++) {
                if (ancestors[i2] !== lowestAncestors[i2])
                  break;
                pasteParentId = ancestors[i2].id;
              }
            }
          }
        }
        let isDuplicating = false;
        if (!isPageId(pasteParentId)) {
          const parent = this.getShape(pasteParentId);
          if (parent) {
            if (!this.getViewportPageBounds().includes(this.getShapePageBounds(parent))) {
              pasteParentId = currentPageId;
            } else {
              if (rootShapeIds.length === 1) {
                const rootShape = shapes.find((s2) => s2.id === rootShapeIds[0]);
                if (this.isShapeOfType(parent, "frame") && this.isShapeOfType(rootShape, "frame") && rootShape.props.w === parent?.props.w && rootShape.props.h === parent?.props.h) {
                  isDuplicating = true;
                }
              }
            }
          } else {
            pasteParentId = currentPageId;
          }
        }
        if (!isDuplicating) {
          isDuplicating = shapeIdMap.has(pasteParentId);
        }
        if (isDuplicating) {
          pasteParentId = this.getShape(pasteParentId).parentId;
        }
        let index3 = this.getHighestIndexForParent(pasteParentId);
        const rootShapes = [];
        const newShapes = shapes.map((oldShape) => {
          const newId = shapeIdMap.get(oldShape.id);
          const newShape = { ...oldShape, id: newId };
          if (rootShapeIds.includes(oldShape.id)) {
            newShape.parentId = currentPageId;
            rootShapes.push(newShape);
          }
          if (shapeIdMap.has(newShape.parentId)) {
            newShape.parentId = shapeIdMap.get(oldShape.parentId);
          } else {
            rootShapeIds.push(newShape.id);
            newShape.index = index3;
            index3 = getIndexAbove(index3);
          }
          return newShape;
        });
        if (newShapes.length + this.getCurrentPageShapeIds().size > this.options.maxShapesPerPage) {
          alertMaxShapes(this);
          return this;
        }
        const newBindings = bindings.map((oldBinding) => ({
          ...oldBinding,
          id: assertExists(bindingIdMap.get(oldBinding.id)),
          fromId: assertExists(shapeIdMap.get(oldBinding.fromId)),
          toId: assertExists(shapeIdMap.get(oldBinding.toId))
        }));
        const assetsToCreate = [];
        const assetsToUpdate = [];
        for (const asset of assets) {
          if (this.store.has(asset.id)) {
            continue;
          }
          if ((asset.type === "image" || asset.type === "video") && asset.props.src?.startsWith("data:image")) {
            assetsToUpdate.push(structuredClone2(asset));
            asset.props.src = null;
          }
          assetsToCreate.push(asset);
        }
        Promise.allSettled(assetsToUpdate.map(async (asset) => {
          const file = await dataUrlToFile(asset.props.src, asset.props.name, asset.props.mimeType ?? "image/png");
          const newAsset = await this.getAssetForExternalContent({ type: "file", file });
          if (!newAsset) {
            this.deleteAssets([asset.id]);
            return;
          }
          this.updateAssets([{ ...newAsset, id: asset.id }]);
        }));
        this.run(() => {
          if (assetsToCreate.length > 0) {
            this.createAssets(assetsToCreate);
          }
          this.createShapes(newShapes);
          this.createBindings(newBindings);
          if (select) {
            this.select(...rootShapes.map((s2) => s2.id));
          }
          if (pasteParentId !== currentPageId) {
            this.reparentShapes(rootShapes.map((s2) => s2.id), pasteParentId);
          }
          const newCreatedShapes = newShapes.map((s2) => this.getShape(s2.id));
          const bounds = Box.Common(newCreatedShapes.map((s2) => this.getShapePageBounds(s2)));
          if (point === void 0) {
            if (!isPageId(pasteParentId)) {
              const shape = this.getShape(pasteParentId);
              point = Mat.applyToPoint(this.getShapePageTransform(shape), this.getShapeGeometry(shape).bounds.center);
            } else {
              const viewportPageBounds = this.getViewportPageBounds();
              if (preservePosition || viewportPageBounds.includes(Box.From(bounds))) {
                point = bounds.center;
              } else {
                point = viewportPageBounds.center;
              }
            }
          }
          if (rootShapes.length === 1) {
            const onlyRoot = rootShapes[0];
            if (this.isShapeOfType(onlyRoot, "frame")) {
              while (this.getShapesAtPoint(point).some((shape) => this.isShapeOfType(shape, "frame") && shape.props.w === onlyRoot.props.w && shape.props.h === onlyRoot.props.h)) {
                point.x += bounds.w + 16;
              }
            }
          }
          const pageCenter = Box.Common(compact(rootShapes.map(({ id }) => this.getShapePageBounds(id)))).center;
          const offset5 = Vec.Sub(point, pageCenter);
          this.updateShapes(rootShapes.map(({ id }) => {
            const s2 = this.getShape(id);
            const localRotation = this.getShapeParentTransform(id).decompose().rotation;
            const localDelta = Vec.Rot(offset5, -localRotation);
            return { id: s2.id, type: s2.type, x: s2.x + localDelta.x, y: s2.y + localDelta.y };
          }));
        });
        return this;
      }
      async getSvgElement(shapes, opts = {}) {
        const result = await getSvgJsx(this, shapes, opts);
        if (!result)
          return void 0;
        const fragment = document.createDocumentFragment();
        const root = (0, import_client.createRoot)(fragment);
        (0, import_react_dom.flushSync)(() => {
          root.render(result.jsx);
        });
        const svg = fragment.firstElementChild;
        assert(svg instanceof SVGSVGElement, "Expected an SVG element");
        root.unmount();
        return { svg, width: result.width, height: result.height };
      }
      async getSvgString(shapes, opts = {}) {
        const result = await this.getSvgElement(shapes, opts);
        if (!result)
          return void 0;
        const serializer = new XMLSerializer();
        return {
          svg: serializer.serializeToString(result.svg),
          width: result.width,
          height: result.height
        };
      }
      async getSvg(shapes, opts = {}) {
        const result = await this.getSvgElement(shapes, opts);
        if (!result)
          return void 0;
        return result.svg;
      }
      _updateInputsFromEvent(info2) {
        const {
          pointerVelocity,
          previousScreenPoint,
          previousPagePoint,
          currentScreenPoint,
          currentPagePoint
        } = this.inputs;
        const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID);
        const { x: cx, y: cy, z: cz } = unsafe__withoutCapture(() => this.getCamera());
        const sx = info2.point.x - screenBounds.x;
        const sy = info2.point.y - screenBounds.y;
        const sz = info2.point.z ?? 0.5;
        previousScreenPoint.setTo(currentScreenPoint);
        previousPagePoint.setTo(currentPagePoint);
        currentScreenPoint.set(sx, sy);
        const nx = sx / cz - cx;
        const ny = sy / cz - cy;
        if (isFinite(nx) && isFinite(ny)) {
          currentPagePoint.set(nx, ny, sz);
        }
        this.inputs.isPen = info2.type === "pointer" && info2.isPen;
        if (info2.name === "pointer_down" || this.inputs.isPinching) {
          pointerVelocity.set(0, 0);
          this.inputs.originScreenPoint.setTo(currentScreenPoint);
          this.inputs.originPagePoint.setTo(currentPagePoint);
        }
        this.run(() => {
          this.store.put([
            {
              id: TLPOINTER_ID,
              typeName: "pointer",
              x: currentPagePoint.x,
              y: currentPagePoint.y,
              lastActivityTimestamp: info2.type === "pointer" && info2.pointerId === INTERNAL_POINTER_IDS.CAMERA_MOVE ? this.store.unsafeGetWithoutCapture(TLPOINTER_ID)?.lastActivityTimestamp ?? this._tickManager.now : this._tickManager.now,
              meta: {}
            }
          ]);
        }, { history: "ignore" });
      }
      cancel() {
        this.dispatch({ type: "misc", name: "cancel" });
        return this;
      }
      interrupt() {
        this.dispatch({ type: "misc", name: "interrupt" });
        return this;
      }
      complete() {
        this.dispatch({ type: "misc", name: "complete" });
        return this;
      }
      focus({ focusContainer = true } = {}) {
        if (this.getIsFocused())
          return this;
        if (focusContainer)
          this.focusManager.focus();
        this.updateInstanceState({ isFocused: true });
        return this;
      }
      blur({ blurContainer = true } = {}) {
        if (!this.getIsFocused())
          return this;
        if (blurContainer) {
          this.focusManager.blur();
        } else {
          this.complete();
        }
        this.updateInstanceState({ isFocused: false });
        return this;
      }
      getIsFocused() {
        return this.getInstanceState().isFocused;
      }
      getSnapshot() {
        return getSnapshot(this.store);
      }
      loadSnapshot(snapshot) {
        loadSnapshot(this.store, snapshot);
        return this;
      }
      cancelDoubleClick() {
        this._clickManager.cancelDoubleClickTimeout();
      }
      _flushEventsForTick(elapsed) {
        this.run(() => {
          if (this._pendingEventsForNextTick.length > 0) {
            const events = [...this._pendingEventsForNextTick];
            this._pendingEventsForNextTick.length = 0;
            for (const info2 of events) {
              this._flushEventForTick(info2);
            }
          }
          if (elapsed > 0) {
            this.root.handleEvent({ type: "misc", name: "tick", elapsed });
          }
          this.scribbles.tick(elapsed);
        });
      }
      maybeTrackPerformance(name) {
        if (debugFlags.measurePerformance.get()) {
          if (this.performanceTracker.isStarted()) {
            clearTimeout(this.performanceTrackerTimeout);
          } else {
            this.performanceTracker.start(name);
          }
          this.performanceTrackerTimeout = this.timers.setTimeout(() => {
            this.performanceTracker.stop();
          }, 50);
        }
      }
    };
    __decorateClass5([
      computed
    ], Editor.prototype, "getCanUndo", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCanRedo", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getPath", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentTool", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentToolId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getDocumentSettings", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getInstanceState", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getOpenMenus", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getIsMenuOpen", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getPageStates", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getPageStatesQuery", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageState", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getCurrentPageStateId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectedShapeIds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectedShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getOnlySelectedShapeId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getOnlySelectedShape", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectionPageBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectionRotation", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectionRotatedPageBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSelectionRotatedScreenBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getFocusedGroupId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getFocusedGroup", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getEditingShapeId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getEditingShape", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getHoveredShapeId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getHoveredShape", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getHintingShapeIds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getHintingShape", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getErasingShapeIds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getErasingShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_unsafe_getCameraId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCamera", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getViewportPageBoundsForFollowing", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCameraForFollowing", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getZoomLevel", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getViewportScreenBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getViewportScreenCenter", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getViewportPageBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getCollaboratorsQuery", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCollaborators", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCollaboratorsOnCurrentPage", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getRenderingShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getAllPagesQuery", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getPages", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageId", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageShapeIdsSorted", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getAllAssetsQuery", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapeGeometryCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapeHandlesCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapePageTransformCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapePageBoundsCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapeClipPathCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapeMaskCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getShapeMaskedPageBoundsCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_notVisibleShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCulledShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageBounds", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageShapes", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageShapesSorted", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getCurrentPageRenderingShapesSorted", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getBindingsIndexCache", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "_getSelectionSharedStyles", 1);
    __decorateClass5([
      computed({ isEqual: (a2, b2) => a2.equals(b2) })
    ], Editor.prototype, "getSharedStyles", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getSharedOpacity", 1);
    __decorateClass5([
      computed
    ], Editor.prototype, "getIsFocused", 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsDarkMode.mjs
function useIsDarkMode() {
  const editor = useEditor();
  const exportContext = useSvgExportContext();
  return useValue("isDarkMode", () => exportContext?.isDarkMode ?? editor.user.getIsDarkMode(), [
    exportContext,
    editor
  ]);
}
var init_useIsDarkMode = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsDarkMode.mjs"() {
    init_dist_esm9();
    init_SvgExportContext();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useCursor.mjs
function getCursorCss(svg, r2, tr, f2, color, hotspotX = 16, hotspotY = 16) {
  const a2 = (-tr - r2) * (PI / 180);
  const s2 = Math.sin(a2);
  const c2 = Math.cos(a2);
  const dx = 1 * c2 - 1 * s2;
  const dy = 1 * s2 + 1 * c2;
  return `url("data:image/svg+xml,<svg height='32' width='32' viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg' style='color: ${color};'><defs><filter id='shadow' y='-40%' x='-40%' width='180px' height='180%' color-interpolation-filters='sRGB'><feDropShadow dx='${dx}' dy='${dy}' stdDeviation='1.2' flood-opacity='.5'/></filter></defs><g fill='none' transform='rotate(${r2 + tr} 16 16)${f2 ? ` scale(-1,-1) translate(0, -32)` : ""}' filter='url(%23shadow)'>` + svg.replaceAll(`"`, `'`) + `</g></svg>") ${hotspotX} ${hotspotY}, pointer`;
}
function getCursor(cursor, rotation = 0, color = "black") {
  return CURSORS[cursor](radiansToDegrees(rotation), false, color);
}
function useCursor() {
  const editor = useEditor();
  const container = useContainer();
  const isDarkMode = useIsDarkMode();
  useQuickReactor("useCursor", () => {
    const { type, rotation } = editor.getInstanceState().cursor;
    if (STATIC_CURSORS.includes(type)) {
      container.style.setProperty("--tl-cursor", `var(--tl-cursor-${type})`);
      return;
    }
    container.style.setProperty("--tl-cursor", getCursor(type, rotation, isDarkMode ? "white" : "black"));
  }, [editor, container, isDarkMode]);
}
var CORNER_SVG, EDGE_SVG, ROTATE_CORNER_SVG, STATIC_CURSORS, CURSORS;
var init_useCursor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useCursor.mjs"() {
    init_dist_esm9();
    init_utils();
    init_useContainer();
    init_useEditor();
    init_useIsDarkMode();
    CORNER_SVG = `<path d='m19.7432 17.0869-4.072 4.068 2.829 2.828-8.473-.013-.013-8.47 2.841 2.842 4.075-4.068 1.414-1.415-2.844-2.842h8.486v8.484l-2.83-2.827z' fill='%23fff'/><path d='m18.6826 16.7334-4.427 4.424 1.828 1.828-5.056-.016-.014-5.054 1.842 1.841 4.428-4.422 2.474-2.475-1.844-1.843h5.073v5.071l-1.83-1.828z' fill='%23000'/>`;
    EDGE_SVG = `<path d='m9 17.9907v.005l5.997 5.996.001-3.999h1.999 2.02v4l5.98-6.001-5.98-5.999.001 4.019-2.021.002h-2l.001-4.022zm1.411.003 3.587-3.588-.001 2.587h3.5 2.521v-2.585l3.565 3.586-3.564 3.585-.001-2.585h-2.521l-3.499-.001-.001 2.586z' fill='%23fff'/><path d='m17.4971 18.9932h2.521v2.586l3.565-3.586-3.565-3.585v2.605h-2.521-3.5v-2.607l-3.586 3.587 3.586 3.586v-2.587z' fill='%23000'/>`;
    ROTATE_CORNER_SVG = `<path d="M22.4789 9.45728L25.9935 12.9942L22.4789 16.5283V14.1032C18.126 14.1502 14.6071 17.6737 14.5675 22.0283H17.05L13.513 25.543L9.97889 22.0283H12.5674C12.6071 16.5691 17.0214 12.1503 22.4789 12.1031L22.4789 9.45728Z" fill="black"/><path fill-rule="evenodd" clip-rule="evenodd" d="M21.4789 7.03223L27.4035 12.9945L21.4789 18.9521V15.1868C18.4798 15.6549 16.1113 18.0273 15.649 21.0284H19.475L13.5128 26.953L7.55519 21.0284H11.6189C12.1243 15.8155 16.2679 11.6677 21.4789 11.1559L21.4789 7.03223ZM22.4789 12.1031C17.0214 12.1503 12.6071 16.5691 12.5674 22.0284H9.97889L13.513 25.543L17.05 22.0284H14.5675C14.5705 21.6896 14.5947 21.3558 14.6386 21.0284C15.1157 17.4741 17.9266 14.6592 21.4789 14.1761C21.8063 14.1316 22.1401 14.1069 22.4789 14.1032V16.5284L25.9935 12.9942L22.4789 9.45729L22.4789 12.1031Z" fill="white"/>`;
    STATIC_CURSORS = [
      "default",
      "pointer",
      "cross",
      "move",
      "grab",
      "grabbing",
      "text",
      "zoom-in",
      "zoom-out"
    ];
    CURSORS = {
      none: () => "none",
      "ew-resize": (r2, f2, c2) => getCursorCss(EDGE_SVG, r2, 0, f2, c2),
      "ns-resize": (r2, f2, c2) => getCursorCss(EDGE_SVG, r2, 90, f2, c2),
      "nesw-resize": (r2, f2, c2) => getCursorCss(CORNER_SVG, r2, 0, f2, c2),
      "nwse-resize": (r2, f2, c2) => getCursorCss(CORNER_SVG, r2, 90, f2, c2),
      "nwse-rotate": (r2, f2, c2) => getCursorCss(ROTATE_CORNER_SVG, r2, 0, f2, c2),
      "nesw-rotate": (r2, f2, c2) => getCursorCss(ROTATE_CORNER_SVG, r2, 90, f2, c2),
      "senw-rotate": (r2, f2, c2) => getCursorCss(ROTATE_CORNER_SVG, r2, 180, f2, c2),
      "swne-rotate": (r2, f2, c2) => getCursorCss(ROTATE_CORNER_SVG, r2, 270, f2, c2)
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useDarkMode.mjs
function useDarkMode() {
  const editor = useEditor();
  const container = useContainer();
  const isDarkMode = useIsDarkMode();
  const forceSrgb = useValue(debugFlags.forceSrgb);
  import_react36.default.useEffect(() => {
    if (isDarkMode) {
      container.setAttribute("data-color-mode", "dark");
      container.classList.remove("tl-theme__light");
      container.classList.add("tl-theme__dark");
    } else {
      container.setAttribute("data-color-mode", "light");
      container.classList.remove("tl-theme__dark");
      container.classList.add("tl-theme__light");
    }
    if (forceSrgb) {
      container.classList.add("tl-theme__force-sRGB");
    } else {
      container.classList.remove("tl-theme__force-sRGB");
    }
  }, [editor, container, forceSrgb, isDarkMode]);
}
var import_react36;
var init_useDarkMode = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useDarkMode.mjs"() {
    init_dist_esm9();
    import_react36 = __toESM(require_react(), 1);
    init_debug_flags();
    init_useContainer();
    init_useEditor();
    init_useIsDarkMode();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useEvent.mjs
function useEvent(handler) {
  const handlerRef = (0, import_react37.useRef)();
  (0, import_react37.useLayoutEffect)(() => {
    handlerRef.current = handler;
  });
  (0, import_react37.useDebugValue)(handler);
  return (0, import_react37.useCallback)((...args) => {
    const fn3 = handlerRef.current;
    assert(fn3, "fn does not exist");
    return fn3(...args);
  }, []);
}
var import_react37;
var init_useEvent = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useEvent.mjs"() {
    init_dist_esm2();
    import_react37 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useForceUpdate.mjs
function useForceUpdate() {
  const [_2, ss] = (0, import_react38.useState)(0);
  (0, import_react38.useEffect)(() => ss((s2) => s2 + 1), []);
}
var import_react38;
var init_useForceUpdate = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useForceUpdate.mjs"() {
    import_react38 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/config/createTLStore.mjs
function createTLSchemaFromUtils(opts) {
  if ("schema" in opts && opts.schema)
    return opts.schema;
  return createTLSchema({
    shapes: "shapeUtils" in opts && opts.shapeUtils ? utilsToMap(checkShapesAndAddCore(opts.shapeUtils)) : void 0,
    bindings: "bindingUtils" in opts && opts.bindingUtils ? utilsToMap(checkBindings(opts.bindingUtils)) : void 0,
    migrations: "migrations" in opts ? opts.migrations : void 0
  });
}
function createTLStore({
  initialData,
  defaultName = "",
  id,
  assets = inlineBase64AssetStore,
  onMount: onMount2,
  collaboration,
  ...rest
} = {}) {
  const schema = createTLSchemaFromUtils(rest);
  const store = new Store({
    id,
    schema,
    initialData,
    props: {
      defaultName,
      assets: {
        upload: assets.upload,
        resolve: assets.resolve ?? defaultAssetResolve
      },
      onMount: (editor) => {
        assert(editor instanceof Editor);
        onMount2?.(editor);
      },
      collaboration
    }
  });
  if (rest.snapshot) {
    if (initialData)
      throw new Error("Cannot provide both initialData and snapshot");
    loadSnapshot(store, rest.snapshot);
  }
  return store;
}
function utilsToMap(utils) {
  return Object.fromEntries(utils.map((s2) => [
    s2.type,
    {
      props: s2.props,
      migrations: s2.migrations
    }
  ]));
}
var defaultAssetResolve, inlineBase64AssetStore;
var init_createTLStore = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/config/createTLStore.mjs"() {
    init_dist_esm4();
    init_dist_esm8();
    init_dist_esm2();
    init_Editor();
    init_TLEditorSnapshot();
    init_defaultBindings();
    init_defaultShapes();
    defaultAssetResolve = (asset) => asset.props.src;
    inlineBase64AssetStore = {
      upload: (_2, file) => FileHelpers.blobToDataUrl(file)
    };
  }
});

// node_modules/idb/build/wrap-idb-value.js
function getIdbProxyableTypes() {
  return idbProxyableTypes || (idbProxyableTypes = [
    IDBDatabase,
    IDBObjectStore,
    IDBIndex,
    IDBCursor,
    IDBTransaction
  ]);
}
function getCursorAdvanceMethods() {
  return cursorAdvanceMethods || (cursorAdvanceMethods = [
    IDBCursor.prototype.advance,
    IDBCursor.prototype.continue,
    IDBCursor.prototype.continuePrimaryKey
  ]);
}
function promisifyRequest(request2) {
  const promise = new Promise((resolve, reject) => {
    const unlisten = () => {
      request2.removeEventListener("success", success);
      request2.removeEventListener("error", error2);
    };
    const success = () => {
      resolve(wrap(request2.result));
      unlisten();
    };
    const error2 = () => {
      reject(request2.error);
      unlisten();
    };
    request2.addEventListener("success", success);
    request2.addEventListener("error", error2);
  });
  promise.then((value) => {
    if (value instanceof IDBCursor) {
      cursorRequestMap.set(value, request2);
    }
  }).catch(() => {
  });
  reverseTransformCache.set(promise, request2);
  return promise;
}
function cacheDonePromiseForTransaction(tx) {
  if (transactionDoneMap.has(tx))
    return;
  const done = new Promise((resolve, reject) => {
    const unlisten = () => {
      tx.removeEventListener("complete", complete);
      tx.removeEventListener("error", error2);
      tx.removeEventListener("abort", error2);
    };
    const complete = () => {
      resolve();
      unlisten();
    };
    const error2 = () => {
      reject(tx.error || new DOMException("AbortError", "AbortError"));
      unlisten();
    };
    tx.addEventListener("complete", complete);
    tx.addEventListener("error", error2);
    tx.addEventListener("abort", error2);
  });
  transactionDoneMap.set(tx, done);
}
function replaceTraps(callback) {
  idbProxyTraps = callback(idbProxyTraps);
}
function wrapFunction(func) {
  if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
    return function(storeNames, ...args) {
      const tx = func.call(unwrap(this), storeNames, ...args);
      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
      return wrap(tx);
    };
  }
  if (getCursorAdvanceMethods().includes(func)) {
    return function(...args) {
      func.apply(unwrap(this), args);
      return wrap(cursorRequestMap.get(this));
    };
  }
  return function(...args) {
    return wrap(func.apply(unwrap(this), args));
  };
}
function transformCachableValue(value) {
  if (typeof value === "function")
    return wrapFunction(value);
  if (value instanceof IDBTransaction)
    cacheDonePromiseForTransaction(value);
  if (instanceOfAny(value, getIdbProxyableTypes()))
    return new Proxy(value, idbProxyTraps);
  return value;
}
function wrap(value) {
  if (value instanceof IDBRequest)
    return promisifyRequest(value);
  if (transformCache.has(value))
    return transformCache.get(value);
  const newValue = transformCachableValue(value);
  if (newValue !== value) {
    transformCache.set(value, newValue);
    reverseTransformCache.set(newValue, value);
  }
  return newValue;
}
var instanceOfAny, idbProxyableTypes, cursorAdvanceMethods, cursorRequestMap, transactionDoneMap, transactionStoreNamesMap, transformCache, reverseTransformCache, idbProxyTraps, unwrap;
var init_wrap_idb_value = __esm({
  "node_modules/idb/build/wrap-idb-value.js"() {
    instanceOfAny = (object2, constructors) => constructors.some((c2) => object2 instanceof c2);
    cursorRequestMap = /* @__PURE__ */ new WeakMap();
    transactionDoneMap = /* @__PURE__ */ new WeakMap();
    transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
    transformCache = /* @__PURE__ */ new WeakMap();
    reverseTransformCache = /* @__PURE__ */ new WeakMap();
    idbProxyTraps = {
      get(target, prop, receiver) {
        if (target instanceof IDBTransaction) {
          if (prop === "done")
            return transactionDoneMap.get(target);
          if (prop === "objectStoreNames") {
            return target.objectStoreNames || transactionStoreNamesMap.get(target);
          }
          if (prop === "store") {
            return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
          }
        }
        return wrap(target[prop]);
      },
      set(target, prop, value) {
        target[prop] = value;
        return true;
      },
      has(target, prop) {
        if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
          return true;
        }
        return prop in target;
      }
    };
    unwrap = (value) => reverseTransformCache.get(value);
  }
});

// node_modules/idb/build/index.js
function openDB(name, version2, { blocked, upgrade, blocking, terminated } = {}) {
  const request2 = indexedDB.open(name, version2);
  const openPromise = wrap(request2);
  if (upgrade) {
    request2.addEventListener("upgradeneeded", (event) => {
      upgrade(wrap(request2.result), event.oldVersion, event.newVersion, wrap(request2.transaction), event);
    });
  }
  if (blocked) {
    request2.addEventListener("blocked", (event) => blocked(event.oldVersion, event.newVersion, event));
  }
  openPromise.then((db) => {
    if (terminated)
      db.addEventListener("close", () => terminated());
    if (blocking) {
      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
    }
  }).catch(() => {
  });
  return openPromise;
}
function deleteDB(name, { blocked } = {}) {
  const request2 = indexedDB.deleteDatabase(name);
  if (blocked) {
    request2.addEventListener("blocked", (event) => blocked(event.oldVersion, event));
  }
  return wrap(request2).then(() => void 0);
}
function getMethod(target, prop) {
  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
    return;
  }
  if (cachedMethods.get(prop))
    return cachedMethods.get(prop);
  const targetFuncName = prop.replace(/FromIndex$/, "");
  const useIndex = prop !== targetFuncName;
  const isWrite = writeMethods.includes(targetFuncName);
  if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
    return;
  }
  const method = async function(storeName, ...args) {
    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
    let target2 = tx.store;
    if (useIndex)
      target2 = target2.index(args.shift());
    return (await Promise.all([
      target2[targetFuncName](...args),
      isWrite && tx.done
    ]))[0];
  };
  cachedMethods.set(prop, method);
  return method;
}
var readMethods, writeMethods, cachedMethods;
var init_build = __esm({
  "node_modules/idb/build/index.js"() {
    init_wrap_idb_value();
    init_wrap_idb_value();
    readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
    writeMethods = ["put", "add", "delete", "clear"];
    cachedMethods = /* @__PURE__ */ new Map();
    replaceTraps((oldTraps) => ({
      ...oldTraps,
      get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
      has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
    }));
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/sync/LocalIndexedDb.mjs
async function openLocalDb(persistenceKey) {
  const storeId = STORE_PREFIX + persistenceKey;
  addDbName(storeId);
  return await openDB(storeId, 4, {
    upgrade(database) {
      if (!database.objectStoreNames.contains(Table.Records)) {
        database.createObjectStore(Table.Records);
      }
      if (!database.objectStoreNames.contains(Table.Schema)) {
        database.createObjectStore(Table.Schema);
      }
      if (!database.objectStoreNames.contains(Table.SessionState)) {
        database.createObjectStore(Table.SessionState);
      }
      if (!database.objectStoreNames.contains(Table.Assets)) {
        database.createObjectStore(Table.Assets);
      }
    }
  });
}
async function migrateLegacyAssetDbIfNeeded(persistenceKey) {
  const databases = window.indexedDB.databases ? (await window.indexedDB.databases()).map((db) => db.name) : getAllIndexDbNames();
  const oldStoreId = LEGACY_ASSET_STORE_PREFIX + persistenceKey;
  const existing = databases.find((dbName) => dbName === oldStoreId);
  if (!existing)
    return;
  const oldAssetDb = await openDB(oldStoreId, 1, {
    upgrade(database) {
      if (!database.objectStoreNames.contains("assets")) {
        database.createObjectStore("assets");
      }
    }
  });
  const oldTx = oldAssetDb.transaction(["assets"], "readonly");
  const oldAssetStore = oldTx.objectStore("assets");
  const oldAssetsKeys = await oldAssetStore.getAllKeys();
  const oldAssets = await Promise.all(oldAssetsKeys.map(async (key) => [key, await oldAssetStore.get(key)]));
  await oldTx.done;
  const newDb = await openLocalDb(persistenceKey);
  const newTx = newDb.transaction([Table.Assets], "readwrite");
  const newAssetTable = newTx.objectStore(Table.Assets);
  for (const [key, value] of oldAssets) {
    newAssetTable.put(value, key);
  }
  await newTx.done;
  oldAssetDb.close();
  newDb.close();
  await deleteDB(oldStoreId);
}
function getAllIndexDbNames() {
  const result = JSON.parse(getFromLocalStorage(dbNameIndexKey) || "[]") ?? [];
  if (!Array.isArray(result)) {
    return [];
  }
  return result;
}
function addDbName(name) {
  const all = new Set(getAllIndexDbNames());
  all.add(name);
  setInLocalStorage(dbNameIndexKey, JSON.stringify([...all]));
}
var STORE_PREFIX, LEGACY_ASSET_STORE_PREFIX, dbNameIndexKey, Table, _LocalIndexedDb, LocalIndexedDb;
var init_LocalIndexedDb = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/sync/LocalIndexedDb.mjs"() {
    init_dist_esm2();
    init_build();
    STORE_PREFIX = "TLDRAW_DOCUMENT_v2";
    LEGACY_ASSET_STORE_PREFIX = "TLDRAW_ASSET_STORE_v1";
    dbNameIndexKey = "TLDRAW_DB_NAME_INDEX_v2";
    Table = {
      Records: "records",
      Schema: "schema",
      SessionState: "session_state",
      Assets: "assets"
    };
    _LocalIndexedDb = class {
      constructor(persistenceKey) {
        __publicField(this, "getDbPromise");
        __publicField(this, "isClosed", false);
        __publicField(this, "pendingTransactionSet", /* @__PURE__ */ new Set());
        _LocalIndexedDb.connectedInstances.add(this);
        this.getDbPromise = (async () => {
          await migrateLegacyAssetDbIfNeeded(persistenceKey);
          return await openLocalDb(persistenceKey);
        })();
      }
      getDb() {
        return this.getDbPromise;
      }
      pending() {
        return Promise.allSettled([this.getDbPromise, ...this.pendingTransactionSet]).then(noop);
      }
      async close() {
        if (this.isClosed)
          return;
        this.isClosed = true;
        await this.pending();
        (await this.getDb()).close();
        _LocalIndexedDb.connectedInstances.delete(this);
      }
      tx(mode, names, cb) {
        const txPromise = (async () => {
          assert(!this.isClosed, "db is closed");
          const db = await this.getDb();
          const tx = db.transaction(names, mode);
          const done = tx.done.catch((e2) => {
            if (!this.isClosed) {
              throw e2;
            }
          });
          try {
            return await cb(tx);
          } finally {
            if (!this.isClosed) {
              await done;
            } else {
              tx.abort();
            }
          }
        })();
        this.pendingTransactionSet.add(txPromise);
        txPromise.finally(() => this.pendingTransactionSet.delete(txPromise));
        return txPromise;
      }
      async load({ sessionId } = {}) {
        return await this.tx("readonly", [Table.Records, Table.Schema, Table.SessionState], async (tx) => {
          const recordsStore = tx.objectStore(Table.Records);
          const schemaStore = tx.objectStore(Table.Schema);
          const sessionStateStore = tx.objectStore(Table.SessionState);
          let sessionStateSnapshot = sessionId ? (await sessionStateStore.get(sessionId))?.snapshot : null;
          if (!sessionStateSnapshot) {
            const all = await sessionStateStore.getAll();
            sessionStateSnapshot = all.sort((a2, b2) => a2.updatedAt - b2.updatedAt).pop()?.snapshot;
          }
          const result = {
            records: await recordsStore.getAll(),
            schema: await schemaStore.get(Table.Schema),
            sessionStateSnapshot
          };
          return result;
        });
      }
      async storeChanges({
        schema,
        changes,
        sessionId,
        sessionStateSnapshot
      }) {
        await this.tx("readwrite", [Table.Records, Table.Schema, Table.SessionState], async (tx) => {
          const recordsStore = tx.objectStore(Table.Records);
          const schemaStore = tx.objectStore(Table.Schema);
          const sessionStateStore = tx.objectStore(Table.SessionState);
          for (const [id, record] of Object.entries(changes.added)) {
            await recordsStore.put(record, id);
          }
          for (const [_prev, updated] of Object.values(changes.updated)) {
            await recordsStore.put(updated, updated.id);
          }
          for (const id of Object.keys(changes.removed)) {
            await recordsStore.delete(id);
          }
          schemaStore.put(schema.serialize(), Table.Schema);
          if (sessionStateSnapshot && sessionId) {
            sessionStateStore.put({
              snapshot: sessionStateSnapshot,
              updatedAt: Date.now(),
              id: sessionId
            }, sessionId);
          } else if (sessionStateSnapshot || sessionId) {
            console.error("sessionStateSnapshot and instanceId must be provided together");
          }
        });
      }
      async storeSnapshot({
        schema,
        snapshot,
        sessionId,
        sessionStateSnapshot
      }) {
        await this.tx("readwrite", [Table.Records, Table.Schema, Table.SessionState], async (tx) => {
          const recordsStore = tx.objectStore(Table.Records);
          const schemaStore = tx.objectStore(Table.Schema);
          const sessionStateStore = tx.objectStore(Table.SessionState);
          await recordsStore.clear();
          for (const [id, record] of Object.entries(snapshot)) {
            await recordsStore.put(record, id);
          }
          schemaStore.put(schema.serialize(), Table.Schema);
          if (sessionStateSnapshot && sessionId) {
            sessionStateStore.put({
              snapshot: sessionStateSnapshot,
              updatedAt: Date.now(),
              id: sessionId
            }, sessionId);
          } else if (sessionStateSnapshot || sessionId) {
            console.error("sessionStateSnapshot and instanceId must be provided together");
          }
        });
      }
      async pruneSessions() {
        await this.tx("readwrite", [Table.SessionState], async (tx) => {
          const sessionStateStore = tx.objectStore(Table.SessionState);
          const all = (await sessionStateStore.getAll()).sort((a2, b2) => a2.updatedAt - b2.updatedAt);
          if (all.length < 10) {
            await tx.done;
            return;
          }
          const toDelete = all.slice(0, all.length - 10);
          for (const { id } of toDelete) {
            await sessionStateStore.delete(id);
          }
        });
      }
      async getAsset(assetId) {
        return await this.tx("readonly", [Table.Assets], async (tx) => {
          const assetsStore = tx.objectStore(Table.Assets);
          return await assetsStore.get(assetId);
        });
      }
      async storeAsset(assetId, blob) {
        await this.tx("readwrite", [Table.Assets], async (tx) => {
          const assetsStore = tx.objectStore(Table.Assets);
          await assetsStore.put(blob, assetId);
        });
      }
    };
    LocalIndexedDb = _LocalIndexedDb;
    __publicField(LocalIndexedDb, "connectedInstances", /* @__PURE__ */ new Set());
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/sync/alerts.mjs
function showCantWriteToIndexDbAlert() {
  window.alert(`Oops! We could not save changes to your browser's storage. We now need to reload the page and try again.

Keep seeing this message?
\u2022 If you're using tldraw in a private or "incognito" window, try loading tldraw in a regular window or in a different browser.
\u2022 If your hard disk is full, try clearing up some space and then reload the page.`);
}
function showCantReadFromIndexDbAlert() {
  window.alert(`Oops! We could not access your browser's storage\u2014and the app won't work correctly without that. We now need to reload the page and try again.

Keep seeing this message?
\u2022 If you're using tldraw in a private or "incognito" window, try loading tldraw in a regular window or in a different browser.`);
}
var init_alerts = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/sync/alerts.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/sync/TLLocalSyncClient.mjs
var PERSIST_THROTTLE_MS, PERSIST_RETRY_THROTTLE_MS, UPDATE_INSTANCE_STATE, msg, BroadcastChannelMock, BC, TLLocalSyncClient;
var init_TLLocalSyncClient = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/sync/TLLocalSyncClient.mjs"() {
    init_dist_esm();
    init_dist_esm4();
    init_dist_esm2();
    init_TLSessionStateSnapshot();
    init_LocalIndexedDb();
    init_alerts();
    PERSIST_THROTTLE_MS = 350;
    PERSIST_RETRY_THROTTLE_MS = 1e4;
    UPDATE_INSTANCE_STATE = Symbol("UPDATE_INSTANCE_STATE");
    msg = (msg2) => msg2;
    BroadcastChannelMock = class {
      constructor(_name) {
        __publicField(this, "onmessage");
      }
      postMessage(_msg) {
      }
      close() {
      }
    };
    BC = typeof BroadcastChannel === "undefined" ? BroadcastChannelMock : BroadcastChannel;
    TLLocalSyncClient = class {
      constructor(store, {
        persistenceKey,
        sessionId = TAB_ID,
        onLoad,
        onLoadError
      }, channel2 = new BC(`tldraw-tab-sync-${persistenceKey}`)) {
        __publicField(this, "disposables", /* @__PURE__ */ new Set());
        __publicField(this, "diffQueue", []);
        __publicField(this, "didDispose", false);
        __publicField(this, "shouldDoFullDBWrite", true);
        __publicField(this, "isReloading", false);
        __publicField(this, "persistenceKey");
        __publicField(this, "sessionId");
        __publicField(this, "serializedSchema");
        __publicField(this, "isDebugging", false);
        __publicField(this, "documentTypes");
        __publicField(this, "$sessionStateSnapshot");
        __publicField(this, "db");
        __publicField(this, "initTime", Date.now());
        __publicField(this, "isPersisting", false);
        __publicField(this, "didLastWriteError", false);
        __publicField(this, "scheduledPersistTimeout", null);
        this.store = store;
        this.channel = channel2;
        if (typeof window !== "undefined") {
          ;
          window.tlsync = this;
        }
        this.persistenceKey = persistenceKey;
        this.sessionId = sessionId;
        this.db = new LocalIndexedDb(persistenceKey);
        this.disposables.add(() => this.db.close());
        this.serializedSchema = this.store.schema.serialize();
        this.$sessionStateSnapshot = createSessionStateSnapshotSignal(this.store);
        this.disposables.add(store.listen(({ changes }) => {
          this.diffQueue.push(changes);
          this.channel.postMessage(msg({
            type: "diff",
            storeId: this.store.id,
            changes,
            schema: this.serializedSchema
          }));
          this.schedulePersist();
        }, { source: "user", scope: "document" }));
        this.disposables.add(store.listen(() => {
          this.diffQueue.push(UPDATE_INSTANCE_STATE);
          this.schedulePersist();
        }, { scope: "session" }));
        this.connect(onLoad, onLoadError);
        this.documentTypes = new Set(Object.values(this.store.schema.types).filter((t3) => t3.scope === "document").map((t3) => t3.typeName));
      }
      debug(...args) {
        if (this.isDebugging) {
          console.debug(...args);
        }
      }
      async connect(onLoad, onLoadError) {
        this.debug("connecting");
        let data;
        try {
          data = await this.db.load({ sessionId: this.sessionId });
        } catch (error2) {
          onLoadError(error2);
          showCantReadFromIndexDbAlert();
          return;
        }
        this.debug("loaded data from store", data, "didDispose", this.didDispose);
        if (this.didDispose)
          return;
        try {
          if (data) {
            const documentSnapshot = Object.fromEntries(data.records.map((r2) => [r2.id, r2]));
            const sessionStateSnapshot = data.sessionStateSnapshot ?? extractSessionStateFromLegacySnapshot(documentSnapshot);
            const migrationResult = this.store.schema.migrateStoreSnapshot({
              store: documentSnapshot,
              schema: data.schema ?? this.store.schema.serializeEarliestVersion()
            });
            if (migrationResult.type === "error") {
              console.error("failed to migrate store", migrationResult);
              onLoadError(new Error(`Failed to migrate store: ${migrationResult.reason}`));
              return;
            }
            this.store.mergeRemoteChanges(() => {
              this.store.put(Object.values(migrationResult.value).filter((r2) => this.documentTypes.has(r2.typeName)), "initialize");
            });
            if (sessionStateSnapshot) {
              loadSessionStateSnapshotIntoStore(this.store, sessionStateSnapshot);
            }
          }
          this.channel.onmessage = ({ data: data2 }) => {
            this.debug("got message", data2);
            const msg2 = data2;
            const res = this.store.schema.getMigrationsSince(msg2.schema);
            if (!res.ok) {
              const timeSinceInit = Date.now() - this.initTime;
              if (timeSinceInit < 5e3) {
                onLoadError(new Error("Schema mismatch, please close other tabs and reload the page"));
                return;
              }
              this.debug("reloading");
              this.isReloading = true;
              window?.location?.reload?.();
              return;
            } else if (res.value.length > 0) {
              this.debug("telling them to reload");
              this.channel.postMessage({ type: "announce", schema: this.serializedSchema });
              this.shouldDoFullDBWrite = true;
              this.persistIfNeeded();
              return;
            }
            if (msg2.type === "diff") {
              this.debug("applying diff");
              transact(() => {
                this.store.mergeRemoteChanges(() => {
                  this.store.applyDiff(msg2.changes);
                  this.store.ensureStoreIsUsable();
                });
              });
            }
          };
          this.channel.postMessage({ type: "announce", schema: this.serializedSchema });
          this.disposables.add(() => {
            this.channel.close();
          });
          onLoad(this);
        } catch (e2) {
          this.debug("error loading data from store", e2);
          if (this.didDispose)
            return;
          onLoadError(e2);
          return;
        }
      }
      close() {
        this.debug("closing");
        this.didDispose = true;
        this.disposables.forEach((d2) => d2());
      }
      schedulePersist() {
        this.debug("schedulePersist", this.scheduledPersistTimeout);
        if (this.scheduledPersistTimeout)
          return;
        this.scheduledPersistTimeout = setTimeout(() => {
          this.scheduledPersistTimeout = null;
          this.persistIfNeeded();
        }, this.didLastWriteError ? PERSIST_RETRY_THROTTLE_MS : PERSIST_THROTTLE_MS);
      }
      persistIfNeeded() {
        this.debug("persistIfNeeded", {
          isPersisting: this.isPersisting,
          isReloading: this.isReloading,
          shouldDoFullDBWrite: this.shouldDoFullDBWrite,
          diffQueueLength: this.diffQueue.length,
          storeIsPossiblyCorrupt: this.store.isPossiblyCorrupted()
        });
        if (this.scheduledPersistTimeout) {
          clearTimeout(this.scheduledPersistTimeout);
          this.scheduledPersistTimeout = null;
        }
        if (this.isPersisting)
          return;
        if (this.isReloading)
          return;
        if (this.store.isPossiblyCorrupted())
          return;
        if (this.shouldDoFullDBWrite || this.diffQueue.length > 0) {
          this.doPersist();
        }
      }
      async doPersist() {
        assert(!this.isPersisting, "persist already in progress");
        if (this.didDispose)
          return;
        this.isPersisting = true;
        this.debug("doPersist start");
        const diffQueue = this.diffQueue;
        this.diffQueue = [];
        try {
          if (this.shouldDoFullDBWrite) {
            this.shouldDoFullDBWrite = false;
            await this.db.storeSnapshot({
              schema: this.store.schema,
              snapshot: this.store.serialize(),
              sessionId: this.sessionId,
              sessionStateSnapshot: this.$sessionStateSnapshot.get()
            });
          } else {
            const diffs = squashRecordDiffs(diffQueue.filter((d2) => d2 !== UPDATE_INSTANCE_STATE));
            await this.db.storeChanges({
              changes: diffs,
              schema: this.store.schema,
              sessionId: this.sessionId,
              sessionStateSnapshot: this.$sessionStateSnapshot.get()
            });
          }
          this.didLastWriteError = false;
        } catch (e2) {
          this.shouldDoFullDBWrite = true;
          this.didLastWriteError = true;
          console.error("failed to store changes in indexed db", e2);
          showCantWriteToIndexDbAlert();
          if (typeof window !== "undefined") {
            window.location.reload();
          }
        }
        this.isPersisting = false;
        this.debug("doPersist end");
        this.schedulePersist();
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useRefState.mjs
function useRefState(initialValue) {
  const ref = (0, import_react39.useRef)(initialValue);
  const [state, setState] = (0, import_react39.useState)(initialValue);
  if (state !== ref.current) {
    setState(ref.current);
  }
  const update = (0, import_react39.useCallback)((value) => {
    if (typeof value === "function") {
      ref.current = value(ref.current);
    } else {
      ref.current = value;
    }
    setState(ref.current);
  }, []);
  return [state, update];
}
var import_react39;
var init_useRefState = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useRefState.mjs"() {
    import_react39 = __toESM(require_react(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useLocalStore.mjs
function useLocalStore(options) {
  const [state, setState] = useRefState({ status: "loading" });
  options = useShallowObjectIdentity(options);
  (0, import_react40.useEffect)(() => {
    const { persistenceKey, sessionId, ...rest } = options;
    if (!persistenceKey) {
      setState({
        status: "not-synced",
        store: createTLStore(rest)
      });
      return;
    }
    setState({ status: "loading" });
    const objectURLCache = new WeakCache();
    const assets = {
      upload: async (asset, file) => {
        await client.db.storeAsset(asset.id, file);
        return asset.id;
      },
      resolve: async (asset) => {
        if (!asset.props.src)
          return null;
        if (asset.props.src.startsWith("asset:")) {
          return await objectURLCache.get(asset, async () => {
            const blob = await client.db.getAsset(asset.id);
            if (!blob)
              return null;
            return URL.createObjectURL(blob);
          });
        }
        return asset.props.src;
      },
      ...rest.assets
    };
    const store = createTLStore({ ...rest, assets });
    let isClosed = false;
    const client = new TLLocalSyncClient(store, {
      sessionId,
      persistenceKey,
      onLoad() {
        if (isClosed)
          return;
        setState({ store, status: "synced-local" });
      },
      onLoadError(err) {
        if (isClosed)
          return;
        setState({ status: "error", error: err });
      }
    });
    return () => {
      isClosed = true;
      client.close();
    };
  }, [options, setState]);
  return state;
}
var import_react40;
var init_useLocalStore = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useLocalStore.mjs"() {
    init_dist_esm2();
    import_react40 = __toESM(require_react(), 1);
    init_createTLStore();
    init_TLLocalSyncClient();
    init_useIdentity();
    init_useRefState();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useZoomCss.mjs
function useZoomCss() {
  const editor = useEditor();
  const container = useContainer();
  React10.useEffect(() => {
    const setScale = (s2) => container.style.setProperty("--tl-zoom", s2.toString());
    const setScaleDebounced = debounce(setScale, 100);
    const scheduler = new EffectScheduler("useZoomCss", () => {
      const numShapes = editor.getCurrentPageShapeIds().size;
      if (numShapes < 300) {
        setScale(editor.getZoomLevel());
      } else {
        setScaleDebounced(editor.getZoomLevel());
      }
    });
    scheduler.attach();
    scheduler.execute();
    return () => {
      scheduler.detach();
      setScaleDebounced.cancel();
    };
  }, [editor, container]);
}
var React10;
var init_useZoomCss = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useZoomCss.mjs"() {
    init_dist_esm();
    init_dist_esm2();
    React10 = __toESM(require_react(), 1);
    init_useContainer();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/licensing.mjs
function str2ab(str) {
  const buf = new ArrayBuffer(str.length);
  const bufView = new Uint8Array(buf);
  for (let i2 = 0, strLen = str.length; i2 < strLen; i2++) {
    bufView[i2] = str.charCodeAt(i2);
  }
  return buf;
}
function importPublicKey(pemContents) {
  const binaryDerString = atob(pemContents);
  const binaryDer = str2ab(binaryDerString);
  return crypto.subtle.importKey("spki", new Uint8Array(binaryDer), {
    name: "ECDSA",
    namedCurve: "P-256"
  }, true, ["verify"]);
}
var init_licensing = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/licensing.mjs"() {
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/license/LicenseManager.mjs
function isEditorUnlicensed(result) {
  if (!result.isLicenseParseable)
    return true;
  if (!result.isDomainValid && !result.isDevelopment)
    return true;
  if (result.isPerpetualLicenseExpired || result.isAnnualLicenseExpired) {
    if (result.isInternalLicense) {
      throw new Error("License: Internal license expired.");
    }
    return true;
  }
  return false;
}
var GRACE_PERIOD_DAYS, FLAGS, HIGHEST_FLAG, PROPERTIES, NUMBER_OF_KNOWN_PROPERTIES, LICENSE_EMAIL, LicenseManager;
var init_LicenseManager = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/license/LicenseManager.mjs"() {
    init_dist_esm();
    init_version();
    init_debug_flags();
    init_licensing();
    GRACE_PERIOD_DAYS = 5;
    FLAGS = {
      ANNUAL_LICENSE: 1,
      PERPETUAL_LICENSE: 2,
      INTERNAL_LICENSE: 4
    };
    HIGHEST_FLAG = Math.max(...Object.values(FLAGS));
    PROPERTIES = {
      ID: 0,
      HOSTS: 1,
      FLAGS: 2,
      EXPIRY_DATE: 3
    };
    NUMBER_OF_KNOWN_PROPERTIES = Object.keys(PROPERTIES).length;
    LICENSE_EMAIL = "sales@tldraw.com";
    LicenseManager = class {
      constructor(licenseKey, testPublicKey, testEnvironment) {
        __publicField(this, "publicKey", "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHJh0uUfxHtCGyerXmmatE368Hd9rI6LH9oPDQihnaCryRFWEVeOvf9U/SPbyxX74LFyJs5tYeAHq5Nc0Ax25LQ");
        __publicField(this, "isDevelopment");
        __publicField(this, "isTest");
        __publicField(this, "isCryptoAvailable");
        __publicField(this, "state", atom2("license state", "pending"));
        this.isTest = false;
        this.isDevelopment = this.getIsDevelopment(testEnvironment);
        this.publicKey = testPublicKey || this.publicKey;
        this.isCryptoAvailable = !!crypto.subtle;
        if (!featureFlags.enableLicensing.get()) {
          this.state.set("licensed");
        } else {
          this.getLicenseFromKey(licenseKey).then((result) => {
            const isUnlicensed = isEditorUnlicensed(result);
            this.state.set(isUnlicensed ? "unlicensed" : "licensed");
            if (isUnlicensed) {
            }
          });
        }
      }
      getIsDevelopment(testEnvironment) {
        if (testEnvironment === "development")
          return true;
        if (testEnvironment === "production")
          return false;
        return window.location.protocol !== "https:";
      }
      async extractLicenseKey(licenseKey) {
        const [data, signature] = licenseKey.split(".");
        const [prefix, encodedData] = data.split("/");
        if (!prefix.startsWith("tldraw-")) {
          throw new Error(`Unsupported prefix '${prefix}'`);
        }
        const publicCryptoKey = await importPublicKey(this.publicKey);
        let isVerified;
        try {
          isVerified = await crypto.subtle.verify({
            name: "ECDSA",
            hash: { name: "SHA-256" }
          }, publicCryptoKey, new Uint8Array(str2ab(atob(signature))), new Uint8Array(str2ab(atob(encodedData))));
        } catch (e2) {
          console.error(e2);
          throw new Error("Could not perform signature validation");
        }
        if (!isVerified) {
          throw new Error("Invalid signature");
        }
        let decodedData;
        try {
          decodedData = JSON.parse(atob(encodedData));
        } catch (e2) {
          throw new Error("Could not parse object");
        }
        if (decodedData.length > NUMBER_OF_KNOWN_PROPERTIES) {
          this.outputMessages([
            "License key contains some unknown properties.",
            "You may want to update tldraw packages to a newer version to get access to new functionality."
          ]);
        }
        return {
          id: decodedData[PROPERTIES.ID],
          hosts: decodedData[PROPERTIES.HOSTS],
          flags: decodedData[PROPERTIES.FLAGS],
          expiryDate: decodedData[PROPERTIES.EXPIRY_DATE]
        };
      }
      async getLicenseFromKey(licenseKey) {
        if (!licenseKey) {
          if (!this.isDevelopment) {
            this.outputNoLicenseKeyProvided();
          }
          return { isLicenseParseable: false, reason: "no-key-provided" };
        }
        if (this.isDevelopment && !this.isCryptoAvailable) {
          console.log("tldraw: you seem to be in a development environment that does not support crypto. License not verified.");
          console.log("You should check that this works in production separately.");
          return { isLicenseParseable: false, reason: "has-key-development-mode" };
        }
        let cleanedLicenseKey = licenseKey.replace(/[\u200B-\u200D\uFEFF]/g, "");
        cleanedLicenseKey = cleanedLicenseKey.replace(/\r?\n|\r/g, "");
        try {
          const licenseInfo = await this.extractLicenseKey(cleanedLicenseKey);
          const expiryDate = new Date(licenseInfo.expiryDate);
          const isAnnualLicense = this.isFlagEnabled(licenseInfo.flags, FLAGS.ANNUAL_LICENSE);
          const isPerpetualLicense = this.isFlagEnabled(licenseInfo.flags, FLAGS.PERPETUAL_LICENSE);
          const result = {
            license: licenseInfo,
            isLicenseParseable: true,
            isDevelopment: this.isDevelopment,
            isDomainValid: this.isDomainValid(licenseInfo),
            expiryDate,
            isAnnualLicense,
            isAnnualLicenseExpired: isAnnualLicense && this.isAnnualLicenseExpired(expiryDate),
            isPerpetualLicense,
            isPerpetualLicenseExpired: isPerpetualLicense && this.isPerpetualLicenseExpired(expiryDate),
            isInternalLicense: this.isFlagEnabled(licenseInfo.flags, FLAGS.INTERNAL_LICENSE)
          };
          this.outputLicenseInfoIfNeeded(result);
          return result;
        } catch (e2) {
          this.outputInvalidLicenseKey(e2.message);
          return { isLicenseParseable: false, reason: "invalid-license-key" };
        }
      }
      isDomainValid(licenseInfo) {
        const currentHostname = window.location.hostname.toLowerCase();
        return licenseInfo.hosts.some((host) => {
          const normalizedHost = host.toLowerCase().trim();
          if (normalizedHost === currentHostname || `www.${normalizedHost}` === currentHostname || normalizedHost === `www.${currentHostname}`) {
            return true;
          }
          if (host === "*") {
            return true;
          }
          if (host.includes("*")) {
            const globToRegex = new RegExp(host.replace(/\*/g, ".*?"));
            return globToRegex.test(currentHostname);
          }
          return false;
        });
      }
      getExpirationDateWithoutGracePeriod(expiryDate) {
        return new Date(expiryDate.getFullYear(), expiryDate.getMonth(), expiryDate.getDate());
      }
      getExpirationDateWithGracePeriod(expiryDate) {
        return new Date(expiryDate.getFullYear(), expiryDate.getMonth(), expiryDate.getDate() + GRACE_PERIOD_DAYS + 1);
      }
      isAnnualLicenseExpired(expiryDate) {
        const expiration = this.getExpirationDateWithGracePeriod(expiryDate);
        const isExpired = /* @__PURE__ */ new Date() >= expiration;
        if (!isExpired && /* @__PURE__ */ new Date() >= this.getExpirationDateWithoutGracePeriod(expiryDate)) {
          this.outputMessages([
            "tldraw license is about to expire, you are in a grace period.",
            `Please reach out to ${LICENSE_EMAIL} if you would like to renew your license.`
          ]);
        }
        return isExpired;
      }
      isPerpetualLicenseExpired(expiryDate) {
        const expiration = this.getExpirationDateWithGracePeriod(expiryDate);
        const dates = {
          major: new Date(publishDates.major),
          minor: new Date(publishDates.minor)
        };
        return dates.major >= expiration || dates.minor >= expiration;
      }
      isFlagEnabled(flags, flag) {
        return (flags & flag) === flag;
      }
      outputNoLicenseKeyProvided() {
        this.outputMessages([
          "No tldraw license key provided!",
          `Please reach out to ${LICENSE_EMAIL} if you would like to license tldraw or if you'd like a trial.`
        ]);
      }
      outputInvalidLicenseKey(msg2) {
        this.outputMessages(["Invalid tldraw license key", `Reason: ${msg2}`]);
      }
      outputLicenseInfoIfNeeded(result) {
        if (result.isAnnualLicenseExpired) {
          this.outputMessages([
            "Your tldraw license has expired!",
            `Please reach out to ${LICENSE_EMAIL} to renew.`
          ]);
        }
        if (!result.isDomainValid && !result.isDevelopment) {
          this.outputMessages([
            "This tldraw license key is not valid for this domain!",
            `Please reach out to ${LICENSE_EMAIL} if you would like to use tldraw on other domains.`
          ]);
        }
        if (result.license.flags >= HIGHEST_FLAG * 2) {
          this.outputMessages([
            "This tldraw license contains some unknown flags.",
            "You may want to update tldraw packages to a newer version to get access to new functionality."
          ]);
        }
      }
      outputMessages(messages) {
        if (this.isTest)
          return;
        this.outputDelimiter();
        for (const message of messages) {
          console.log(`%c${message}`, `color: white; background: crimson; padding: 2px; border-radius: 3px;`);
        }
        this.outputDelimiter();
      }
      outputDelimiter() {
        console.log("%c-------------------------------------------------------------------", `color: white; background: crimson; padding: 2px; border-radius: 3px;`);
      }
    };
    __publicField(LicenseManager, "className", "tl-watermark_SEE-LICENSE");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/license/LicenseProvider.mjs
function LicenseProvider({
  licenseKey,
  children
}) {
  const [licenseManager] = (0, import_react41.useState)(() => new LicenseManager(licenseKey));
  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(LicenseContext.Provider, { value: licenseManager, children });
}
var import_jsx_runtime31, import_react41, LicenseContext, useLicenseContext;
var init_LicenseProvider = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/license/LicenseProvider.mjs"() {
    import_jsx_runtime31 = __toESM(require_jsx_runtime(), 1);
    import_react41 = __toESM(require_react(), 1);
    init_LicenseManager();
    LicenseContext = (0, import_react41.createContext)({});
    useLicenseContext = () => (0, import_react41.useContext)(LicenseContext);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/watermarks.mjs
var watermarkDesktopSvg;
var init_watermarks = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/watermarks.mjs"() {
    watermarkDesktopSvg = '<svg xmlns="http://www.w3.org/2000/svg" width="3001" height="1000" fill="none"><path fill="#000" d="M590.656 300.449c0 49.706-40.294 90-90 90-49.705 0-90-40.294-90-90 0-49.705 40.295-90 90-90 49.706 0 90 40.295 90 90M569.431 719.011c-15.247 32.821-56.006 91.589-98.338 91.438-32.004-.115-38.642-30.904-17.414-50.856 17.381-16.337 28.246-48.075 31.995-72.719.415-2.728-1.556-5.197-4.272-5.679-39.666-7.04-70.746-40.877-70.746-83.417 0-48.23 38.983-87.329 87.07-87.329 39.936 0 70.172 22.237 83.369 52.397 18.839 43.055 7.117 115.733-11.664 156.165M2613.29 385.681V239.319c0-11.363 9.22-20.569 20.59-20.569h8.26c11.37 0 20.59 9.206 20.59 20.569v36.911c0 8.629 7 15.625 15.63 15.625h35.25c8.63 0 15.63-6.996 15.63-15.625v-36.911c0-11.363 9.22-20.569 20.59-20.569h8.17c11.37 0 20.59 9.206 20.59 20.569v146.362c0 11.363-9.22 20.569-20.59 20.569h-8.17c-11.37 0-20.59-9.206-20.59-20.569v-36.999c0-8.63-7-15.625-15.63-15.625h-35.25c-8.63 0-15.63 6.995-15.63 15.625v36.999c0 11.363-9.22 20.569-20.59 20.569h-8.26c-11.37 0-20.59-9.206-20.59-20.569M2391.97 239.319v146.362c0 11.348-9.16 20.569-20.49 20.569h-8.2c-11.33 0-20.49-9.221-20.49-20.569V239.319c0-11.348 9.16-20.569 20.49-20.569h8.2c11.33 0 20.49 9.221 20.49 20.569M2098.23 391.43l-42.69-146.361c-3.85-13.171 6.06-26.319 19.79-26.319h10.6c9.59 0 17.93 6.611 20.08 15.952l17.01 73.045c1.48 6.348 10.47 6.478 12.14.176l19.47-73.838c2.38-9.04 10.57-15.335 19.93-15.335h12.1c9.37 0 17.56 6.3 19.94 15.346l19.49 74.067c1.66 6.305 10.65 6.178 12.13-.171l17.09-73.294c2.15-9.339 10.49-15.948 20.08-15.948h10.53c13.72 0 23.63 13.141 19.79 26.31l-42.63 146.361c-2.56 8.789-10.63 14.829-19.79 14.829h-15.68c-9.12 0-17.16-5.98-19.76-14.709l-21.17-71.059c-1.77-5.948-10.19-5.957-11.97-.012l-21.33 71.071c-2.6 8.729-10.64 14.709-19.76 14.709h-15.59c-9.17 0-17.23-6.035-19.8-14.82M2443.23 218.75h118.59c11.38 0 20.62 9.195 20.62 20.557s-9.24 20.556-20.62 20.556h-24.79c-5.53 0-10 4.477-10 10v115.818c0 11.368-9.25 20.569-20.63 20.569h-7.65c-11.39 0-20.63-9.201-20.63-20.569V269.863c0-5.523-4.48-10-10-10h-24.89c-11.37 0-20.61-9.195-20.61-20.556s9.24-20.557 20.61-20.557M1174.15 218.75h24.64c8.35 0 15.88 5.042 19.04 12.764l34.61 83.942c2.13 5.161 9.44 5.155 11.56-.01l34.43-83.932a20.58 20.58 0 0 1 19.04-12.764h24.64c11.37 0 20.58 9.208 20.58 20.569v146.362c0 11.361-9.21 20.569-20.58 20.569h-7.09c-11.36 0-20.58-9.208-20.58-20.569l-.12-50.645c-.01-6.888-9.53-8.688-12.06-2.283l-23.46 59.332a20.57 20.57 0 0 1-19.14 13.009h-3.03a20.57 20.57 0 0 1-19.15-13.046l-23.47-59.68c-2.52-6.416-12.05-4.623-12.06 2.271l-.13 51.042c0 11.361-9.21 20.569-20.57 20.569h-7.1c-11.36 0-20.57-9.208-20.57-20.569V239.319c0-11.361 9.21-20.569 20.57-20.569"/><path fill="#000" fill-rule="evenodd" d="m1449.94 391.836 6.12-19.392a6.255 6.255 0 0 1 5.96-4.369l50.22-.061a6.24 6.24 0 0 1 5.96 4.348l6.23 19.486c2.71 8.581 10.71 14.402 19.74 14.402h9.34c14.13 0 24.15-13.791 19.61-27.151l-49.74-146.361c-2.85-8.37-10.74-13.988-19.61-13.988h-33.16c-8.87 0-16.77 5.618-19.61 13.988l-49.74 146.361c-4.54 13.36 5.48 27.151 19.61 27.151h9.32c9.04 0 17.04-5.827 19.75-14.414m31.1-98.858c1.85-5.807 10.08-5.796 11.91.016l8.83 27.916c1.28 4.028-1.73 8.134-5.96 8.134h-17.74c-4.23 0-7.24-4.119-5.95-8.151zM1681.81 406.25c18.91 0 35.39-3.686 49.36-11.168 13.97-7.544 24.73-18.394 32.24-32.489 7.56-14.105 11.29-30.866 11.29-50.182 0-19.256-3.73-35.957-11.29-50.004-7.57-14.094-18.35-24.912-32.32-32.397-13.91-7.545-30.4-11.26-49.37-11.26h-49.5c-11.38 0-20.63 9.201-20.63 20.569v146.362c0 11.368 9.25 20.569 20.63 20.569zm23.13-47.701c-6.62 3.215-14.85 4.886-24.79 4.886-10.49 0-19-8.507-19-19v-64.34c0-10.149 8.23-18.376 18.38-18.376 10.18 0 18.56 1.703 25.23 4.974 6.59 3.149 11.63 8.315 15.08 15.633 3.45 7.269 5.28 17.268 5.28 30.162 0 12.891-1.82 22.951-5.28 30.347-3.39 7.319-8.36 12.509-14.9 15.714" clip-rule="evenodd"/><path fill="#000" d="M1804.21 385.681V239.319c0-11.361 9.21-20.569 20.58-20.569h91.28c11.36 0 20.57 9.202 20.57 20.557s-9.21 20.556-20.57 20.556h-54.64a7.807 7.807 0 0 0-7.81 7.813v16.366a7.806 7.806 0 0 0 7.81 7.812h48.13c11.37 0 20.58 9.246 20.58 20.602s-9.21 20.601-20.58 20.601h-48.13a7.806 7.806 0 0 0-7.81 7.812v16.455a7.807 7.807 0 0 0 7.81 7.813h54.64c11.36 0 20.57 9.202 20.57 20.556s-9.21 20.557-20.57 20.557h-91.28c-11.37 0-20.58-9.208-20.58-20.569"/><path fill="#000" fill-rule="evenodd" d="M2875.5 68.75h-2750c-31.066 0-56.25 25.184-56.25 56.25v750c0 31.066 25.184 56.25 56.25 56.25h2750c31.07 0 56.25-25.184 56.25-56.25V125c0-31.066-25.18-56.25-56.25-56.25M125.5 0C56.464 0 .5 55.964.5 125v750c0 69.036 55.965 125 125 125h2750c69.04 0 125-55.964 125-125V125c0-69.036-55.96-125-125-125z" clip-rule="evenodd"/><path fill="#000" d="M2476.06 804.813c-10.54 0-19.82-6.947-22.81-17.068L2390.79 575.7c-4.49-15.248 6.92-30.534 22.8-30.534h27.75c11.1 0 20.72 7.686 23.18 18.52L2489 671.402c2.07 9.093 14.93 9.321 17.32.308l28.83-108.844c2.76-10.435 12.19-17.7 22.98-17.7h25.17c10.8 0 20.25 7.293 22.99 17.755l28.27 107.739c2.36 9.001 15.18 8.829 17.3-.232l25.01-106.888c2.51-10.763 12.1-18.374 23.14-18.374h27.87c15.88 0 27.29 15.286 22.8 30.534l-62.46 212.045a23.78 23.78 0 0 1-22.81 17.068h-32.12c-10.39 0-19.58-6.763-22.69-16.696l-32.08-102.694c-2.62-8.397-14.51-8.331-17.04.095l-30.74 102.346c-3.02 10.061-12.27 16.949-22.76 16.949zM1742.44 804.813h-75.81c-13.09 0-23.71-10.656-23.71-23.801V568.967c0-13.145 10.62-23.801 23.71-23.801h74.8c26.6 0 49.59 5.198 68.95 15.594 19.45 10.312 34.44 25.187 44.96 44.627 10.61 19.355 15.91 42.556 15.91 69.602q0 40.57-15.78 69.73c-10.53 19.355-25.43 34.231-44.71 44.627-19.28 10.311-42.05 15.467-68.32 15.467m-29.3-83.642c0 13.145 10.61 23.801 23.71 23.801h3.06c12.8 0 23.7-2.07 32.71-6.212 9.09-4.141 16-11.283 20.71-21.426q7.2-15.213 7.2-42.345 0-27.13-7.32-42.344c-4.8-10.143-11.87-17.285-21.22-21.426-9.26-4.142-20.63-6.212-34.1-6.212h-1.04c-13.1 0-23.71 10.656-23.71 23.801zM1460.86 804.813c-13.12 0-23.76-10.656-23.76-23.801V568.967c0-13.145 10.64-23.801 23.76-23.801h22.84c13.13 0 23.76 10.656 23.76 23.801v155.247c0 13.145 10.64 23.801 23.76 23.801h57.27c13.12 0 23.76 10.656 23.76 23.801v9.196c0 13.145-10.64 23.801-23.76 23.801zM1204.45 601.964c-13.13 0-23.77-10.656-23.77-23.801v-9.196c0-13.145 10.64-23.801 23.77-23.801h177.89c13.13 0 23.78 10.656 23.78 23.801v9.196c0 13.145-10.65 23.801-23.78 23.801h-39.38c-8.21 0-14.86 6.66-14.86 14.875v164.173c0 13.145-10.64 23.801-23.78 23.801h-21.85c-13.13 0-23.78-10.656-23.78-23.801V616.839c0-8.215-6.65-14.875-14.86-14.875z"/><path fill="#000" fill-rule="evenodd" d="M2223.05 787.891c-3.02 10.047-12.27 16.922-22.74 16.922h-25.43c-16.19 0-27.64-15.862-22.57-31.261l69.88-212.045c3.21-9.753 12.31-16.341 22.56-16.341h61.84c10.25 0 19.35 6.588 22.56 16.341l69.87 212.045c5.08 15.399-6.37 31.261-22.56 31.261h-25.43c-10.48 0-19.72-6.875-22.74-16.922l-6.7-22.2a14.84 14.84 0 0 0-14.21-10.576h-63.42c-6.55 0-12.32 4.296-14.22 10.576zm76.13-96.945-14.13-48.436c-2.46-8.451-14.36-8.602-17.04-.217l-15.46 48.436c-1.84 5.759 2.45 11.645 8.48 11.645h29.6c5.94 0 10.22-5.715 8.55-11.428" clip-rule="evenodd"/><path fill="#000" d="M1939.6 804.813c-13.13 0-23.77-10.656-23.77-23.801V568.967c0-13.145 10.64-23.801 23.77-23.801h88.13c19.24 0 36.08 3.508 50.51 10.523s25.65 17.115 33.67 30.3q12.03 19.779 12.03 47.416c0 18.595-4.14 34.273-12.41 47.036-7.64 11.913-18.18 21.101-31.63 27.564-16.98 8.159-36 11.104-54.7 11.104h-43.07c-76.56 0 4.08-135.84 4.08-84.706v7.996c0 12.117 9.81 21.941 21.91 21.941 8.12 0 16.3-.345 24.04-3.043 5.91-2.113 10.43-5.451 13.55-10.015 3.2-4.565 4.81-10.523 4.81-17.877 0-7.437-1.61-13.481-4.81-18.129-3.12-4.733-7.64-8.199-13.55-10.396-7.05-2.766-14.67-3.423-22.18-3.423-13.13 0-23.77 10.656-23.77 23.801v47.71c0 11.825 11.14 16.003 19.91 20.752 12.31 6.671 7.58 25.389-6.42 25.389-7.45 0-13.49 6.048-13.49 13.508v48.395c0 13.145-10.63 23.801-23.76 23.801zm134.89-106.758 5.41 9.95 33.51 61.622c8.62 15.86-2.84 35.186-20.87 35.186h-22.27c-8.74 0-16.77-4.798-20.92-12.496l-35.05-65.04a15.52 15.52 0 0 0-13.66-8.168c-42.24 0 40.62-82.154 73.85-21.054M931.652 0h68.748v1000h-68.748z"/></svg>';
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/license/Watermark.mjs
async function getWatermarkUrl(forceLocal) {
  if (forceLocal) {
    return WATERMARK_LOCAL_SRC;
  }
  if (!watermarkUrlPromise) {
    watermarkUrlPromise = Promise.race([
      (async () => {
        try {
          const response = await fetch2(WATERMARK_REMOTE_SRC);
          if (!response.ok)
            return WATERMARK_LOCAL_SRC;
          const blob = await response.blob();
          return URL.createObjectURL(blob);
        } catch {
          return WATERMARK_LOCAL_SRC;
        }
      })(),
      new Promise((resolve) => {
        setTimeout(() => {
          resolve(WATERMARK_LOCAL_SRC);
        }, 3e3);
      })
    ]);
  }
  return watermarkUrlPromise;
}
var import_jsx_runtime32, import_react42, WATERMARK_REMOTE_SRC, WATERMARK_LOCAL_SRC, watermarkUrlPromise, Watermark;
var init_Watermark = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/license/Watermark.mjs"() {
    import_jsx_runtime32 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm9();
    init_dist_esm2();
    import_react42 = __toESM(require_react(), 1);
    init_useCanvasEvents();
    init_useEditor();
    init_assets();
    init_debug_flags();
    init_dom();
    init_watermarks();
    init_LicenseManager();
    init_LicenseProvider();
    WATERMARK_REMOTE_SRC = `${getDefaultCdnBaseUrl()}/watermarks/watermark-desktop.svg`;
    WATERMARK_LOCAL_SRC = `data:image/svg+xml;utf8,${encodeURIComponent(watermarkDesktopSvg)}`;
    watermarkUrlPromise = null;
    Watermark = import_react42.default.memo(function Watermark2({
      forceLocal = false
    }) {
      const events = useCanvasEvents();
      const editor = useEditor();
      const licenseManager = useLicenseContext();
      const showWatermark = useValue("show watermark", () => featureFlags.enableLicensing.get() && editor.getViewportScreenBounds().width > 760 && licenseManager.state.get() === "unlicensed", [editor, licenseManager]);
      const isDebugMode = useValue("debug mode", () => editor.getInstanceState().isDebugMode, [editor]);
      const isMenuOpen = useValue("is menu open", () => editor.getIsMenuOpen(), [editor]);
      const [src, setSrc] = (0, import_react42.useState)(null);
      const shouldUseLocal = forceLocal || licenseManager.isDevelopment;
      (0, import_react42.useEffect)(() => {
        if (!showWatermark)
          return;
        let isCancelled = false;
        (async () => {
          const src2 = await getWatermarkUrl(shouldUseLocal);
          if (isCancelled)
            return;
          setSrc(src2);
        })();
        return () => {
          isCancelled = true;
        };
      }, [shouldUseLocal, showWatermark]);
      if (!showWatermark || !src)
        return null;
      const className = LicenseManager.className;
      const maskCss = `url('${src}') center 100% / 100% no-repeat`;
      return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_jsx_runtime32.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("style", { children: `
/* ------------------- SEE LICENSE -------------------
The tldraw watermark is part of tldraw's license. It is shown for unlicensed
users. By using this library, you agree to keep the watermark's behavior, 
keeping it visible, unobscured, and available to user-interaction.

To remove the watermark, please purchase a license at tldraw.dev.
*/

.${className} {
	position: absolute;
	bottom: var(--space-2);
	right: var(--space-2);
	width: 96px;
	height: 32px;
	z-index: 2147483647 !important;
	pointer-events: ${isMenuOpen ? "none" : "all"};
	background-color: color-mix(in srgb, var(--color-background) 62%, transparent);
	border-radius: 5px;
	padding: 2px;
	box-sizing: content-box;
}

.${className}[data-debug='true'] {
	bottom: 46px;
}

.${className} > a {
	position: absolute;
	width: 96px;
	height: 32px;
	pointer-events: none;
	cursor: inherit;
	color: var(--color-text);
	background-color: currentColor;
	opacity: .28;
}

@media (hover: hover) {
	.${className}:hover {
		background-color: var(--color-background);
		transition: background-color 0.2s ease-in-out;
		transition-delay: 0.32s;
	}
	.${className}:hover > a {
		animation: delayed_link 0.2s forwards ease-in-out;
		animation-delay: 0.32s;
	}
}

@keyframes delayed_link {
	0% {
		cursor: inherit;
		opacity: .38;
		pointer-events: none;
	}
	100% {
		cursor: pointer;
		opacity: 1;
		pointer-events: all;
	}
}
` }),
        /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("div", { className, "data-debug": isDebugMode, draggable: false, ...events, children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("a", {
          href: "https://tldraw.dev",
          target: "_blank",
          rel: "noreferrer",
          draggable: false,
          onPointerDown: stopEventPropagation,
          style: { mask: maskCss, WebkitMask: maskCss }
        }) })
      ] });
    });
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/TldrawEditor.mjs
function TldrawEditorWithOwnStore(props) {
  const {
    defaultName,
    snapshot,
    initialData,
    shapeUtils,
    bindingUtils,
    persistenceKey,
    sessionId,
    user,
    assets
  } = props;
  const syncedStore = useLocalStore({
    shapeUtils,
    bindingUtils,
    initialData,
    persistenceKey,
    sessionId,
    defaultName,
    snapshot,
    assets
  });
  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TldrawEditorWithLoadingStore, { ...props, store: syncedStore, user });
}
function TldrawEditorWithReadyStore({
  onMount: onMount2,
  children,
  store,
  tools,
  shapeUtils,
  bindingUtils,
  user,
  initialState: initialState2,
  autoFocus = true,
  inferDarkMode,
  cameraOptions,
  options,
  licenseKey
}) {
  const { ErrorFallback } = useEditorComponents();
  const container = useContainer();
  const [editor, setEditor] = useRefState(null);
  const editorOptionsRef = (0, import_react43.useRef)({
    autoFocus: autoFocus && !noAutoFocus(),
    inferDarkMode,
    initialState: initialState2,
    cameraOptions
  });
  (0, import_react43.useLayoutEffect)(() => {
    editorOptionsRef.current = {
      autoFocus: autoFocus && !noAutoFocus(),
      inferDarkMode,
      initialState: initialState2,
      cameraOptions
    };
  }, [autoFocus, inferDarkMode, initialState2, cameraOptions]);
  (0, import_react43.useLayoutEffect)(() => {
    const { autoFocus: autoFocus2, inferDarkMode: inferDarkMode2, initialState: initialState22, cameraOptions: cameraOptions2 } = editorOptionsRef.current;
    const editor2 = new Editor({
      store,
      shapeUtils,
      bindingUtils,
      tools,
      getContainer: () => container,
      user,
      initialState: initialState22,
      autoFocus: autoFocus2,
      inferDarkMode: inferDarkMode2,
      cameraOptions: cameraOptions2,
      options,
      licenseKey
    });
    setEditor(editor2);
    return () => {
      editor2.dispose();
    };
  }, [bindingUtils, container, options, shapeUtils, store, tools, user, setEditor, licenseKey]);
  (0, import_react43.useLayoutEffect)(() => {
    if (editor && cameraOptions) {
      editor.setCameraOptions(cameraOptions);
    }
  }, [editor, cameraOptions]);
  const crashingError = (0, import_react43.useSyncExternalStore)((0, import_react43.useCallback)((onStoreChange) => {
    if (editor) {
      editor.on("crash", onStoreChange);
      return () => editor.off("crash", onStoreChange);
    }
    return () => {
    };
  }, [editor]), () => editor?.getCrashingError() ?? null);
  (0, import_react43.useEffect)(function handleFocusOnPointerDownForPreserveFocusMode() {
    if (!editor)
      return;
    function handleFocusOnPointerDown() {
      if (!editor)
        return;
      editor.focus();
    }
    function handleBlurOnPointerDown() {
      if (!editor)
        return;
      editor.blur();
    }
    if (autoFocus && noAutoFocus()) {
      editor.getContainer().addEventListener("pointerdown", handleFocusOnPointerDown);
      document.body.addEventListener("pointerdown", handleBlurOnPointerDown);
      return () => {
        editor.getContainer()?.removeEventListener("pointerdown", handleFocusOnPointerDown);
        document.body.removeEventListener("pointerdown", handleBlurOnPointerDown);
      };
    }
  }, [editor, autoFocus]);
  const { Canvas } = useEditorComponents();
  if (!editor) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(OptionalErrorBoundary, {
    fallback: ErrorFallback,
    onError: (error2) => editor.annotateError(error2, { origin: "react.tldraw", willCrashApp: true }),
    children: crashingError ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(Crash, { crashingError }) : /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(EditorContext.Provider, { value: editor, children: /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)(Layout, { onMount: onMount2, children: [
      children ?? (Canvas ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(Canvas, {}) : null),
      /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(Watermark, {})
    ] }) })
  });
}
function Layout({ children, onMount: onMount2 }) {
  useZoomCss();
  useCursor();
  useDarkMode();
  useForceUpdate();
  useOnMount((editor) => {
    const teardownStore = editor.store.props.onMount(editor);
    const teardownCallback = onMount2?.(editor);
    return () => {
      teardownStore?.();
      teardownCallback?.();
    };
  });
  return children;
}
function Crash({ crashingError }) {
  throw crashingError;
}
function LoadingScreen({ children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", { className: "tl-loading", children });
}
function ErrorScreen({ children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", { className: "tl-loading", children });
}
function useOnMount(onMount2) {
  const editor = useEditor();
  const onMountEvent = useEvent((editor2) => {
    let teardown = void 0;
    editor2.run(() => {
      teardown = onMount2?.(editor2);
      editor2.emit("mount");
    }, { history: "ignore" });
    window.tldrawReady = true;
    return teardown;
  });
  import_react43.default.useLayoutEffect(() => {
    if (editor)
      return onMountEvent?.(editor);
  }, [editor, onMountEvent]);
}
var import_jsx_runtime33, import_react43, import_classnames11, EMPTY_SHAPE_UTILS_ARRAY, EMPTY_BINDING_UTILS_ARRAY, EMPTY_TOOLS_ARRAY, TL_CONTAINER_CLASS, TldrawEditor, TldrawEditorWithLoadingStore, noAutoFocus;
var init_TldrawEditor = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/TldrawEditor.mjs"() {
    import_jsx_runtime33 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm4();
    init_dist_esm2();
    import_react43 = __toESM(require_react(), 1);
    import_classnames11 = __toESM(require_classnames(), 1);
    init_version();
    init_ErrorBoundary();
    init_DefaultErrorFallback();
    init_createTLUser();
    init_Editor();
    init_useContainer();
    init_useCursor();
    init_useDarkMode();
    init_useEditor();
    init_useEditorComponents();
    init_useEvent();
    init_useForceUpdate();
    init_useLocalStore();
    init_useRefState();
    init_useZoomCss();
    init_LicenseProvider();
    init_Watermark();
    init_dom();
    EMPTY_SHAPE_UTILS_ARRAY = [];
    EMPTY_BINDING_UTILS_ARRAY = [];
    EMPTY_TOOLS_ARRAY = [];
    TL_CONTAINER_CLASS = "tl-container";
    TldrawEditor = (0, import_react43.memo)(function TldrawEditor2({
      store,
      components,
      className,
      user: _user,
      ...rest
    }) {
      const [container, setContainer] = import_react43.default.useState(null);
      const user = (0, import_react43.useMemo)(() => _user ?? createTLUser(), [_user]);
      const ErrorFallback = components?.ErrorFallback === void 0 ? DefaultErrorFallback : components?.ErrorFallback;
      const withDefaults = {
        ...rest,
        shapeUtils: rest.shapeUtils ?? EMPTY_SHAPE_UTILS_ARRAY,
        bindingUtils: rest.bindingUtils ?? EMPTY_BINDING_UTILS_ARRAY,
        tools: rest.tools ?? EMPTY_TOOLS_ARRAY,
        components
      };
      return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", {
        ref: setContainer,
        "data-tldraw": version,
        draggable: false,
        className: (0, import_classnames11.default)(`${TL_CONTAINER_CLASS} tl-theme__light`, className),
        onPointerDown: stopEventPropagation,
        tabIndex: -1,
        children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(OptionalErrorBoundary, {
          fallback: ErrorFallback,
          onError: (error2) => annotateError(error2, { tags: { origin: "react.tldraw-before-app" } }),
          children: container && /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(LicenseProvider, { licenseKey: rest.licenseKey, children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(ContainerProvider, { container, children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(EditorComponentsProvider, { overrides: components, children: store ? store instanceof Store ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TldrawEditorWithReadyStore, { ...withDefaults, store, user }) : /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TldrawEditorWithLoadingStore, { ...withDefaults, store, user }) : /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TldrawEditorWithOwnStore, { ...withDefaults, store, user }) }) }) })
        })
      });
    });
    TldrawEditorWithLoadingStore = (0, import_react43.memo)(function TldrawEditorBeforeLoading({
      store,
      user,
      ...rest
    }) {
      const container = useContainer();
      (0, import_react43.useLayoutEffect)(() => {
        if (user.userPreferences.get().colorScheme === "dark") {
          container.classList.remove("tl-theme__light");
          container.classList.add("tl-theme__dark");
        }
      }, [container, user]);
      const { LoadingScreen: LoadingScreen2 } = useEditorComponents();
      switch (store.status) {
        case "error": {
          throw store.error;
        }
        case "loading": {
          return LoadingScreen2 ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(LoadingScreen2, {}) : null;
        }
        case "not-synced": {
          break;
        }
        case "synced-local": {
          break;
        }
        case "synced-remote": {
          break;
        }
      }
      return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TldrawEditorWithReadyStore, { ...rest, store: store.store, user });
    });
    noAutoFocus = () => document.location.search.includes("tldraw_preserve_focus");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/components/HTMLContainer.mjs
function HTMLContainer({ children, className = "", ...rest }) {
  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { ...rest, className: (0, import_classnames12.default)("tl-html-container", className), children });
}
var import_jsx_runtime34, import_classnames12;
var init_HTMLContainer = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/components/HTMLContainer.mjs"() {
    import_jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
    import_classnames12 = __toESM(require_classnames(), 1);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/bindings/BindingUtil.mjs
var BindingUtil;
var init_BindingUtil = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/bindings/BindingUtil.mjs"() {
    BindingUtil = class {
      constructor(editor) {
        this.editor = editor;
      }
    };
    __publicField(BindingUtil, "props");
    __publicField(BindingUtil, "migrations");
    __publicField(BindingUtil, "type");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/shared/resizeBox.mjs
function resizeBox(shape, info2, opts = {}) {
  const { newPoint, handle, scaleX, scaleY } = info2;
  const { minWidth = 1, maxWidth: maxWidth2 = Infinity, minHeight = 1, maxHeight: maxHeight2 = Infinity } = opts;
  let w2 = shape.props.w * scaleX;
  let h2 = shape.props.h * scaleY;
  const offset5 = new Vec(0, 0);
  if (w2 > 0) {
    if (w2 < minWidth) {
      switch (handle) {
        case "top_left":
        case "left":
        case "bottom_left": {
          offset5.x = w2 - minWidth;
          break;
        }
        case "top":
        case "bottom": {
          offset5.x = (w2 - minWidth) / 2;
          break;
        }
        default: {
          offset5.x = 0;
        }
      }
      w2 = minWidth;
    }
  } else {
    offset5.x = w2;
    w2 = -w2;
    if (w2 < minWidth) {
      switch (handle) {
        case "top_left":
        case "left":
        case "bottom_left": {
          offset5.x = -w2;
          break;
        }
        default: {
          offset5.x = -minWidth;
        }
      }
      w2 = minWidth;
    }
  }
  if (h2 > 0) {
    if (h2 < minHeight) {
      switch (handle) {
        case "top_left":
        case "top":
        case "top_right": {
          offset5.y = h2 - minHeight;
          break;
        }
        case "right":
        case "left": {
          offset5.y = (h2 - minHeight) / 2;
          break;
        }
        default: {
          offset5.y = 0;
        }
      }
      h2 = minHeight;
    }
  } else {
    offset5.y = h2;
    h2 = -h2;
    if (h2 < minHeight) {
      switch (handle) {
        case "top_left":
        case "top":
        case "top_right": {
          offset5.y = -h2;
          break;
        }
        default: {
          offset5.y = -minHeight;
        }
      }
      h2 = minHeight;
    }
  }
  const { x: x2, y: y2 } = offset5.rot(shape.rotation).add(newPoint);
  return {
    ...shape,
    x: x2,
    y: y2,
    props: {
      w: Math.min(maxWidth2, w2),
      h: Math.min(maxHeight2, h2)
    }
  };
}
var init_resizeBox = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/shared/resizeBox.mjs"() {
    init_Vec();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/BaseBoxShapeUtil.mjs
var BaseBoxShapeUtil;
var init_BaseBoxShapeUtil = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/shapes/BaseBoxShapeUtil.mjs"() {
    init_dist_esm2();
    init_Rectangle2d();
    init_ShapeUtil();
    init_resizeBox();
    BaseBoxShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "onResize", (shape, info2) => {
          return resizeBox(shape, info2);
        });
      }
      getGeometry(shape) {
        return new Rectangle2d({
          width: shape.props.w,
          height: shape.props.h,
          isFilled: true
        });
      }
      getHandleSnapGeometry(shape) {
        return {
          points: this.getGeometry(shape).bounds.cornersAndCenter
        };
      }
      getInterpolatedProps(startShape, endShape, t3) {
        return {
          ...endShape.props,
          w: lerp(startShape.props.w, endShape.props.w, t3),
          h: lerp(startShape.props.h, endShape.props.h, t3)
        };
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/children/Idle.mjs
var Idle;
var init_Idle = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/children/Idle.mjs"() {
    init_StateNode();
    Idle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle, "id", "idle");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/children/Pointing.mjs
var Pointing;
var init_Pointing = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/children/Pointing.mjs"() {
    init_dist_esm8();
    init_dist_esm2();
    init_Vec();
    init_StateNode();
    Pointing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "markId", "");
        __publicField(this, "wasFocusedOnEnter", false);
        __publicField(this, "onEnter", () => {
          this.wasFocusedOnEnter = !this.editor.getIsMenuOpen();
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            const { originPagePoint } = this.editor.inputs;
            const shapeType = this.parent.shapeType;
            const id = createShapeId();
            this.markId = `creating:${id}`;
            this.editor.mark(this.markId);
            this.editor.createShapes([
              {
                id,
                type: shapeType,
                x: originPagePoint.x,
                y: originPagePoint.y,
                props: {
                  w: 1,
                  h: 1
                }
              }
            ]).select(id);
            this.editor.setCurrentTool("select.resizing", {
              ...info2,
              target: "selection",
              handle: "bottom_right",
              isCreating: true,
              creationCursorOffset: { x: 1, y: 1 },
              onInteractionEnd: this.parent.id,
              onCreate: this.parent.onCreate
            });
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      complete() {
        const { originPagePoint } = this.editor.inputs;
        if (!this.wasFocusedOnEnter) {
          return;
        }
        this.editor.mark(this.markId);
        const shapeType = this.parent.shapeType;
        const id = createShapeId();
        this.editor.mark(this.markId);
        this.editor.createShapes([
          {
            id,
            type: shapeType,
            x: originPagePoint.x,
            y: originPagePoint.y
          }
        ]);
        const shape = this.editor.getShape(id);
        if (!shape) {
          this.cancel();
          return;
        }
        let { w: w2, h: h2 } = shape.props;
        const delta = new Vec(w2 / 2, h2 / 2);
        const parentTransform = this.editor.getShapeParentTransform(shape);
        if (parentTransform)
          delta.rot(-parentTransform.rotation());
        let scale = 1;
        if (this.editor.user.getIsDynamicResizeMode()) {
          scale = 1 / this.editor.getZoomLevel();
          w2 *= scale;
          h2 *= scale;
          delta.mul(scale);
        }
        const next = structuredClone2(shape);
        next.x = shape.x - delta.x;
        next.y = shape.y - delta.y;
        next.props.w = w2;
        next.props.h = h2;
        if ("scale" in shape.props) {
          ;
          next.props.scale = scale;
        }
        this.editor.updateShape(next);
        this.editor.setSelectedShapes([id]);
        if (this.editor.getInstanceState().isToolLocked) {
          this.parent.transition("idle");
        } else {
          this.editor.setCurrentTool("select.idle");
        }
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(Pointing, "id", "pointing");
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/BaseBoxShapeTool.mjs
var BaseBoxShapeTool;
var init_BaseBoxShapeTool = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/editor/tools/BaseBoxShapeTool/BaseBoxShapeTool.mjs"() {
    init_StateNode();
    init_Idle();
    init_Pointing();
    BaseBoxShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onCreate");
      }
    };
    __publicField(BaseBoxShapeTool, "id", "box");
    __publicField(BaseBoxShapeTool, "initial", "idle");
    __publicField(BaseBoxShapeTool, "children", () => [Idle, Pointing]);
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsCropping.mjs
var init_useIsCropping = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsCropping.mjs"() {
    init_dist_esm9();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsEditing.mjs
function useIsEditing(shapeId) {
  const editor = useEditor();
  return useValue("isEditing", () => editor.getEditingShapeId() === shapeId, [editor, shapeId]);
}
var init_useIsEditing = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useIsEditing.mjs"() {
    init_dist_esm9();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useSelectionEvents.mjs
function useSelectionEvents(handle) {
  const editor = useEditor();
  const events = (0, import_react44.useMemo)(function selectionEvents() {
    const onPointerDown = (e2) => {
      if (e2.isKilled)
        return;
      if (e2.button === RIGHT_MOUSE_BUTTON) {
        editor.dispatch({
          type: "pointer",
          target: "selection",
          handle,
          name: "right_click",
          ...getPointerInfo(e2)
        });
        return;
      }
      if (e2.button !== 0)
        return;
      const elm = loopToHtmlElement(e2.currentTarget);
      function releaseCapture() {
        elm.removeEventListener("pointerup", releaseCapture);
        releasePointerCapture(elm, e2);
      }
      setPointerCapture(elm, e2);
      elm.addEventListener("pointerup", releaseCapture);
      editor.dispatch({
        name: "pointer_down",
        type: "pointer",
        target: "selection",
        handle,
        ...getPointerInfo(e2)
      });
      stopEventPropagation(e2);
    };
    let lastX, lastY;
    function onPointerMove(e2) {
      if (e2.isKilled)
        return;
      if (e2.button !== 0)
        return;
      if (e2.clientX === lastX && e2.clientY === lastY)
        return;
      lastX = e2.clientX;
      lastY = e2.clientY;
      editor.dispatch({
        name: "pointer_move",
        type: "pointer",
        target: "selection",
        handle,
        ...getPointerInfo(e2)
      });
    }
    const onPointerUp = (e2) => {
      if (e2.isKilled)
        return;
      if (e2.button !== 0)
        return;
      editor.dispatch({
        name: "pointer_up",
        type: "pointer",
        target: "selection",
        handle,
        ...getPointerInfo(e2)
      });
    };
    return {
      onPointerDown,
      onPointerMove,
      onPointerUp
    };
  }, [editor, handle]);
  return events;
}
var import_react44;
var init_useSelectionEvents = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useSelectionEvents.mjs"() {
    import_react44 = __toESM(require_react(), 1);
    init_constants3();
    init_dom();
    init_getPointerInfo();
    init_useEditor();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/hooks/useTLStore.mjs
function useTLStore(opts) {
  const [current, setCurrent] = (0, import_react45.useState)(() => ({ store: createTLStore(opts), opts }));
  if (!areObjectsShallowEqual(current.opts, opts)) {
    const next = { store: createTLStore(opts), opts };
    setCurrent(next);
    return next.store;
  }
  return current.store;
}
var import_react45;
var init_useTLStore = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/hooks/useTLStore.mjs"() {
    init_dist_esm2();
    import_react45 = __toESM(require_react(), 1);
    init_createTLStore();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/geometry-constants.mjs
function getVerticesCountForLength(length, spacing = SPACING) {
  return Math.max(MIN_COUNT, Math.ceil(length / spacing));
}
var SPACING, MIN_COUNT;
var init_geometry_constants = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/geometry-constants.mjs"() {
    SPACING = 20;
    MIN_COUNT = 8;
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Arc2d.mjs
var Arc2d;
var init_Arc2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Arc2d.mjs"() {
    init_Vec();
    init_intersect();
    init_utils();
    init_Geometry2d();
    init_geometry_constants();
    Arc2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isFilled: false, isClosed: false });
        __publicField(this, "_center");
        __publicField(this, "radius");
        __publicField(this, "start");
        __publicField(this, "end");
        __publicField(this, "largeArcFlag");
        __publicField(this, "sweepFlag");
        __publicField(this, "measure");
        __publicField(this, "angleStart");
        __publicField(this, "angleEnd");
        const { center, sweepFlag, largeArcFlag, start: start2, end: end2 } = config;
        if (start2.equals(end2))
          throw Error(`Arc must have different start and end points.`);
        this.angleStart = Vec.Angle(center, start2);
        this.angleEnd = Vec.Angle(center, end2);
        this.radius = Vec.Dist(center, start2);
        this.measure = getArcMeasure(this.angleStart, this.angleEnd, sweepFlag, largeArcFlag);
        this.start = start2;
        this.end = end2;
        this.sweepFlag = sweepFlag;
        this.largeArcFlag = largeArcFlag;
        this._center = center;
      }
      nearestPoint(point) {
        const { _center, measure, radius, angleEnd, angleStart, start: A2, end: B } = this;
        const t3 = getPointInArcT(measure, angleStart, angleEnd, _center.angle(point));
        if (t3 <= 0)
          return A2;
        if (t3 >= 1)
          return B;
        const P2 = _center.clone().add(point.clone().sub(_center).uni().mul(radius));
        let nearest;
        let dist = Infinity;
        let d2;
        for (const p2 of [A2, B, P2]) {
          d2 = Vec.Dist2(point, p2);
          if (d2 < dist) {
            nearest = p2;
            dist = d2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      hitTestLineSegment(A2, B) {
        const { _center, radius, measure, angleStart, angleEnd } = this;
        const intersection = intersectLineSegmentCircle(A2, B, _center, radius);
        if (intersection === null)
          return false;
        return intersection.some((p2) => {
          const result = getPointInArcT(measure, angleStart, angleEnd, _center.angle(p2));
          return result >= 0 && result <= 1;
        });
      }
      getVertices() {
        const { _center, measure, length, radius, angleStart } = this;
        const vertices = [];
        for (let i2 = 0, n2 = getVerticesCountForLength(Math.abs(length)); i2 < n2 + 1; i2++) {
          const t3 = i2 / n2 * measure;
          const angle = angleStart + t3;
          vertices.push(getPointOnCircle(_center, radius, angle));
        }
        return vertices;
      }
      getSvgPathData(first = true) {
        const { start: start2, end: end2, radius, largeArcFlag, sweepFlag } = this;
        return `${first ? `M${start2.toFixed()}` : ``} A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end2.toFixed()}`;
      }
      getLength() {
        return this.measure * this.radius;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Circle2d.mjs
var Circle2d;
var init_Circle2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Circle2d.mjs"() {
    init_Box();
    init_Vec();
    init_intersect();
    init_utils();
    init_Geometry2d();
    init_geometry_constants();
    Circle2d = class extends Geometry2d {
      constructor(config) {
        super({ isClosed: true, ...config });
        __publicField(this, "_center");
        __publicField(this, "radius");
        __publicField(this, "x");
        __publicField(this, "y");
        this.config = config;
        const { x: x2 = 0, y: y2 = 0, radius } = config;
        this.x = x2;
        this.y = y2;
        this._center = new Vec(radius + x2, radius + y2);
        this.radius = radius;
      }
      getBounds() {
        return new Box(this.x, this.y, this.radius * 2, this.radius * 2);
      }
      getVertices() {
        const { _center, radius } = this;
        const perimeter = PI2 * radius;
        const vertices = [];
        for (let i2 = 0, n2 = getVerticesCountForLength(perimeter); i2 < n2; i2++) {
          const angle = i2 / n2 * PI2;
          vertices.push(getPointOnCircle(_center, radius, angle));
        }
        return vertices;
      }
      nearestPoint(point) {
        const { _center, radius } = this;
        if (_center.equals(point))
          return Vec.AddXY(_center, radius, 0);
        return _center.clone().add(point.clone().sub(_center).uni().mul(radius));
      }
      hitTestLineSegment(A2, B, distance = 0) {
        const { _center, radius } = this;
        return intersectLineSegmentCircle(A2, B, _center, radius + distance) !== null;
      }
      getSvgPathData() {
        const { _center, radius } = this;
        return `M${_center.x + radius},${_center.y} a${radius},${radius} 0 1,0 ${radius * 2},0a${radius},${radius} 0 1,0 -${radius * 2},0`;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/CubicBezier2d.mjs
var CubicBezier2d;
var init_CubicBezier2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/CubicBezier2d.mjs"() {
    init_Vec();
    init_Polyline2d();
    CubicBezier2d = class extends Polyline2d {
      constructor(config) {
        const { start: a2, cp1: b2, cp2: c2, end: d2 } = config;
        super({ ...config, points: [a2, d2] });
        __publicField(this, "a");
        __publicField(this, "b");
        __publicField(this, "c");
        __publicField(this, "d");
        this.a = a2;
        this.b = b2;
        this.c = c2;
        this.d = d2;
      }
      getVertices() {
        const vertices = [];
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        for (let i2 = 0, n2 = 10; i2 <= n2; i2++) {
          const t3 = i2 / n2;
          vertices.push(new Vec((1 - t3) * (1 - t3) * (1 - t3) * a2.x + 3 * ((1 - t3) * (1 - t3)) * t3 * b2.x + 3 * (1 - t3) * (t3 * t3) * c2.x + t3 * t3 * t3 * d2.x, (1 - t3) * (1 - t3) * (1 - t3) * a2.y + 3 * ((1 - t3) * (1 - t3)) * t3 * b2.y + 3 * (1 - t3) * (t3 * t3) * c2.y + t3 * t3 * t3 * d2.y));
        }
        return vertices;
      }
      midPoint() {
        return CubicBezier2d.GetAtT(this, 0.5);
      }
      nearestPoint(A2) {
        let nearest;
        let dist = Infinity;
        let d2;
        let p2;
        for (const edge of this.segments) {
          p2 = edge.nearestPoint(A2);
          d2 = Vec.Dist2(p2, A2);
          if (d2 < dist) {
            nearest = p2;
            dist = d2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      getSvgPathData(first = true) {
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        return `${first ? `M ${a2.toFixed()} ` : ``} C${b2.toFixed()} ${c2.toFixed()} ${d2.toFixed()}`;
      }
      static GetAtT(segment, t3) {
        const { a: a2, b: b2, c: c2, d: d2 } = segment;
        return new Vec((1 - t3) * (1 - t3) * (1 - t3) * a2.x + 3 * ((1 - t3) * (1 - t3)) * t3 * b2.x + 3 * (1 - t3) * (t3 * t3) * c2.x + t3 * t3 * t3 * d2.x, (1 - t3) * (1 - t3) * (1 - t3) * a2.y + 3 * ((1 - t3) * (1 - t3)) * t3 * b2.y + 3 * (1 - t3) * (t3 * t3) * c2.y + t3 * t3 * t3 * d2.y);
      }
      getLength(precision = 32) {
        let n1, p1 = this.a, length = 0;
        for (let i2 = 1; i2 <= precision; i2++) {
          n1 = CubicBezier2d.GetAtT(this, i2 / precision);
          length += Vec.Dist(p1, n1);
          p1 = n1;
        }
        return length;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/CubicSpline2d.mjs
var CubicSpline2d;
var init_CubicSpline2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/CubicSpline2d.mjs"() {
    init_Vec();
    init_CubicBezier2d();
    init_Geometry2d();
    CubicSpline2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isClosed: false, isFilled: false });
        __publicField(this, "points");
        __publicField(this, "_segments");
        const { points } = config;
        this.points = points;
      }
      get segments() {
        if (!this._segments) {
          this._segments = [];
          const { points } = this;
          const len = points.length;
          const last7 = len - 2;
          const k2 = 1.25;
          for (let i2 = 0; i2 < len - 1; i2++) {
            const p0 = i2 === 0 ? points[0] : points[i2 - 1];
            const p1 = points[i2];
            const p2 = points[i2 + 1];
            const p3 = i2 === last7 ? p2 : points[i2 + 2];
            const start2 = p1, cp1 = i2 === 0 ? p0 : new Vec(p1.x + (p2.x - p0.x) / 6 * k2, p1.y + (p2.y - p0.y) / 6 * k2), cp2 = i2 === last7 ? p2 : new Vec(p2.x - (p3.x - p1.x) / 6 * k2, p2.y - (p3.y - p1.y) / 6 * k2), end2 = p2;
            this._segments.push(new CubicBezier2d({ start: start2, cp1, cp2, end: end2 }));
          }
        }
        return this._segments;
      }
      getLength() {
        return this.segments.reduce((acc, segment) => acc + segment.length, 0);
      }
      getVertices() {
        const vertices = this.segments.reduce((acc, segment) => {
          return acc.concat(segment.vertices);
        }, []);
        vertices.push(this.points[this.points.length - 1]);
        return vertices;
      }
      nearestPoint(A2) {
        let nearest;
        let dist = Infinity;
        let d2;
        let p2;
        for (const segment of this.segments) {
          p2 = segment.nearestPoint(A2);
          d2 = Vec.Dist2(p2, A2);
          if (d2 < dist) {
            nearest = p2;
            dist = d2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      hitTestLineSegment(A2, B) {
        return this.segments.some((segment) => segment.hitTestLineSegment(A2, B));
      }
      getSvgPathData() {
        let d2 = this.segments.reduce((d22, segment, i2) => {
          return d22 + segment.getSvgPathData(i2 === 0);
        }, "");
        if (this.isClosed) {
          d2 += "Z";
        }
        return d2;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Ellipse2d.mjs
var Ellipse2d;
var init_Ellipse2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Ellipse2d.mjs"() {
    init_Box();
    init_Vec();
    init_utils();
    init_Edge2d();
    init_Geometry2d();
    init_geometry_constants();
    Ellipse2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isClosed: true });
        __publicField(this, "w");
        __publicField(this, "h");
        __publicField(this, "_edges");
        this.config = config;
        const { width, height } = config;
        this.w = width;
        this.h = height;
      }
      get edges() {
        if (!this._edges) {
          const { vertices } = this;
          this._edges = [];
          for (let i2 = 0, n2 = vertices.length; i2 < n2; i2++) {
            const start2 = vertices[i2];
            const end2 = vertices[(i2 + 1) % n2];
            this._edges.push(new Edge2d({ start: start2, end: end2 }));
          }
        }
        return this._edges;
      }
      getVertices() {
        const w2 = Math.max(1, this.w);
        const h2 = Math.max(1, this.h);
        const cx = w2 / 2;
        const cy = h2 / 2;
        const q = Math.pow(cx - cy, 2) / Math.pow(cx + cy, 2);
        const p2 = PI * (cx + cy) * (1 + 3 * q / (10 + Math.sqrt(4 - 3 * q)));
        const len = getVerticesCountForLength(p2);
        const step = PI2 / len;
        const a2 = Math.cos(step);
        const b2 = Math.sin(step);
        let sin = 0;
        let cos = 1;
        let ts = 0;
        let tc = 1;
        const vertices = Array(len);
        for (let i2 = 0; i2 < len; i2++) {
          vertices[i2] = new Vec(cx + cx * cos, cy + cy * sin);
          ts = b2 * cos + a2 * sin;
          tc = a2 * cos - b2 * sin;
          sin = ts;
          cos = tc;
        }
        return vertices;
      }
      nearestPoint(A2) {
        let nearest;
        let dist = Infinity;
        let d2;
        let p2;
        for (const edge of this.edges) {
          p2 = edge.nearestPoint(A2);
          d2 = Vec.Dist2(p2, A2);
          if (d2 < dist) {
            nearest = p2;
            dist = d2;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      hitTestLineSegment(A2, B) {
        return this.edges.some((edge) => edge.hitTestLineSegment(A2, B));
      }
      getBounds() {
        return new Box(0, 0, this.w, this.h);
      }
      getLength() {
        const { w: w2, h: h2 } = this;
        const cx = w2 / 2;
        const cy = h2 / 2;
        const rx = Math.max(0, cx);
        const ry = Math.max(0, cy);
        return perimeterOfEllipse(rx, ry);
      }
      getSvgPathData(first = false) {
        const { w: w2, h: h2 } = this;
        const cx = w2 / 2;
        const cy = h2 / 2;
        const rx = Math.max(0, cx);
        const ry = Math.max(0, cy);
        return `${first ? `M${cx - rx},${cy}` : ``} a${rx},${ry},0,1,1,${rx * 2},0a${rx},${ry},0,1,1,-${rx * 2},0`;
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Point2d.mjs
var init_Point2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Point2d.mjs"() {
    init_Vec();
    init_Geometry2d();
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Stadium2d.mjs
var Stadium2d;
var init_Stadium2d = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/primitives/geometry/Stadium2d.mjs"() {
    init_Box();
    init_Vec();
    init_utils();
    init_Arc2d();
    init_Edge2d();
    init_Geometry2d();
    Stadium2d = class extends Geometry2d {
      constructor(config) {
        super({ ...config, isClosed: true });
        __publicField(this, "w");
        __publicField(this, "h");
        __publicField(this, "a");
        __publicField(this, "b");
        __publicField(this, "c");
        __publicField(this, "d");
        this.config = config;
        const { width: w2, height: h2 } = config;
        this.w = w2;
        this.h = h2;
        if (h2 > w2) {
          const r2 = w2 / 2;
          this.a = new Arc2d({
            start: new Vec(0, r2),
            end: new Vec(w2, r2),
            center: new Vec(w2 / 2, r2),
            sweepFlag: 1,
            largeArcFlag: 1
          });
          this.b = new Edge2d({ start: new Vec(w2, r2), end: new Vec(w2, h2 - r2) });
          this.c = new Arc2d({
            start: new Vec(w2, h2 - r2),
            end: new Vec(0, h2 - r2),
            center: new Vec(w2 / 2, h2 - r2),
            sweepFlag: 1,
            largeArcFlag: 1
          });
          this.d = new Edge2d({ start: new Vec(0, h2 - r2), end: new Vec(0, r2) });
        } else {
          const r2 = h2 / 2;
          this.a = new Arc2d({
            start: new Vec(r2, h2),
            end: new Vec(r2, 0),
            center: new Vec(r2, r2),
            sweepFlag: 1,
            largeArcFlag: 1
          });
          this.b = new Edge2d({ start: new Vec(r2, 0), end: new Vec(w2 - r2, 0) });
          this.c = new Arc2d({
            start: new Vec(w2 - r2, 0),
            end: new Vec(w2 - r2, h2),
            center: new Vec(w2 - r2, r2),
            sweepFlag: 1,
            largeArcFlag: 1
          });
          this.d = new Edge2d({ start: new Vec(w2 - r2, h2), end: new Vec(r2, h2) });
        }
      }
      nearestPoint(A2) {
        let nearest;
        let dist = Infinity;
        let _d;
        let p2;
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        for (const part of [a2, b2, c2, d2]) {
          p2 = part.nearestPoint(A2);
          _d = Vec.Dist2(p2, A2);
          if (_d < dist) {
            nearest = p2;
            dist = _d;
          }
        }
        if (!nearest)
          throw Error("nearest point not found");
        return nearest;
      }
      hitTestLineSegment(A2, B) {
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        return [a2, b2, c2, d2].some((edge) => edge.hitTestLineSegment(A2, B));
      }
      getVertices() {
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        return [a2, b2, c2, d2].reduce((a22, p2) => {
          a22.push(...p2.vertices);
          return a22;
        }, []);
      }
      getBounds() {
        return new Box(0, 0, this.w, this.h);
      }
      getLength() {
        const { h: h2, w: w2 } = this;
        if (h2 > w2)
          return (PI * (w2 / 2) + (h2 - w2)) * 2;
        else
          return (PI * (h2 / 2) + (w2 - h2)) * 2;
      }
      getSvgPathData() {
        const { a: a2, b: b2, c: c2, d: d2 } = this;
        return [a2, b2, c2, d2].map((p2, i2) => p2.getSvgPathData(i2 === 0)).join(" ") + " Z";
      }
    };
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/sync/hardReset.mjs
async function hardReset({ shouldReload = true } = {}) {
  clearSessionStorage();
  for (const instance of LocalIndexedDb.connectedInstances) {
    await instance.close();
  }
  await Promise.all(getAllIndexDbNames().map((db) => deleteDB(db)));
  clearLocalStorage();
  if (shouldReload) {
    window.location.reload();
  }
}
var init_hardReset = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/sync/hardReset.mjs"() {
    init_dist_esm2();
    init_build();
    init_LocalIndexedDb();
    if (typeof window !== "undefined") {
      if (false) {
        ;
        window.hardReset = hardReset;
      }
      ;
      window.__tldraw__hardReset = hardReset;
    }
  }
});

// node_modules/@tldraw/editor/dist-esm/lib/utils/window-open.mjs
function openWindow(url, target = "_blank") {
  runtime.openWindow(url, target);
}
var init_window_open = __esm({
  "node_modules/@tldraw/editor/dist-esm/lib/utils/window-open.mjs"() {
    init_runtime();
  }
});

// node_modules/@tldraw/editor/dist-esm/index.mjs
var import_at, import_flat_map, import_flat, import_at2, import_replace_all;
var init_dist_esm10 = __esm({
  "node_modules/@tldraw/editor/dist-esm/index.mjs"() {
    import_at = __toESM(require_at2(), 1);
    import_flat_map = __toESM(require_flat_map2(), 1);
    import_flat = __toESM(require_flat2(), 1);
    import_at2 = __toESM(require_at4(), 1);
    import_replace_all = __toESM(require_replace_all2(), 1);
    init_debug_flags();
    init_dist_esm4();
    init_dist_esm8();
    init_dist_esm2();
    init_dist_esm6();
    init_dist_esm();
    init_dist_esm9();
    init_TldrawEditor();
    init_ErrorBoundary();
    init_HTMLContainer();
    init_SVGContainer();
    init_DefaultBackground();
    init_DefaultBrush();
    init_DefaultCanvas();
    init_DefaultCollaboratorHint();
    init_DefaultCursor();
    init_DefaultErrorFallback();
    init_DefaultGrid();
    init_DefaultHandle();
    init_DefaultHandles();
    init_DefaultScribble();
    init_DefaultSelectionBackground();
    init_DefaultSelectionForeground();
    init_DefaultShapeIndicator();
    init_DefaultShapeIndicators();
    init_DefaultSnapIndictor();
    init_DefaultSpinner();
    init_DefaultSvgDefs();
    init_TLEditorSnapshot();
    init_TLSessionStateSnapshot();
    init_TLUserPreferences();
    init_createTLStore();
    init_createTLUser();
    init_defaultShapes();
    init_constants3();
    init_Editor();
    init_BindingUtil();
    init_ClickManager();
    init_EdgeScrollManager();
    init_EnvironmentManager();
    init_HistoryManager();
    init_ScribbleManager();
    init_BoundsSnaps();
    init_HandleSnaps();
    init_SnapManager();
    init_TextManager();
    init_UserPreferencesManager();
    init_BaseBoxShapeUtil();
    init_ShapeUtil();
    init_GroupShapeUtil();
    init_resizeBox();
    init_BaseBoxShapeTool();
    init_StateNode();
    init_SvgExportContext();
    init_event_types();
    init_useContainer();
    init_useCursor();
    init_useEditor();
    init_useEditorComponents();
    init_useEvent();
    init_useIdentity();
    init_useIsCropping();
    init_useIsDarkMode();
    init_useIsEditing();
    init_useLocalStore();
    init_usePeerIds();
    init_usePresence();
    init_useRefState();
    init_useSafeId();
    init_useSelectionEvents();
    init_useTLStore();
    init_useTransform();
    init_options();
    init_Box();
    init_Mat();
    init_Vec();
    init_easings();
    init_Arc2d();
    init_Circle2d();
    init_CubicBezier2d();
    init_CubicSpline2d();
    init_Edge2d();
    init_Ellipse2d();
    init_Geometry2d();
    init_Group2d();
    init_Point2d();
    init_Polygon2d();
    init_Polyline2d();
    init_Rectangle2d();
    init_Stadium2d();
    init_intersect();
    init_utils();
    init_SharedStylesMap();
    init_assets();
    init_debug_flags();
    init_dom();
    init_getIncrementedName();
    init_getPointerInfo();
    init_getSvgPathFromPoints();
    init_hardResetEditor();
    init_normalizeWheel();
    init_refreshPage();
    init_rotation();
    init_runtime();
    init_hardReset();
    init_uniq();
    init_uniqueId();
    init_window_open();
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawHandles.mjs
function TldrawHandles({ children }) {
  const editor = useEditor();
  const shouldDisplayHandles = useValue("shouldDisplayHandles", () => {
    if (editor.isInAny("select.idle", "select.pointing_handle", "select.pointing_shape")) {
      return true;
    }
    if (editor.isInAny("select.editing_shape")) {
      const onlySelectedShape = editor.getOnlySelectedShape();
      return onlySelectedShape && editor.isShapeOfType(onlySelectedShape, "note");
    }
    return false;
  }, [editor]);
  if (!shouldDisplayHandles)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("svg", { className: "tl-user-handles tl-overlays__item", children });
}
var import_jsx_runtime35;
var init_TldrawHandles = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawHandles.mjs"() {
    import_jsx_runtime35 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStrokeOutlinePoints.mjs
function getStrokeOutlineTracks(strokePoints, options = {}) {
  const { size: size4 = 16, smoothing = 0.5 } = options;
  if (strokePoints.length === 0 || size4 <= 0) {
    return { left: [], right: [] };
  }
  const firstStrokePoint = strokePoints[0];
  const lastStrokePoint = strokePoints[strokePoints.length - 1];
  const totalLength = lastStrokePoint.runningLength;
  const minDistance = Math.pow(size4 * smoothing, 2);
  const leftPts = [];
  const rightPts = [];
  let prevVector = strokePoints[0].vector;
  let pl = strokePoints[0].point;
  let pr = pl;
  let tl = pl;
  let tr = pr;
  let isPrevPointSharpCorner = false;
  let strokePoint;
  for (let i2 = 0; i2 < strokePoints.length; i2++) {
    strokePoint = strokePoints[i2];
    const { point, vector } = strokePoints[i2];
    const prevDpr = strokePoint.vector.dpr(prevVector);
    const nextVector = (i2 < strokePoints.length - 1 ? strokePoints[i2 + 1] : strokePoints[i2]).vector;
    const nextDpr = i2 < strokePoints.length - 1 ? nextVector.dpr(strokePoint.vector) : 1;
    const isPointSharpCorner = prevDpr < 0 && !isPrevPointSharpCorner;
    const isNextPointSharpCorner = nextDpr !== null && nextDpr < 0.2;
    if (isPointSharpCorner || isNextPointSharpCorner) {
      if (nextDpr > -0.62 && totalLength - strokePoint.runningLength > strokePoint.radius) {
        const offset22 = prevVector.clone().mul(strokePoint.radius);
        const cpr = prevVector.clone().cpr(nextVector);
        if (cpr < 0) {
          tl = Vec.Add(point, offset22);
          tr = Vec.Sub(point, offset22);
        } else {
          tl = Vec.Sub(point, offset22);
          tr = Vec.Add(point, offset22);
        }
        leftPts.push(tl);
        rightPts.push(tr);
      } else {
        const offset22 = prevVector.clone().mul(strokePoint.radius).per();
        const start2 = Vec.Sub(strokePoint.input, offset22);
        for (let step = 1 / 13, t3 = 0; t3 < 1; t3 += step) {
          tl = Vec.RotWith(start2, strokePoint.input, FIXED_PI * t3);
          leftPts.push(tl);
          tr = Vec.RotWith(start2, strokePoint.input, FIXED_PI + FIXED_PI * -t3);
          rightPts.push(tr);
        }
      }
      pl = tl;
      pr = tr;
      if (isNextPointSharpCorner) {
        isPrevPointSharpCorner = true;
      }
      continue;
    }
    isPrevPointSharpCorner = false;
    if (strokePoint === firstStrokePoint || strokePoint === lastStrokePoint) {
      const offset22 = Vec.Per(vector).mul(strokePoint.radius);
      leftPts.push(Vec.Sub(point, offset22));
      rightPts.push(Vec.Add(point, offset22));
      continue;
    }
    const offset5 = Vec.Lrp(nextVector, vector, nextDpr).per().mul(strokePoint.radius);
    tl = Vec.Sub(point, offset5);
    if (i2 <= 1 || Vec.Dist2(pl, tl) > minDistance) {
      leftPts.push(tl);
      pl = tl;
    }
    tr = Vec.Add(point, offset5);
    if (i2 <= 1 || Vec.Dist2(pr, tr) > minDistance) {
      rightPts.push(tr);
      pr = tr;
    }
    prevVector = vector;
    continue;
  }
  return {
    left: leftPts,
    right: rightPts
  };
}
function getStrokeOutlinePoints(strokePoints, options = {}) {
  const { size: size4 = 16, start: start2 = {}, end: end2 = {}, last: isComplete = false } = options;
  const { cap: capStart = true } = start2;
  const { cap: capEnd = true } = end2;
  if (strokePoints.length === 0 || size4 <= 0) {
    return [];
  }
  const firstStrokePoint = strokePoints[0];
  const lastStrokePoint = strokePoints[strokePoints.length - 1];
  const totalLength = lastStrokePoint.runningLength;
  const taperStart = start2.taper === false ? 0 : start2.taper === true ? Math.max(size4, totalLength) : start2.taper;
  const taperEnd = end2.taper === false ? 0 : end2.taper === true ? Math.max(size4, totalLength) : end2.taper;
  const { left: leftPts, right: rightPts } = getStrokeOutlineTracks(strokePoints, options);
  const firstPoint = firstStrokePoint.point;
  const lastPoint = strokePoints.length > 1 ? strokePoints[strokePoints.length - 1].point : Vec.AddXY(firstStrokePoint.point, 1, 1);
  if (strokePoints.length === 1) {
    if (!(taperStart || taperEnd) || isComplete) {
      const start22 = Vec.Add(firstPoint, Vec.Sub(firstPoint, lastPoint).uni().per().mul(-firstStrokePoint.radius));
      const dotPts = [];
      for (let step = 1 / 13, t3 = step; t3 <= 1; t3 += step) {
        dotPts.push(Vec.RotWith(start22, firstPoint, FIXED_PI * 2 * t3));
      }
      return dotPts;
    }
  }
  const startCap = [];
  if (taperStart || taperEnd && strokePoints.length === 1) {
  } else if (capStart) {
    for (let step = 1 / 8, t3 = step; t3 <= 1; t3 += step) {
      const pt = Vec.RotWith(rightPts[0], firstPoint, FIXED_PI * t3);
      startCap.push(pt);
    }
  } else {
    const cornersVector = Vec.Sub(leftPts[0], rightPts[0]);
    const offsetA = Vec.Mul(cornersVector, 0.5);
    const offsetB = Vec.Mul(cornersVector, 0.51);
    startCap.push(Vec.Sub(firstPoint, offsetA), Vec.Sub(firstPoint, offsetB), Vec.Add(firstPoint, offsetB), Vec.Add(firstPoint, offsetA));
  }
  const endCap = [];
  const direction = lastStrokePoint.vector.clone().per().neg();
  if (taperEnd || taperStart && strokePoints.length === 1) {
    endCap.push(lastPoint);
  } else if (capEnd) {
    const start22 = Vec.Add(lastPoint, Vec.Mul(direction, lastStrokePoint.radius));
    for (let step = 1 / 29, t3 = step; t3 < 1; t3 += step) {
      endCap.push(Vec.RotWith(start22, lastPoint, FIXED_PI * 3 * t3));
    }
  } else {
    endCap.push(Vec.Add(lastPoint, Vec.Mul(direction, lastStrokePoint.radius)), Vec.Add(lastPoint, Vec.Mul(direction, lastStrokePoint.radius * 0.99)), Vec.Sub(lastPoint, Vec.Mul(direction, lastStrokePoint.radius * 0.99)), Vec.Sub(lastPoint, Vec.Mul(direction, lastStrokePoint.radius)));
  }
  return leftPts.concat(endCap, rightPts.reverse(), startCap);
}
var PI3, FIXED_PI;
var init_getStrokeOutlinePoints = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStrokeOutlinePoints.mjs"() {
    init_dist_esm10();
    ({ PI: PI3 } = Math);
    FIXED_PI = PI3 + 1e-4;
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStrokePoints.mjs
function getStrokePoints(rawInputPoints, options = {}) {
  const { streamline = 0.5, size: size4 = 16, simulatePressure = false } = options;
  if (rawInputPoints.length === 0)
    return [];
  const t3 = 0.15 + (1 - streamline) * 0.85;
  let pts = rawInputPoints.map(Vec.From);
  let pointsRemovedFromNearEnd = 0;
  if (!simulatePressure) {
    let pt2 = pts[0];
    while (pt2) {
      if (pt2.z >= MIN_START_PRESSURE)
        break;
      pts.shift();
      pt2 = pts[0];
    }
  }
  if (!simulatePressure) {
    let pt2 = pts[pts.length - 1];
    while (pt2) {
      if (pt2.z >= MIN_END_PRESSURE)
        break;
      pts.pop();
      pt2 = pts[pts.length - 1];
    }
  }
  if (pts.length === 0)
    return [
      {
        point: Vec.From(rawInputPoints[0]),
        input: Vec.From(rawInputPoints[0]),
        pressure: simulatePressure ? 0.5 : 0.15,
        vector: new Vec(1, 1),
        distance: 0,
        runningLength: 0,
        radius: 1
      }
    ];
  let pt = pts[1];
  while (pt) {
    if (Vec.Dist2(pt, pts[0]) > (size4 / 3) ** 2)
      break;
    pts[0].z = Math.max(pts[0].z, pt.z);
    pts.splice(1, 1);
    pt = pts[1];
  }
  const last7 = pts.pop();
  pt = pts[pts.length - 1];
  while (pt) {
    if (Vec.Dist2(pt, last7) > (size4 / 3) ** 2)
      break;
    pts.pop();
    pt = pts[pts.length - 1];
    pointsRemovedFromNearEnd++;
  }
  pts.push(last7);
  const isComplete = options.last || !options.simulatePressure || pts.length > 1 && Vec.Dist2(pts[pts.length - 1], pts[pts.length - 2]) < size4 ** 2 || pointsRemovedFromNearEnd > 0;
  if (pts.length === 2 && options.simulatePressure) {
    const last22 = pts[1];
    pts = pts.slice(0, -1);
    for (let i2 = 1; i2 < 5; i2++) {
      const next = Vec.Lrp(pts[0], last22, i2 / 4);
      next.z = (pts[0].z + (last22.z - pts[0].z)) * i2 / 4;
      pts.push(next);
    }
  }
  const strokePoints = [
    {
      point: pts[0],
      input: pts[0],
      pressure: simulatePressure ? 0.5 : pts[0].z,
      vector: new Vec(1, 1),
      distance: 0,
      runningLength: 0,
      radius: 1
    }
  ];
  let totalLength = 0;
  let prev = strokePoints[0];
  let point, distance;
  if (isComplete && streamline > 0) {
    pts.push(pts[pts.length - 1].clone());
  }
  for (let i2 = 1, n2 = pts.length; i2 < n2; i2++) {
    point = !t3 || options.last && i2 === n2 - 1 ? pts[i2].clone() : pts[i2].clone().lrp(prev.point, 1 - t3);
    if (prev.point.equals(point))
      continue;
    distance = Vec.Dist(point, prev.point);
    totalLength += distance;
    if (i2 < 4 && totalLength < size4) {
      continue;
    }
    prev = {
      input: pts[i2],
      point,
      pressure: simulatePressure ? 0.5 : pts[i2].z,
      vector: Vec.Sub(prev.point, point).uni(),
      distance,
      runningLength: totalLength,
      radius: 1
    };
    strokePoints.push(prev);
  }
  if (strokePoints[1]?.vector) {
    strokePoints[0].vector = strokePoints[1].vector.clone();
  }
  if (totalLength < 1) {
    const maxPressureAmongPoints = Math.max(0.5, ...strokePoints.map((s2) => s2.pressure));
    strokePoints.forEach((s2) => s2.pressure = maxPressureAmongPoints);
  }
  return strokePoints;
}
var MIN_START_PRESSURE, MIN_END_PRESSURE;
var init_getStrokePoints = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStrokePoints.mjs"() {
    init_dist_esm10();
    MIN_START_PRESSURE = 0.025;
    MIN_END_PRESSURE = 0.01;
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/setStrokePointRadii.mjs
function setStrokePointRadii(strokePoints, options) {
  const {
    size: size4 = 16,
    thinning = 0.5,
    simulatePressure = true,
    easing = (t3) => t3,
    start: start2 = {},
    end: end2 = {}
  } = options;
  const { easing: taperStartEase = EASINGS.easeOutQuad } = start2;
  const { easing: taperEndEase = EASINGS.easeOutCubic } = end2;
  const totalLength = strokePoints[strokePoints.length - 1].runningLength;
  let firstRadius;
  let prevPressure = strokePoints[0].pressure;
  let strokePoint;
  if (!simulatePressure && totalLength < size4) {
    const max3 = strokePoints.reduce((max22, curr) => Math.max(max22, curr.pressure), 0.5);
    strokePoints.forEach((sp) => {
      sp.pressure = max3;
      sp.radius = size4 * easing(0.5 - thinning * (0.5 - sp.pressure));
    });
    return strokePoints;
  } else {
    let p2;
    for (let i2 = 0, n2 = strokePoints.length; i2 < n2; i2++) {
      strokePoint = strokePoints[i2];
      if (strokePoint.runningLength > size4 * 5)
        break;
      const sp = min(1, strokePoint.distance / size4);
      if (simulatePressure) {
        const rp = min(1, 1 - sp);
        p2 = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
      } else {
        p2 = min(1, prevPressure + (strokePoint.pressure - prevPressure) * 0.5);
      }
      prevPressure = prevPressure + (p2 - prevPressure) * 0.5;
    }
    for (let i2 = 0; i2 < strokePoints.length; i2++) {
      strokePoint = strokePoints[i2];
      if (thinning) {
        let { pressure } = strokePoint;
        const sp = min(1, strokePoint.distance / size4);
        if (simulatePressure) {
          const rp = min(1, 1 - sp);
          pressure = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
        } else {
          pressure = min(1, prevPressure + (pressure - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
        }
        strokePoint.radius = size4 * easing(0.5 - thinning * (0.5 - pressure));
        prevPressure = pressure;
      } else {
        strokePoint.radius = size4 / 2;
      }
      if (firstRadius === void 0) {
        firstRadius = strokePoint.radius;
      }
    }
  }
  const taperStart = start2.taper === false ? 0 : start2.taper === true ? Math.max(size4, totalLength) : start2.taper;
  const taperEnd = end2.taper === false ? 0 : end2.taper === true ? Math.max(size4, totalLength) : end2.taper;
  if (taperStart || taperEnd) {
    for (let i2 = 0; i2 < strokePoints.length; i2++) {
      strokePoint = strokePoints[i2];
      const { runningLength } = strokePoint;
      const ts = runningLength < taperStart ? taperStartEase(runningLength / taperStart) : 1;
      const te2 = totalLength - runningLength < taperEnd ? taperEndEase((totalLength - runningLength) / taperEnd) : 1;
      strokePoint.radius = Math.max(0.01, strokePoint.radius * Math.min(ts, te2));
    }
  }
  return strokePoints;
}
var min, RATE_OF_PRESSURE_CHANGE;
var init_setStrokePointRadii = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/setStrokePointRadii.mjs"() {
    init_dist_esm10();
    ({ min } = Math);
    RATE_OF_PRESSURE_CHANGE = 0.275;
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStroke.mjs
function getStroke(points, options = {}) {
  return getStrokeOutlinePoints(setStrokePointRadii(getStrokePoints(points, options), options), options);
}
var init_getStroke = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/getStroke.mjs"() {
    init_getStrokeOutlinePoints();
    init_getStrokePoints();
    init_setStrokePointRadii();
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawScribble.mjs
function TldrawScribble({ scribble, zoom, color, opacity, className }) {
  if (!scribble.points.length)
    return null;
  const stroke = getStroke(scribble.points, {
    size: scribble.size / zoom,
    start: { taper: scribble.taper, easing: EASINGS.linear },
    last: scribble.state === "stopping",
    simulatePressure: false,
    streamline: 0.32
  });
  let d2;
  if (stroke.length < 4) {
    const r2 = scribble.size / zoom / 2;
    const { x: x2, y: y2 } = scribble.points[scribble.points.length - 1];
    d2 = `M ${x2 - r2},${y2} a ${r2},${r2} 0 1,0 ${r2 * 2},0 a ${r2},${r2} 0 1,0 ${-r2 * 2},0`;
  } else {
    d2 = getSvgPathFromPoints(stroke);
  }
  return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("svg", { className: className ? (0, import_classnames13.default)("tl-overlays__item", className) : className, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("path", {
    className: "tl-scribble",
    d: d2,
    fill: color ?? `var(--color-${scribble.color})`,
    opacity: opacity ?? scribble.opacity
  }) });
}
var import_jsx_runtime36, import_classnames13;
var init_TldrawScribble = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawScribble.mjs"() {
    import_jsx_runtime36 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames13 = __toESM(require_classnames(), 1);
    init_getStroke();
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawSelectionBackground.mjs
var import_jsx_runtime37, TldrawSelectionBackground;
var init_TldrawSelectionBackground = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawSelectionBackground.mjs"() {
    import_jsx_runtime37 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    TldrawSelectionBackground = ({ bounds, rotation }) => {
      const editor = useEditor();
      const shouldDisplay = useValue("should display", () => editor.isInAny("select.idle", "select.brushing", "select.scribble_brushing", "select.pointing_shape", "select.pointing_selection", "text.resizing"), [editor]);
      if (!shouldDisplay)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(DefaultSelectionBackground, { bounds, rotation });
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useReadonly.mjs
function useReadonly() {
  const editor = useEditor();
  return useValue("isReadonlyMode", () => editor.getInstanceState().isReadonly, [editor]);
}
var init_useReadonly = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useReadonly.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawCropHandles.mjs
function TldrawCropHandles({
  size: size4,
  width,
  height,
  hideAlternateHandles
}) {
  const cropStrokeWidth = toDomPrecision(size4 / 3);
  const offset5 = cropStrokeWidth / 2;
  return /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)("svg", { className: "tl-overlays__item", children: [
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("polyline", {
      className: "tl-corner-crop-handle",
      points: `
						${toDomPrecision(0 - offset5)},${toDomPrecision(size4)} 
						${toDomPrecision(0 - offset5)},${toDomPrecision(0 - offset5)} 
						${toDomPrecision(size4)},${toDomPrecision(0 - offset5)}`,
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.top_left",
      "aria-label": "top_left handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("line", {
      className: (0, import_classnames14.default)("tl-corner-crop-edge-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      x1: toDomPrecision(width / 2 - size4),
      y1: toDomPrecision(0 - offset5),
      x2: toDomPrecision(width / 2 + size4),
      y2: toDomPrecision(0 - offset5),
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.top",
      "aria-label": "top handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("polyline", {
      className: (0, import_classnames14.default)("tl-corner-crop-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      points: `
						${toDomPrecision(width - size4)},${toDomPrecision(0 - offset5)} 
						${toDomPrecision(width + offset5)},${toDomPrecision(0 - offset5)} 
						${toDomPrecision(width + offset5)},${toDomPrecision(size4)}`,
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.top_right",
      "aria-label": "top_right handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("line", {
      className: (0, import_classnames14.default)("tl-corner-crop-edge-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      x1: toDomPrecision(width + offset5),
      y1: toDomPrecision(height / 2 - size4),
      x2: toDomPrecision(width + offset5),
      y2: toDomPrecision(height / 2 + size4),
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.right",
      "aria-label": "right handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("polyline", {
      className: "tl-corner-crop-handle",
      points: `
						${toDomPrecision(width + offset5)},${toDomPrecision(height - size4)} 
						${toDomPrecision(width + offset5)},${toDomPrecision(height + offset5)}
						${toDomPrecision(width - size4)},${toDomPrecision(height + offset5)}`,
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.bottom_right",
      "aria-label": "bottom_right handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("line", {
      className: (0, import_classnames14.default)("tl-corner-crop-edge-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      x1: toDomPrecision(width / 2 - size4),
      y1: toDomPrecision(height + offset5),
      x2: toDomPrecision(width / 2 + size4),
      y2: toDomPrecision(height + offset5),
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.bottom",
      "aria-label": "bottom handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("polyline", {
      className: (0, import_classnames14.default)("tl-corner-crop-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      points: `
						${toDomPrecision(0 + size4)},${toDomPrecision(height + offset5)} 
						${toDomPrecision(0 - offset5)},${toDomPrecision(height + offset5)}
						${toDomPrecision(0 - offset5)},${toDomPrecision(height - size4)}`,
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.bottom_left",
      "aria-label": "bottom_left handle"
    }),
    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("line", {
      className: (0, import_classnames14.default)("tl-corner-crop-edge-handle", {
        "tl-hidden": hideAlternateHandles
      }),
      x1: toDomPrecision(0 - offset5),
      y1: toDomPrecision(height / 2 - size4),
      x2: toDomPrecision(0 - offset5),
      y2: toDomPrecision(height / 2 + size4),
      strokeWidth: cropStrokeWidth,
      "data-testid": "selection.crop.left",
      "aria-label": "left handle"
    })
  ] });
}
var import_jsx_runtime38, import_classnames14;
var init_TldrawCropHandles = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawCropHandles.mjs"() {
    import_jsx_runtime38 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames14 = __toESM(require_classnames(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawSelectionForeground.mjs
var import_jsx_runtime39, import_classnames15, import_react46, TldrawSelectionForeground, RotateCornerHandle, SQUARE_ROOT_PI, MobileRotateHandle;
var init_TldrawSelectionForeground = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawSelectionForeground.mjs"() {
    import_jsx_runtime39 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames15 = __toESM(require_classnames(), 1);
    import_react46 = __toESM(require_react(), 1);
    init_useReadonly();
    init_TldrawCropHandles();
    TldrawSelectionForeground = track(function TldrawSelectionForeground2({
      bounds,
      rotation
    }) {
      const editor = useEditor();
      const rSvg = (0, import_react46.useRef)(null);
      const isReadonlyMode = useReadonly();
      const topEvents = useSelectionEvents("top");
      const rightEvents = useSelectionEvents("right");
      const bottomEvents = useSelectionEvents("bottom");
      const leftEvents = useSelectionEvents("left");
      const topLeftEvents = useSelectionEvents("top_left");
      const topRightEvents = useSelectionEvents("top_right");
      const bottomRightEvents = useSelectionEvents("bottom_right");
      const bottomLeftEvents = useSelectionEvents("bottom_left");
      const isDefaultCursor = !editor.getIsMenuOpen() && editor.getInstanceState().cursor.type === "default";
      const isCoarsePointer = editor.getInstanceState().isCoarsePointer;
      const onlyShape = editor.getOnlySelectedShape();
      const isLockedShape = onlyShape && editor.isShapeOrAncestorLocked(onlyShape);
      const expandOutlineBy = onlyShape ? editor.getShapeUtil(onlyShape).expandSelectionOutlinePx(onlyShape) : 0;
      useTransform(rSvg, bounds?.x, bounds?.y, 1, editor.getSelectionRotation(), {
        x: -expandOutlineBy,
        y: -expandOutlineBy
      });
      if (!bounds)
        return null;
      bounds = bounds.clone().expandBy(expandOutlineBy).zeroFix();
      const zoom = editor.getZoomLevel();
      const isChangingStyle = editor.getInstanceState().isChangingStyle;
      const width = bounds.width;
      const height = bounds.height;
      const size4 = 8 / zoom;
      const isTinyX = width < size4 * 2;
      const isTinyY = height < size4 * 2;
      const isSmallX = width < size4 * 4;
      const isSmallY = height < size4 * 4;
      const isSmallCropX = width < size4 * 5;
      const isSmallCropY = height < size4 * 5;
      const mobileHandleMultiplier = isCoarsePointer ? 1.75 : 1;
      const targetSize = 6 / zoom * mobileHandleMultiplier;
      const targetSizeX = (isSmallX ? targetSize / 2 : targetSize) * (mobileHandleMultiplier * 0.75);
      const targetSizeY = (isSmallY ? targetSize / 2 : targetSize) * (mobileHandleMultiplier * 0.75);
      const showSelectionBounds = (onlyShape ? !editor.getShapeUtil(onlyShape).hideSelectionBoundsFg(onlyShape) : true) && !isChangingStyle;
      let shouldDisplayBox = showSelectionBounds && editor.isInAny("select.idle", "select.brushing", "select.scribble_brushing", "select.pointing_canvas", "select.pointing_selection", "select.pointing_shape", "select.crop.idle", "select.crop.pointing_crop", "select.crop.pointing_crop_handle", "select.pointing_resize_handle") || showSelectionBounds && editor.isIn("select.resizing") && onlyShape && editor.isShapeOfType(onlyShape, "text");
      if (onlyShape && shouldDisplayBox) {
        if (editor.environment.isFirefox && editor.isShapeOfType(onlyShape, "embed")) {
          shouldDisplayBox = false;
        }
      }
      const showCropHandles = editor.isInAny("select.crop.idle", "select.crop.pointing_crop", "select.crop.pointing_crop_handle") && !isChangingStyle && !isReadonlyMode;
      const shouldDisplayControls = editor.isInAny("select.idle", "select.pointing_selection", "select.pointing_shape", "select.crop.idle") && !isChangingStyle && !isReadonlyMode;
      const showCornerRotateHandles = !isCoarsePointer && !(isTinyX || isTinyY) && (shouldDisplayControls || showCropHandles) && (onlyShape ? !editor.getShapeUtil(onlyShape).hideRotateHandle(onlyShape) : true) && !isLockedShape;
      const showMobileRotateHandle = isCoarsePointer && (!isSmallX || !isSmallY) && (shouldDisplayControls || showCropHandles) && (onlyShape ? !editor.getShapeUtil(onlyShape).hideRotateHandle(onlyShape) : true) && !isLockedShape;
      const showResizeHandles = shouldDisplayControls && (onlyShape ? editor.getShapeUtil(onlyShape).canResize(onlyShape) && !editor.getShapeUtil(onlyShape).hideResizeHandles(onlyShape) : true) && !showCropHandles && !isLockedShape;
      const hideAlternateCornerHandles = isTinyX || isTinyY;
      const showOnlyOneHandle = isTinyX && isTinyY;
      const hideAlternateCropHandles = isSmallCropX || isSmallCropY;
      const showHandles = showResizeHandles || showCropHandles;
      const hideRotateCornerHandles = !showCornerRotateHandles;
      const hideMobileRotateHandle = !shouldDisplayControls || !showMobileRotateHandle;
      const hideTopLeftCorner = !shouldDisplayControls || !showHandles;
      const hideTopRightCorner = !shouldDisplayControls || !showHandles || hideAlternateCornerHandles;
      const hideBottomLeftCorner = !shouldDisplayControls || !showHandles || hideAlternateCornerHandles;
      const hideBottomRightCorner = !shouldDisplayControls || !showHandles || showOnlyOneHandle && !showCropHandles;
      let hideVerticalEdgeTargets = true;
      let hideHorizontalEdgeTargets = true;
      if (showCropHandles) {
        hideVerticalEdgeTargets = hideAlternateCropHandles;
        hideHorizontalEdgeTargets = hideAlternateCropHandles;
      } else if (showResizeHandles) {
        hideVerticalEdgeTargets = hideAlternateCornerHandles || showOnlyOneHandle || isCoarsePointer;
        const isMobileAndTextShape = isCoarsePointer && onlyShape && onlyShape.type === "text";
        hideHorizontalEdgeTargets = hideVerticalEdgeTargets && !isMobileAndTextShape;
      }
      const textHandleHeight = Math.min(24 / zoom, height - targetSizeY * 3);
      const showTextResizeHandles = shouldDisplayControls && isCoarsePointer && onlyShape && editor.isShapeOfType(onlyShape, "text") && textHandleHeight * zoom >= 4;
      return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("svg", { className: "tl-overlays__item tl-selection__fg", "data-testid": "selection-foreground", children: /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("g", { ref: rSvg, children: [
        shouldDisplayBox && /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: "tl-selection__fg__outline",
          width: toDomPrecision(width),
          height: toDomPrecision(height)
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(RotateCornerHandle, {
          "data-testid": "selection.rotate.top-left",
          cx: 0,
          cy: 0,
          targetSize,
          corner: "top_left_rotate",
          cursor: isDefaultCursor ? getCursor("nwse-rotate", rotation) : void 0,
          isHidden: hideRotateCornerHandles
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(RotateCornerHandle, {
          "data-testid": "selection.rotate.top-right",
          cx: width + targetSize * 3,
          cy: 0,
          targetSize,
          corner: "top_right_rotate",
          cursor: isDefaultCursor ? getCursor("nesw-rotate", rotation) : void 0,
          isHidden: hideRotateCornerHandles
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(RotateCornerHandle, {
          "data-testid": "selection.rotate.bottom-left",
          cx: 0,
          cy: height + targetSize * 3,
          targetSize,
          corner: "bottom_left_rotate",
          cursor: isDefaultCursor ? getCursor("swne-rotate", rotation) : void 0,
          isHidden: hideRotateCornerHandles
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(RotateCornerHandle, {
          "data-testid": "selection.rotate.bottom-right",
          cx: width + targetSize * 3,
          cy: height + targetSize * 3,
          targetSize,
          corner: "bottom_right_rotate",
          cursor: isDefaultCursor ? getCursor("senw-rotate", rotation) : void 0,
          isHidden: hideRotateCornerHandles
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(MobileRotateHandle, {
          "data-testid": "selection.rotate.mobile",
          cx: isSmallX ? -targetSize * 1.5 : width / 2,
          cy: isSmallX ? height / 2 : -targetSize * 1.5,
          size: size4,
          isHidden: hideMobileRotateHandle
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideVerticalEdgeTargets
          }),
          "data-testid": "selection.resize.top",
          "aria-label": "top target",
          pointerEvents: "all",
          x: 0,
          y: toDomPrecision(0 - (isSmallY ? targetSizeY * 2 : targetSizeY)),
          width: toDomPrecision(width),
          height: toDomPrecision(Math.max(1, targetSizeY * 2)),
          style: isDefaultCursor ? { cursor: getCursor("ns-resize", rotation) } : void 0,
          ...topEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideHorizontalEdgeTargets
          }),
          "data-testid": "selection.resize.right",
          "aria-label": "right target",
          pointerEvents: "all",
          x: toDomPrecision(width - (isSmallX ? 0 : targetSizeX)),
          y: 0,
          height: toDomPrecision(height),
          width: toDomPrecision(Math.max(1, targetSizeX * 2)),
          style: isDefaultCursor ? { cursor: getCursor("ew-resize", rotation) } : void 0,
          ...rightEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideVerticalEdgeTargets
          }),
          "data-testid": "selection.resize.bottom",
          "aria-label": "bottom target",
          pointerEvents: "all",
          x: 0,
          y: toDomPrecision(height - (isSmallY ? 0 : targetSizeY)),
          width: toDomPrecision(width),
          height: toDomPrecision(Math.max(1, targetSizeY * 2)),
          style: isDefaultCursor ? { cursor: getCursor("ns-resize", rotation) } : void 0,
          ...bottomEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideHorizontalEdgeTargets
          }),
          "data-testid": "selection.resize.left",
          "aria-label": "left target",
          pointerEvents: "all",
          x: toDomPrecision(0 - (isSmallX ? targetSizeX * 2 : targetSizeX)),
          y: 0,
          height: toDomPrecision(height),
          width: toDomPrecision(Math.max(1, targetSizeX * 2)),
          style: isDefaultCursor ? { cursor: getCursor("ew-resize", rotation) } : void 0,
          ...leftEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideTopLeftCorner
          }),
          "data-testid": "selection.target.top-left",
          "aria-label": "top-left target",
          pointerEvents: "all",
          x: toDomPrecision(0 - (isSmallX ? targetSizeX * 2 : targetSizeX * 1.5)),
          y: toDomPrecision(0 - (isSmallY ? targetSizeY * 2 : targetSizeY * 1.5)),
          width: toDomPrecision(targetSizeX * 3),
          height: toDomPrecision(targetSizeY * 3),
          style: isDefaultCursor ? { cursor: getCursor("nwse-resize", rotation) } : void 0,
          ...topLeftEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideTopRightCorner
          }),
          "data-testid": "selection.target.top-right",
          "aria-label": "top-right target",
          pointerEvents: "all",
          x: toDomPrecision(width - (isSmallX ? 0 : targetSizeX * 1.5)),
          y: toDomPrecision(0 - (isSmallY ? targetSizeY * 2 : targetSizeY * 1.5)),
          width: toDomPrecision(targetSizeX * 3),
          height: toDomPrecision(targetSizeY * 3),
          style: isDefaultCursor ? { cursor: getCursor("nesw-resize", rotation) } : void 0,
          ...topRightEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideBottomRightCorner
          }),
          "data-testid": "selection.target.bottom-right",
          "aria-label": "bottom-right target",
          pointerEvents: "all",
          x: toDomPrecision(width - (isSmallX ? targetSizeX : targetSizeX * 1.5)),
          y: toDomPrecision(height - (isSmallY ? targetSizeY : targetSizeY * 1.5)),
          width: toDomPrecision(targetSizeX * 3),
          height: toDomPrecision(targetSizeY * 3),
          style: isDefaultCursor ? { cursor: getCursor("nwse-resize", rotation) } : void 0,
          ...bottomRightEvents
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
          className: (0, import_classnames15.default)("tl-transparent", {
            "tl-hidden": hideBottomLeftCorner
          }),
          "data-testid": "selection.target.bottom-left",
          "aria-label": "bottom-left target",
          pointerEvents: "all",
          x: toDomPrecision(0 - (isSmallX ? targetSizeX * 3 : targetSizeX * 1.5)),
          y: toDomPrecision(height - (isSmallY ? 0 : targetSizeY * 1.5)),
          width: toDomPrecision(targetSizeX * 3),
          height: toDomPrecision(targetSizeY * 3),
          style: isDefaultCursor ? { cursor: getCursor("nesw-resize", rotation) } : void 0,
          ...bottomLeftEvents
        }),
        showResizeHandles && /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)(import_jsx_runtime39.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.resize.top-left",
            className: (0, import_classnames15.default)("tl-corner-handle", {
              "tl-hidden": hideTopLeftCorner
            }),
            "aria-label": "top_left handle",
            x: toDomPrecision(0 - size4 / 2),
            y: toDomPrecision(0 - size4 / 2),
            width: toDomPrecision(size4),
            height: toDomPrecision(size4)
          }),
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.resize.top-right",
            className: (0, import_classnames15.default)("tl-corner-handle", {
              "tl-hidden": hideTopRightCorner
            }),
            "aria-label": "top_right handle",
            x: toDomPrecision(width - size4 / 2),
            y: toDomPrecision(0 - size4 / 2),
            width: toDomPrecision(size4),
            height: toDomPrecision(size4)
          }),
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.resize.bottom-right",
            className: (0, import_classnames15.default)("tl-corner-handle", {
              "tl-hidden": hideBottomRightCorner
            }),
            "aria-label": "bottom_right handle",
            x: toDomPrecision(width - size4 / 2),
            y: toDomPrecision(height - size4 / 2),
            width: toDomPrecision(size4),
            height: toDomPrecision(size4)
          }),
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.resize.bottom-left",
            className: (0, import_classnames15.default)("tl-corner-handle", {
              "tl-hidden": hideBottomLeftCorner
            }),
            "aria-label": "bottom_left handle",
            x: toDomPrecision(0 - size4 / 2),
            y: toDomPrecision(height - size4 / 2),
            width: toDomPrecision(size4),
            height: toDomPrecision(size4)
          })
        ] }),
        showTextResizeHandles && /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)(import_jsx_runtime39.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.text-resize.left.handle",
            className: "tl-text-handle",
            "aria-label": "bottom_left handle",
            x: toDomPrecision(0 - size4 / 4),
            y: toDomPrecision(height / 2 - textHandleHeight / 2),
            rx: size4 / 4,
            width: toDomPrecision(size4 / 2),
            height: toDomPrecision(textHandleHeight)
          }),
          /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
            "data-testid": "selection.text-resize.right.handle",
            className: "tl-text-handle",
            "aria-label": "bottom_left handle",
            rx: size4 / 4,
            x: toDomPrecision(width - size4 / 4),
            y: toDomPrecision(height / 2 - textHandleHeight / 2),
            width: toDomPrecision(size4 / 2),
            height: toDomPrecision(textHandleHeight)
          })
        ] }),
        showCropHandles && /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(TldrawCropHandles, {
          ...{
            size: size4,
            width,
            height,
            hideAlternateHandles: hideAlternateCropHandles
          }
        })
      ] }) });
    });
    RotateCornerHandle = function RotateCornerHandle2({
      cx,
      cy,
      targetSize,
      corner,
      cursor,
      isHidden: isHidden2,
      "data-testid": testId
    }) {
      const events = useSelectionEvents(corner);
      return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("rect", {
        className: (0, import_classnames15.default)("tl-transparent", "tl-rotate-corner", { "tl-hidden": isHidden2 }),
        "data-testid": testId,
        "aria-label": `${corner} target`,
        pointerEvents: "all",
        x: toDomPrecision(cx - targetSize * 3),
        y: toDomPrecision(cy - targetSize * 3),
        width: toDomPrecision(Math.max(1, targetSize * 3)),
        height: toDomPrecision(Math.max(1, targetSize * 3)),
        cursor,
        ...events
      });
    };
    SQUARE_ROOT_PI = Math.sqrt(Math.PI);
    MobileRotateHandle = function RotateHandle({
      cx,
      cy,
      size: size4,
      isHidden: isHidden2,
      "data-testid": testId
    }) {
      const events = useSelectionEvents("mobile_rotate");
      const editor = useEditor();
      const zoom = useValue("zoom level", () => editor.getZoomLevel(), [editor]);
      const bgRadius = Math.max(14 * (1 / zoom), 20 / Math.max(1, zoom));
      return /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("g", { children: [
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("circle", {
          "data-testid": testId,
          pointerEvents: "all",
          className: (0, import_classnames15.default)("tl-transparent", "tl-mobile-rotate__bg", { "tl-hidden": isHidden2 }),
          cx,
          cy,
          r: bgRadius,
          ...events
        }),
        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("circle", {
          className: (0, import_classnames15.default)("tl-mobile-rotate__fg", { "tl-hidden": isHidden2 }),
          cx,
          cy,
          r: size4 / SQUARE_ROOT_PI
        })
      ] });
    };
  }
});

// node_modules/tldraw/dist-esm/lib/canvas/TldrawShapeIndicators.mjs
function TldrawShapeIndicators() {
  const editor = useEditor();
  const isInSelectState = useValue("is in a valid select state", () => {
    return editor.isInAny("select.idle", "select.brushing", "select.scribble_brushing", "select.editing_shape", "select.pointing_shape", "select.pointing_selection", "select.pointing_handle");
  }, [editor]);
  if (!isInSelectState)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(DefaultShapeIndicators, {});
}
var import_jsx_runtime40;
var init_TldrawShapeIndicators = __esm({
  "node_modules/tldraw/dist-esm/lib/canvas/TldrawShapeIndicators.mjs"() {
    import_jsx_runtime40 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/straight-arrow.mjs
function getStraightArrowInfo(editor, shape, bindings) {
  const { arrowheadStart, arrowheadEnd } = shape.props;
  const terminalsInArrowSpace = getArrowTerminalsInArrowSpace(editor, shape, bindings);
  const a2 = terminalsInArrowSpace.start.clone();
  const b2 = terminalsInArrowSpace.end.clone();
  const c2 = Vec.Med(a2, b2);
  if (Vec.Equals(a2, b2)) {
    return {
      bindings,
      isStraight: true,
      start: {
        handle: a2,
        point: a2,
        arrowhead: shape.props.arrowheadStart
      },
      end: {
        handle: b2,
        point: b2,
        arrowhead: shape.props.arrowheadEnd
      },
      middle: c2,
      isValid: false,
      length: 0
    };
  }
  const uAB = Vec.Sub(b2, a2).uni();
  const startShapeInfo = getBoundShapeInfoForTerminal(editor, shape, "start");
  const endShapeInfo = getBoundShapeInfoForTerminal(editor, shape, "end");
  const arrowPageTransform = editor.getShapePageTransform(shape);
  updateArrowheadPointWithBoundShape(b2, terminalsInArrowSpace.start, arrowPageTransform, endShapeInfo);
  updateArrowheadPointWithBoundShape(a2, terminalsInArrowSpace.end, arrowPageTransform, startShapeInfo);
  let offsetA = 0;
  let offsetB = 0;
  let strokeOffsetA = 0;
  let strokeOffsetB = 0;
  let minLength = MIN_ARROW_LENGTH * shape.props.scale;
  const isSelfIntersection = startShapeInfo && endShapeInfo && startShapeInfo.shape === endShapeInfo.shape;
  const relationship = startShapeInfo && endShapeInfo ? getBoundShapeRelationships(editor, startShapeInfo.shape.id, endShapeInfo.shape.id) : "safe";
  if (relationship === "safe" && startShapeInfo && endShapeInfo && !isSelfIntersection && !startShapeInfo.isExact && !endShapeInfo.isExact) {
    if (endShapeInfo.didIntersect && !startShapeInfo.didIntersect) {
      if (startShapeInfo.isClosed) {
        a2.setTo(b2.clone().add(uAB.clone().mul(MIN_ARROW_LENGTH * shape.props.scale)));
      }
    } else if (!endShapeInfo.didIntersect) {
      if (endShapeInfo.isClosed) {
        b2.setTo(a2.clone().sub(uAB.clone().mul(MIN_ARROW_LENGTH * shape.props.scale)));
      }
    }
  }
  const distance = Vec.Sub(b2, a2);
  const u2 = Vec.Len(distance) ? distance.uni() : Vec.From(distance);
  const didFlip = !Vec.Equals(u2, uAB);
  if (!isSelfIntersection) {
    if (relationship !== "start-contains-end" && startShapeInfo && arrowheadStart !== "none" && !startShapeInfo.isExact) {
      strokeOffsetA = STROKE_SIZES[shape.props.size] / 2 + ("size" in startShapeInfo.shape.props ? STROKE_SIZES[startShapeInfo.shape.props.size] / 2 : 0);
      offsetA = (BOUND_ARROW_OFFSET + strokeOffsetA) * shape.props.scale;
      minLength += strokeOffsetA * shape.props.scale;
    }
    if (relationship !== "end-contains-start" && endShapeInfo && arrowheadEnd !== "none" && !endShapeInfo.isExact) {
      strokeOffsetB = STROKE_SIZES[shape.props.size] / 2 + ("size" in endShapeInfo.shape.props ? STROKE_SIZES[endShapeInfo.shape.props.size] / 2 : 0);
      offsetB = (BOUND_ARROW_OFFSET + strokeOffsetB) * shape.props.scale;
      minLength += strokeOffsetB * shape.props.scale;
    }
  }
  const tA = a2.clone().add(u2.clone().mul(offsetA * (didFlip ? -1 : 1)));
  const tB = b2.clone().sub(u2.clone().mul(offsetB * (didFlip ? -1 : 1)));
  if (Vec.DistMin(tA, tB, minLength)) {
    if (offsetA !== 0 && offsetB !== 0) {
      offsetA *= -1.5;
      offsetB *= -1.5;
    } else if (offsetA !== 0) {
      offsetA *= -1;
    } else if (offsetB !== 0) {
      offsetB *= -1;
    } else {
    }
  }
  a2.add(u2.clone().mul(offsetA * (didFlip ? -1 : 1)));
  b2.sub(u2.clone().mul(offsetB * (didFlip ? -1 : 1)));
  if (didFlip) {
    if (startShapeInfo && endShapeInfo) {
      b2.setTo(Vec.Add(a2, u2.clone().mul(-MIN_ARROW_LENGTH * shape.props.scale)));
    }
    c2.setTo(Vec.Med(terminalsInArrowSpace.start, terminalsInArrowSpace.end));
  } else {
    c2.setTo(Vec.Med(a2, b2));
  }
  const length = Vec.Dist(a2, b2);
  return {
    bindings,
    isStraight: true,
    start: {
      handle: terminalsInArrowSpace.start,
      point: a2,
      arrowhead: shape.props.arrowheadStart
    },
    end: {
      handle: terminalsInArrowSpace.end,
      point: b2,
      arrowhead: shape.props.arrowheadEnd
    },
    middle: c2,
    isValid: length > 0,
    length
  };
}
function updateArrowheadPointWithBoundShape(point, opposite, arrowPageTransform, targetShapeInfo) {
  if (targetShapeInfo === void 0) {
    return;
  }
  if (targetShapeInfo.isExact) {
    return;
  }
  const pageFrom = Mat.applyToPoint(arrowPageTransform, opposite);
  const pageTo = Mat.applyToPoint(arrowPageTransform, point);
  const targetFrom = Mat.applyToPoint(Mat.Inverse(targetShapeInfo.transform), pageFrom);
  const targetTo = Mat.applyToPoint(Mat.Inverse(targetShapeInfo.transform), pageTo);
  const isClosed = targetShapeInfo.isClosed;
  const fn3 = isClosed ? intersectLineSegmentPolygon : intersectLineSegmentPolyline;
  const intersection = fn3(targetFrom, targetTo, targetShapeInfo.outline);
  let targetInt;
  if (intersection !== null) {
    targetInt = intersection.sort((p1, p2) => Vec.Dist2(p1, targetFrom) - Vec.Dist2(p2, targetFrom))[0] ?? (isClosed ? void 0 : targetTo);
  }
  if (targetInt === void 0) {
    return;
  }
  const pageInt = Mat.applyToPoint(targetShapeInfo.transform, targetInt);
  const arrowInt = Mat.applyToPoint(Mat.Inverse(arrowPageTransform), pageInt);
  point.setTo(arrowInt);
  targetShapeInfo.didIntersect = true;
}
var init_straight_arrow = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/straight-arrow.mjs"() {
    init_dist_esm10();
    init_shared();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/curved-arrow.mjs
function getCurvedArrowInfo(editor, shape, bindings) {
  const { arrowheadEnd, arrowheadStart } = shape.props;
  const bend = shape.props.bend;
  if (Math.abs(bend) > Math.abs(shape.props.bend * (WAY_TOO_BIG_ARROW_BEND_FACTOR * shape.props.scale))) {
    return getStraightArrowInfo(editor, shape, bindings);
  }
  const terminalsInArrowSpace = getArrowTerminalsInArrowSpace(editor, shape, bindings);
  const med = Vec.Med(terminalsInArrowSpace.start, terminalsInArrowSpace.end);
  const distance = Vec.Sub(terminalsInArrowSpace.end, terminalsInArrowSpace.start);
  const u2 = Vec.Len(distance) ? distance.uni() : Vec.From(distance);
  const middle = Vec.Add(med, u2.per().mul(-bend));
  const startShapeInfo = getBoundShapeInfoForTerminal(editor, shape, "start");
  const endShapeInfo = getBoundShapeInfoForTerminal(editor, shape, "end");
  const a2 = terminalsInArrowSpace.start.clone();
  const b2 = terminalsInArrowSpace.end.clone();
  const c2 = middle.clone();
  if (Vec.Equals(a2, b2)) {
    return {
      bindings,
      isStraight: true,
      start: {
        handle: a2,
        point: a2,
        arrowhead: shape.props.arrowheadStart
      },
      end: {
        handle: b2,
        point: b2,
        arrowhead: shape.props.arrowheadEnd
      },
      middle: c2,
      isValid: false,
      length: 0
    };
  }
  const isClockwise = shape.props.bend < 0;
  const distFn = isClockwise ? clockwiseAngleDist : counterClockwiseAngleDist;
  const handleArc = getArcInfo(a2, b2, c2);
  const handle_aCA = Vec.Angle(handleArc.center, a2);
  const handle_aCB = Vec.Angle(handleArc.center, b2);
  const handle_dAB = distFn(handle_aCA, handle_aCB);
  if (handleArc.length === 0 || handleArc.size === 0 || !isSafeFloat(handleArc.length) || !isSafeFloat(handleArc.size)) {
    return getStraightArrowInfo(editor, shape, bindings);
  }
  const tempA = a2.clone();
  const tempB = b2.clone();
  const tempC = c2.clone();
  const arrowPageTransform = editor.getShapePageTransform(shape);
  let offsetA = 0;
  let offsetB = 0;
  let minLength = MIN_ARROW_LENGTH * shape.props.scale;
  if (startShapeInfo && !startShapeInfo.isExact) {
    const startInPageSpace = Mat.applyToPoint(arrowPageTransform, tempA);
    const centerInPageSpace = Mat.applyToPoint(arrowPageTransform, handleArc.center);
    const endInPageSpace = Mat.applyToPoint(arrowPageTransform, tempB);
    const inverseTransform = Mat.Inverse(startShapeInfo.transform);
    const startInStartShapeLocalSpace = Mat.applyToPoint(inverseTransform, startInPageSpace);
    const centerInStartShapeLocalSpace = Mat.applyToPoint(inverseTransform, centerInPageSpace);
    const endInStartShapeLocalSpace = Mat.applyToPoint(inverseTransform, endInPageSpace);
    const { isClosed } = startShapeInfo;
    const fn3 = isClosed ? intersectCirclePolygon : intersectCirclePolyline;
    let point;
    let intersections = fn3(centerInStartShapeLocalSpace, handleArc.radius, startShapeInfo.outline);
    if (intersections) {
      const angleToStart = centerInStartShapeLocalSpace.angle(startInStartShapeLocalSpace);
      const angleToEnd = centerInStartShapeLocalSpace.angle(endInStartShapeLocalSpace);
      const dAB2 = distFn(angleToStart, angleToEnd);
      intersections = intersections.filter((pt) => distFn(angleToStart, centerInStartShapeLocalSpace.angle(pt)) <= dAB2);
      const targetDist = dAB2 * 0.25;
      intersections.sort(isClosed ? (p0, p1) => Math.abs(distFn(angleToStart, centerInStartShapeLocalSpace.angle(p0)) - targetDist) < Math.abs(distFn(angleToStart, centerInStartShapeLocalSpace.angle(p1)) - targetDist) ? -1 : 1 : (p0, p1) => distFn(angleToStart, centerInStartShapeLocalSpace.angle(p0)) < distFn(angleToStart, centerInStartShapeLocalSpace.angle(p1)) ? -1 : 1);
      point = intersections[0] ?? (isClosed ? void 0 : startInStartShapeLocalSpace);
    } else {
      point = isClosed ? void 0 : startInStartShapeLocalSpace;
    }
    if (point) {
      tempA.setTo(editor.getPointInShapeSpace(shape, Mat.applyToPoint(startShapeInfo.transform, point)));
      startShapeInfo.didIntersect = true;
      if (arrowheadStart !== "none") {
        const strokeOffset = STROKE_SIZES[shape.props.size] / 2 + ("size" in startShapeInfo.shape.props ? STROKE_SIZES[startShapeInfo.shape.props.size] / 2 : 0);
        offsetA = (BOUND_ARROW_OFFSET + strokeOffset) * shape.props.scale;
        minLength += strokeOffset * shape.props.scale;
      }
    }
  }
  if (endShapeInfo && !endShapeInfo.isExact) {
    const startInPageSpace = Mat.applyToPoint(arrowPageTransform, tempA);
    const endInPageSpace = Mat.applyToPoint(arrowPageTransform, tempB);
    const centerInPageSpace = Mat.applyToPoint(arrowPageTransform, handleArc.center);
    const inverseTransform = Mat.Inverse(endShapeInfo.transform);
    const startInEndShapeLocalSpace = Mat.applyToPoint(inverseTransform, startInPageSpace);
    const centerInEndShapeLocalSpace = Mat.applyToPoint(inverseTransform, centerInPageSpace);
    const endInEndShapeLocalSpace = Mat.applyToPoint(inverseTransform, endInPageSpace);
    const isClosed = endShapeInfo.isClosed;
    const fn3 = isClosed ? intersectCirclePolygon : intersectCirclePolyline;
    let point;
    let intersections = fn3(centerInEndShapeLocalSpace, handleArc.radius, endShapeInfo.outline);
    if (intersections) {
      const angleToStart = centerInEndShapeLocalSpace.angle(startInEndShapeLocalSpace);
      const angleToEnd = centerInEndShapeLocalSpace.angle(endInEndShapeLocalSpace);
      const dAB2 = distFn(angleToStart, angleToEnd);
      const targetDist = dAB2 * 0.75;
      intersections = intersections.filter((pt) => distFn(angleToStart, centerInEndShapeLocalSpace.angle(pt)) <= dAB2);
      intersections.sort(isClosed ? (p0, p1) => Math.abs(distFn(angleToStart, centerInEndShapeLocalSpace.angle(p0)) - targetDist) < Math.abs(distFn(angleToStart, centerInEndShapeLocalSpace.angle(p1)) - targetDist) ? -1 : 1 : (p0, p1) => distFn(angleToStart, centerInEndShapeLocalSpace.angle(p0)) < distFn(angleToStart, centerInEndShapeLocalSpace.angle(p1)) ? -1 : 1);
      if (intersections[0]) {
        point = intersections[0];
      } else {
        point = isClosed ? void 0 : endInEndShapeLocalSpace;
      }
    } else {
      point = isClosed ? void 0 : endInEndShapeLocalSpace;
    }
    if (point) {
      tempB.setTo(editor.getPointInShapeSpace(shape, Mat.applyToPoint(endShapeInfo.transform, point)));
      endShapeInfo.didIntersect = true;
      if (arrowheadEnd !== "none") {
        const strokeOffset = STROKE_SIZES[shape.props.size] / 2 + ("size" in endShapeInfo.shape.props ? STROKE_SIZES[endShapeInfo.shape.props.size] / 2 : 0);
        offsetB = (BOUND_ARROW_OFFSET + strokeOffset) * shape.props.scale;
        minLength += strokeOffset * shape.props.scale;
      }
    }
  }
  let aCA = Vec.Angle(handleArc.center, tempA);
  let aCB = Vec.Angle(handleArc.center, tempB);
  let dAB = distFn(aCA, aCB);
  let lAB = dAB * handleArc.radius;
  const tA = tempA.clone();
  const tB = tempB.clone();
  if (offsetA !== 0) {
    tA.setTo(handleArc.center).add(Vec.FromAngle(aCA + dAB * (offsetA / lAB * (isClockwise ? 1 : -1))).mul(handleArc.radius));
  }
  if (offsetB !== 0) {
    tB.setTo(handleArc.center).add(Vec.FromAngle(aCB + dAB * (offsetB / lAB * (isClockwise ? -1 : 1))).mul(handleArc.radius));
  }
  if (Vec.DistMin(tA, tB, minLength)) {
    if (offsetA !== 0 && offsetB !== 0) {
      offsetA *= -1.5;
      offsetB *= -1.5;
    } else if (offsetA !== 0) {
      offsetA *= -2;
    } else if (offsetB !== 0) {
      offsetB *= -2;
    } else {
    }
  }
  if (offsetA !== 0) {
    tempA.setTo(handleArc.center).add(Vec.FromAngle(aCA + dAB * (offsetA / lAB * (isClockwise ? 1 : -1))).mul(handleArc.radius));
  }
  if (offsetB !== 0) {
    tempB.setTo(handleArc.center).add(Vec.FromAngle(aCB + dAB * (offsetB / lAB * (isClockwise ? -1 : 1))).mul(handleArc.radius));
  }
  if (startShapeInfo && endShapeInfo && !startShapeInfo.isExact && !endShapeInfo.isExact) {
    aCA = Vec.Angle(handleArc.center, tempA);
    aCB = Vec.Angle(handleArc.center, tempB);
    dAB = distFn(aCA, aCB);
    lAB = dAB * handleArc.radius;
    const relationship = getBoundShapeRelationships(editor, startShapeInfo.shape.id, endShapeInfo.shape.id);
    if (relationship === "double-bound" && lAB < 30) {
      tempA.setTo(a2);
      tempB.setTo(b2);
      tempC.setTo(c2);
    } else if (relationship === "safe") {
      if (startShapeInfo && !startShapeInfo.didIntersect) {
        tempA.setTo(a2);
      }
      if (endShapeInfo && !endShapeInfo.didIntersect || distFn(handle_aCA, aCA) > distFn(handle_aCA, aCB)) {
        tempB.setTo(handleArc.center).add(Vec.FromAngle(aCA + dAB * (Math.min(0.9, MIN_ARROW_LENGTH * shape.props.scale / lAB) * (isClockwise ? 1 : -1))).mul(handleArc.radius));
      }
    }
  }
  placeCenterHandle(handleArc.center, handleArc.radius, tempA, tempB, tempC, handle_dAB, isClockwise);
  if (tempA.equals(tempB)) {
    tempA.setTo(tempC.clone().addXY(1, 1));
    tempB.setTo(tempC.clone().subXY(1, 1));
  }
  a2.setTo(tempA);
  b2.setTo(tempB);
  c2.setTo(tempC);
  const bodyArc = getArcInfo(a2, b2, c2);
  return {
    bindings,
    isStraight: false,
    start: {
      point: a2,
      handle: terminalsInArrowSpace.start,
      arrowhead: shape.props.arrowheadStart
    },
    end: {
      point: b2,
      handle: terminalsInArrowSpace.end,
      arrowhead: shape.props.arrowheadEnd
    },
    middle: c2,
    handleArc,
    bodyArc,
    isValid: bodyArc.length !== 0 && isFinite(bodyArc.center.x) && isFinite(bodyArc.center.y)
  };
}
function getArcInfo(a2, b2, c2) {
  const center = centerOfCircleFromThreePoints(a2, b2, c2);
  const radius = Vec.Dist(center, a2);
  const sweepFlag = +Vec.Clockwise(a2, c2, b2);
  const ab = ((a2.y - b2.y) ** 2 + (a2.x - b2.x) ** 2) ** 0.5;
  const bc = ((b2.y - c2.y) ** 2 + (b2.x - c2.x) ** 2) ** 0.5;
  const ca = ((c2.y - a2.y) ** 2 + (c2.x - a2.x) ** 2) ** 0.5;
  const theta = Math.acos((bc * bc + ca * ca - ab * ab) / (2 * bc * ca)) * 2;
  const largeArcFlag = +(PI > theta);
  const size4 = (PI2 - theta) * (sweepFlag ? 1 : -1);
  const length = size4 * radius;
  return {
    center,
    radius,
    size: size4,
    length,
    largeArcFlag,
    sweepFlag
  };
}
function placeCenterHandle(center, radius, tempA, tempB, tempC, originalArcLength, isClockwise) {
  const aCA = Vec.Angle(center, tempA);
  const aCB = Vec.Angle(center, tempB);
  let dAB = clockwiseAngleDist(aCA, aCB);
  if (!isClockwise)
    dAB = PI2 - dAB;
  tempC.setTo(center).add(Vec.FromAngle(aCA + dAB * (0.5 * (isClockwise ? 1 : -1))).mul(radius));
  if (dAB > originalArcLength) {
    tempC.rotWith(center, PI);
    const t3 = tempB.clone();
    tempB.setTo(tempA);
    tempA.setTo(t3);
  }
}
var init_curved_arrow = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/curved-arrow.mjs"() {
    init_dist_esm10();
    init_shared();
    init_straight_arrow();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/shared.mjs
function getIsArrowStraight(shape) {
  return Math.abs(shape.props.bend) < MIN_ARROW_BEND * shape.props.scale;
}
function getBoundShapeInfoForTerminal(editor, arrow5, terminalName) {
  const binding = editor.getBindingsFromShape(arrow5, "arrow").find((b2) => b2.props.terminal === terminalName);
  if (!binding)
    return;
  const boundShape = editor.getShape(binding.toId);
  if (!boundShape)
    return;
  const transform = editor.getShapePageTransform(boundShape);
  const geometry = editor.getShapeGeometry(boundShape);
  const outline = geometry instanceof Group2d ? geometry.children[0].vertices : geometry.vertices;
  return {
    shape: boundShape,
    transform,
    isClosed: geometry.isClosed,
    isExact: binding.props.isExact,
    didIntersect: false,
    outline
  };
}
function getArrowTerminalInArrowSpace(editor, arrowPageTransform, binding, forceImprecise) {
  const boundShape = editor.getShape(binding.toId);
  if (!boundShape) {
    return new Vec(0, 0);
  } else {
    const { point, size: size4 } = editor.getShapeGeometry(boundShape).bounds;
    const shapePoint = Vec.Add(point, Vec.MulV(binding.props.isPrecise || forceImprecise ? binding.props.normalizedAnchor : { x: 0.5, y: 0.5 }, size4));
    const pagePoint = Mat.applyToPoint(editor.getShapePageTransform(boundShape), shapePoint);
    const arrowPoint = Mat.applyToPoint(Mat.Inverse(arrowPageTransform), pagePoint);
    return arrowPoint;
  }
}
function getArrowBindings(editor, shape) {
  const bindings = editor.getBindingsFromShape(shape, "arrow");
  return {
    start: bindings.find((b2) => b2.props.terminal === "start"),
    end: bindings.find((b2) => b2.props.terminal === "end")
  };
}
function getArrowInfo(editor, shape) {
  const id = typeof shape === "string" ? shape : shape.id;
  return arrowInfoCache.get(editor, id);
}
function getArrowTerminalsInArrowSpace(editor, shape, bindings) {
  const arrowPageTransform = editor.getShapePageTransform(shape);
  const boundShapeRelationships = getBoundShapeRelationships(editor, bindings.start?.toId, bindings.end?.toId);
  const start2 = bindings.start ? getArrowTerminalInArrowSpace(editor, arrowPageTransform, bindings.start, boundShapeRelationships === "double-bound" || boundShapeRelationships === "start-contains-end") : Vec.From(shape.props.start);
  const end2 = bindings.end ? getArrowTerminalInArrowSpace(editor, arrowPageTransform, bindings.end, boundShapeRelationships === "double-bound" || boundShapeRelationships === "end-contains-start") : Vec.From(shape.props.end);
  return { start: start2, end: end2 };
}
function createOrUpdateArrowBinding(editor, arrow5, target, props) {
  const arrowId = typeof arrow5 === "string" ? arrow5 : arrow5.id;
  const targetId = typeof target === "string" ? target : target.id;
  const existingMany = editor.getBindingsFromShape(arrowId, "arrow").filter((b2) => b2.props.terminal === props.terminal);
  if (existingMany.length > 1) {
    editor.deleteBindings(existingMany.slice(1));
  }
  const existing = existingMany[0];
  if (existing) {
    editor.updateBinding({
      ...existing,
      toId: targetId,
      props
    });
  } else {
    editor.createBinding({
      type: "arrow",
      fromId: arrowId,
      toId: targetId,
      props
    });
  }
}
function removeArrowBinding(editor, arrow5, terminal) {
  const existing = editor.getBindingsFromShape(arrow5, "arrow").filter((b2) => b2.props.terminal === terminal);
  editor.deleteBindings(existing);
}
function getBoundShapeRelationships(editor, startShapeId, endShapeId) {
  if (!startShapeId || !endShapeId)
    return "safe";
  if (startShapeId === endShapeId)
    return "double-bound";
  const startBounds = editor.getShapePageBounds(startShapeId);
  const endBounds = editor.getShapePageBounds(endShapeId);
  if (startBounds && endBounds) {
    if (startBounds.contains(endBounds))
      return "start-contains-end";
    if (endBounds.contains(startBounds))
      return "end-contains-start";
  }
  return "safe";
}
var MIN_ARROW_BEND, arrowInfoCache, MIN_ARROW_LENGTH, BOUND_ARROW_OFFSET, WAY_TOO_BIG_ARROW_BEND_FACTOR, STROKE_SIZES;
var init_shared = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/shared.mjs"() {
    init_dist_esm10();
    init_dist_esm4();
    init_curved_arrow();
    init_straight_arrow();
    MIN_ARROW_BEND = 8;
    arrowInfoCache = createComputedCache("arrow info", (editor, shape) => {
      const bindings = getArrowBindings(editor, shape);
      return getIsArrowStraight(shape) ? getStraightArrowInfo(editor, shape, bindings) : getCurvedArrowInfo(editor, shape, bindings);
    });
    MIN_ARROW_LENGTH = 10;
    BOUND_ARROW_OFFSET = 10;
    WAY_TOO_BIG_ARROW_BEND_FACTOR = 10;
    STROKE_SIZES = {
      s: 2,
      m: 3.5,
      l: 5,
      xl: 10
    };
  }
});

// node_modules/tldraw/dist-esm/lib/bindings/arrow/ArrowBindingUtil.mjs
function reparentArrow(editor, arrowId) {
  const arrow5 = editor.getShape(arrowId);
  if (!arrow5)
    return;
  const bindings = getArrowBindings(editor, arrow5);
  const { start: start2, end: end2 } = bindings;
  const startShape = start2 ? editor.getShape(start2.toId) : void 0;
  const endShape = end2 ? editor.getShape(end2.toId) : void 0;
  const parentPageId = editor.getAncestorPageId(arrow5);
  if (!parentPageId)
    return;
  let nextParentId;
  if (startShape && endShape) {
    nextParentId = editor.findCommonAncestor([startShape, endShape]) ?? parentPageId;
  } else if (startShape || endShape) {
    const bindingParentId = (startShape || endShape)?.parentId;
    if (bindingParentId && bindingParentId === arrow5.parentId) {
      nextParentId = arrow5.parentId;
    } else {
      nextParentId = parentPageId;
    }
  } else {
    return;
  }
  if (nextParentId && nextParentId !== arrow5.parentId) {
    editor.reparentShapes([arrowId], nextParentId);
  }
  const reparentedArrow = editor.getShape(arrowId);
  if (!reparentedArrow)
    throw Error("no reparented arrow");
  const startSibling = editor.getShapeNearestSibling(reparentedArrow, startShape);
  const endSibling = editor.getShapeNearestSibling(reparentedArrow, endShape);
  let highestSibling;
  if (startSibling && endSibling) {
    highestSibling = startSibling.index > endSibling.index ? startSibling : endSibling;
  } else if (startSibling && !endSibling) {
    highestSibling = startSibling;
  } else if (endSibling && !startSibling) {
    highestSibling = endSibling;
  } else {
    return;
  }
  let finalIndex;
  const higherSiblings = editor.getSortedChildIdsForParent(highestSibling.parentId).map((id) => editor.getShape(id)).filter((sibling) => sibling.index > highestSibling.index);
  if (higherSiblings.length) {
    const nextHighestNonArrowSibling = higherSiblings.find((sibling) => sibling.type !== "arrow");
    if (reparentedArrow.index > highestSibling.index && (!nextHighestNonArrowSibling || reparentedArrow.index < nextHighestNonArrowSibling.index)) {
      return;
    }
    finalIndex = getIndexBetween(highestSibling.index, higherSiblings[0].index);
  } else {
    finalIndex = getIndexAbove(highestSibling.index);
  }
  if (finalIndex !== reparentedArrow.index) {
    editor.updateShapes([{ id: arrowId, type: "arrow", index: finalIndex }]);
  }
}
function arrowDidUpdate(editor, arrow5) {
  const bindings = getArrowBindings(editor, arrow5);
  for (const handle of ["start", "end"]) {
    const binding = bindings[handle];
    if (!binding)
      continue;
    const boundShape = editor.getShape(binding.toId);
    const isShapeInSamePageAsArrow = editor.getAncestorPageId(arrow5) === editor.getAncestorPageId(boundShape);
    if (!boundShape || !isShapeInSamePageAsArrow) {
      updateArrowTerminal({ editor, arrow: arrow5, terminal: handle, unbind: true });
    }
  }
  reparentArrow(editor, arrow5.id);
}
function updateArrowTerminal({
  editor,
  arrow: arrow5,
  terminal,
  unbind: unbind2 = false,
  useHandle = false
}) {
  const info2 = getArrowInfo(editor, arrow5);
  if (!info2) {
    throw new Error("expected arrow info");
  }
  const startPoint = useHandle ? info2.start.handle : info2.start.point;
  const endPoint = useHandle ? info2.end.handle : info2.end.point;
  const point = terminal === "start" ? startPoint : endPoint;
  const update = {
    id: arrow5.id,
    type: "arrow",
    props: {
      [terminal]: { x: point.x, y: point.y },
      bend: arrow5.props.bend
    }
  };
  if (!info2.isStraight) {
    const newStart = terminal === "start" ? startPoint : info2.start.handle;
    const newEnd = terminal === "end" ? endPoint : info2.end.handle;
    const newMidPoint = Vec.Med(newStart, newEnd);
    const lineSegment = Vec.Sub(newStart, newEnd).per().uni().mul(info2.handleArc.radius * 2 * Math.sign(arrow5.props.bend));
    const intersections = intersectLineSegmentCircle(info2.handleArc.center, Vec.Add(newMidPoint, lineSegment), info2.handleArc.center, info2.handleArc.radius);
    assert(intersections?.length === 1);
    const bend = Vec.Dist(newMidPoint, intersections[0]) * Math.sign(arrow5.props.bend);
    if (!approximately(bend, update.props.bend)) {
      update.props.bend = bend;
    }
  }
  editor.updateShape(update);
  if (unbind2) {
    removeArrowBinding(editor, arrow5, terminal);
  }
}
var ArrowBindingUtil;
var init_ArrowBindingUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/bindings/arrow/ArrowBindingUtil.mjs"() {
    init_dist_esm10();
    init_shared();
    ArrowBindingUtil = class extends BindingUtil {
      getDefaultProps() {
        return {
          isPrecise: false,
          isExact: false,
          normalizedAnchor: { x: 0.5, y: 0.5 }
        };
      }
      onAfterCreate({ binding }) {
        arrowDidUpdate(this.editor, this.editor.getShape(binding.fromId));
      }
      onAfterChange({ bindingAfter }) {
        arrowDidUpdate(this.editor, this.editor.getShape(bindingAfter.fromId));
      }
      onAfterChangeFromShape({
        shapeAfter
      }) {
        arrowDidUpdate(this.editor, shapeAfter);
      }
      onAfterChangeToShape({ binding }) {
        reparentArrow(this.editor, binding.fromId);
      }
      onBeforeIsolateFromShape({
        binding
      }) {
        const arrow5 = this.editor.getShape(binding.fromId);
        if (!arrow5)
          return;
        updateArrowTerminal({
          editor: this.editor,
          arrow: arrow5,
          terminal: binding.props.terminal
        });
      }
    };
    __publicField(ArrowBindingUtil, "type", "arrow");
    __publicField(ArrowBindingUtil, "props", arrowBindingProps);
    __publicField(ArrowBindingUtil, "migrations", arrowBindingMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/defaultBindingUtils.mjs
var defaultBindingUtils;
var init_defaultBindingUtils = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultBindingUtils.mjs"() {
    init_ArrowBindingUtil();
    defaultBindingUtils = [ArrowBindingUtil];
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/default-shape-constants.mjs
var TEXT_PROPS, STROKE_SIZES2, FONT_SIZES, LABEL_FONT_SIZES, ARROW_LABEL_FONT_SIZES, FONT_FAMILIES, LABEL_TO_ARROW_PADDING, ARROW_LABEL_PADDING, LABEL_PADDING;
var init_default_shape_constants = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/default-shape-constants.mjs"() {
    TEXT_PROPS = {
      lineHeight: 1.35,
      fontWeight: "normal",
      fontVariant: "normal",
      fontStyle: "normal",
      padding: "0px"
    };
    STROKE_SIZES2 = {
      s: 2,
      m: 3.5,
      l: 5,
      xl: 10
    };
    FONT_SIZES = {
      s: 18,
      m: 24,
      l: 36,
      xl: 44
    };
    LABEL_FONT_SIZES = {
      s: 18,
      m: 22,
      l: 26,
      xl: 32
    };
    ARROW_LABEL_FONT_SIZES = {
      s: 18,
      m: 20,
      l: 24,
      xl: 28
    };
    FONT_FAMILIES = {
      draw: "var(--tl-font-draw)",
      sans: "var(--tl-font-sans)",
      serif: "var(--tl-font-serif)",
      mono: "var(--tl-font-mono)"
    };
    LABEL_TO_ARROW_PADDING = 20;
    ARROW_LABEL_PADDING = 4.25;
    LABEL_PADDING = 16;
  }
});

// node_modules/canvas-size/dist/canvas-size.esm.js
function _iterableToArrayLimit(arr, i2) {
  var _i = arr == null ? null : typeof Symbol != "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
  if (_i != null) {
    var _s, _e, _x, _r, _arr = [], _n = true, _d = false;
    try {
      if (_x = (_i = _i.call(arr)).next, i2 === 0) {
        if (Object(_i) !== _i)
          return;
        _n = false;
      } else
        for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i2); _n = true)
          ;
    } catch (err) {
      _d = true, _e = err;
    } finally {
      try {
        if (!_n && _i.return != null && (_r = _i.return(), Object(_r) !== _r))
          return;
      } finally {
        if (_d)
          throw _e;
      }
    }
    return _arr;
  }
}
function ownKeys(object2, enumerableOnly) {
  var keys = Object.keys(object2);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object2);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object2, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
function _objectSpread2(target) {
  for (var i2 = 1; i2 < arguments.length; i2++) {
    var source = arguments[i2] != null ? arguments[i2] : {};
    i2 % 2 ? ownKeys(Object(source), true).forEach(function(key) {
      _defineProperty(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
function _defineProperty(obj, key, value) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null)
    return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i2;
  for (i2 = 0; i2 < sourceKeys.length; i2++) {
    key = sourceKeys[i2];
    if (excluded.indexOf(key) >= 0)
      continue;
    target[key] = source[key];
  }
  return target;
}
function _objectWithoutProperties(source, excluded) {
  if (source == null)
    return {};
  var target = _objectWithoutPropertiesLoose(source, excluded);
  var key, i2;
  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
    for (i2 = 0; i2 < sourceSymbolKeys.length; i2++) {
      key = sourceSymbolKeys[i2];
      if (excluded.indexOf(key) >= 0)
        continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key))
        continue;
      target[key] = source[key];
    }
  }
  return target;
}
function _slicedToArray(arr, i2) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
}
function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr))
    return _arrayLikeToArray(arr);
}
function _arrayWithHoles(arr) {
  if (Array.isArray(arr))
    return arr;
}
function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
    return Array.from(iter);
}
function _unsupportedIterableToArray(o2, minLen) {
  if (!o2)
    return;
  if (typeof o2 === "string")
    return _arrayLikeToArray(o2, minLen);
  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
  if (n2 === "Object" && o2.constructor)
    n2 = o2.constructor.name;
  if (n2 === "Map" || n2 === "Set")
    return Array.from(o2);
  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
    return _arrayLikeToArray(o2, minLen);
}
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length)
    len = arr.length;
  for (var i2 = 0, arr2 = new Array(len); i2 < len; i2++)
    arr2[i2] = arr[i2];
  return arr2;
}
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null)
    return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== void 0) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object")
      return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
function canvasTest(settings) {
  var size4 = settings.sizes.shift();
  var width = Math.max(Math.ceil(size4[0]), 1);
  var height = Math.max(Math.ceil(size4[1]), 1);
  var fill = [width - 1, height - 1, 1, 1];
  var job = Date.now();
  var isWorker = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
  var cropCvs, testCvs;
  if (isWorker) {
    cropCvs = new OffscreenCanvas(1, 1);
    testCvs = new OffscreenCanvas(width, height);
  } else {
    cropCvs = document.createElement("canvas");
    cropCvs.width = 1;
    cropCvs.height = 1;
    testCvs = document.createElement("canvas");
    testCvs.width = width;
    testCvs.height = height;
  }
  var cropCtx = cropCvs.getContext("2d");
  var testCtx = testCvs.getContext("2d");
  if (testCtx) {
    testCtx.fillRect.apply(testCtx, fill);
    cropCtx.drawImage(testCvs, width - 1, height - 1, 1, 1, 0, 0, 1, 1);
  }
  var isTestPass = cropCtx && cropCtx.getImageData(0, 0, 1, 1).data[3] !== 0;
  var benchmark = Date.now() - job;
  [cropCvs, testCvs].forEach(function(cvs) {
    cvs.height = 0;
    cvs.width = 0;
  });
  if (isWorker) {
    postMessage({
      width,
      height,
      benchmark,
      isTestPass
    });
    if (!isTestPass && settings.sizes.length) {
      canvasTest(settings);
    }
  } else if (isTestPass) {
    settings.onSuccess(width, height, benchmark);
  } else {
    settings.onError(width, height, benchmark);
    if (settings.sizes.length) {
      canvasTest(settings);
    }
  }
  return isTestPass;
}
function createSizesArray(settings) {
  var isArea = settings.width === settings.height;
  var isWidth = settings.height === 1;
  var isHeight = settings.width === 1;
  var sizes = [];
  if (!settings.width || !settings.height) {
    settings.sizes.forEach(function(testSize2) {
      var width2 = isArea || isWidth ? testSize2 : 1;
      var height2 = isArea || isHeight ? testSize2 : 1;
      sizes.push([width2, height2]);
    });
  } else {
    var testMin = settings.min || defaults.min;
    var testStep = settings.step || defaults.step;
    var testSize = Math.max(settings.width, settings.height);
    while (testSize >= testMin) {
      var width = isArea || isWidth ? testSize : 1;
      var height = isArea || isHeight ? testSize : 1;
      sizes.push([width, height]);
      testSize -= testStep;
    }
  }
  return sizes;
}
function handleMethod(settings) {
  var hasCanvasSupport = window && "HTMLCanvasElement" in window;
  var hasOffscreenCanvasSupport = window && "OffscreenCanvas" in window;
  var jobID = Date.now();
  var _onError = settings.onError, _onSuccess = settings.onSuccess, settingsWithoutCallbacks = _objectWithoutProperties(settings, _excluded);
  var worker = null;
  if (!hasCanvasSupport) {
    return false;
  }
  if (settings.useWorker && hasOffscreenCanvasSupport) {
    var js = "\n            var canvasTest = ".concat(canvasTest.toString(), ";\n            onmessage = function(e) {\n                canvasTest(e.data);\n            };\n        ");
    var blob = new Blob([js], {
      type: "application/javascript"
    });
    var blobURL = URL.createObjectURL(blob);
    worker = new Worker(blobURL);
    URL.revokeObjectURL(blobURL);
    worker.onmessage = function(e2) {
      var _e$data = e2.data, width = _e$data.width, height = _e$data.height, benchmark = _e$data.benchmark, isTestPass = _e$data.isTestPass;
      if (isTestPass) {
        workerJobs[jobID].onSuccess(width, height, benchmark);
        delete workerJobs[jobID];
      } else {
        workerJobs[jobID].onError(width, height, benchmark);
      }
    };
  }
  if (settings.usePromise) {
    return new Promise(function(resolve, reject) {
      var promiseSettings = _objectSpread2(_objectSpread2({}, settings), {}, {
        onError: function onError2(width, height, benchmark) {
          var isLastTest;
          if (settings.sizes.length === 0) {
            isLastTest = true;
          } else {
            var _settings$sizes$slice = settings.sizes.slice(-1), _settings$sizes$slice2 = _slicedToArray(_settings$sizes$slice, 1), _settings$sizes$slice3 = _slicedToArray(_settings$sizes$slice2[0], 2), lastWidth = _settings$sizes$slice3[0], lastHeight = _settings$sizes$slice3[1];
            isLastTest = width === lastWidth && height === lastHeight;
          }
          _onError(width, height, benchmark);
          if (isLastTest) {
            reject({
              width,
              height,
              benchmark
            });
          }
        },
        onSuccess: function onSuccess2(width, height, benchmark) {
          _onSuccess(width, height, benchmark);
          resolve({
            width,
            height,
            benchmark
          });
        }
      });
      if (worker) {
        var onError = promiseSettings.onError, onSuccess = promiseSettings.onSuccess;
        workerJobs[jobID] = {
          onError,
          onSuccess
        };
        worker.postMessage(settingsWithoutCallbacks);
      } else {
        canvasTest(promiseSettings);
      }
    });
  } else {
    if (worker) {
      workerJobs[jobID] = {
        onError: _onError,
        onSuccess: _onSuccess
      };
      worker.postMessage(settingsWithoutCallbacks);
    } else {
      return canvasTest(settings);
    }
  }
}
var testSizes, _excluded, defaults, workerJobs, canvasSize;
var init_canvas_size_esm = __esm({
  "node_modules/canvas-size/dist/canvas-size.esm.js"() {
    testSizes = {
      area: [16384, 14188, 11402, 11180, 10836, 8192, 4096, 1],
      height: [8388607, 65535, 32767, 16384, 8192, 4096, 1],
      width: [4194303, 65535, 32767, 16384, 8192, 4096, 1]
    };
    _excluded = ["onError", "onSuccess"];
    defaults = {
      max: null,
      min: 1,
      sizes: [],
      step: 1024,
      usePromise: false,
      useWorker: false,
      onError: Function.prototype,
      onSuccess: Function.prototype
    };
    workerJobs = {};
    canvasSize = {
      maxArea: function maxArea() {
        var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
        var sizes = createSizesArray({
          width: options.max,
          height: options.max,
          min: options.min,
          step: options.step,
          sizes: _toConsumableArray(testSizes.area)
        });
        var settings = _objectSpread2(_objectSpread2(_objectSpread2({}, defaults), options), {}, {
          sizes
        });
        return handleMethod(settings);
      },
      maxHeight: function maxHeight() {
        var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
        var sizes = createSizesArray({
          width: 1,
          height: options.max,
          min: options.min,
          step: options.step,
          sizes: _toConsumableArray(testSizes.height)
        });
        var settings = _objectSpread2(_objectSpread2(_objectSpread2({}, defaults), options), {}, {
          sizes
        });
        return handleMethod(settings);
      },
      maxWidth: function maxWidth() {
        var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
        var sizes = createSizesArray({
          width: options.max,
          height: 1,
          min: options.min,
          step: options.step,
          sizes: _toConsumableArray(testSizes.width)
        });
        var settings = _objectSpread2(_objectSpread2(_objectSpread2({}, defaults), options), {}, {
          sizes
        });
        return handleMethod(settings);
      },
      test: function test() {
        var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
        var settings = _objectSpread2(_objectSpread2({}, defaults), options);
        settings.sizes = _toConsumableArray(settings.sizes);
        if (settings.width && settings.height) {
          settings.sizes = [[settings.width, settings.height]];
        }
        return handleMethod(settings);
      }
    };
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/getBrowserCanvasMaxSize.mjs
function getBrowserCanvasMaxSize() {
  if (!maxSizePromise) {
    maxSizePromise = calculateBrowserCanvasMaxSize();
  }
  return maxSizePromise;
}
async function calculateBrowserCanvasMaxSize() {
  const maxWidth2 = await canvasSize.maxWidth({ usePromise: true });
  const maxHeight2 = await canvasSize.maxHeight({ usePromise: true });
  const maxArea2 = await canvasSize.maxArea({ usePromise: true });
  return {
    maxWidth: maxWidth2.width,
    maxHeight: maxHeight2.height,
    maxArea: maxArea2.width * maxArea2.height
  };
}
async function clampToBrowserMaxCanvasSize(width, height) {
  if (width <= MAX_SAFE_CANVAS_DIMENSION && height <= MAX_SAFE_CANVAS_DIMENSION && width * height <= MAX_SAFE_CANVAS_AREA) {
    return [width, height];
  }
  const { maxWidth: maxWidth2, maxHeight: maxHeight2, maxArea: maxArea2 } = await getBrowserCanvasMaxSize();
  const aspectRatio = width / height;
  if (width > maxWidth2) {
    width = maxWidth2;
    height = width / aspectRatio;
  }
  if (height > maxHeight2) {
    height = maxHeight2;
    width = height * aspectRatio;
  }
  if (width * height > maxArea2) {
    const ratio = Math.sqrt(maxArea2 / (width * height));
    width *= ratio;
    height *= ratio;
  }
  return [width, height];
}
var maxSizePromise, MAX_SAFE_CANVAS_DIMENSION, MAX_SAFE_CANVAS_AREA;
var init_getBrowserCanvasMaxSize = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/getBrowserCanvasMaxSize.mjs"() {
    init_canvas_size_esm();
    maxSizePromise = null;
    MAX_SAFE_CANVAS_DIMENSION = 8192;
    MAX_SAFE_CANVAS_AREA = 4096 * 4096;
  }
});

// node_modules/tldraw/dist-esm/lib/utils/assets/assets.mjs
var init_assets2 = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/assets/assets.mjs"() {
    init_dist_esm10();
    init_getBrowserCanvasMaxSize();
  }
});

// node_modules/tldraw/dist-esm/lib/utils/embeds/embeds.mjs
function escapeStringRegexp(string2) {
  if (typeof string2 !== "string") {
    throw new TypeError("Expected a string");
  }
  return string2.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
}
function matchEmbedUrl(url) {
  const host = new URL(url).host.replace("www.", "");
  for (const localEmbedDef of EMBED_DEFINITIONS) {
    if (checkHostnames(localEmbedDef.hostnames, host)) {
      const originalUrl = localEmbedDef.fromEmbedUrl(url);
      if (originalUrl) {
        return {
          definition: localEmbedDef,
          url: originalUrl,
          embedUrl: url
        };
      }
    }
  }
}
function matchUrl(url) {
  const host = new URL(url).host.replace("www.", "");
  for (const localEmbedDef of EMBED_DEFINITIONS) {
    if (checkHostnames(localEmbedDef.hostnames, host)) {
      const embedUrl = localEmbedDef.toEmbedUrl(url);
      if (embedUrl) {
        return {
          definition: localEmbedDef,
          embedUrl,
          url
        };
      }
    }
  }
}
function getEmbedInfoUnsafely(inputUrl) {
  const result = matchUrl(inputUrl) ?? matchEmbedUrl(inputUrl);
  return result;
}
function getEmbedInfo(inputUrl) {
  try {
    return getEmbedInfoUnsafely(inputUrl);
  } catch (e2) {
    console.error(e2);
  }
  return void 0;
}
var globlikeRegExp, checkHostnames;
var init_embeds = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/embeds/embeds.mjs"() {
    init_dist_esm10();
    globlikeRegExp = (input) => {
      return input.split("*").map((str) => escapeStringRegexp(str)).join(".+");
    };
    checkHostnames = (hostnames, targetHostname) => {
      return !!hostnames.find((hostname) => {
        const re2 = new RegExp(globlikeRegExp(hostname));
        return targetHostname.match(re2);
      });
    };
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/TextHelpers.mjs
function getCaretIndex(element) {
  if (typeof window.getSelection === "undefined")
    return;
  const selection = window.getSelection();
  if (!selection)
    return;
  let position = 0;
  if (selection.rangeCount !== 0) {
    const range = selection.getRangeAt(0);
    const preCaretRange = range.cloneRange();
    preCaretRange.selectNodeContents(element);
    preCaretRange.setEnd(range.endContainer, range.endOffset);
    position = preCaretRange.toString().length;
  }
  return position;
}
var INDENT, _TextHelpers, TextHelpers;
var init_TextHelpers = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/TextHelpers.mjs"() {
    INDENT = "  ";
    _TextHelpers = class {
      static insertTextFirefox(field, text) {
        field.setRangeText(text, field.selectionStart || 0, field.selectionEnd || 0, "end");
        field.dispatchEvent(new InputEvent("input", {
          data: text,
          inputType: "insertText",
          isComposing: false
        }));
      }
      static insert(field, text) {
        const document2 = field.ownerDocument;
        const initialFocus = document2.activeElement;
        if (initialFocus !== field) {
          field.focus();
        }
        if (!document2.execCommand("insertText", false, text)) {
          _TextHelpers.insertTextFirefox(field, text);
        }
        if (initialFocus === document2.body) {
          field.blur();
        } else if (initialFocus instanceof HTMLElement && initialFocus !== field) {
          initialFocus.focus();
        }
      }
      static set(field, text) {
        field.select();
        _TextHelpers.insert(field, text);
      }
      static getSelection(field) {
        const { selectionStart, selectionEnd } = field;
        return field.value.slice(selectionStart ? selectionStart : void 0, selectionEnd ? selectionEnd : void 0);
      }
      static wrapSelection(field, wrap2, wrapEnd) {
        const { selectionStart, selectionEnd } = field;
        const selection = _TextHelpers.getSelection(field);
        _TextHelpers.insert(field, wrap2 + selection + (wrapEnd ?? wrap2));
        field.selectionStart = (selectionStart || 0) + wrap2.length;
        field.selectionEnd = (selectionEnd || 0) + wrap2.length;
      }
      static replace(field, searchValue, replacer) {
        let drift = 0;
        field.value.replace(searchValue, (...args) => {
          const matchStart = drift + args[args.length - 2];
          const matchLength = args[0].length;
          field.selectionStart = matchStart;
          field.selectionEnd = matchStart + matchLength;
          const replacement = typeof replacer === "string" ? replacer : replacer(...args);
          _TextHelpers.insert(field, replacement);
          field.selectionStart = matchStart;
          drift += replacement.length - matchLength;
          return replacement;
        });
      }
      static findLineEnd(value, currentEnd) {
        const lastLineStart = value.lastIndexOf("\n", currentEnd - 1) + 1;
        if (value.charAt(lastLineStart) !== "	") {
          return currentEnd;
        }
        return lastLineStart + 1;
      }
      static indent(element) {
        const { selectionStart, selectionEnd, value } = element;
        const selectedContrast = value.slice(selectionStart, selectionEnd);
        const lineBreakCount = /\n/g.exec(selectedContrast)?.length;
        if (lineBreakCount && lineBreakCount > 0) {
          const firstLineStart = value.lastIndexOf("\n", selectionStart - 1) + 1;
          const newSelection = element.value.slice(firstLineStart, selectionEnd - 1);
          const indentedText = newSelection.replace(/^|\n/g, `$&${INDENT}`);
          const replacementsCount = indentedText.length - newSelection.length;
          element.setSelectionRange(firstLineStart, selectionEnd - 1);
          _TextHelpers.insert(element, indentedText);
          element.setSelectionRange(selectionStart + 1, selectionEnd + replacementsCount);
        } else {
          _TextHelpers.insert(element, INDENT);
        }
      }
      static unindent(element) {
        const { selectionStart, selectionEnd, value } = element;
        const firstLineStart = value.lastIndexOf("\n", selectionStart - 1) + 1;
        const minimumSelectionEnd = _TextHelpers.findLineEnd(value, selectionEnd);
        const newSelection = element.value.slice(firstLineStart, minimumSelectionEnd);
        const indentedText = newSelection.replace(/(^|\n)(\t| {1,2})/g, "$1");
        const replacementsCount = newSelection.length - indentedText.length;
        element.setSelectionRange(firstLineStart, minimumSelectionEnd);
        _TextHelpers.insert(element, indentedText);
        const firstLineIndentation = /\t| {1,2}/.exec(value.slice(firstLineStart, selectionStart));
        const difference = firstLineIndentation ? firstLineIndentation[0].length : 0;
        const newSelectionStart = selectionStart - difference;
        element.setSelectionRange(selectionStart - difference, Math.max(newSelectionStart, selectionEnd - replacementsCount));
      }
      static indentCE(element) {
        const selection = window.getSelection();
        const value = element.innerText;
        const selectionStart = getCaretIndex(element) ?? 0;
        const selectionEnd = getCaretIndex(element) ?? 0;
        const selectedContrast = value.slice(selectionStart, selectionEnd);
        const lineBreakCount = /\n/g.exec(selectedContrast)?.length;
        if (lineBreakCount && lineBreakCount > 0) {
          const firstLineStart = value.lastIndexOf("\n", selectionStart - 1) + 1;
          const newSelection = value.slice(firstLineStart, selectionEnd - 1);
          const indentedText = newSelection.replace(/^|\n/g, `$&${INDENT}`);
          const replacementsCount = indentedText.length - newSelection.length;
          if (selection) {
            selection.setBaseAndExtent(element, selectionStart + 1, element, selectionEnd + replacementsCount);
          }
        } else {
          const selection2 = window.getSelection();
          element.innerText = value.slice(0, selectionStart) + INDENT + value.slice(selectionStart);
          selection2?.setBaseAndExtent(element, selectionStart + 1, element, selectionStart + 2);
        }
      }
      static unindentCE(element) {
        const selection = window.getSelection();
        const value = element.innerText;
        const selectionStart = getCaretIndex(element) ?? 0;
        const selectionEnd = getCaretIndex(element) ?? 0;
        const firstLineStart = value.lastIndexOf("\n", selectionStart - 1) + 1;
        const minimumSelectionEnd = _TextHelpers.findLineEnd(value, selectionEnd);
        const newSelection = value.slice(firstLineStart, minimumSelectionEnd);
        const indentedText = newSelection.replace(/(^|\n)(\t| {1,2})/g, "$1");
        const replacementsCount = newSelection.length - indentedText.length;
        if (selection) {
          selection.setBaseAndExtent(element, firstLineStart, element, minimumSelectionEnd);
          const firstLineIndentation = /\t| {1,2}/.exec(value.slice(firstLineStart, selectionStart));
          const difference = firstLineIndentation ? firstLineIndentation[0].length : 0;
          const newSelectionStart = selectionStart - difference;
          selection.setBaseAndExtent(element, selectionStart - difference, element, Math.max(newSelectionStart, selectionEnd - replacementsCount));
        }
      }
      static normalizeText(text) {
        return text.replace(_TextHelpers.fixNewLines, "\n");
      }
      static normalizeTextForDom(text) {
        return text.replace(_TextHelpers.fixNewLines, "\n").split("\n").map((x2) => x2 || " ").join("\n");
      }
    };
    TextHelpers = _TextHelpers;
    __publicField(TextHelpers, "fixNewLines", /\r?\n|\r/g);
  }
});

// node_modules/tldraw/dist-esm/lib/utils/text/text.mjs
function isRightToLeftLanguage(text) {
  return rtlRegex.test(text);
}
var rtlRegex;
var init_text = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/text/text.mjs"() {
    init_TextHelpers();
    rtlRegex = /[\u0590-\u05FF\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/;
  }
});

// node_modules/tldraw/dist-esm/lib/defaultExternalContentHandlers.mjs
var init_defaultExternalContentHandlers = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultExternalContentHandlers.mjs"() {
    init_dist_esm10();
    init_default_shape_constants();
    init_assets2();
    init_embeds();
    init_text();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/toolStates/Idle.mjs
var Idle2;
var init_Idle2 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/toolStates/Idle.mjs"() {
    init_dist_esm10();
    Idle2 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
        __publicField(this, "onKeyUp", (info2) => {
          if (info2.key === "Enter") {
            if (this.editor.getInstanceState().isReadonly)
              return null;
            const onlySelectedShape = this.editor.getOnlySelectedShape();
            if (onlySelectedShape && this.editor.getShapeUtil(onlySelectedShape).canEdit(onlySelectedShape)) {
              this.editor.setCurrentTool("select");
              this.editor.setEditingShape(onlySelectedShape.id);
              this.editor.root.getCurrent()?.transition("editing_shape", {
                ...info2,
                target: "shape",
                shape: onlySelectedShape
              });
            }
          }
        });
      }
    };
    __publicField(Idle2, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/toolStates/Pointing.mjs
var Pointing2;
var init_Pointing2 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/toolStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing2 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shape");
        __publicField(this, "markId", "");
        __publicField(this, "onEnter", () => {
          this.didTimeout = false;
          const target = this.editor.getShapeAtPoint(this.editor.inputs.currentPagePoint, {
            filter: (targetShape) => {
              return !targetShape.isLocked && this.editor.canBindShapes({ fromShape: "arrow", toShape: targetShape, binding: "arrow" });
            },
            margin: 0,
            hitInside: true,
            renderingOnly: true
          });
          if (!target) {
            this.createArrowShape();
          } else {
            this.editor.setHintingShapes([target.id]);
          }
          this.startPreciseTimeout();
        });
        __publicField(this, "onExit", () => {
          this.shape = void 0;
          this.editor.setHintingShapes([]);
          this.clearPreciseTimeout();
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            if (!this.shape) {
              this.createArrowShape();
            }
            if (!this.shape)
              throw Error(`expected shape`);
            this.updateArrowShapeEndHandle();
            this.editor.setCurrentTool("select.dragging_handle", {
              shape: this.shape,
              handle: { id: "end", type: "vertex", index: "a3", x: 0, y: 0 },
              isCreating: true,
              onInteractionEnd: "arrow"
            });
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.cancel();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
        __publicField(this, "preciseTimeout", -1);
        __publicField(this, "didTimeout", false);
      }
      cancel() {
        if (this.shape) {
          this.editor.bailToMark(this.markId);
        }
        this.editor.setHintingShapes([]);
        this.parent.transition("idle");
      }
      createArrowShape() {
        const { originPagePoint } = this.editor.inputs;
        const id = createShapeId();
        this.markId = `creating:${id}`;
        this.editor.mark(this.markId);
        this.editor.createShape({
          id,
          type: "arrow",
          x: originPagePoint.x,
          y: originPagePoint.y,
          props: {
            scale: this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1
          }
        });
        const shape = this.editor.getShape(id);
        if (!shape)
          throw Error(`expected shape`);
        const handles = this.editor.getShapeHandles(shape);
        if (!handles)
          throw Error(`expected handles for arrow`);
        const util = this.editor.getShapeUtil("arrow");
        const initial = this.shape;
        const startHandle = handles.find((h2) => h2.id === "start");
        const change = util.onHandleDrag?.(shape, {
          handle: { ...startHandle, x: 0, y: 0 },
          isPrecise: true,
          initial
        });
        if (change) {
          this.editor.updateShapes([change]);
        }
        this.shape = this.editor.getShape(id);
        this.editor.select(id);
      }
      updateArrowShapeEndHandle() {
        const shape = this.shape;
        if (!shape)
          throw Error(`expected shape`);
        const handles = this.editor.getShapeHandles(shape);
        if (!handles)
          throw Error(`expected handles for arrow`);
        {
          const util = this.editor.getShapeUtil("arrow");
          const initial = this.shape;
          const startHandle = handles.find((h2) => h2.id === "start");
          const change = util.onHandleDrag?.(shape, {
            handle: { ...startHandle, x: 0, y: 0 },
            isPrecise: this.didTimeout,
            initial
          });
          if (change) {
            this.editor.updateShapes([change]);
          }
        }
        {
          const util = this.editor.getShapeUtil("arrow");
          const initial = this.shape;
          const point = this.editor.getPointInShapeSpace(shape, this.editor.inputs.currentPagePoint);
          const endHandle = handles.find((h2) => h2.id === "end");
          const change = util.onHandleDrag?.(this.editor.getShape(shape), {
            handle: { ...endHandle, x: point.x, y: point.y },
            isPrecise: false,
            initial
          });
          if (change) {
            this.editor.updateShapes([change]);
          }
        }
        this.shape = this.editor.getShape(shape.id);
      }
      startPreciseTimeout() {
        this.preciseTimeout = this.editor.timers.setTimeout(() => {
          if (!this.getIsActive())
            return;
          this.didTimeout = true;
        }, 320);
      }
      clearPreciseTimeout() {
        clearTimeout(this.preciseTimeout);
      }
    };
    __publicField(Pointing2, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/ArrowShapeTool.mjs
var ArrowShapeTool;
var init_ArrowShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/ArrowShapeTool.mjs"() {
    init_dist_esm10();
    init_Idle2();
    init_Pointing2();
    ArrowShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "arrow");
      }
    };
    __publicField(ArrowShapeTool, "id", "arrow");
    __publicField(ArrowShapeTool, "initial", "idle");
    __publicField(ArrowShapeTool, "children", () => [Idle2, Pointing2]);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/draw/toolStates/Drawing.mjs
var Drawing;
var init_Drawing = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/draw/toolStates/Drawing.mjs"() {
    init_dist_esm10();
    init_default_shape_constants();
    Drawing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "initialShape");
        __publicField(this, "shapeType", this.parent.id === "highlight" ? "highlight" : "draw");
        __publicField(this, "util", this.editor.getShapeUtil(this.shapeType));
        __publicField(this, "isPen", false);
        __publicField(this, "isPenOrStylus", false);
        __publicField(this, "segmentMode", "free");
        __publicField(this, "didJustShiftClickToExtendPreviousShapeLine", false);
        __publicField(this, "pagePointWhereCurrentSegmentChanged", {});
        __publicField(this, "pagePointWhereNextSegmentChanged", null);
        __publicField(this, "lastRecordedPoint", {});
        __publicField(this, "mergeNextPoint", false);
        __publicField(this, "currentLineLength", 0);
        __publicField(this, "canDraw", false);
        __publicField(this, "markId", null);
        __publicField(this, "onEnter", (info2) => {
          this.markId = null;
          this.info = info2;
          this.canDraw = !this.editor.getIsMenuOpen();
          this.lastRecordedPoint = this.editor.inputs.currentPagePoint.clone();
          if (this.canDraw) {
            this.startShape();
          }
        });
        __publicField(this, "onPointerMove", () => {
          const { inputs } = this.editor;
          if (this.isPen && !inputs.isPen) {
            if (this.markId) {
              this.editor.bailToMark(this.markId);
              this.startShape();
              return;
            }
          } else {
            if (!this.canDraw && inputs.isDragging) {
              this.startShape();
              this.canDraw = true;
            }
          }
          if (this.canDraw) {
            if (this.isPenOrStylus) {
              if (Vec.Dist(inputs.currentPagePoint, this.lastRecordedPoint) >= 1 / this.editor.getZoomLevel()) {
                this.lastRecordedPoint = inputs.currentPagePoint.clone();
                this.mergeNextPoint = false;
              } else {
                this.mergeNextPoint = true;
              }
            } else {
              this.mergeNextPoint = false;
            }
            this.updateDrawingShape();
          }
        });
        __publicField(this, "onKeyDown", (info2) => {
          if (info2.key === "Shift") {
            switch (this.segmentMode) {
              case "free": {
                this.segmentMode = "starting_straight";
                this.pagePointWhereNextSegmentChanged = this.editor.inputs.currentPagePoint.clone();
                break;
              }
              case "starting_free": {
                this.segmentMode = "starting_straight";
              }
            }
          }
          this.updateDrawingShape();
        });
        __publicField(this, "onKeyUp", (info2) => {
          if (info2.key === "Shift") {
            this.editor.snaps.clearIndicators();
            switch (this.segmentMode) {
              case "straight": {
                this.segmentMode = "starting_free";
                this.pagePointWhereNextSegmentChanged = this.editor.inputs.currentPagePoint.clone();
                break;
              }
              case "starting_straight": {
                this.pagePointWhereNextSegmentChanged = null;
                this.segmentMode = "free";
                break;
              }
            }
          }
          this.updateDrawingShape();
        });
        __publicField(this, "onExit", () => {
          this.editor.snaps.clearIndicators();
          this.pagePointWhereCurrentSegmentChanged = this.editor.inputs.currentPagePoint.clone();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          if (this.editor.inputs.isDragging) {
            return;
          }
          if (this.markId) {
            this.editor.bailToMark(this.markId);
          }
          this.cancel();
        });
      }
      canClose() {
        return this.shapeType !== "highlight";
      }
      getIsClosed(segments, size4, scale) {
        if (!this.canClose())
          return false;
        const strokeWidth = STROKE_SIZES2[size4];
        const firstPoint = segments[0].points[0];
        const lastSegment = segments[segments.length - 1];
        const lastPoint = lastSegment.points[lastSegment.points.length - 1];
        return firstPoint !== lastPoint && this.currentLineLength > strokeWidth * 4 * scale && Vec.DistMin(firstPoint, lastPoint, strokeWidth * 2 * scale);
      }
      startShape() {
        const {
          inputs: { originPagePoint, isPen }
        } = this.editor;
        this.markId = "draw start " + uniqueId();
        this.editor.mark(this.markId);
        const { z = 0.5 } = this.info.point;
        this.isPen = isPen;
        this.isPenOrStylus = isPen || z > 0 && z < 0.5 || z > 0.5 && z < 1;
        const pressure = this.isPenOrStylus ? z * 1.25 : 0.5;
        this.segmentMode = this.editor.inputs.shiftKey ? "straight" : "free";
        this.didJustShiftClickToExtendPreviousShapeLine = false;
        this.lastRecordedPoint = originPagePoint.clone();
        if (this.initialShape) {
          const shape = this.editor.getShape(this.initialShape.id);
          if (shape && this.segmentMode === "straight") {
            this.didJustShiftClickToExtendPreviousShapeLine = true;
            const prevSegment = last(shape.props.segments);
            if (!prevSegment)
              throw Error("Expected a previous segment!");
            const prevPoint = last(prevSegment.points);
            if (!prevPoint)
              throw Error("Expected a previous point!");
            const { x: x2, y: y2 } = this.editor.getPointInShapeSpace(shape, originPagePoint).toFixed();
            const newSegment = {
              type: this.segmentMode,
              points: [
                {
                  x: prevPoint.x,
                  y: prevPoint.y,
                  z: +pressure.toFixed(2)
                },
                {
                  x: x2,
                  y: y2,
                  z: +pressure.toFixed(2)
                }
              ]
            };
            const prevPointPageSpace = Mat.applyToPoint(this.editor.getShapePageTransform(shape.id), prevPoint);
            this.pagePointWhereCurrentSegmentChanged = prevPointPageSpace;
            this.pagePointWhereNextSegmentChanged = null;
            const segments = [...shape.props.segments, newSegment];
            if (this.currentLineLength < STROKE_SIZES2[shape.props.size] * 4) {
              this.currentLineLength = this.getLineLength(segments);
            }
            const shapePartial = {
              id: shape.id,
              type: this.shapeType,
              props: {
                segments
              }
            };
            if (this.canClose()) {
              ;
              shapePartial.props.isClosed = this.getIsClosed(segments, shape.props.size, shape.props.scale);
            }
            this.editor.updateShapes([shapePartial]);
            return;
          }
        }
        this.pagePointWhereCurrentSegmentChanged = originPagePoint.clone();
        const id = createShapeId();
        this.editor.createShapes([
          {
            id,
            type: this.shapeType,
            x: originPagePoint.x,
            y: originPagePoint.y,
            props: {
              isPen: this.isPenOrStylus,
              scale: this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1,
              segments: [
                {
                  type: this.segmentMode,
                  points: [
                    {
                      x: 0,
                      y: 0,
                      z: +pressure.toFixed(2)
                    }
                  ]
                }
              ]
            }
          }
        ]);
        this.currentLineLength = 0;
        this.initialShape = this.editor.getShape(id);
      }
      updateDrawingShape() {
        const { initialShape } = this;
        const { inputs } = this.editor;
        if (!initialShape)
          return;
        const {
          id,
          props: { size: size4, scale }
        } = initialShape;
        const shape = this.editor.getShape(id);
        if (!shape)
          return;
        const { segments } = shape.props;
        const { x: x2, y: y2, z } = this.editor.getPointInShapeSpace(shape, inputs.currentPagePoint).toFixed();
        const pressure = this.isPenOrStylus ? +(inputs.currentPagePoint.z * 1.25).toFixed(2) : 0.5;
        const newPoint = { x: x2, y: y2, z: pressure };
        switch (this.segmentMode) {
          case "starting_straight": {
            const { pagePointWhereNextSegmentChanged } = this;
            if (pagePointWhereNextSegmentChanged === null) {
              throw Error("We should have a point where the segment changed");
            }
            const hasMovedFarEnough = Vec.Dist2(pagePointWhereNextSegmentChanged, inputs.currentPagePoint) > this.editor.options.dragDistanceSquared;
            if (hasMovedFarEnough) {
              this.pagePointWhereCurrentSegmentChanged = this.pagePointWhereNextSegmentChanged.clone();
              this.pagePointWhereNextSegmentChanged = null;
              this.segmentMode = "straight";
              const prevSegment = last(segments);
              if (!prevSegment)
                throw Error("Expected a previous segment!");
              const prevLastPoint = last(prevSegment.points);
              if (!prevLastPoint)
                throw Error("Expected a previous last point!");
              let newSegment;
              const newLastPoint = this.editor.getPointInShapeSpace(shape, this.pagePointWhereCurrentSegmentChanged).toFixed().toJson();
              if (prevSegment.type === "straight") {
                this.currentLineLength += Vec.Dist(prevLastPoint, newLastPoint);
                newSegment = {
                  type: "straight",
                  points: [{ ...prevLastPoint }, newLastPoint]
                };
                const transform = this.editor.getShapePageTransform(shape);
                this.pagePointWhereCurrentSegmentChanged = Mat.applyToPoint(transform, prevLastPoint);
              } else {
                newSegment = {
                  type: "straight",
                  points: [newLastPoint, newPoint]
                };
              }
              const shapePartial = {
                id,
                type: this.shapeType,
                props: {
                  segments: [...segments, newSegment]
                }
              };
              if (this.canClose()) {
                ;
                shapePartial.props.isClosed = this.getIsClosed(segments, size4, scale);
              }
              this.editor.updateShapes([shapePartial]);
            }
            break;
          }
          case "starting_free": {
            const { pagePointWhereNextSegmentChanged } = this;
            if (pagePointWhereNextSegmentChanged === null) {
              throw Error("We should have a point where the segment changed");
            }
            const hasMovedFarEnough = Vec.Dist2(pagePointWhereNextSegmentChanged, inputs.currentPagePoint) > this.editor.options.dragDistanceSquared;
            if (hasMovedFarEnough) {
              this.pagePointWhereCurrentSegmentChanged = this.pagePointWhereNextSegmentChanged.clone();
              this.pagePointWhereNextSegmentChanged = null;
              this.segmentMode = "free";
              const newSegments = segments.slice();
              const prevStraightSegment = newSegments[newSegments.length - 1];
              const prevPoint = last(prevStraightSegment.points);
              if (!prevPoint) {
                throw Error("No previous point!");
              }
              const newFreeSegment = {
                type: "free",
                points: [
                  ...Vec.PointsBetween(prevPoint, newPoint, 6).map((p2) => ({
                    x: toFixed(p2.x),
                    y: toFixed(p2.y),
                    z: toFixed(p2.z)
                  }))
                ]
              };
              const finalSegments = [...newSegments, newFreeSegment];
              if (this.currentLineLength < STROKE_SIZES2[shape.props.size] * 4) {
                this.currentLineLength = this.getLineLength(finalSegments);
              }
              const shapePartial = {
                id,
                type: this.shapeType,
                props: {
                  segments: finalSegments
                }
              };
              if (this.canClose()) {
                ;
                shapePartial.props.isClosed = this.getIsClosed(finalSegments, size4, scale);
              }
              this.editor.updateShapes([shapePartial]);
            }
            break;
          }
          case "straight": {
            const newSegments = segments.slice();
            const newSegment = newSegments[newSegments.length - 1];
            const { pagePointWhereCurrentSegmentChanged } = this;
            const { ctrlKey, currentPagePoint } = this.editor.inputs;
            if (!pagePointWhereCurrentSegmentChanged)
              throw Error("We should have a point where the segment changed");
            let pagePoint;
            let shouldSnapToAngle = false;
            if (this.didJustShiftClickToExtendPreviousShapeLine) {
              if (this.editor.inputs.isDragging) {
                shouldSnapToAngle = !ctrlKey;
                this.didJustShiftClickToExtendPreviousShapeLine = false;
              } else {
              }
            } else {
              shouldSnapToAngle = !ctrlKey;
            }
            let newPoint2 = this.editor.getPointInShapeSpace(shape, currentPagePoint).toFixed().toJson();
            let didSnap = false;
            let snapSegment = void 0;
            const shouldSnap = this.editor.user.getIsSnapMode() ? !ctrlKey : ctrlKey;
            if (shouldSnap) {
              if (newSegments.length > 2) {
                let nearestPoint = void 0;
                let minDistance = 8 / this.editor.getZoomLevel();
                for (let i2 = 0, n2 = segments.length - 2; i2 < n2; i2++) {
                  const segment = segments[i2];
                  if (!segment)
                    break;
                  if (segment.type === "free")
                    continue;
                  const first = segment.points[0];
                  const lastPoint = last(segment.points);
                  if (!(first && lastPoint))
                    continue;
                  const nearestPointOnSegment = Vec.NearestPointOnLineSegment(first, lastPoint, newPoint2);
                  if (Vec.DistMin(nearestPointOnSegment, newPoint2, minDistance)) {
                    nearestPoint = nearestPointOnSegment.toFixed().toJson();
                    minDistance = Vec.Dist(nearestPointOnSegment, newPoint2);
                    snapSegment = segment;
                    break;
                  }
                }
                if (nearestPoint) {
                  didSnap = true;
                  newPoint2 = nearestPoint;
                }
              }
            }
            if (didSnap && snapSegment) {
              const transform = this.editor.getShapePageTransform(shape);
              const first = snapSegment.points[0];
              const lastPoint = last(snapSegment.points);
              if (!lastPoint)
                throw Error("Expected a last point!");
              const A2 = Mat.applyToPoint(transform, first);
              const B = Mat.applyToPoint(transform, lastPoint);
              const snappedPoint = Mat.applyToPoint(transform, newPoint2);
              this.editor.snaps.setIndicators([
                {
                  id: uniqueId(),
                  type: "points",
                  points: [A2, snappedPoint, B]
                }
              ]);
            } else {
              this.editor.snaps.clearIndicators();
              if (shouldSnapToAngle) {
                const currentAngle = Vec.Angle(pagePointWhereCurrentSegmentChanged, currentPagePoint);
                const snappedAngle = snapAngle(currentAngle, 24);
                const angleDiff = snappedAngle - currentAngle;
                pagePoint = Vec.RotWith(currentPagePoint, pagePointWhereCurrentSegmentChanged, angleDiff);
              } else {
                pagePoint = currentPagePoint;
              }
              newPoint2 = this.editor.getPointInShapeSpace(shape, pagePoint).toFixed().toJson();
            }
            this.currentLineLength += Vec.Dist(newSegment.points[0], newPoint2);
            newSegments[newSegments.length - 1] = {
              ...newSegment,
              type: "straight",
              points: [newSegment.points[0], newPoint2]
            };
            const shapePartial = {
              id,
              type: this.shapeType,
              props: {
                segments: newSegments
              }
            };
            if (this.canClose()) {
              ;
              shapePartial.props.isClosed = this.getIsClosed(segments, size4, scale);
            }
            this.editor.updateShapes([shapePartial]);
            break;
          }
          case "free": {
            const newSegments = segments.slice();
            const newSegment = newSegments[newSegments.length - 1];
            const newPoints = [...newSegment.points];
            if (newPoints.length && this.mergeNextPoint) {
              const { z: z2 } = newPoints[newPoints.length - 1];
              newPoints[newPoints.length - 1] = {
                x: newPoint.x,
                y: newPoint.y,
                z: z2 ? Math.max(z2, newPoint.z) : newPoint.z
              };
            } else {
              this.currentLineLength += Vec.Dist(newPoints[newPoints.length - 1], newPoint);
              newPoints.push(newPoint);
            }
            newSegments[newSegments.length - 1] = {
              ...newSegment,
              points: newPoints
            };
            if (this.currentLineLength < STROKE_SIZES2[shape.props.size] * 4) {
              this.currentLineLength = this.getLineLength(newSegments);
            }
            const shapePartial = {
              id,
              type: this.shapeType,
              props: {
                segments: newSegments
              }
            };
            if (this.canClose()) {
              ;
              shapePartial.props.isClosed = this.getIsClosed(newSegments, size4, scale);
            }
            this.editor.updateShapes([shapePartial]);
            if (newPoints.length > this.editor.options.maxPointsPerDrawShape) {
              this.editor.updateShapes([{ id, type: this.shapeType, props: { isComplete: true } }]);
              const newShapeId = createShapeId();
              const props = this.editor.getShape(id).props;
              this.editor.createShapes([
                {
                  id: newShapeId,
                  type: this.shapeType,
                  x: toFixed(inputs.currentPagePoint.x),
                  y: toFixed(inputs.currentPagePoint.y),
                  props: {
                    isPen: this.isPenOrStylus,
                    scale: props.scale,
                    segments: [
                      {
                        type: "free",
                        points: [{ x: 0, y: 0, z: this.isPenOrStylus ? +(z * 1.25).toFixed() : 0.5 }]
                      }
                    ]
                  }
                }
              ]);
              this.initialShape = structuredClone2(this.editor.getShape(newShapeId));
              this.mergeNextPoint = false;
              this.lastRecordedPoint = inputs.currentPagePoint.clone();
              this.currentLineLength = 0;
            }
            break;
          }
        }
      }
      getLineLength(segments) {
        let length = 0;
        for (const segment of segments) {
          for (let i2 = 0; i2 < segment.points.length - 1; i2++) {
            const A2 = segment.points[i2];
            const B = segment.points[i2 + 1];
            length += Vec.Dist2(B, A2);
          }
        }
        return Math.sqrt(length);
      }
      complete() {
        if (!this.canDraw) {
          this.cancel();
          return;
        }
        const { initialShape } = this;
        if (!initialShape)
          return;
        this.editor.updateShapes([
          { id: initialShape.id, type: initialShape.type, props: { isComplete: true } }
        ]);
        this.parent.transition("idle");
      }
      cancel() {
        this.parent.transition("idle", this.info);
      }
    };
    __publicField(Drawing, "id", "drawing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/draw/toolStates/Idle.mjs
var Idle3;
var init_Idle3 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/draw/toolStates/Idle.mjs"() {
    init_dist_esm10();
    Idle3 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("drawing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle3, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/draw/DrawShapeTool.mjs
var DrawShapeTool;
var init_DrawShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/draw/DrawShapeTool.mjs"() {
    init_dist_esm10();
    init_Drawing();
    init_Idle3();
    DrawShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "draw");
        __publicField(this, "onExit", () => {
          const drawingState = this.children["drawing"];
          drawingState.initialShape = void 0;
        });
      }
    };
    __publicField(DrawShapeTool, "id", "draw");
    __publicField(DrawShapeTool, "initial", "idle");
    __publicField(DrawShapeTool, "isLockable", false);
    __publicField(DrawShapeTool, "children", () => [Idle3, Drawing]);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/frame/FrameShapeTool.mjs
function canEnclose(shape, ancestorIds, frame3) {
  if (ancestorIds.includes(shape.id)) {
    return false;
  }
  if (shape.parentId === frame3.parentId) {
    return true;
  }
  return false;
}
var FrameShapeTool;
var init_FrameShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/frame/FrameShapeTool.mjs"() {
    init_dist_esm10();
    FrameShapeTool = class extends BaseBoxShapeTool {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "frame");
        __publicField(this, "onCreate", (shape) => {
          if (!shape)
            return;
          const bounds = this.editor.getShapePageBounds(shape);
          const shapesToAddToFrame = [];
          const ancestorIds = this.editor.getShapeAncestors(shape).map((shape2) => shape2.id);
          this.editor.getSortedChildIdsForParent(shape.parentId).map((siblingShapeId) => {
            const siblingShape = this.editor.getShape(siblingShapeId);
            if (!siblingShape)
              return;
            if (siblingShape.id === shape.id)
              return;
            if (siblingShape.isLocked)
              return;
            const pageShapeBounds = this.editor.getShapePageBounds(siblingShape);
            if (!pageShapeBounds)
              return;
            if (bounds.contains(pageShapeBounds)) {
              if (canEnclose(siblingShape, ancestorIds, shape)) {
                shapesToAddToFrame.push(siblingShape.id);
              }
            }
          });
          this.editor.reparentShapes(shapesToAddToFrame, shape.id);
          if (this.editor.getInstanceState().isToolLocked) {
            this.editor.setCurrentTool("frame");
          } else {
            this.editor.setCurrentTool("select.idle");
          }
        });
      }
    };
    __publicField(FrameShapeTool, "id", "frame");
    __publicField(FrameShapeTool, "initial", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/toolStates/Idle.mjs
var Idle4;
var init_Idle4 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/toolStates/Idle.mjs"() {
    init_dist_esm10();
    Idle4 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onKeyUp", (info2) => {
          if (info2.key === "Enter") {
            if (this.editor.getInstanceState().isReadonly)
              return null;
            const onlySelectedShape = this.editor.getOnlySelectedShape();
            if (onlySelectedShape && this.editor.getShapeUtil(onlySelectedShape).canEdit(onlySelectedShape)) {
              this.editor.setCurrentTool("select");
              this.editor.setEditingShape(onlySelectedShape.id);
              this.editor.root.getCurrent()?.transition("editing_shape", {
                ...info2,
                target: "shape",
                shape: onlySelectedShape
              });
            }
          }
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle4, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/toolStates/Pointing.mjs
var Pointing3;
var init_Pointing3 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/toolStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing3 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "markId", "");
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            const { originPagePoint } = this.editor.inputs;
            const id = createShapeId();
            this.markId = `creating:${id}`;
            this.editor.mark(this.markId);
            this.editor.createShapes([
              {
                id,
                type: "geo",
                x: originPagePoint.x,
                y: originPagePoint.y,
                props: {
                  w: 1,
                  h: 1,
                  geo: this.editor.getStyleForNextShape(GeoShapeGeoStyle),
                  scale: this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1
                }
              }
            ]).select(id).setCurrentTool("select.resizing", {
              ...info2,
              target: "selection",
              handle: "bottom_right",
              isCreating: true,
              creationCursorOffset: { x: 1, y: 1 },
              onInteractionEnd: "geo"
            });
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      complete() {
        const { originPagePoint } = this.editor.inputs;
        const id = createShapeId();
        this.markId = `creating:${id}`;
        this.editor.mark(this.markId);
        const scale = this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1;
        const geo = this.editor.getStyleForNextShape(GeoShapeGeoStyle);
        const size4 = geo === "star" ? { w: 200, h: 190 } : geo === "cloud" ? { w: 300, h: 180 } : { w: 200, h: 200 };
        this.editor.createShapes([
          {
            id,
            type: "geo",
            x: originPagePoint.x,
            y: originPagePoint.y,
            props: {
              geo: this.editor.getStyleForNextShape(GeoShapeGeoStyle),
              scale,
              ...size4
            }
          }
        ]);
        const shape = this.editor.getShape(id);
        if (!shape)
          return;
        const { w: w2, h: h2 } = shape.props;
        const delta = new Vec(w2 / 2, h2 / 2).mul(scale);
        const parentTransform = this.editor.getShapeParentTransform(shape);
        if (parentTransform)
          delta.rot(-parentTransform.rotation());
        this.editor.select(id);
        this.editor.updateShape({
          id: shape.id,
          type: "geo",
          x: shape.x - delta.x,
          y: shape.y - delta.y,
          props: {
            geo: this.editor.getStyleForNextShape(GeoShapeGeoStyle),
            w: w2 * scale,
            h: h2 * scale
          }
        });
        if (this.editor.getInstanceState().isToolLocked) {
          this.parent.transition("idle");
        } else {
          this.editor.setCurrentTool("select", {});
        }
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(Pointing3, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/GeoShapeTool.mjs
var GeoShapeTool;
var init_GeoShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/GeoShapeTool.mjs"() {
    init_dist_esm10();
    init_Idle4();
    init_Pointing3();
    GeoShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "geo");
      }
    };
    __publicField(GeoShapeTool, "id", "geo");
    __publicField(GeoShapeTool, "initial", "idle");
    __publicField(GeoShapeTool, "children", () => [Idle4, Pointing3]);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/highlight/HighlightShapeTool.mjs
var HighlightShapeTool;
var init_HighlightShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/highlight/HighlightShapeTool.mjs"() {
    init_dist_esm10();
    init_Drawing();
    init_Idle3();
    HighlightShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "highlight");
        __publicField(this, "onExit", () => {
          const drawingState = this.children["drawing"];
          drawingState.initialShape = void 0;
        });
      }
    };
    __publicField(HighlightShapeTool, "id", "highlight");
    __publicField(HighlightShapeTool, "initial", "idle");
    __publicField(HighlightShapeTool, "children", () => [Idle3, Drawing]);
    __publicField(HighlightShapeTool, "isLockable", false);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/toolStates/Idle.mjs
var Idle5;
var init_Idle5 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/toolStates/Idle.mjs"() {
    init_dist_esm10();
    Idle5 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeId", "");
        __publicField(this, "onEnter", (info2) => {
          this.shapeId = info2.shapeId;
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onPointerDown", () => {
          this.parent.transition("pointing", { shapeId: this.shapeId });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle5, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/toolStates/Pointing.mjs
var MINIMUM_DISTANCE_BETWEEN_SHIFT_CLICKED_HANDLES, Pointing4;
var init_Pointing4 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/toolStates/Pointing.mjs"() {
    init_dist_esm10();
    MINIMUM_DISTANCE_BETWEEN_SHIFT_CLICKED_HANDLES = 2;
    Pointing4 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shape", {});
        __publicField(this, "markId");
        __publicField(this, "onEnter", (info2) => {
          const { inputs } = this.editor;
          const { currentPagePoint } = inputs;
          this.markId = void 0;
          const shape = info2.shapeId && this.editor.getShape(info2.shapeId);
          if (shape && inputs.shiftKey) {
            this.markId = `creating:${shape.id}`;
            this.editor.mark(this.markId);
            this.shape = shape;
            const handles = this.editor.getShapeHandles(this.shape);
            if (!handles)
              return;
            const vertexHandles = handles.filter((h2) => h2.type === "vertex").sort(sortByIndex);
            const endHandle = vertexHandles[vertexHandles.length - 1];
            const prevEndHandle = vertexHandles[vertexHandles.length - 2];
            const shapePagePoint = Mat.applyToPoint(this.editor.getShapeParentTransform(this.shape), new Vec(this.shape.x, this.shape.y));
            const nextPoint = Vec.Sub(currentPagePoint, shapePagePoint).addXY(0.1, 0.1);
            const points = structuredClone2(this.shape.props.points);
            if (Vec.DistMin(endHandle, prevEndHandle, MINIMUM_DISTANCE_BETWEEN_SHIFT_CLICKED_HANDLES) || Vec.DistMin(nextPoint, endHandle, MINIMUM_DISTANCE_BETWEEN_SHIFT_CLICKED_HANDLES)) {
              points[endHandle.id] = {
                id: endHandle.id,
                index: endHandle.index,
                x: nextPoint.x,
                y: nextPoint.y
              };
            } else {
              const nextIndex = getIndexAbove(endHandle.index);
              points[nextIndex] = {
                id: nextIndex,
                index: nextIndex,
                x: nextPoint.x,
                y: nextPoint.y
              };
            }
            this.editor.updateShapes([
              {
                id: this.shape.id,
                type: this.shape.type,
                props: {
                  points
                }
              }
            ]);
          } else {
            const id = createShapeId();
            this.markId = `creating:${id}`;
            this.editor.mark(this.markId);
            this.editor.createShapes([
              {
                id,
                type: "line",
                x: currentPagePoint.x,
                y: currentPagePoint.y,
                props: {
                  scale: this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1
                }
              }
            ]);
            this.editor.select(id);
            this.shape = this.editor.getShape(id);
          }
        });
        __publicField(this, "onPointerMove", () => {
          if (!this.shape)
            return;
          if (this.editor.inputs.isDragging) {
            const handles = this.editor.getShapeHandles(this.shape);
            if (!handles) {
              if (this.markId)
                this.editor.bailToMark(this.markId);
              throw Error("No handles found");
            }
            const lastHandle = last(handles);
            this.editor.setCurrentTool("select.dragging_handle", {
              shape: this.shape,
              isCreating: true,
              handle: { ...lastHandle, x: lastHandle.x - 0.1, y: lastHandle.y - 0.1 },
              onInteractionEnd: "line"
            });
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.parent.transition("idle");
          if (this.markId)
            this.editor.bailToMark(this.markId);
          this.editor.snaps.clearIndicators();
        });
      }
      complete() {
        this.parent.transition("idle", { shapeId: this.shape.id });
        this.editor.snaps.clearIndicators();
      }
      cancel() {
        if (this.markId)
          this.editor.bailToMark(this.markId);
        this.parent.transition("idle", { shapeId: this.shape.id });
        this.editor.snaps.clearIndicators();
      }
    };
    __publicField(Pointing4, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/LineShapeTool.mjs
var LineShapeTool;
var init_LineShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/LineShapeTool.mjs"() {
    init_dist_esm10();
    init_Idle5();
    init_Pointing4();
    LineShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "line");
      }
    };
    __publicField(LineShapeTool, "id", "line");
    __publicField(LineShapeTool, "initial", "idle");
    __publicField(LineShapeTool, "children", () => [Idle5, Pointing4]);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/note/toolStates/Idle.mjs
var Idle6;
var init_Idle6 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/note/toolStates/Idle.mjs"() {
    init_dist_esm10();
    Idle6 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle6, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/selectHelpers.mjs
function kickoutOccludedShapes(editor, shapeIds) {
  const parentsToCheck = /* @__PURE__ */ new Set();
  for (const id of shapeIds) {
    const shape = editor.getShape(id);
    if (!shape)
      continue;
    if (editor.getShapeUtil(shape).onDragShapesOut) {
      parentsToCheck.add(shape);
    }
    const parent = editor.getShape(shape.parentId);
    if (!parent)
      continue;
    if (editor.getShapeUtil(parent).onDragShapesOut) {
      parentsToCheck.add(parent);
    }
  }
  const parentsWithKickedOutChildren = /* @__PURE__ */ new Map();
  for (const parent of parentsToCheck) {
    const occludedChildren = getOccludedChildren(editor, parent);
    if (occludedChildren.length) {
      parentsWithKickedOutChildren.set(parent, occludedChildren);
    }
  }
  for (const [parent, kickedOutChildrenIds] of parentsWithKickedOutChildren) {
    const shapeUtil = editor.getShapeUtil(parent);
    const kickedOutChildren = compact(kickedOutChildrenIds.map((id) => editor.getShape(id)));
    shapeUtil.onDragShapesOut?.(parent, kickedOutChildren);
  }
}
function getOccludedChildren(editor, parent) {
  const childIds = editor.getSortedChildIdsForParent(parent.id);
  if (childIds.length === 0)
    return [];
  const parentPageBounds = editor.getShapePageBounds(parent);
  if (!parentPageBounds)
    return [];
  let parentGeometry;
  let parentPageTransform;
  let parentPageCorners;
  const results = [];
  for (const childId of childIds) {
    const shapePageBounds = editor.getShapePageBounds(childId);
    if (!shapePageBounds) {
      continue;
    }
    if (!parentPageBounds.includes(shapePageBounds)) {
      results.push(childId);
      continue;
    }
    parentGeometry ?? (parentGeometry = editor.getShapeGeometry(parent));
    parentPageTransform ?? (parentPageTransform = editor.getShapePageTransform(parent));
    parentPageCorners ?? (parentPageCorners = parentPageTransform.applyToPoints(parentGeometry.vertices));
    const parentCornersInShapeSpace = editor.getShapePageTransform(childId).clone().invert().applyToPoints(parentPageCorners);
    const { vertices, isClosed } = editor.getShapeGeometry(childId);
    if (vertices.some((v2) => pointInPolygon(v2, parentCornersInShapeSpace))) {
      continue;
    }
    if (isClosed) {
      if (polygonsIntersect(parentCornersInShapeSpace, vertices)) {
        continue;
      }
    } else if (polygonIntersectsPolyline(parentCornersInShapeSpace, vertices)) {
      continue;
    }
    results.push(childId);
  }
  return results;
}
function startEditingShapeWithLabel(editor, shape, selectAll = false) {
  editor.select(shape);
  editor.setEditingShape(shape);
  editor.setCurrentTool("select.editing_shape", {
    target: "shape",
    shape
  });
  if (selectAll) {
    editor.emit("select-all-text", { shapeId: shape.id });
  }
  zoomToShapeIfOffscreen(editor);
}
function zoomToShapeIfOffscreen(editor) {
  const selectionPageBounds = editor.getSelectionPageBounds();
  const viewportPageBounds = editor.getViewportPageBounds();
  if (selectionPageBounds && !viewportPageBounds.contains(selectionPageBounds)) {
    const eb = selectionPageBounds.clone().expandBy(ZOOM_TO_SHAPE_PADDING / editor.getZoomLevel()).expand(viewportPageBounds);
    const nextBounds = viewportPageBounds.clone().translate({
      x: (eb.center.x - viewportPageBounds.center.x) * 2,
      y: (eb.center.y - viewportPageBounds.center.y) * 2
    });
    editor.zoomToBounds(nextBounds, {
      animation: {
        duration: editor.options.animationMediumMs
      },
      inset: 0
    });
  }
}
var ZOOM_TO_SHAPE_PADDING;
var init_selectHelpers = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/selectHelpers.mjs"() {
    init_dist_esm10();
    ZOOM_TO_SHAPE_PADDING = 16;
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/note/noteHelpers.mjs
function getBaseAdjacentNotePositions(editor, scale) {
  if (scale === 1)
    return BASE_NOTE_POSITIONS(editor);
  const s2 = NOTE_SIZE * scale;
  const m2 = editor.options.adjacentShapeMargin * scale;
  return [
    [["a1"], new Vec(s2 * 0.5, s2 * -0.5 - m2)],
    [["a2"], new Vec(s2 * 1.5 + m2, s2 * 0.5)],
    [["a3"], new Vec(s2 * 0.5, s2 * 1.5 + m2)],
    [["a4"], new Vec(s2 * -0.5 - m2, s2 * 0.5)]
  ];
}
function getNoteAdjacentPositions(editor, pagePoint, pageRotation, growY, extraHeight, scale) {
  return Object.fromEntries(getBaseAdjacentNotePositions(editor, scale).map(([id, v2], i2) => {
    const point = v2.clone();
    if (i2 === 0 && extraHeight) {
      point.y -= extraHeight;
    } else if (i2 === 2 && growY) {
      point.y += growY;
    }
    return [id, point.rot(pageRotation).add(pagePoint)];
  }));
}
function getAvailableNoteAdjacentPositions(editor, rotation, scale, extraHeight) {
  const selectedShapeIds = new Set(editor.getSelectedShapeIds());
  const minSize = (NOTE_SIZE + editor.options.adjacentShapeMargin + extraHeight) ** 2;
  const allCenters = /* @__PURE__ */ new Map();
  const positions = [];
  for (const shape of editor.getCurrentPageShapes()) {
    if (!editor.isShapeOfType(shape, "note") || scale !== shape.props.scale || selectedShapeIds.has(shape.id)) {
      continue;
    }
    const transform = editor.getShapePageTransform(shape.id);
    if (rotation !== transform.rotation())
      continue;
    allCenters.set(shape, editor.getShapePageBounds(shape).center);
    positions.push(...Object.values(getNoteAdjacentPositions(editor, transform.point(), rotation, shape.props.growY, extraHeight, scale)));
  }
  const len = positions.length;
  let position;
  for (const [shape, center] of allCenters) {
    for (let i2 = 0; i2 < len; i2++) {
      position = positions[i2];
      if (!position)
        continue;
      if (Vec.Dist2(center, position) > minSize)
        continue;
      if (editor.isPointInShape(shape, position)) {
        positions[i2] = void 0;
      }
    }
  }
  return compact(positions);
}
function getNoteShapeForAdjacentPosition(editor, shape, center, pageRotation, forceNew = false) {
  let nextNote;
  const allShapesOnPage = editor.getCurrentPageShapesSorted();
  const minDistance = (NOTE_SIZE + editor.options.adjacentShapeMargin ** 2) ** shape.props.scale;
  for (let i2 = allShapesOnPage.length - 1; i2 >= 0; i2--) {
    const otherNote = allShapesOnPage[i2];
    if (otherNote.type === "note" && otherNote.id !== shape.id) {
      const otherBounds = editor.getShapePageBounds(otherNote);
      if (otherBounds && Vec.Dist2(otherBounds.center, center) < minDistance && editor.isPointInShape(otherNote, center)) {
        nextNote = otherNote;
        break;
      }
    }
  }
  editor.complete();
  if (!nextNote || forceNew) {
    editor.mark("creating note shape");
    const id = createShapeId();
    editor.createShape({
      id,
      type: "note",
      x: center.x,
      y: center.y,
      rotation: pageRotation,
      opacity: shape.opacity,
      props: {
        ...shape.props,
        text: "",
        growY: 0,
        fontSizeAdjustment: 0,
        url: ""
      }
    });
    const createdShape = editor.getShape(id);
    if (!createdShape)
      return;
    const topLeft = editor.getPointInParentSpace(createdShape, Vec.Sub(center, Vec.Rot(NOTE_CENTER_OFFSET.clone().mul(createdShape.props.scale), pageRotation)));
    editor.updateShape({
      id,
      type: "note",
      x: topLeft.x,
      y: topLeft.y
    });
    nextNote = editor.getShape(id);
  }
  zoomToShapeIfOffscreen(editor);
  return nextNote;
}
var CLONE_HANDLE_MARGIN, NOTE_SIZE, NOTE_CENTER_OFFSET, NOTE_ADJACENT_POSITION_SNAP_RADIUS, BASE_NOTE_POSITIONS;
var init_noteHelpers = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/note/noteHelpers.mjs"() {
    init_dist_esm10();
    init_selectHelpers();
    CLONE_HANDLE_MARGIN = 0;
    NOTE_SIZE = 200;
    NOTE_CENTER_OFFSET = new Vec(NOTE_SIZE / 2, NOTE_SIZE / 2);
    NOTE_ADJACENT_POSITION_SNAP_RADIUS = 10;
    BASE_NOTE_POSITIONS = (editor) => [
      [
        ["a1"],
        new Vec(NOTE_SIZE * 0.5, NOTE_SIZE * -0.5 - editor.options.adjacentShapeMargin)
      ],
      [
        ["a2"],
        new Vec(NOTE_SIZE * 1.5 + editor.options.adjacentShapeMargin, NOTE_SIZE * 0.5)
      ],
      [
        ["a3"],
        new Vec(NOTE_SIZE * 0.5, NOTE_SIZE * 1.5 + editor.options.adjacentShapeMargin)
      ],
      [
        ["a4"],
        new Vec(NOTE_SIZE * -0.5 - editor.options.adjacentShapeMargin, NOTE_SIZE * 0.5)
      ]
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/note/toolStates/Pointing.mjs
function getNoteShapeAdjacentPositionOffset(editor, center, scale) {
  let min4 = NOTE_ADJACENT_POSITION_SNAP_RADIUS / editor.getZoomLevel();
  let offset5;
  for (const pit of getAvailableNoteAdjacentPositions(editor, 0, scale, 0)) {
    const deltaToPit = Vec.Sub(center, pit);
    const dist = deltaToPit.len();
    if (dist < min4) {
      min4 = dist;
      offset5 = deltaToPit;
    }
  }
  return offset5;
}
function createNoteShape(editor, id, center) {
  editor.createShape({
    id,
    type: "note",
    x: center.x,
    y: center.y,
    props: {
      scale: editor.user.getIsDynamicResizeMode() ? 1 / editor.getZoomLevel() : 1
    }
  }).select(id);
  const shape = editor.getShape(id);
  const bounds = editor.getShapeGeometry(shape).bounds;
  editor.updateShapes([
    {
      id,
      type: "note",
      x: shape.x - bounds.width / 2,
      y: shape.y - bounds.height / 2
    }
  ]);
  return editor.getShape(id);
}
var Pointing5;
var init_Pointing5 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/note/toolStates/Pointing.mjs"() {
    init_dist_esm10();
    init_noteHelpers();
    Pointing5 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "dragged", false);
        __publicField(this, "info", {});
        __publicField(this, "wasFocusedOnEnter", false);
        __publicField(this, "markId", "");
        __publicField(this, "shape", {});
        __publicField(this, "onEnter", () => {
          const { editor } = this;
          this.wasFocusedOnEnter = !editor.getIsMenuOpen();
          if (this.wasFocusedOnEnter) {
            const id = createShapeId();
            this.markId = `creating:${id}`;
            editor.mark(this.markId);
            const center = this.editor.inputs.originPagePoint.clone();
            const offset5 = getNoteShapeAdjacentPositionOffset(this.editor, center, this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1);
            if (offset5) {
              center.sub(offset5);
            }
            this.shape = createNoteShape(this.editor, id, center);
          }
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            if (!this.wasFocusedOnEnter) {
              const id = createShapeId();
              const center = this.editor.inputs.originPagePoint.clone();
              const offset5 = getNoteShapeAdjacentPositionOffset(this.editor, center, this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1);
              if (offset5) {
                center.sub(offset5);
              }
              this.shape = createNoteShape(this.editor, id, center);
            }
            this.editor.setCurrentTool("select.translating", {
              ...info2,
              target: "shape",
              shape: this.shape,
              onInteractionEnd: "note",
              isCreating: true,
              onCreate: () => {
                this.editor.setEditingShape(this.shape.id);
                this.editor.setCurrentTool("select.editing_shape");
              }
            });
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
      }
      complete() {
        if (this.wasFocusedOnEnter) {
          if (this.editor.getInstanceState().isToolLocked) {
            this.parent.transition("idle");
          } else {
            this.editor.setEditingShape(this.shape.id);
            this.editor.setCurrentTool("select.editing_shape", {
              ...this.info,
              target: "shape",
              shape: this.shape
            });
          }
        }
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        this.parent.transition("idle", this.info);
      }
    };
    __publicField(Pointing5, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/note/NoteShapeTool.mjs
var NoteShapeTool;
var init_NoteShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/note/NoteShapeTool.mjs"() {
    init_dist_esm10();
    init_Idle6();
    init_Pointing5();
    NoteShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "note");
      }
    };
    __publicField(NoteShapeTool, "id", "note");
    __publicField(NoteShapeTool, "initial", "idle");
    __publicField(NoteShapeTool, "children", () => [Idle6, Pointing5]);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/selection-logic/updateHoveredShapeId.mjs
function _updateHoveredShapeId(editor) {
  const hitShape = editor.getShapeAtPoint(editor.inputs.currentPagePoint, {
    hitInside: false,
    hitLabels: false,
    margin: editor.options.hitTestMargin / editor.getZoomLevel(),
    renderingOnly: true
  });
  if (!hitShape)
    return editor.setHoveredShape(null);
  let shapeToHover = void 0;
  const outermostShape = editor.getOutermostSelectableShape(hitShape);
  if (outermostShape === hitShape) {
    shapeToHover = hitShape;
  } else {
    if (outermostShape.id === editor.getFocusedGroupId() || editor.getSelectedShapeIds().includes(outermostShape.id)) {
      shapeToHover = hitShape;
    } else {
      shapeToHover = outermostShape;
    }
  }
  return editor.setHoveredShape(shapeToHover.id);
}
var updateHoveredShapeId;
var init_updateHoveredShapeId = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/selection-logic/updateHoveredShapeId.mjs"() {
    init_dist_esm10();
    updateHoveredShapeId = (0, import_lodash.default)(_updateHoveredShapeId, false ? 0 : 32);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/text/toolStates/Idle.mjs
var Idle7;
var init_Idle7 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/text/toolStates/Idle.mjs"() {
    init_dist_esm10();
    init_updateHoveredShapeId();
    Idle7 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerMove", (info2) => {
          switch (info2.target) {
            case "shape":
            case "canvas": {
              updateHoveredShapeId(this.editor);
            }
          }
        });
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
        __publicField(this, "onExit", () => {
          updateHoveredShapeId.cancel();
        });
        __publicField(this, "onKeyDown", (info2) => {
          if (info2.key === "Enter") {
            if (this.editor.getInstanceState().isReadonly)
              return null;
            const onlySelectedShape = this.editor.getOnlySelectedShape();
            if (onlySelectedShape && this.editor.getShapeUtil(onlySelectedShape).canEdit(onlySelectedShape)) {
              this.editor.setCurrentTool("select");
              this.editor.setEditingShape(onlySelectedShape.id);
              this.editor.root.getCurrent()?.transition("editing_shape", {
                ...info2,
                target: "shape",
                shape: onlySelectedShape
              });
            }
          }
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle7, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/text/toolStates/Pointing.mjs
var Pointing6;
var init_Pointing6 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/text/toolStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing6 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shape");
        __publicField(this, "markId", "");
        __publicField(this, "onExit", () => {
          this.editor.setHintingShapes([]);
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            const {
              inputs: { originPagePoint }
            } = this.editor;
            const id = createShapeId();
            this.markId = `creating:${id}`;
            this.editor.mark(this.markId);
            const shape = this.createTextShape(id, originPagePoint, false);
            if (!shape) {
              this.cancel();
              return;
            }
            this.shape = this.editor.getShape(shape);
            this.editor.select(id);
            this.editor.setCurrentTool("select.resizing", {
              ...info2,
              target: "selection",
              handle: "right",
              isCreating: true,
              creationCursorOffset: { x: 18, y: 1 },
              onInteractionEnd: "text",
              onCreate: () => {
                this.editor.setEditingShape(shape.id);
                this.editor.setCurrentTool("select.editing_shape");
              }
            });
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      complete() {
        this.editor.mark("creating text shape");
        const id = createShapeId();
        const { currentPagePoint } = this.editor.inputs;
        const shape = this.createTextShape(id, currentPagePoint, true);
        if (!shape)
          return;
        this.editor.select(id);
        this.editor.setEditingShape(id);
        this.editor.setCurrentTool("select");
        this.editor.root.getCurrent()?.transition("editing_shape");
      }
      cancel() {
        this.parent.transition("idle");
        this.editor.bailToMark(this.markId);
      }
      createTextShape(id, point, autoSize) {
        this.editor.createShape({
          id,
          type: "text",
          x: point.x,
          y: point.y,
          props: {
            text: "",
            autoSize,
            w: 20,
            scale: this.editor.user.getIsDynamicResizeMode() ? 1 / this.editor.getZoomLevel() : 1
          }
        });
        const shape = this.editor.getShape(id);
        if (!shape) {
          this.cancel();
          return;
        }
        const bounds = this.editor.getShapePageBounds(shape);
        const delta = new Vec();
        if (autoSize) {
          switch (shape.props.textAlign) {
            case "start": {
              delta.x = 0;
              break;
            }
            case "middle": {
              delta.x = -bounds.width / 2;
              break;
            }
            case "end": {
              delta.x = -bounds.width;
              break;
            }
          }
        } else {
          delta.x = 0;
        }
        delta.y = -bounds.height / 2;
        if (isShapeId(shape.parentId)) {
          const transform = this.editor.getShapeParentTransform(shape);
          delta.rot(-transform.rotation());
        }
        this.editor.updateShape({
          ...shape,
          x: shape.x + delta.x,
          y: shape.y + delta.y
        });
        return shape;
      }
    };
    __publicField(Pointing6, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/text/TextShapeTool.mjs
var TextShapeTool;
var init_TextShapeTool = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/text/TextShapeTool.mjs"() {
    init_dist_esm10();
    init_Idle7();
    init_Pointing6();
    TextShapeTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeType", "text");
      }
    };
    __publicField(TextShapeTool, "id", "text");
    __publicField(TextShapeTool, "initial", "idle");
    __publicField(TextShapeTool, "children", () => [Idle7, Pointing6]);
    __publicField(TextShapeTool, "isLockable", false);
  }
});

// node_modules/tldraw/dist-esm/lib/defaultShapeTools.mjs
var defaultShapeTools;
var init_defaultShapeTools = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultShapeTools.mjs"() {
    init_ArrowShapeTool();
    init_DrawShapeTool();
    init_FrameShapeTool();
    init_GeoShapeTool();
    init_HighlightShapeTool();
    init_LineShapeTool();
    init_NoteShapeTool();
    init_TextShapeTool();
    defaultShapeTools = [
      TextShapeTool,
      DrawShapeTool,
      GeoShapeTool,
      NoteShapeTool,
      LineShapeTool,
      FrameShapeTool,
      ArrowShapeTool,
      HighlightShapeTool
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/useDefaultColorTheme.mjs
function useDefaultColorTheme() {
  return getDefaultColorTheme({ isDarkMode: useIsDarkMode() });
}
var init_useDefaultColorTheme = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/useDefaultColorTheme.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/defaultStyleDefs.mjs
function getFontDefForExport(fontStyle) {
  return {
    key: `${DefaultFontStyle.id}:${fontStyle}`,
    getElement: async () => {
      const font = findFont(fontStyle);
      if (!font)
        return null;
      const url = font.$$_url;
      const fontFaceRule = font.$$_fontface;
      if (!url || !fontFaceRule)
        return null;
      const fontFile = await (await fetch2(url)).blob();
      const base64FontFile = await FileHelpers.blobToDataUrl(fontFile);
      const newFontFaceRule = fontFaceRule.replace(url, base64FontFile);
      return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("style", { children: newFontFaceRule });
    }
  };
}
function findFont(name) {
  const fontFamily = DefaultFontFamilies[name];
  for (const font of document.fonts) {
    if (fontFamily.includes(font.family)) {
      return font;
    }
  }
  return null;
}
function getFillDefForExport(fill) {
  return {
    key: `${DefaultFontStyle.id}:${fill}`,
    getElement: async () => {
      if (fill !== "pattern")
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(HashPatternForExport, {});
    }
  };
}
function HashPatternForExport() {
  const theme = useDefaultColorTheme();
  const t3 = 8 / 12;
  return /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(import_jsx_runtime41.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)("mask", { id: "hash_pattern_mask", children: [
      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("rect", { x: "0", y: "0", width: "8", height: "8", fill: "white" }),
      /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)("g", { strokeLinecap: "round", stroke: "black", children: [
        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("line", { x1: t3 * 1, y1: t3 * 3, x2: t3 * 3, y2: t3 * 1 }),
        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("line", { x1: t3 * 5, y1: t3 * 7, x2: t3 * 7, y2: t3 * 5 }),
        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("line", { x1: t3 * 9, y1: t3 * 11, x2: t3 * 11, y2: t3 * 9 })
      ] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("pattern", {
      id: getHashPatternZoomName(1, theme.id),
      width: "8",
      height: "8",
      patternUnits: "userSpaceOnUse",
      children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("rect", { x: "0", y: "0", width: "8", height: "8", fill: theme.solid, mask: "url(#hash_pattern_mask)" })
    })
  ] });
}
function getFillDefForCanvas() {
  return {
    key: `${DefaultFontStyle.id}:pattern`,
    component: PatternFillDefForCanvas
  };
}
function getDefaultPixels() {
  if (!defaultPixels) {
    defaultPixels = {
      white: canvasBlob([1, 1], (ctx) => {
        ctx.fillStyle = "#f8f9fa";
        ctx.fillRect(0, 0, 1, 1);
      }),
      black: canvasBlob([1, 1], (ctx) => {
        ctx.fillStyle = "#212529";
        ctx.fillRect(0, 0, 1, 1);
      })
    };
  }
  return defaultPixels;
}
function getPatternLodForZoomLevel(zoom) {
  return Math.ceil(Math.log2(Math.max(1, zoom)));
}
function getHashPatternZoomName(zoom, theme) {
  const lod = getPatternLodForZoomLevel(zoom);
  return `tldraw_hash_pattern_${theme}_${lod}`;
}
function getPatternLodsToGenerate(maxZoom) {
  const levels = [];
  const minLod = 0;
  const maxLod = getPatternLodForZoomLevel(maxZoom);
  for (let i2 = minLod; i2 <= maxLod; i2++) {
    levels.push(Math.pow(2, i2));
  }
  return levels;
}
function getDefaultPatterns(maxZoom) {
  const defaultPixels2 = getDefaultPixels();
  return getPatternLodsToGenerate(maxZoom).flatMap((zoom) => [
    { zoom, url: defaultPixels2.white, theme: "light" },
    { zoom, url: defaultPixels2.black, theme: "dark" }
  ]);
}
function usePattern() {
  const editor = useEditor();
  const dpr = useValue("devicePixelRatio", () => editor.getInstanceState().devicePixelRatio, [
    editor
  ]);
  const maxZoom = useValue("maxZoom", () => Math.ceil(last(editor.getCameraOptions().zoomSteps)), [
    editor
  ]);
  const [isReady, setIsReady] = (0, import_react47.useState)(false);
  const [backgroundUrls, setBackgroundUrls] = (0, import_react47.useState)(() => getDefaultPatterns(maxZoom));
  (0, import_react47.useEffect)(() => {
    if (false) {
      setIsReady(true);
      return;
    }
    const promise = Promise.all(getPatternLodsToGenerate(maxZoom).flatMap((zoom) => [
      generateImage(dpr, zoom, false).then((blob) => ({
        zoom,
        theme: "light",
        url: URL.createObjectURL(blob)
      })),
      generateImage(dpr, zoom, true).then((blob) => ({
        zoom,
        theme: "dark",
        url: URL.createObjectURL(blob)
      }))
    ]));
    let isCancelled = false;
    promise.then((urls) => {
      if (isCancelled)
        return;
      setBackgroundUrls(urls);
      setIsReady(true);
    });
    return () => {
      isCancelled = true;
      setIsReady(false);
      promise.then((patterns) => {
        for (const { url } of patterns) {
          URL.revokeObjectURL(url);
        }
      });
    };
  }, [dpr, maxZoom]);
  const defs = /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_jsx_runtime41.Fragment, { children: backgroundUrls.map((item) => {
    const id = getHashPatternZoomName(item.zoom, item.theme);
    return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("pattern", {
      id,
      width: TILE_PATTERN_SIZE,
      height: TILE_PATTERN_SIZE,
      patternUnits: "userSpaceOnUse",
      children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("image", { href: item.url, width: TILE_PATTERN_SIZE, height: TILE_PATTERN_SIZE })
    }, id);
  }) });
  return { defs, isReady };
}
function PatternFillDefForCanvas() {
  const editor = useEditor();
  const containerRef = (0, import_react47.useRef)(null);
  const { defs, isReady } = usePattern();
  (0, import_react47.useEffect)(() => {
    if (isReady && editor.environment.isSafari) {
      const htmlLayer = findHtmlLayerParent(containerRef.current);
      if (htmlLayer) {
        editor.timers.requestAnimationFrame(() => {
          htmlLayer.style.display = "none";
          editor.timers.requestAnimationFrame(() => {
            htmlLayer.style.display = "";
          });
        });
      }
    }
  }, [editor, isReady]);
  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("g", { ref: containerRef, "data-testid": isReady ? "ready-pattern-fill-defs" : void 0, children: defs });
}
function findHtmlLayerParent(element) {
  if (element.classList.contains("tl-html-layer"))
    return element;
  if (element.parentElement)
    return findHtmlLayerParent(element.parentElement);
  return null;
}
var import_jsx_runtime41, import_react47, TILE_PATTERN_SIZE, generateImage, canvasBlob, defaultPixels;
var init_defaultStyleDefs = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/defaultStyleDefs.mjs"() {
    import_jsx_runtime41 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react47 = __toESM(require_react(), 1);
    init_useDefaultColorTheme();
    TILE_PATTERN_SIZE = 8;
    generateImage = (dpr, currentZoom, darkMode) => {
      return new Promise((resolve, reject) => {
        const size4 = TILE_PATTERN_SIZE * currentZoom * dpr;
        const canvasEl = document.createElement("canvas");
        canvasEl.width = size4;
        canvasEl.height = size4;
        const ctx = canvasEl.getContext("2d");
        if (!ctx)
          return;
        ctx.fillStyle = darkMode ? DefaultColorThemePalette.darkMode.solid : DefaultColorThemePalette.lightMode.solid;
        ctx.fillRect(0, 0, size4, size4);
        ctx.globalCompositeOperation = "destination-out";
        ctx.lineCap = "round";
        ctx.lineWidth = 1.25 * currentZoom * dpr;
        const t3 = 8 / 12;
        const s2 = (v2) => v2 * currentZoom * dpr;
        ctx.beginPath();
        ctx.moveTo(s2(t3 * 1), s2(t3 * 3));
        ctx.lineTo(s2(t3 * 3), s2(t3 * 1));
        ctx.moveTo(s2(t3 * 5), s2(t3 * 7));
        ctx.lineTo(s2(t3 * 7), s2(t3 * 5));
        ctx.moveTo(s2(t3 * 9), s2(t3 * 11));
        ctx.lineTo(s2(t3 * 11), s2(t3 * 9));
        ctx.stroke();
        canvasEl.toBlob((blob) => {
          if (!blob || debugFlags.throwToBlob.get()) {
            reject();
          } else {
            resolve(blob);
          }
        });
      });
    };
    canvasBlob = (size4, fn3) => {
      const canvas = document.createElement("canvas");
      canvas.width = size4[0];
      canvas.height = size4[1];
      const ctx = canvas.getContext("2d");
      if (!ctx)
        return "";
      fn3(ctx);
      return canvas.toDataURL();
    };
    defaultPixels = null;
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/ShapeFill.mjs
function PatternFill({ d: d2, color, theme }) {
  const editor = useEditor();
  const svgExport = useSvgExportContext();
  const zoomLevel = useValue("zoomLevel", () => editor.getZoomLevel(), [editor]);
  const teenyTiny = editor.getZoomLevel() <= 0.18;
  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)(import_jsx_runtime42.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("path", { fill: theme[color].pattern, d: d2 }),
    /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("path", {
      fill: svgExport ? `url(#${getHashPatternZoomName(1, theme.id)})` : teenyTiny ? theme[color].semi : `url(#${getHashPatternZoomName(zoomLevel, theme.id)})`,
      d: d2
    })
  ] });
}
var import_jsx_runtime42, import_react48, ShapeFill;
var init_ShapeFill = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/ShapeFill.mjs"() {
    import_jsx_runtime42 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react48 = __toESM(require_react(), 1);
    init_defaultStyleDefs();
    ShapeFill = import_react48.default.memo(function ShapeFill2({
      theme,
      d: d2,
      color,
      fill,
      scale
    }) {
      switch (fill) {
        case "none": {
          return null;
        }
        case "solid": {
          return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("path", { fill: theme[color].semi, d: d2 });
        }
        case "semi": {
          return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("path", { fill: theme.solid, d: d2 });
        }
        case "fill": {
          return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("path", { fill: theme[color].fill, d: d2 });
        }
        case "pattern": {
          return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(PatternFill, { theme, color, fill, d: d2, scale });
        }
      }
    });
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/createTextJsxFromSpans.mjs
function correctSpacesToNbsp(input) {
  return input.replace(/\s/g, "\xA0");
}
function createTextJsxFromSpans(editor, spans, opts) {
  const { padding = 0 } = opts;
  if (spans.length === 0)
    return null;
  const bounds = Box.From(spans[0].box);
  for (const { box } of spans) {
    bounds.union(box);
  }
  const offsetX = padding + (opts.offsetX ?? 0);
  const offsetY = (opts.offsetY ?? 0) + opts.fontSize / 2 + (opts.verticalTextAlign === "start" ? padding : opts.verticalTextAlign === "end" ? opts.height - padding - bounds.height : (Math.ceil(opts.height) - bounds.height) / 2);
  let currentLineTop = null;
  const children = [];
  for (const { text, box } of spans) {
    const didBreakLine = currentLineTop !== null && box.y > currentLineTop;
    if (didBreakLine) {
      children.push(/* @__PURE__ */ (0, import_jsx_runtime43.jsx)("tspan", {
        alignmentBaseline: "mathematical",
        x: offsetX,
        y: box.y + offsetY,
        children: "\n"
      }, children.length));
    }
    children.push(/* @__PURE__ */ (0, import_jsx_runtime43.jsx)("tspan", {
      alignmentBaseline: "mathematical",
      x: box.x + offsetX,
      y: box.y + offsetY,
      unicodeBidi: "plaintext",
      children: correctSpacesToNbsp(text)
    }, children.length));
    currentLineTop = box.y;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("text", {
    fontSize: opts.fontSize,
    fontFamily: opts.fontFamily,
    fontStyle: opts.fontStyle,
    fontWeight: opts.fontWeight,
    dominantBaseline: "mathematical",
    alignmentBaseline: "mathematical",
    stroke: opts.stroke,
    strokeWidth: opts.strokeWidth,
    fill: opts.fill,
    children
  });
}
var import_jsx_runtime43;
var init_createTextJsxFromSpans = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/createTextJsxFromSpans.mjs"() {
    import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/legacyProps.mjs
function getLegacyOffsetX(align, padding, spans, totalWidth) {
  if ((align === "start-legacy" || align === "end-legacy") && spans.length !== 0) {
    const spansBounds = Box.From(spans[0].box);
    for (const { box } of spans) {
      spansBounds.union(box);
    }
    if (align === "start-legacy") {
      return (totalWidth - 2 * padding - spansBounds.width) / 2;
    } else if (align === "end-legacy") {
      return -(totalWidth - 2 * padding - spansBounds.width) / 2;
    }
  }
}
function isLegacyAlign(align) {
  return align === "start-legacy" || align === "middle-legacy" || align === "end-legacy";
}
var init_legacyProps = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/legacyProps.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/SvgTextLabel.mjs
function SvgTextLabel({
  fontSize,
  font,
  align,
  verticalAlign,
  text,
  labelColor,
  bounds,
  padding = 16,
  stroke = true
}) {
  const editor = useEditor();
  const theme = useDefaultColorTheme();
  const opts = {
    fontSize,
    fontFamily: DefaultFontFamilies[font],
    textAlign: align,
    verticalTextAlign: verticalAlign,
    width: Math.ceil(bounds.width),
    height: Math.ceil(bounds.height),
    padding,
    lineHeight: TEXT_PROPS.lineHeight,
    fontStyle: "normal",
    fontWeight: "normal",
    overflow: "wrap",
    offsetX: 0,
    offsetY: 0,
    fill: labelColor,
    stroke: void 0,
    strokeWidth: void 0
  };
  const spans = editor.textMeasure.measureTextSpans(text, opts);
  const offsetX = getLegacyOffsetX(align, padding, spans, bounds.width);
  if (offsetX) {
    opts.offsetX = offsetX;
  }
  opts.offsetX += bounds.x;
  opts.offsetY += bounds.y;
  const mainSpans = createTextJsxFromSpans(editor, spans, opts);
  let outlineSpans = null;
  if (stroke) {
    opts.fill = theme.background;
    opts.stroke = theme.background;
    opts.strokeWidth = 2;
    outlineSpans = createTextJsxFromSpans(editor, spans, opts);
  }
  return /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(import_jsx_runtime44.Fragment, { children: [
    outlineSpans,
    mainSpans
  ] });
}
var import_jsx_runtime44;
var init_SvgTextLabel = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/SvgTextLabel.mjs"() {
    import_jsx_runtime44 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_createTextJsxFromSpans();
    init_default_shape_constants();
    init_legacyProps();
    init_useDefaultColorTheme();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/text/TextArea.mjs
var import_jsx_runtime45, import_react49, TextArea;
var init_TextArea = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/text/TextArea.mjs"() {
    import_jsx_runtime45 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react49 = __toESM(require_react(), 1);
    TextArea = (0, import_react49.forwardRef)(function TextArea2({
      isEditing,
      text,
      handleFocus,
      handleChange,
      handleKeyDown,
      handleBlur,
      handleInputPointerDown,
      handleDoubleClick
    }, ref) {
      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("textarea", {
        ref,
        className: "tl-text tl-text-input",
        name: "text",
        tabIndex: -1,
        readOnly: !isEditing,
        autoComplete: "off",
        autoCapitalize: "off",
        autoCorrect: "off",
        autoSave: "off",
        placeholder: "",
        spellCheck: "true",
        wrap: "off",
        dir: "auto",
        defaultValue: text,
        onFocus: handleFocus,
        onChange: handleChange,
        onKeyDown: handleKeyDown,
        onBlur: handleBlur,
        onTouchEnd: stopEventPropagation,
        onContextMenu: isEditing ? stopEventPropagation : void 0,
        onPointerDown: handleInputPointerDown,
        onDoubleClick: handleDoubleClick,
        onDragStart: preventDefault
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/useEditableText.mjs
function useEditableText(id, type, text) {
  const editor = useEditor();
  const rInput = (0, import_react50.useRef)(null);
  const isEditing = useValue("isEditing", () => editor.getEditingShapeId() === id, [editor]);
  const isEditingAnything = useValue("isEditingAnything", () => !!editor.getEditingShapeId(), [
    editor
  ]);
  (0, import_react50.useEffect)(() => {
    function selectAllIfEditing({ shapeId }) {
      if (shapeId === id) {
        rInput.current?.select();
      }
    }
    editor.on("select-all-text", selectAllIfEditing);
    return () => {
      editor.off("select-all-text", selectAllIfEditing);
    };
  }, [editor, id, isEditing]);
  (0, import_react50.useEffect)(() => {
    if (!isEditing)
      return;
    if (document.activeElement !== rInput.current) {
      rInput.current?.focus();
    }
    if (editor.getInstanceState().isCoarsePointer) {
      rInput.current?.select();
    }
    if (editor.environment.isSafari) {
      rInput.current?.blur();
      rInput.current?.focus();
    }
  }, [editor, isEditing]);
  const handleKeyDown = (0, import_react50.useCallback)((e2) => {
    if (editor.getEditingShapeId() !== id)
      return;
    switch (e2.key) {
      case "Enter": {
        if (e2.ctrlKey || e2.metaKey) {
          editor.complete();
        }
        break;
      }
    }
  }, [editor, id]);
  const handleChange = (0, import_react50.useCallback)((e2) => {
    if (editor.getEditingShapeId() !== id)
      return;
    let text2 = TextHelpers.normalizeText(e2.currentTarget.value);
    const untabbedText = text2.replace(/\t/g, INDENT);
    if (untabbedText !== text2) {
      const selectionStart = e2.currentTarget.selectionStart;
      e2.currentTarget.value = untabbedText;
      e2.currentTarget.selectionStart = selectionStart + (untabbedText.length - text2.length);
      e2.currentTarget.selectionEnd = selectionStart + (untabbedText.length - text2.length);
      text2 = untabbedText;
    }
    editor.updateShape({
      id,
      type,
      props: { text: text2 }
    });
  }, [editor, id, type]);
  const handleInputPointerDown = (0, import_react50.useCallback)((e2) => {
    editor.dispatch({
      ...getPointerInfo(e2),
      type: "pointer",
      name: "pointer_down",
      target: "shape",
      shape: editor.getShape(id)
    });
    stopEventPropagation(e2);
  }, [editor, id]);
  return {
    rInput,
    handleFocus: noop,
    handleBlur: noop,
    handleKeyDown,
    handleChange,
    handleInputPointerDown,
    handleDoubleClick: stopEventPropagation,
    isEmpty: text.trim().length === 0,
    isEditing,
    isEditingAnything
  };
}
var import_react50;
var init_useEditableText = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/useEditableText.mjs"() {
    init_dist_esm10();
    import_react50 = __toESM(require_react(), 1);
    init_TextHelpers();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/TextLabel.mjs
var import_jsx_runtime46, import_react51, TextLabel;
var init_TextLabel = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/TextLabel.mjs"() {
    import_jsx_runtime46 = __toESM(require_jsx_runtime(), 1);
    import_react51 = __toESM(require_react(), 1);
    init_TextArea();
    init_TextHelpers();
    init_legacyProps();
    init_useEditableText();
    TextLabel = import_react51.default.memo(function TextLabel2({
      id,
      type,
      text,
      labelColor,
      font,
      fontSize,
      lineHeight,
      align,
      verticalAlign,
      wrap: wrap2,
      isSelected,
      padding = 0,
      onKeyDown: handleKeyDownCustom,
      classNamePrefix,
      style,
      textWidth,
      textHeight
    }) {
      const { rInput, isEmpty, isEditing, isEditingAnything, ...editableTextRest } = useEditableText(id, type, text);
      const [initialText, setInitialText] = (0, import_react51.useState)(text);
      (0, import_react51.useEffect)(() => {
        if (!isEditing)
          setInitialText(text);
      }, [isEditing, text]);
      const finalText = TextHelpers.normalizeTextForDom(text);
      const hasText = finalText.length > 0;
      const legacyAlign = isLegacyAlign(align);
      if (!isEditing && !hasText) {
        return null;
      }
      const cssPrefix = classNamePrefix || "tl-text";
      return /* @__PURE__ */ (0, import_jsx_runtime46.jsx)("div", {
        className: `${cssPrefix}-label tl-text-wrapper`,
        "data-font": font,
        "data-align": align,
        "data-hastext": !isEmpty,
        "data-isediting": isEditing,
        "data-iseditinganything": isEditingAnything,
        "data-textwrap": !!wrap2,
        "data-isselected": isSelected,
        style: {
          justifyContent: align === "middle" || legacyAlign ? "center" : align,
          alignItems: verticalAlign === "middle" ? "center" : verticalAlign,
          padding,
          ...style
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime46.jsxs)("div", {
          className: `${cssPrefix}-label__inner tl-text-content__wrapper`,
          style: {
            fontSize,
            lineHeight: Math.floor(fontSize * lineHeight) + "px",
            minHeight: Math.floor(fontSize * lineHeight) + "px",
            minWidth: Math.ceil(textWidth || 0),
            color: labelColor,
            width: textWidth ? Math.ceil(textWidth) : void 0,
            height: textHeight ? Math.ceil(textHeight) : void 0
          },
          children: [
            /* @__PURE__ */ (0, import_jsx_runtime46.jsx)("div", { className: `${cssPrefix} tl-text tl-text-content`, dir: "auto", children: finalText.split("\n").map((lineOfText, index3) => /* @__PURE__ */ (0, import_jsx_runtime46.jsx)("div", { dir: "auto", children: lineOfText }, index3)) }),
            (isEditingAnything || isSelected) && /* @__PURE__ */ (0, import_jsx_runtime46.jsx)(TextArea, {
              ref: rInput,
              text,
              isEditing,
              ...editableTextRest,
              handleKeyDown: handleKeyDownCustom ?? editableTextRest.handleKeyDown
            }, initialText)
          ]
        })
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/getPerfectDashProps.mjs
function getPerfectDashProps2(totalLength, strokeWidth, opts = {}) {
  const {
    closed = false,
    snap = 1,
    start: start2 = "outset",
    end: end2 = "outset",
    lengthRatio = 2,
    style = "dashed"
  } = opts;
  let dashLength = 0;
  let dashCount = 0;
  let ratio = 1;
  let gapLength = 0;
  let strokeDashoffset = 0;
  switch (style) {
    case "dashed": {
      ratio = 1;
      dashLength = Math.min(strokeWidth * lengthRatio, totalLength / 4);
      break;
    }
    case "dotted": {
      ratio = 100;
      dashLength = strokeWidth / ratio;
      break;
    }
    default: {
      return {
        strokeDasharray: "none",
        strokeDashoffset: "none"
      };
    }
  }
  if (!closed) {
    if (start2 === "outset") {
      totalLength += dashLength / 2;
      strokeDashoffset += dashLength / 2;
    } else if (start2 === "skip") {
      totalLength -= dashLength;
      strokeDashoffset -= dashLength;
    }
    if (end2 === "outset") {
      totalLength += dashLength / 2;
    } else if (end2 === "skip") {
      totalLength -= dashLength;
    }
  }
  dashCount = Math.floor(totalLength / dashLength / (2 * ratio));
  dashCount -= dashCount % snap;
  if (dashCount < 3 && style === "dashed") {
    if (totalLength / strokeWidth < 4) {
      dashLength = totalLength;
      dashCount = 1;
      gapLength = 0;
    } else {
      dashLength = totalLength * (1 / 3);
      gapLength = totalLength * (1 / 3);
    }
  } else {
    dashLength = totalLength / dashCount / (2 * ratio);
    if (closed) {
      strokeDashoffset = dashLength / 2;
      gapLength = (totalLength - dashCount * dashLength) / dashCount;
    } else {
      gapLength = (totalLength - dashCount * dashLength) / Math.max(1, dashCount - 1);
    }
  }
  return {
    strokeDasharray: [dashLength, gapLength].join(" "),
    strokeDashoffset: strokeDashoffset.toString()
  };
}
var init_getPerfectDashProps2 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/getPerfectDashProps.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowLabel.mjs
function getArrowLabelSize(editor, shape) {
  const cachedSize = labelSizeCache.get(shape);
  if (cachedSize)
    return cachedSize;
  const info2 = getArrowInfo(editor, shape);
  let width = 0;
  let height = 0;
  const bodyGeom = info2.isStraight ? new Edge2d({
    start: Vec.From(info2.start.point),
    end: Vec.From(info2.end.point)
  }) : new Arc2d({
    center: Vec.Cast(info2.handleArc.center),
    start: Vec.Cast(info2.start.point),
    end: Vec.Cast(info2.end.point),
    sweepFlag: info2.bodyArc.sweepFlag,
    largeArcFlag: info2.bodyArc.largeArcFlag
  });
  if (shape.props.text.trim()) {
    const bodyBounds = bodyGeom.bounds;
    const fontSize = getArrowLabelFontSize(shape);
    const { w: w2, h: h2 } = editor.textMeasure.measureText(shape.props.text, {
      ...TEXT_PROPS,
      fontFamily: FONT_FAMILIES[shape.props.font],
      fontSize,
      maxWidth: null
    });
    width = w2;
    height = h2;
    if (bodyBounds.width > bodyBounds.height) {
      width = Math.max(Math.min(w2, 64), Math.min(bodyBounds.width - 64, w2));
      const { w: squishedWidth, h: squishedHeight } = editor.textMeasure.measureText(shape.props.text, {
        ...TEXT_PROPS,
        fontFamily: FONT_FAMILIES[shape.props.font],
        fontSize,
        maxWidth: width
      });
      width = squishedWidth;
      height = squishedHeight;
    }
    if (width > 16 * fontSize) {
      width = 16 * fontSize;
      const { w: squishedWidth, h: squishedHeight } = editor.textMeasure.measureText(shape.props.text, {
        ...TEXT_PROPS,
        fontFamily: FONT_FAMILIES[shape.props.font],
        fontSize,
        maxWidth: width
      });
      width = squishedWidth;
      height = squishedHeight;
    }
  }
  const size4 = new Vec(width, height).addScalar(ARROW_LABEL_PADDING * 2 * shape.props.scale);
  labelSizeCache.set(shape, size4);
  return size4;
}
function getLabelToArrowPadding(shape) {
  const strokeWidth = STROKE_SIZES2[shape.props.size];
  const labelToArrowPadding = (LABEL_TO_ARROW_PADDING + (strokeWidth - STROKE_SIZES2.s) * 2 + (strokeWidth === STROKE_SIZES2.xl ? 20 : 0)) * shape.props.scale;
  return labelToArrowPadding;
}
function getStraightArrowLabelRange(editor, shape, info2) {
  const labelSize = getArrowLabelSize(editor, shape);
  const labelToArrowPadding = getLabelToArrowPadding(shape);
  const startOffset = Vec.Nudge(info2.start.point, info2.end.point, labelToArrowPadding);
  const endOffset = Vec.Nudge(info2.end.point, info2.start.point, labelToArrowPadding);
  const intersectionPoints = intersectLineSegmentPolygon(startOffset, endOffset, Box.FromCenter(info2.middle, labelSize).corners);
  if (!intersectionPoints || intersectionPoints.length !== 2) {
    return { start: 0.5, end: 0.5 };
  }
  let [startIntersect, endIntersect] = intersectionPoints;
  if (Vec.Dist2(startIntersect, startOffset) > Vec.Dist2(endIntersect, startOffset)) {
    ;
    [endIntersect, startIntersect] = intersectionPoints;
  }
  const startConstrained = startOffset.add(Vec.Sub(info2.middle, startIntersect));
  const endConstrained = endOffset.add(Vec.Sub(info2.middle, endIntersect));
  const start2 = Vec.Dist(info2.start.point, startConstrained) / info2.length;
  const end2 = Vec.Dist(info2.start.point, endConstrained) / info2.length;
  return { start: start2, end: end2 };
}
function getCurvedArrowLabelRange(editor, shape, info2) {
  const labelSize = getArrowLabelSize(editor, shape);
  const labelToArrowPadding = getLabelToArrowPadding(shape);
  const direction = Math.sign(shape.props.bend);
  const labelToArrowPaddingRad = labelToArrowPadding / info2.handleArc.radius * direction;
  const startOffsetAngle = Vec.Angle(info2.bodyArc.center, info2.start.point) - labelToArrowPaddingRad;
  const endOffsetAngle = Vec.Angle(info2.bodyArc.center, info2.end.point) + labelToArrowPaddingRad;
  const startOffset = getPointOnCircle(info2.bodyArc.center, info2.bodyArc.radius, startOffsetAngle);
  const endOffset = getPointOnCircle(info2.bodyArc.center, info2.bodyArc.radius, endOffsetAngle);
  const dbg = [];
  const startIntersections = intersectArcPolygon(info2.bodyArc.center, info2.bodyArc.radius, startOffsetAngle, endOffsetAngle, direction, Box.FromCenter(startOffset, labelSize).corners);
  dbg.push(new Polygon2d({
    points: Box.FromCenter(startOffset, labelSize).corners,
    debugColor: "lime",
    isFilled: false,
    ignore: true
  }));
  const endIntersections = intersectArcPolygon(info2.bodyArc.center, info2.bodyArc.radius, startOffsetAngle, endOffsetAngle, direction, Box.FromCenter(endOffset, labelSize).corners);
  dbg.push(new Polygon2d({
    points: Box.FromCenter(endOffset, labelSize).corners,
    debugColor: "lime",
    isFilled: false,
    ignore: true
  }));
  for (const pt of [
    ...startIntersections ?? [],
    ...endIntersections ?? [],
    startOffset,
    endOffset
  ]) {
    dbg.push(new Circle2d({
      x: pt.x - 3,
      y: pt.y - 3,
      radius: 3,
      isFilled: false,
      debugColor: "magenta",
      ignore: true
    }));
  }
  const startConstrained = (startIntersections && furthest(info2.start.point, startIntersections)) ?? info2.middle;
  const endConstrained = (endIntersections && furthest(info2.end.point, endIntersections)) ?? info2.middle;
  const startAngle = Vec.Angle(info2.bodyArc.center, info2.start.point);
  const endAngle = Vec.Angle(info2.bodyArc.center, info2.end.point);
  const constrainedStartAngle = Vec.Angle(info2.bodyArc.center, startConstrained);
  const constrainedEndAngle = Vec.Angle(info2.bodyArc.center, endConstrained);
  if (angleDistance(startAngle, constrainedStartAngle, direction) > angleDistance(startAngle, constrainedEndAngle, direction)) {
    return { start: 0.5, end: 0.5, dbg };
  }
  const fullDistance = angleDistance(startAngle, endAngle, direction);
  const start2 = angleDistance(startAngle, constrainedStartAngle, direction) / fullDistance;
  const end2 = angleDistance(startAngle, constrainedEndAngle, direction) / fullDistance;
  return { start: start2, end: end2, dbg };
}
function getArrowLabelPosition(editor, shape) {
  let labelCenter;
  const debugGeom = [];
  const info2 = getArrowInfo(editor, shape);
  const hasStartBinding = !!info2.bindings.start;
  const hasEndBinding = !!info2.bindings.end;
  const hasStartArrowhead = info2.start.arrowhead !== "none";
  const hasEndArrowhead = info2.end.arrowhead !== "none";
  if (info2.isStraight) {
    const range = getStraightArrowLabelRange(editor, shape, info2);
    let clampedPosition = clamp(shape.props.labelPosition, hasStartArrowhead || hasStartBinding ? range.start : 0, hasEndArrowhead || hasEndBinding ? range.end : 1);
    clampedPosition = clampedPosition >= 0.48 && clampedPosition <= 0.52 ? 0.5 : clampedPosition;
    labelCenter = Vec.Lrp(info2.start.point, info2.end.point, clampedPosition);
  } else {
    const range = getCurvedArrowLabelRange(editor, shape, info2);
    if (range.dbg)
      debugGeom.push(...range.dbg);
    let clampedPosition = clamp(shape.props.labelPosition, hasStartArrowhead || hasStartBinding ? range.start : 0, hasEndArrowhead || hasEndBinding ? range.end : 1);
    clampedPosition = clampedPosition >= 0.48 && clampedPosition <= 0.52 ? 0.5 : clampedPosition;
    const labelAngle = interpolateArcAngles(Vec.Angle(info2.bodyArc.center, info2.start.point), Vec.Angle(info2.bodyArc.center, info2.end.point), Math.sign(shape.props.bend), clampedPosition);
    labelCenter = getPointOnCircle(info2.bodyArc.center, info2.bodyArc.radius, labelAngle);
  }
  const labelSize = getArrowLabelSize(editor, shape);
  return { box: Box.FromCenter(labelCenter, labelSize), debugGeom };
}
function intersectArcPolygon(center, radius, angleStart, angleEnd, direction, polygon) {
  const intersections = intersectCirclePolygon(center, radius, polygon);
  const fullArcDistance = angleDistance(angleStart, angleEnd, direction);
  return intersections?.filter((pt) => {
    const pDistance = angleDistance(angleStart, Vec.Angle(center, pt), direction);
    return pDistance >= 0 && pDistance <= fullArcDistance;
  });
}
function furthest(from, candidates) {
  let furthest2 = null;
  let furthestDist = -Infinity;
  for (const candidate of candidates) {
    const dist = Vec.Dist2(from, candidate);
    if (dist > furthestDist) {
      furthest2 = candidate;
      furthestDist = dist;
    }
  }
  return furthest2;
}
function interpolateArcAngles(angleStart, angleEnd, direction, t3) {
  const dist = angleDistance(angleStart, angleEnd, direction);
  return angleStart + dist * t3 * direction * -1;
}
function getArrowLabelFontSize(shape) {
  return ARROW_LABEL_FONT_SIZES[shape.props.size] * shape.props.scale;
}
var labelSizeCache;
var init_arrowLabel = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowLabel.mjs"() {
    init_dist_esm10();
    init_default_shape_constants();
    init_shared();
    labelSizeCache = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowheads.mjs
function getArrowPoints(info2, side, strokeWidth) {
  const PT = side === "end" ? info2.end.point : info2.start.point;
  const PB = side === "end" ? info2.start.point : info2.end.point;
  const compareLength = info2.isStraight ? Vec.Dist(PB, PT) : Math.abs(info2.bodyArc.length);
  const length = Math.max(Math.min(compareLength / 5, strokeWidth * 3), strokeWidth);
  let P0;
  if (info2.isStraight) {
    P0 = Vec.Nudge(PT, PB, length);
  } else {
    const ints = intersectCircleCircle(PT, length, info2.handleArc.center, info2.handleArc.radius);
    P0 = side === "end" ? info2.handleArc.sweepFlag ? ints[0] : ints[1] : info2.handleArc.sweepFlag ? ints[1] : ints[0];
  }
  if (Vec.IsNaN(P0)) {
    P0 = info2.start.point;
  }
  return {
    point: PT,
    int: P0
  };
}
function getArrowhead({ point, int }) {
  const PL = Vec.RotWith(int, point, PI / 6);
  const PR = Vec.RotWith(int, point, -PI / 6);
  return `M ${PL.x} ${PL.y} L ${point.x} ${point.y} L ${PR.x} ${PR.y}`;
}
function getTriangleHead({ point, int }) {
  const PL = Vec.RotWith(int, point, PI / 6);
  const PR = Vec.RotWith(int, point, -PI / 6);
  return `M ${PL.x} ${PL.y} L ${point.x} ${point.y} L ${PR.x} ${PR.y} Z`;
}
function getInvertedTriangleHead({ point, int }) {
  const d2 = Vec.Sub(int, point).div(2);
  const PL = Vec.Add(point, Vec.Rot(d2, HALF_PI));
  const PR = Vec.Sub(point, Vec.Rot(d2, HALF_PI));
  return `M ${PL.x} ${PL.y} L ${int.x} ${int.y} L ${PR.x} ${PR.y} Z`;
}
function getDotHead({ point, int }) {
  const A2 = Vec.Lrp(point, int, 0.45);
  const r2 = Vec.Dist(A2, point);
  return `M ${A2.x - r2},${A2.y}
  a ${r2},${r2} 0 1,0 ${r2 * 2},0
  a ${r2},${r2} 0 1,0 -${r2 * 2},0 `;
}
function getDiamondHead({ point, int }) {
  const PB = Vec.Lrp(point, int, 0.75);
  const PL = Vec.RotWith(PB, point, PI / 4);
  const PR = Vec.RotWith(PB, point, -PI / 4);
  const PQ = Vec.Lrp(PL, PR, 0.5);
  PQ.add(Vec.Sub(PQ, point));
  return `M ${PQ.x} ${PQ.y} L ${PL.x} ${PL.y} ${point.x} ${point.y} L ${PR.x} ${PR.y} Z`;
}
function getSquareHead({ int, point }) {
  const PB = Vec.Lrp(point, int, 0.85);
  const d2 = Vec.Sub(PB, point).div(2);
  const PL1 = Vec.Add(point, Vec.Rot(d2, HALF_PI));
  const PR1 = Vec.Sub(point, Vec.Rot(d2, HALF_PI));
  const PL2 = Vec.Add(PB, Vec.Rot(d2, HALF_PI));
  const PR2 = Vec.Sub(PB, Vec.Rot(d2, HALF_PI));
  return `M ${PL1.x} ${PL1.y} L ${PL2.x} ${PL2.y} L ${PR2.x} ${PR2.y} L ${PR1.x} ${PR1.y} Z`;
}
function getBarHead({ int, point }) {
  const d2 = Vec.Sub(int, point).div(2);
  const PL = Vec.Add(point, Vec.Rot(d2, HALF_PI));
  const PR = Vec.Sub(point, Vec.Rot(d2, HALF_PI));
  return `M ${PL.x} ${PL.y} L ${PR.x} ${PR.y}`;
}
function getArrowheadPathForType(info2, side, strokeWidth) {
  const type = side === "end" ? info2.end.arrowhead : info2.start.arrowhead;
  if (type === "none")
    return;
  const points = getArrowPoints(info2, side, strokeWidth);
  if (!points)
    return;
  switch (type) {
    case "bar":
      return getBarHead(points);
    case "square":
      return getSquareHead(points);
    case "diamond":
      return getDiamondHead(points);
    case "dot":
      return getDotHead(points);
    case "inverted":
      return getInvertedTriangleHead(points);
    case "arrow":
      return getArrowhead(points);
    case "triangle":
      return getTriangleHead(points);
  }
  return "";
}
var init_arrowheads = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowheads.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowpaths.mjs
function getCurvedArrowHandlePath(info2) {
  const {
    start: start2,
    end: end2,
    handleArc: { radius, largeArcFlag, sweepFlag }
  } = info2;
  return `M${start2.handle.x},${start2.handle.y} A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end2.handle.x},${end2.handle.y}`;
}
function getSolidCurvedArrowPath(info2) {
  const {
    start: start2,
    end: end2,
    bodyArc: { radius, largeArcFlag, sweepFlag }
  } = info2;
  return `M${start2.point.x},${start2.point.y} A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end2.point.x},${end2.point.y}`;
}
function getArrowPath(start2, end2) {
  return `M${start2.x},${start2.y}L${end2.x},${end2.y}`;
}
function getStraightArrowHandlePath(info2) {
  return getArrowPath(info2.start.handle, info2.end.handle);
}
function getSolidStraightArrowPath(info2) {
  return getArrowPath(info2.start.point, info2.end.point);
}
var init_arrowpaths = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/arrowpaths.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/arrow/ArrowShapeUtil.mjs
function getLength(editor, shape) {
  const info2 = getArrowInfo(editor, shape);
  return info2.isStraight ? Vec.Dist(info2.start.handle, info2.end.handle) : Math.abs(info2.handleArc.length);
}
function ArrowheadDotDef() {
  return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("marker", { id: "arrowhead-dot", className: "tl-arrow-hint", refX: "3.0", refY: "3.0", orient: "0", children: /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("circle", { cx: "3", cy: "3", r: "2", strokeDasharray: "100%" }) });
}
function ArrowheadCrossDef() {
  return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("marker", { id: "arrowhead-cross", className: "tl-arrow-hint", refX: "3.0", refY: "3.0", orient: "auto", children: [
    /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("line", { x1: "1.5", y1: "1.5", x2: "4.5", y2: "4.5", strokeDasharray: "100%" }),
    /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("line", { x1: "1.5", y1: "4.5", x2: "4.5", y2: "1.5", strokeDasharray: "100%" })
  ] });
}
var import_jsx_runtime47, import_react52, globalRenderIndex, ArrowShapeUtil, ArrowSvg, shapeAtTranslationStart;
var init_ArrowShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/arrow/ArrowShapeUtil.mjs"() {
    import_jsx_runtime47 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react52 = __toESM(require_react(), 1);
    init_ArrowBindingUtil();
    init_ShapeFill();
    init_SvgTextLabel();
    init_TextLabel();
    init_default_shape_constants();
    init_defaultStyleDefs();
    init_getPerfectDashProps2();
    init_useDefaultColorTheme();
    init_arrowLabel();
    init_arrowheads();
    init_arrowpaths();
    init_shared();
    globalRenderIndex = 0;
    ArrowShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "canSnap", () => false);
        __publicField(this, "hideResizeHandles", () => true);
        __publicField(this, "hideRotateHandle", () => true);
        __publicField(this, "hideSelectionBoundsBg", () => true);
        __publicField(this, "hideSelectionBoundsFg", () => true);
        __publicField(this, "canBeLaidOut", (shape) => {
          const bindings = getArrowBindings(this.editor, shape);
          return !bindings.start && !bindings.end;
        });
        __publicField(this, "onHandleDrag", (shape, { handle, isPrecise }) => {
          const handleId = handle.id;
          const bindings = getArrowBindings(this.editor, shape);
          if (handleId === "middle") {
            const { start: start2, end: end2 } = getArrowTerminalsInArrowSpace(this.editor, shape, bindings);
            const delta = Vec.Sub(end2, start2);
            const v2 = Vec.Per(delta);
            const med = Vec.Med(end2, start2);
            const A2 = Vec.Sub(med, v2);
            const B = Vec.Add(med, v2);
            const point2 = Vec.NearestPointOnLineSegment(A2, B, handle, false);
            let bend = Vec.Dist(point2, med);
            if (Vec.Clockwise(point2, end2, med))
              bend *= -1;
            return { id: shape.id, type: shape.type, props: { bend } };
          }
          const update = { id: shape.id, type: "arrow", props: {} };
          const currentBinding = bindings[handleId];
          const otherHandleId = handleId === "start" ? "end" : "start";
          const otherBinding = bindings[otherHandleId];
          if (this.editor.inputs.ctrlKey) {
            removeArrowBinding(this.editor, shape, handleId);
            update.props[handleId] = {
              x: handle.x,
              y: handle.y
            };
            return update;
          }
          const point = this.editor.getShapePageTransform(shape.id).applyToPoint(handle);
          const target = this.editor.getShapeAtPoint(point, {
            hitInside: true,
            hitFrameInside: true,
            margin: 0,
            filter: (targetShape) => {
              return !targetShape.isLocked && this.editor.canBindShapes({ fromShape: shape, toShape: targetShape, binding: "arrow" });
            }
          });
          if (!target) {
            removeArrowBinding(this.editor, shape, handleId);
            update.props[handleId] = {
              x: handle.x,
              y: handle.y
            };
            return update;
          }
          const targetGeometry = this.editor.getShapeGeometry(target);
          const targetBounds = Box.ZeroFix(targetGeometry.bounds);
          const pageTransform = this.editor.getShapePageTransform(update.id);
          const pointInPageSpace = pageTransform.applyToPoint(handle);
          const pointInTargetSpace = this.editor.getPointInShapeSpace(target, pointInPageSpace);
          let precise2 = isPrecise;
          if (!precise2) {
            if (!currentBinding || currentBinding && target.id !== currentBinding.toId) {
              precise2 = this.editor.inputs.pointerVelocity.len() < 0.5;
            }
          }
          if (!isPrecise) {
            if (!targetGeometry.isClosed) {
              precise2 = true;
            }
            if (otherBinding && target.id === otherBinding.toId && otherBinding.props.isPrecise) {
              precise2 = true;
            }
          }
          const normalizedAnchor = {
            x: (pointInTargetSpace.x - targetBounds.minX) / targetBounds.width,
            y: (pointInTargetSpace.y - targetBounds.minY) / targetBounds.height
          };
          if (precise2) {
            if (Vec.Dist(pointInTargetSpace, targetBounds.center) < Math.max(4, Math.min(Math.min(targetBounds.width, targetBounds.height) * 0.15, 16)) / this.editor.getZoomLevel()) {
              normalizedAnchor.x = 0.5;
              normalizedAnchor.y = 0.5;
            }
          }
          const b2 = {
            terminal: handleId,
            normalizedAnchor,
            isPrecise: precise2,
            isExact: this.editor.inputs.altKey
          };
          createOrUpdateArrowBinding(this.editor, shape, target.id, b2);
          this.editor.setHintingShapes([target.id]);
          const newBindings = getArrowBindings(this.editor, shape);
          if (newBindings.start && newBindings.end && newBindings.start.toId === newBindings.end.toId) {
            if (Vec.Equals(newBindings.start.props.normalizedAnchor, newBindings.end.props.normalizedAnchor)) {
              createOrUpdateArrowBinding(this.editor, shape, newBindings.end.toId, {
                ...newBindings.end.props,
                normalizedAnchor: {
                  x: newBindings.end.props.normalizedAnchor.x + 0.05,
                  y: newBindings.end.props.normalizedAnchor.y
                }
              });
            }
          }
          return update;
        });
        __publicField(this, "onTranslateStart", (shape) => {
          const bindings = getArrowBindings(this.editor, shape);
          const terminalsInArrowSpace = getArrowTerminalsInArrowSpace(this.editor, shape, bindings);
          const shapePageTransform = this.editor.getShapePageTransform(shape.id);
          const selectedShapeIds = this.editor.getSelectedShapeIds();
          if (bindings.start && (selectedShapeIds.includes(bindings.start.toId) || this.editor.isAncestorSelected(bindings.start.toId)) || bindings.end && (selectedShapeIds.includes(bindings.end.toId) || this.editor.isAncestorSelected(bindings.end.toId))) {
            return;
          }
          shapeAtTranslationStart.set(shape, {
            pagePosition: shapePageTransform.applyToPoint(shape),
            terminalBindings: mapObjectMapValues(terminalsInArrowSpace, (terminalName, point) => {
              const binding = bindings[terminalName];
              if (!binding)
                return null;
              return {
                binding,
                shapePosition: point,
                pagePosition: shapePageTransform.applyToPoint(point)
              };
            })
          });
          if (bindings.start) {
            updateArrowTerminal({
              editor: this.editor,
              arrow: shape,
              terminal: "start",
              useHandle: true
            });
            shape = this.editor.getShape(shape.id);
          }
          if (bindings.end) {
            updateArrowTerminal({
              editor: this.editor,
              arrow: shape,
              terminal: "end",
              useHandle: true
            });
          }
          for (const handleName of ["start", "end"]) {
            const binding = bindings[handleName];
            if (!binding)
              continue;
            this.editor.updateBinding({
              ...binding,
              props: { ...binding.props, isPrecise: true }
            });
          }
          return;
        });
        __publicField(this, "onTranslate", (initialShape, shape) => {
          const atTranslationStart = shapeAtTranslationStart.get(initialShape);
          if (!atTranslationStart)
            return;
          const shapePageTransform = this.editor.getShapePageTransform(shape.id);
          const pageDelta = Vec.Sub(shapePageTransform.applyToPoint(shape), atTranslationStart.pagePosition);
          for (const terminalBinding of Object.values(atTranslationStart.terminalBindings)) {
            if (!terminalBinding)
              continue;
            const newPagePoint = Vec.Add(terminalBinding.pagePosition, Vec.Mul(pageDelta, 0.5));
            const newTarget = this.editor.getShapeAtPoint(newPagePoint, {
              hitInside: true,
              hitFrameInside: true,
              margin: 0,
              filter: (targetShape) => {
                return !targetShape.isLocked && this.editor.canBindShapes({ fromShape: shape, toShape: targetShape, binding: "arrow" });
              }
            });
            if (newTarget?.id === terminalBinding.binding.toId) {
              const targetBounds = Box.ZeroFix(this.editor.getShapeGeometry(newTarget).bounds);
              const pointInTargetSpace = this.editor.getPointInShapeSpace(newTarget, newPagePoint);
              const normalizedAnchor = {
                x: (pointInTargetSpace.x - targetBounds.minX) / targetBounds.width,
                y: (pointInTargetSpace.y - targetBounds.minY) / targetBounds.height
              };
              createOrUpdateArrowBinding(this.editor, shape, newTarget.id, {
                ...terminalBinding.binding.props,
                normalizedAnchor,
                isPrecise: true
              });
            } else {
              removeArrowBinding(this.editor, shape, terminalBinding.binding.props.terminal);
            }
          }
        });
        __publicField(this, "_resizeInitialBindings", new WeakCache());
        __publicField(this, "onResize", (shape, info2) => {
          const { scaleX, scaleY } = info2;
          const bindings = this._resizeInitialBindings.get(shape, () => getArrowBindings(this.editor, shape));
          const terminals = getArrowTerminalsInArrowSpace(this.editor, shape, bindings);
          const { start: start2, end: end2 } = structuredClone2(shape.props);
          let { bend } = shape.props;
          if (!bindings.start) {
            start2.x = terminals.start.x * scaleX;
            start2.y = terminals.start.y * scaleY;
          }
          if (!bindings.end) {
            end2.x = terminals.end.x * scaleX;
            end2.y = terminals.end.y * scaleY;
          }
          const mx = Math.abs(scaleX);
          const my = Math.abs(scaleY);
          const startNormalizedAnchor = bindings?.start ? Vec.From(bindings.start.props.normalizedAnchor) : null;
          const endNormalizedAnchor = bindings?.end ? Vec.From(bindings.end.props.normalizedAnchor) : null;
          if (scaleX < 0 && scaleY >= 0) {
            if (bend !== 0) {
              bend *= -1;
              bend *= Math.max(mx, my);
            }
            if (startNormalizedAnchor) {
              startNormalizedAnchor.x = 1 - startNormalizedAnchor.x;
            }
            if (endNormalizedAnchor) {
              endNormalizedAnchor.x = 1 - endNormalizedAnchor.x;
            }
          } else if (scaleX >= 0 && scaleY < 0) {
            if (bend !== 0) {
              bend *= -1;
              bend *= Math.max(mx, my);
            }
            if (startNormalizedAnchor) {
              startNormalizedAnchor.y = 1 - startNormalizedAnchor.y;
            }
            if (endNormalizedAnchor) {
              endNormalizedAnchor.y = 1 - endNormalizedAnchor.y;
            }
          } else if (scaleX >= 0 && scaleY >= 0) {
            if (bend !== 0) {
              bend *= Math.max(mx, my);
            }
          } else if (scaleX < 0 && scaleY < 0) {
            if (bend !== 0) {
              bend *= Math.max(mx, my);
            }
            if (startNormalizedAnchor) {
              startNormalizedAnchor.x = 1 - startNormalizedAnchor.x;
              startNormalizedAnchor.y = 1 - startNormalizedAnchor.y;
            }
            if (endNormalizedAnchor) {
              endNormalizedAnchor.x = 1 - endNormalizedAnchor.x;
              endNormalizedAnchor.y = 1 - endNormalizedAnchor.y;
            }
          }
          if (bindings.start && startNormalizedAnchor) {
            createOrUpdateArrowBinding(this.editor, shape, bindings.start.toId, {
              ...bindings.start.props,
              normalizedAnchor: startNormalizedAnchor.toJson()
            });
          }
          if (bindings.end && endNormalizedAnchor) {
            createOrUpdateArrowBinding(this.editor, shape, bindings.end.toId, {
              ...bindings.end.props,
              normalizedAnchor: endNormalizedAnchor.toJson()
            });
          }
          const next = {
            props: {
              start: start2,
              end: end2,
              bend
            }
          };
          return next;
        });
        __publicField(this, "onDoubleClickHandle", (shape, handle) => {
          switch (handle.id) {
            case "start": {
              return {
                id: shape.id,
                type: shape.type,
                props: {
                  ...shape.props,
                  arrowheadStart: shape.props.arrowheadStart === "none" ? "arrow" : "none"
                }
              };
            }
            case "end": {
              return {
                id: shape.id,
                type: shape.type,
                props: {
                  ...shape.props,
                  arrowheadEnd: shape.props.arrowheadEnd === "none" ? "arrow" : "none"
                }
              };
            }
          }
        });
        __publicField(this, "onEditEnd", (shape) => {
          const {
            id,
            type,
            props: { text }
          } = shape;
          if (text.trimEnd() !== shape.props.text) {
            this.editor.updateShapes([
              {
                id,
                type,
                props: {
                  text: text.trimEnd()
                }
              }
            ]);
          }
        });
      }
      canBind({ toShapeType }) {
        return toShapeType !== "arrow";
      }
      getDefaultProps() {
        return {
          dash: "draw",
          size: "m",
          fill: "none",
          color: "black",
          labelColor: "black",
          bend: 0,
          start: { x: 0, y: 0 },
          end: { x: 2, y: 0 },
          arrowheadStart: "none",
          arrowheadEnd: "arrow",
          text: "",
          labelPosition: 0.5,
          font: "draw",
          scale: 1
        };
      }
      getGeometry(shape) {
        const info2 = getArrowInfo(this.editor, shape);
        const debugGeom = [];
        const bodyGeom = info2.isStraight ? new Edge2d({
          start: Vec.From(info2.start.point),
          end: Vec.From(info2.end.point)
        }) : new Arc2d({
          center: Vec.Cast(info2.handleArc.center),
          start: Vec.Cast(info2.start.point),
          end: Vec.Cast(info2.end.point),
          sweepFlag: info2.bodyArc.sweepFlag,
          largeArcFlag: info2.bodyArc.largeArcFlag
        });
        let labelGeom;
        if (shape.props.text.trim()) {
          const labelPosition = getArrowLabelPosition(this.editor, shape);
          debugGeom.push(...labelPosition.debugGeom);
          labelGeom = new Rectangle2d({
            x: labelPosition.box.x,
            y: labelPosition.box.y,
            width: labelPosition.box.w,
            height: labelPosition.box.h,
            isFilled: true,
            isLabel: true
          });
        }
        return new Group2d({
          children: [...labelGeom ? [bodyGeom, labelGeom] : [bodyGeom], ...debugGeom]
        });
      }
      getHandles(shape) {
        const info2 = getArrowInfo(this.editor, shape);
        return [
          {
            id: "start",
            type: "vertex",
            index: "a0",
            x: info2.start.handle.x,
            y: info2.start.handle.y
          },
          {
            id: "middle",
            type: "virtual",
            index: "a2",
            x: info2.middle.x,
            y: info2.middle.y
          },
          {
            id: "end",
            type: "vertex",
            index: "a3",
            x: info2.end.handle.x,
            y: info2.end.handle.y
          }
        ].filter(Boolean);
      }
      component(shape) {
        const theme = useDefaultColorTheme();
        const onlySelectedShape = this.editor.getOnlySelectedShape();
        const shouldDisplayHandles = this.editor.isInAny("select.idle", "select.pointing_handle", "select.dragging_handle", "select.translating", "arrow.dragging") && !this.editor.getInstanceState().isReadonly;
        const info2 = getArrowInfo(this.editor, shape);
        if (!info2?.isValid)
          return null;
        const labelPosition = getArrowLabelPosition(this.editor, shape);
        const isSelected = shape.id === this.editor.getOnlySelectedShapeId();
        const isEditing = this.editor.getEditingShapeId() === shape.id;
        const showArrowLabel = isEditing || shape.props.text;
        return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)(import_jsx_runtime47.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(SVGContainer, { id: shape.id, style: { minWidth: 50, minHeight: 50 }, children: /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(ArrowSvg, {
            shape,
            shouldDisplayHandles: shouldDisplayHandles && onlySelectedShape?.id === shape.id
          }) }),
          showArrowLabel && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(TextLabel, {
            id: shape.id,
            classNamePrefix: "tl-arrow",
            type: "arrow",
            font: shape.props.font,
            fontSize: getArrowLabelFontSize(shape),
            lineHeight: TEXT_PROPS.lineHeight,
            align: "middle",
            verticalAlign: "middle",
            text: shape.props.text,
            labelColor: theme[shape.props.labelColor].solid,
            textWidth: labelPosition.box.w,
            isSelected,
            padding: 0,
            style: {
              transform: `translate(${labelPosition.box.center.x}px, ${labelPosition.box.center.y}px)`
            }
          })
        ] });
      }
      indicator(shape) {
        const isEditing = useIsEditing(shape.id);
        const info2 = getArrowInfo(this.editor, shape);
        if (!info2)
          return null;
        const { start: start2, end: end2 } = getArrowTerminalsInArrowSpace(this.editor, shape, info2?.bindings);
        const geometry = this.editor.getShapeGeometry(shape);
        const bounds = geometry.bounds;
        const labelGeometry = shape.props.text.trim() ? geometry.children[1] : null;
        if (Vec.Equals(start2, end2))
          return null;
        const strokeWidth = STROKE_SIZES2[shape.props.size] * shape.props.scale;
        const as = info2.start.arrowhead && getArrowheadPathForType(info2, "start", strokeWidth);
        const ae = info2.end.arrowhead && getArrowheadPathForType(info2, "end", strokeWidth);
        const path = info2.isStraight ? getSolidStraightArrowPath(info2) : getSolidCurvedArrowPath(info2);
        const includeMask = as && info2.start.arrowhead !== "arrow" || ae && info2.end.arrowhead !== "arrow" || !!labelGeometry;
        const maskId = (shape.id + "_clip").replace(":", "_");
        if (isEditing && labelGeometry) {
          return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
            x: toDomPrecision(labelGeometry.x),
            y: toDomPrecision(labelGeometry.y),
            width: labelGeometry.w,
            height: labelGeometry.h,
            rx: 3.5 * shape.props.scale,
            ry: 3.5 * shape.props.scale
          });
        }
        return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("g", { children: [
          includeMask && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("mask", { id: maskId, children: [
            /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
              x: bounds.minX - 100,
              y: bounds.minY - 100,
              width: bounds.w + 200,
              height: bounds.h + 200,
              fill: "white"
            }),
            labelGeometry && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
              x: toDomPrecision(labelGeometry.x),
              y: toDomPrecision(labelGeometry.y),
              width: labelGeometry.w,
              height: labelGeometry.h,
              fill: "black",
              rx: 3.5 * shape.props.scale,
              ry: 3.5 * shape.props.scale
            }),
            as && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", {
              d: as,
              fill: info2.start.arrowhead === "arrow" ? "none" : "black",
              stroke: "none"
            }),
            ae && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", {
              d: ae,
              fill: info2.end.arrowhead === "arrow" ? "none" : "black",
              stroke: "none"
            })
          ] }) }),
          /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("g", { ...includeMask ? { mask: `url(#${maskId})` } : void 0, children: [
            includeMask && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
              x: bounds.minX - 100,
              y: bounds.minY - 100,
              width: bounds.width + 200,
              height: bounds.height + 200,
              opacity: 0
            }),
            /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: path })
          ] }),
          as && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: as }),
          ae && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: ae }),
          labelGeometry && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
            x: toDomPrecision(labelGeometry.x),
            y: toDomPrecision(labelGeometry.y),
            width: labelGeometry.w,
            height: labelGeometry.h,
            rx: 3.5,
            ry: 3.5
          })
        ] });
      }
      toSvg(shape, ctx) {
        ctx.addExportDef(getFillDefForExport(shape.props.fill));
        if (shape.props.text)
          ctx.addExportDef(getFontDefForExport(shape.props.font));
        const theme = getDefaultColorTheme(ctx);
        const scaleFactor = 1 / shape.props.scale;
        return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("g", { transform: `scale(${scaleFactor})`, children: [
          /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(ArrowSvg, { shape, shouldDisplayHandles: false }),
          /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(SvgTextLabel, {
            fontSize: getArrowLabelFontSize(shape),
            font: shape.props.font,
            align: "middle",
            verticalAlign: "middle",
            text: shape.props.text,
            labelColor: theme[shape.props.labelColor].solid,
            bounds: getArrowLabelPosition(this.editor, shape).box,
            padding: 4 * shape.props.scale
          })
        ] });
      }
      getCanvasSvgDefs() {
        return [
          getFillDefForCanvas(),
          {
            key: `arrow:dot`,
            component: ArrowheadDotDef
          },
          {
            key: `arrow:cross`,
            component: ArrowheadCrossDef
          }
        ];
      }
      getInterpolatedProps(startShape, endShape, progress) {
        return {
          ...endShape.props,
          start: {
            x: lerp(startShape.props.start.x, endShape.props.start.x, progress),
            y: lerp(startShape.props.start.y, endShape.props.start.y, progress)
          },
          end: {
            x: lerp(startShape.props.end.x, endShape.props.end.x, progress),
            y: lerp(startShape.props.end.y, endShape.props.end.y, progress)
          },
          bend: lerp(startShape.props.bend, endShape.props.bend, progress),
          labelPosition: lerp(startShape.props.labelPosition, endShape.props.labelPosition, progress)
        };
      }
    };
    __publicField(ArrowShapeUtil, "type", "arrow");
    __publicField(ArrowShapeUtil, "props", arrowShapeProps);
    __publicField(ArrowShapeUtil, "migrations", arrowShapeMigrations);
    ArrowSvg = track(function ArrowSvg2({
      shape,
      shouldDisplayHandles
    }) {
      const editor = useEditor();
      const theme = useDefaultColorTheme();
      const info2 = getArrowInfo(editor, shape);
      const bounds = Box.ZeroFix(editor.getShapeGeometry(shape).bounds);
      const bindings = getArrowBindings(editor, shape);
      const changeIndex = import_react52.default.useMemo(() => {
        return editor.environment.isSafari ? globalRenderIndex += 1 : 0;
      }, [shape]);
      if (!info2?.isValid)
        return null;
      const strokeWidth = STROKE_SIZES2[shape.props.size] * shape.props.scale;
      const as = info2.start.arrowhead && getArrowheadPathForType(info2, "start", strokeWidth);
      const ae = info2.end.arrowhead && getArrowheadPathForType(info2, "end", strokeWidth);
      const path = info2.isStraight ? getSolidStraightArrowPath(info2) : getSolidCurvedArrowPath(info2);
      let handlePath = null;
      if (shouldDisplayHandles) {
        const sw = 2 / editor.getZoomLevel();
        const { strokeDasharray: strokeDasharray2, strokeDashoffset: strokeDashoffset2 } = getPerfectDashProps2(getLength(editor, shape), sw, {
          end: "skip",
          start: "skip",
          lengthRatio: 2.5
        });
        handlePath = bindings.start || bindings.end ? /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", {
          className: "tl-arrow-hint",
          d: info2.isStraight ? getStraightArrowHandlePath(info2) : getCurvedArrowHandlePath(info2),
          strokeDasharray: strokeDasharray2,
          strokeDashoffset: strokeDashoffset2,
          strokeWidth: sw,
          markerStart: bindings.start ? bindings.start.props.isExact ? "" : bindings.start.props.isPrecise ? "url(#arrowhead-cross)" : "url(#arrowhead-dot)" : "",
          markerEnd: bindings.end ? bindings.end.props.isExact ? "" : bindings.end.props.isPrecise ? "url(#arrowhead-cross)" : "url(#arrowhead-dot)" : "",
          opacity: 0.16
        }) : null;
      }
      const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(info2.isStraight ? info2.length : Math.abs(info2.bodyArc.length), strokeWidth, {
        style: shape.props.dash
      });
      const labelPosition = getArrowLabelPosition(editor, shape);
      const maskStartArrowhead = !(info2.start.arrowhead === "none" || info2.start.arrowhead === "arrow");
      const maskEndArrowhead = !(info2.end.arrowhead === "none" || info2.end.arrowhead === "arrow");
      const maskId = (shape.id + "_clip_" + changeIndex).replace(":", "_");
      return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)(import_jsx_runtime47.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("mask", { id: maskId, children: [
          /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
            x: toDomPrecision(-100 + bounds.minX),
            y: toDomPrecision(-100 + bounds.minY),
            width: toDomPrecision(bounds.width + 200),
            height: toDomPrecision(bounds.height + 200),
            fill: "white"
          }),
          shape.props.text.trim() && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
            x: labelPosition.box.x,
            y: labelPosition.box.y,
            width: labelPosition.box.w,
            height: labelPosition.box.h,
            fill: "black",
            rx: 4,
            ry: 4
          }),
          as && maskStartArrowhead && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: as, fill: info2.start.arrowhead === "arrow" ? "none" : "black", stroke: "none" }),
          ae && maskEndArrowhead && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: ae, fill: info2.end.arrowhead === "arrow" ? "none" : "black", stroke: "none" })
        ] }) }),
        /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("g", {
          fill: "none",
          stroke: theme[shape.props.color].solid,
          strokeWidth,
          strokeLinejoin: "round",
          strokeLinecap: "round",
          pointerEvents: "none",
          children: [
            handlePath,
            /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("g", { mask: `url(#${maskId})`, children: [
              /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("rect", {
                x: toDomPrecision(bounds.minX - 100),
                y: toDomPrecision(bounds.minY - 100),
                width: toDomPrecision(bounds.width + 200),
                height: toDomPrecision(bounds.height + 200),
                opacity: 0
              }),
              /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: path, strokeDasharray, strokeDashoffset })
            ] }),
            as && maskStartArrowhead && shape.props.fill !== "none" && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(ShapeFill, {
              theme,
              d: as,
              color: shape.props.color,
              fill: shape.props.fill,
              scale: shape.props.scale
            }),
            ae && maskEndArrowhead && shape.props.fill !== "none" && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(ShapeFill, {
              theme,
              d: ae,
              color: shape.props.color,
              fill: shape.props.fill,
              scale: shape.props.scale
            }),
            as && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: as }),
            ae && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("path", { d: ae })
          ]
        })
      ] });
    });
    shapeAtTranslationStart = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/HyperlinkButton.mjs
function HyperlinkButton({ url, zoomLevel }) {
  return /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("a", {
    className: (0, import_classnames16.default)("tl-hyperlink-button", {
      "tl-hyperlink-button__hidden": zoomLevel < 0.32
    }),
    href: url,
    target: "_blank",
    rel: "noopener noreferrer",
    onPointerDown: stopEventPropagation,
    onPointerUp: stopEventPropagation,
    title: url,
    draggable: false,
    children: /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("div", {
      className: "tl-hyperlink__icon",
      style: {
        mask: `url("${LINK_ICON}") center 100% / 100% no-repeat`,
        WebkitMask: `url("${LINK_ICON}") center 100% / 100% no-repeat`
      }
    })
  });
}
var import_jsx_runtime48, import_classnames16, LINK_ICON;
var init_HyperlinkButton = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/HyperlinkButton.mjs"() {
    import_jsx_runtime48 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames16 = __toESM(require_classnames(), 1);
    LINK_ICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' fill='none'%3E%3Cpath stroke='%23000' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M13 5H7a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6M19 5h6m0 0v6m0-6L13 17'/%3E%3C/svg%3E";
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/icons-editor.mjs
var LINK_ICON2;
var init_icons_editor = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/icons-editor.mjs"() {
    LINK_ICON2 = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' fill='none'%3E%3Cpath stroke='%23000' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M13 5H7a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6M19 5h6m0 0v6m0-6L13 17'/%3E%3C/svg%3E";
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/rotated-box-shadow.mjs
function getRotatedBoxShadow(rotation) {
  const cssStrings = ROTATING_BOX_SHADOWS.map((shadow) => {
    const { offsetX, offsetY, blur, spread, color } = shadow;
    const vec = new Vec(offsetX, offsetY);
    const { x: x2, y: y2 } = vec.rot(-rotation);
    return `${x2}px ${y2}px ${blur}px ${spread}px ${color}`;
  });
  return cssStrings.join(", ");
}
var ROTATING_BOX_SHADOWS;
var init_rotated_box_shadow = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/rotated-box-shadow.mjs"() {
    init_dist_esm10();
    ROTATING_BOX_SHADOWS = [
      {
        offsetX: 0,
        offsetY: 2,
        blur: 4,
        spread: 0,
        color: "#00000029"
      },
      {
        offsetX: 0,
        offsetY: 3,
        blur: 6,
        spread: 0,
        color: "#0000001f"
      }
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/bookmark/BookmarkShapeUtil.mjs
function getBookmarkSize(editor, shape) {
  const asset = shape.props.assetId ? editor.getAsset(shape.props.assetId) : null;
  let h2 = BOOKMARK_HEIGHT;
  if (asset) {
    if (!asset.props.image) {
      if (!asset.props.title) {
        h2 = BOOKMARK_JUST_URL_HEIGHT;
      } else {
        h2 = SHORT_BOOKMARK_HEIGHT;
      }
    }
  }
  return {
    ...shape,
    props: {
      ...shape.props,
      h: h2
    }
  };
}
function updateBookmarkAssetOnUrlChange(editor, shape) {
  const { url } = shape.props;
  const assetId = AssetRecordType.createId(getHashForString(url));
  if (editor.getAsset(assetId)) {
    if (shape.props.assetId !== assetId) {
      editor.updateShapes([
        {
          id: shape.id,
          type: shape.type,
          props: { assetId }
        }
      ]);
    }
  } else {
    editor.updateShapes([
      {
        id: shape.id,
        type: shape.type,
        props: { assetId: null }
      }
    ]);
    createBookmarkAssetOnUrlChange(editor, shape);
  }
}
var import_jsx_runtime49, BOOKMARK_WIDTH, BOOKMARK_HEIGHT, BOOKMARK_JUST_URL_HEIGHT, SHORT_BOOKMARK_HEIGHT, BookmarkShapeUtil, getHumanReadableAddress, createBookmarkAssetOnUrlChange;
var init_BookmarkShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/bookmark/BookmarkShapeUtil.mjs"() {
    import_jsx_runtime49 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_HyperlinkButton();
    init_icons_editor();
    init_rotated_box_shadow();
    BOOKMARK_WIDTH = 300;
    BOOKMARK_HEIGHT = 320;
    BOOKMARK_JUST_URL_HEIGHT = 46;
    SHORT_BOOKMARK_HEIGHT = 101;
    BookmarkShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canResize", () => false);
        __publicField(this, "hideSelectionBoundsFg", () => true);
        __publicField(this, "onBeforeCreate", (next) => {
          return getBookmarkSize(this.editor, next);
        });
        __publicField(this, "onBeforeUpdate", (prev, shape) => {
          if (prev.props.url !== shape.props.url) {
            if (!validation_exports.linkUrl.isValid(shape.props.url)) {
              return { ...shape, props: { ...shape.props, url: prev.props.url } };
            } else {
              updateBookmarkAssetOnUrlChange(this.editor, shape);
            }
          }
          if (prev.props.assetId !== shape.props.assetId) {
            return getBookmarkSize(this.editor, shape);
          }
        });
      }
      getDefaultProps() {
        return {
          url: "",
          w: BOOKMARK_WIDTH,
          h: BOOKMARK_HEIGHT,
          assetId: null
        };
      }
      component(shape) {
        const asset = shape.props.assetId ? this.editor.getAsset(shape.props.assetId) : null;
        const pageRotation = this.editor.getShapePageTransform(shape).rotation();
        const address = getHumanReadableAddress(shape);
        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(HTMLContainer, { children: /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("div", {
          className: "tl-bookmark__container",
          style: {
            boxShadow: getRotatedBoxShadow(pageRotation),
            maxHeight: shape.props.h
          },
          children: [
            (!asset || asset.props.image) && /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("div", { className: "tl-bookmark__image_container", children: [
              asset ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("img", {
                className: "tl-bookmark__image",
                draggable: false,
                referrerPolicy: "strict-origin-when-cross-origin",
                src: asset?.props.image,
                alt: asset?.props.title || ""
              }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("div", { className: "tl-bookmark__placeholder" }),
              asset?.props.image && /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: this.editor.getZoomLevel() })
            ] }),
            /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("div", { className: "tl-bookmark__copy_container", children: [
              asset?.props.title ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("h2", { className: "tl-bookmark__heading", children: asset.props.title }) : null,
              asset?.props.description && asset?.props.image ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("p", { className: "tl-bookmark__description", children: asset.props.description }) : null,
              /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("a", {
                className: "tl-bookmark__link",
                href: shape.props.url || "",
                target: "_blank",
                rel: "noopener noreferrer",
                onPointerDown: stopEventPropagation,
                onPointerUp: stopEventPropagation,
                onClick: stopEventPropagation,
                children: [
                  asset?.props.favicon ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("img", {
                    className: "tl-bookmark__favicon",
                    src: asset?.props.favicon,
                    referrerPolicy: "strict-origin-when-cross-origin",
                    alt: `favicon of ${address}`
                  }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("div", {
                    className: "tl-hyperlink__icon",
                    style: {
                      mask: `url("${LINK_ICON2}") center 100% / 100% no-repeat`,
                      WebkitMask: `url("${LINK_ICON2}") center 100% / 100% no-repeat`
                    }
                  }),
                  /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("span", { children: address })
                ]
              })
            ] })
          ]
        }) });
      }
      indicator(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("rect", {
          width: toDomPrecision(shape.props.w),
          height: toDomPrecision(shape.props.h),
          rx: "6",
          ry: "6"
        });
      }
    };
    __publicField(BookmarkShapeUtil, "type", "bookmark");
    __publicField(BookmarkShapeUtil, "props", bookmarkShapeProps);
    __publicField(BookmarkShapeUtil, "migrations", bookmarkShapeMigrations);
    getHumanReadableAddress = (shape) => {
      try {
        const url = new URL(shape.props.url);
        return url.hostname.replace(/^www\./, "");
      } catch (e2) {
        return shape.props.url;
      }
    };
    createBookmarkAssetOnUrlChange = debounce(async (editor, shape) => {
      if (editor.isDisposed)
        return;
      const { url } = shape.props;
      const asset = await editor.getAssetForExternalContent({ type: "url", url });
      if (!asset) {
        return;
      }
      editor.run(() => {
        editor.createAssets([asset]);
        editor.updateShapes([
          {
            id: shape.id,
            type: shape.type,
            props: { assetId: asset.id }
          }
        ]);
      });
    }, 500);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/svg.mjs
function getSvgPathFromStrokePoints(points, closed = false) {
  const len = points.length;
  if (len < 2) {
    return "";
  }
  let a2 = points[0].point;
  let b2 = points[1].point;
  if (len === 2) {
    return `M${precise(a2)}L${precise(b2)}`;
  }
  let result = "";
  for (let i2 = 2, max3 = len - 1; i2 < max3; i2++) {
    a2 = points[i2].point;
    b2 = points[i2 + 1].point;
    result += average2(a2, b2);
  }
  if (closed) {
    return `M${average2(points[0].point, points[1].point)}Q${precise(points[1].point)}${average2(points[1].point, points[2].point)}T${result}${average2(points[len - 1].point, points[0].point)}${average2(points[0].point, points[1].point)}Z`;
  } else {
    return `M${precise(points[0].point)}Q${precise(points[1].point)}${average2(points[1].point, points[2].point)}${points.length > 3 ? "T" : ""}${result}L${precise(points[len - 1].point)}`;
  }
}
var init_svg = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/svg.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/svgInk.mjs
function svgInk(rawInputPoints, options = {}) {
  const { start: start2 = {}, end: end2 = {} } = options;
  const { cap: capStart = true } = start2;
  const { cap: capEnd = true } = end2;
  assert(!start2.taper && !end2.taper, "cap taper not supported here");
  assert(!start2.easing && !end2.easing, "cap easing not supported here");
  assert(capStart && capEnd, "cap must be true");
  const points = getStrokePoints(rawInputPoints, options);
  setStrokePointRadii(points, options);
  const partitions = partitionAtElbows(points);
  let svg = "";
  for (const partition5 of partitions) {
    svg += renderPartition(partition5, options);
  }
  return svg;
}
function partitionAtElbows(points) {
  if (points.length <= 2)
    return [points];
  const result = [];
  let currentPartition = [points[0]];
  let prevV = Vec.Sub(points[1].point, points[0].point).uni();
  let nextV;
  let dpr;
  let prevPoint, thisPoint, nextPoint;
  for (let i2 = 1, n2 = points.length; i2 < n2 - 1; i2++) {
    prevPoint = points[i2 - 1];
    thisPoint = points[i2];
    nextPoint = points[i2 + 1];
    nextV = Vec.Sub(nextPoint.point, thisPoint.point).uni();
    dpr = Vec.Dpr(prevV, nextV);
    prevV = nextV;
    if (dpr < -0.8) {
      const elbowPoint = {
        ...thisPoint,
        point: thisPoint.input
      };
      currentPartition.push(elbowPoint);
      result.push(cleanUpPartition(currentPartition));
      currentPartition = [elbowPoint];
      continue;
    }
    currentPartition.push(thisPoint);
    if (dpr > 0.7) {
      continue;
    }
    if ((Vec.Dist2(prevPoint.point, thisPoint.point) + Vec.Dist2(thisPoint.point, nextPoint.point)) / ((prevPoint.radius + thisPoint.radius + nextPoint.radius) / 3) ** 2 < 1.5) {
      currentPartition.push(thisPoint);
      result.push(cleanUpPartition(currentPartition));
      currentPartition = [thisPoint];
      continue;
    }
  }
  currentPartition.push(points[points.length - 1]);
  result.push(cleanUpPartition(currentPartition));
  return result;
}
function cleanUpPartition(partition5) {
  const startPoint = partition5[0];
  let nextPoint;
  while (partition5.length > 2) {
    nextPoint = partition5[1];
    if (Vec.Dist2(startPoint.point, nextPoint.point) < ((startPoint.radius + nextPoint.radius) / 2 * 0.5) ** 2) {
      partition5.splice(1, 1);
    } else {
      break;
    }
  }
  const endPoint = partition5[partition5.length - 1];
  let prevPoint;
  while (partition5.length > 2) {
    prevPoint = partition5[partition5.length - 2];
    if (Vec.Dist2(endPoint.point, prevPoint.point) < ((endPoint.radius + prevPoint.radius) / 2 * 0.5) ** 2) {
      partition5.splice(partition5.length - 2, 1);
    } else {
      break;
    }
  }
  if (partition5.length > 1) {
    partition5[0] = {
      ...partition5[0],
      vector: Vec.Sub(partition5[0].point, partition5[1].point).uni()
    };
    partition5[partition5.length - 1] = {
      ...partition5[partition5.length - 1],
      vector: Vec.Sub(partition5[partition5.length - 2].point, partition5[partition5.length - 1].point).uni()
    };
  }
  return partition5;
}
function circlePath(cx, cy, r2) {
  return "M " + cx + " " + cy + " m -" + r2 + ", 0 a " + r2 + "," + r2 + " 0 1,1 " + r2 * 2 + ",0 a " + r2 + "," + r2 + " 0 1,1 -" + r2 * 2 + ",0";
}
function renderPartition(strokePoints, options = {}) {
  if (strokePoints.length === 0)
    return "";
  if (strokePoints.length === 1) {
    return circlePath(strokePoints[0].point.x, strokePoints[0].point.y, strokePoints[0].radius);
  }
  const { left: left2, right: right2 } = getStrokeOutlineTracks(strokePoints, options);
  right2.reverse();
  let svg = `M${precise(left2[0])}T`;
  for (let i2 = 1; i2 < left2.length; i2++) {
    svg += average2(left2[i2 - 1], left2[i2]);
  }
  {
    const point = strokePoints[strokePoints.length - 1];
    const radius = point.radius;
    const direction = point.vector.clone().per().neg();
    const arcStart = Vec.Add(point.point, Vec.Mul(direction, radius));
    const arcEnd = Vec.Add(point.point, Vec.Mul(direction, -radius));
    svg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(radius)} 0 0 1 ${precise(arcEnd)}T`;
  }
  for (let i2 = 1; i2 < right2.length; i2++) {
    svg += average2(right2[i2 - 1], right2[i2]);
  }
  {
    const point = strokePoints[0];
    const radius = point.radius;
    const direction = point.vector.clone().per();
    const arcStart = Vec.Add(point.point, Vec.Mul(direction, radius));
    const arcEnd = Vec.Add(point.point, Vec.Mul(direction, -radius));
    svg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(radius)} 0 0 1 ${precise(arcEnd)}Z`;
  }
  return svg;
}
var init_svgInk = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/freehand/svgInk.mjs"() {
    init_dist_esm10();
    init_getStrokeOutlinePoints();
    init_getStrokePoints();
    init_setStrokePointRadii();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/draw/getPath.mjs
function getHighlightFreehandSettings({
  strokeWidth,
  showAsComplete
}) {
  return {
    size: 1 + strokeWidth,
    thinning: 0,
    streamline: 0.5,
    smoothing: 0.5,
    simulatePressure: false,
    easing: EASINGS.easeOutSine,
    last: showAsComplete
  };
}
function getFreehandOptions(shapeProps, strokeWidth, forceComplete, forceSolid) {
  const last7 = shapeProps.isComplete || forceComplete;
  if (forceSolid) {
    if (shapeProps.isPen) {
      return { ...solidRealPressureSettings(strokeWidth), last: last7 };
    } else {
      return { ...solidSettings(strokeWidth), last: last7 };
    }
  }
  if (shapeProps.dash === "draw") {
    if (shapeProps.isPen) {
      return { ...realPressureSettings(strokeWidth), last: last7 };
    } else {
      return { ...simulatePressureSettings(strokeWidth), last: last7 };
    }
  }
  return { ...solidSettings(strokeWidth), last: last7 };
}
function getPointsFromSegments(segments) {
  const points = [];
  for (const segment of segments) {
    if (segment.type === "free" || segment.points.length < 2) {
      points.push(...segment.points.map(Vec.Cast));
    } else {
      const pointsToInterpolate = Math.max(4, Math.floor(Vec.Dist(segment.points[0], segment.points[1]) / 16));
      points.push(...Vec.PointsBetween(segment.points[0], segment.points[1], pointsToInterpolate));
    }
  }
  return points;
}
function getDrawShapeStrokeDashArray(shape, strokeWidth) {
  return {
    draw: "none",
    solid: `none`,
    dotted: `0.1 ${strokeWidth * 2}`,
    dashed: `${strokeWidth * 2} ${strokeWidth * 2}`
  }[shape.props.dash];
}
var PEN_EASING, simulatePressureSettings, realPressureSettings, solidSettings, solidRealPressureSettings;
var init_getPath = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/draw/getPath.mjs"() {
    init_dist_esm10();
    PEN_EASING = (t3) => t3 * 0.65 + SIN(t3 * PI / 2) * 0.35;
    simulatePressureSettings = (strokeWidth) => {
      return {
        size: strokeWidth,
        thinning: 0.5,
        streamline: modulate(strokeWidth, [9, 16], [0.64, 0.74], true),
        smoothing: 0.62,
        easing: EASINGS.easeOutSine,
        simulatePressure: true
      };
    };
    realPressureSettings = (strokeWidth) => {
      return {
        size: 1 + strokeWidth * 1.2,
        thinning: 0.62,
        streamline: 0.62,
        smoothing: 0.62,
        simulatePressure: false,
        easing: PEN_EASING
      };
    };
    solidSettings = (strokeWidth) => {
      return {
        size: strokeWidth,
        thinning: 0,
        streamline: modulate(strokeWidth, [9, 16], [0.64, 0.74], true),
        smoothing: 0.62,
        simulatePressure: false,
        easing: EASINGS.linear
      };
    };
    solidRealPressureSettings = (strokeWidth) => {
      return {
        size: strokeWidth,
        thinning: 0,
        streamline: 0.62,
        smoothing: 0.62,
        simulatePressure: false,
        easing: EASINGS.linear
      };
    };
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/draw/DrawShapeUtil.mjs
function getDot(point, sw) {
  const r2 = (sw + 1) * 0.5;
  return `M ${point.x} ${point.y} m -${r2}, 0 a ${r2},${r2} 0 1,0 ${r2 * 2},0 a ${r2},${r2} 0 1,0 -${r2 * 2},0`;
}
function getIsDot(shape) {
  return shape.props.segments.length === 1 && shape.props.segments[0].points.length < 2;
}
function DrawShapeSvg({ shape, zoomLevel }) {
  const theme = useDefaultColorTheme();
  const allPointsFromSegments = getPointsFromSegments(shape.props.segments);
  const showAsComplete = shape.props.isComplete || last(shape.props.segments)?.type === "straight";
  let sw = (STROKE_SIZES2[shape.props.size] + 1) * shape.props.scale;
  const forceSolid = zoomLevel < 0.5 && zoomLevel < 1.5 / sw;
  if (!forceSolid && !shape.props.isPen && shape.props.dash === "draw" && allPointsFromSegments.length === 1) {
    sw += rng(shape.id)() * (sw / 6);
  }
  const options = getFreehandOptions(shape.props, sw, showAsComplete, forceSolid);
  if (!forceSolid && shape.props.dash === "draw") {
    return /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(import_jsx_runtime50.Fragment, { children: [
      shape.props.isClosed && shape.props.fill && allPointsFromSegments.length > 1 ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(ShapeFill, {
        d: getSvgPathFromStrokePoints(getStrokePoints(allPointsFromSegments, options), shape.props.isClosed),
        theme,
        color: shape.props.color,
        fill: shape.props.isClosed ? shape.props.fill : "none",
        scale: shape.props.scale
      }) : null,
      /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("path", {
        d: svgInk(allPointsFromSegments, options),
        strokeLinecap: "round",
        fill: theme[shape.props.color].solid
      })
    ] });
  }
  const strokePoints = getStrokePoints(allPointsFromSegments, options);
  const isDot = strokePoints.length < 2;
  const solidStrokePath = isDot ? getDot(allPointsFromSegments[0], 0) : getSvgPathFromStrokePoints(strokePoints, shape.props.isClosed);
  return /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(import_jsx_runtime50.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(ShapeFill, {
      d: solidStrokePath,
      theme,
      color: shape.props.color,
      fill: isDot || shape.props.isClosed ? shape.props.fill : "none",
      scale: shape.props.scale
    }),
    /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("path", {
      d: solidStrokePath,
      strokeLinecap: "round",
      fill: isDot ? theme[shape.props.color].solid : "none",
      stroke: theme[shape.props.color].solid,
      strokeWidth: sw,
      strokeDasharray: isDot ? "none" : getDrawShapeStrokeDashArray(shape, sw),
      strokeDashoffset: "0"
    })
  ] });
}
var import_jsx_runtime50, DrawShapeUtil;
var init_DrawShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/draw/DrawShapeUtil.mjs"() {
    import_jsx_runtime50 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_ShapeFill();
    init_default_shape_constants();
    init_defaultStyleDefs();
    init_getStrokePoints();
    init_svg();
    init_svgInk();
    init_useDefaultColorTheme();
    init_getPath();
    DrawShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "hideResizeHandles", (shape) => getIsDot(shape));
        __publicField(this, "hideRotateHandle", (shape) => getIsDot(shape));
        __publicField(this, "hideSelectionBoundsFg", (shape) => getIsDot(shape));
        __publicField(this, "onResize", (shape, info2) => {
          const { scaleX, scaleY } = info2;
          const newSegments = [];
          for (const segment of shape.props.segments) {
            newSegments.push({
              ...segment,
              points: segment.points.map(({ x: x2, y: y2, z }) => {
                return {
                  x: toFixed(scaleX * x2),
                  y: toFixed(scaleY * y2),
                  z
                };
              })
            });
          }
          return {
            props: {
              segments: newSegments
            }
          };
        });
      }
      getDefaultProps() {
        return {
          segments: [],
          color: "black",
          fill: "none",
          dash: "draw",
          size: "m",
          isComplete: false,
          isClosed: false,
          isPen: false,
          scale: 1
        };
      }
      getGeometry(shape) {
        const points = getPointsFromSegments(shape.props.segments);
        const sw = (STROKE_SIZES2[shape.props.size] + 1) * shape.props.scale;
        if (shape.props.segments.length === 1) {
          const box = Box.FromPoints(points);
          if (box.width < sw * 2 && box.height < sw * 2) {
            return new Circle2d({
              x: -sw,
              y: -sw,
              radius: sw,
              isFilled: true
            });
          }
        }
        const strokePoints = getStrokePoints(points, getFreehandOptions(shape.props, sw, shape.props.isPen, true)).map((p2) => p2.point);
        if (shape.props.isClosed) {
          return new Polygon2d({
            points: strokePoints,
            isFilled: shape.props.fill !== "none"
          });
        }
        return new Polyline2d({
          points: strokePoints
        });
      }
      component(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(SVGContainer, { id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(DrawShapeSvg, { shape, zoomLevel: this.editor.getZoomLevel() }) });
      }
      indicator(shape) {
        const allPointsFromSegments = getPointsFromSegments(shape.props.segments);
        let sw = (STROKE_SIZES2[shape.props.size] + 1) * shape.props.scale;
        const zoomLevel = this.editor.getZoomLevel();
        const forceSolid = zoomLevel < 0.5 && zoomLevel < 1.5 / sw;
        if (!forceSolid && !shape.props.isPen && shape.props.dash === "draw" && allPointsFromSegments.length === 1) {
          sw += rng(shape.id)() * (sw / 6);
        }
        const showAsComplete = shape.props.isComplete || last(shape.props.segments)?.type === "straight";
        const options = getFreehandOptions(shape.props, sw, showAsComplete, true);
        const strokePoints = getStrokePoints(allPointsFromSegments, options);
        const solidStrokePath = strokePoints.length > 1 ? getSvgPathFromStrokePoints(strokePoints, shape.props.isClosed) : getDot(allPointsFromSegments[0], sw);
        return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("path", { d: solidStrokePath });
      }
      toSvg(shape, ctx) {
        ctx.addExportDef(getFillDefForExport(shape.props.fill));
        const scaleFactor = 1 / shape.props.scale;
        return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("g", { transform: `scale(${scaleFactor})`, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(DrawShapeSvg, { shape, zoomLevel: 1 }) });
      }
      getCanvasSvgDefs() {
        return [getFillDefForCanvas()];
      }
      expandSelectionOutlinePx(shape) {
        const multiplier = shape.props.dash === "draw" ? 1.6 : 1;
        return STROKE_SIZES2[shape.props.size] * multiplier / 2 * shape.props.scale;
      }
    };
    __publicField(DrawShapeUtil, "type", "draw");
    __publicField(DrawShapeUtil, "props", drawShapeProps);
    __publicField(DrawShapeUtil, "migrations", drawShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/resizeBox.mjs
function resizeBox2(shape, info2, opts = {}) {
  const { newPoint, handle, scaleX, scaleY } = info2;
  const { minWidth = 1, maxWidth: maxWidth2 = Infinity, minHeight = 1, maxHeight: maxHeight2 = Infinity } = opts;
  let w2 = shape.props.w * scaleX;
  let h2 = shape.props.h * scaleY;
  const offset5 = new Vec(0, 0);
  if (w2 > 0) {
    if (w2 < minWidth) {
      switch (handle) {
        case "top_left":
        case "left":
        case "bottom_left": {
          offset5.x = w2 - minWidth;
          break;
        }
        case "top":
        case "bottom": {
          offset5.x = (w2 - minWidth) / 2;
          break;
        }
        default: {
          offset5.x = 0;
        }
      }
      w2 = minWidth;
    }
  } else {
    offset5.x = w2;
    w2 = -w2;
    if (w2 < minWidth) {
      switch (handle) {
        case "top_left":
        case "left":
        case "bottom_left": {
          offset5.x = -w2;
          break;
        }
        default: {
          offset5.x = -minWidth;
        }
      }
      w2 = minWidth;
    }
  }
  if (h2 > 0) {
    if (h2 < minHeight) {
      switch (handle) {
        case "top_left":
        case "top":
        case "top_right": {
          offset5.y = h2 - minHeight;
          break;
        }
        case "right":
        case "left": {
          offset5.y = (h2 - minHeight) / 2;
          break;
        }
        default: {
          offset5.y = 0;
        }
      }
      h2 = minHeight;
    }
  } else {
    offset5.y = h2;
    h2 = -h2;
    if (h2 < minHeight) {
      switch (handle) {
        case "top_left":
        case "top":
        case "top_right": {
          offset5.y = -h2;
          break;
        }
        default: {
          offset5.y = -minHeight;
        }
      }
      h2 = minHeight;
    }
  }
  const { x: x2, y: y2 } = offset5.rot(shape.rotation).add(newPoint);
  return {
    x: x2,
    y: y2,
    props: {
      w: Math.min(maxWidth2, w2),
      h: Math.min(maxHeight2, h2)
    }
  };
}
var init_resizeBox2 = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/resizeBox.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/embed/EmbedShapeUtil.mjs
function Gist({
  id,
  file,
  isInteractive,
  width,
  height,
  style,
  pageRotation
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("iframe", {
    className: "tl-embed",
    draggable: false,
    width: toDomPrecision(width),
    height: toDomPrecision(height),
    frameBorder: "0",
    scrolling: "no",
    seamless: true,
    referrerPolicy: "no-referrer-when-downgrade",
    style: {
      ...style,
      pointerEvents: isInteractive ? "all" : "none",
      zIndex: isInteractive ? "" : "-1",
      boxShadow: getRotatedBoxShadow(pageRotation)
    },
    srcDoc: `
			<html>
				<head>
					<base target="_blank">
				</head>
				<body>
					<script src=${`https://gist.github.com/${id}.js${file ? `?file=${file}` : ""}`}><\/script>
					<style type="text/css">
						* { margin: 0px; }
						table { height: 100%; background-color: red; }
						.gist { background-color: none; height: 100%;  }
						.gist .gist-file { height: calc(100vh - 2px); padding: 0px; display: grid; grid-template-rows: 1fr auto; }
					</style>
				</body>
			</html>`
  });
}
var import_jsx_runtime51, import_react53, getSandboxPermissions, EmbedShapeUtil;
var init_EmbedShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/embed/EmbedShapeUtil.mjs"() {
    import_jsx_runtime51 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react53 = __toESM(require_react(), 1);
    init_embeds();
    init_resizeBox2();
    init_rotated_box_shadow();
    getSandboxPermissions = (permissions) => {
      return Object.entries(permissions).filter(([_perm, isEnabled]) => isEnabled).map(([perm]) => perm).join(" ");
    };
    EmbedShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "hideSelectionBoundsFg", (shape) => !this.canResize(shape));
        __publicField(this, "canEdit", () => true);
        __publicField(this, "canResize", (shape) => {
          return !!getEmbedInfo(shape.props.url)?.definition?.doesResize;
        });
        __publicField(this, "canEditInReadOnly", () => true);
        __publicField(this, "isAspectRatioLocked", (shape) => {
          const embedInfo = getEmbedInfo(shape.props.url);
          return embedInfo?.definition.isAspectRatioLocked ?? false;
        });
        __publicField(this, "onResize", (shape, info2) => {
          const isAspectRatioLocked = this.isAspectRatioLocked(shape);
          const embedInfo = getEmbedInfo(shape.props.url);
          let minWidth = embedInfo?.definition.minWidth ?? 200;
          let minHeight = embedInfo?.definition.minHeight ?? 200;
          if (isAspectRatioLocked) {
            const aspectRatio = shape.props.w / shape.props.h;
            if (aspectRatio > 1) {
              minWidth *= aspectRatio;
            } else {
              minHeight /= aspectRatio;
            }
          }
          return resizeBox2(shape, info2, { minWidth, minHeight });
        });
      }
      getDefaultProps() {
        return {
          w: 300,
          h: 300,
          url: ""
        };
      }
      component(shape) {
        const { w: w2, h: h2, url } = shape.props;
        const isEditing = useIsEditing(shape.id);
        const embedInfo = (0, import_react53.useMemo)(() => getEmbedInfoUnsafely(url), [url]);
        const isHoveringWhileEditingSameShape = useValue("is hovering", () => {
          const { editingShapeId, hoveredShapeId } = this.editor.getCurrentPageState();
          if (editingShapeId && hoveredShapeId !== editingShapeId) {
            const editingShape = this.editor.getShape(editingShapeId);
            if (editingShape && this.editor.isShapeOfType(editingShape, "embed")) {
              return true;
            }
          }
          return false;
        }, []);
        const pageRotation = this.editor.getShapePageTransform(shape).rotation();
        const isInteractive = isEditing || isHoveringWhileEditingSameShape;
        const isIframe = typeof window !== "undefined" && (window !== window.top || window.self !== window.parent);
        if (isIframe && embedInfo?.definition.type === "tldraw")
          return null;
        if (embedInfo?.definition.type === "github_gist") {
          const idFromGistUrl = embedInfo.url.split("/").pop();
          if (!idFromGistUrl)
            throw Error("No gist id!");
          return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(HTMLContainer, { className: "tl-embed-container", id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Gist, {
            id: idFromGistUrl,
            width: toDomPrecision(w2),
            height: toDomPrecision(h2),
            isInteractive,
            pageRotation
          }) });
        }
        const sandbox = getSandboxPermissions({
          ...embedShapePermissionDefaults,
          ...embedInfo?.definition.overridePermissions ?? {}
        });
        return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(HTMLContainer, { className: "tl-embed-container", id: shape.id, children: embedInfo?.definition ? /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("iframe", {
          className: "tl-embed",
          sandbox,
          src: embedInfo.embedUrl,
          width: toDomPrecision(w2),
          height: toDomPrecision(h2),
          draggable: false,
          frameBorder: "0",
          referrerPolicy: "no-referrer-when-downgrade",
          style: {
            border: 0,
            pointerEvents: isInteractive ? "auto" : "none",
            zIndex: isInteractive ? "" : "-1",
            boxShadow: getRotatedBoxShadow(pageRotation),
            borderRadius: embedInfo?.definition.overrideOutlineRadius ?? 8,
            background: embedInfo?.definition.backgroundColor
          }
        }) : null });
      }
      indicator(shape) {
        const embedInfo = (0, import_react53.useMemo)(() => getEmbedInfo(shape.props.url), [shape.props.url]);
        return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("rect", {
          width: toDomPrecision(shape.props.w),
          height: toDomPrecision(shape.props.h),
          rx: embedInfo?.definition.overrideOutlineRadius ?? 8,
          ry: embedInfo?.definition.overrideOutlineRadius ?? 8
        });
      }
    };
    __publicField(EmbedShapeUtil, "type", "embed");
    __publicField(EmbedShapeUtil, "props", embedShapeProps);
    __publicField(EmbedShapeUtil, "migrations", embedShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/frame/components/FrameLabelInput.mjs
var import_jsx_runtime52, import_react54, FrameLabelInput;
var init_FrameLabelInput = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/frame/components/FrameLabelInput.mjs"() {
    import_jsx_runtime52 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react54 = __toESM(require_react(), 1);
    init_FrameShapeUtil();
    FrameLabelInput = (0, import_react54.forwardRef)(({ id, name, isEditing }, ref) => {
      const editor = useEditor();
      const handleKeyDown = (0, import_react54.useCallback)((e2) => {
        if (e2.key === "Enter" && !e2.nativeEvent.isComposing) {
          stopEventPropagation(e2);
          e2.currentTarget.blur();
          editor.setEditingShape(null);
        }
      }, [editor]);
      const handleBlur = (0, import_react54.useCallback)((e2) => {
        const shape = editor.getShape(id);
        if (!shape)
          return;
        const name2 = shape.props.name;
        const value = e2.currentTarget.value.trim();
        if (name2 === value)
          return;
        editor.updateShapes([
          {
            id,
            type: "frame",
            props: { name: value }
          }
        ]);
      }, [id, editor]);
      const handleChange = (0, import_react54.useCallback)((e2) => {
        const shape = editor.getShape(id);
        if (!shape)
          return;
        const name2 = shape.props.name;
        const value = e2.currentTarget.value;
        if (name2 === value)
          return;
        editor.updateShapes([
          {
            id,
            type: "frame",
            props: { name: value }
          }
        ]);
      }, [id, editor]);
      return /* @__PURE__ */ (0, import_jsx_runtime52.jsxs)("div", { className: `tl-frame-label ${isEditing ? "tl-frame-label__editing" : ""}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("input", {
          className: "tl-frame-name-input",
          ref,
          style: { display: isEditing ? void 0 : "none" },
          value: name,
          autoFocus: true,
          onKeyDown: handleKeyDown,
          onBlur: handleBlur,
          onChange: handleChange
        }),
        defaultEmptyAs(name, "Frame") + String.fromCharCode(8203)
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/frame/components/FrameHeading.mjs
var import_jsx_runtime53, import_react55, FrameHeading;
var init_FrameHeading = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/frame/components/FrameHeading.mjs"() {
    import_jsx_runtime53 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react55 = __toESM(require_react(), 1);
    init_FrameLabelInput();
    FrameHeading = function FrameHeading2({
      id,
      name,
      width,
      height
    }) {
      const editor = useEditor();
      const pageRotation = useValue("shape rotation", () => canonicalizeRotation(editor.getShapePageTransform(id).rotation()), [editor, id]);
      const isEditing = useIsEditing(id);
      const rInput = (0, import_react55.useRef)(null);
      const handlePointerDown = (0, import_react55.useCallback)((e2) => {
        const event = getPointerInfo(e2);
        e2.preventDefault();
        if (editor.getEditingShapeId() === id)
          return;
        editor.dispatch({
          type: "pointer",
          name: "pointer_down",
          target: "shape",
          shape: editor.getShape(id),
          ...event
        });
      }, [editor, id]);
      (0, import_react55.useEffect)(() => {
        const el = rInput.current;
        if (el && isEditing) {
          el.focus();
          el.select();
        }
      }, [rInput, isEditing]);
      const offsetRotation = pageRotation + Math.PI / 4;
      const scaledRotation = (offsetRotation * (2 / Math.PI) + 4) % 4;
      const labelSide = ["top", "left", "bottom", "right"][Math.floor(scaledRotation)];
      let labelTranslate;
      switch (labelSide) {
        case "top":
          labelTranslate = ``;
          break;
        case "right":
          labelTranslate = `translate(${toDomPrecision(width)}px, 0px) rotate(90deg)`;
          break;
        case "bottom":
          labelTranslate = `translate(${toDomPrecision(width)}px, ${toDomPrecision(height)}px) rotate(180deg)`;
          break;
        case "left":
          labelTranslate = `translate(0px, ${toDomPrecision(height)}px) rotate(270deg)`;
          break;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime53.jsx)("div", {
        className: "tl-frame-heading",
        style: {
          overflow: isEditing ? "visible" : "hidden",
          maxWidth: `calc(var(--tl-zoom) * ${labelSide === "top" || labelSide === "bottom" ? Math.ceil(width) : Math.ceil(height)}px + var(--space-5))`,
          bottom: "100%",
          transform: `${labelTranslate} scale(var(--tl-scale)) translateX(calc(-1 * var(--space-3))`
        },
        onPointerDown: handlePointerDown,
        children: /* @__PURE__ */ (0, import_jsx_runtime53.jsx)("div", { className: "tl-frame-heading-hit-area", children: /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(FrameLabelInput, { ref: rInput, id, name, isEditing }) })
      });
    };
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/frame/FrameShapeUtil.mjs
function defaultEmptyAs(str, dflt) {
  if (str.match(/^\s*$/)) {
    return dflt;
  }
  return str;
}
var import_jsx_runtime54, import_classnames17, FrameShapeUtil;
var init_FrameShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/frame/FrameShapeUtil.mjs"() {
    import_jsx_runtime54 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames17 = __toESM(require_classnames(), 1);
    init_createTextJsxFromSpans();
    init_useDefaultColorTheme();
    init_FrameHeading();
    FrameShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "canReceiveNewChildrenOfType", (shape, _type) => {
          return !shape.isLocked;
        });
        __publicField(this, "canDropShapes", (shape, _shapes) => {
          return !shape.isLocked;
        });
        __publicField(this, "onDragShapesOver", (frame3, shapes) => {
          if (!shapes.every((child) => child.parentId === frame3.id)) {
            this.editor.reparentShapes(shapes, frame3.id);
          }
        });
        __publicField(this, "onDragShapesOut", (_shape, shapes) => {
          const parent = this.editor.getShape(_shape.parentId);
          const isInGroup = parent && this.editor.isShapeOfType(parent, "group");
          if (isInGroup) {
            this.editor.reparentShapes(shapes, parent.id);
          } else {
            this.editor.reparentShapes(shapes, this.editor.getCurrentPageId());
          }
        });
        __publicField(this, "onResize", (shape, info2) => {
          return resizeBox(shape, info2);
        });
      }
      getDefaultProps() {
        return { w: 160 * 2, h: 90 * 2, name: "" };
      }
      getGeometry(shape) {
        return new Rectangle2d({
          width: shape.props.w,
          height: shape.props.h,
          isFilled: false
        });
      }
      component(shape) {
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        const theme = useDefaultColorTheme();
        const isCreating = useValue("is creating this shape", () => {
          const resizingState = this.editor.getStateDescendant("select.resizing");
          if (!resizingState)
            return false;
          if (!resizingState.getIsActive())
            return false;
          const info2 = resizingState?.info;
          if (!info2)
            return false;
          return info2.isCreating && this.editor.getOnlySelectedShapeId() === shape.id;
        }, [shape.id]);
        return /* @__PURE__ */ (0, import_jsx_runtime54.jsxs)(import_jsx_runtime54.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(SVGContainer, { children: /* @__PURE__ */ (0, import_jsx_runtime54.jsx)("rect", {
            className: (0, import_classnames17.default)("tl-frame__body", { "tl-frame__creating": isCreating }),
            width: bounds.width,
            height: bounds.height,
            fill: theme.solid,
            stroke: theme.text
          }) }),
          isCreating ? null : /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(FrameHeading, {
            id: shape.id,
            name: shape.props.name,
            width: bounds.width,
            height: bounds.height
          })
        ] });
      }
      toSvg(shape, ctx) {
        const theme = getDefaultColorTheme({ isDarkMode: ctx.isDarkMode });
        const pageRotation = canonicalizeRotation(this.editor.getShapePageTransform(shape.id).rotation());
        const offsetRotation = pageRotation + Math.PI / 4;
        const scaledRotation = (offsetRotation * (2 / Math.PI) + 4) % 4;
        const labelSide = Math.floor(scaledRotation);
        let labelTranslate;
        switch (labelSide) {
          case 0:
            labelTranslate = ``;
            break;
          case 3:
            labelTranslate = `translate(${toDomPrecision(shape.props.w)}, 0) rotate(90)`;
            break;
          case 2:
            labelTranslate = `translate(${toDomPrecision(shape.props.w)}, ${toDomPrecision(shape.props.h)}) rotate(180)`;
            break;
          case 1:
            labelTranslate = `translate(0, ${toDomPrecision(shape.props.h)}) rotate(270)`;
            break;
          default:
            throw Error("labelSide out of bounds");
        }
        const opts = {
          fontSize: 12,
          fontFamily: "Inter, sans-serif",
          textAlign: "start",
          width: shape.props.w,
          height: 32,
          padding: 0,
          lineHeight: 1,
          fontStyle: "normal",
          fontWeight: "normal",
          overflow: "truncate-ellipsis",
          verticalTextAlign: "middle"
        };
        const spans = this.editor.textMeasure.measureTextSpans(defaultEmptyAs(shape.props.name, "Frame") + String.fromCharCode(8203), opts);
        const firstSpan = spans[0];
        const lastSpan = last(spans);
        const labelTextWidth = lastSpan.box.w + lastSpan.box.x - firstSpan.box.x;
        const text = createTextJsxFromSpans(this.editor, spans, {
          offsetY: -opts.height - 2,
          ...opts
        });
        return /* @__PURE__ */ (0, import_jsx_runtime54.jsxs)(import_jsx_runtime54.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime54.jsx)("rect", {
            width: shape.props.w,
            height: shape.props.h,
            fill: theme.solid,
            stroke: theme.black.solid,
            strokeWidth: 1,
            rx: 1,
            ry: 1
          }),
          /* @__PURE__ */ (0, import_jsx_runtime54.jsxs)("g", { transform: labelTranslate, children: [
            /* @__PURE__ */ (0, import_jsx_runtime54.jsx)("rect", {
              x: -8,
              y: -opts.height - 4,
              width: labelTextWidth + 16,
              height: opts.height,
              fill: theme.background,
              rx: 4,
              ry: 4
            }),
            text
          ] })
        ] });
      }
      indicator(shape) {
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        return /* @__PURE__ */ (0, import_jsx_runtime54.jsx)("rect", {
          width: toDomPrecision(bounds.width),
          height: toDomPrecision(bounds.height),
          className: `tl-frame-indicator`
        });
      }
      providesBackgroundForChildren() {
        return true;
      }
    };
    __publicField(FrameShapeUtil, "type", "frame");
    __publicField(FrameShapeUtil, "props", frameShapeProps);
    __publicField(FrameShapeUtil, "migrations", frameShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/geo-shape-helpers.mjs
function getOvalPerimeter(h2, w2) {
  if (h2 > w2)
    return (PI * (w2 / 2) + (h2 - w2)) * 2;
  else
    return (PI * (h2 / 2) + (w2 - h2)) * 2;
}
function getHeartPath(w2, h2) {
  return getHeartParts(w2, h2).map((c2, i2) => c2.getSvgPathData(i2 === 0)).join(" ") + " Z";
}
function getDrawHeartPath(w2, h2, sw, id) {
  const o2 = w2 / 4;
  const k2 = h2 / 4;
  const random = rng(id);
  const mutDistance = sw * 0.75;
  const mut = (v2) => v2.addXY(random() * mutDistance, random() * mutDistance);
  const A2 = new Vec(w2 / 2, h2);
  const B = new Vec(0, k2 * 1.2);
  const C2 = new Vec(w2 / 2, k2 * 0.9);
  const D2 = new Vec(w2, k2 * 1.2);
  const Am = mut(new Vec(w2 / 2, h2));
  const Bm = mut(new Vec(0, k2 * 1.2));
  const Cm = mut(new Vec(w2 / 2, k2 * 0.9));
  const Dm = mut(new Vec(w2, k2 * 1.2));
  const parts = [
    new CubicBezier2d({
      start: A2,
      cp1: new Vec(o2 * 1.5, k2 * 3),
      cp2: new Vec(0, k2 * 2.5),
      end: B
    }),
    new CubicBezier2d({
      start: B,
      cp1: new Vec(0, -k2 * 0.32),
      cp2: new Vec(o2 * 1.85, -k2 * 0.32),
      end: C2
    }),
    new CubicBezier2d({
      start: C2,
      cp1: new Vec(o2 * 2.15, -k2 * 0.32),
      cp2: new Vec(w2, -k2 * 0.32),
      end: D2
    }),
    new CubicBezier2d({
      start: D2,
      cp1: new Vec(w2, k2 * 2.5),
      cp2: new Vec(o2 * 2.5, k2 * 3),
      end: Am
    }),
    new CubicBezier2d({
      start: Am,
      cp1: new Vec(o2 * 1.5, k2 * 3),
      cp2: new Vec(0, k2 * 2.5),
      end: Bm
    }),
    new CubicBezier2d({
      start: Bm,
      cp1: new Vec(0, -k2 * 0.32),
      cp2: new Vec(o2 * 1.85, -k2 * 0.32),
      end: Cm
    }),
    new CubicBezier2d({
      start: Cm,
      cp1: new Vec(o2 * 2.15, -k2 * 0.32),
      cp2: new Vec(w2, -k2 * 0.32),
      end: Dm
    }),
    new CubicBezier2d({
      start: Dm,
      cp1: new Vec(w2, k2 * 2.5),
      cp2: new Vec(o2 * 2.5, k2 * 3),
      end: A2
    })
  ];
  return parts.map((c2, i2) => c2.getSvgPathData(i2 === 0)).join(" ") + " Z";
}
function getHeartParts(w2, h2) {
  const o2 = w2 / 4;
  const k2 = h2 / 4;
  return [
    new CubicBezier2d({
      start: new Vec(w2 / 2, h2),
      cp1: new Vec(o2 * 1.5, k2 * 3),
      cp2: new Vec(0, k2 * 2.5),
      end: new Vec(0, k2 * 1.2)
    }),
    new CubicBezier2d({
      start: new Vec(0, k2 * 1.2),
      cp1: new Vec(0, -k2 * 0.32),
      cp2: new Vec(o2 * 1.85, -k2 * 0.32),
      end: new Vec(w2 / 2, k2 * 0.9)
    }),
    new CubicBezier2d({
      start: new Vec(w2 / 2, k2 * 0.9),
      cp1: new Vec(o2 * 2.15, -k2 * 0.32),
      cp2: new Vec(w2, -k2 * 0.32),
      end: new Vec(w2, k2 * 1.2)
    }),
    new CubicBezier2d({
      start: new Vec(w2, k2 * 1.2),
      cp1: new Vec(w2, k2 * 2.5),
      cp2: new Vec(o2 * 2.5, k2 * 3),
      end: new Vec(w2 / 2, h2)
    })
  ];
}
function getEllipseStrokeOptions(strokeWidth) {
  return {
    size: 1 + strokeWidth,
    thinning: 0.25,
    end: { taper: strokeWidth },
    start: { taper: strokeWidth },
    streamline: 0,
    smoothing: 1,
    simulatePressure: false
  };
}
function getEllipseStrokePoints(id, width, height, strokeWidth) {
  const getRandom = rng(id);
  const rx = width / 2;
  const ry = height / 2;
  const perimeter = perimeterOfEllipse(rx, ry);
  const points = [];
  const start2 = PI2 * getRandom();
  const length = PI2 + HALF_PI / 2 + Math.abs(getRandom()) * HALF_PI;
  const count3 = Math.max(16, perimeter / 10);
  for (let i2 = 0; i2 < count3; i2++) {
    const t3 = i2 / (count3 - 1);
    const r2 = start2 + t3 * length;
    const c2 = Math.cos(r2);
    const s2 = Math.sin(r2);
    points.push(new Vec(rx * c2 + width * 0.5 + 0.05 * getRandom(), ry * s2 + height / 2 + 0.05 * getRandom(), Math.min(1, 0.5 + Math.abs(0.5 - (getRandom() > 0 ? EASINGS.easeInOutSine(t3) : EASINGS.easeInExpo(t3))) / 2)));
  }
  return getStrokePoints(points, getEllipseStrokeOptions(strokeWidth));
}
function getEllipseDrawIndicatorPath(id, width, height, strokeWidth) {
  return getSvgPathFromStrokePoints(getEllipseStrokePoints(id, width, height, strokeWidth));
}
function getRoundedInkyPolygonPath(points) {
  let polylineA = `M`;
  const len = points.length;
  let p0;
  let p1;
  let p2;
  for (let i2 = 0, n2 = len; i2 < n2; i2 += 3) {
    p0 = points[i2];
    p1 = points[i2 + 1];
    p2 = points[i2 + 2];
    polylineA += `${precise(p0)}L${precise(p1)}Q${precise(p2)}`;
  }
  polylineA += `${precise(points[0])}`;
  return polylineA;
}
function getRoundedPolygonPoints(id, outline, offset5, roundness, passes) {
  const results = [];
  const random = rng(id);
  let p0 = outline[0];
  let p1;
  const len = outline.length;
  for (let i2 = 0, n2 = len * passes; i2 < n2; i2++) {
    p1 = Vec.AddXY(outline[(i2 + 1) % len], random() * offset5, random() * offset5);
    const delta = Vec.Sub(p1, p0);
    const distance = Vec.Len(delta);
    const vector = Vec.Div(delta, distance).mul(Math.min(distance / 4, roundness));
    results.push(Vec.Add(p0, vector), Vec.Add(p1, vector.neg()), p1);
    p0 = p1;
  }
  return results;
}
function getPillPoints(width, height, numPoints) {
  const radius = Math.min(width, height) / 2;
  const longSide = Math.max(width, height) - radius * 2;
  const circumference = Math.PI * (radius * 2) + 2 * longSide;
  const spacing = circumference / numPoints;
  const sections = width > height ? [
    {
      type: "straight",
      start: new Vec(radius, 0),
      delta: new Vec(1, 0)
    },
    {
      type: "arc",
      center: new Vec(width - radius, radius),
      startAngle: -PI / 2
    },
    {
      type: "straight",
      start: new Vec(width - radius, height),
      delta: new Vec(-1, 0)
    },
    {
      type: "arc",
      center: new Vec(radius, radius),
      startAngle: PI / 2
    }
  ] : [
    {
      type: "straight",
      start: new Vec(width, radius),
      delta: new Vec(0, 1)
    },
    {
      type: "arc",
      center: new Vec(radius, height - radius),
      startAngle: 0
    },
    {
      type: "straight",
      start: new Vec(0, height - radius),
      delta: new Vec(0, -1)
    },
    {
      type: "arc",
      center: new Vec(radius, radius),
      startAngle: PI
    }
  ];
  let sectionOffset = 0;
  const points = [];
  for (let i2 = 0; i2 < numPoints; i2++) {
    const section = sections[0];
    if (section.type === "straight") {
      points.push(Vec.Add(section.start, Vec.Mul(section.delta, sectionOffset)));
    } else {
      points.push(getPointOnCircle(section.center, radius, section.startAngle + sectionOffset / radius));
    }
    sectionOffset += spacing;
    let sectionLength = section.type === "straight" ? longSide : PI * radius;
    while (sectionOffset > sectionLength) {
      sectionOffset -= sectionLength;
      sections.push(sections.shift());
      sectionLength = sections[0].type === "straight" ? longSide : PI * radius;
    }
  }
  return points;
}
function getCloudArcs(width, height, seed, size4) {
  const getRandom = rng(seed);
  const pillCircumference = getOvalPerimeter(width, height);
  const numBumps = Math.max(Math.ceil(pillCircumference / SIZES[size4]), 6, Math.ceil(pillCircumference / Math.min(width, height)));
  const targetBumpProtrusion = pillCircumference / numBumps * BUMP_PROTRUSION;
  const innerWidth = Math.max(width - targetBumpProtrusion * 2, 1);
  const innerHeight = Math.max(height - targetBumpProtrusion * 2, 1);
  const innerCircumference = getOvalPerimeter(innerWidth, innerHeight);
  const distanceBetweenPointsOnPerimeter = innerCircumference / numBumps;
  const paddingX = (width - innerWidth) / 2;
  const paddingY = (height - innerHeight) / 2;
  const bumpPoints = getPillPoints(innerWidth, innerHeight, numBumps).map((p2) => {
    return p2.addXY(paddingX, paddingY);
  });
  const maxWiggleX = width < 20 ? 0 : targetBumpProtrusion * 0.3;
  const maxWiggleY = height < 20 ? 0 : targetBumpProtrusion * 0.3;
  const wiggledPoints = bumpPoints.slice(0);
  for (let i2 = 0; i2 < Math.floor(numBumps / 2); i2++) {
    wiggledPoints[i2] = Vec.AddXY(wiggledPoints[i2], getRandom() * maxWiggleX, getRandom() * maxWiggleY);
    wiggledPoints[numBumps - i2 - 1] = Vec.AddXY(wiggledPoints[numBumps - i2 - 1], getRandom() * maxWiggleX, getRandom() * maxWiggleY);
  }
  const arcs = [];
  for (let i2 = 0; i2 < wiggledPoints.length; i2++) {
    const j2 = i2 === wiggledPoints.length - 1 ? 0 : i2 + 1;
    const leftWigglePoint = wiggledPoints[i2];
    const rightWigglePoint = wiggledPoints[j2];
    const leftPoint = bumpPoints[i2];
    const rightPoint = bumpPoints[j2];
    const distanceBetweenOriginalPoints = Vec.Dist(leftPoint, rightPoint);
    const curvatureOffset = distanceBetweenPointsOnPerimeter - distanceBetweenOriginalPoints;
    const distanceBetweenWigglePoints = Vec.Dist(leftWigglePoint, rightWigglePoint);
    const relativeSize = distanceBetweenWigglePoints / distanceBetweenOriginalPoints;
    const finalDistance = (Math.max(paddingX, paddingY) + curvatureOffset) * relativeSize;
    const arcPoint = Vec.Lrp(leftPoint, rightPoint, 0.5).add(Vec.Sub(rightPoint, leftPoint).uni().per().mul(finalDistance));
    if (arcPoint.x < 0) {
      arcPoint.x = 0;
    } else if (arcPoint.x > width) {
      arcPoint.x = width;
    }
    if (arcPoint.y < 0) {
      arcPoint.y = 0;
    } else if (arcPoint.y > height) {
      arcPoint.y = height;
    }
    const center = centerOfCircleFromThreePoints(leftWigglePoint, rightWigglePoint, arcPoint);
    const radius = Vec.Dist(center ? center : Vec.Average([leftWigglePoint, rightWigglePoint]), leftWigglePoint);
    arcs.push({
      leftPoint: leftWigglePoint,
      rightPoint: rightWigglePoint,
      arcPoint,
      center,
      radius
    });
  }
  return arcs;
}
function cloudOutline(width, height, seed, size4) {
  const path = [];
  const arcs = getCloudArcs(width, height, seed, size4);
  for (const { center, radius, leftPoint, rightPoint } of arcs) {
    path.push(...getPointsOnArc(leftPoint, rightPoint, center, radius, 10));
  }
  return path;
}
function getCloudPath(width, height, seed, size4) {
  const arcs = getCloudArcs(width, height, seed, size4);
  let path = `M${arcs[0].leftPoint.toFixed()}`;
  for (const { leftPoint, rightPoint, radius, center } of arcs) {
    if (center === null) {
      path += ` L${rightPoint.toFixed()}`;
      continue;
    }
    const arc = Vec.Clockwise(leftPoint, rightPoint, center) ? "0" : "1";
    path += ` A${toDomPrecision(radius)},${toDomPrecision(radius)} 0 ${arc},1 ${rightPoint.toFixed()}`;
  }
  path += " Z";
  return path;
}
function inkyCloudSvgPath(width, height, seed, size4) {
  const getRandom = rng(seed);
  const mutMultiplier = DRAW_OFFSETS[size4];
  const arcs = getCloudArcs(width, height, seed, size4);
  const avgArcLengthSquared = arcs.reduce((sum, arc) => sum + Vec.Dist2(arc.leftPoint, arc.rightPoint), 0) / arcs.length;
  const shouldMutatePoints = avgArcLengthSquared > (mutMultiplier * 15) ** 2;
  const mutPoint = shouldMutatePoints ? (p2) => p2.addXY(getRandom() * mutMultiplier * 2, getRandom() * mutMultiplier * 2) : (p2) => p2;
  let pathA = `M${arcs[0].leftPoint.toFixed()}`;
  let leftMutPoint = mutPoint(arcs[0].leftPoint);
  let pathB = `M${leftMutPoint.toFixed()}`;
  for (const { leftPoint, center, rightPoint, radius, arcPoint } of arcs) {
    if (center === null) {
      pathA += ` L${rightPoint.toFixed()}`;
      const rightMutPoint2 = mutPoint(rightPoint);
      pathB += ` L${rightMutPoint2.toFixed()}`;
      leftMutPoint = rightMutPoint2;
      continue;
    }
    const arc = Vec.Clockwise(leftPoint, rightPoint, center) ? "0" : "1";
    pathA += ` A${toDomPrecision(radius)},${toDomPrecision(radius)} 0 ${arc},1 ${rightPoint.toFixed()}`;
    const rightMutPoint = mutPoint(rightPoint);
    const mutArcPoint = mutPoint(arcPoint);
    const mutCenter = centerOfCircleFromThreePoints(leftMutPoint, rightMutPoint, mutArcPoint);
    if (!Number.isFinite(mutCenter.x) || !Number.isFinite(mutCenter.y)) {
      pathB += ` L${rightMutPoint.toFixed()}`;
      leftMutPoint = rightMutPoint;
      continue;
    }
    const mutRadius = Math.abs(Vec.Dist(mutCenter, leftMutPoint));
    pathB += ` A${toDomPrecision(mutRadius)},${toDomPrecision(mutRadius)} 0 ${arc},1 ${rightMutPoint.toFixed()}`;
    leftMutPoint = rightMutPoint;
  }
  return pathA + pathB + " Z";
}
var SIZES, BUMP_PROTRUSION, DRAW_OFFSETS;
var init_geo_shape_helpers = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/geo-shape-helpers.mjs"() {
    init_dist_esm10();
    init_getStrokePoints();
    init_svg();
    init_dist_esm10();
    SIZES = {
      s: 50,
      m: 70,
      l: 100,
      xl: 130
    };
    BUMP_PROTRUSION = 0.2;
    DRAW_OFFSETS = {
      s: 0.5,
      m: 0.7,
      l: 0.9,
      xl: 1.6
    };
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/getLines.mjs
function getLines(props, sw) {
  switch (props.geo) {
    case "x-box": {
      return getXBoxLines(props.w, props.h, sw, props.dash);
    }
    case "check-box": {
      return getCheckBoxLines(props.w, props.h);
    }
    default: {
      return void 0;
    }
  }
}
function getXBoxLines(w2, h2, sw, dash) {
  const inset = dash === "draw" ? 0.62 : 0;
  if (dash === "dashed") {
    return [
      [new Vec(0, 0), new Vec(w2 / 2, h2 / 2)],
      [new Vec(w2, h2), new Vec(w2 / 2, h2 / 2)],
      [new Vec(0, h2), new Vec(w2 / 2, h2 / 2)],
      [new Vec(w2, 0), new Vec(w2 / 2, h2 / 2)]
    ];
  }
  const clampX = (x2) => Math.max(0, Math.min(w2, x2));
  const clampY = (y2) => Math.max(0, Math.min(h2, y2));
  return [
    [
      new Vec(clampX(sw * inset), clampY(sw * inset)),
      new Vec(clampX(w2 - sw * inset), clampY(h2 - sw * inset))
    ],
    [
      new Vec(clampX(sw * inset), clampY(h2 - sw * inset)),
      new Vec(clampX(w2 - sw * inset), clampY(sw * inset))
    ]
  ];
}
function getCheckBoxLines(w2, h2) {
  const size4 = Math.min(w2, h2) * 0.82;
  const ox = (w2 - size4) / 2;
  const oy = (h2 - size4) / 2;
  const clampX = (x2) => Math.max(0, Math.min(w2, x2));
  const clampY = (y2) => Math.max(0, Math.min(h2, y2));
  return [
    [
      new Vec(clampX(ox + size4 * 0.25), clampY(oy + size4 * 0.52)),
      new Vec(clampX(ox + size4 * 0.45), clampY(oy + size4 * 0.82))
    ],
    [
      new Vec(clampX(ox + size4 * 0.45), clampY(oy + size4 * 0.82)),
      new Vec(clampX(ox + size4 * 0.82), clampY(oy + size4 * 0.22))
    ]
  ];
}
var init_getLines = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/getLines.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/components/GeoShapeBody.mjs
function GeoShapeBody({ shape, shouldScale }) {
  const scaleToUse = shouldScale ? shape.props.scale : 1;
  const editor = useEditor();
  const theme = useDefaultColorTheme();
  const { id, props } = shape;
  const { w: w2, color, fill, dash, growY, size: size4 } = props;
  const strokeWidth = STROKE_SIZES2[size4] * scaleToUse;
  const h2 = props.h + growY;
  switch (props.geo) {
    case "cloud": {
      if (dash === "solid") {
        const d2 = getCloudPath(w2, h2, id, size4);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      } else if (dash === "draw") {
        const d2 = inkyCloudSvgPath(w2, h2, id, size4);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      } else {
        const d2 = getCloudPath(w2, h2, id, size4);
        const arcs = getCloudArcs(w2, h2, id, size4);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("g", {
            strokeWidth,
            stroke: theme[color].solid,
            fill: "none",
            pointerEvents: "all",
            children: arcs.map(({ leftPoint, rightPoint, center, radius }, i2) => {
              const arcLength = center ? radius * canonicalizeRotation(canonicalizeRotation(Vec.Angle(center, rightPoint)) - canonicalizeRotation(Vec.Angle(center, leftPoint))) : Vec.Dist(leftPoint, rightPoint);
              const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(arcLength, strokeWidth, {
                style: dash,
                start: "outset",
                end: "outset"
              });
              return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", {
                d: center ? `M${leftPoint.x},${leftPoint.y}A${radius},${radius},0,0,1,${rightPoint.x},${rightPoint.y}` : `M${leftPoint.x},${leftPoint.y}L${rightPoint.x},${rightPoint.y}`,
                strokeDasharray,
                strokeDashoffset
              }, i2);
            })
          })
        ] });
      }
    }
    case "ellipse": {
      const geometry = shouldScale ? editor.getShapeGeometry(shape) : editor.getShapeUtil(shape).getGeometry(shape);
      const d2 = geometry.getSvgPathData(true);
      if (dash === "dashed" || dash === "dotted") {
        const perimeter = geometry.length;
        const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(perimeter < 64 ? perimeter * 2 : perimeter, strokeWidth, {
          style: dash,
          snap: 4,
          closed: true
        });
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", {
            d: d2,
            strokeWidth,
            fill: "none",
            stroke: theme[color].solid,
            strokeDasharray,
            strokeDashoffset
          })
        ] });
      } else {
        const geometry2 = shouldScale ? editor.getShapeGeometry(shape) : editor.getShapeUtil(shape).getGeometry(shape);
        const d22 = geometry2.getSvgPathData(true);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d22, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d22, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      }
    }
    case "oval": {
      const geometry = shouldScale ? editor.getShapeGeometry(shape) : editor.getShapeUtil(shape).getGeometry(shape);
      const d2 = geometry.getSvgPathData(true);
      if (dash === "dashed" || dash === "dotted") {
        const perimeter = geometry.getLength();
        const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(perimeter < 64 ? perimeter * 2 : perimeter, strokeWidth, {
          style: dash,
          snap: 4,
          start: "outset",
          end: "outset",
          closed: true
        });
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", {
            d: d2,
            strokeWidth,
            fill: "none",
            stroke: theme[color].solid,
            strokeDasharray,
            strokeDashoffset
          })
        ] });
      } else {
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      }
    }
    case "heart": {
      if (dash === "dashed" || dash === "dotted" || dash === "solid") {
        const d2 = getHeartPath(w2, h2);
        const curves = getHeartParts(w2, h2);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          curves.map((c2, i2) => {
            const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(c2.length, strokeWidth, {
              style: dash,
              snap: 1,
              start: "outset",
              end: "outset",
              closed: true
            });
            return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", {
              d: c2.getSvgPathData(),
              strokeWidth,
              fill: "none",
              stroke: theme[color].solid,
              strokeDasharray,
              strokeDashoffset,
              pointerEvents: "all"
            }, `curve_${i2}`);
          })
        ] });
      } else {
        const d2 = getDrawHeartPath(w2, h2, strokeWidth, shape.id);
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      }
    }
    default: {
      const geometry = shouldScale ? editor.getShapeGeometry(shape) : editor.getShapeUtil(shape).getGeometry(shape);
      const outline = geometry instanceof Group2d ? geometry.children[0].vertices : geometry.vertices;
      const lines = getLines(shape.props, strokeWidth);
      if (dash === "solid") {
        let d2 = "M" + outline[0] + "L" + outline.slice(1) + "Z";
        if (lines) {
          for (const [A2, B] of lines) {
            d2 += `M${A2.x},${A2.y}L${B.x},${B.y}`;
          }
        }
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      } else if (dash === "dashed" || dash === "dotted") {
        const d2 = "M" + outline[0] + "L" + outline.slice(1) + "Z";
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, { theme, d: d2, color, fill, scale: scaleToUse }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)("g", {
            strokeWidth,
            stroke: theme[color].solid,
            fill: "none",
            pointerEvents: "all",
            children: [
              Array.from(Array(outline.length)).map((_2, i2) => {
                const A2 = Vec.ToFixed(outline[i2]);
                const B = Vec.ToFixed(outline[(i2 + 1) % outline.length]);
                const dist = Vec.Dist(A2, B);
                const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(dist, strokeWidth, {
                  style: dash,
                  start: "outset",
                  end: "outset"
                });
                return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("line", {
                  x1: A2.x,
                  y1: A2.y,
                  x2: B.x,
                  y2: B.y,
                  strokeDasharray,
                  strokeDashoffset
                }, i2);
              }),
              lines && lines.map(([A2, B], i2) => {
                const dist = Vec.Dist(A2, B);
                const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(dist, strokeWidth, {
                  style: dash,
                  start: "skip",
                  end: "skip",
                  snap: dash === "dotted" ? 4 : void 0
                });
                return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", {
                  d: `M${A2.x},${A2.y}L${B.x},${B.y}`,
                  stroke: theme[color].solid,
                  strokeWidth,
                  fill: "none",
                  strokeDasharray,
                  strokeDashoffset
                }, `line_fg_${i2}`);
              })
            ]
          })
        ] });
      } else if (dash === "draw") {
        let d2 = getRoundedInkyPolygonPath(getRoundedPolygonPoints(id, outline, strokeWidth / 3, strokeWidth * 2, 2));
        if (lines) {
          for (const [A2, B] of lines) {
            d2 += `M${A2.toFixed()}L${B.toFixed()}`;
          }
        }
        const innerPathData = getRoundedInkyPolygonPath(getRoundedPolygonPoints(id, outline, 0, strokeWidth * 2, 1));
        return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(ShapeFill, {
            theme,
            d: innerPathData,
            color,
            fill,
            scale: scaleToUse
          }),
          /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("path", { d: d2, stroke: theme[color].solid, strokeWidth, fill: "none" })
        ] });
      }
    }
  }
}
var import_jsx_runtime55;
var init_GeoShapeBody = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/components/GeoShapeBody.mjs"() {
    import_jsx_runtime55 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_ShapeFill();
    init_default_shape_constants();
    init_getPerfectDashProps2();
    init_useDefaultColorTheme();
    init_geo_shape_helpers();
    init_getLines();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/geo/GeoShapeUtil.mjs
function getUnscaledLabelSize(editor, shape) {
  const { text, font, size: size4, w: w2 } = shape.props;
  if (!text) {
    return { w: 0, h: 0 };
  }
  const minSize = editor.textMeasure.measureText("w", {
    ...TEXT_PROPS,
    fontFamily: FONT_FAMILIES[font],
    fontSize: LABEL_FONT_SIZES[size4],
    maxWidth: 100
  });
  const sizes = {
    s: 2,
    m: 3.5,
    l: 5,
    xl: 10
  };
  const textSize = editor.textMeasure.measureText(text, {
    ...TEXT_PROPS,
    fontFamily: FONT_FAMILIES[font],
    fontSize: LABEL_FONT_SIZES[size4],
    minWidth: minSize.w,
    maxWidth: Math.max(0, Math.ceil(minSize.w + sizes[size4]), Math.ceil(w2 / shape.props.scale - LABEL_PADDING * 2))
  });
  return {
    w: textSize.w + LABEL_PADDING * 2,
    h: textSize.h + LABEL_PADDING * 2
  };
}
var import_jsx_runtime56, MIN_SIZE_WITH_LABEL, GeoShapeUtil;
var init_GeoShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/geo/GeoShapeUtil.mjs"() {
    import_jsx_runtime56 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_HyperlinkButton();
    init_SvgTextLabel();
    init_TextLabel();
    init_default_shape_constants();
    init_defaultStyleDefs();
    init_useDefaultColorTheme();
    init_GeoShapeBody();
    init_geo_shape_helpers();
    init_getLines();
    MIN_SIZE_WITH_LABEL = 17 * 3;
    GeoShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "onEditEnd", (shape) => {
          const {
            id,
            type,
            props: { text }
          } = shape;
          if (text.trimEnd() !== shape.props.text) {
            this.editor.updateShapes([
              {
                id,
                type,
                props: {
                  text: text.trimEnd()
                }
              }
            ]);
          }
        });
        __publicField(this, "onResize", (shape, { handle, newPoint, scaleX, scaleY, initialShape }) => {
          const unscaledInitialW = initialShape.props.w / initialShape.props.scale;
          const unscaledInitialH = initialShape.props.h / initialShape.props.scale;
          const unscaledGrowY = initialShape.props.growY / initialShape.props.scale;
          let unscaledW = unscaledInitialW * scaleX;
          let unscaledH = (unscaledInitialH + unscaledGrowY) * scaleY;
          let overShrinkX = 0;
          let overShrinkY = 0;
          const min4 = MIN_SIZE_WITH_LABEL;
          if (shape.props.text.trim()) {
            let newW = Math.max(Math.abs(unscaledW), min4);
            let newH = Math.max(Math.abs(unscaledH), min4);
            if (newW < min4 && newH === min4)
              newW = min4;
            if (newW === min4 && newH < min4)
              newH = min4;
            const unscaledLabelSize = getUnscaledLabelSize(this.editor, {
              ...shape,
              props: {
                ...shape.props,
                w: newW * shape.props.scale,
                h: newH * shape.props.scale
              }
            });
            const nextW = Math.max(Math.abs(unscaledW), unscaledLabelSize.w) * Math.sign(unscaledW);
            const nextH = Math.max(Math.abs(unscaledH), unscaledLabelSize.h) * Math.sign(unscaledH);
            overShrinkX = Math.abs(nextW) - Math.abs(unscaledW);
            overShrinkY = Math.abs(nextH) - Math.abs(unscaledH);
            unscaledW = nextW;
            unscaledH = nextH;
          }
          const scaledW = unscaledW * shape.props.scale;
          const scaledH = unscaledH * shape.props.scale;
          const offset5 = new Vec(0, 0);
          if (scaleX < 0) {
            offset5.x += scaledW;
          }
          if (handle === "left" || handle === "top_left" || handle === "bottom_left") {
            offset5.x += scaleX < 0 ? overShrinkX : -overShrinkX;
          }
          if (scaleY < 0) {
            offset5.y += scaledH;
          }
          if (handle === "top" || handle === "top_left" || handle === "top_right") {
            offset5.y += scaleY < 0 ? overShrinkY : -overShrinkY;
          }
          const { x: x2, y: y2 } = offset5.rot(shape.rotation).add(newPoint);
          return {
            x: x2,
            y: y2,
            props: {
              w: Math.max(Math.abs(scaledW), 1),
              h: Math.max(Math.abs(scaledH), 1),
              growY: 0
            }
          };
        });
        __publicField(this, "onBeforeCreate", (shape) => {
          if (!shape.props.text) {
            if (shape.props.growY) {
              return {
                ...shape,
                props: {
                  ...shape.props,
                  growY: 0
                }
              };
            } else {
              return;
            }
          }
          const unscaledPrevHeight = shape.props.h / shape.props.scale;
          const unscaledNextHeight = getUnscaledLabelSize(this.editor, shape).h;
          let growY = null;
          if (unscaledNextHeight > unscaledPrevHeight) {
            growY = unscaledNextHeight - unscaledPrevHeight;
          } else {
            if (shape.props.growY) {
              growY = 0;
            }
          }
          if (growY !== null) {
            return {
              ...shape,
              props: {
                ...shape.props,
                growY: growY * shape.props.scale
              }
            };
          }
        });
        __publicField(this, "onBeforeUpdate", (prev, next) => {
          const prevText = prev.props.text;
          const nextText = next.props.text;
          if (prevText === nextText && prev.props.font === next.props.font && prev.props.size === next.props.size) {
            return;
          }
          if (prevText && !nextText) {
            return {
              ...next,
              props: {
                ...next.props,
                growY: 0
              }
            };
          }
          const unscaledPrevWidth = prev.props.w / prev.props.scale;
          const unscaledPrevHeight = prev.props.h / prev.props.scale;
          const unscaledPrevGrowY = prev.props.growY / prev.props.scale;
          const unscaledNextLabelSize = getUnscaledLabelSize(this.editor, next);
          if (!prevText && nextText && nextText.length === 1) {
            let unscaledW = Math.max(unscaledPrevWidth, unscaledNextLabelSize.w);
            let unscaledH = Math.max(unscaledPrevHeight, unscaledNextLabelSize.h);
            const min4 = MIN_SIZE_WITH_LABEL;
            if (unscaledPrevWidth < min4 && unscaledPrevHeight < min4) {
              unscaledW = Math.max(unscaledW, min4);
              unscaledH = Math.max(unscaledH, min4);
              unscaledW = Math.max(unscaledW, unscaledH);
              unscaledH = Math.max(unscaledW, unscaledH);
            }
            return {
              ...next,
              props: {
                ...next.props,
                w: unscaledW * next.props.scale,
                h: unscaledH * next.props.scale,
                growY: 0
              }
            };
          }
          let growY = null;
          if (unscaledNextLabelSize.h > unscaledPrevHeight) {
            growY = unscaledNextLabelSize.h - unscaledPrevHeight;
          } else {
            if (unscaledPrevGrowY) {
              growY = 0;
            }
          }
          if (growY !== null) {
            const unscaledNextWidth = next.props.w / next.props.scale;
            return {
              ...next,
              props: {
                ...next.props,
                growY: growY * next.props.scale,
                w: Math.max(unscaledNextWidth, unscaledNextLabelSize.w) * next.props.scale
              }
            };
          }
          if (unscaledNextLabelSize.w > unscaledPrevWidth) {
            return {
              ...next,
              props: {
                ...next.props,
                w: unscaledNextLabelSize.w * next.props.scale
              }
            };
          }
        });
        __publicField(this, "onDoubleClick", (shape) => {
          if (this.editor.inputs.altKey) {
            switch (shape.props.geo) {
              case "rectangle": {
                return {
                  ...shape,
                  props: {
                    geo: "check-box"
                  }
                };
              }
              case "check-box": {
                return {
                  ...shape,
                  props: {
                    geo: "rectangle"
                  }
                };
              }
            }
          }
          return;
        });
      }
      getDefaultProps() {
        return {
          w: 100,
          h: 100,
          geo: "rectangle",
          color: "black",
          labelColor: "black",
          fill: "none",
          dash: "draw",
          size: "m",
          font: "draw",
          text: "",
          align: "middle",
          verticalAlign: "middle",
          growY: 0,
          url: "",
          scale: 1
        };
      }
      getGeometry(shape) {
        const w2 = Math.max(1, shape.props.w);
        const h2 = Math.max(1, shape.props.h + shape.props.growY);
        const cx = w2 / 2;
        const cy = h2 / 2;
        const isFilled = shape.props.fill !== "none";
        let body;
        switch (shape.props.geo) {
          case "cloud": {
            body = new Polygon2d({
              points: cloudOutline(w2, h2, shape.id, shape.props.size),
              isFilled
            });
            break;
          }
          case "triangle": {
            body = new Polygon2d({
              points: [new Vec(cx, 0), new Vec(w2, h2), new Vec(0, h2)],
              isFilled
            });
            break;
          }
          case "diamond": {
            body = new Polygon2d({
              points: [new Vec(cx, 0), new Vec(w2, cy), new Vec(cx, h2), new Vec(0, cy)],
              isFilled
            });
            break;
          }
          case "pentagon": {
            body = new Polygon2d({
              points: getPolygonVertices(w2, h2, 5),
              isFilled
            });
            break;
          }
          case "hexagon": {
            body = new Polygon2d({
              points: getPolygonVertices(w2, h2, 6),
              isFilled
            });
            break;
          }
          case "octagon": {
            body = new Polygon2d({
              points: getPolygonVertices(w2, h2, 8),
              isFilled
            });
            break;
          }
          case "ellipse": {
            body = new Ellipse2d({
              width: w2,
              height: h2,
              isFilled
            });
            break;
          }
          case "oval": {
            body = new Stadium2d({
              width: w2,
              height: h2,
              isFilled
            });
            break;
          }
          case "star": {
            const sides2 = 5;
            const step = PI2 / sides2 / 2;
            const rightMostIndex = Math.floor(sides2 / 4) * 2;
            const leftMostIndex = sides2 * 2 - rightMostIndex;
            const topMostIndex = 0;
            const bottomMostIndex = Math.floor(sides2 / 2) * 2;
            const maxX = Math.cos(-HALF_PI + rightMostIndex * step) * w2 / 2;
            const minX = Math.cos(-HALF_PI + leftMostIndex * step) * w2 / 2;
            const minY = Math.sin(-HALF_PI + topMostIndex * step) * h2 / 2;
            const maxY = Math.sin(-HALF_PI + bottomMostIndex * step) * h2 / 2;
            const diffX = w2 - Math.abs(maxX - minX);
            const diffY = h2 - Math.abs(maxY - minY);
            const offsetX = w2 / 2 + minX - (w2 / 2 - maxX);
            const offsetY = h2 / 2 + minY - (h2 / 2 - maxY);
            const ratio = 1;
            const cx2 = (w2 - offsetX) / 2;
            const cy2 = (h2 - offsetY) / 2;
            const ox = (w2 + diffX) / 2;
            const oy = (h2 + diffY) / 2;
            const ix = ox * ratio / 2;
            const iy = oy * ratio / 2;
            body = new Polygon2d({
              points: Array.from(Array(sides2 * 2)).map((_2, i2) => {
                const theta = -HALF_PI + i2 * step;
                return new Vec(cx2 + (i2 % 2 ? ix : ox) * Math.cos(theta), cy2 + (i2 % 2 ? iy : oy) * Math.sin(theta));
              }),
              isFilled
            });
            break;
          }
          case "rhombus": {
            const offset5 = Math.min(w2 * 0.38, h2 * 0.38);
            body = new Polygon2d({
              points: [new Vec(offset5, 0), new Vec(w2, 0), new Vec(w2 - offset5, h2), new Vec(0, h2)],
              isFilled
            });
            break;
          }
          case "rhombus-2": {
            const offset5 = Math.min(w2 * 0.38, h2 * 0.38);
            body = new Polygon2d({
              points: [new Vec(0, 0), new Vec(w2 - offset5, 0), new Vec(w2, h2), new Vec(offset5, h2)],
              isFilled
            });
            break;
          }
          case "trapezoid": {
            const offset5 = Math.min(w2 * 0.38, h2 * 0.38);
            body = new Polygon2d({
              points: [new Vec(offset5, 0), new Vec(w2 - offset5, 0), new Vec(w2, h2), new Vec(0, h2)],
              isFilled
            });
            break;
          }
          case "arrow-right": {
            const ox = Math.min(w2, h2) * 0.38;
            const oy = h2 * 0.16;
            body = new Polygon2d({
              points: [
                new Vec(0, oy),
                new Vec(w2 - ox, oy),
                new Vec(w2 - ox, 0),
                new Vec(w2, h2 / 2),
                new Vec(w2 - ox, h2),
                new Vec(w2 - ox, h2 - oy),
                new Vec(0, h2 - oy)
              ],
              isFilled
            });
            break;
          }
          case "arrow-left": {
            const ox = Math.min(w2, h2) * 0.38;
            const oy = h2 * 0.16;
            body = new Polygon2d({
              points: [
                new Vec(ox, 0),
                new Vec(ox, oy),
                new Vec(w2, oy),
                new Vec(w2, h2 - oy),
                new Vec(ox, h2 - oy),
                new Vec(ox, h2),
                new Vec(0, h2 / 2)
              ],
              isFilled
            });
            break;
          }
          case "arrow-up": {
            const ox = w2 * 0.16;
            const oy = Math.min(w2, h2) * 0.38;
            body = new Polygon2d({
              points: [
                new Vec(w2 / 2, 0),
                new Vec(w2, oy),
                new Vec(w2 - ox, oy),
                new Vec(w2 - ox, h2),
                new Vec(ox, h2),
                new Vec(ox, oy),
                new Vec(0, oy)
              ],
              isFilled
            });
            break;
          }
          case "arrow-down": {
            const ox = w2 * 0.16;
            const oy = Math.min(w2, h2) * 0.38;
            body = new Polygon2d({
              points: [
                new Vec(ox, 0),
                new Vec(w2 - ox, 0),
                new Vec(w2 - ox, h2 - oy),
                new Vec(w2, h2 - oy),
                new Vec(w2 / 2, h2),
                new Vec(0, h2 - oy),
                new Vec(ox, h2 - oy)
              ],
              isFilled
            });
            break;
          }
          case "check-box":
          case "x-box":
          case "rectangle": {
            body = new Rectangle2d({
              width: w2,
              height: h2,
              isFilled
            });
            break;
          }
          case "heart": {
            const parts = getHeartParts(w2, h2);
            const points = parts.reduce((acc, part) => {
              acc.push(...part.vertices);
              return acc;
            }, []);
            body = new Polygon2d({
              points,
              isFilled
            });
            break;
          }
          default: {
            exhaustiveSwitchError(shape.props.geo);
          }
        }
        const unscaledlabelSize = getUnscaledLabelSize(this.editor, shape);
        const unscaledW = w2 / shape.props.scale;
        const unscaledH = h2 / shape.props.scale;
        const unscaledminWidth = Math.min(100, unscaledW / 2);
        const unscaledMinHeight = Math.min(LABEL_FONT_SIZES[shape.props.size] * TEXT_PROPS.lineHeight + LABEL_PADDING * 2, unscaledH / 2);
        const unscaledLabelWidth = Math.min(unscaledW, Math.max(unscaledlabelSize.w, Math.min(unscaledminWidth, Math.max(1, unscaledW - 8))));
        const unscaledLabelHeight = Math.min(unscaledH, Math.max(unscaledlabelSize.h, Math.min(unscaledMinHeight, Math.max(1, unscaledH - 8))));
        const lines = getLines(shape.props, STROKE_SIZES2[shape.props.size] * shape.props.scale);
        const edges = lines ? lines.map((line) => new Polyline2d({ points: line })) : [];
        return new Group2d({
          children: [
            body,
            new Rectangle2d({
              x: shape.props.align === "start" ? 0 : shape.props.align === "end" ? (unscaledW - unscaledLabelWidth) * shape.props.scale : (unscaledW - unscaledLabelWidth) / 2 * shape.props.scale,
              y: shape.props.verticalAlign === "start" ? 0 : shape.props.verticalAlign === "end" ? (unscaledH - unscaledLabelHeight) * shape.props.scale : (unscaledH - unscaledLabelHeight) / 2 * shape.props.scale,
              width: unscaledLabelWidth * shape.props.scale,
              height: unscaledLabelHeight * shape.props.scale,
              isFilled: true,
              isLabel: true
            }),
            ...edges
          ]
        });
      }
      getHandleSnapGeometry(shape) {
        const geometry = this.getGeometry(shape);
        const outline = geometry.children[0];
        switch (shape.props.geo) {
          case "arrow-down":
          case "arrow-left":
          case "arrow-right":
          case "arrow-up":
          case "check-box":
          case "diamond":
          case "hexagon":
          case "octagon":
          case "pentagon":
          case "rectangle":
          case "rhombus":
          case "rhombus-2":
          case "star":
          case "trapezoid":
          case "triangle":
          case "x-box":
            return { outline, points: [...outline.getVertices(), geometry.bounds.center] };
          case "cloud":
          case "ellipse":
          case "heart":
          case "oval":
            return { outline, points: [geometry.bounds.center] };
          default:
            exhaustiveSwitchError(shape.props.geo);
        }
      }
      component(shape) {
        const { id, type, props } = shape;
        const { fill, font, align, verticalAlign, size: size4, text } = props;
        const theme = useDefaultColorTheme();
        const isEditingAnything = this.editor.getEditingShapeId() !== null;
        const isOnlySelected = useValue("isGeoOnlySelected", () => shape.id === this.editor.getOnlySelectedShapeId(), []);
        const showHtmlContainer = isEditingAnything || shape.props.text;
        return /* @__PURE__ */ (0, import_jsx_runtime56.jsxs)(import_jsx_runtime56.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(SVGContainer, { id, children: /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(GeoShapeBody, { shape, shouldScale: true }) }),
          showHtmlContainer && /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(HTMLContainer, {
            style: {
              overflow: "hidden",
              width: shape.props.w,
              height: shape.props.h + props.growY
            },
            children: /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(TextLabel, {
              id,
              type,
              font,
              fontSize: LABEL_FONT_SIZES[size4] * shape.props.scale,
              lineHeight: TEXT_PROPS.lineHeight,
              padding: LABEL_PADDING * shape.props.scale,
              fill,
              align,
              verticalAlign,
              text,
              isSelected: isOnlySelected,
              labelColor: theme[props.labelColor].solid,
              wrap: true
            })
          }),
          shape.props.url && /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: this.editor.getZoomLevel() })
        ] });
      }
      indicator(shape) {
        const { id, props } = shape;
        const { w: w2, size: size4 } = props;
        const h2 = props.h + props.growY;
        const strokeWidth = STROKE_SIZES2[size4];
        const geometry = this.editor.getShapeGeometry(shape);
        switch (props.geo) {
          case "ellipse": {
            if (props.dash === "draw") {
              return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: getEllipseDrawIndicatorPath(id, w2, h2, strokeWidth) });
            }
            return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: geometry.getSvgPathData(true) });
          }
          case "heart": {
            return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: getHeartPath(w2, h2) });
          }
          case "oval": {
            return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: geometry.getSvgPathData(true) });
          }
          case "cloud": {
            return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: getCloudPath(w2, h2, id, size4) });
          }
          default: {
            const geometry2 = this.editor.getShapeGeometry(shape);
            const outline = geometry2 instanceof Group2d ? geometry2.children[0].vertices : geometry2.vertices;
            let path;
            if (props.dash === "draw") {
              const polygonPoints = getRoundedPolygonPoints(id, outline, 0, strokeWidth * 2 * shape.props.scale, 1);
              path = getRoundedInkyPolygonPath(polygonPoints);
            } else {
              path = "M" + outline[0] + "L" + outline.slice(1) + "Z";
            }
            const lines = getLines(shape.props, strokeWidth);
            if (lines) {
              for (const [A2, B] of lines) {
                path += `M${A2.x},${A2.y}L${B.x},${B.y}`;
              }
            }
            return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)("path", { d: path });
          }
        }
      }
      toSvg(shape, ctx) {
        const newShape = {
          ...shape,
          props: {
            ...shape.props,
            w: shape.props.w / shape.props.scale,
            h: shape.props.h / shape.props.scale
          }
        };
        const props = newShape.props;
        ctx.addExportDef(getFillDefForExport(props.fill));
        let textEl;
        if (props.text) {
          ctx.addExportDef(getFontDefForExport(props.font));
          const theme = getDefaultColorTheme(ctx);
          const bounds = new Box(0, 0, props.w, props.h + props.growY);
          textEl = /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(SvgTextLabel, {
            fontSize: LABEL_FONT_SIZES[props.size],
            font: props.font,
            align: props.align,
            verticalAlign: props.verticalAlign,
            text: props.text,
            labelColor: theme[props.labelColor].solid,
            bounds,
            padding: 16
          });
        }
        return /* @__PURE__ */ (0, import_jsx_runtime56.jsxs)(import_jsx_runtime56.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(GeoShapeBody, { shouldScale: false, shape: newShape }),
          textEl
        ] });
      }
      getCanvasSvgDefs() {
        return [getFillDefForCanvas()];
      }
    };
    __publicField(GeoShapeUtil, "type", "geo");
    __publicField(GeoShapeUtil, "props", geoShapeProps);
    __publicField(GeoShapeUtil, "migrations", geoShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/useColorSpace.mjs
function useColorSpace() {
  const [supportsP3, setSupportsP3] = (0, import_react56.useState)(false);
  (0, import_react56.useEffect)(() => {
    const supportsSyntax = CSS.supports("color", "color(display-p3 1 1 1)");
    const query = matchMedia("(color-gamut: p3)");
    setSupportsP3(supportsSyntax && query.matches);
    const onChange = () => setSupportsP3(supportsSyntax && query.matches);
    query.addEventListener("change", onChange);
    return () => query.removeEventListener("change", onChange);
  }, []);
  const forceSrgb = useValue(debugFlags.forceSrgb);
  return forceSrgb || !supportsP3 ? "srgb" : "p3";
}
var import_react56;
var init_useColorSpace = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/useColorSpace.mjs"() {
    init_dist_esm10();
    import_react56 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/highlight/HighlightShapeUtil.mjs
function getShapeDot(point) {
  const r2 = 0.1;
  return `M ${point.x} ${point.y} m -${r2}, 0 a ${r2},${r2} 0 1,0 ${r2 * 2},0 a ${r2},${r2} 0 1,0 -${r2 * 2},0`;
}
function getIndicatorDot(point, sw) {
  const r2 = sw / 2;
  return `M ${point.x} ${point.y} m -${r2}, 0 a ${r2},${r2} 0 1,0 ${r2 * 2},0 a ${r2},${r2} 0 1,0 -${r2 * 2},0`;
}
function getHighlightStrokePoints(shape, strokeWidth, forceSolid) {
  const allPointsFromSegments = getPointsFromSegments(shape.props.segments);
  const showAsComplete = shape.props.isComplete || last(shape.props.segments)?.type === "straight";
  let sw = strokeWidth;
  if (!forceSolid && !shape.props.isPen && allPointsFromSegments.length === 1) {
    sw += rng(shape.id)() * (strokeWidth / 6);
  }
  const options = getHighlightFreehandSettings({
    strokeWidth: sw,
    showAsComplete
  });
  const strokePoints = getStrokePoints(allPointsFromSegments, options);
  return { strokePoints, sw };
}
function getStrokeWidth(shape) {
  return FONT_SIZES[shape.props.size] * 1.12 * shape.props.scale;
}
function getIsDot2(shape) {
  return shape.props.segments.length === 1 && shape.props.segments[0].points.length < 2;
}
function HighlightRenderer({
  strokeWidth,
  forceSolid,
  shape,
  opacity
}) {
  const theme = useDefaultColorTheme();
  const allPointsFromSegments = getPointsFromSegments(shape.props.segments);
  let sw = strokeWidth;
  if (!forceSolid && !shape.props.isPen && allPointsFromSegments.length === 1) {
    sw += rng(shape.id)() * (sw / 6);
  }
  const options = getHighlightFreehandSettings({
    strokeWidth: sw,
    showAsComplete: shape.props.isComplete || last(shape.props.segments)?.type === "straight"
  });
  const strokePoints = getStrokePoints(allPointsFromSegments, options);
  const solidStrokePath = strokePoints.length > 1 ? getSvgPathFromStrokePoints(strokePoints, false) : getShapeDot(shape.props.segments[0].points[0]);
  const colorSpace = useColorSpace();
  const color = theme[shape.props.color].highlight[colorSpace];
  return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)("path", {
    d: solidStrokePath,
    strokeLinecap: "round",
    fill: "none",
    pointerEvents: "all",
    stroke: color,
    strokeWidth: sw,
    opacity
  });
}
function useHighlightForceSolid(editor, shape) {
  return useValue("forceSolid", () => {
    const sw = getStrokeWidth(shape);
    const zoomLevel = editor.getZoomLevel();
    if (sw / zoomLevel < 1.5) {
      return true;
    }
    return false;
  }, [editor]);
}
var import_jsx_runtime57, OVERLAY_OPACITY, UNDERLAY_OPACITY, HighlightShapeUtil;
var init_HighlightShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/highlight/HighlightShapeUtil.mjs"() {
    import_jsx_runtime57 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_getPath();
    init_default_shape_constants();
    init_getStrokeOutlinePoints();
    init_getStrokePoints();
    init_setStrokePointRadii();
    init_svg();
    init_useColorSpace();
    init_useDefaultColorTheme();
    OVERLAY_OPACITY = 0.35;
    UNDERLAY_OPACITY = 0.82;
    HighlightShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "hideResizeHandles", (shape) => getIsDot2(shape));
        __publicField(this, "hideRotateHandle", (shape) => getIsDot2(shape));
        __publicField(this, "hideSelectionBoundsFg", (shape) => getIsDot2(shape));
        __publicField(this, "onResize", (shape, info2) => {
          const { scaleX, scaleY } = info2;
          const newSegments = [];
          for (const segment of shape.props.segments) {
            newSegments.push({
              ...segment,
              points: segment.points.map(({ x: x2, y: y2, z }) => {
                return {
                  x: scaleX * x2,
                  y: scaleY * y2,
                  z
                };
              })
            });
          }
          return {
            props: {
              segments: newSegments
            }
          };
        });
      }
      getDefaultProps() {
        return {
          segments: [],
          color: "black",
          size: "m",
          isComplete: false,
          isPen: false,
          scale: 1
        };
      }
      getGeometry(shape) {
        const strokeWidth = getStrokeWidth(shape);
        if (getIsDot2(shape)) {
          return new Circle2d({
            x: -strokeWidth / 2,
            y: -strokeWidth / 2,
            radius: strokeWidth / 2,
            isFilled: true
          });
        }
        const { strokePoints, sw } = getHighlightStrokePoints(shape, strokeWidth, true);
        const opts = getHighlightFreehandSettings({ strokeWidth: sw, showAsComplete: true });
        setStrokePointRadii(strokePoints, opts);
        return new Polygon2d({
          points: getStrokeOutlinePoints(strokePoints, opts),
          isFilled: true
        });
      }
      component(shape) {
        const forceSolid = useHighlightForceSolid(this.editor, shape);
        const strokeWidth = getStrokeWidth(shape);
        return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(SVGContainer, { id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(HighlightRenderer, {
          shape,
          forceSolid,
          strokeWidth,
          opacity: OVERLAY_OPACITY
        }) });
      }
      backgroundComponent(shape) {
        const forceSolid = useHighlightForceSolid(this.editor, shape);
        const strokeWidth = getStrokeWidth(shape);
        return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(SVGContainer, { id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(HighlightRenderer, {
          shape,
          forceSolid,
          strokeWidth,
          opacity: UNDERLAY_OPACITY
        }) });
      }
      indicator(shape) {
        const forceSolid = useHighlightForceSolid(this.editor, shape);
        const strokeWidth = getStrokeWidth(shape);
        const { strokePoints, sw } = getHighlightStrokePoints(shape, strokeWidth, forceSolid);
        const allPointsFromSegments = getPointsFromSegments(shape.props.segments);
        let strokePath;
        if (strokePoints.length < 2) {
          strokePath = getIndicatorDot(allPointsFromSegments[0], sw);
        } else {
          strokePath = getSvgPathFromStrokePoints(strokePoints, false);
        }
        return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)("path", { d: strokePath });
      }
      toSvg(shape) {
        const strokeWidth = getStrokeWidth(shape);
        const forceSolid = strokeWidth < 1.5;
        const scaleFactor = 1 / shape.props.scale;
        return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)("g", { transform: `scale(${scaleFactor})`, children: /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(HighlightRenderer, {
          forceSolid,
          strokeWidth,
          shape,
          opacity: OVERLAY_OPACITY
        }) });
      }
      toBackgroundSvg(shape) {
        const strokeWidth = getStrokeWidth(shape);
        const forceSolid = strokeWidth < 1.5;
        const scaleFactor = 1 / shape.props.scale;
        return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)("g", { transform: `scale(${scaleFactor})`, children: /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(HighlightRenderer, {
          forceSolid,
          strokeWidth,
          shape,
          opacity: UNDERLAY_OPACITY
        }) });
      }
    };
    __publicField(HighlightShapeUtil, "type", "highlight");
    __publicField(HighlightShapeUtil, "props", highlightShapeProps);
    __publicField(HighlightShapeUtil, "migrations", highlightShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/BrokenAssetIcon.mjs
function BrokenAssetIcon() {
  return /* @__PURE__ */ (0, import_jsx_runtime58.jsxs)("svg", {
    width: "15",
    height: "15",
    viewBox: "0 0 30 30",
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    stroke: "currentColor",
    strokeLinecap: "round",
    strokeLinejoin: "round",
    children: [
      /* @__PURE__ */ (0, import_jsx_runtime58.jsx)("path", { d: "M3,11 L3,3 11,3", strokeWidth: "2" }),
      /* @__PURE__ */ (0, import_jsx_runtime58.jsx)("path", { d: "M19,27 L27,27 L27,19", strokeWidth: "2" }),
      /* @__PURE__ */ (0, import_jsx_runtime58.jsx)("path", { d: "M27,3 L3,27", strokeWidth: "2" })
    ]
  });
}
var import_jsx_runtime58;
var init_BrokenAssetIcon = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/BrokenAssetIcon.mjs"() {
    import_jsx_runtime58 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/useAsset.mjs
function useAsset(shapeId, assetId, width) {
  const editor = useEditor();
  const [url, setUrl] = (0, import_react57.useState)(null);
  const asset = assetId ? editor.getAsset(assetId) : null;
  const culledShapes = editor.getCulledShapes();
  const isCulled = culledShapes.has(shapeId);
  const didAlreadyResolve = (0, import_react57.useRef)(false);
  (0, import_react57.useEffect)(() => {
    if (url)
      didAlreadyResolve.current = true;
  }, [url]);
  const shapeScale = asset && "w" in asset.props ? width / asset.props.w : 1;
  const screenScale = useValue("zoom level", () => editor.getZoomLevel() * shapeScale, [
    editor,
    shapeScale
  ]);
  (0, import_react57.useEffect)(() => {
    if (isCulled)
      return;
    let isCancelled = false;
    const timer = editor.timers.setTimeout(async () => {
      const resolvedUrl = await editor.resolveAssetUrl(assetId, {
        screenScale
      });
      if (!isCancelled)
        setUrl(resolvedUrl);
    }, didAlreadyResolve.current ? 500 : 0);
    return () => {
      clearTimeout(timer);
      isCancelled = true;
    };
  }, [assetId, asset?.props.src, isCulled, screenScale, editor]);
  return { asset, url };
}
var import_react57;
var init_useAsset = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/useAsset.mjs"() {
    init_dist_esm10();
    import_react57 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/usePrefersReducedMotion.mjs
function usePrefersReducedMotion() {
  const [prefersReducedMotion, setPrefersReducedMotion] = (0, import_react58.useState)(false);
  (0, import_react58.useEffect)(() => {
    if (typeof window === "undefined" || !("matchMedia" in window))
      return;
    const mql = window.matchMedia("(prefers-reduced-motion: reduce)");
    const handler = () => {
      setPrefersReducedMotion(mql.matches);
    };
    handler();
    mql.addEventListener("change", handler);
    return () => mql.removeEventListener("change", handler);
  }, []);
  return prefersReducedMotion;
}
var import_react58;
var init_usePrefersReducedMotion = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/usePrefersReducedMotion.mjs"() {
    import_react58 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/image/ImageShapeUtil.mjs
async function getDataURIFromURL(url) {
  const response = await fetch2(url);
  const blob = await response.blob();
  return FileHelpers.blobToDataUrl(blob);
}
function getCroppedContainerStyle(shape) {
  const crop = shape.props.crop;
  const topLeft = crop?.topLeft;
  if (!topLeft) {
    return {
      width: shape.props.w,
      height: shape.props.h
    };
  }
  const w2 = 1 / (crop.bottomRight.x - crop.topLeft.x) * shape.props.w;
  const h2 = 1 / (crop.bottomRight.y - crop.topLeft.y) * shape.props.h;
  const offsetX = -topLeft.x * w2;
  const offsetY = -topLeft.y * h2;
  return {
    transform: `translate(${offsetX}px, ${offsetY}px)`,
    width: w2,
    height: h2
  };
}
var import_jsx_runtime59, import_classnames18, import_react59, ImageShapeUtil;
var init_ImageShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/image/ImageShapeUtil.mjs"() {
    import_jsx_runtime59 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames18 = __toESM(require_classnames(), 1);
    import_react59 = __toESM(require_react(), 1);
    init_BrokenAssetIcon();
    init_HyperlinkButton();
    init_useAsset();
    init_usePrefersReducedMotion();
    ImageShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "isAspectRatioLocked", () => true);
        __publicField(this, "canCrop", () => true);
        __publicField(this, "onResize", (shape, info2) => {
          let resized = resizeBox(shape, info2);
          const { flipX, flipY } = info2.initialShape.props;
          resized = {
            ...resized,
            props: {
              ...resized.props,
              flipX: info2.scaleX < 0 !== flipX,
              flipY: info2.scaleY < 0 !== flipY
            }
          };
          return resized;
        });
        __publicField(this, "onDoubleClick", (shape) => {
          const asset = shape.props.assetId ? this.editor.getAsset(shape.props.assetId) : void 0;
          if (!asset)
            return;
          const canPlay = asset.props.src && this.isAnimated(shape);
          if (!canPlay)
            return;
          this.editor.updateShapes([
            {
              type: "image",
              id: shape.id,
              props: {
                playing: !shape.props.playing
              }
            }
          ]);
        });
        __publicField(this, "onDoubleClickEdge", (shape) => {
          const props = shape.props;
          if (!props)
            return;
          if (this.editor.getCroppingShapeId() !== shape.id) {
            return;
          }
          const crop = structuredClone2(props.crop) || {
            topLeft: { x: 0, y: 0 },
            bottomRight: { x: 1, y: 1 }
          };
          const w2 = 1 / (crop.bottomRight.x - crop.topLeft.x) * shape.props.w;
          const h2 = 1 / (crop.bottomRight.y - crop.topLeft.y) * shape.props.h;
          const pointDelta = new Vec(crop.topLeft.x * w2, crop.topLeft.y * h2).rot(shape.rotation);
          const partial = {
            id: shape.id,
            type: shape.type,
            x: shape.x - pointDelta.x,
            y: shape.y - pointDelta.y,
            props: {
              crop: {
                topLeft: { x: 0, y: 0 },
                bottomRight: { x: 1, y: 1 }
              },
              w: w2,
              h: h2
            }
          };
          this.editor.updateShapes([partial]);
        });
      }
      getDefaultProps() {
        return {
          w: 100,
          h: 100,
          assetId: null,
          playing: true,
          url: "",
          crop: null,
          flipX: false,
          flipY: false
        };
      }
      isAnimated(shape) {
        const asset = shape.props.assetId ? this.editor.getAsset(shape.props.assetId) : void 0;
        if (!asset)
          return false;
        return "mimeType" in asset.props && MediaHelpers.isAnimatedImageType(asset?.props.mimeType) || "isAnimated" in asset.props && asset.props.isAnimated;
      }
      component(shape) {
        const isCropping = this.editor.getCroppingShapeId() === shape.id;
        const prefersReducedMotion = usePrefersReducedMotion();
        const [staticFrameSrc, setStaticFrameSrc] = (0, import_react59.useState)("");
        const [loadedSrc, setLoadedSrc] = (0, import_react59.useState)("");
        const isSelected = shape.id === this.editor.getOnlySelectedShapeId();
        const { asset, url } = useAsset(shape.id, shape.props.assetId, shape.props.w);
        (0, import_react59.useEffect)(() => {
          if (url) {
            let cancelled = false;
            const image = Image();
            image.onload = () => {
              if (cancelled)
                return;
              setLoadedSrc(url);
            };
            image.src = url;
            return () => {
              cancelled = true;
            };
          }
        }, [url, shape]);
        (0, import_react59.useEffect)(() => {
          if (url && this.isAnimated(shape)) {
            let cancelled = false;
            const image = Image();
            image.onload = () => {
              if (cancelled)
                return;
              const canvas = document.createElement("canvas");
              canvas.width = image.width;
              canvas.height = image.height;
              const ctx = canvas.getContext("2d");
              if (!ctx)
                return;
              ctx.drawImage(image, 0, 0);
              setStaticFrameSrc(canvas.toDataURL());
              setLoadedSrc(url);
            };
            image.crossOrigin = "anonymous";
            image.src = url;
            return () => {
              cancelled = true;
            };
          }
        }, [prefersReducedMotion, url, shape]);
        if (asset?.type === "bookmark") {
          throw Error("Bookmark assets can't be rendered as images");
        }
        const showCropPreview = isSelected && isCropping && this.editor.isIn("select.crop");
        const reduceMotion = prefersReducedMotion && (asset?.props.mimeType?.includes("video") || this.isAnimated(shape));
        const containerStyle = getCroppedContainerStyle(shape);
        if (!asset?.props.src) {
          return /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(HTMLContainer, {
            id: shape.id,
            style: {
              overflow: "hidden",
              width: shape.props.w,
              height: shape.props.h,
              color: "var(--color-text-3)",
              backgroundColor: asset ? "transparent" : "var(--color-low)",
              border: asset ? "none" : "1px solid var(--color-low-border)"
            },
            children: [
              /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("div", { className: "tl-image-container", style: containerStyle, children: asset ? null : /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(BrokenAssetIcon, {}) }),
              "url" in shape.props && shape.props.url && /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: this.editor.getZoomLevel() })
            ]
          });
        }
        if (!loadedSrc)
          return null;
        return /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(import_jsx_runtime59.Fragment, { children: [
          showCropPreview && /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("div", { style: containerStyle, children: /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("img", {
            className: "tl-image",
            crossOrigin: this.isAnimated(shape) ? "anonymous" : void 0,
            src: !shape.props.playing || reduceMotion ? staticFrameSrc : loadedSrc,
            referrerPolicy: "strict-origin-when-cross-origin",
            style: {
              opacity: 0.1
            },
            draggable: false
          }) }),
          /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(HTMLContainer, {
            id: shape.id,
            style: { overflow: "hidden", width: shape.props.w, height: shape.props.h },
            children: [
              /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)("div", { className: "tl-image-container", style: containerStyle, children: [
                /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("img", {
                  className: (0, import_classnames18.default)("tl-image", {
                    "tl-flip-x": shape.props.flipX && !shape.props.flipY,
                    "tl-flip-y": shape.props.flipY && !shape.props.flipX,
                    "tl-flip-xy": shape.props.flipY && shape.props.flipX
                  }),
                  crossOrigin: this.isAnimated(shape) ? "anonymous" : void 0,
                  src: !shape.props.playing || reduceMotion ? staticFrameSrc : loadedSrc,
                  referrerPolicy: "strict-origin-when-cross-origin",
                  draggable: false
                }),
                this.isAnimated(shape) && !shape.props.playing && /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("div", { className: "tl-image__tg", children: "GIF" })
              ] }),
              shape.props.url && /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: this.editor.getZoomLevel() })
            ]
          })
        ] });
      }
      indicator(shape) {
        const isCropping = this.editor.getCroppingShapeId() === shape.id;
        if (isCropping)
          return null;
        return /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("rect", { width: toDomPrecision(shape.props.w), height: toDomPrecision(shape.props.h) });
      }
      async toSvg(shape) {
        if (!shape.props.assetId)
          return null;
        const asset = this.editor.getAsset(shape.props.assetId);
        if (!asset)
          return null;
        let src = await this.editor.resolveAssetUrl(shape.props.assetId, {
          shouldResolveToOriginal: true
        });
        if (!src)
          return null;
        if (src.startsWith("blob:") || src.startsWith("http") || src.startsWith("/") || src.startsWith("./")) {
          src = await getDataURIFromURL(src) || "";
        }
        const containerStyle = getCroppedContainerStyle(shape);
        const crop = shape.props.crop;
        if (containerStyle.transform && crop) {
          const { transform, width, height } = containerStyle;
          const croppedWidth = (crop.bottomRight.x - crop.topLeft.x) * width;
          const croppedHeight = (crop.bottomRight.y - crop.topLeft.y) * height;
          const points = [
            new Vec(0, 0),
            new Vec(croppedWidth, 0),
            new Vec(croppedWidth, croppedHeight),
            new Vec(0, croppedHeight)
          ];
          const cropClipId = `cropClipPath_${shape.id.replace(":", "_")}`;
          return /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(import_jsx_runtime59.Fragment, { children: [
            /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("clipPath", { id: cropClipId, children: /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("polygon", { points: points.map((p2) => `${p2.x},${p2.y}`).join(" ") }) }) }),
            /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("g", { clipPath: `url(#${cropClipId})`, children: /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("image", { href: src, width, height, style: { transform } }) })
          ] });
        } else {
          return /* @__PURE__ */ (0, import_jsx_runtime59.jsx)("image", { href: src, width: shape.props.w, height: shape.props.h });
        }
      }
    };
    __publicField(ImageShapeUtil, "type", "image");
    __publicField(ImageShapeUtil, "props", imageShapeProps);
    __publicField(ImageShapeUtil, "migrations", imageShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/components/getLinePath.mjs
function getLineDrawFreehandOptions(strokeWidth) {
  return {
    size: strokeWidth,
    thinning: 0.4,
    streamline: 0,
    smoothing: 0.5,
    simulatePressure: true,
    last: true
  };
}
function getLineStrokePoints(shape, spline, strokeWidth) {
  const points = spline.vertices;
  const options = getLineDrawFreehandOptions(strokeWidth);
  return getStrokePoints(points, options);
}
function getLineDrawStrokeOutlinePoints(shape, spline, strokeWidth) {
  const options = getLineDrawFreehandOptions(strokeWidth);
  return getStrokeOutlinePoints(setStrokePointRadii(getLineStrokePoints(shape, spline, strokeWidth), options), options);
}
function getLineDrawPath(shape, spline, strokeWidth) {
  const stroke = getLineDrawStrokeOutlinePoints(shape, spline, strokeWidth);
  return getSvgPathFromPoints(stroke);
}
function getLineIndicatorPath(shape, spline, strokeWidth) {
  if (shape.props.dash === "draw") {
    const strokePoints = getLineStrokePoints(shape, spline, strokeWidth);
    return getSvgPathFromStrokePoints(strokePoints);
  }
  return spline.getSvgPathData();
}
var init_getLinePath = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/components/getLinePath.mjs"() {
    init_dist_esm10();
    init_getStrokeOutlinePoints();
    init_getStrokePoints();
    init_setStrokePointRadii();
    init_svg();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/line-helpers.mjs
function getDrawLinePathData(id, outline, strokeWidth) {
  let innerPathData = `M ${precise(outline[0])}L`;
  let outerPathData2 = `M ${precise(outline[0])}L`;
  const offset5 = strokeWidth / 3;
  const roundness = strokeWidth * 2;
  const random = rng(id);
  let p0 = outline[0];
  let p1;
  let s0 = outline[0];
  let s1;
  const len = outline.length;
  for (let i2 = 0, n2 = len - 1; i2 < n2; i2++) {
    p1 = outline[i2 + 1];
    s1 = Vec.AddXY(outline[i2 + 1], random() * offset5, random() * offset5);
    const delta = Vec.Sub(p1, p0);
    const distance = Vec.Len(delta);
    const vector = Vec.Div(delta, distance).mul(Math.min(distance / 4, roundness));
    const q0 = Vec.Add(p0, vector);
    const q1 = Vec.Add(p1, vector.neg());
    const sDelta = Vec.Sub(s1, s0);
    const sDistance = Vec.Len(sDelta);
    const sVector = Vec.Div(sDelta, sDistance).mul(Math.min(sDistance / 4, roundness));
    const sq0 = Vec.Add(s0, sVector);
    const sq1 = Vec.Add(s1, sVector.neg());
    if (i2 === n2 - 1) {
      innerPathData += `${precise(q0)}L ${precise(p1)}`;
      outerPathData2 += `${precise(sq0)}L ${precise(s1)}`;
    } else {
      innerPathData += `${precise(q0)}L ${precise(q1)}Q ${precise(p1)}`;
      outerPathData2 += `${precise(sq0)}L ${precise(sq1)}Q ${precise(s1)}`;
      p0 = p1;
      s0 = s1;
    }
  }
  return [innerPathData, innerPathData + outerPathData2];
}
var init_line_helpers = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/line-helpers.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/line/LineShapeUtil.mjs
function linePointsToArray(shape) {
  return Object.values(shape.props.points).sort(sortByIndex);
}
function getGeometryForLineShape(shape) {
  const points = linePointsToArray(shape).map(Vec.From);
  switch (shape.props.spline) {
    case "cubic": {
      return new CubicSpline2d({ points });
    }
    case "line": {
      return new Polyline2d({ points });
    }
  }
}
function LineShapeSvg({
  shape,
  shouldScale = false
}) {
  const theme = useDefaultColorTheme();
  const spline = getGeometryForLineShape(shape);
  const { dash, color, size: size4 } = shape.props;
  const scaleFactor = 1 / shape.props.scale;
  const scale = shouldScale ? scaleFactor : 1;
  const strokeWidth = STROKE_SIZES2[size4] * shape.props.scale;
  if (shape.props.spline === "line") {
    if (dash === "solid") {
      const outline = spline.points;
      const pathData = "M" + outline[0] + "L" + outline.slice(1);
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
        d: pathData,
        stroke: theme[color].solid,
        strokeWidth,
        fill: "none",
        transform: `scale(${scale})`
      });
    }
    if (dash === "dashed" || dash === "dotted") {
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("g", { stroke: theme[color].solid, strokeWidth, transform: `scale(${scale})`, children: spline.segments.map((segment, i2) => {
        const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(segment.length, strokeWidth, {
          style: dash,
          start: i2 > 0 ? "outset" : "none",
          end: i2 < spline.segments.length - 1 ? "outset" : "none"
        });
        return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
          strokeDasharray,
          strokeDashoffset,
          d: segment.getSvgPathData(true),
          fill: "none"
        }, i2);
      }) });
    }
    if (dash === "draw") {
      const outline = spline.points;
      const [_2, outerPathData] = getDrawLinePathData(shape.id, outline, strokeWidth);
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
        d: outerPathData,
        stroke: theme[color].solid,
        strokeWidth,
        fill: "none",
        transform: `scale(${scale})`
      });
    }
  }
  if (shape.props.spline === "cubic") {
    const splinePath = spline.getSvgPathData();
    if (dash === "solid") {
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
        strokeWidth,
        stroke: theme[color].solid,
        fill: "none",
        d: splinePath,
        transform: `scale(${scale})`
      });
    }
    if (dash === "dashed" || dash === "dotted") {
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("g", { stroke: theme[color].solid, strokeWidth, transform: `scale(${scale})`, children: spline.segments.map((segment, i2) => {
        const { strokeDasharray, strokeDashoffset } = getPerfectDashProps2(segment.length, strokeWidth, {
          style: dash,
          start: i2 > 0 ? "outset" : "none",
          end: i2 < spline.segments.length - 1 ? "outset" : "none"
        });
        return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
          strokeDasharray,
          strokeDashoffset,
          d: segment.getSvgPathData(),
          fill: "none"
        }, i2);
      }) });
    }
    if (dash === "draw") {
      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", {
        d: getLineDrawPath(shape, spline, strokeWidth),
        strokeWidth: 1,
        stroke: theme[color].solid,
        fill: theme[color].solid,
        transform: `scale(${scale})`
      });
    }
  }
}
var import_jsx_runtime60, handlesCache, LineShapeUtil;
var init_LineShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/line/LineShapeUtil.mjs"() {
    import_jsx_runtime60 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_default_shape_constants();
    init_getPerfectDashProps2();
    init_useDefaultColorTheme();
    init_getLinePath();
    init_line_helpers();
    handlesCache = new WeakCache();
    LineShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "hideResizeHandles", () => true);
        __publicField(this, "hideRotateHandle", () => true);
        __publicField(this, "hideSelectionBoundsFg", () => true);
        __publicField(this, "hideSelectionBoundsBg", () => true);
        __publicField(this, "onResize", (shape, info2) => {
          const { scaleX, scaleY } = info2;
          return {
            props: {
              points: mapObjectMapValues(shape.props.points, (_2, { id, index: index3, x: x2, y: y2 }) => ({
                id,
                index: index3,
                x: x2 * scaleX,
                y: y2 * scaleY
              }))
            }
          };
        });
        __publicField(this, "onHandleDrag", (shape, { handle }) => {
          if (handle.type !== "vertex")
            return;
          return {
            ...shape,
            props: {
              ...shape.props,
              points: {
                ...shape.props.points,
                [handle.id]: { id: handle.id, index: handle.index, x: handle.x, y: handle.y }
              }
            }
          };
        });
      }
      getDefaultProps() {
        const [start2, end2] = getIndices(2);
        return {
          dash: "draw",
          size: "m",
          color: "black",
          spline: "line",
          points: {
            [start2]: { id: start2, index: start2, x: 0, y: 0 },
            [end2]: { id: end2, index: end2, x: 0.1, y: 0.1 }
          },
          scale: 1
        };
      }
      getGeometry(shape) {
        return getGeometryForLineShape(shape);
      }
      getHandles(shape) {
        return handlesCache.get(shape.props, () => {
          const spline = getGeometryForLineShape(shape);
          const points = linePointsToArray(shape);
          const results = points.map((point) => ({
            ...point,
            id: point.index,
            type: "vertex",
            canSnap: true
          }));
          for (let i2 = 0; i2 < points.length - 1; i2++) {
            const index3 = getIndexBetween(points[i2].index, points[i2 + 1].index);
            const segment = spline.segments[i2];
            const point = segment.midPoint();
            results.push({
              id: index3,
              type: "create",
              index: index3,
              x: point.x,
              y: point.y,
              canSnap: true
            });
          }
          return results.sort(sortByIndex);
        });
      }
      component(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(SVGContainer, { id: shape.id, children: /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(LineShapeSvg, { shape }) });
      }
      indicator(shape) {
        const strokeWidth = STROKE_SIZES2[shape.props.size] * shape.props.scale;
        const spline = getGeometryForLineShape(shape);
        const { dash } = shape.props;
        let path;
        if (shape.props.spline === "line") {
          const outline = spline.points;
          if (dash === "solid" || dash === "dotted" || dash === "dashed") {
            path = "M" + outline[0] + "L" + outline.slice(1);
          } else {
            const [innerPathData] = getDrawLinePathData(shape.id, outline, strokeWidth);
            path = innerPathData;
          }
        } else {
          path = getLineIndicatorPath(shape, spline, strokeWidth);
        }
        return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)("path", { d: path });
      }
      toSvg(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(LineShapeSvg, { shouldScale: true, shape });
      }
      getHandleSnapGeometry(shape) {
        const points = linePointsToArray(shape);
        return {
          points,
          getSelfSnapPoints: (handle) => {
            const index3 = this.getHandles(shape).filter((h2) => h2.type === "vertex").findIndex((h2) => h2.id === handle.id);
            return points.filter((_2, i2) => Math.abs(i2 - index3) > 1).map(Vec.From);
          },
          getSelfSnapOutline: (handle) => {
            const index3 = this.getHandles(shape).filter((h2) => h2.type === "vertex").findIndex((h2) => h2.id === handle.id);
            const segments = getGeometryForLineShape(shape).segments.filter((_2, i2) => i2 !== index3 - 1 && i2 !== index3);
            if (!segments.length)
              return null;
            return new Group2d({ children: segments });
          }
        };
      }
      getInterpolatedProps(startShape, endShape, progress) {
        const startPoints = linePointsToArray(startShape);
        const endPoints = linePointsToArray(endShape);
        const pointsToUseStart = [];
        const pointsToUseEnd = [];
        let index3 = ZERO_INDEX_KEY;
        if (startPoints.length > endPoints.length) {
          for (let i2 = 0; i2 < startPoints.length; i2++) {
            pointsToUseStart[i2] = { ...startPoints[i2] };
            if (endPoints[i2] === void 0) {
              pointsToUseEnd[i2] = { ...endPoints[endPoints.length - 1], id: index3 };
            } else {
              pointsToUseEnd[i2] = { ...endPoints[i2], id: index3 };
            }
            index3 = getIndexAbove(index3);
          }
        } else if (endPoints.length > startPoints.length) {
          for (let i2 = 0; i2 < endPoints.length; i2++) {
            pointsToUseEnd[i2] = { ...endPoints[i2] };
            if (startPoints[i2] === void 0) {
              pointsToUseStart[i2] = {
                ...startPoints[startPoints.length - 1],
                id: index3
              };
            } else {
              pointsToUseStart[i2] = { ...startPoints[i2], id: index3 };
            }
            index3 = getIndexAbove(index3);
          }
        } else {
          for (let i2 = 0; i2 < endPoints.length; i2++) {
            pointsToUseStart[i2] = startPoints[i2];
            pointsToUseEnd[i2] = endPoints[i2];
          }
        }
        return {
          ...endShape.props,
          points: Object.fromEntries(pointsToUseStart.map((point, i2) => {
            const endPoint = pointsToUseEnd[i2];
            return [
              point.id,
              {
                ...point,
                x: lerp(point.x, endPoint.x, progress),
                y: lerp(point.y, endPoint.y, progress)
              }
            ];
          }))
        };
      }
    };
    __publicField(LineShapeUtil, "type", "line");
    __publicField(LineShapeUtil, "props", lineShapeProps);
    __publicField(LineShapeUtil, "migrations", lineShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/asset-urls.mjs
function AssetUrlsProvider({
  assetUrls,
  children
}) {
  (0, import_react60.useEffect)(() => {
    for (const src of Object.values(assetUrls.icons)) {
      const image = Image();
      image.src = src;
      image.decode();
    }
    for (const src of Object.values(assetUrls.embedIcons)) {
      const image = Image();
      image.src = src;
      image.decode();
    }
  }, [assetUrls]);
  return /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(AssetUrlsContext.Provider, { value: assetUrls, children });
}
function useAssetUrls() {
  const assetUrls = (0, import_react60.useContext)(AssetUrlsContext);
  if (!assetUrls) {
    throw new Error("useAssetUrls must be used within an AssetUrlsProvider");
  }
  return assetUrls;
}
var import_jsx_runtime61, import_react60, AssetUrlsContext;
var init_asset_urls = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/asset-urls.mjs"() {
    import_jsx_runtime61 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react60 = __toESM(require_react(), 1);
    AssetUrlsContext = (0, import_react60.createContext)(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/defaultTranslation.mjs
var DEFAULT_TRANSLATION;
var init_defaultTranslation = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/defaultTranslation.mjs"() {
    DEFAULT_TRANSLATION = {
      "action.convert-to-bookmark": "Convert to Bookmark",
      "action.convert-to-embed": "Convert to Embed",
      "action.open-embed-link": "Open link",
      "action.align-bottom": "Align bottom",
      "action.align-center-horizontal": "Align horizontally",
      "action.align-center-vertical": "Align vertically",
      "action.align-center-horizontal.short": "Align H",
      "action.align-center-vertical.short": "Align V",
      "action.align-left": "Align left",
      "action.align-right": "Align right",
      "action.align-top": "Align top",
      "action.back-to-content": "Back to content",
      "action.bring-forward": "Bring forward",
      "action.bring-to-front": "Bring to front",
      "action.copy-as-json.short": "JSON",
      "action.copy-as-json": "Copy as JSON",
      "action.copy-as-png.short": "PNG",
      "action.copy-as-png": "Copy as PNG",
      "action.copy-as-svg.short": "SVG",
      "action.copy-as-svg": "Copy as SVG",
      "action.copy": "Copy",
      "action.cut": "Cut",
      "action.delete": "Delete",
      "action.unlock-all": "Unlock all",
      "action.distribute-horizontal": "Distribute horizontally",
      "action.distribute-vertical": "Distribute vertically",
      "action.distribute-horizontal.short": "Distribute H",
      "action.distribute-vertical.short": "Distribute V",
      "action.duplicate": "Duplicate",
      "action.edit-link": "Edit link",
      "action.exit-pen-mode": "Exit pen mode",
      "action.export-as-json.short": "JSON",
      "action.export-as-json": "Export as JSON",
      "action.export-as-png.short": "PNG",
      "action.export-as-png": "Export as PNG",
      "action.export-as-svg.short": "SVG",
      "action.export-as-svg": "Export as SVG",
      "action.export-all-as-json.short": "JSON",
      "action.export-all-as-json": "Export as JSON",
      "action.export-all-as-png.short": "PNG",
      "action.export-all-as-png": "Export as PNG",
      "action.export-all-as-svg.short": "SVG",
      "action.export-all-as-svg": "Export as SVG",
      "action.fit-frame-to-content": "Fit to content",
      "action.flip-horizontal": "Flip horizontally",
      "action.flip-vertical": "Flip vertically",
      "action.flip-horizontal.short": "Flip H",
      "action.flip-vertical.short": "Flip V",
      "action.fork-project": "Fork this project",
      "action.fork-project-on-tldraw": "Fork project on tldraw",
      "action.group": "Group",
      "action.insert-embed": "Insert embed",
      "action.insert-media": "Upload media",
      "action.leave-shared-project": "Leave shared project",
      "action.new-project": "New project",
      "action.new-shared-project": "New shared project",
      "action.open-cursor-chat": "Cursor chat",
      "action.open-file": "Open file",
      "action.pack": "Pack",
      "action.paste": "Paste",
      "action.paste-error-title": "Pasting failed",
      "action.paste-error-description": "Could not paste due to missing clipboard permissions. Please enable the permissions and try again.",
      "action.print": "Print",
      "action.redo": "Redo",
      "action.remove-frame": "Remove frame",
      "action.rename": "Rename",
      "action.rotate-ccw": "Rotate counterclockwise",
      "action.rotate-cw": "Rotate clockwise",
      "action.save-copy": "Save a copy",
      "action.select-all": "Select all",
      "action.select-none": "Select none",
      "action.send-backward": "Send backward",
      "action.send-to-back": "Send to back",
      "action.share-project": "Share this project",
      "action.stack-horizontal": "Stack horizontally",
      "action.stack-vertical": "Stack vertically",
      "action.stack-horizontal.short": "Stack H",
      "action.stack-vertical.short": "Stack V",
      "action.stop-following": "Stop following",
      "action.stretch-horizontal": "Stretch horizontally",
      "action.stretch-vertical": "Stretch vertically",
      "action.stretch-horizontal.short": "Stretch H",
      "action.stretch-vertical.short": "Stretch V",
      "action.toggle-auto-size": "Toggle auto size",
      "action.toggle-dark-mode.menu": "Dark mode",
      "action.toggle-dark-mode": "Toggle dark mode",
      "action.toggle-paste-at-cursor.menu": "Paste at cursor",
      "action.toggle-paste-at-cursor": "Toggle paste at cursor",
      "action.toggle-wrap-mode.menu": "Select on wrap",
      "action.toggle-wrap-mode": "Toggle Select on wrap",
      "action.toggle-reduce-motion.menu": "Reduce motion",
      "action.toggle-reduce-motion": "Toggle reduce motion",
      "action.toggle-edge-scrolling.menu": "Edge scrolling",
      "action.toggle-edge-scrolling": "Toggle edge scrolling",
      "action.toggle-debug-mode.menu": "Debug mode",
      "action.toggle-debug-mode": "Toggle debug mode",
      "action.toggle-focus-mode.menu": "Focus mode",
      "action.toggle-focus-mode": "Toggle focus mode",
      "action.toggle-dynamic-size-mode.menu": "Dynamic size",
      "action.toggle-dynamic-size-mode": "Toggle dynamic size",
      "action.toggle-grid.menu": "Show grid",
      "action.toggle-grid": "Toggle grid",
      "action.toggle-lock": "Toggle locked",
      "action.flatten-to-image": "Flatten",
      "action.toggle-snap-mode.menu": "Always snap",
      "action.toggle-snap-mode": "Toggle always snap",
      "action.toggle-tool-lock.menu": "Tool lock",
      "action.toggle-tool-lock": "Toggle tool lock",
      "action.toggle-transparent.context-menu": "Transparent",
      "action.toggle-transparent.menu": "Transparent",
      "action.toggle-transparent": "Toggle transparent background",
      "action.undo": "Undo",
      "action.ungroup": "Ungroup",
      "action.zoom-in": "Zoom in",
      "action.zoom-out": "Zoom out",
      "action.zoom-to-100": "Zoom to 100%",
      "action.zoom-to-fit": "Zoom to fit",
      "action.zoom-to-selection": "Zoom to selection",
      "assets.files.size-too-big": "File size is too big",
      "assets.files.type-not-allowed": "File type is not allowed",
      "assets.files.upload-failed": "Upload failed",
      "assets.url.failed": "Couldn't load URL preview",
      "theme.dark": "Dark",
      "theme.light": "Light",
      "theme.system": "System",
      "color-style.white": "White",
      "color-style.black": "Black",
      "color-style.blue": "Blue",
      "color-style.green": "Green",
      "color-style.grey": "Grey",
      "color-style.light-blue": "Light blue",
      "color-style.light-green": "Light green",
      "color-style.light-red": "Light red",
      "color-style.light-violet": "Light violet",
      "color-style.orange": "Orange",
      "color-style.red": "Red",
      "color-style.violet": "Violet",
      "color-style.yellow": "Yellow",
      "fill-style.none": "None",
      "document.default-name": "Untitled",
      "fill-style.semi": "Semi",
      "fill-style.solid": "Solid",
      "fill-style.pattern": "Pattern",
      "fill-style.fill": "Fill",
      "dash-style.dashed": "Dashed",
      "dash-style.dotted": "Dotted",
      "dash-style.draw": "Draw",
      "dash-style.solid": "Solid",
      "size-style.s": "Small",
      "size-style.m": "Medium",
      "size-style.l": "Large",
      "size-style.xl": "Extra large",
      "opacity-style.0.1": "10%",
      "opacity-style.0.25": "25%",
      "opacity-style.0.5": "50%",
      "opacity-style.0.75": "75%",
      "opacity-style.1": "100%",
      "font-style.draw": "Draw",
      "font-style.sans": "Sans",
      "font-style.serif": "Serif",
      "font-style.mono": "Mono",
      "align-style.start": "Start",
      "align-style.middle": "Middle",
      "align-style.end": "End",
      "align-style.justify": "Justify",
      "verticalAlign-style.start": "Top",
      "verticalAlign-style.middle": "Middle",
      "verticalAlign-style.end": "Bottom",
      "geo-style.arrow-down": "Arrow down",
      "geo-style.arrow-left": "Arrow left",
      "geo-style.arrow-right": "Arrow right",
      "geo-style.arrow-up": "Arrow up",
      "geo-style.diamond": "Diamond",
      "geo-style.ellipse": "Ellipse",
      "geo-style.hexagon": "Hexagon",
      "geo-style.octagon": "Octagon",
      "geo-style.oval": "Oval",
      "geo-style.cloud": "Cloud",
      "geo-style.pentagon": "Pentagon",
      "geo-style.rectangle": "Rectangle",
      "geo-style.rhombus-2": "Rhombus 2",
      "geo-style.rhombus": "Rhombus",
      "geo-style.star": "Star",
      "geo-style.trapezoid": "Trapezoid",
      "geo-style.triangle": "Triangle",
      "geo-style.x-box": "X box",
      "geo-style.check-box": "Check box",
      "arrowheadStart-style.none": "None",
      "arrowheadStart-style.arrow": "Arrow",
      "arrowheadStart-style.bar": "Bar",
      "arrowheadStart-style.diamond": "Diamond",
      "arrowheadStart-style.dot": "Dot",
      "arrowheadStart-style.inverted": "Inverted",
      "arrowheadStart-style.pipe": "Pipe",
      "arrowheadStart-style.square": "Square",
      "arrowheadStart-style.triangle": "Triangle",
      "arrowheadEnd-style.none": "None",
      "arrowheadEnd-style.arrow": "Arrow",
      "arrowheadEnd-style.bar": "Bar",
      "arrowheadEnd-style.diamond": "Diamond",
      "arrowheadEnd-style.dot": "Dot",
      "arrowheadEnd-style.inverted": "Inverted",
      "arrowheadEnd-style.pipe": "Pipe",
      "arrowheadEnd-style.square": "Square",
      "arrowheadEnd-style.triangle": "Triangle",
      "spline-style.line": "Line",
      "spline-style.cubic": "Cubic",
      "tool.select": "Select",
      "tool.hand": "Hand",
      "tool.draw": "Draw",
      "tool.eraser": "Eraser",
      "tool.arrow-down": "Arrow down",
      "tool.arrow-left": "Arrow left",
      "tool.arrow-right": "Arrow right",
      "tool.arrow-up": "Arrow up",
      "tool.arrow": "Arrow",
      "tool.cloud": "Cloud",
      "tool.diamond": "Diamond",
      "tool.ellipse": "Ellipse",
      "tool.hexagon": "Hexagon",
      "tool.highlight": "Highlight",
      "tool.line": "Line",
      "tool.octagon": "Octagon",
      "tool.oval": "Oval",
      "tool.pentagon": "Pentagon",
      "tool.rectangle": "Rectangle",
      "tool.rhombus": "Rhombus",
      "tool.star": "Star",
      "tool.trapezoid": "Trapezoid",
      "tool.triangle": "Triangle",
      "tool.x-box": "X box",
      "tool.check-box": "Check box",
      "tool.asset": "Asset",
      "tool.frame": "Frame",
      "tool.note": "Note",
      "tool.laser": "Laser",
      "tool.embed": "Embed",
      "tool.text": "Text",
      "menu.title": "Menu",
      "menu.theme": "Theme",
      "menu.copy-as": "Copy as",
      "menu.edit": "Edit",
      "menu.export-as": "Export as",
      "menu.file": "File",
      "menu.language": "Language",
      "menu.preferences": "Preferences",
      "menu.help": "Help",
      "menu.view": "View",
      "context-menu.edit": "Edit",
      "context-menu.arrange": "Arrange",
      "context-menu.copy-as": "Copy as",
      "context-menu.export-as": "Export as",
      "context-menu.export-all-as": "Export",
      "context-menu.move-to-page": "Move to page",
      "context-menu.reorder": "Reorder",
      "page-menu.title": "Pages",
      "page-menu.create-new-page": "Create new page",
      "page-menu.max-page-count-reached": "Max pages reached",
      "page-menu.new-page-initial-name": "Page 1",
      "page-menu.edit-start": "Edit",
      "page-menu.edit-done": "Done",
      "page-menu.go-to-page": "Go to page",
      "page-menu.submenu.rename": "Rename",
      "page-menu.submenu.duplicate-page": "Duplicate",
      "page-menu.submenu.title": "Menu",
      "page-menu.submenu.move-down": "Move down",
      "page-menu.submenu.move-up": "Move up",
      "page-menu.submenu.delete": "Delete",
      "share-menu.title": "Share",
      "share-menu.save-note": "Download this project to your computer as a .tldr file.",
      "share-menu.fork-note": "Create a new shared project based on this snapshot.",
      "share-menu.share-project": "Share this project",
      "share-menu.default-project-name": "Shared Project",
      "share-menu.copy-link": "Copy editor link",
      "share-menu.readonly-link": "Read-only",
      "share-menu.create-snapshot-link": "Copy snapshot link",
      "share-menu.snapshot-link-note": "Capture and share this project as a read-only snapshot link.",
      "share-menu.copy-readonly-link": "Copy viewer link",
      "share-menu.offline-note": "Create a new shared project based on your current project.",
      "share-menu.copy-link-note": "Anyone with the link will be able to view and edit this project.",
      "share-menu.copy-readonly-link-note": "Anyone with the link will be able to access this project.",
      "share-menu.project-too-large": "Sorry, this project can't be shared because it's too large. We're working on it!",
      "share-menu.upload-failed": "Sorry, we couldn't upload your project at the moment. Please try again or let us know if the problem persists.",
      "share-menu.creating-project": "Creating the new project\u2026",
      "share-menu.copied": "Copied link",
      "status.offline": "Offline",
      "status.online": "Online",
      "people-menu.title": "People",
      "people-menu.change-name": "Change name",
      "people-menu.change-color": "Change color",
      "people-menu.follow": "Following",
      "people-menu.following": "Following",
      "people-menu.leading": "Following You",
      "people-menu.user": "(You)",
      "people-menu.invite": "Invite others",
      "help-menu.title": "Help and resources",
      "help-menu.about": "About",
      "help-menu.docs": "Documentation & API",
      "help-menu.discord": "Discord",
      "help-menu.github": "GitHub",
      "help-menu.keyboard-shortcuts": "Keyboard shortcuts",
      "help-menu.twitter": "Twitter",
      "actions-menu.title": "Actions",
      "edit-link-dialog.title": "Edit link",
      "edit-link-dialog.invalid-url": "A link must be a valid URL.",
      "edit-link-dialog.detail": "Links will open in a new tab.",
      "edit-link-dialog.url": "URL",
      "edit-link-dialog.clear": "Clear",
      "edit-link-dialog.save": "Continue",
      "edit-link-dialog.cancel": "Cancel",
      "embed-dialog.title": "Insert embed",
      "embed-dialog.back": "Back",
      "embed-dialog.create": "Create",
      "embed-dialog.cancel": "Cancel",
      "embed-dialog.url": "URL",
      "embed-dialog.instruction": "Paste in the site's URL to create the embed.",
      "embed-dialog.invalid-url": "We could not create an embed from that URL.",
      "edit-pages-dialog.move-down": "Move down",
      "edit-pages-dialog.move-up": "Move up",
      "shortcuts-dialog.title": "Keyboard shortcuts",
      "shortcuts-dialog.edit": "Edit",
      "shortcuts-dialog.file": "File",
      "shortcuts-dialog.preferences": "Preferences",
      "shortcuts-dialog.tools": "Tools",
      "shortcuts-dialog.transform": "Transform",
      "shortcuts-dialog.view": "View",
      "shortcuts-dialog.collaboration": "Collaboration",
      "home-project-dialog.title": "Home project",
      "home-project-dialog.description": "This is your local home project. It's just for you!",
      "rename-project-dialog.title": "Rename project",
      "rename-project-dialog.cancel": "Cancel",
      "rename-project-dialog.rename": "Rename",
      "home-project-dialog.ok": "Ok",
      "style-panel.title": "Styles",
      "style-panel.align": "Align",
      "style-panel.vertical-align": "Vertical align",
      "style-panel.position": "Position",
      "style-panel.arrowheads": "Arrows",
      "style-panel.arrowhead-start": "Start",
      "style-panel.arrowhead-end": "End",
      "style-panel.color": "Color",
      "style-panel.dash": "Dash",
      "style-panel.fill": "Fill",
      "style-panel.font": "Font",
      "style-panel.geo": "Shape",
      "style-panel.mixed": "Mixed",
      "style-panel.opacity": "Opacity",
      "style-panel.size": "Size",
      "style-panel.spline": "Spline",
      "tool-panel.drawing": "Drawing",
      "tool-panel.shapes": "Shapes",
      "tool-panel.more": "More",
      "debug-panel.more": "More",
      "navigation-zone.toggle-minimap": "Toggle minimap",
      "navigation-zone.zoom": "Zoom",
      "focus-mode.toggle-focus-mode": "Toggle focus mode",
      "toast.close": "Close",
      "file-system.file-open-error.title": "Could not open file",
      "file-system.file-open-error.not-a-tldraw-file": "The file you tried to open doesn't look like a tldraw file.",
      "file-system.file-open-error.file-format-version-too-new": "The file you tried to open is from a newer version of tldraw. Please reload the page and try again.",
      "file-system.file-open-error.generic-corrupted-file": "The file you tried to open is corrupted.",
      "file-system.confirm-open.title": "Overwrite current project?",
      "file-system.confirm-open.description": "Opening a file will replace your current project and any unsaved changes will be lost. Are you sure you want to continue?",
      "file-system.confirm-open.cancel": "Cancel",
      "file-system.confirm-open.open": "Open file",
      "file-system.confirm-open.dont-show-again": "Don't ask again",
      "file-system.confirm-clear.title": "Clear current project?",
      "file-system.confirm-clear.description": "Creating a new project will clear your current project and any unsaved changes will be lost. Are you sure you want to continue?",
      "file-system.confirm-clear.cancel": "Cancel",
      "file-system.confirm-clear.continue": "Continue",
      "file-system.confirm-clear.dont-show-again": "Don't ask again",
      "file-system.shared-document-file-open-error.title": "Could not open file",
      "file-system.shared-document-file-open-error.description": "Opening files from shared projects is not supported.",
      "sharing.confirm-leave.title": "Leave current project?",
      "sharing.confirm-leave.description": "Are you sure you want to leave this shared project? You can return to it by navigating to its URL.",
      "sharing.confirm-leave.cancel": "Cancel",
      "sharing.confirm-leave.leave": "Leave",
      "sharing.confirm-leave.dont-show-again": "Don't ask again",
      "toast.error.export-fail.title": "Failed export",
      "toast.error.export-fail.desc": "Failed to export image",
      "toast.error.copy-fail.title": "Failed copy",
      "toast.error.copy-fail.desc": "Failed to copy image",
      "context.pages.new-page": "New page",
      "vscode.file-open.desc": "We've updated this document to work with the current version of tldraw. If you'd like to keep the original version (which will work on old.tldraw.com), click below to create a backup.",
      "vscode.file-open.open": "Continue",
      "vscode.file-open.backup": "Backup",
      "vscode.file-open.backup-saved": "Backup saved",
      "vscode.file-open.backup-failed": "Backup failed: this is not a .tldr file.",
      "vscode.file-open.dont-show-again": "Don't ask again",
      "cursor-chat.type-to-chat": "Type to chat..."
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/translations.mjs
async function fetchTranslation(locale, assetUrls) {
  const mainRes = await fetch2(assetUrls.translations.en);
  if (!mainRes.ok) {
    console.warn(`No main translations found.`);
    return EN_TRANSLATION;
  }
  if (locale === "en") {
    return EN_TRANSLATION;
  }
  const language = LANGUAGES.find((t3) => t3.locale === locale);
  if (!language) {
    console.warn(`No translation found for locale ${locale}`);
    return EN_TRANSLATION;
  }
  const res = await fetch2(assetUrls.translations[language.locale]);
  const messages = await res.json();
  if (!messages) {
    console.warn(`No messages found for locale ${locale}`);
    return EN_TRANSLATION;
  }
  const missing = [];
  for (const key in EN_TRANSLATION.messages) {
    if (!messages[key]) {
      missing.push(key);
    }
  }
  if (missing.length > 0 && false) {
    console.warn(`Language ${locale}: missing messages for keys:
${missing.join("\n")}`);
  }
  return {
    locale,
    label: language.label,
    dir: RTL_LANGUAGES.has(language.locale) ? "rtl" : "ltr",
    messages: { ...EN_TRANSLATION.messages, ...messages }
  };
}
var RTL_LANGUAGES, EN_TRANSLATION;
var init_translations2 = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/translations.mjs"() {
    init_dist_esm10();
    init_defaultTranslation();
    RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "fa", "he", "ur", "ku"]);
    EN_TRANSLATION = {
      locale: "en",
      label: "English",
      messages: DEFAULT_TRANSLATION,
      dir: "ltr"
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/useTranslation.mjs
function useCurrentTranslation() {
  const translations = React16.useContext(TranslationsContext);
  if (!translations) {
    throw new Error("useCurrentTranslation must be used inside of <TldrawUiContextProvider />");
  }
  return translations;
}
function useTranslation() {
  const translation = useCurrentTranslation();
  return React16.useCallback(function msg2(id) {
    return translation.messages[id] ?? id;
  }, [translation]);
}
function untranslated(string2) {
  return string2;
}
var import_jsx_runtime62, React16, TranslationsContext, TranslationProvider;
var init_useTranslation = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useTranslation/useTranslation.mjs"() {
    import_jsx_runtime62 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    React16 = __toESM(require_react(), 1);
    init_asset_urls();
    init_defaultTranslation();
    init_translations2();
    TranslationsContext = React16.createContext(null);
    TranslationProvider = track(function TranslationProvider2({
      overrides,
      children
    }) {
      const editor = useEditor();
      const locale = editor.user.getLocale();
      const getAssetUrl = useAssetUrls();
      const [currentTranslation, setCurrentTranslation] = React16.useState(() => {
        if (overrides && overrides["en"]) {
          return {
            locale: "en",
            label: "English",
            dir: "ltr",
            messages: { ...DEFAULT_TRANSLATION, ...overrides["en"] }
          };
        }
        return {
          locale: "en",
          label: "English",
          dir: "ltr",
          messages: DEFAULT_TRANSLATION
        };
      });
      React16.useEffect(() => {
        let isCancelled = false;
        async function loadTranslation() {
          const translation = await fetchTranslation(locale, getAssetUrl);
          if (translation && !isCancelled) {
            if (overrides && overrides[locale]) {
              setCurrentTranslation({
                ...translation,
                messages: { ...translation.messages, ...overrides[locale] }
              });
            } else {
              setCurrentTranslation(translation);
            }
          }
        }
        loadTranslation();
        return () => {
          isCancelled = true;
        };
      }, [getAssetUrl, locale, overrides]);
      return /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(TranslationsContext.Provider, { value: currentTranslation, children });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/note/NoteShapeUtil.mjs
function getNoteSizeAdjustments(editor, shape) {
  const { labelHeight, fontSizeAdjustment } = getLabelSize(editor, shape);
  const growY = Math.max(0, labelHeight - NOTE_SIZE);
  if (growY !== shape.props.growY || fontSizeAdjustment !== shape.props.fontSizeAdjustment) {
    return {
      ...shape,
      props: {
        ...shape.props,
        growY,
        fontSizeAdjustment
      }
    };
  }
}
function getNoteLabelSize(editor, shape) {
  const { text } = shape.props;
  if (!text) {
    const minHeight = LABEL_FONT_SIZES[shape.props.size] * TEXT_PROPS.lineHeight + LABEL_PADDING * 2;
    return { labelHeight: minHeight, labelWidth: 100, fontSizeAdjustment: 0 };
  }
  const unadjustedFontSize = LABEL_FONT_SIZES[shape.props.size];
  let fontSizeAdjustment = 0;
  let iterations = 0;
  let labelHeight = NOTE_SIZE;
  let labelWidth = NOTE_SIZE;
  const FUZZ = 1;
  do {
    fontSizeAdjustment = Math.min(unadjustedFontSize, unadjustedFontSize - iterations);
    const nextTextSize = editor.textMeasure.measureText(text, {
      ...TEXT_PROPS,
      fontFamily: FONT_FAMILIES[shape.props.font],
      fontSize: fontSizeAdjustment,
      maxWidth: NOTE_SIZE - LABEL_PADDING * 2 - FUZZ,
      disableOverflowWrapBreaking: true
    });
    labelHeight = nextTextSize.h + LABEL_PADDING * 2;
    labelWidth = nextTextSize.w + LABEL_PADDING * 2;
    if (fontSizeAdjustment <= 14) {
      const nextTextSizeWithOverflowBreak = editor.textMeasure.measureText(text, {
        ...TEXT_PROPS,
        fontFamily: FONT_FAMILIES[shape.props.font],
        fontSize: fontSizeAdjustment,
        maxWidth: NOTE_SIZE - LABEL_PADDING * 2 - FUZZ
      });
      labelHeight = nextTextSizeWithOverflowBreak.h + LABEL_PADDING * 2;
      labelWidth = nextTextSizeWithOverflowBreak.w + LABEL_PADDING * 2;
      break;
    }
    if (nextTextSize.scrollWidth.toFixed(0) === nextTextSize.w.toFixed(0)) {
      break;
    }
  } while (iterations++ < 50);
  return {
    labelHeight,
    labelWidth,
    fontSizeAdjustment
  };
}
function getLabelSize(editor, shape) {
  return labelSizesForNote.get(shape, () => getNoteLabelSize(editor, shape));
}
function useNoteKeydownHandler(id) {
  const editor = useEditor();
  const translation = useCurrentTranslation();
  return (0, import_react61.useCallback)((e2) => {
    const shape = editor.getShape(id);
    if (!shape)
      return;
    const isTab = e2.key === "Tab";
    const isCmdEnter = (e2.metaKey || e2.ctrlKey) && e2.key === "Enter";
    if (isTab || isCmdEnter) {
      e2.preventDefault();
      const pageTransform = editor.getShapePageTransform(id);
      const pageRotation = pageTransform.rotation();
      const isRTL2 = !!(translation.dir === "rtl" || isRightToLeftLanguage(shape.props.text));
      const offsetLength = (NOTE_SIZE + editor.options.adjacentShapeMargin + (isCmdEnter && !e2.shiftKey ? shape.props.growY : 0)) * shape.props.scale;
      const adjacentCenter = new Vec(isTab ? e2.shiftKey != isRTL2 ? -1 : 1 : 0, isCmdEnter ? e2.shiftKey ? -1 : 1 : 0).mul(offsetLength).add(NOTE_CENTER_OFFSET.clone().mul(shape.props.scale)).rot(pageRotation).add(pageTransform.point());
      const newNote = getNoteShapeForAdjacentPosition(editor, shape, adjacentCenter, pageRotation);
      if (newNote) {
        editor.mark("editing adjacent shape");
        startEditingShapeWithLabel(editor, newNote, true);
      }
    }
  }, [id, editor, translation.dir]);
}
function getNoteHeight(shape) {
  return (NOTE_SIZE + shape.props.growY) * shape.props.scale;
}
function getNoteShadow(id, rotation, scale) {
  const random = rng(id);
  const lift = Math.abs(random()) + 0.5;
  const oy = Math.cos(rotation);
  const a2 = 5 * scale;
  const b2 = 4 * scale;
  const c2 = 6 * scale;
  const d2 = 7 * scale;
  return `0px ${a2 - lift}px ${a2}px -${a2}px rgba(15, 23, 31, .6),
	0px ${(b2 + lift * d2) * Math.max(0, oy)}px ${c2 + lift * d2}px -${b2 + lift * c2}px rgba(15, 23, 31, ${(0.3 + lift * 0.1).toFixed(2)}), 
	0px ${48 * scale}px ${10 * scale}px -${10 * scale}px inset rgba(15, 23, 44, ${((0.022 + random() * 5e-3) * ((1 + oy) / 2)).toFixed(2)})`;
}
function getBoundsForSVG(shape) {
  return new Box(0, 0, NOTE_SIZE, NOTE_SIZE + shape.props.growY);
}
var import_jsx_runtime63, import_react61, NoteShapeUtil, labelSizesForNote;
var init_NoteShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/note/NoteShapeUtil.mjs"() {
    import_jsx_runtime63 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react61 = __toESM(require_react(), 1);
    init_useTranslation();
    init_text();
    init_HyperlinkButton();
    init_SvgTextLabel();
    init_TextLabel();
    init_default_shape_constants();
    init_defaultStyleDefs();
    init_selectHelpers();
    init_useDefaultColorTheme();
    init_noteHelpers();
    NoteShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "hideResizeHandles", () => true);
        __publicField(this, "hideSelectionBoundsFg", () => false);
        __publicField(this, "onBeforeCreate", (next) => {
          return getNoteSizeAdjustments(this.editor, next);
        });
        __publicField(this, "onBeforeUpdate", (prev, next) => {
          if (prev.props.text === next.props.text && prev.props.font === next.props.font && prev.props.size === next.props.size) {
            return;
          }
          return getNoteSizeAdjustments(this.editor, next);
        });
        __publicField(this, "onEditEnd", (shape) => {
          const {
            id,
            type,
            props: { text }
          } = shape;
          if (text.trimEnd() !== shape.props.text) {
            this.editor.updateShapes([
              {
                id,
                type,
                props: {
                  text: text.trimEnd()
                }
              }
            ]);
          }
        });
      }
      getDefaultProps() {
        return {
          color: "black",
          size: "m",
          text: "",
          font: "draw",
          align: "middle",
          verticalAlign: "middle",
          growY: 0,
          fontSizeAdjustment: 0,
          url: "",
          scale: 1
        };
      }
      getGeometry(shape) {
        const { labelHeight, labelWidth } = getLabelSize(this.editor, shape);
        const { scale } = shape.props;
        const lh = labelHeight * scale;
        const lw = labelWidth * scale;
        const nw = NOTE_SIZE * scale;
        const nh = getNoteHeight(shape);
        return new Group2d({
          children: [
            new Rectangle2d({ width: nw, height: nh, isFilled: true }),
            new Rectangle2d({
              x: shape.props.align === "start" ? 0 : shape.props.align === "end" ? nw - lw : (nw - lw) / 2,
              y: shape.props.verticalAlign === "start" ? 0 : shape.props.verticalAlign === "end" ? nh - lh : (nh - lh) / 2,
              width: lw,
              height: lh,
              isFilled: true,
              isLabel: true
            })
          ]
        });
      }
      getHandles(shape) {
        const { scale } = shape.props;
        const isCoarsePointer = this.editor.getInstanceState().isCoarsePointer;
        if (isCoarsePointer)
          return [];
        const zoom = this.editor.getZoomLevel();
        if (zoom * scale < 0.25)
          return [];
        const nh = getNoteHeight(shape);
        const nw = NOTE_SIZE * scale;
        const offset5 = CLONE_HANDLE_MARGIN / zoom * scale;
        if (zoom * scale < 0.5) {
          return [
            {
              id: "bottom",
              index: "a3",
              type: "clone",
              x: nw / 2,
              y: nh + offset5
            }
          ];
        }
        return [
          {
            id: "top",
            index: "a1",
            type: "clone",
            x: nw / 2,
            y: -offset5
          },
          {
            id: "right",
            index: "a2",
            type: "clone",
            x: nw + offset5,
            y: nh / 2
          },
          {
            id: "bottom",
            index: "a3",
            type: "clone",
            x: nw / 2,
            y: nh + offset5
          },
          {
            id: "left",
            index: "a4",
            type: "clone",
            x: -offset5,
            y: nh / 2
          }
        ];
      }
      component(shape) {
        const {
          id,
          type,
          props: { scale, color, font, size: size4, align, text, verticalAlign, fontSizeAdjustment }
        } = shape;
        const handleKeyDown = useNoteKeydownHandler(id);
        const theme = useDefaultColorTheme();
        const nw = NOTE_SIZE * scale;
        const nh = getNoteHeight(shape);
        const rotation = useValue("shape rotation", () => this.editor.getShapePageTransform(id)?.rotation() ?? 0, [this.editor]);
        const hideShadows = useValue("zoom", () => this.editor.getZoomLevel() < 0.35 / scale, [
          scale,
          this.editor
        ]);
        const isSelected = shape.id === this.editor.getOnlySelectedShapeId();
        return /* @__PURE__ */ (0, import_jsx_runtime63.jsxs)(import_jsx_runtime63.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("div", {
            id,
            className: "tl-note__container",
            style: {
              width: nw,
              height: nh,
              backgroundColor: theme[color].note.fill,
              borderBottom: hideShadows ? `${3 * scale}px solid rgb(15, 23, 31, .2)` : `none`,
              boxShadow: hideShadows ? "none" : getNoteShadow(shape.id, rotation, scale)
            },
            children: /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(TextLabel, {
              id,
              type,
              font,
              fontSize: (fontSizeAdjustment || LABEL_FONT_SIZES[size4]) * scale,
              lineHeight: TEXT_PROPS.lineHeight,
              align,
              verticalAlign,
              text,
              isNote: true,
              isSelected,
              labelColor: theme[color].note.text,
              wrap: true,
              padding: 16 * scale,
              onKeyDown: handleKeyDown
            })
          }),
          "url" in shape.props && shape.props.url && /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: this.editor.getZoomLevel() })
        ] });
      }
      indicator(shape) {
        const { scale } = shape.props;
        return /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("rect", {
          rx: scale,
          width: toDomPrecision(NOTE_SIZE * scale),
          height: toDomPrecision(getNoteHeight(shape))
        });
      }
      toSvg(shape, ctx) {
        if (shape.props.text)
          ctx.addExportDef(getFontDefForExport(shape.props.font));
        const theme = getDefaultColorTheme({ isDarkMode: ctx.isDarkMode });
        const bounds = getBoundsForSVG(shape);
        return /* @__PURE__ */ (0, import_jsx_runtime63.jsxs)(import_jsx_runtime63.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("rect", { x: 5, y: 5, rx: 1, width: NOTE_SIZE - 10, height: bounds.h, fill: "rgba(0,0,0,.1)" }),
          /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("rect", {
            rx: 1,
            width: NOTE_SIZE,
            height: bounds.h,
            fill: theme[shape.props.color].note.fill
          }),
          /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(SvgTextLabel, {
            fontSize: shape.props.fontSizeAdjustment || LABEL_FONT_SIZES[shape.props.size],
            font: shape.props.font,
            align: shape.props.align,
            verticalAlign: shape.props.verticalAlign,
            text: shape.props.text,
            labelColor: theme[shape.props.color].note.text,
            bounds,
            stroke: false
          })
        ] });
      }
    };
    __publicField(NoteShapeUtil, "type", "note");
    __publicField(NoteShapeUtil, "props", noteShapeProps);
    __publicField(NoteShapeUtil, "migrations", noteShapeMigrations);
    labelSizesForNote = new WeakCache();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/shared/resizeScaled.mjs
function resizeScaled(shape, {
  initialBounds,
  scaleX,
  scaleY,
  newPoint
}) {
  const scaleDelta = Math.max(0.01, Math.min(Math.abs(scaleX), Math.abs(scaleY)));
  const offset5 = new Vec(0, 0);
  if (scaleX < 0) {
    offset5.x = -(initialBounds.width * scaleDelta);
  }
  if (scaleY < 0) {
    offset5.y = -(initialBounds.height * scaleDelta);
  }
  const { x: x2, y: y2 } = Vec.Add(newPoint, offset5.rot(shape.rotation));
  return {
    x: x2,
    y: y2,
    props: {
      scale: scaleDelta * shape.props.scale
    }
  };
}
var init_resizeScaled = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/shared/resizeScaled.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/text/TextShapeUtil.mjs
function getTextSize(editor, props) {
  const { font, text, autoSize, size: size4, w: w2 } = props;
  const minWidth = autoSize ? 16 : Math.max(16, w2);
  const fontSize = FONT_SIZES[size4];
  const cw = autoSize ? null : Math.floor(Math.max(minWidth, w2));
  const result = editor.textMeasure.measureText(text, {
    ...TEXT_PROPS,
    fontFamily: FONT_FAMILIES[font],
    fontSize,
    maxWidth: cw
  });
  if (autoSize) {
    result.w += 1;
  }
  return {
    width: Math.max(minWidth, result.w),
    height: Math.max(fontSize, result.h)
  };
}
function useTextShapeKeydownHandler(id) {
  const editor = useEditor();
  return (0, import_react62.useCallback)((e2) => {
    if (editor.getEditingShapeId() !== id)
      return;
    switch (e2.key) {
      case "Enter": {
        if (e2.ctrlKey || e2.metaKey) {
          editor.complete();
        }
        break;
      }
      case "Tab": {
        preventDefault(e2);
        if (e2.shiftKey) {
          TextHelpers.unindent(e2.currentTarget);
        } else {
          TextHelpers.indent(e2.currentTarget);
        }
        break;
      }
    }
  }, [editor, id]);
}
var import_jsx_runtime64, import_react62, sizeCache, TextShapeUtil;
var init_TextShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/text/TextShapeUtil.mjs"() {
    import_jsx_runtime64 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react62 = __toESM(require_react(), 1);
    init_SvgTextLabel();
    init_TextHelpers();
    init_TextLabel();
    init_default_shape_constants();
    init_defaultStyleDefs();
    init_resizeScaled();
    init_useDefaultColorTheme();
    sizeCache = new WeakCache();
    TextShapeUtil = class extends ShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "isAspectRatioLocked", () => true);
        __publicField(this, "onResize", (shape, info2) => {
          const { newPoint, initialBounds, initialShape, scaleX, handle } = info2;
          if (info2.mode === "scale_shape" || handle !== "right" && handle !== "left") {
            return {
              id: shape.id,
              type: shape.type,
              ...resizeScaled(shape, info2)
            };
          } else {
            const nextWidth = Math.max(1, Math.abs(initialBounds.width * scaleX));
            const { x: x2, y: y2 } = scaleX < 0 ? Vec.Sub(newPoint, Vec.FromAngle(shape.rotation).mul(nextWidth)) : newPoint;
            return {
              id: shape.id,
              type: shape.type,
              x: x2,
              y: y2,
              props: {
                w: nextWidth / initialShape.props.scale,
                autoSize: false
              }
            };
          }
        });
        __publicField(this, "onEditEnd", (shape) => {
          const {
            id,
            type,
            props: { text }
          } = shape;
          const trimmedText = shape.props.text.trimEnd();
          if (trimmedText.length === 0) {
            this.editor.deleteShapes([shape.id]);
          } else {
            if (trimmedText !== shape.props.text) {
              this.editor.updateShapes([
                {
                  id,
                  type,
                  props: {
                    text: text.trimEnd()
                  }
                }
              ]);
            }
          }
        });
        __publicField(this, "onBeforeUpdate", (prev, next) => {
          if (!next.props.autoSize)
            return;
          const styleDidChange = prev.props.size !== next.props.size || prev.props.textAlign !== next.props.textAlign || prev.props.font !== next.props.font || prev.props.scale !== 1 && next.props.scale === 1;
          const textDidChange = prev.props.text !== next.props.text;
          if (!styleDidChange && !textDidChange)
            return;
          const boundsA = this.getMinDimensions(prev);
          const boundsB = getTextSize(this.editor, next.props);
          const wA = boundsA.width * prev.props.scale;
          const hA = boundsA.height * prev.props.scale;
          const wB = boundsB.width * next.props.scale;
          const hB = boundsB.height * next.props.scale;
          let delta;
          switch (next.props.textAlign) {
            case "middle": {
              delta = new Vec((wB - wA) / 2, textDidChange ? 0 : (hB - hA) / 2);
              break;
            }
            case "end": {
              delta = new Vec(wB - wA, textDidChange ? 0 : (hB - hA) / 2);
              break;
            }
            default: {
              if (textDidChange)
                break;
              delta = new Vec(0, (hB - hA) / 2);
              break;
            }
          }
          if (delta) {
            delta.rot(next.rotation);
            const { x: x2, y: y2 } = next;
            return {
              ...next,
              x: x2 - delta.x,
              y: y2 - delta.y,
              props: { ...next.props, w: wB }
            };
          } else {
            return {
              ...next,
              props: { ...next.props, w: wB }
            };
          }
        });
      }
      getDefaultProps() {
        return {
          color: "black",
          size: "m",
          w: 8,
          text: "",
          font: "draw",
          textAlign: "start",
          autoSize: true,
          scale: 1
        };
      }
      getMinDimensions(shape) {
        return sizeCache.get(shape.props, (props) => getTextSize(this.editor, props));
      }
      getGeometry(shape) {
        const { scale } = shape.props;
        const { width, height } = this.getMinDimensions(shape);
        return new Rectangle2d({
          width: width * scale,
          height: height * scale,
          isFilled: true,
          isLabel: true
        });
      }
      component(shape) {
        const {
          id,
          props: { font, size: size4, text, color, scale, textAlign }
        } = shape;
        const { width, height } = this.getMinDimensions(shape);
        const isSelected = shape.id === this.editor.getOnlySelectedShapeId();
        const theme = useDefaultColorTheme();
        const handleKeyDown = useTextShapeKeydownHandler(id);
        return /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(TextLabel, {
          id,
          classNamePrefix: "tl-text-shape",
          type: "text",
          font,
          fontSize: FONT_SIZES[size4],
          lineHeight: TEXT_PROPS.lineHeight,
          align: textAlign,
          verticalAlign: "middle",
          text,
          labelColor: theme[color].solid,
          isSelected,
          textWidth: width,
          textHeight: height,
          style: {
            transform: `scale(${scale})`,
            transformOrigin: "top left"
          },
          wrap: true,
          onKeyDown: handleKeyDown
        });
      }
      indicator(shape) {
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        const editor = useEditor();
        if (shape.props.autoSize && editor.getEditingShapeId() === shape.id)
          return null;
        return /* @__PURE__ */ (0, import_jsx_runtime64.jsx)("rect", { width: toDomPrecision(bounds.width), height: toDomPrecision(bounds.height) });
      }
      toSvg(shape, ctx) {
        if (shape.props.text)
          ctx.addExportDef(getFontDefForExport(shape.props.font));
        const bounds = this.editor.getShapeGeometry(shape).bounds;
        const width = bounds.width / (shape.props.scale ?? 1);
        const height = bounds.height / (shape.props.scale ?? 1);
        const theme = getDefaultColorTheme(ctx);
        return /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(SvgTextLabel, {
          fontSize: FONT_SIZES[shape.props.size],
          font: shape.props.font,
          align: shape.props.textAlign,
          verticalAlign: "middle",
          text: shape.props.text,
          labelColor: theme[shape.props.color].solid,
          bounds: new Box(0, 0, width, height),
          padding: 0
        });
      }
    };
    __publicField(TextShapeUtil, "type", "text");
    __publicField(TextShapeUtil, "props", textShapeProps);
    __publicField(TextShapeUtil, "migrations", textShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/shapes/video/VideoShapeUtil.mjs
function serializeVideo(id) {
  const splitId = id.split(":")[1];
  const video = document.querySelector(`.tl-video-shape-${splitId}`);
  if (video) {
    const canvas = document.createElement("canvas");
    canvas.width = video.videoWidth;
    canvas.height = video.videoHeight;
    canvas.getContext("2d").drawImage(video, 0, 0);
    return canvas.toDataURL("image/png");
  } else
    throw new Error("Video with not found when attempting serialization.");
}
var import_jsx_runtime65, import_react63, VideoShapeUtil;
var init_VideoShapeUtil = __esm({
  "node_modules/tldraw/dist-esm/lib/shapes/video/VideoShapeUtil.mjs"() {
    import_jsx_runtime65 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react63 = __toESM(require_react(), 1);
    init_BrokenAssetIcon();
    init_HyperlinkButton();
    init_useAsset();
    init_usePrefersReducedMotion();
    VideoShapeUtil = class extends BaseBoxShapeUtil {
      constructor() {
        super(...arguments);
        __publicField(this, "canEdit", () => true);
        __publicField(this, "isAspectRatioLocked", () => true);
      }
      getDefaultProps() {
        return {
          w: 100,
          h: 100,
          assetId: null,
          time: 0,
          playing: true,
          url: ""
        };
      }
      component(shape) {
        const { editor } = this;
        const showControls = editor.getShapeGeometry(shape).bounds.w * editor.getZoomLevel() >= 110;
        const { asset, url } = useAsset(shape.id, shape.props.assetId, shape.props.w);
        const { time: time3, playing } = shape.props;
        const isEditing = useIsEditing(shape.id);
        const prefersReducedMotion = usePrefersReducedMotion();
        const rVideo = (0, import_react63.useRef)(null);
        const handlePlay = (0, import_react63.useCallback)((e2) => {
          const video = e2.currentTarget;
          if (!video)
            return;
          editor.updateShapes([
            {
              type: "video",
              id: shape.id,
              props: {
                playing: true,
                time: video.currentTime
              }
            }
          ]);
        }, [shape.id, editor]);
        const handlePause = (0, import_react63.useCallback)((e2) => {
          const video = e2.currentTarget;
          if (!video)
            return;
          editor.updateShapes([
            {
              type: "video",
              id: shape.id,
              props: {
                playing: false,
                time: video.currentTime
              }
            }
          ]);
        }, [shape.id, editor]);
        const handleSetCurrentTime = (0, import_react63.useCallback)((e2) => {
          const video = e2.currentTarget;
          if (!video)
            return;
          if (isEditing) {
            editor.updateShapes([
              {
                type: "video",
                id: shape.id,
                props: {
                  time: video.currentTime
                }
              }
            ]);
          }
        }, [isEditing, shape.id, editor]);
        const [isLoaded, setIsLoaded] = (0, import_react63.useState)(false);
        const handleLoadedData = (0, import_react63.useCallback)((e2) => {
          const video = e2.currentTarget;
          if (!video)
            return;
          if (time3 !== video.currentTime) {
            video.currentTime = time3;
          }
          if (!playing) {
            video.pause();
          }
          setIsLoaded(true);
        }, [playing, time3]);
        (0, import_react63.useEffect)(() => {
          const video = rVideo.current;
          if (!video)
            return;
          if (isLoaded && !isEditing && time3 !== video.currentTime) {
            video.currentTime = time3;
          }
          if (isEditing) {
            if (document.activeElement !== video) {
              video.focus();
            }
          }
        }, [isEditing, isLoaded, time3]);
        (0, import_react63.useEffect)(() => {
          if (prefersReducedMotion) {
            const video = rVideo.current;
            if (!video)
              return;
            video.pause();
            video.currentTime = 0;
          }
        }, [rVideo, prefersReducedMotion]);
        return /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(import_jsx_runtime65.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(HTMLContainer, {
            id: shape.id,
            style: {
              color: "var(--color-text-3)",
              backgroundColor: asset ? "transparent" : "var(--color-low)",
              border: asset ? "none" : "1px solid var(--color-low-border)"
            },
            children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { className: "tl-counter-scaled", children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { className: "tl-video-container", children: !asset?.props.src ? /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(BrokenAssetIcon, {}) : url ? /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("video", {
              ref: rVideo,
              style: isEditing ? { pointerEvents: "all" } : void 0,
              className: `tl-video tl-video-shape-${shape.id.split(":")[1]}`,
              width: "100%",
              height: "100%",
              draggable: false,
              playsInline: true,
              autoPlay: true,
              muted: true,
              loop: true,
              disableRemotePlayback: true,
              disablePictureInPicture: true,
              controls: isEditing && showControls,
              onPlay: handlePlay,
              onPause: handlePause,
              onTimeUpdate: handleSetCurrentTime,
              onLoadedData: handleLoadedData,
              hidden: !isLoaded,
              children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("source", { src: url })
            }) : null }) })
          }),
          "url" in shape.props && shape.props.url && /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(HyperlinkButton, { url: shape.props.url, zoomLevel: editor.getZoomLevel() })
        ] });
      }
      indicator(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("rect", { width: toDomPrecision(shape.props.w), height: toDomPrecision(shape.props.h) });
      }
      toSvg(shape) {
        return /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("image", { href: serializeVideo(shape.id), width: shape.props.w, height: shape.props.h });
      }
    };
    __publicField(VideoShapeUtil, "type", "video");
    __publicField(VideoShapeUtil, "props", videoShapeProps);
    __publicField(VideoShapeUtil, "migrations", videoShapeMigrations);
  }
});

// node_modules/tldraw/dist-esm/lib/defaultShapeUtils.mjs
var defaultShapeUtils;
var init_defaultShapeUtils = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultShapeUtils.mjs"() {
    init_ArrowShapeUtil();
    init_BookmarkShapeUtil();
    init_DrawShapeUtil();
    init_EmbedShapeUtil();
    init_FrameShapeUtil();
    init_GeoShapeUtil();
    init_HighlightShapeUtil();
    init_ImageShapeUtil();
    init_LineShapeUtil();
    init_NoteShapeUtil();
    init_TextShapeUtil();
    init_VideoShapeUtil();
    defaultShapeUtils = [
      TextShapeUtil,
      BookmarkShapeUtil,
      DrawShapeUtil,
      GeoShapeUtil,
      NoteShapeUtil,
      LineShapeUtil,
      FrameShapeUtil,
      ArrowShapeUtil,
      HighlightShapeUtil,
      EmbedShapeUtil,
      ImageShapeUtil,
      VideoShapeUtil
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/defaultSideEffects.mjs
var init_defaultSideEffects = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultSideEffects.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Erasing.mjs
var Erasing;
var init_Erasing = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Erasing.mjs"() {
    init_dist_esm10();
    Erasing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "scribbleId", "id");
        __publicField(this, "markId", "");
        __publicField(this, "excludedShapeIds", /* @__PURE__ */ new Set());
        __publicField(this, "onEnter", (info2) => {
          this.markId = "erase scribble begin";
          this.editor.mark(this.markId);
          this.info = info2;
          const { originPagePoint } = this.editor.inputs;
          this.excludedShapeIds = new Set(this.editor.getCurrentPageShapes().filter((shape) => {
            if (this.editor.isShapeOrAncestorLocked(shape))
              return true;
            if (this.editor.isShapeOfType(shape, "group") || this.editor.isShapeOfType(shape, "frame")) {
              const pointInShapeShape = this.editor.getPointInShapeSpace(shape, originPagePoint);
              const geometry = this.editor.getShapeGeometry(shape);
              return geometry.bounds.containsPoint(pointInShapeShape);
            }
            return false;
          }).map((shape) => shape.id));
          const scribble = this.editor.scribbles.addScribble({
            color: "muted-1",
            size: 12
          });
          this.scribbleId = scribble.id;
          this.update();
        });
        __publicField(this, "pushPointToScribble", () => {
          const { x: x2, y: y2 } = this.editor.inputs.currentPagePoint;
          this.editor.scribbles.addPoint(this.scribbleId, x2, y2);
        });
        __publicField(this, "onExit", () => {
          this.editor.scribbles.stop(this.scribbleId);
        });
        __publicField(this, "onPointerMove", () => {
          this.update();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
      }
      update() {
        const { editor, excludedShapeIds } = this;
        const erasingShapeIds = editor.getErasingShapeIds();
        const zoomLevel = editor.getZoomLevel();
        const currentPageShapes = editor.getCurrentPageShapes();
        const {
          inputs: { currentPagePoint, previousPagePoint }
        } = editor;
        this.pushPointToScribble();
        const erasing2 = new Set(erasingShapeIds);
        const minDist = this.editor.options.hitTestMargin / zoomLevel;
        for (const shape of currentPageShapes) {
          if (editor.isShapeOfType(shape, "group"))
            continue;
          const pageMask = editor.getShapeMask(shape.id);
          if (pageMask && !pointInPolygon(currentPagePoint, pageMask)) {
            continue;
          }
          const geometry = editor.getShapeGeometry(shape);
          const pageTransform = editor.getShapePageTransform(shape);
          if (!geometry || !pageTransform)
            continue;
          const pt = pageTransform.clone().invert();
          const A2 = pt.applyToPoint(previousPagePoint);
          const B = pt.applyToPoint(currentPagePoint);
          const { bounds } = geometry;
          if (bounds.minX - minDist > Math.max(A2.x, B.x) || bounds.minY - minDist > Math.max(A2.y, B.y) || bounds.maxX + minDist < Math.min(A2.x, B.x) || bounds.maxY + minDist < Math.min(A2.y, B.y)) {
            continue;
          }
          if (geometry.hitTestLineSegment(A2, B, minDist)) {
            erasing2.add(editor.getOutermostSelectableShape(shape).id);
          }
        }
        this.editor.setErasingShapes([...erasing2].filter((id) => !excludedShapeIds.has(id)));
      }
      complete() {
        const { editor } = this;
        editor.deleteShapes(editor.getCurrentPageState().erasingShapeIds);
        editor.setErasingShapes([]);
        this.parent.transition("idle");
      }
      cancel() {
        const { editor } = this;
        editor.setErasingShapes([]);
        editor.bailToMark(this.markId);
        this.parent.transition("idle", this.info);
      }
    };
    __publicField(Erasing, "id", "erasing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Idle.mjs
var Idle8;
var init_Idle8 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Idle.mjs"() {
    init_dist_esm10();
    Idle8 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle8, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Pointing.mjs
var Pointing7;
var init_Pointing7 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/EraserTool/childStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing7 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          const zoomLevel = this.editor.getZoomLevel();
          const currentPageShapesSorted = this.editor.getCurrentPageShapesSorted();
          const {
            inputs: { currentPagePoint }
          } = this.editor;
          const erasing2 = /* @__PURE__ */ new Set();
          const initialSize = erasing2.size;
          for (let n2 = currentPageShapesSorted.length, i2 = n2 - 1; i2 >= 0; i2--) {
            const shape = currentPageShapesSorted[i2];
            if (this.editor.isShapeOrAncestorLocked(shape) || this.editor.isShapeOfType(shape, "group")) {
              continue;
            }
            if (this.editor.isPointInShape(shape, currentPagePoint, {
              hitInside: false,
              margin: this.editor.options.hitTestMargin / zoomLevel
            })) {
              const hitShape = this.editor.getOutermostSelectableShape(shape);
              if (this.editor.isShapeOfType(hitShape, "frame") && erasing2.size > initialSize) {
                break;
              }
              erasing2.add(hitShape.id);
            }
          }
          this.editor.setErasingShapes([...erasing2]);
        });
        __publicField(this, "onLongPress", (info2) => {
          this.startErasing(info2);
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            this.startErasing(info2);
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      startErasing(info2) {
        this.parent.transition("erasing", info2);
      }
      complete() {
        const erasingShapeIds = this.editor.getErasingShapeIds();
        if (erasingShapeIds.length) {
          this.editor.mark("erase end");
          this.editor.deleteShapes(erasingShapeIds);
        }
        this.editor.setErasingShapes([]);
        this.parent.transition("idle");
      }
      cancel() {
        this.editor.setErasingShapes([]);
        this.parent.transition("idle");
      }
    };
    __publicField(Pointing7, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/EraserTool/EraserTool.mjs
var EraserTool;
var init_EraserTool = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/EraserTool/EraserTool.mjs"() {
    init_dist_esm10();
    init_Erasing();
    init_Idle8();
    init_Pointing7();
    EraserTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
      }
    };
    __publicField(EraserTool, "id", "eraser");
    __publicField(EraserTool, "initial", "idle");
    __publicField(EraserTool, "isLockable", false);
    __publicField(EraserTool, "children", () => [Idle8, Pointing7, Erasing]);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Dragging.mjs
var Dragging;
var init_Dragging = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Dragging.mjs"() {
    init_dist_esm10();
    Dragging = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "initialCamera", new Vec());
        __publicField(this, "onEnter", () => {
          this.initialCamera = Vec.From(this.editor.getCamera());
          this.update();
        });
        __publicField(this, "onPointerMove", () => {
          this.update();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.parent.transition("idle");
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
      }
      update() {
        const { initialCamera, editor } = this;
        const { currentScreenPoint, originScreenPoint } = editor.inputs;
        const delta = Vec.Sub(currentScreenPoint, originScreenPoint).div(editor.getZoomLevel());
        if (delta.len2() === 0)
          return;
        editor.setCamera(initialCamera.clone().add(delta));
      }
      complete() {
        const { editor } = this;
        const { pointerVelocity } = editor.inputs;
        const velocityAtPointerUp = Math.min(pointerVelocity.len(), 2);
        if (velocityAtPointerUp > 0.1) {
          this.editor.slideCamera({ speed: velocityAtPointerUp, direction: pointerVelocity });
        }
        this.parent.transition("idle");
      }
    };
    __publicField(Dragging, "id", "dragging");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Idle.mjs
var Idle9;
var init_Idle9 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Idle.mjs"() {
    init_dist_esm10();
    Idle9 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "grab", rotation: 0 });
        });
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("pointing", info2);
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select");
        });
      }
    };
    __publicField(Idle9, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Pointing.mjs
var Pointing8;
var init_Pointing8 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/HandTool/childStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing8 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.editor.stopCameraAnimation();
          this.editor.setCursor({ type: "grabbing", rotation: 0 });
        });
        __publicField(this, "onLongPress", () => {
          this.startDragging();
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            this.startDragging();
          }
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.complete();
        });
      }
      startDragging() {
        this.parent.transition("dragging");
      }
      complete() {
        this.parent.transition("idle");
      }
    };
    __publicField(Pointing8, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/HandTool/HandTool.mjs
var HandTool;
var init_HandTool = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/HandTool/HandTool.mjs"() {
    init_dist_esm10();
    init_Dragging();
    init_Idle9();
    init_Pointing8();
    HandTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onDoubleClick", (info2) => {
          if (info2.phase === "settle") {
            const { currentScreenPoint } = this.editor.inputs;
            this.editor.zoomIn(currentScreenPoint, {
              animation: { duration: 220, easing: EASINGS.easeOutQuint }
            });
          }
        });
        __publicField(this, "onTripleClick", (info2) => {
          if (info2.phase === "settle") {
            const { currentScreenPoint } = this.editor.inputs;
            this.editor.zoomOut(currentScreenPoint, {
              animation: { duration: 320, easing: EASINGS.easeOutQuint }
            });
          }
        });
        __publicField(this, "onQuadrupleClick", (info2) => {
          if (info2.phase === "settle") {
            const zoomLevel = this.editor.getZoomLevel();
            const {
              inputs: { currentScreenPoint }
            } = this.editor;
            if (zoomLevel === 1) {
              this.editor.zoomToFit({ animation: { duration: 400, easing: EASINGS.easeOutQuint } });
            } else {
              this.editor.resetZoom(currentScreenPoint, {
                animation: { duration: 320, easing: EASINGS.easeOutQuint }
              });
            }
          }
        });
      }
    };
    __publicField(HandTool, "id", "hand");
    __publicField(HandTool, "initial", "idle");
    __publicField(HandTool, "isLockable", false);
    __publicField(HandTool, "children", () => [Idle9, Pointing8, Dragging]);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/LaserTool/childStates/Idle.mjs
var Idle10;
var init_Idle10 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/LaserTool/childStates/Idle.mjs"() {
    init_dist_esm10();
    Idle10 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onPointerDown", (info2) => {
          this.parent.transition("lasering", info2);
        });
      }
    };
    __publicField(Idle10, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/LaserTool/childStates/Lasering.mjs
var Lasering;
var init_Lasering = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/LaserTool/childStates/Lasering.mjs"() {
    init_dist_esm10();
    Lasering = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "scribbleId", "id");
        __publicField(this, "onEnter", () => {
          const scribble = this.editor.scribbles.addScribble({
            color: "laser",
            opacity: 0.7,
            size: 4,
            delay: 1200,
            shrink: 0.05,
            taper: true
          });
          this.scribbleId = scribble.id;
          this.pushPointToScribble();
        });
        __publicField(this, "onExit", () => {
          this.editor.scribbles.stop(this.scribbleId);
        });
        __publicField(this, "onPointerMove", () => {
          this.pushPointToScribble();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "pushPointToScribble", () => {
          const { x: x2, y: y2 } = this.editor.inputs.currentPagePoint;
          this.editor.scribbles.addPoint(this.scribbleId, x2, y2);
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
      }
      complete() {
        this.parent.transition("idle");
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(Lasering, "id", "lasering");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/LaserTool/LaserTool.mjs
var LaserTool;
var init_LaserTool = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/LaserTool/LaserTool.mjs"() {
    init_dist_esm10();
    init_Idle10();
    init_Lasering();
    LaserTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "cross", rotation: 0 });
        });
      }
    };
    __publicField(LaserTool, "id", "laser");
    __publicField(LaserTool, "initial", "idle");
    __publicField(LaserTool, "children", () => [Idle10, Lasering]);
    __publicField(LaserTool, "isLockable", false);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Brushing.mjs
var Brushing;
var init_Brushing = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Brushing.mjs"() {
    init_dist_esm10();
    Brushing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "initialSelectedShapeIds", []);
        __publicField(this, "excludedShapeIds", /* @__PURE__ */ new Set());
        __publicField(this, "isWrapMode", false);
        __publicField(this, "initialStartShape", null);
        __publicField(this, "onEnter", (info2) => {
          const { altKey: altKey2, currentPagePoint } = this.editor.inputs;
          this.isWrapMode = this.editor.user.getIsWrapMode();
          if (altKey2) {
            this.parent.transition("scribble_brushing", info2);
            return;
          }
          this.excludedShapeIds = new Set(this.editor.getCurrentPageShapes().filter((shape) => this.editor.isShapeOfType(shape, "group") || this.editor.isShapeOrAncestorLocked(shape)).map((shape) => shape.id));
          this.info = info2;
          this.initialSelectedShapeIds = this.editor.getSelectedShapeIds().slice();
          this.initialStartShape = this.editor.getShapesAtPoint(currentPagePoint)[0];
          this.hitTestShapes();
        });
        __publicField(this, "onExit", () => {
          this.initialSelectedShapeIds = [];
          this.editor.updateInstanceState({ brush: null });
        });
        __publicField(this, "onTick", ({ elapsed }) => {
          const { editor } = this;
          editor.edgeScrollManager.updateEdgeScrolling(elapsed);
        });
        __publicField(this, "onPointerMove", () => {
          this.hitTestShapes();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", (info2) => {
          this.editor.setSelectedShapes(this.initialSelectedShapeIds);
          this.parent.transition("idle", info2);
        });
        __publicField(this, "onKeyDown", (info2) => {
          if (this.editor.inputs.altKey) {
            this.parent.transition("scribble_brushing", info2);
          } else {
            this.hitTestShapes();
          }
        });
        __publicField(this, "onKeyUp", () => {
          this.hitTestShapes();
        });
        __publicField(this, "onInterrupt", () => {
          this.editor.updateInstanceState({ brush: null });
        });
      }
      complete() {
        this.hitTestShapes();
        this.parent.transition("idle");
      }
      hitTestShapes() {
        const { editor, excludedShapeIds, isWrapMode } = this;
        const {
          inputs: { originPagePoint, currentPagePoint, shiftKey, ctrlKey }
        } = editor;
        const results = new Set(shiftKey ? this.initialSelectedShapeIds : []);
        const isWrapping = isWrapMode ? !ctrlKey : ctrlKey;
        const brush = Box.FromPoints([originPagePoint, currentPagePoint]);
        const { corners } = brush;
        let A2, B, shape, pageBounds, pageTransform, localCorners;
        const currentPageShapes = editor.getCurrentPageShapes();
        const currentPageId = editor.getCurrentPageId();
        testAllShapes:
          for (let i2 = 0, n2 = currentPageShapes.length; i2 < n2; i2++) {
            shape = currentPageShapes[i2];
            if (excludedShapeIds.has(shape.id) || results.has(shape.id))
              continue testAllShapes;
            pageBounds = editor.getShapePageBounds(shape);
            if (!pageBounds)
              continue testAllShapes;
            if (brush.contains(pageBounds)) {
              this.handleHit(shape, currentPagePoint, currentPageId, results, corners);
              continue testAllShapes;
            }
            if (isWrapping || editor.isShapeOfType(shape, "frame")) {
              continue testAllShapes;
            }
            if (brush.collides(pageBounds)) {
              pageTransform = editor.getShapePageTransform(shape);
              if (!pageTransform)
                continue testAllShapes;
              localCorners = pageTransform.clone().invert().applyToPoints(corners);
              const geometry = editor.getShapeGeometry(shape);
              hitTestBrushEdges:
                for (let i22 = 0; i22 < 4; i22++) {
                  A2 = localCorners[i22];
                  B = localCorners[(i22 + 1) % 4];
                  if (geometry.hitTestLineSegment(A2, B, 0)) {
                    this.handleHit(shape, currentPagePoint, currentPageId, results, corners);
                    break hitTestBrushEdges;
                  }
                }
            }
          }
        editor.getInstanceState().isCoarsePointer;
        const currentBrush = editor.getInstanceState().brush;
        if (!currentBrush || !brush.equals(currentBrush)) {
          editor.updateInstanceState({ brush: { ...brush.toJson() } });
        }
        const current = editor.getSelectedShapeIds();
        if (current.length !== results.size || current.some((id) => !results.has(id))) {
          editor.setSelectedShapes(Array.from(results));
        }
      }
      handleHit(shape, currentPagePoint, currentPageId, results, corners) {
        if (shape.parentId === currentPageId) {
          results.add(shape.id);
          return;
        }
        const selectedShape = this.editor.getOutermostSelectableShape(shape);
        const pageMask = this.editor.getShapeMask(selectedShape.id);
        if (pageMask && !polygonsIntersect(pageMask, corners) && !pointInPolygon(currentPagePoint, pageMask)) {
          return;
        }
        results.add(selectedShape.id);
      }
    };
    __publicField(Brushing, "id", "brushing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingResizeHandle.mjs
var CursorTypeMap, PointingResizeHandle;
var init_PointingResizeHandle = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingResizeHandle.mjs"() {
    init_dist_esm10();
    CursorTypeMap = {
      bottom: "ns-resize",
      top: "ns-resize",
      left: "ew-resize",
      right: "ew-resize",
      bottom_left: "nesw-resize",
      bottom_right: "nwse-resize",
      top_left: "nwse-resize",
      top_right: "nesw-resize",
      bottom_left_rotate: "swne-rotate",
      bottom_right_rotate: "senw-rotate",
      top_left_rotate: "nwse-rotate",
      top_right_rotate: "nesw-rotate",
      mobile_rotate: "grabbing"
    };
    PointingResizeHandle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.updateCursor();
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            this.startResizing();
          }
        });
        __publicField(this, "onLongPress", () => {
          this.startResizing();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      updateCursor() {
        const selected = this.editor.getSelectedShapes();
        const cursorType = CursorTypeMap[this.info.handle];
        this.editor.setCursor({
          type: cursorType,
          rotation: selected.length === 1 ? this.editor.getSelectionRotation() : 0
        });
      }
      startResizing() {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.parent.transition("resizing", this.info);
      }
      complete() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
      cancel() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
    };
    __publicField(PointingResizeHandle, "id", "pointing_resize_handle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/crop-constants.mjs
var MIN_CROP_SIZE;
var init_crop_constants = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/crop-constants.mjs"() {
    MIN_CROP_SIZE = 8;
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/Cropping.mjs
var Cropping;
var init_Cropping = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/Cropping.mjs"() {
    init_dist_esm10();
    init_selectHelpers();
    init_PointingResizeHandle();
    init_crop_constants();
    Cropping = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "markId", "");
        __publicField(this, "snapshot", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.markId = "cropping";
          this.editor.mark(this.markId);
          this.snapshot = this.createSnapshot();
          this.updateShapes();
        });
        __publicField(this, "onPointerMove", () => {
          this.updateShapes();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "getDefaultCrop", () => ({
          topLeft: { x: 0, y: 0 },
          bottomRight: { x: 1, y: 1 }
        }));
      }
      updateCursor() {
        const selectedShape = this.editor.getSelectedShapes()[0];
        if (!selectedShape)
          return;
        const cursorType = CursorTypeMap[this.info.handle];
        this.editor.setCursor({ type: cursorType, rotation: this.editor.getSelectionRotation() });
      }
      updateShapes() {
        const { shape, cursorHandleOffset } = this.snapshot;
        if (!shape)
          return;
        const util = this.editor.getShapeUtil("image");
        if (!util)
          return;
        const props = shape.props;
        const currentPagePoint = this.editor.inputs.currentPagePoint.clone().sub(cursorHandleOffset);
        const originPagePoint = this.editor.inputs.originPagePoint.clone().sub(cursorHandleOffset);
        const change = currentPagePoint.clone().sub(originPagePoint).rot(-shape.rotation);
        const crop = props.crop ?? this.getDefaultCrop();
        const newCrop = structuredClone2(crop);
        const newPoint = new Vec(shape.x, shape.y);
        const pointDelta = new Vec(0, 0);
        const w2 = 1 / (crop.bottomRight.x - crop.topLeft.x) * props.w;
        const h2 = 1 / (crop.bottomRight.y - crop.topLeft.y) * props.h;
        let hasCropChanged = false;
        switch (this.info.handle) {
          case "top":
          case "top_left":
          case "top_right": {
            if (h2 < MIN_CROP_SIZE)
              break;
            hasCropChanged = true;
            newCrop.topLeft.y = newCrop.topLeft.y + change.y / h2;
            const heightAfterCrop = h2 * (newCrop.bottomRight.y - newCrop.topLeft.y);
            if (heightAfterCrop < MIN_CROP_SIZE) {
              newCrop.topLeft.y = newCrop.bottomRight.y - MIN_CROP_SIZE / h2;
              pointDelta.y = (newCrop.topLeft.y - crop.topLeft.y) * h2;
            } else {
              if (newCrop.topLeft.y <= 0) {
                newCrop.topLeft.y = 0;
                pointDelta.y = (newCrop.topLeft.y - crop.topLeft.y) * h2;
              } else {
                pointDelta.y = change.y;
              }
            }
            break;
          }
          case "bottom":
          case "bottom_left":
          case "bottom_right": {
            if (h2 < MIN_CROP_SIZE)
              break;
            hasCropChanged = true;
            newCrop.bottomRight.y = Math.min(1, newCrop.bottomRight.y + change.y / h2);
            const heightAfterCrop = h2 * (newCrop.bottomRight.y - newCrop.topLeft.y);
            if (heightAfterCrop < MIN_CROP_SIZE) {
              newCrop.bottomRight.y = newCrop.topLeft.y + MIN_CROP_SIZE / h2;
            }
            break;
          }
        }
        switch (this.info.handle) {
          case "left":
          case "top_left":
          case "bottom_left": {
            if (w2 < MIN_CROP_SIZE)
              break;
            hasCropChanged = true;
            newCrop.topLeft.x = newCrop.topLeft.x + change.x / w2;
            const widthAfterCrop = w2 * (newCrop.bottomRight.x - newCrop.topLeft.x);
            if (widthAfterCrop < MIN_CROP_SIZE) {
              newCrop.topLeft.x = newCrop.bottomRight.x - MIN_CROP_SIZE / w2;
              pointDelta.x = (newCrop.topLeft.x - crop.topLeft.x) * w2;
            } else {
              if (newCrop.topLeft.x <= 0) {
                newCrop.topLeft.x = 0;
                pointDelta.x = (newCrop.topLeft.x - crop.topLeft.x) * w2;
              } else {
                pointDelta.x = change.x;
              }
            }
            break;
          }
          case "right":
          case "top_right":
          case "bottom_right": {
            if (w2 < MIN_CROP_SIZE)
              break;
            hasCropChanged = true;
            newCrop.bottomRight.x = Math.min(1, newCrop.bottomRight.x + change.x / w2);
            const widthAfterCrop = w2 * (newCrop.bottomRight.x - newCrop.topLeft.x);
            if (widthAfterCrop < MIN_CROP_SIZE) {
              newCrop.bottomRight.x = newCrop.topLeft.x + MIN_CROP_SIZE / w2;
            }
            break;
          }
        }
        if (!hasCropChanged)
          return;
        newPoint.add(pointDelta.rot(shape.rotation));
        const partial = {
          id: shape.id,
          type: shape.type,
          x: newPoint.x,
          y: newPoint.y,
          props: {
            crop: newCrop,
            w: (newCrop.bottomRight.x - newCrop.topLeft.x) * w2,
            h: (newCrop.bottomRight.y - newCrop.topLeft.y) * h2
          }
        };
        this.editor.updateShapes([partial]);
        this.updateCursor();
      }
      complete() {
        this.updateShapes();
        kickoutOccludedShapes(this.editor, [this.snapshot.shape.id]);
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
        } else {
          this.editor.setCroppingShape(null);
          this.editor.setCurrentTool("select.idle");
        }
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
        } else {
          this.editor.setCroppingShape(null);
          this.editor.setCurrentTool("select.idle");
        }
      }
      createSnapshot() {
        const selectionRotation = this.editor.getSelectionRotation();
        const {
          inputs: { originPagePoint }
        } = this.editor;
        const shape = this.editor.getOnlySelectedShape();
        const selectionBounds = this.editor.getSelectionRotatedPageBounds();
        const dragHandlePoint = Vec.RotWith(selectionBounds.getHandlePoint(this.info.handle), selectionBounds.point, selectionRotation);
        const cursorHandleOffset = Vec.Sub(originPagePoint, dragHandlePoint);
        return {
          shape,
          cursorHandleOffset
        };
      }
    };
    __publicField(Cropping, "id", "cropping");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/selection-logic/getHitShapeOnCanvasPointerDown.mjs
function getHitShapeOnCanvasPointerDown(editor, hitLabels = false) {
  const zoomLevel = editor.getZoomLevel();
  const {
    inputs: { currentPagePoint }
  } = editor;
  return editor.getShapeAtPoint(currentPagePoint, {
    hitInside: false,
    hitLabels,
    margin: editor.options.hitTestMargin / zoomLevel,
    renderingOnly: true
  }) ?? editor.getSelectedShapeAtPoint(currentPagePoint);
}
var init_getHitShapeOnCanvasPointerDown = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/selection-logic/getHitShapeOnCanvasPointerDown.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/crop_helpers.mjs
function getTranslateCroppedImageChange(editor, shape, delta) {
  if (!shape) {
    throw Error("Needs to translate a cropped shape!");
  }
  const { crop: oldCrop } = shape.props;
  if (!oldCrop) {
    return;
  }
  const flatten = editor.inputs.shiftKey ? Math.abs(delta.x) < Math.abs(delta.y) ? "x" : "y" : null;
  if (flatten === "x") {
    delta.x = 0;
  } else if (flatten === "y") {
    delta.y = 0;
  }
  delta.rot(-shape.rotation);
  const w2 = 1 / (oldCrop.bottomRight.x - oldCrop.topLeft.x) * shape.props.w;
  const h2 = 1 / (oldCrop.bottomRight.y - oldCrop.topLeft.y) * shape.props.h;
  const yCrop = oldCrop.bottomRight.y - oldCrop.topLeft.y;
  const xCrop = oldCrop.bottomRight.x - oldCrop.topLeft.x;
  const newCrop = structuredClone2(oldCrop);
  newCrop.topLeft.x = Math.min(1 - xCrop, Math.max(0, newCrop.topLeft.x - delta.x / w2));
  newCrop.topLeft.y = Math.min(1 - yCrop, Math.max(0, newCrop.topLeft.y - delta.y / h2));
  newCrop.bottomRight.x = newCrop.topLeft.x + xCrop;
  newCrop.bottomRight.y = newCrop.topLeft.y + yCrop;
  const partial = {
    id: shape.id,
    type: shape.type,
    props: {
      crop: newCrop
    }
  };
  return partial;
}
var init_crop_helpers = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/crop_helpers.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/Idle.mjs
var Idle11;
var init_Idle11 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/Idle.mjs"() {
    init_dist_esm10();
    init_getHitShapeOnCanvasPointerDown();
    init_crop_helpers();
    Idle11 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.editor.setCursor({ type: "default", rotation: 0 });
          const onlySelectedShape = this.editor.getOnlySelectedShape();
          if (onlySelectedShape) {
            this.editor.setCroppingShape(onlySelectedShape.id);
          }
        });
        __publicField(this, "onExit", () => {
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "onCancel", () => {
          this.editor.setCroppingShape(null);
          this.editor.setCurrentTool("select.idle", {});
        });
        __publicField(this, "onPointerDown", (info2) => {
          if (this.editor.getIsMenuOpen())
            return;
          if (info2.ctrlKey) {
            this.cancel();
            this.editor.root.handleEvent(info2);
            return;
          }
          switch (info2.target) {
            case "canvas": {
              const hitShape = getHitShapeOnCanvasPointerDown(this.editor);
              if (hitShape && !this.editor.isShapeOfType(hitShape, "group")) {
                this.onPointerDown({
                  ...info2,
                  shape: hitShape,
                  target: "shape"
                });
                return;
              }
              this.cancel();
              this.editor.root.handleEvent(info2);
              break;
            }
            case "shape": {
              if (info2.shape.id === this.editor.getCroppingShapeId()) {
                this.editor.setCurrentTool("select.crop.pointing_crop", info2);
                return;
              } else {
                if (this.editor.getShapeUtil(info2.shape)?.canCrop(info2.shape)) {
                  this.editor.setCroppingShape(info2.shape.id);
                  this.editor.setSelectedShapes([info2.shape.id]);
                  this.editor.setCurrentTool("select.crop.pointing_crop", info2);
                } else {
                  this.cancel();
                  this.editor.root.handleEvent(info2);
                }
              }
              break;
            }
            case "selection": {
              switch (info2.handle) {
                case "mobile_rotate":
                case "top_left_rotate":
                case "top_right_rotate":
                case "bottom_left_rotate":
                case "bottom_right_rotate": {
                  this.editor.setCurrentTool("select.pointing_rotate_handle", {
                    ...info2,
                    onInteractionEnd: "select.crop.idle"
                  });
                  break;
                }
                case "top":
                case "right":
                case "bottom":
                case "left":
                case "top_left":
                case "top_right":
                case "bottom_left":
                case "bottom_right": {
                  this.editor.setCurrentTool("select.crop.pointing_crop_handle", {
                    ...info2,
                    onInteractionEnd: "select.crop.idle"
                  });
                  break;
                }
                default: {
                  this.cancel();
                }
              }
              break;
            }
          }
        });
        __publicField(this, "onDoubleClick", (info2) => {
          if (this.editor.inputs.shiftKey || info2.phase !== "up")
            return;
          const croppingShapeId = this.editor.getCroppingShapeId();
          if (!croppingShapeId)
            return;
          const shape = this.editor.getShape(croppingShapeId);
          if (!shape)
            return;
          const util = this.editor.getShapeUtil(shape);
          if (!util)
            return;
          if (info2.target === "selection") {
            util.onDoubleClickEdge?.(shape);
            return;
          }
          this.cancel();
          this.editor.root.handleEvent(info2);
        });
        __publicField(this, "onKeyDown", () => {
          this.nudgeCroppingImage(false);
        });
        __publicField(this, "onKeyRepeat", () => {
          this.nudgeCroppingImage(true);
        });
        __publicField(this, "onKeyUp", (info2) => {
          switch (info2.code) {
            case "Enter": {
              this.editor.setCroppingShape(null);
              this.editor.setCurrentTool("select.idle", {});
              break;
            }
          }
        });
      }
      cancel() {
        this.editor.setCroppingShape(null);
        this.editor.setCurrentTool("select.idle", {});
      }
      nudgeCroppingImage(ephemeral = false) {
        const {
          editor: {
            inputs: { keys }
          }
        } = this;
        const shiftKey = keys.has("ShiftLeft");
        const delta = new Vec(0, 0);
        if (keys.has("ArrowLeft"))
          delta.x += 1;
        if (keys.has("ArrowRight"))
          delta.x -= 1;
        if (keys.has("ArrowUp"))
          delta.y += 1;
        if (keys.has("ArrowDown"))
          delta.y -= 1;
        if (delta.equals(new Vec(0, 0)))
          return;
        if (shiftKey)
          delta.mul(10);
        const shape = this.editor.getShape(this.editor.getCroppingShapeId());
        if (!shape)
          return;
        const partial = getTranslateCroppedImageChange(this.editor, shape, delta);
        if (partial) {
          if (!ephemeral) {
            this.editor.mark("translate crop");
          }
          this.editor.updateShapes([partial]);
        }
      }
    };
    __publicField(Idle11, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/PointingCrop.mjs
var PointingCrop;
var init_PointingCrop = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/PointingCrop.mjs"() {
    init_dist_esm10();
    PointingCrop = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onCancel", () => {
          this.editor.setCurrentTool("select.crop.idle", {});
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            this.editor.setCurrentTool("select.crop.translating_crop", info2);
          }
        });
        __publicField(this, "onPointerUp", (info2) => {
          this.editor.setCurrentTool("select.crop.idle", info2);
        });
      }
    };
    __publicField(PointingCrop, "id", "pointing_crop");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/PointingCropHandle.mjs
var PointingCropHandle;
var init_PointingCropHandle = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/PointingCropHandle.mjs"() {
    init_dist_esm10();
    init_PointingResizeHandle();
    PointingCropHandle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          const selectedShape = this.editor.getSelectedShapes()[0];
          if (!selectedShape)
            return;
          const cursorType = CursorTypeMap[this.info.handle];
          this.editor.setCursor({ type: cursorType, rotation: this.editor.getSelectionRotation() });
          this.editor.setCroppingShape(selectedShape.id);
        });
        __publicField(this, "onExit", () => {
          this.editor.setCursor({ type: "default", rotation: 0 });
          this.parent.setCurrentToolIdMask(void 0);
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            this.startCropping();
          }
        });
        __publicField(this, "onLongPress", () => {
          this.startCropping();
        });
        __publicField(this, "onPointerUp", () => {
          if (this.info.onInteractionEnd) {
            this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
          } else {
            this.editor.setCroppingShape(null);
            this.editor.setCurrentTool("select.idle");
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      startCropping() {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.parent.transition("cropping", {
          ...this.info,
          onInteractionEnd: this.info.onInteractionEnd
        });
      }
      cancel() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
        } else {
          this.editor.setCroppingShape(null);
          this.editor.setCurrentTool("select.idle");
        }
      }
    };
    __publicField(PointingCropHandle, "id", "pointing_crop_handle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/TranslatingCrop.mjs
var TranslatingCrop;
var init_TranslatingCrop = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/children/TranslatingCrop.mjs"() {
    init_dist_esm10();
    init_crop_helpers();
    TranslatingCrop = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "markId", "translating crop");
        __publicField(this, "snapshot", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.snapshot = this.createSnapshot();
          this.editor.mark(this.markId);
          this.editor.setCursor({ type: "move", rotation: 0 });
          this.updateShapes();
        });
        __publicField(this, "onExit", () => {
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "onPointerMove", () => {
          this.updateShapes();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onKeyDown", (info2) => {
          switch (info2.key) {
            case "Alt":
            case "Shift": {
              this.updateShapes();
              return;
            }
          }
        });
        __publicField(this, "onKeyUp", (info2) => {
          switch (info2.key) {
            case "Enter": {
              this.complete();
              return;
            }
            case "Alt":
            case "Shift": {
              this.updateShapes();
            }
          }
        });
      }
      complete() {
        this.updateShapes();
        this.editor.setCurrentTool("select.crop.idle", this.info);
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        this.editor.setCurrentTool("select.crop.idle", this.info);
      }
      createSnapshot() {
        const shape = this.editor.getOnlySelectedShape();
        return { shape };
      }
      updateShapes() {
        const shape = this.snapshot.shape;
        if (!shape)
          return;
        const { originPagePoint, currentPagePoint } = this.editor.inputs;
        const delta = currentPagePoint.clone().sub(originPagePoint);
        const partial = getTranslateCroppedImageChange(this.editor, shape, delta);
        if (partial) {
          this.editor.updateShapes([partial]);
        }
      }
    };
    __publicField(TranslatingCrop, "id", "translating_crop");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/Crop.mjs
var Crop;
var init_Crop = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Crop/Crop.mjs"() {
    init_dist_esm10();
    init_Cropping();
    init_Idle11();
    init_PointingCrop();
    init_PointingCropHandle();
    init_TranslatingCrop();
    Crop = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "markId", "");
        __publicField(this, "onEnter", () => {
          this.didCancel = false;
          this.markId = "crop";
          this.editor.mark(this.markId);
        });
        __publicField(this, "didCancel", false);
        __publicField(this, "onExit", () => {
          if (this.didCancel) {
            this.editor.bailToMark(this.markId);
          } else {
            this.editor.squashToMark(this.markId);
          }
        });
        __publicField(this, "onCancel", () => {
          this.didCancel = true;
        });
      }
    };
    __publicField(Crop, "id", "crop");
    __publicField(Crop, "initial", "idle");
    __publicField(Crop, "children", () => [
      Idle11,
      TranslatingCrop,
      PointingCrop,
      PointingCropHandle,
      Cropping
    ]);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/DraggingHandle.mjs
var DraggingHandle;
var init_DraggingHandle = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/DraggingHandle.mjs"() {
    init_dist_esm10();
    init_shared();
    init_selectHelpers();
    DraggingHandle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeId", "");
        __publicField(this, "initialHandle", {});
        __publicField(this, "initialAdjacentHandle", null);
        __publicField(this, "initialPagePoint", {});
        __publicField(this, "markId", "");
        __publicField(this, "initialPageTransform");
        __publicField(this, "initialPageRotation");
        __publicField(this, "info", {});
        __publicField(this, "isPrecise", false);
        __publicField(this, "isPreciseId", null);
        __publicField(this, "pointingId", null);
        __publicField(this, "onEnter", (info2) => {
          const { shape, isCreating, handle } = info2;
          this.info = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.shapeId = shape.id;
          this.markId = isCreating ? `creating:${shape.id}` : "dragging handle";
          if (!isCreating)
            this.editor.mark(this.markId);
          this.initialHandle = structuredClone2(handle);
          if (this.editor.isShapeOfType(shape, "line")) {
            if (this.initialHandle.type === "create") {
              this.editor.updateShape({
                ...shape,
                props: {
                  points: {
                    ...shape.props.points,
                    [handle.index]: { id: handle.index, index: handle.index, x: handle.x, y: handle.y }
                  }
                }
              });
              const handlesAfter = this.editor.getShapeHandles(shape);
              const handleAfter = handlesAfter.find((h2) => h2.index === handle.index);
              this.initialHandle = structuredClone2(handleAfter);
            }
          }
          this.initialPageTransform = this.editor.getShapePageTransform(shape);
          this.initialPageRotation = this.initialPageTransform.rotation();
          this.initialPagePoint = this.editor.inputs.originPagePoint.clone();
          this.editor.setCursor({ type: isCreating ? "cross" : "grabbing", rotation: 0 });
          const handles = this.editor.getShapeHandles(shape).sort(sortByIndex);
          const index3 = handles.findIndex((h2) => h2.id === info2.handle.id);
          this.initialAdjacentHandle = null;
          for (let i2 = index3 + 1; i2 < handles.length; i2++) {
            const handle2 = handles[i2];
            if (handle2.type === "vertex" && handle2.id !== "middle" && handle2.id !== info2.handle.id) {
              this.initialAdjacentHandle = handle2;
              break;
            }
          }
          if (!this.initialAdjacentHandle) {
            for (let i2 = handles.length - 1; i2 >= 0; i2--) {
              const handle2 = handles[i2];
              if (handle2.type === "vertex" && handle2.id !== "middle" && handle2.id !== info2.handle.id) {
                this.initialAdjacentHandle = handle2;
                break;
              }
            }
          }
          if (this.editor.isShapeOfType(shape, "arrow")) {
            const initialBinding = getArrowBindings(this.editor, shape)[info2.handle.id];
            this.isPrecise = false;
            if (initialBinding) {
              this.editor.setHintingShapes([initialBinding.toId]);
              this.isPrecise = initialBinding.props.isPrecise;
              if (this.isPrecise) {
                this.isPreciseId = initialBinding.toId;
              } else {
                this.resetExactTimeout();
              }
            } else {
              this.editor.setHintingShapes([]);
            }
          }
          this.update();
          this.editor.select(this.shapeId);
        });
        __publicField(this, "exactTimeout", -1);
        __publicField(this, "onPointerMove", () => {
          this.update();
        });
        __publicField(this, "onKeyDown", () => {
          this.update();
        });
        __publicField(this, "onKeyUp", () => {
          this.update();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.update();
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.editor.setHintingShapes([]);
          this.editor.snaps.clearIndicators();
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
      }
      resetExactTimeout() {
        if (this.exactTimeout !== -1) {
          this.clearExactTimeout();
        }
        this.exactTimeout = this.editor.timers.setTimeout(() => {
          if (this.getIsActive() && !this.isPrecise) {
            this.isPrecise = true;
            this.isPreciseId = this.pointingId;
            this.update();
          }
          this.exactTimeout = -1;
        }, 750);
      }
      clearExactTimeout() {
        if (this.exactTimeout !== -1) {
          clearTimeout(this.exactTimeout);
          this.exactTimeout = -1;
        }
      }
      complete() {
        this.editor.snaps.clearIndicators();
        kickoutOccludedShapes(this.editor, [this.shapeId]);
        const { onInteractionEnd } = this.info;
        if (this.editor.getInstanceState().isToolLocked && onInteractionEnd) {
          this.editor.setCurrentTool(onInteractionEnd, { shapeId: this.shapeId });
          return;
        }
        this.parent.transition("idle");
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        this.editor.snaps.clearIndicators();
        const { onInteractionEnd } = this.info;
        if (onInteractionEnd) {
          this.editor.setCurrentTool(onInteractionEnd, { shapeId: this.shapeId });
          return;
        }
        this.parent.transition("idle");
      }
      update() {
        const { editor, shapeId, initialPagePoint } = this;
        const { initialHandle, initialPageRotation, initialAdjacentHandle } = this;
        const hintingShapeIds = this.editor.getHintingShapeIds();
        const isSnapMode = this.editor.user.getIsSnapMode();
        const {
          snaps,
          inputs: { currentPagePoint, shiftKey, ctrlKey, altKey: altKey2, pointerVelocity }
        } = editor;
        const initial = this.info.shape;
        const shape = editor.getShape(shapeId);
        if (!shape)
          return;
        const util = editor.getShapeUtil(shape);
        let point = currentPagePoint.clone().sub(initialPagePoint).rot(-initialPageRotation).add(initialHandle);
        if (shiftKey && initialAdjacentHandle && initialHandle.id !== "middle") {
          const angle = Vec.Angle(initialAdjacentHandle, point);
          const snappedAngle = snapAngle(angle, 24);
          const angleDifference = snappedAngle - angle;
          point = Vec.RotWith(point, initialAdjacentHandle, angleDifference);
        }
        editor.snaps.clearIndicators();
        let nextHandle = { ...initialHandle, x: point.x, y: point.y };
        if (initialHandle.canSnap && (isSnapMode ? !ctrlKey : ctrlKey)) {
          const pageTransform = editor.getShapePageTransform(shape.id);
          if (!pageTransform)
            throw Error("Expected a page transform");
          const snap = snaps.handles.snapHandle({ currentShapeId: shapeId, handle: nextHandle });
          if (snap) {
            snap.nudge.rot(-editor.getShapeParentTransform(shape).rotation());
            point.add(snap.nudge);
            nextHandle = { ...initialHandle, x: point.x, y: point.y };
          }
        }
        const changes = util.onHandleDrag?.(shape, {
          handle: nextHandle,
          isPrecise: this.isPrecise || altKey2,
          initial
        });
        const next = { id: shape.id, type: shape.type, ...changes };
        if (initialHandle.type === "vertex" && this.editor.isShapeOfType(shape, "arrow")) {
          const bindingAfter = getArrowBindings(editor, shape)[initialHandle.id];
          if (bindingAfter) {
            if (hintingShapeIds[0] !== bindingAfter.toId) {
              editor.setHintingShapes([bindingAfter.toId]);
              this.pointingId = bindingAfter.toId;
              this.isPrecise = pointerVelocity.len() < 0.5 || altKey2;
              this.isPreciseId = this.isPrecise ? bindingAfter.toId : null;
              this.resetExactTimeout();
            }
          } else {
            if (hintingShapeIds.length > 0) {
              editor.setHintingShapes([]);
              this.pointingId = null;
              this.isPrecise = false;
              this.isPreciseId = null;
              this.resetExactTimeout();
            }
          }
        }
        if (changes) {
          editor.updateShapes([next]);
        }
      }
    };
    __publicField(DraggingHandle, "id", "dragging_handle");
  }
});

// node_modules/tldraw/dist-esm/lib/utils/shapes/shapes.mjs
function getTextLabels(geometry) {
  if (geometry.isLabel) {
    return [geometry];
  }
  if (geometry instanceof Group2d) {
    return geometry.children.filter((child) => child.isLabel);
  }
  return [];
}
var init_shapes = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/shapes/shapes.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/EditingShape.mjs
var EditingShape;
var init_EditingShape = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/EditingShape.mjs"() {
    init_dist_esm10();
    init_shapes();
    init_updateHoveredShapeId();
    EditingShape = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "hitShapeForPointerUp", null);
        __publicField(this, "onEnter", () => {
          const editingShape = this.editor.getEditingShape();
          if (!editingShape)
            throw Error("Entered editing state without an editing shape");
          this.hitShapeForPointerUp = null;
          updateHoveredShapeId(this.editor);
          this.editor.select(editingShape);
        });
        __publicField(this, "onExit", () => {
          const { editingShapeId } = this.editor.getCurrentPageState();
          if (!editingShapeId)
            return;
          this.editor.setEditingShape(null);
          updateHoveredShapeId.cancel();
          const shape = this.editor.getShape(editingShapeId);
          const util = this.editor.getShapeUtil(shape);
          util.onEditEnd?.(shape);
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.hitShapeForPointerUp && this.editor.inputs.isDragging) {
            if (this.editor.getInstanceState().isReadonly)
              return;
            if (this.hitShapeForPointerUp.isLocked)
              return;
            this.editor.select(this.hitShapeForPointerUp);
            this.parent.transition("translating", info2);
            this.hitShapeForPointerUp = null;
            return;
          }
          switch (info2.target) {
            case "shape":
            case "canvas": {
              updateHoveredShapeId(this.editor);
              return;
            }
          }
        });
        __publicField(this, "onPointerDown", (info2) => {
          this.hitShapeForPointerUp = null;
          switch (info2.target) {
            case "shape": {
              const { shape: selectingShape } = info2;
              const editingShape = this.editor.getEditingShape();
              if (!editingShape) {
                throw Error("Expected an editing shape!");
              }
              const geometry = this.editor.getShapeUtil(selectingShape).getGeometry(selectingShape);
              const textLabels = getTextLabels(geometry);
              const textLabel = textLabels.length === 1 ? textLabels[0] : void 0;
              const isEmptyTextShape = this.editor.isShapeOfType(editingShape, "text") && editingShape.props.text.trim() === "";
              if (textLabel && !isEmptyTextShape) {
                const pointInShapeSpace = this.editor.getPointInShapeSpace(selectingShape, this.editor.inputs.currentPagePoint);
                if (textLabel.bounds.containsPoint(pointInShapeSpace, 0) && textLabel.hitTestPoint(pointInShapeSpace)) {
                  if (selectingShape.id === editingShape.id) {
                    return;
                  } else {
                    this.hitShapeForPointerUp = selectingShape;
                    this.editor.mark("editing on pointer up");
                    this.editor.select(selectingShape.id);
                    return;
                  }
                }
              } else {
                if (selectingShape.id === editingShape.id) {
                  if (this.editor.isShapeOfType(selectingShape, "frame")) {
                    this.editor.setEditingShape(null);
                    this.parent.transition("idle", info2);
                  }
                } else {
                  this.parent.transition("pointing_shape", info2);
                  return;
                }
                return;
              }
              break;
            }
          }
          this.parent.transition("idle", info2);
          this.editor.root.handleEvent(info2);
        });
        __publicField(this, "onPointerUp", (info2) => {
          const hitShape = this.hitShapeForPointerUp;
          if (!hitShape)
            return;
          this.hitShapeForPointerUp = null;
          const util = this.editor.getShapeUtil(hitShape);
          if (hitShape.isLocked)
            return;
          if (this.editor.getInstanceState().isReadonly) {
            if (!util.canEditInReadOnly(hitShape)) {
              this.parent.transition("pointing_shape", info2);
              return;
            }
          }
          this.editor.select(hitShape.id);
          this.editor.setEditingShape(hitShape.id);
          updateHoveredShapeId(this.editor);
        });
        __publicField(this, "onComplete", (info2) => {
          this.parent.transition("idle", info2);
        });
        __publicField(this, "onCancel", (info2) => {
          this.parent.transition("idle", info2);
        });
      }
    };
    __publicField(EditingShape, "id", "editing_shape");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/selection-logic/getShouldEnterCropModeOnPointerDown.mjs
function getShouldEnterCropMode(editor) {
  const onlySelectedShape = editor.getOnlySelectedShape();
  return !!(onlySelectedShape && !editor.isShapeOrAncestorLocked(onlySelectedShape) && editor.getShapeUtil(onlySelectedShape).canCrop(onlySelectedShape));
}
var init_getShouldEnterCropModeOnPointerDown = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/selection-logic/getShouldEnterCropModeOnPointerDown.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/tools/selection-logic/selectOnCanvasPointerUp.mjs
function selectOnCanvasPointerUp(editor) {
  const selectedShapeIds = editor.getSelectedShapeIds();
  const { shiftKey, altKey: altKey2, currentPagePoint } = editor.inputs;
  const hitShape = editor.getShapeAtPoint(currentPagePoint, {
    hitInside: false,
    margin: editor.options.hitTestMargin / editor.getZoomLevel(),
    hitLabels: true,
    renderingOnly: true,
    filter: (shape) => !shape.isLocked
  });
  if (hitShape) {
    const outermostSelectableShape = editor.getOutermostSelectableShape(hitShape);
    if (shiftKey && !altKey2) {
      editor.cancelDoubleClick();
      if (selectedShapeIds.includes(outermostSelectableShape.id)) {
        editor.mark("deselecting shape");
        editor.deselect(outermostSelectableShape);
      } else {
        editor.mark("shift selecting shape");
        editor.setSelectedShapes([...selectedShapeIds, outermostSelectableShape.id]);
      }
    } else {
      let shapeToSelect = void 0;
      if (outermostSelectableShape === hitShape) {
        shapeToSelect = hitShape;
      } else {
        if (outermostSelectableShape.id === editor.getFocusedGroupId() || selectedShapeIds.includes(outermostSelectableShape.id)) {
          shapeToSelect = hitShape;
        } else {
          shapeToSelect = outermostSelectableShape;
        }
      }
      if (shapeToSelect && !selectedShapeIds.includes(shapeToSelect.id)) {
        editor.mark("selecting shape");
        editor.select(shapeToSelect.id);
      }
    }
  } else {
    if (shiftKey) {
      return;
    } else {
      if (selectedShapeIds.length > 0) {
        editor.mark("selecting none");
        editor.selectNone();
      }
      const focusedGroupId = editor.getFocusedGroupId();
      if (isShapeId(focusedGroupId)) {
        const groupShape = editor.getShape(focusedGroupId);
        if (!editor.isPointInShape(groupShape, currentPagePoint, { margin: 0, hitInside: true })) {
          editor.setFocusedGroup(null);
        }
      }
    }
  }
}
var init_selectOnCanvasPointerUp = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/selection-logic/selectOnCanvasPointerUp.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Idle.mjs
function isPointInRotatedSelectionBounds(editor, point) {
  const selectionBounds = editor.getSelectionRotatedPageBounds();
  if (!selectionBounds)
    return false;
  const selectionRotation = editor.getSelectionRotation();
  if (!selectionRotation)
    return selectionBounds.containsPoint(point);
  return pointInPolygon(point, selectionBounds.corners.map((c2) => Vec.RotWith(c2, selectionBounds.point, selectionRotation)));
}
var SKIPPED_KEYS_FOR_AUTO_EDITING, Idle12, MAJOR_NUDGE_FACTOR, MINOR_NUDGE_FACTOR, GRID_INCREMENT;
var init_Idle12 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Idle.mjs"() {
    init_dist_esm10();
    init_getHitShapeOnCanvasPointerDown();
    init_getShouldEnterCropModeOnPointerDown();
    init_selectOnCanvasPointerUp();
    init_updateHoveredShapeId();
    init_selectHelpers();
    SKIPPED_KEYS_FOR_AUTO_EDITING = [
      "Delete",
      "Backspace",
      "[",
      "]",
      "Enter",
      " ",
      "Shift",
      "Tab"
    ];
    Idle12 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          this.parent.setCurrentToolIdMask(void 0);
          updateHoveredShapeId(this.editor);
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "onExit", () => {
          updateHoveredShapeId.cancel();
        });
        __publicField(this, "onPointerMove", () => {
          updateHoveredShapeId(this.editor);
        });
        __publicField(this, "onPointerDown", (info2) => {
          if (this.editor.getIsMenuOpen())
            return;
          const shouldEnterCropMode = info2.ctrlKey && getShouldEnterCropMode(this.editor);
          if (info2.ctrlKey && !shouldEnterCropMode) {
            if (info2.target === "shape" && this.isDarwin && this.editor.inputs.keys.has("ControlLeft")) {
              if (!this.editor.isShapeOrAncestorLocked(info2.shape)) {
                this.parent.transition("pointing_shape", info2);
                return;
              }
            }
            this.parent.transition("brushing", info2);
            return;
          }
          switch (info2.target) {
            case "canvas": {
              const hitShape = getHitShapeOnCanvasPointerDown(this.editor);
              if (hitShape && !hitShape.isLocked) {
                this.onPointerDown({
                  ...info2,
                  shape: hitShape,
                  target: "shape"
                });
                return;
              }
              const selectedShapeIds = this.editor.getSelectedShapeIds();
              const onlySelectedShape = this.editor.getOnlySelectedShape();
              const {
                inputs: { currentPagePoint }
              } = this.editor;
              if (selectedShapeIds.length > 1 || onlySelectedShape && !this.editor.getShapeUtil(onlySelectedShape).hideSelectionBoundsBg(onlySelectedShape)) {
                if (isPointInRotatedSelectionBounds(this.editor, currentPagePoint)) {
                  this.onPointerDown({
                    ...info2,
                    target: "selection"
                  });
                  return;
                }
              }
              this.parent.transition("pointing_canvas", info2);
              break;
            }
            case "shape": {
              const { shape } = info2;
              if (this.isOverArrowLabelTest(shape)) {
                this.parent.transition("pointing_arrow_label", info2);
                break;
              }
              if (this.editor.isShapeOrAncestorLocked(shape)) {
                this.parent.transition("pointing_canvas", info2);
                break;
              }
              this.parent.transition("pointing_shape", info2);
              break;
            }
            case "handle": {
              if (this.editor.getInstanceState().isReadonly)
                break;
              if (this.editor.inputs.altKey) {
                this.parent.transition("pointing_shape", info2);
              } else {
                this.parent.transition("pointing_handle", info2);
              }
              break;
            }
            case "selection": {
              switch (info2.handle) {
                case "mobile_rotate":
                case "top_left_rotate":
                case "top_right_rotate":
                case "bottom_left_rotate":
                case "bottom_right_rotate": {
                  this.parent.transition("pointing_rotate_handle", info2);
                  break;
                }
                case "top":
                case "right":
                case "bottom":
                case "left":
                case "top_left":
                case "top_right":
                case "bottom_left":
                case "bottom_right": {
                  if (shouldEnterCropMode) {
                    this.parent.transition("crop.pointing_crop_handle", info2);
                  } else {
                    this.parent.transition("pointing_resize_handle", info2);
                  }
                  break;
                }
                default: {
                  const hoveredShape = this.editor.getHoveredShape();
                  if (hoveredShape && !this.editor.getSelectedShapeIds().includes(hoveredShape.id) && !hoveredShape.isLocked) {
                    this.onPointerDown({
                      ...info2,
                      shape: hoveredShape,
                      target: "shape"
                    });
                    return;
                  }
                  this.parent.transition("pointing_selection", info2);
                }
              }
              break;
            }
          }
        });
        __publicField(this, "onDoubleClick", (info2) => {
          if (this.editor.inputs.shiftKey || info2.phase !== "up")
            return;
          switch (info2.target) {
            case "canvas": {
              const hoveredShape = this.editor.getHoveredShape();
              const hitShape = hoveredShape && !this.editor.isShapeOfType(hoveredShape, "group") ? hoveredShape : this.editor.getSelectedShapeAtPoint(this.editor.inputs.currentPagePoint) ?? this.editor.getShapeAtPoint(this.editor.inputs.currentPagePoint, {
                margin: this.editor.options.hitTestMargin / this.editor.getZoomLevel(),
                hitInside: false
              });
              const focusedGroupId = this.editor.getFocusedGroupId();
              if (hitShape) {
                if (this.editor.isShapeOfType(hitShape, "group")) {
                  selectOnCanvasPointerUp(this.editor);
                  return;
                } else {
                  const parent = this.editor.getShape(hitShape.parentId);
                  if (parent && this.editor.isShapeOfType(parent, "group")) {
                    if (focusedGroupId && parent.id === focusedGroupId) {
                    } else {
                      selectOnCanvasPointerUp(this.editor);
                      return;
                    }
                  }
                }
                this.onDoubleClick({
                  ...info2,
                  shape: hitShape,
                  target: "shape"
                });
                return;
              }
              if (!this.editor.inputs.shiftKey) {
                this.handleDoubleClickOnCanvas(info2);
              }
              break;
            }
            case "selection": {
              if (this.editor.getInstanceState().isReadonly)
                break;
              const onlySelectedShape = this.editor.getOnlySelectedShape();
              if (onlySelectedShape) {
                const util = this.editor.getShapeUtil(onlySelectedShape);
                if (!this.canInteractWithShapeInReadOnly(onlySelectedShape)) {
                  return;
                }
                if (info2.handle === "right" || info2.handle === "left" || info2.handle === "top" || info2.handle === "bottom") {
                  const change = util.onDoubleClickEdge?.(onlySelectedShape);
                  if (change) {
                    this.editor.mark("double click edge");
                    this.editor.updateShapes([change]);
                    kickoutOccludedShapes(this.editor, [onlySelectedShape.id]);
                    return;
                  }
                }
                if (util.canCrop(onlySelectedShape) && !this.editor.isShapeOrAncestorLocked(onlySelectedShape)) {
                  this.parent.transition("crop", info2);
                  return;
                }
                if (this.shouldStartEditingShape(onlySelectedShape)) {
                  this.startEditingShape(onlySelectedShape, info2, true);
                }
              }
              break;
            }
            case "shape": {
              const { shape } = info2;
              const util = this.editor.getShapeUtil(shape);
              if (shape.type !== "video" && shape.type !== "embed" && this.editor.getInstanceState().isReadonly)
                break;
              if (util.onDoubleClick) {
                const change = util.onDoubleClick?.(shape);
                if (change) {
                  this.editor.updateShapes([change]);
                  return;
                } else if (util.canCrop(shape) && !this.editor.isShapeOrAncestorLocked(shape)) {
                  this.editor.mark("select and crop");
                  this.editor.select(info2.shape?.id);
                  this.parent.transition("crop", info2);
                  return;
                }
              }
              if (this.shouldStartEditingShape(shape)) {
                this.startEditingShape(shape, info2, true);
              } else {
                this.handleDoubleClickOnCanvas(info2);
              }
              break;
            }
            case "handle": {
              if (this.editor.getInstanceState().isReadonly)
                break;
              const { shape, handle } = info2;
              const util = this.editor.getShapeUtil(shape);
              const changes = util.onDoubleClickHandle?.(shape, handle);
              if (changes) {
                this.editor.updateShapes([changes]);
              } else {
                if (this.shouldStartEditingShape(shape)) {
                  this.startEditingShape(shape, info2, true);
                }
              }
            }
          }
        });
        __publicField(this, "onRightClick", (info2) => {
          switch (info2.target) {
            case "canvas": {
              const hoveredShape = this.editor.getHoveredShape();
              const hitShape = hoveredShape && !this.editor.isShapeOfType(hoveredShape, "group") ? hoveredShape : this.editor.getShapeAtPoint(this.editor.inputs.currentPagePoint, {
                margin: this.editor.options.hitTestMargin / this.editor.getZoomLevel(),
                hitInside: false,
                hitLabels: true,
                hitLocked: true,
                hitFrameInside: false,
                renderingOnly: true
              });
              if (hitShape) {
                this.onRightClick({
                  ...info2,
                  shape: hitShape,
                  target: "shape"
                });
                return;
              }
              const selectedShapeIds = this.editor.getSelectedShapeIds();
              const onlySelectedShape = this.editor.getOnlySelectedShape();
              const {
                inputs: { currentPagePoint }
              } = this.editor;
              if (selectedShapeIds.length > 1 || onlySelectedShape && !this.editor.getShapeUtil(onlySelectedShape).hideSelectionBoundsBg(onlySelectedShape)) {
                if (isPointInRotatedSelectionBounds(this.editor, currentPagePoint)) {
                  this.onRightClick({
                    ...info2,
                    target: "selection"
                  });
                  return;
                }
              }
              this.editor.selectNone();
              break;
            }
            case "shape": {
              const { selectedShapeIds } = this.editor.getCurrentPageState();
              const { shape } = info2;
              const targetShape = this.editor.getOutermostSelectableShape(shape, (parent) => !selectedShapeIds.includes(parent.id));
              if (!selectedShapeIds.includes(targetShape.id) && !this.editor.findShapeAncestor(targetShape, (shape2) => selectedShapeIds.includes(shape2.id))) {
                this.editor.mark("selecting shape");
                this.editor.setSelectedShapes([targetShape.id]);
              }
              break;
            }
          }
        });
        __publicField(this, "onCancel", () => {
          if (this.editor.getFocusedGroupId() !== this.editor.getCurrentPageId() && this.editor.getSelectedShapeIds().length > 0) {
            this.editor.popFocusedGroupId();
          } else {
            this.editor.mark("clearing selection");
            this.editor.selectNone();
          }
        });
        __publicField(this, "onKeyDown", (info2) => {
          switch (info2.code) {
            case "ArrowLeft":
            case "ArrowRight":
            case "ArrowUp":
            case "ArrowDown": {
              this.nudgeSelectedShapes(false);
              return;
            }
          }
          if (debugFlags["editOnType"].get()) {
            if (!SKIPPED_KEYS_FOR_AUTO_EDITING.includes(info2.key) && !info2.altKey && !info2.ctrlKey) {
              const onlySelectedShape = this.editor.getOnlySelectedShape();
              if (onlySelectedShape && this.editor.isShapeOfType(onlySelectedShape, "note") && this.shouldStartEditingShape(onlySelectedShape)) {
                this.startEditingShape(onlySelectedShape, {
                  ...info2,
                  target: "shape",
                  shape: onlySelectedShape
                }, true);
                return;
              }
            }
          }
        });
        __publicField(this, "onKeyRepeat", (info2) => {
          switch (info2.code) {
            case "ArrowLeft":
            case "ArrowRight":
            case "ArrowUp":
            case "ArrowDown": {
              this.nudgeSelectedShapes(true);
              break;
            }
          }
        });
        __publicField(this, "onKeyUp", (info2) => {
          switch (info2.code) {
            case "Enter": {
              const selectedShapes = this.editor.getSelectedShapes();
              if (selectedShapes.every((shape) => this.editor.isShapeOfType(shape, "group"))) {
                this.editor.setSelectedShapes(selectedShapes.flatMap((shape) => this.editor.getSortedChildIdsForParent(shape.id)));
                return;
              }
              const onlySelectedShape = this.editor.getOnlySelectedShape();
              if (onlySelectedShape && this.shouldStartEditingShape(onlySelectedShape)) {
                this.startEditingShape(onlySelectedShape, {
                  ...info2,
                  target: "shape",
                  shape: onlySelectedShape
                }, true);
                return;
              }
              if (getShouldEnterCropMode(this.editor)) {
                this.parent.transition("crop", info2);
              }
              break;
            }
          }
        });
        __publicField(this, "isDarwin", window.navigator.userAgent.toLowerCase().indexOf("mac") > -1);
      }
      shouldStartEditingShape(shape = this.editor.getOnlySelectedShape()) {
        if (!shape)
          return false;
        if (this.editor.isShapeOrAncestorLocked(shape) && shape.type !== "embed")
          return false;
        if (!this.canInteractWithShapeInReadOnly(shape))
          return false;
        return this.editor.getShapeUtil(shape).canEdit(shape);
      }
      startEditingShape(shape, info2, shouldSelectAll) {
        if (this.editor.isShapeOrAncestorLocked(shape) && shape.type !== "embed")
          return;
        this.editor.mark("editing shape");
        startEditingShapeWithLabel(this.editor, shape, shouldSelectAll);
        this.parent.transition("editing_shape", info2);
      }
      isOverArrowLabelTest(shape) {
        if (!shape)
          return false;
        const pointInShapeSpace = this.editor.getPointInShapeSpace(shape, this.editor.inputs.currentPagePoint);
        if (this.editor.isShapeOfType(shape, "arrow")) {
          const labelGeometry = this.editor.getShapeGeometry(shape).children[1];
          if (labelGeometry && pointInPolygon(pointInShapeSpace, labelGeometry.vertices)) {
            return true;
          }
        }
        return false;
      }
      handleDoubleClickOnCanvas(info2) {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.editor.mark("creating text shape");
        const id = createShapeId();
        const { x: x2, y: y2 } = this.editor.inputs.currentPagePoint;
        this.editor.createShapes([
          {
            id,
            type: "text",
            x: x2,
            y: y2,
            props: {
              text: "",
              autoSize: true
            }
          }
        ]);
        const shape = this.editor.getShape(id);
        if (!shape)
          return;
        const util = this.editor.getShapeUtil(shape);
        if (this.editor.getInstanceState().isReadonly) {
          if (!util.canEditInReadOnly(shape)) {
            return;
          }
        }
        this.editor.setEditingShape(id);
        this.editor.select(id);
        this.parent.transition("editing_shape", info2);
      }
      nudgeSelectedShapes(ephemeral = false) {
        const {
          editor: {
            inputs: { keys }
          }
        } = this;
        const shiftKey = keys.has("ShiftLeft");
        const delta = new Vec(0, 0);
        if (keys.has("ArrowLeft"))
          delta.x -= 1;
        if (keys.has("ArrowRight"))
          delta.x += 1;
        if (keys.has("ArrowUp"))
          delta.y -= 1;
        if (keys.has("ArrowDown"))
          delta.y += 1;
        if (delta.equals(new Vec(0, 0)))
          return;
        if (!ephemeral)
          this.editor.mark("nudge shapes");
        const { gridSize } = this.editor.getDocumentSettings();
        const step = this.editor.getInstanceState().isGridMode ? shiftKey ? gridSize * GRID_INCREMENT : gridSize : shiftKey ? MAJOR_NUDGE_FACTOR : MINOR_NUDGE_FACTOR;
        const selectedShapeIds = this.editor.getSelectedShapeIds();
        this.editor.nudgeShapes(selectedShapeIds, delta.mul(step));
        kickoutOccludedShapes(this.editor, selectedShapeIds);
      }
      canInteractWithShapeInReadOnly(shape) {
        if (!this.editor.getInstanceState().isReadonly)
          return true;
        const util = this.editor.getShapeUtil(shape);
        if (util.canEditInReadOnly(shape))
          return true;
        return false;
      }
    };
    __publicField(Idle12, "id", "idle");
    MAJOR_NUDGE_FACTOR = 10;
    MINOR_NUDGE_FACTOR = 1;
    GRID_INCREMENT = 5;
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingArrowLabel.mjs
var PointingArrowLabel;
var init_PointingArrowLabel = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingArrowLabel.mjs"() {
    init_dist_esm10();
    init_shared();
    PointingArrowLabel = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "shapeId", "");
        __publicField(this, "markId", "");
        __publicField(this, "wasAlreadySelected", false);
        __publicField(this, "didDrag", false);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          const { shape } = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.info = info2;
          this.shapeId = shape.id;
          this.didDrag = false;
          this.wasAlreadySelected = this.editor.getOnlySelectedShapeId() === shape.id;
          this.updateCursor();
          const geometry = this.editor.getShapeGeometry(shape);
          const labelGeometry = geometry.children[1];
          if (!labelGeometry) {
            throw Error(`Expected to find an arrow label geometry for shape: ${shape.id}`);
          }
          const { currentPagePoint } = this.editor.inputs;
          const pointInShapeSpace = this.editor.getPointInShapeSpace(shape, currentPagePoint);
          this._labelDragOffset = Vec.Sub(labelGeometry.center, pointInShapeSpace);
          this.markId = "label-drag start";
          this.editor.mark(this.markId);
          this.editor.setSelectedShapes([this.shapeId]);
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "_labelDragOffset", new Vec(0, 0));
        __publicField(this, "onPointerMove", () => {
          const { isDragging } = this.editor.inputs;
          if (!isDragging)
            return;
          const shape = this.editor.getShape(this.shapeId);
          if (!shape)
            return;
          const info2 = getArrowInfo(this.editor, shape);
          const groupGeometry = this.editor.getShapeGeometry(shape);
          const bodyGeometry = groupGeometry.children[0];
          const pointInShapeSpace = this.editor.getPointInShapeSpace(shape, this.editor.inputs.currentPagePoint);
          const nearestPoint = bodyGeometry.nearestPoint(Vec.Add(pointInShapeSpace, this._labelDragOffset));
          let nextLabelPosition;
          if (info2.isStraight) {
            const lineLength = Vec.Dist(info2.start.point, info2.end.point);
            const segmentLength = Vec.Dist(info2.end.point, nearestPoint);
            nextLabelPosition = 1 - segmentLength / lineLength;
          } else {
            const { _center, measure, angleEnd, angleStart } = groupGeometry.children[0];
            nextLabelPosition = getPointInArcT(measure, angleStart, angleEnd, _center.angle(nearestPoint));
          }
          if (isNaN(nextLabelPosition)) {
            nextLabelPosition = 0.5;
          }
          this.didDrag = true;
          this.editor.updateShape({
            id: shape.id,
            type: shape.type,
            props: { labelPosition: nextLabelPosition }
          });
        });
        __publicField(this, "onPointerUp", () => {
          const shape = this.editor.getShape(this.shapeId);
          if (!shape)
            return;
          if (this.didDrag || !this.wasAlreadySelected) {
            this.complete();
          } else {
            this.editor.setEditingShape(shape.id);
            this.editor.setCurrentTool("select.editing_shape");
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      updateCursor() {
        this.editor.setCursor({ type: "grabbing", rotation: 0 });
      }
      complete() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
    };
    __publicField(PointingArrowLabel, "id", "pointing_arrow_label");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingCanvas.mjs
var PointingCanvas;
var init_PointingCanvas = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingCanvas.mjs"() {
    init_dist_esm10();
    init_selectOnCanvasPointerUp();
    PointingCanvas = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "onEnter", () => {
          const { inputs } = this.editor;
          if (!inputs.shiftKey) {
            if (this.editor.getSelectedShapeIds().length > 0) {
              this.editor.mark("selecting none");
              this.editor.selectNone();
            }
          }
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            this.parent.transition("brushing", info2);
          }
        });
        __publicField(this, "onPointerUp", () => {
          selectOnCanvasPointerUp(this.editor);
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onInterrupt", () => {
          this.parent.transition("idle");
        });
      }
      complete() {
        this.parent.transition("idle");
      }
    };
    __publicField(PointingCanvas, "id", "pointing_canvas");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingHandle.mjs
function getNoteForPit(editor, shape, handle, forceNew) {
  const pageTransform = editor.getShapePageTransform(shape.id);
  const pagePoint = pageTransform.point();
  const pageRotation = pageTransform.rotation();
  const pits = getNoteAdjacentPositions(editor, pagePoint, pageRotation, shape.props.growY, 0, shape.props.scale);
  const pit = pits[handle.index];
  if (pit) {
    return getNoteShapeForAdjacentPosition(editor, shape, pit, pageRotation, forceNew);
  }
}
var PointingHandle;
var init_PointingHandle = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingHandle.mjs"() {
    init_dist_esm10();
    init_shared();
    init_noteHelpers();
    init_selectHelpers();
    PointingHandle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          const { shape } = info2;
          if (this.editor.isShapeOfType(shape, "arrow")) {
            const initialBinding = getArrowBindings(this.editor, shape)[info2.handle.id];
            if (initialBinding) {
              this.editor.setHintingShapes([initialBinding.toId]);
            }
          }
          this.editor.setCursor({ type: "grabbing", rotation: 0 });
        });
        __publicField(this, "onExit", () => {
          this.editor.setHintingShapes([]);
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "onPointerUp", () => {
          const { shape, handle } = this.info;
          if (this.editor.isShapeOfType(shape, "note")) {
            const { editor } = this;
            const nextNote = getNoteForPit(editor, shape, handle, false);
            if (nextNote) {
              startEditingShapeWithLabel(editor, nextNote, true);
              return;
            }
          }
          this.parent.transition("idle", this.info);
        });
        __publicField(this, "onPointerMove", () => {
          const { editor } = this;
          if (editor.inputs.isDragging) {
            this.startDraggingHandle();
          }
        });
        __publicField(this, "onLongPress", () => {
          this.startDraggingHandle();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      startDraggingHandle() {
        const { editor } = this;
        if (editor.getInstanceState().isReadonly)
          return;
        const { shape, handle } = this.info;
        if (editor.isShapeOfType(shape, "note")) {
          const nextNote = getNoteForPit(editor, shape, handle, true);
          if (nextNote) {
            const centeredOnPointer = editor.getPointInParentSpace(nextNote, editor.inputs.originPagePoint).sub(Vec.Rot(NOTE_CENTER_OFFSET.clone().mul(shape.props.scale), nextNote.rotation));
            editor.updateShape({ ...nextNote, x: centeredOnPointer.x, y: centeredOnPointer.y });
            editor.setHoveredShape(nextNote.id).select(nextNote.id).setCurrentTool("select.translating", {
              ...this.info,
              target: "shape",
              shape: editor.getShape(nextNote),
              onInteractionEnd: "note",
              isCreating: true,
              onCreate: () => {
                startEditingShapeWithLabel(editor, nextNote, true);
              }
            });
            return;
          }
        }
        this.parent.transition("dragging_handle", this.info);
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(PointingHandle, "id", "pointing_handle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingRotateHandle.mjs
var PointingRotateHandle;
var init_PointingRotateHandle = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingRotateHandle.mjs"() {
    init_dist_esm10();
    init_PointingResizeHandle();
    PointingRotateHandle = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.info = info2;
          this.updateCursor();
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.editor.setCursor({ type: "default", rotation: 0 });
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            this.startRotating();
          }
        });
        __publicField(this, "onLongPress", () => {
          this.startRotating();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      updateCursor() {
        this.editor.setCursor({
          type: CursorTypeMap[this.info.handle],
          rotation: this.editor.getSelectionRotation()
        });
      }
      startRotating() {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.parent.transition("rotating", this.info);
      }
      complete() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
      cancel() {
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
    };
    __publicField(PointingRotateHandle, "id", "pointing_rotate_handle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingSelection.mjs
var PointingSelection;
var init_PointingSelection = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingSelection.mjs"() {
    init_dist_esm10();
    init_selectOnCanvasPointerUp();
    PointingSelection = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
        });
        __publicField(this, "onPointerUp", (info2) => {
          selectOnCanvasPointerUp(this.editor);
          this.parent.transition("idle", info2);
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            this.startTranslating(info2);
          }
        });
        __publicField(this, "onLongPress", (info2) => {
          this.startTranslating(info2);
        });
        __publicField(this, "onDoubleClick", (info2) => {
          const hoveredShape = this.editor.getHoveredShape();
          const hitShape = hoveredShape && !this.editor.isShapeOfType(hoveredShape, "group") ? hoveredShape : this.editor.getShapeAtPoint(this.editor.inputs.currentPagePoint, {
            hitInside: true,
            margin: 0,
            renderingOnly: true
          });
          if (hitShape) {
            this.parent.transition("idle");
            this.parent.onDoubleClick?.({
              ...info2,
              target: "shape",
              shape: this.editor.getShape(hitShape)
            });
            return;
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      startTranslating(info2) {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.parent.transition("translating", info2);
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(PointingSelection, "id", "pointing_selection");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingShape.mjs
var PointingShape;
var init_PointingShape = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/PointingShape.mjs"() {
    init_dist_esm10();
    init_shapes();
    PointingShape = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "hitShape", {});
        __publicField(this, "hitShapeForPointerUp", {});
        __publicField(this, "isDoubleClick", false);
        __publicField(this, "didSelectOnEnter", false);
        __publicField(this, "onEnter", (info2) => {
          const selectedShapeIds = this.editor.getSelectedShapeIds();
          const selectionBounds = this.editor.getSelectionRotatedPageBounds();
          const focusedGroupId = this.editor.getFocusedGroupId();
          const {
            inputs: { currentPagePoint, shiftKey, altKey: altKey2 }
          } = this.editor;
          this.hitShape = info2.shape;
          this.isDoubleClick = false;
          const outermostSelectingShape = this.editor.getOutermostSelectableShape(info2.shape);
          const selectedAncestor = this.editor.findShapeAncestor(outermostSelectingShape, (parent) => selectedShapeIds.includes(parent.id));
          if (this.editor.getShapeUtil(info2.shape).onClick || outermostSelectingShape.id === focusedGroupId || selectedShapeIds.includes(outermostSelectingShape.id) || selectedAncestor || selectedShapeIds.length > 1 && selectionBounds?.containsPoint(currentPagePoint)) {
            this.didSelectOnEnter = false;
            this.hitShapeForPointerUp = outermostSelectingShape;
            return;
          }
          this.didSelectOnEnter = true;
          if (shiftKey && !altKey2) {
            this.editor.cancelDoubleClick();
            if (!selectedShapeIds.includes(outermostSelectingShape.id)) {
              this.editor.mark("shift selecting shape");
              this.editor.setSelectedShapes([...selectedShapeIds, outermostSelectingShape.id]);
            }
          } else {
            this.editor.mark("selecting shape");
            this.editor.setSelectedShapes([outermostSelectingShape.id]);
          }
        });
        __publicField(this, "onPointerUp", (info2) => {
          const selectedShapeIds = this.editor.getSelectedShapeIds();
          const focusedGroupId = this.editor.getFocusedGroupId();
          const zoomLevel = this.editor.getZoomLevel();
          const {
            inputs: { currentPagePoint, shiftKey }
          } = this.editor;
          const hitShape = this.editor.getShapeAtPoint(currentPagePoint, {
            margin: this.editor.options.hitTestMargin / zoomLevel,
            hitInside: true,
            renderingOnly: true
          }) ?? this.hitShape;
          const selectingShape = hitShape ? this.editor.getOutermostSelectableShape(hitShape) : this.hitShapeForPointerUp;
          if (selectingShape) {
            const util = this.editor.getShapeUtil(selectingShape);
            if (util.onClick) {
              const change = util.onClick?.(selectingShape);
              if (change) {
                this.editor.mark("shape on click");
                this.editor.updateShapes([change]);
                this.parent.transition("idle", info2);
                return;
              }
            }
            if (selectingShape.id === focusedGroupId) {
              if (selectedShapeIds.length > 0) {
                this.editor.mark("clearing shape ids");
                this.editor.setSelectedShapes([]);
              } else {
                this.editor.popFocusedGroupId();
              }
              this.parent.transition("idle", info2);
              return;
            }
          }
          if (!this.didSelectOnEnter) {
            const outermostSelectableShape = this.editor.getOutermostSelectableShape(hitShape, (parent) => !selectedShapeIds.includes(parent.id));
            if (selectedShapeIds.includes(outermostSelectableShape.id)) {
              if (shiftKey) {
                this.editor.mark("deselecting on pointer up");
                this.editor.deselect(selectingShape);
              } else {
                if (selectedShapeIds.includes(selectingShape.id)) {
                  if (selectedShapeIds.length === 1) {
                    const geometry = this.editor.getShapeUtil(selectingShape).getGeometry(selectingShape);
                    const textLabels = getTextLabels(geometry);
                    const textLabel = textLabels.length === 1 ? textLabels[0] : void 0;
                    if (textLabel) {
                      const pointInShapeSpace = this.editor.getPointInShapeSpace(selectingShape, currentPagePoint);
                      if (textLabel.bounds.containsPoint(pointInShapeSpace, 0) && textLabel.hitTestPoint(pointInShapeSpace)) {
                        this.editor.run(() => {
                          this.editor.mark("editing on pointer up");
                          this.editor.select(selectingShape.id);
                          const util = this.editor.getShapeUtil(selectingShape);
                          if (this.editor.getInstanceState().isReadonly) {
                            if (!util.canEditInReadOnly(selectingShape)) {
                              return;
                            }
                          }
                          this.editor.setEditingShape(selectingShape.id);
                          this.editor.setCurrentTool("select.editing_shape");
                          if (this.isDoubleClick) {
                            this.editor.emit("select-all-text", { shapeId: selectingShape.id });
                          }
                        });
                        return;
                      }
                    }
                  }
                  this.editor.mark("selecting on pointer up");
                  this.editor.select(selectingShape.id);
                } else {
                  this.editor.mark("selecting on pointer up");
                  this.editor.select(selectingShape);
                }
              }
            } else if (shiftKey) {
              const ancestors = this.editor.getShapeAncestors(outermostSelectableShape);
              this.editor.mark("shift deselecting on pointer up");
              this.editor.setSelectedShapes([
                ...this.editor.getSelectedShapeIds().filter((id) => !ancestors.find((a2) => a2.id === id)),
                outermostSelectableShape.id
              ]);
            } else {
              this.editor.mark("selecting on pointer up");
              this.editor.setSelectedShapes([outermostSelectableShape.id]);
            }
          }
          this.parent.transition("idle", info2);
        });
        __publicField(this, "onDoubleClick", () => {
          this.isDoubleClick = true;
        });
        __publicField(this, "onPointerMove", (info2) => {
          if (this.editor.inputs.isDragging) {
            this.startTranslating(info2);
          }
        });
        __publicField(this, "onLongPress", (info2) => {
          this.startTranslating(info2);
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.cancel();
        });
        __publicField(this, "onInterrupt", () => {
          this.cancel();
        });
      }
      startTranslating(info2) {
        if (this.editor.getInstanceState().isReadonly)
          return;
        this.editor.focus();
        this.parent.transition("translating", info2);
      }
      cancel() {
        this.parent.transition("idle");
      }
    };
    __publicField(PointingShape, "id", "pointing_shape");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Resizing.mjs
function rotateSelectionHandle2(handle, rotation) {
  rotation = rotation % PI2;
  const numSteps = Math.round(rotation / (PI / 4));
  const currentIndex = ORDERED_SELECTION_HANDLES.indexOf(handle);
  return ORDERED_SELECTION_HANDLES[(currentIndex + numSteps) % ORDERED_SELECTION_HANDLES.length];
}
var Resizing, ORDERED_SELECTION_HANDLES;
var init_Resizing = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Resizing.mjs"() {
    init_dist_esm10();
    init_selectHelpers();
    Resizing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "markId", "");
        __publicField(this, "didHoldCommand", false);
        __publicField(this, "creationCursorOffset", { x: 0, y: 0 });
        __publicField(this, "snapshot", {});
        __publicField(this, "onEnter", (info2) => {
          const { isCreating = false, creationCursorOffset = { x: 0, y: 0 } } = info2;
          this.info = info2;
          this.didHoldCommand = false;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.creationCursorOffset = creationCursorOffset;
          this.snapshot = this._createSnapshot();
          if (isCreating) {
            this.markId = `creating:${this.editor.getOnlySelectedShape().id}`;
            this.editor.setCursor({ type: "cross", rotation: 0 });
          } else {
            this.markId = "starting resizing";
            this.editor.mark(this.markId);
          }
          this.handleResizeStart();
          this.updateShapes();
        });
        __publicField(this, "onTick", ({ elapsed }) => {
          const { editor } = this;
          editor.edgeScrollManager.updateEdgeScrolling(elapsed);
        });
        __publicField(this, "onPointerMove", () => {
          this.updateShapes();
        });
        __publicField(this, "onKeyDown", () => {
          this.updateShapes();
        });
        __publicField(this, "onKeyUp", () => {
          this.updateShapes();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.editor.setCursor({ type: "default", rotation: 0 });
          this.editor.snaps.clearIndicators();
        });
        __publicField(this, "_createSnapshot", () => {
          const selectedShapeIds = this.editor.getSelectedShapeIds();
          const selectionRotation = this.editor.getSelectionRotation();
          const {
            inputs: { originPagePoint }
          } = this.editor;
          const selectionBounds = this.editor.getSelectionRotatedPageBounds();
          const dragHandlePoint = Vec.RotWith(selectionBounds.getHandlePoint(this.info.handle), selectionBounds.point, selectionRotation);
          const cursorHandleOffset = Vec.Sub(originPagePoint, dragHandlePoint);
          const shapeSnapshots = /* @__PURE__ */ new Map();
          const frames = [];
          selectedShapeIds.forEach((id) => {
            const shape = this.editor.getShape(id);
            if (shape) {
              if (shape.type === "frame") {
                frames.push({
                  id,
                  children: compact(this.editor.getSortedChildIdsForParent(shape).map((id2) => this.editor.getShape(id2)))
                });
              }
              shapeSnapshots.set(shape.id, this._createShapeSnapshot(shape));
              if (this.editor.isShapeOfType(shape, "frame") && selectedShapeIds.length === 1)
                return;
              this.editor.visitDescendants(shape.id, (descendantId) => {
                const descendent = this.editor.getShape(descendantId);
                if (descendent) {
                  shapeSnapshots.set(descendent.id, this._createShapeSnapshot(descendent));
                  if (this.editor.isShapeOfType(descendent, "frame")) {
                    return false;
                  }
                }
              });
            }
          });
          const canShapesDeform = ![...shapeSnapshots.values()].some((shape) => !areAnglesCompatible(shape.pageRotation, selectionRotation) || shape.isAspectRatioLocked);
          return {
            shapeSnapshots,
            selectionBounds,
            cursorHandleOffset,
            selectionRotation,
            selectedShapeIds,
            canShapesDeform,
            initialSelectionPageBounds: this.editor.getSelectionPageBounds(),
            frames
          };
        });
        __publicField(this, "_createShapeSnapshot", (shape) => {
          const pageTransform = this.editor.getShapePageTransform(shape);
          const util = this.editor.getShapeUtil(shape);
          return {
            shape,
            bounds: this.editor.getShapeGeometry(shape).bounds,
            pageTransform,
            pageRotation: Mat.Decompose(pageTransform).rotation,
            isAspectRatioLocked: util.isAspectRatioLocked(shape)
          };
        });
      }
      cancel() {
        this.editor.bailToMark(this.markId);
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
        } else {
          this.parent.transition("idle");
        }
      }
      complete() {
        kickoutOccludedShapes(this.editor, this.snapshot.selectedShapeIds);
        this.handleResizeEnd();
        if (this.info.isCreating && this.info.onCreate) {
          this.info.onCreate?.(this.editor.getOnlySelectedShape());
          return;
        }
        if (this.editor.getInstanceState().isToolLocked && this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd, {});
          return;
        }
        this.parent.transition("idle");
      }
      handleResizeStart() {
        const { shapeSnapshots } = this.snapshot;
        const changes = [];
        shapeSnapshots.forEach(({ shape }) => {
          const util = this.editor.getShapeUtil(shape);
          const change = util.onResizeStart?.(shape);
          if (change) {
            changes.push(change);
          }
        });
        if (changes.length > 0) {
          this.editor.updateShapes(changes);
        }
      }
      handleResizeEnd() {
        const { shapeSnapshots } = this.snapshot;
        const changes = [];
        shapeSnapshots.forEach(({ shape }) => {
          const current = this.editor.getShape(shape.id);
          const util = this.editor.getShapeUtil(shape);
          const change = util.onResizeEnd?.(shape, current);
          if (change) {
            changes.push(change);
          }
        });
        if (changes.length > 0) {
          this.editor.updateShapes(changes);
        }
      }
      updateShapes() {
        const { altKey: altKey2, shiftKey } = this.editor.inputs;
        const {
          frames,
          shapeSnapshots,
          selectionBounds,
          cursorHandleOffset,
          selectedShapeIds,
          selectionRotation,
          canShapesDeform
        } = this.snapshot;
        let isAspectRatioLocked = shiftKey || !canShapesDeform;
        if (shapeSnapshots.size === 1) {
          const onlySnapshot = [...shapeSnapshots.values()][0];
          if (this.editor.isShapeOfType(onlySnapshot.shape, "text")) {
            isAspectRatioLocked = !(this.info.handle === "left" || this.info.handle === "right");
          }
        }
        const { ctrlKey } = this.editor.inputs;
        const currentPagePoint = this.editor.inputs.currentPagePoint.clone().sub(cursorHandleOffset).sub(this.creationCursorOffset);
        const originPagePoint = this.editor.inputs.originPagePoint.clone().sub(cursorHandleOffset);
        if (this.editor.getInstanceState().isGridMode && !ctrlKey) {
          const { gridSize } = this.editor.getDocumentSettings();
          currentPagePoint.snapToGrid(gridSize);
        }
        const dragHandle = this.info.handle;
        const scaleOriginHandle = rotateSelectionHandle2(dragHandle, Math.PI);
        this.editor.snaps.clearIndicators();
        const shouldSnap = this.editor.user.getIsSnapMode() ? !ctrlKey : ctrlKey;
        if (shouldSnap && selectionRotation % HALF_PI === 0) {
          const { nudge } = this.editor.snaps.shapeBounds.snapResizeShapes({
            dragDelta: Vec.Sub(currentPagePoint, originPagePoint),
            initialSelectionPageBounds: this.snapshot.initialSelectionPageBounds,
            handle: rotateSelectionHandle2(dragHandle, selectionRotation),
            isAspectRatioLocked,
            isResizingFromCenter: altKey2
          });
          currentPagePoint.add(nudge);
        }
        const scaleOriginPage = Vec.RotWith(altKey2 ? selectionBounds.center : selectionBounds.getHandlePoint(scaleOriginHandle), selectionBounds.point, selectionRotation);
        const distanceFromScaleOriginNow = Vec.Sub(currentPagePoint, scaleOriginPage).rot(-selectionRotation);
        const distanceFromScaleOriginAtStart = Vec.Sub(originPagePoint, scaleOriginPage).rot(-selectionRotation);
        const scale = Vec.DivV(distanceFromScaleOriginNow, distanceFromScaleOriginAtStart);
        if (!Number.isFinite(scale.x))
          scale.x = 1;
        if (!Number.isFinite(scale.y))
          scale.y = 1;
        const isXLocked = dragHandle === "top" || dragHandle === "bottom";
        const isYLocked = dragHandle === "left" || dragHandle === "right";
        if (isAspectRatioLocked) {
          if (isYLocked) {
            scale.y = Math.abs(scale.x);
          } else if (isXLocked) {
            scale.x = Math.abs(scale.y);
          } else if (Math.abs(scale.x) > Math.abs(scale.y)) {
            scale.y = Math.abs(scale.x) * (scale.y < 0 ? -1 : 1);
          } else {
            scale.x = Math.abs(scale.y) * (scale.x < 0 ? -1 : 1);
          }
        } else {
          if (isXLocked) {
            scale.x = 1;
          }
          if (isYLocked) {
            scale.y = 1;
          }
        }
        if (!this.info.isCreating) {
          this.updateCursor({
            dragHandle,
            isFlippedX: scale.x < 0,
            isFlippedY: scale.y < 0,
            rotation: selectionRotation
          });
        }
        for (const id of shapeSnapshots.keys()) {
          const snapshot = shapeSnapshots.get(id);
          this.editor.resizeShape(id, scale, {
            initialShape: snapshot.shape,
            initialBounds: snapshot.bounds,
            initialPageTransform: snapshot.pageTransform,
            dragHandle,
            mode: selectedShapeIds.length === 1 && id === selectedShapeIds[0] ? "resize_bounds" : "scale_shape",
            scaleOrigin: scaleOriginPage,
            isAspectRatioLocked,
            scaleAxisRotation: selectionRotation,
            skipStartAndEndCallbacks: true
          });
        }
        if (this.editor.inputs.ctrlKey) {
          this.didHoldCommand = true;
          for (const { id, children } of frames) {
            if (!children.length)
              continue;
            const initial = shapeSnapshots.get(id).shape;
            const current = this.editor.getShape(id);
            if (!(initial && current))
              continue;
            const dx = current.x - initial.x;
            const dy = current.y - initial.y;
            const delta = new Vec(dx, dy).rot(-initial.rotation);
            if (delta.x !== 0 || delta.y !== 0) {
              for (const child of children) {
                this.editor.updateShape({
                  id: child.id,
                  type: child.type,
                  x: child.x - delta.x,
                  y: child.y - delta.y
                });
              }
            }
          }
        } else if (this.didHoldCommand) {
          this.didHoldCommand = false;
          for (const { children } of frames) {
            if (!children.length)
              continue;
            for (const child of children) {
              this.editor.updateShape({
                id: child.id,
                type: child.type,
                x: child.x,
                y: child.y
              });
            }
          }
        }
      }
      updateCursor({
        dragHandle,
        isFlippedX,
        isFlippedY,
        rotation
      }) {
        const nextCursor = { ...this.editor.getInstanceState().cursor };
        switch (dragHandle) {
          case "top_left":
          case "bottom_right": {
            nextCursor.type = "nwse-resize";
            if (isFlippedX !== isFlippedY) {
              nextCursor.type = "nesw-resize";
            }
            break;
          }
          case "top_right":
          case "bottom_left": {
            nextCursor.type = "nesw-resize";
            if (isFlippedX !== isFlippedY) {
              nextCursor.type = "nwse-resize";
            }
            break;
          }
        }
        nextCursor.rotation = rotation;
        this.editor.setCursor(nextCursor);
      }
    };
    __publicField(Resizing, "id", "resizing");
    ORDERED_SELECTION_HANDLES = [
      "top",
      "top_right",
      "right",
      "bottom_right",
      "bottom",
      "bottom_left",
      "left",
      "top_left"
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Rotating.mjs
var ONE_DEGREE, Rotating;
var init_Rotating = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Rotating.mjs"() {
    init_dist_esm10();
    init_selectHelpers();
    init_PointingResizeHandle();
    ONE_DEGREE = Math.PI / 180;
    Rotating = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "snapshot", {});
        __publicField(this, "info", {});
        __publicField(this, "markId", "");
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.markId = "rotate start";
          this.editor.mark(this.markId);
          const snapshot = getRotationSnapshot({ editor: this.editor });
          if (!snapshot)
            return this.parent.transition("idle", this.info);
          this.snapshot = snapshot;
          const newSelectionRotation = this._getRotationFromPointerPosition({
            snapToNearestDegree: false
          });
          applyRotationToSnapshotShapes({
            editor: this.editor,
            delta: this._getRotationFromPointerPosition({ snapToNearestDegree: false }),
            snapshot: this.snapshot,
            stage: "start"
          });
          this.editor.setCursor({
            type: CursorTypeMap[this.info.handle],
            rotation: newSelectionRotation + this.snapshot.initialSelectionRotation
          });
        });
        __publicField(this, "onExit", () => {
          this.editor.setCursor({ type: "default", rotation: 0 });
          this.parent.setCurrentToolIdMask(void 0);
          this.snapshot = {};
        });
        __publicField(this, "onPointerMove", () => {
          this.update();
        });
        __publicField(this, "onKeyDown", () => {
          this.update();
        });
        __publicField(this, "onKeyUp", () => {
          this.update();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "update", () => {
          const newSelectionRotation = this._getRotationFromPointerPosition({
            snapToNearestDegree: false
          });
          applyRotationToSnapshotShapes({
            editor: this.editor,
            delta: newSelectionRotation,
            snapshot: this.snapshot,
            stage: "update"
          });
          this.editor.setCursor({
            type: CursorTypeMap[this.info.handle],
            rotation: newSelectionRotation + this.snapshot.initialSelectionRotation
          });
        });
        __publicField(this, "cancel", () => {
          this.editor.bailToMark(this.markId);
          if (this.info.onInteractionEnd) {
            this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
          } else {
            this.parent.transition("idle", this.info);
          }
        });
        __publicField(this, "complete", () => {
          applyRotationToSnapshotShapes({
            editor: this.editor,
            delta: this._getRotationFromPointerPosition({ snapToNearestDegree: true }),
            snapshot: this.snapshot,
            stage: "end"
          });
          kickoutOccludedShapes(this.editor, this.snapshot.shapeSnapshots.map((s2) => s2.shape.id));
          if (this.info.onInteractionEnd) {
            this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
          } else {
            this.parent.transition("idle", this.info);
          }
        });
      }
      _getRotationFromPointerPosition({ snapToNearestDegree }) {
        const selectionRotation = this.editor.getSelectionRotation();
        const selectionBounds = this.editor.getSelectionRotatedPageBounds();
        const {
          inputs: { shiftKey, currentPagePoint }
        } = this.editor;
        const { initialCursorAngle, initialSelectionRotation } = this.snapshot;
        if (!selectionBounds)
          return initialSelectionRotation;
        const selectionPageCenter = selectionBounds.center.clone().rotWith(selectionBounds.point, selectionRotation);
        const preSnapRotationDelta = selectionPageCenter.angle(currentPagePoint) - initialCursorAngle;
        let newSelectionRotation = initialSelectionRotation + preSnapRotationDelta;
        if (shiftKey) {
          newSelectionRotation = snapAngle(newSelectionRotation, 24);
        } else if (snapToNearestDegree) {
          newSelectionRotation = Math.round(newSelectionRotation / ONE_DEGREE) * ONE_DEGREE;
          if (this.editor.getInstanceState().isCoarsePointer) {
            const snappedToRightAngle = snapAngle(newSelectionRotation, 4);
            const angleToRightAngle = shortAngleDist(newSelectionRotation, snappedToRightAngle);
            if (Math.abs(angleToRightAngle) < degreesToRadians(5)) {
              newSelectionRotation = snappedToRightAngle;
            }
          }
        }
        return newSelectionRotation - initialSelectionRotation;
      }
    };
    __publicField(Rotating, "id", "rotating");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/ScribbleBrushing.mjs
var ScribbleBrushing;
var init_ScribbleBrushing = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/ScribbleBrushing.mjs"() {
    init_dist_esm10();
    ScribbleBrushing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "hits", /* @__PURE__ */ new Set());
        __publicField(this, "size", 0);
        __publicField(this, "scribbleId", "id");
        __publicField(this, "initialSelectedShapeIds", /* @__PURE__ */ new Set());
        __publicField(this, "newlySelectedShapeIds", /* @__PURE__ */ new Set());
        __publicField(this, "onEnter", () => {
          this.initialSelectedShapeIds = new Set(this.editor.inputs.shiftKey ? this.editor.getSelectedShapeIds() : []);
          this.newlySelectedShapeIds = /* @__PURE__ */ new Set();
          this.size = 0;
          this.hits.clear();
          const scribbleItem = this.editor.scribbles.addScribble({
            color: "selection-stroke",
            opacity: 0.32,
            size: 12
          });
          this.scribbleId = scribbleItem.id;
          this.updateScribbleSelection(true);
          this.editor.updateInstanceState({ brush: null });
        });
        __publicField(this, "onExit", () => {
          this.editor.scribbles.stop(this.scribbleId);
        });
        __publicField(this, "onPointerMove", () => {
          this.updateScribbleSelection(true);
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onKeyDown", () => {
          this.updateScribbleSelection(false);
        });
        __publicField(this, "onKeyUp", () => {
          if (!this.editor.inputs.altKey) {
            this.parent.transition("brushing");
          } else {
            this.updateScribbleSelection(false);
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "pushPointToScribble", () => {
          const { x: x2, y: y2 } = this.editor.inputs.currentPagePoint;
          this.editor.scribbles.addPoint(this.scribbleId, x2, y2);
        });
      }
      updateScribbleSelection(addPoint) {
        const { editor } = this;
        const currentPageShapes = this.editor.getCurrentPageShapes();
        const {
          inputs: { shiftKey, originPagePoint, previousPagePoint, currentPagePoint }
        } = this.editor;
        const { newlySelectedShapeIds, initialSelectedShapeIds } = this;
        if (addPoint) {
          this.pushPointToScribble();
        }
        const shapes = currentPageShapes;
        let shape, geometry, A2, B;
        const minDist = 0;
        for (let i2 = 0, n2 = shapes.length; i2 < n2; i2++) {
          shape = shapes[i2];
          if (editor.isShapeOfType(shape, "group") || newlySelectedShapeIds.has(shape.id) || editor.isShapeOrAncestorLocked(shape)) {
            continue;
          }
          geometry = editor.getShapeGeometry(shape);
          if (editor.isShapeOfType(shape, "frame") && geometry.bounds.containsPoint(editor.getPointInShapeSpace(shape, originPagePoint))) {
            continue;
          }
          const pageTransform = editor.getShapePageTransform(shape);
          if (!geometry || !pageTransform)
            continue;
          const pt = pageTransform.clone().invert();
          A2 = pt.applyToPoint(previousPagePoint);
          B = pt.applyToPoint(currentPagePoint);
          const { bounds } = geometry;
          if (bounds.minX - minDist > Math.max(A2.x, B.x) || bounds.minY - minDist > Math.max(A2.y, B.y) || bounds.maxX + minDist < Math.min(A2.x, B.x) || bounds.maxY + minDist < Math.min(A2.y, B.y)) {
            continue;
          }
          if (geometry.hitTestLineSegment(A2, B, minDist)) {
            const outermostShape = this.editor.getOutermostSelectableShape(shape);
            const pageMask = this.editor.getShapeMask(outermostShape.id);
            if (pageMask) {
              const intersection = intersectLineSegmentPolygon(previousPagePoint, currentPagePoint, pageMask);
              if (intersection !== null) {
                const isInMask = pointInPolygon(currentPagePoint, pageMask);
                if (!isInMask)
                  continue;
              }
            }
            newlySelectedShapeIds.add(outermostShape.id);
          }
        }
        const current = editor.getSelectedShapeIds();
        const next = new Set(shiftKey ? [...newlySelectedShapeIds, ...initialSelectedShapeIds] : [...newlySelectedShapeIds]);
        if (current.length !== next.size || current.some((id) => !next.has(id))) {
          this.editor.setSelectedShapes(Array.from(next));
        }
      }
      complete() {
        this.updateScribbleSelection(true);
        this.parent.transition("idle");
      }
      cancel() {
        this.editor.setSelectedShapes([...this.initialSelectedShapeIds]);
        this.parent.transition("idle");
      }
    };
    __publicField(ScribbleBrushing, "id", "scribble_brushing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/DragAndDropManager.mjs
var INITIAL_POINTER_LAG_DURATION, FAST_POINTER_LAG_DURATION, DragAndDropManager;
var init_DragAndDropManager = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/DragAndDropManager.mjs"() {
    init_dist_esm10();
    init_selectHelpers();
    INITIAL_POINTER_LAG_DURATION = 20;
    FAST_POINTER_LAG_DURATION = 100;
    DragAndDropManager = class {
      constructor(editor) {
        __publicField(this, "prevDroppingShapeId", null);
        __publicField(this, "droppingNodeTimer", null);
        __publicField(this, "first", true);
        __publicField(this, "dispose", () => {
          this.clear();
        });
        this.editor = editor;
        editor.disposables.add(this.dispose);
      }
      updateDroppingNode(movingShapes, cb) {
        if (this.first) {
          this.editor.setHintingShapes(movingShapes.map((s2) => this.editor.findShapeAncestor(s2, (v2) => v2.type !== "group")).filter((s2) => s2));
          this.prevDroppingShapeId = this.editor.getDroppingOverShape(this.editor.inputs.originPagePoint, movingShapes)?.id ?? null;
          this.first = false;
        }
        if (this.droppingNodeTimer === null) {
          this.setDragTimer(movingShapes, INITIAL_POINTER_LAG_DURATION, cb);
        } else if (this.editor.inputs.pointerVelocity.len() > 0.5) {
          clearTimeout(this.droppingNodeTimer);
          this.setDragTimer(movingShapes, FAST_POINTER_LAG_DURATION, cb);
        }
      }
      setDragTimer(movingShapes, duration, cb) {
        this.droppingNodeTimer = this.editor.timers.setTimeout(() => {
          this.editor.run(() => {
            this.handleDrag(this.editor.inputs.currentPagePoint, movingShapes, cb);
          });
          this.droppingNodeTimer = null;
        }, duration);
      }
      handleDrag(point, movingShapes, cb) {
        movingShapes = compact(movingShapes.map((shape) => this.editor.getShape(shape.id)));
        const nextDroppingShapeId = this.editor.getDroppingOverShape(point, movingShapes)?.id ?? null;
        if (nextDroppingShapeId === this.prevDroppingShapeId) {
          this.hintParents(movingShapes);
          return;
        }
        const { prevDroppingShapeId } = this;
        const prevDroppingShape = prevDroppingShapeId && this.editor.getShape(prevDroppingShapeId);
        const nextDroppingShape = nextDroppingShapeId && this.editor.getShape(nextDroppingShapeId);
        if (prevDroppingShape) {
          this.editor.getShapeUtil(prevDroppingShape).onDragShapesOut?.(prevDroppingShape, movingShapes);
        }
        if (nextDroppingShape) {
          this.editor.getShapeUtil(nextDroppingShape).onDragShapesOver?.(nextDroppingShape, movingShapes);
        }
        this.hintParents(movingShapes);
        cb?.();
        this.prevDroppingShapeId = nextDroppingShapeId;
      }
      hintParents(movingShapes) {
        const shapesGroupedByAncestor = /* @__PURE__ */ new Map();
        for (const shape of movingShapes) {
          const ancestor = this.editor.findShapeAncestor(shape, (v2) => v2.type !== "group");
          if (!ancestor)
            continue;
          if (!shapesGroupedByAncestor.has(ancestor.id)) {
            shapesGroupedByAncestor.set(ancestor.id, []);
          }
          shapesGroupedByAncestor.get(ancestor.id).push(shape.id);
        }
        const hintingShapes = [];
        for (const [ancestorId, shapeIds] of shapesGroupedByAncestor) {
          const ancestor = this.editor.getShape(ancestorId);
          if (!ancestor)
            continue;
          if (getOccludedChildren(this.editor, ancestor).length < shapeIds.length) {
            hintingShapes.push(ancestor.id);
          }
        }
        this.editor.setHintingShapes(hintingShapes);
      }
      dropShapes(shapes) {
        const { prevDroppingShapeId } = this;
        this.handleDrag(this.editor.inputs.currentPagePoint, shapes);
        if (prevDroppingShapeId) {
          const shape = this.editor.getShape(prevDroppingShapeId);
          if (!shape)
            return;
          this.editor.getShapeUtil(shape).onDropShapesOver?.(shape, shapes);
        }
      }
      clear() {
        this.prevDroppingShapeId = null;
        if (this.droppingNodeTimer !== null) {
          clearTimeout(this.droppingNodeTimer);
        }
        this.droppingNodeTimer = null;
        this.editor.setHintingShapes([]);
        this.first = true;
      }
    };
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Translating.mjs
function getTranslatingSnapshot(editor) {
  const movingShapes = [];
  const pagePoints = [];
  const selectedShapeIds = editor.getSelectedShapeIds();
  const shapeSnapshots = compact(selectedShapeIds.map((id) => {
    const shape = editor.getShape(id);
    if (!shape)
      return null;
    movingShapes.push(shape);
    const pageTransform = editor.getShapePageTransform(id);
    const pagePoint = pageTransform.point();
    const pageRotation = pageTransform.rotation();
    pagePoints.push(pagePoint);
    const parentTransform = PageRecordType.isId(shape.parentId) ? null : Mat.Inverse(editor.getShapePageTransform(shape.parentId));
    return {
      shape,
      pagePoint,
      pageRotation,
      parentTransform
    };
  }));
  const onlySelectedShape = editor.getOnlySelectedShape();
  let initialSnapPoints = [];
  if (onlySelectedShape) {
    initialSnapPoints = editor.snaps.shapeBounds.getSnapPoints(onlySelectedShape.id);
  } else {
    const selectionPageBounds = editor.getSelectionPageBounds();
    if (selectionPageBounds) {
      initialSnapPoints = selectionPageBounds.cornersAndCenter.map((p2, i2) => ({
        id: "selection:" + i2,
        x: p2.x,
        y: p2.y
      }));
    }
  }
  let noteAdjacentPositions;
  let noteSnapshot;
  const { originPagePoint } = editor.inputs;
  const allHoveredNotes = shapeSnapshots.filter((s2) => editor.isShapeOfType(s2.shape, "note") && editor.isPointInShape(s2.shape, originPagePoint));
  if (allHoveredNotes.length === 0) {
  } else if (allHoveredNotes.length === 1) {
    noteSnapshot = allHoveredNotes[0];
  } else {
    const allShapesSorted = editor.getCurrentPageShapesSorted();
    noteSnapshot = allHoveredNotes.map((s2) => ({
      snapshot: s2,
      index: allShapesSorted.findIndex((shape) => shape.id === s2.shape.id)
    })).sort((a2, b2) => b2.index - a2.index)[0]?.snapshot;
  }
  if (noteSnapshot) {
    noteAdjacentPositions = getAvailableNoteAdjacentPositions(editor, noteSnapshot.pageRotation, noteSnapshot.shape.props.scale, noteSnapshot.shape.props.growY ?? 0);
  }
  return {
    averagePagePoint: Vec.Average(pagePoints),
    movingShapes,
    shapeSnapshots,
    initialPageBounds: editor.getSelectionPageBounds(),
    initialSnapPoints,
    noteAdjacentPositions,
    noteSnapshot
  };
}
function moveShapesToPoint({
  editor,
  snapshot
}) {
  const { inputs } = editor;
  const {
    noteSnapshot,
    noteAdjacentPositions,
    initialPageBounds,
    initialSnapPoints,
    shapeSnapshots,
    averagePagePoint
  } = snapshot;
  const isGridMode = editor.getInstanceState().isGridMode;
  const gridSize = editor.getDocumentSettings().gridSize;
  const delta = Vec.Sub(inputs.currentPagePoint, inputs.originPagePoint);
  const flatten = editor.inputs.shiftKey ? Math.abs(delta.x) < Math.abs(delta.y) ? "x" : "y" : null;
  if (flatten === "x") {
    delta.x = 0;
  } else if (flatten === "y") {
    delta.y = 0;
  }
  editor.snaps.clearIndicators();
  const isSnapping = editor.user.getIsSnapMode() ? !inputs.ctrlKey : inputs.ctrlKey;
  if (isSnapping && editor.inputs.pointerVelocity.len() < 0.5) {
    const { nudge } = editor.snaps.shapeBounds.snapTranslateShapes({
      dragDelta: delta,
      initialSelectionPageBounds: initialPageBounds,
      lockedAxis: flatten,
      initialSelectionSnapPoints: initialSnapPoints
    });
    delta.add(nudge);
  } else {
    if (noteSnapshot && noteAdjacentPositions) {
      const { scale } = noteSnapshot.shape.props;
      const pageCenter = noteSnapshot.pagePoint.clone().add(delta).add(NOTE_CENTER_OFFSET.clone().mul(scale).rot(noteSnapshot.pageRotation));
      let min4 = NOTE_ADJACENT_POSITION_SNAP_RADIUS / editor.getZoomLevel();
      let offset5 = new Vec(0, 0);
      for (const pit of noteAdjacentPositions) {
        const deltaToPit = Vec.Sub(pageCenter, pit);
        const dist = deltaToPit.len();
        if (dist < min4) {
          min4 = dist;
          offset5 = deltaToPit;
        }
      }
      delta.sub(offset5);
    }
  }
  const averageSnappedPoint = Vec.Add(averagePagePoint, delta);
  if (isGridMode && !inputs.ctrlKey) {
    averageSnappedPoint.snapToGrid(gridSize);
  }
  const averageSnap = Vec.Sub(averageSnappedPoint, averagePagePoint);
  editor.updateShapes(compact(shapeSnapshots.map(({ shape, pagePoint, parentTransform }) => {
    const newPagePoint = Vec.Add(pagePoint, averageSnap);
    const newLocalPoint = parentTransform ? Mat.applyToPoint(parentTransform, newPagePoint) : newPagePoint;
    return {
      id: shape.id,
      type: shape.type,
      x: newLocalPoint.x,
      y: newLocalPoint.y
    };
  })));
}
var Translating;
var init_Translating = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/childStates/Translating.mjs"() {
    init_dist_esm10();
    init_noteHelpers();
    init_DragAndDropManager();
    init_selectHelpers();
    Translating = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "selectionSnapshot", {});
        __publicField(this, "snapshot", {});
        __publicField(this, "markId", "");
        __publicField(this, "isCloning", false);
        __publicField(this, "isCreating", false);
        __publicField(this, "onCreate", () => void 0);
        __publicField(this, "dragAndDropManager", new DragAndDropManager(this.editor));
        __publicField(this, "onEnter", (info2) => {
          const { isCreating = false, onCreate: onCreate2 = () => void 0 } = info2;
          if (!this.editor.getSelectedShapeIds()?.length) {
            this.parent.transition("idle");
            return;
          }
          this.info = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.isCreating = isCreating;
          this.onCreate = onCreate2;
          if (isCreating) {
            this.markId = `creating:${this.editor.getOnlySelectedShape().id}`;
          } else {
            this.markId = "translating";
            this.editor.mark(this.markId);
          }
          this.isCloning = false;
          this.info = info2;
          this.editor.setCursor({ type: "move", rotation: 0 });
          this.selectionSnapshot = getTranslatingSnapshot(this.editor);
          if (!this.isCreating) {
            if (this.editor.inputs.altKey) {
              this.startCloning();
              return;
            }
          }
          this.snapshot = this.selectionSnapshot;
          this.handleStart();
          this.updateShapes();
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.selectionSnapshot = {};
          this.snapshot = {};
          this.editor.snaps.clearIndicators();
          this.editor.setCursor({ type: "default", rotation: 0 });
          this.dragAndDropManager.clear();
        });
        __publicField(this, "onTick", ({ elapsed }) => {
          const { editor } = this;
          this.dragAndDropManager.updateDroppingNode(this.snapshot.movingShapes, this.updateParentTransforms);
          editor.edgeScrollManager.updateEdgeScrolling(elapsed);
        });
        __publicField(this, "onPointerMove", () => {
          this.updateShapes();
        });
        __publicField(this, "onKeyDown", () => {
          if (this.editor.inputs.altKey && !this.isCloning) {
            this.startCloning();
            return;
          }
          this.updateShapes();
        });
        __publicField(this, "onKeyUp", () => {
          if (!this.editor.inputs.altKey && this.isCloning) {
            this.stopCloning();
            return;
          }
          this.updateShapes();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onComplete", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
        __publicField(this, "updateParentTransforms", () => {
          const {
            editor,
            snapshot: { shapeSnapshots }
          } = this;
          const movingShapes = [];
          shapeSnapshots.forEach((shapeSnapshot) => {
            const shape = editor.getShape(shapeSnapshot.shape.id);
            if (!shape)
              return null;
            movingShapes.push(shape);
            const parentTransform = isPageId(shape.parentId) ? null : Mat.Inverse(editor.getShapePageTransform(shape.parentId));
            shapeSnapshot.parentTransform = parentTransform;
          });
        });
      }
      startCloning() {
        if (this.isCreating)
          return;
        this.isCloning = true;
        this.reset();
        this.markId = "translating";
        this.editor.mark(this.markId);
        this.editor.duplicateShapes(Array.from(this.editor.getSelectedShapeIds()));
        this.snapshot = getTranslatingSnapshot(this.editor);
        this.handleStart();
        this.updateShapes();
      }
      stopCloning() {
        this.isCloning = false;
        this.snapshot = this.selectionSnapshot;
        this.reset();
        this.markId = "translating";
        this.editor.mark(this.markId);
        this.updateShapes();
      }
      reset() {
        this.editor.bailToMark(this.markId);
      }
      complete() {
        this.updateShapes();
        this.dragAndDropManager.dropShapes(this.snapshot.movingShapes);
        kickoutOccludedShapes(this.editor, this.snapshot.movingShapes.map((s2) => s2.id));
        this.handleEnd();
        if (this.editor.getInstanceState().isToolLocked && this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd);
        } else {
          if (this.isCreating) {
            this.onCreate?.(this.editor.getOnlySelectedShape());
          } else {
            this.parent.transition("idle");
          }
        }
      }
      cancel() {
        this.reset();
        if (this.info.onInteractionEnd) {
          this.editor.setCurrentTool(this.info.onInteractionEnd);
        } else {
          this.parent.transition("idle", this.info);
        }
      }
      handleStart() {
        const { movingShapes } = this.snapshot;
        const changes = [];
        movingShapes.forEach((shape) => {
          const util = this.editor.getShapeUtil(shape);
          const change = util.onTranslateStart?.(shape);
          if (change) {
            changes.push(change);
          }
        });
        if (changes.length > 0) {
          this.editor.updateShapes(changes);
        }
        this.editor.setHoveredShape(null);
      }
      handleEnd() {
        const { movingShapes } = this.snapshot;
        if (this.isCloning && movingShapes.length > 0) {
          const currentAveragePagePoint = Vec.Average(movingShapes.map((s2) => this.editor.getShapePageTransform(s2.id).point()));
          const offset5 = Vec.Sub(currentAveragePagePoint, this.selectionSnapshot.averagePagePoint);
          if (!Vec.IsNaN(offset5)) {
            this.editor.updateInstanceState({
              duplicateProps: {
                shapeIds: movingShapes.map((s2) => s2.id),
                offset: { x: offset5.x, y: offset5.y }
              }
            });
          }
        }
        const changes = [];
        movingShapes.forEach((shape) => {
          const current = this.editor.getShape(shape.id);
          const util = this.editor.getShapeUtil(shape);
          const change = util.onTranslateEnd?.(shape, current);
          if (change) {
            changes.push(change);
          }
        });
        if (changes.length > 0) {
          this.editor.updateShapes(changes);
        }
      }
      updateShapes() {
        const { snapshot } = this;
        this.dragAndDropManager.updateDroppingNode(snapshot.movingShapes, this.updateParentTransforms);
        moveShapesToPoint({
          editor: this.editor,
          snapshot
        });
        const { movingShapes } = snapshot;
        const changes = [];
        movingShapes.forEach((shape) => {
          const current = this.editor.getShape(shape.id);
          const util = this.editor.getShapeUtil(shape);
          const change = util.onTranslate?.(shape, current);
          if (change) {
            changes.push(change);
          }
        });
        if (changes.length > 0) {
          this.editor.updateShapes(changes);
        }
      }
    };
    __publicField(Translating, "id", "translating");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/SelectTool/SelectTool.mjs
var SelectTool;
var init_SelectTool = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/SelectTool/SelectTool.mjs"() {
    init_dist_esm10();
    init_Brushing();
    init_Crop();
    init_Cropping();
    init_PointingCropHandle();
    init_DraggingHandle();
    init_EditingShape();
    init_Idle12();
    init_PointingArrowLabel();
    init_PointingCanvas();
    init_PointingHandle();
    init_PointingResizeHandle();
    init_PointingRotateHandle();
    init_PointingSelection();
    init_PointingShape();
    init_Resizing();
    init_Rotating();
    init_ScribbleBrushing();
    init_Translating();
    SelectTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "reactor");
        __publicField(this, "cleanUpDuplicateProps", () => {
          const selectedShapeIds = this.editor.getSelectedShapeIds();
          const instance = this.editor.getInstanceState();
          if (!instance.duplicateProps)
            return;
          const duplicatedShapes = new Set(instance.duplicateProps.shapeIds);
          if (selectedShapeIds.length === duplicatedShapes.size && selectedShapeIds.every((shapeId) => duplicatedShapes.has(shapeId))) {
            return;
          }
          this.editor.updateInstanceState({
            duplicateProps: null
          });
        });
        __publicField(this, "onEnter", () => {
          this.reactor = react("clean duplicate props", () => {
            try {
              this.cleanUpDuplicateProps();
            } catch (e2) {
              if (typeof process !== "undefined" && false) {
              } else {
                console.error(e2);
              }
            }
          });
        });
        __publicField(this, "onExit", () => {
          this.reactor?.();
          if (this.editor.getCurrentPageState().editingShapeId) {
            this.editor.setEditingShape(null);
          }
        });
      }
    };
    __publicField(SelectTool, "id", "select");
    __publicField(SelectTool, "initial", "idle");
    __publicField(SelectTool, "isLockable", false);
    __publicField(SelectTool, "children", () => [
      Crop,
      Cropping,
      Idle12,
      PointingCanvas,
      PointingShape,
      Translating,
      Brushing,
      ScribbleBrushing,
      PointingCropHandle,
      PointingSelection,
      PointingResizeHandle,
      EditingShape,
      Resizing,
      Rotating,
      PointingRotateHandle,
      PointingArrowLabel,
      PointingHandle,
      DraggingHandle
    ]);
  }
});

// node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/Idle.mjs
var Idle13;
var init_Idle13 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/Idle.mjs"() {
    init_dist_esm10();
    Idle13 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
        });
        __publicField(this, "onPointerDown", () => {
          this.parent.transition("pointing", this.info);
        });
      }
    };
    __publicField(Idle13, "id", "idle");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/Pointing.mjs
var Pointing9;
var init_Pointing9 = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/Pointing.mjs"() {
    init_dist_esm10();
    Pointing9 = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onPointerMove", () => {
          if (this.editor.inputs.isDragging) {
            this.parent.transition("zoom_brushing", this.info);
          }
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
      }
      complete() {
        const { currentScreenPoint } = this.editor.inputs;
        if (this.editor.inputs.altKey) {
          this.editor.zoomOut(currentScreenPoint, { animation: { duration: 220 } });
        } else {
          this.editor.zoomIn(currentScreenPoint, { animation: { duration: 220 } });
        }
        this.parent.transition("idle", this.info);
      }
      cancel() {
        this.parent.transition("idle", this.info);
      }
    };
    __publicField(Pointing9, "id", "pointing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/ZoomBrushing.mjs
var ZoomBrushing;
var init_ZoomBrushing = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/ZoomTool/childStates/ZoomBrushing.mjs"() {
    init_dist_esm10();
    ZoomBrushing = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "zoomBrush", new Box());
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.update();
        });
        __publicField(this, "onExit", () => {
          this.editor.updateInstanceState({ zoomBrush: null });
        });
        __publicField(this, "onPointerMove", () => {
          this.update();
        });
        __publicField(this, "onPointerUp", () => {
          this.complete();
        });
        __publicField(this, "onCancel", () => {
          this.cancel();
        });
      }
      update() {
        const {
          inputs: { originPagePoint, currentPagePoint }
        } = this.editor;
        this.zoomBrush.setTo(Box.FromPoints([originPagePoint, currentPagePoint]));
        this.editor.updateInstanceState({ zoomBrush: this.zoomBrush.toJson() });
      }
      cancel() {
        this.parent.transition("idle", this.info);
      }
      complete() {
        const { zoomBrush } = this;
        const threshold = 8 / this.editor.getZoomLevel();
        if (zoomBrush.width < threshold && zoomBrush.height < threshold) {
          const point = this.editor.inputs.currentScreenPoint;
          if (this.editor.inputs.altKey) {
            this.editor.zoomOut(point, { animation: { duration: 220 } });
          } else {
            this.editor.zoomIn(point, { animation: { duration: 220 } });
          }
        } else {
          const targetZoom = this.editor.inputs.altKey ? this.editor.getZoomLevel() / 2 : void 0;
          this.editor.zoomToBounds(zoomBrush, { targetZoom, animation: { duration: 220 } });
        }
        this.parent.transition("idle", this.info);
      }
    };
    __publicField(ZoomBrushing, "id", "zoom_brushing");
  }
});

// node_modules/tldraw/dist-esm/lib/tools/ZoomTool/ZoomTool.mjs
var ZoomTool;
var init_ZoomTool = __esm({
  "node_modules/tldraw/dist-esm/lib/tools/ZoomTool/ZoomTool.mjs"() {
    init_dist_esm10();
    init_Idle13();
    init_Pointing9();
    init_ZoomBrushing();
    ZoomTool = class extends StateNode {
      constructor() {
        super(...arguments);
        __publicField(this, "info", {});
        __publicField(this, "onEnter", (info2) => {
          this.info = info2;
          this.parent.setCurrentToolIdMask(info2.onInteractionEnd);
          this.updateCursor();
        });
        __publicField(this, "onExit", () => {
          this.parent.setCurrentToolIdMask(void 0);
          this.editor.updateInstanceState({ zoomBrush: null, cursor: { type: "default", rotation: 0 } });
          this.parent.setCurrentToolIdMask(void 0);
        });
        __publicField(this, "onKeyDown", () => {
          this.updateCursor();
        });
        __publicField(this, "onKeyUp", (info2) => {
          this.updateCursor();
          if (info2.code === "KeyZ") {
            this.complete();
          }
        });
        __publicField(this, "onInterrupt", () => {
          this.complete();
        });
      }
      complete() {
        if (this.info.onInteractionEnd && this.info.onInteractionEnd !== "select") {
          this.editor.setCurrentTool(this.info.onInteractionEnd, this.info);
        } else {
          this.parent.transition("select");
        }
      }
      updateCursor() {
        if (this.editor.inputs.altKey) {
          this.editor.setCursor({ type: "zoom-out", rotation: 0 });
        } else {
          this.editor.setCursor({ type: "zoom-in", rotation: 0 });
        }
      }
    };
    __publicField(ZoomTool, "id", "zoom");
    __publicField(ZoomTool, "initial", "idle");
    __publicField(ZoomTool, "children", () => [Idle13, ZoomBrushing, Pointing9]);
    __publicField(ZoomTool, "isLockable", false);
  }
});

// node_modules/tldraw/dist-esm/lib/defaultTools.mjs
var defaultTools;
var init_defaultTools = __esm({
  "node_modules/tldraw/dist-esm/lib/defaultTools.mjs"() {
    init_EraserTool();
    init_HandTool();
    init_LaserTool();
    init_SelectTool();
    init_ZoomTool();
    defaultTools = [EraserTool, HandTool, LaserTool, ZoomTool, SelectTool];
  }
});

// node_modules/@radix-ui/primitive/dist/index.mjs
function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
  return function handleEvent(event) {
    originalEventHandler?.(event);
    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
      return ourEventHandler?.(event);
    }
  };
}
var init_dist = __esm({
  "node_modules/@radix-ui/primitive/dist/index.mjs"() {
  }
});

// node_modules/@radix-ui/react-compose-refs/dist/index.mjs
function setRef(ref, value) {
  if (typeof ref === "function") {
    return ref(value);
  } else if (ref !== null && ref !== void 0) {
    ref.current = value;
  }
}
function composeRefs(...refs) {
  return (node) => {
    let hasCleanup = false;
    const cleanups = refs.map((ref) => {
      const cleanup = setRef(ref, node);
      if (!hasCleanup && typeof cleanup == "function") {
        hasCleanup = true;
      }
      return cleanup;
    });
    if (hasCleanup) {
      return () => {
        for (let i2 = 0; i2 < cleanups.length; i2++) {
          const cleanup = cleanups[i2];
          if (typeof cleanup == "function") {
            cleanup();
          } else {
            setRef(refs[i2], null);
          }
        }
      };
    }
  };
}
function useComposedRefs(...refs) {
  return React17.useCallback(composeRefs(...refs), refs);
}
var React17;
var init_dist2 = __esm({
  "node_modules/@radix-ui/react-compose-refs/dist/index.mjs"() {
    React17 = __toESM(require_react(), 1);
  }
});

// node_modules/@radix-ui/react-context/dist/index.mjs
function createContext22(rootComponentName, defaultContext) {
  const Context2 = React18.createContext(defaultContext);
  const Provider2 = (props) => {
    const { children, ...context } = props;
    const value = React18.useMemo(() => context, Object.values(context));
    return /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(Context2.Provider, { value, children });
  };
  Provider2.displayName = rootComponentName + "Provider";
  function useContext22(consumerName) {
    const context = React18.useContext(Context2);
    if (context)
      return context;
    if (defaultContext !== void 0)
      return defaultContext;
    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
  }
  return [Provider2, useContext22];
}
function createContextScope(scopeName, createContextScopeDeps = []) {
  let defaultContexts = [];
  function createContext32(rootComponentName, defaultContext) {
    const BaseContext = React18.createContext(defaultContext);
    const index3 = defaultContexts.length;
    defaultContexts = [...defaultContexts, defaultContext];
    const Provider2 = (props) => {
      const { scope, children, ...context } = props;
      const Context2 = scope?.[scopeName]?.[index3] || BaseContext;
      const value = React18.useMemo(() => context, Object.values(context));
      return /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(Context2.Provider, { value, children });
    };
    Provider2.displayName = rootComponentName + "Provider";
    function useContext22(consumerName, scope) {
      const Context2 = scope?.[scopeName]?.[index3] || BaseContext;
      const context = React18.useContext(Context2);
      if (context)
        return context;
      if (defaultContext !== void 0)
        return defaultContext;
      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
    }
    return [Provider2, useContext22];
  }
  const createScope = () => {
    const scopeContexts = defaultContexts.map((defaultContext) => {
      return React18.createContext(defaultContext);
    });
    return function useScope(scope) {
      const contexts = scope?.[scopeName] || scopeContexts;
      return React18.useMemo(() => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }), [scope, contexts]);
    };
  };
  createScope.scopeName = scopeName;
  return [createContext32, composeContextScopes(createScope, ...createContextScopeDeps)];
}
function composeContextScopes(...scopes) {
  const baseScope = scopes[0];
  if (scopes.length === 1)
    return baseScope;
  const createScope = () => {
    const scopeHooks = scopes.map((createScope2) => ({
      useScope: createScope2(),
      scopeName: createScope2.scopeName
    }));
    return function useComposedScopes(overrideScopes) {
      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
        const scopeProps = useScope(overrideScopes);
        const currentScope = scopeProps[`__scope${scopeName}`];
        return { ...nextScopes2, ...currentScope };
      }, {});
      return React18.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
    };
  };
  createScope.scopeName = baseScope.scopeName;
  return createScope;
}
var React18, import_jsx_runtime66;
var init_dist3 = __esm({
  "node_modules/@radix-ui/react-context/dist/index.mjs"() {
    React18 = __toESM(require_react(), 1);
    import_jsx_runtime66 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
var React19, useLayoutEffect22;
var init_dist4 = __esm({
  "node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs"() {
    React19 = __toESM(require_react(), 1);
    useLayoutEffect22 = Boolean(globalThis?.document) ? React19.useLayoutEffect : () => {
    };
  }
});

// node_modules/@radix-ui/react-id/dist/index.mjs
function useId2(deterministicId) {
  const [id, setId] = React20.useState(useReactId());
  useLayoutEffect22(() => {
    if (!deterministicId)
      setId((reactId) => reactId ?? String(count++));
  }, [deterministicId]);
  return deterministicId || (id ? `radix-${id}` : "");
}
var React20, useReactId, count;
var init_dist5 = __esm({
  "node_modules/@radix-ui/react-id/dist/index.mjs"() {
    React20 = __toESM(require_react(), 1);
    init_dist4();
    useReactId = React20["useId".toString()] || (() => void 0);
    count = 0;
  }
});

// node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
function useCallbackRef(callback) {
  const callbackRef = React21.useRef(callback);
  React21.useEffect(() => {
    callbackRef.current = callback;
  });
  return React21.useMemo(() => (...args) => callbackRef.current?.(...args), []);
}
var React21;
var init_dist6 = __esm({
  "node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs"() {
    React21 = __toESM(require_react(), 1);
  }
});

// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
function useControllableState({
  prop,
  defaultProp,
  onChange = () => {
  }
}) {
  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });
  const isControlled = prop !== void 0;
  const value = isControlled ? prop : uncontrolledProp;
  const handleChange = useCallbackRef(onChange);
  const setValue = React22.useCallback((nextValue) => {
    if (isControlled) {
      const setter = nextValue;
      const value2 = typeof nextValue === "function" ? setter(prop) : nextValue;
      if (value2 !== prop)
        handleChange(value2);
    } else {
      setUncontrolledProp(nextValue);
    }
  }, [isControlled, prop, setUncontrolledProp, handleChange]);
  return [value, setValue];
}
function useUncontrolledState({
  defaultProp,
  onChange
}) {
  const uncontrolledState = React22.useState(defaultProp);
  const [value] = uncontrolledState;
  const prevValueRef = React22.useRef(value);
  const handleChange = useCallbackRef(onChange);
  React22.useEffect(() => {
    if (prevValueRef.current !== value) {
      handleChange(value);
      prevValueRef.current = value;
    }
  }, [value, prevValueRef, handleChange]);
  return uncontrolledState;
}
var React22;
var init_dist7 = __esm({
  "node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs"() {
    React22 = __toESM(require_react(), 1);
    init_dist6();
  }
});

// node_modules/@radix-ui/react-slot/dist/index.mjs
function isSlottable(child) {
  return React23.isValidElement(child) && child.type === Slottable;
}
function mergeProps(slotProps, childProps) {
  const overrideProps = { ...childProps };
  for (const propName in childProps) {
    const slotPropValue = slotProps[propName];
    const childPropValue = childProps[propName];
    const isHandler = /^on[A-Z]/.test(propName);
    if (isHandler) {
      if (slotPropValue && childPropValue) {
        overrideProps[propName] = (...args) => {
          childPropValue(...args);
          slotPropValue(...args);
        };
      } else if (slotPropValue) {
        overrideProps[propName] = slotPropValue;
      }
    } else if (propName === "style") {
      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
    } else if (propName === "className") {
      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
    }
  }
  return { ...slotProps, ...overrideProps };
}
function getElementRef(element) {
  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
  if (mayWarn) {
    return element.ref;
  }
  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
  if (mayWarn) {
    return element.props.ref;
  }
  return element.props.ref || element.ref;
}
var React23, import_jsx_runtime67, Slot, SlotClone, Slottable;
var init_dist8 = __esm({
  "node_modules/@radix-ui/react-slot/dist/index.mjs"() {
    React23 = __toESM(require_react(), 1);
    init_dist2();
    import_jsx_runtime67 = __toESM(require_jsx_runtime(), 1);
    Slot = React23.forwardRef((props, forwardedRef) => {
      const { children, ...slotProps } = props;
      const childrenArray = React23.Children.toArray(children);
      const slottable = childrenArray.find(isSlottable);
      if (slottable) {
        const newElement = slottable.props.children;
        const newChildren = childrenArray.map((child) => {
          if (child === slottable) {
            if (React23.Children.count(newElement) > 1)
              return React23.Children.only(null);
            return React23.isValidElement(newElement) ? newElement.props.children : null;
          } else {
            return child;
          }
        });
        return /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children: React23.isValidElement(newElement) ? React23.cloneElement(newElement, void 0, newChildren) : null });
      }
      return /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children });
    });
    Slot.displayName = "Slot";
    SlotClone = React23.forwardRef((props, forwardedRef) => {
      const { children, ...slotProps } = props;
      if (React23.isValidElement(children)) {
        const childrenRef = getElementRef(children);
        return React23.cloneElement(children, {
          ...mergeProps(slotProps, children.props),
          ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
        });
      }
      return React23.Children.count(children) > 1 ? React23.Children.only(null) : null;
    });
    SlotClone.displayName = "SlotClone";
    Slottable = ({ children }) => {
      return /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(import_jsx_runtime67.Fragment, { children });
    };
  }
});

// node_modules/@radix-ui/react-primitive/dist/index.mjs
function dispatchDiscreteCustomEvent(target, event) {
  if (target)
    ReactDOM.flushSync(() => target.dispatchEvent(event));
}
var React24, ReactDOM, import_jsx_runtime68, NODES, Primitive;
var init_dist9 = __esm({
  "node_modules/@radix-ui/react-primitive/dist/index.mjs"() {
    React24 = __toESM(require_react(), 1);
    ReactDOM = __toESM(require_react_dom(), 1);
    init_dist8();
    import_jsx_runtime68 = __toESM(require_jsx_runtime(), 1);
    NODES = [
      "a",
      "button",
      "div",
      "form",
      "h2",
      "h3",
      "img",
      "input",
      "label",
      "li",
      "nav",
      "ol",
      "p",
      "span",
      "svg",
      "ul"
    ];
    Primitive = NODES.reduce((primitive, node) => {
      const Node2 = React24.forwardRef((props, forwardedRef) => {
        const { asChild, ...primitiveProps } = props;
        const Comp = asChild ? Slot : node;
        if (typeof window !== "undefined") {
          window[Symbol.for("radix-ui")] = true;
        }
        return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Comp, { ...primitiveProps, ref: forwardedRef });
      });
      Node2.displayName = `Primitive.${node}`;
      return { ...primitive, [node]: Node2 };
    }, {});
  }
});

// node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs
function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
  React25.useEffect(() => {
    const handleKeyDown = (event) => {
      if (event.key === "Escape") {
        onEscapeKeyDown(event);
      }
    };
    ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
    return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
  }, [onEscapeKeyDown, ownerDocument]);
}
var React25;
var init_dist10 = __esm({
  "node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs"() {
    React25 = __toESM(require_react(), 1);
    init_dist6();
  }
});

// node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs
function usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {
  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
  const isPointerInsideReactTreeRef = React26.useRef(false);
  const handleClickRef = React26.useRef(() => {
  });
  React26.useEffect(() => {
    const handlePointerDown = (event) => {
      if (event.target && !isPointerInsideReactTreeRef.current) {
        let handleAndDispatchPointerDownOutsideEvent2 = function() {
          handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, { discrete: true });
        };
        var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2;
        const eventDetail = { originalEvent: event };
        if (event.pointerType === "touch") {
          ownerDocument.removeEventListener("click", handleClickRef.current);
          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;
          ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
        } else {
          handleAndDispatchPointerDownOutsideEvent2();
        }
      } else {
        ownerDocument.removeEventListener("click", handleClickRef.current);
      }
      isPointerInsideReactTreeRef.current = false;
    };
    const timerId = window.setTimeout(() => {
      ownerDocument.addEventListener("pointerdown", handlePointerDown);
    }, 0);
    return () => {
      window.clearTimeout(timerId);
      ownerDocument.removeEventListener("pointerdown", handlePointerDown);
      ownerDocument.removeEventListener("click", handleClickRef.current);
    };
  }, [ownerDocument, handlePointerDownOutside]);
  return {
    onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true
  };
}
function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
  const handleFocusOutside = useCallbackRef(onFocusOutside);
  const isFocusInsideReactTreeRef = React26.useRef(false);
  React26.useEffect(() => {
    const handleFocus = (event) => {
      if (event.target && !isFocusInsideReactTreeRef.current) {
        const eventDetail = { originalEvent: event };
        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
          discrete: false
        });
      }
    };
    ownerDocument.addEventListener("focusin", handleFocus);
    return () => ownerDocument.removeEventListener("focusin", handleFocus);
  }, [ownerDocument, handleFocusOutside]);
  return {
    onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
    onBlurCapture: () => isFocusInsideReactTreeRef.current = false
  };
}
function dispatchUpdate() {
  const event = new CustomEvent(CONTEXT_UPDATE);
  document.dispatchEvent(event);
}
function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
  const target = detail.originalEvent.target;
  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });
  if (handler)
    target.addEventListener(name, handler, { once: true });
  if (discrete) {
    dispatchDiscreteCustomEvent(target, event);
  } else {
    target.dispatchEvent(event);
  }
}
var React26, import_jsx_runtime69, DISMISSABLE_LAYER_NAME, CONTEXT_UPDATE, POINTER_DOWN_OUTSIDE, FOCUS_OUTSIDE, originalBodyPointerEvents, DismissableLayerContext, DismissableLayer, BRANCH_NAME, DismissableLayerBranch, Root, Branch;
var init_dist11 = __esm({
  "node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs"() {
    React26 = __toESM(require_react(), 1);
    init_dist();
    init_dist9();
    init_dist2();
    init_dist6();
    init_dist10();
    import_jsx_runtime69 = __toESM(require_jsx_runtime(), 1);
    "use client";
    DISMISSABLE_LAYER_NAME = "DismissableLayer";
    CONTEXT_UPDATE = "dismissableLayer.update";
    POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
    FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
    DismissableLayerContext = React26.createContext({
      layers: /* @__PURE__ */ new Set(),
      layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
      branches: /* @__PURE__ */ new Set()
    });
    DismissableLayer = React26.forwardRef((props, forwardedRef) => {
      const {
        disableOutsidePointerEvents = false,
        onEscapeKeyDown,
        onPointerDownOutside,
        onFocusOutside,
        onInteractOutside,
        onDismiss,
        ...layerProps
      } = props;
      const context = React26.useContext(DismissableLayerContext);
      const [node, setNode] = React26.useState(null);
      const ownerDocument = node?.ownerDocument ?? globalThis?.document;
      const [, force] = React26.useState({});
      const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
      const layers = Array.from(context.layers);
      const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
      const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
      const index3 = node ? layers.indexOf(node) : -1;
      const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
      const isPointerEventsEnabled = index3 >= highestLayerWithOutsidePointerEventsDisabledIndex;
      const pointerDownOutside = usePointerDownOutside((event) => {
        const target = event.target;
        const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));
        if (!isPointerEventsEnabled || isPointerDownOnBranch)
          return;
        onPointerDownOutside?.(event);
        onInteractOutside?.(event);
        if (!event.defaultPrevented)
          onDismiss?.();
      }, ownerDocument);
      const focusOutside = useFocusOutside((event) => {
        const target = event.target;
        const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));
        if (isFocusInBranch)
          return;
        onFocusOutside?.(event);
        onInteractOutside?.(event);
        if (!event.defaultPrevented)
          onDismiss?.();
      }, ownerDocument);
      useEscapeKeydown((event) => {
        const isHighestLayer = index3 === context.layers.size - 1;
        if (!isHighestLayer)
          return;
        onEscapeKeyDown?.(event);
        if (!event.defaultPrevented && onDismiss) {
          event.preventDefault();
          onDismiss();
        }
      }, ownerDocument);
      React26.useEffect(() => {
        if (!node)
          return;
        if (disableOutsidePointerEvents) {
          if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
            originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
            ownerDocument.body.style.pointerEvents = "none";
          }
          context.layersWithOutsidePointerEventsDisabled.add(node);
        }
        context.layers.add(node);
        dispatchUpdate();
        return () => {
          if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {
            ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
          }
        };
      }, [node, ownerDocument, disableOutsidePointerEvents, context]);
      React26.useEffect(() => {
        return () => {
          if (!node)
            return;
          context.layers.delete(node);
          context.layersWithOutsidePointerEventsDisabled.delete(node);
          dispatchUpdate();
        };
      }, [node, context]);
      React26.useEffect(() => {
        const handleUpdate = () => force({});
        document.addEventListener(CONTEXT_UPDATE, handleUpdate);
        return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(Primitive.div, {
        ...layerProps,
        ref: composedRefs,
        style: {
          pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
          ...props.style
        },
        onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
        onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
        onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
      });
    });
    DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
    BRANCH_NAME = "DismissableLayerBranch";
    DismissableLayerBranch = React26.forwardRef((props, forwardedRef) => {
      const context = React26.useContext(DismissableLayerContext);
      const ref = React26.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      React26.useEffect(() => {
        const node = ref.current;
        if (node) {
          context.branches.add(node);
          return () => {
            context.branches.delete(node);
          };
        }
      }, [context.branches]);
      return /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(Primitive.div, { ...props, ref: composedRefs });
    });
    DismissableLayerBranch.displayName = BRANCH_NAME;
    Root = DismissableLayer;
    Branch = DismissableLayerBranch;
  }
});

// node_modules/@radix-ui/react-focus-scope/dist/index.mjs
function focusFirst(candidates, { select = false } = {}) {
  const previouslyFocusedElement = document.activeElement;
  for (const candidate of candidates) {
    focus(candidate, { select });
    if (document.activeElement !== previouslyFocusedElement)
      return;
  }
}
function getTabbableEdges(container) {
  const candidates = getTabbableCandidates(container);
  const first = findVisible(candidates, container);
  const last7 = findVisible(candidates.reverse(), container);
  return [first, last7];
}
function getTabbableCandidates(container) {
  const nodes = [];
  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
    acceptNode: (node) => {
      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
      if (node.disabled || node.hidden || isHiddenInput)
        return NodeFilter.FILTER_SKIP;
      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
    }
  });
  while (walker.nextNode())
    nodes.push(walker.currentNode);
  return nodes;
}
function findVisible(elements, container) {
  for (const element of elements) {
    if (!isHidden(element, { upTo: container }))
      return element;
  }
}
function isHidden(node, { upTo }) {
  if (getComputedStyle(node).visibility === "hidden")
    return true;
  while (node) {
    if (upTo !== void 0 && node === upTo)
      return false;
    if (getComputedStyle(node).display === "none")
      return true;
    node = node.parentElement;
  }
  return false;
}
function isSelectableInput(element) {
  return element instanceof HTMLInputElement && "select" in element;
}
function focus(element, { select = false } = {}) {
  if (element && element.focus) {
    const previouslyFocusedElement = document.activeElement;
    element.focus({ preventScroll: true });
    if (element !== previouslyFocusedElement && isSelectableInput(element) && select)
      element.select();
  }
}
function createFocusScopesStack() {
  let stack2 = [];
  return {
    add(focusScope) {
      const activeFocusScope = stack2[0];
      if (focusScope !== activeFocusScope) {
        activeFocusScope?.pause();
      }
      stack2 = arrayRemove(stack2, focusScope);
      stack2.unshift(focusScope);
    },
    remove(focusScope) {
      stack2 = arrayRemove(stack2, focusScope);
      stack2[0]?.resume();
    }
  };
}
function arrayRemove(array2, item) {
  const updatedArray = [...array2];
  const index3 = updatedArray.indexOf(item);
  if (index3 !== -1) {
    updatedArray.splice(index3, 1);
  }
  return updatedArray;
}
function removeLinks(items) {
  return items.filter((item) => item.tagName !== "A");
}
var React27, import_jsx_runtime70, AUTOFOCUS_ON_MOUNT, AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS, FOCUS_SCOPE_NAME, FocusScope, focusScopesStack;
var init_dist12 = __esm({
  "node_modules/@radix-ui/react-focus-scope/dist/index.mjs"() {
    React27 = __toESM(require_react(), 1);
    init_dist2();
    init_dist9();
    init_dist6();
    import_jsx_runtime70 = __toESM(require_jsx_runtime(), 1);
    "use client";
    AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
    AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
    EVENT_OPTIONS = { bubbles: false, cancelable: true };
    FOCUS_SCOPE_NAME = "FocusScope";
    FocusScope = React27.forwardRef((props, forwardedRef) => {
      const {
        loop = false,
        trapped = false,
        onMountAutoFocus: onMountAutoFocusProp,
        onUnmountAutoFocus: onUnmountAutoFocusProp,
        ...scopeProps
      } = props;
      const [container, setContainer] = React27.useState(null);
      const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
      const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
      const lastFocusedElementRef = React27.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));
      const focusScope = React27.useRef({
        paused: false,
        pause() {
          this.paused = true;
        },
        resume() {
          this.paused = false;
        }
      }).current;
      React27.useEffect(() => {
        if (trapped) {
          let handleFocusIn2 = function(event) {
            if (focusScope.paused || !container)
              return;
            const target = event.target;
            if (container.contains(target)) {
              lastFocusedElementRef.current = target;
            } else {
              focus(lastFocusedElementRef.current, { select: true });
            }
          }, handleFocusOut2 = function(event) {
            if (focusScope.paused || !container)
              return;
            const relatedTarget = event.relatedTarget;
            if (relatedTarget === null)
              return;
            if (!container.contains(relatedTarget)) {
              focus(lastFocusedElementRef.current, { select: true });
            }
          }, handleMutations2 = function(mutations) {
            const focusedElement = document.activeElement;
            if (focusedElement !== document.body)
              return;
            for (const mutation of mutations) {
              if (mutation.removedNodes.length > 0)
                focus(container);
            }
          };
          var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;
          document.addEventListener("focusin", handleFocusIn2);
          document.addEventListener("focusout", handleFocusOut2);
          const mutationObserver = new MutationObserver(handleMutations2);
          if (container)
            mutationObserver.observe(container, { childList: true, subtree: true });
          return () => {
            document.removeEventListener("focusin", handleFocusIn2);
            document.removeEventListener("focusout", handleFocusOut2);
            mutationObserver.disconnect();
          };
        }
      }, [trapped, container, focusScope.paused]);
      React27.useEffect(() => {
        if (container) {
          focusScopesStack.add(focusScope);
          const previouslyFocusedElement = document.activeElement;
          const hasFocusedCandidate = container.contains(previouslyFocusedElement);
          if (!hasFocusedCandidate) {
            const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
            container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
            container.dispatchEvent(mountEvent);
            if (!mountEvent.defaultPrevented) {
              focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
              if (document.activeElement === previouslyFocusedElement) {
                focus(container);
              }
            }
          }
          return () => {
            container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
            setTimeout(() => {
              const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
              container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
              container.dispatchEvent(unmountEvent);
              if (!unmountEvent.defaultPrevented) {
                focus(previouslyFocusedElement ?? document.body, { select: true });
              }
              container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
              focusScopesStack.remove(focusScope);
            }, 0);
          };
        }
      }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
      const handleKeyDown = React27.useCallback((event) => {
        if (!loop && !trapped)
          return;
        if (focusScope.paused)
          return;
        const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
        const focusedElement = document.activeElement;
        if (isTabKey && focusedElement) {
          const container2 = event.currentTarget;
          const [first, last7] = getTabbableEdges(container2);
          const hasTabbableElementsInside = first && last7;
          if (!hasTabbableElementsInside) {
            if (focusedElement === container2)
              event.preventDefault();
          } else {
            if (!event.shiftKey && focusedElement === last7) {
              event.preventDefault();
              if (loop)
                focus(first, { select: true });
            } else if (event.shiftKey && focusedElement === first) {
              event.preventDefault();
              if (loop)
                focus(last7, { select: true });
            }
          }
        }
      }, [loop, trapped, focusScope.paused]);
      return /* @__PURE__ */ (0, import_jsx_runtime70.jsx)(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
    });
    FocusScope.displayName = FOCUS_SCOPE_NAME;
    focusScopesStack = createFocusScopesStack();
  }
});

// node_modules/@radix-ui/react-portal/dist/index.mjs
var React28, import_react_dom2, import_jsx_runtime71, PORTAL_NAME, Portal;
var init_dist13 = __esm({
  "node_modules/@radix-ui/react-portal/dist/index.mjs"() {
    React28 = __toESM(require_react(), 1);
    import_react_dom2 = __toESM(require_react_dom(), 1);
    init_dist9();
    init_dist4();
    import_jsx_runtime71 = __toESM(require_jsx_runtime(), 1);
    "use client";
    PORTAL_NAME = "Portal";
    Portal = React28.forwardRef((props, forwardedRef) => {
      const { container: containerProp, ...portalProps } = props;
      const [mounted, setMounted] = React28.useState(false);
      useLayoutEffect22(() => setMounted(true), []);
      const container = containerProp || mounted && globalThis?.document?.body;
      return container ? import_react_dom2.default.createPortal(/* @__PURE__ */ (0, import_jsx_runtime71.jsx)(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
    });
    Portal.displayName = PORTAL_NAME;
  }
});

// node_modules/@radix-ui/react-presence/dist/index.mjs
function useStateMachine(initialState2, machine) {
  return React30.useReducer((state, event) => {
    const nextState = machine[state][event];
    return nextState ?? state;
  }, initialState2);
}
function usePresence2(present) {
  const [node, setNode] = React29.useState();
  const stylesRef = React29.useRef({});
  const prevPresentRef = React29.useRef(present);
  const prevAnimationNameRef = React29.useRef("none");
  const initialState2 = present ? "mounted" : "unmounted";
  const [state, send] = useStateMachine(initialState2, {
    mounted: {
      UNMOUNT: "unmounted",
      ANIMATION_OUT: "unmountSuspended"
    },
    unmountSuspended: {
      MOUNT: "mounted",
      ANIMATION_END: "unmounted"
    },
    unmounted: {
      MOUNT: "mounted"
    }
  });
  React29.useEffect(() => {
    const currentAnimationName = getAnimationName(stylesRef.current);
    prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
  }, [state]);
  useLayoutEffect22(() => {
    const styles3 = stylesRef.current;
    const wasPresent = prevPresentRef.current;
    const hasPresentChanged = wasPresent !== present;
    if (hasPresentChanged) {
      const prevAnimationName = prevAnimationNameRef.current;
      const currentAnimationName = getAnimationName(styles3);
      if (present) {
        send("MOUNT");
      } else if (currentAnimationName === "none" || styles3?.display === "none") {
        send("UNMOUNT");
      } else {
        const isAnimating = prevAnimationName !== currentAnimationName;
        if (wasPresent && isAnimating) {
          send("ANIMATION_OUT");
        } else {
          send("UNMOUNT");
        }
      }
      prevPresentRef.current = present;
    }
  }, [present, send]);
  useLayoutEffect22(() => {
    if (node) {
      let timeoutId;
      const ownerWindow = node.ownerDocument.defaultView ?? window;
      const handleAnimationEnd = (event) => {
        const currentAnimationName = getAnimationName(stylesRef.current);
        const isCurrentAnimation = currentAnimationName.includes(event.animationName);
        if (event.target === node && isCurrentAnimation) {
          send("ANIMATION_END");
          if (!prevPresentRef.current) {
            const currentFillMode = node.style.animationFillMode;
            node.style.animationFillMode = "forwards";
            timeoutId = ownerWindow.setTimeout(() => {
              if (node.style.animationFillMode === "forwards") {
                node.style.animationFillMode = currentFillMode;
              }
            });
          }
        }
      };
      const handleAnimationStart = (event) => {
        if (event.target === node) {
          prevAnimationNameRef.current = getAnimationName(stylesRef.current);
        }
      };
      node.addEventListener("animationstart", handleAnimationStart);
      node.addEventListener("animationcancel", handleAnimationEnd);
      node.addEventListener("animationend", handleAnimationEnd);
      return () => {
        ownerWindow.clearTimeout(timeoutId);
        node.removeEventListener("animationstart", handleAnimationStart);
        node.removeEventListener("animationcancel", handleAnimationEnd);
        node.removeEventListener("animationend", handleAnimationEnd);
      };
    } else {
      send("ANIMATION_END");
    }
  }, [node, send]);
  return {
    isPresent: ["mounted", "unmountSuspended"].includes(state),
    ref: React29.useCallback((node2) => {
      if (node2)
        stylesRef.current = getComputedStyle(node2);
      setNode(node2);
    }, [])
  };
}
function getAnimationName(styles3) {
  return styles3?.animationName || "none";
}
function getElementRef2(element) {
  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
  if (mayWarn) {
    return element.ref;
  }
  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
  if (mayWarn) {
    return element.props.ref;
  }
  return element.props.ref || element.ref;
}
var React29, React30, Presence;
var init_dist14 = __esm({
  "node_modules/@radix-ui/react-presence/dist/index.mjs"() {
    React29 = __toESM(require_react(), 1);
    init_dist2();
    init_dist4();
    React30 = __toESM(require_react(), 1);
    "use client";
    Presence = (props) => {
      const { present, children } = props;
      const presence = usePresence2(present);
      const child = typeof children === "function" ? children({ present: presence.isPresent }) : React29.Children.only(children);
      const ref = useComposedRefs(presence.ref, getElementRef2(child));
      const forceMount = typeof children === "function";
      return forceMount || presence.isPresent ? React29.cloneElement(child, { ref }) : null;
    };
    Presence.displayName = "Presence";
  }
});

// node_modules/@radix-ui/react-focus-guards/dist/index.mjs
function useFocusGuards() {
  React31.useEffect(() => {
    const edgeGuards = document.querySelectorAll("[data-radix-focus-guard]");
    document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
    document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
    count2++;
    return () => {
      if (count2 === 1) {
        document.querySelectorAll("[data-radix-focus-guard]").forEach((node) => node.remove());
      }
      count2--;
    };
  }, []);
}
function createFocusGuard() {
  const element = document.createElement("span");
  element.setAttribute("data-radix-focus-guard", "");
  element.tabIndex = 0;
  element.style.outline = "none";
  element.style.opacity = "0";
  element.style.position = "fixed";
  element.style.pointerEvents = "none";
  return element;
}
var React31, count2;
var init_dist15 = __esm({
  "node_modules/@radix-ui/react-focus-guards/dist/index.mjs"() {
    React31 = __toESM(require_react(), 1);
    "use client";
    count2 = 0;
  }
});

// node_modules/tslib/tslib.js
var require_tslib = __commonJS({
  "node_modules/tslib/tslib.js"(exports, module2) {
    var __extends2;
    var __assign2;
    var __rest2;
    var __decorate2;
    var __param2;
    var __metadata2;
    var __awaiter2;
    var __generator2;
    var __exportStar2;
    var __values2;
    var __read2;
    var __spread2;
    var __spreadArrays2;
    var __spreadArray2;
    var __await2;
    var __asyncGenerator2;
    var __asyncDelegator2;
    var __asyncValues2;
    var __makeTemplateObject2;
    var __importStar2;
    var __importDefault2;
    var __classPrivateFieldGet2;
    var __classPrivateFieldSet2;
    var __classPrivateFieldIn2;
    var __createBinding2;
    (function(factory) {
      var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
      if (typeof define === "function" && define.amd) {
        define("tslib", ["exports"], function(exports2) {
          factory(createExporter(root, createExporter(exports2)));
        });
      } else if (typeof module2 === "object" && typeof module2.exports === "object") {
        factory(createExporter(root, createExporter(module2.exports)));
      } else {
        factory(createExporter(root));
      }
      function createExporter(exports2, previous) {
        if (exports2 !== root) {
          if (typeof Object.create === "function") {
            Object.defineProperty(exports2, "__esModule", { value: true });
          } else {
            exports2.__esModule = true;
          }
        }
        return function(id, v2) {
          return exports2[id] = previous ? previous(id, v2) : v2;
        };
      }
    })(function(exporter) {
      var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
        d2.__proto__ = b2;
      } || function(d2, b2) {
        for (var p2 in b2)
          if (Object.prototype.hasOwnProperty.call(b2, p2))
            d2[p2] = b2[p2];
      };
      __extends2 = function(d2, b2) {
        if (typeof b2 !== "function" && b2 !== null)
          throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
        extendStatics(d2, b2);
        function __() {
          this.constructor = d2;
        }
        d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
      };
      __assign2 = Object.assign || function(t3) {
        for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
          s2 = arguments[i2];
          for (var p2 in s2)
            if (Object.prototype.hasOwnProperty.call(s2, p2))
              t3[p2] = s2[p2];
        }
        return t3;
      };
      __rest2 = function(s2, e2) {
        var t3 = {};
        for (var p2 in s2)
          if (Object.prototype.hasOwnProperty.call(s2, p2) && e2.indexOf(p2) < 0)
            t3[p2] = s2[p2];
        if (s2 != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i2 = 0, p2 = Object.getOwnPropertySymbols(s2); i2 < p2.length; i2++) {
            if (e2.indexOf(p2[i2]) < 0 && Object.prototype.propertyIsEnumerable.call(s2, p2[i2]))
              t3[p2[i2]] = s2[p2[i2]];
          }
        return t3;
      };
      __decorate2 = function(decorators, target, key, desc) {
        var c2 = arguments.length, r2 = c2 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
          r2 = Reflect.decorate(decorators, target, key, desc);
        else
          for (var i2 = decorators.length - 1; i2 >= 0; i2--)
            if (d2 = decorators[i2])
              r2 = (c2 < 3 ? d2(r2) : c2 > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
        return c2 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
      };
      __param2 = function(paramIndex, decorator) {
        return function(target, key) {
          decorator(target, key, paramIndex);
        };
      };
      __metadata2 = function(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
          return Reflect.metadata(metadataKey, metadataValue);
      };
      __awaiter2 = function(thisArg, _arguments, P2, generator) {
        function adopt(value) {
          return value instanceof P2 ? value : new P2(function(resolve) {
            resolve(value);
          });
        }
        return new (P2 || (P2 = Promise))(function(resolve, reject) {
          function fulfilled(value) {
            try {
              step(generator.next(value));
            } catch (e2) {
              reject(e2);
            }
          }
          function rejected(value) {
            try {
              step(generator["throw"](value));
            } catch (e2) {
              reject(e2);
            }
          }
          function step(result) {
            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
          }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
      };
      __generator2 = function(thisArg, body) {
        var _2 = { label: 0, sent: function() {
          if (t3[0] & 1)
            throw t3[1];
          return t3[1];
        }, trys: [], ops: [] }, f2, y2, t3, g2;
        return g2 = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
          return this;
        }), g2;
        function verb(n2) {
          return function(v2) {
            return step([n2, v2]);
          };
        }
        function step(op) {
          if (f2)
            throw new TypeError("Generator is already executing.");
          while (_2)
            try {
              if (f2 = 1, y2 && (t3 = op[0] & 2 ? y2["return"] : op[0] ? y2["throw"] || ((t3 = y2["return"]) && t3.call(y2), 0) : y2.next) && !(t3 = t3.call(y2, op[1])).done)
                return t3;
              if (y2 = 0, t3)
                op = [op[0] & 2, t3.value];
              switch (op[0]) {
                case 0:
                case 1:
                  t3 = op;
                  break;
                case 4:
                  _2.label++;
                  return { value: op[1], done: false };
                case 5:
                  _2.label++;
                  y2 = op[1];
                  op = [0];
                  continue;
                case 7:
                  op = _2.ops.pop();
                  _2.trys.pop();
                  continue;
                default:
                  if (!(t3 = _2.trys, t3 = t3.length > 0 && t3[t3.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                    _2 = 0;
                    continue;
                  }
                  if (op[0] === 3 && (!t3 || op[1] > t3[0] && op[1] < t3[3])) {
                    _2.label = op[1];
                    break;
                  }
                  if (op[0] === 6 && _2.label < t3[1]) {
                    _2.label = t3[1];
                    t3 = op;
                    break;
                  }
                  if (t3 && _2.label < t3[2]) {
                    _2.label = t3[2];
                    _2.ops.push(op);
                    break;
                  }
                  if (t3[2])
                    _2.ops.pop();
                  _2.trys.pop();
                  continue;
              }
              op = body.call(thisArg, _2);
            } catch (e2) {
              op = [6, e2];
              y2 = 0;
            } finally {
              f2 = t3 = 0;
            }
          if (op[0] & 5)
            throw op[1];
          return { value: op[0] ? op[1] : void 0, done: true };
        }
      };
      __exportStar2 = function(m2, o2) {
        for (var p2 in m2)
          if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(o2, p2))
            __createBinding2(o2, m2, p2);
      };
      __createBinding2 = Object.create ? function(o2, m2, k2, k22) {
        if (k22 === void 0)
          k22 = k2;
        var desc = Object.getOwnPropertyDescriptor(m2, k2);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k2];
          } };
        }
        Object.defineProperty(o2, k22, desc);
      } : function(o2, m2, k2, k22) {
        if (k22 === void 0)
          k22 = k2;
        o2[k22] = m2[k2];
      };
      __values2 = function(o2) {
        var s2 = typeof Symbol === "function" && Symbol.iterator, m2 = s2 && o2[s2], i2 = 0;
        if (m2)
          return m2.call(o2);
        if (o2 && typeof o2.length === "number")
          return {
            next: function() {
              if (o2 && i2 >= o2.length)
                o2 = void 0;
              return { value: o2 && o2[i2++], done: !o2 };
            }
          };
        throw new TypeError(s2 ? "Object is not iterable." : "Symbol.iterator is not defined.");
      };
      __read2 = function(o2, n2) {
        var m2 = typeof Symbol === "function" && o2[Symbol.iterator];
        if (!m2)
          return o2;
        var i2 = m2.call(o2), r2, ar = [], e2;
        try {
          while ((n2 === void 0 || n2-- > 0) && !(r2 = i2.next()).done)
            ar.push(r2.value);
        } catch (error2) {
          e2 = { error: error2 };
        } finally {
          try {
            if (r2 && !r2.done && (m2 = i2["return"]))
              m2.call(i2);
          } finally {
            if (e2)
              throw e2.error;
          }
        }
        return ar;
      };
      __spread2 = function() {
        for (var ar = [], i2 = 0; i2 < arguments.length; i2++)
          ar = ar.concat(__read2(arguments[i2]));
        return ar;
      };
      __spreadArrays2 = function() {
        for (var s2 = 0, i2 = 0, il = arguments.length; i2 < il; i2++)
          s2 += arguments[i2].length;
        for (var r2 = Array(s2), k2 = 0, i2 = 0; i2 < il; i2++)
          for (var a2 = arguments[i2], j2 = 0, jl = a2.length; j2 < jl; j2++, k2++)
            r2[k2] = a2[j2];
        return r2;
      };
      __spreadArray2 = function(to, from, pack) {
        if (pack || arguments.length === 2)
          for (var i2 = 0, l2 = from.length, ar; i2 < l2; i2++) {
            if (ar || !(i2 in from)) {
              if (!ar)
                ar = Array.prototype.slice.call(from, 0, i2);
              ar[i2] = from[i2];
            }
          }
        return to.concat(ar || Array.prototype.slice.call(from));
      };
      __await2 = function(v2) {
        return this instanceof __await2 ? (this.v = v2, this) : new __await2(v2);
      };
      __asyncGenerator2 = function(thisArg, _arguments, generator) {
        if (!Symbol.asyncIterator)
          throw new TypeError("Symbol.asyncIterator is not defined.");
        var g2 = generator.apply(thisArg, _arguments || []), i2, q = [];
        return i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
          return this;
        }, i2;
        function verb(n2) {
          if (g2[n2])
            i2[n2] = function(v2) {
              return new Promise(function(a2, b2) {
                q.push([n2, v2, a2, b2]) > 1 || resume(n2, v2);
              });
            };
        }
        function resume(n2, v2) {
          try {
            step(g2[n2](v2));
          } catch (e2) {
            settle(q[0][3], e2);
          }
        }
        function step(r2) {
          r2.value instanceof __await2 ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q[0][2], r2);
        }
        function fulfill(value) {
          resume("next", value);
        }
        function reject(value) {
          resume("throw", value);
        }
        function settle(f2, v2) {
          if (f2(v2), q.shift(), q.length)
            resume(q[0][0], q[0][1]);
        }
      };
      __asyncDelegator2 = function(o2) {
        var i2, p2;
        return i2 = {}, verb("next"), verb("throw", function(e2) {
          throw e2;
        }), verb("return"), i2[Symbol.iterator] = function() {
          return this;
        }, i2;
        function verb(n2, f2) {
          i2[n2] = o2[n2] ? function(v2) {
            return (p2 = !p2) ? { value: __await2(o2[n2](v2)), done: n2 === "return" } : f2 ? f2(v2) : v2;
          } : f2;
        }
      };
      __asyncValues2 = function(o2) {
        if (!Symbol.asyncIterator)
          throw new TypeError("Symbol.asyncIterator is not defined.");
        var m2 = o2[Symbol.asyncIterator], i2;
        return m2 ? m2.call(o2) : (o2 = typeof __values2 === "function" ? __values2(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
          return this;
        }, i2);
        function verb(n2) {
          i2[n2] = o2[n2] && function(v2) {
            return new Promise(function(resolve, reject) {
              v2 = o2[n2](v2), settle(resolve, reject, v2.done, v2.value);
            });
          };
        }
        function settle(resolve, reject, d2, v2) {
          Promise.resolve(v2).then(function(v3) {
            resolve({ value: v3, done: d2 });
          }, reject);
        }
      };
      __makeTemplateObject2 = function(cooked, raw) {
        if (Object.defineProperty) {
          Object.defineProperty(cooked, "raw", { value: raw });
        } else {
          cooked.raw = raw;
        }
        return cooked;
      };
      var __setModuleDefault = Object.create ? function(o2, v2) {
        Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
      } : function(o2, v2) {
        o2["default"] = v2;
      };
      __importStar2 = function(mod) {
        if (mod && mod.__esModule)
          return mod;
        var result = {};
        if (mod != null) {
          for (var k2 in mod)
            if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
              __createBinding2(result, mod, k2);
        }
        __setModuleDefault(result, mod);
        return result;
      };
      __importDefault2 = function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      __classPrivateFieldGet2 = function(receiver, state, kind, f2) {
        if (kind === "a" && !f2)
          throw new TypeError("Private accessor was defined without a getter");
        if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
          throw new TypeError("Cannot read private member from an object whose class did not declare it");
        return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
      };
      __classPrivateFieldSet2 = function(receiver, state, value, kind, f2) {
        if (kind === "m")
          throw new TypeError("Private method is not writable");
        if (kind === "a" && !f2)
          throw new TypeError("Private accessor was defined without a setter");
        if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
          throw new TypeError("Cannot write private member to an object whose class did not declare it");
        return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
      };
      __classPrivateFieldIn2 = function(state, receiver) {
        if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
          throw new TypeError("Cannot use 'in' operator on non-object");
        return typeof state === "function" ? receiver === state : state.has(receiver);
      };
      exporter("__extends", __extends2);
      exporter("__assign", __assign2);
      exporter("__rest", __rest2);
      exporter("__decorate", __decorate2);
      exporter("__param", __param2);
      exporter("__metadata", __metadata2);
      exporter("__awaiter", __awaiter2);
      exporter("__generator", __generator2);
      exporter("__exportStar", __exportStar2);
      exporter("__createBinding", __createBinding2);
      exporter("__values", __values2);
      exporter("__read", __read2);
      exporter("__spread", __spread2);
      exporter("__spreadArrays", __spreadArrays2);
      exporter("__spreadArray", __spreadArray2);
      exporter("__await", __await2);
      exporter("__asyncGenerator", __asyncGenerator2);
      exporter("__asyncDelegator", __asyncDelegator2);
      exporter("__asyncValues", __asyncValues2);
      exporter("__makeTemplateObject", __makeTemplateObject2);
      exporter("__importStar", __importStar2);
      exporter("__importDefault", __importDefault2);
      exporter("__classPrivateFieldGet", __classPrivateFieldGet2);
      exporter("__classPrivateFieldSet", __classPrivateFieldSet2);
      exporter("__classPrivateFieldIn", __classPrivateFieldIn2);
    });
  }
});

// node_modules/tslib/modules/index.js
var import_tslib, __extends, __assign, __rest, __decorate, __param, __metadata, __awaiter, __generator, __exportStar, __createBinding, __values, __read, __spread, __spreadArrays, __spreadArray, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet, __classPrivateFieldIn;
var init_modules = __esm({
  "node_modules/tslib/modules/index.js"() {
    import_tslib = __toESM(require_tslib(), 1);
    ({
      __extends,
      __assign,
      __rest,
      __decorate,
      __param,
      __metadata,
      __awaiter,
      __generator,
      __exportStar,
      __createBinding,
      __values,
      __read,
      __spread,
      __spreadArrays,
      __spreadArray,
      __await,
      __asyncGenerator,
      __asyncDelegator,
      __asyncValues,
      __makeTemplateObject,
      __importStar,
      __importDefault,
      __classPrivateFieldGet,
      __classPrivateFieldSet,
      __classPrivateFieldIn
    } = import_tslib.default);
  }
});

// node_modules/react-remove-scroll-bar/dist/es2015/constants.js
var zeroRightClassName, fullWidthClassName, noScrollbarsClassName, removedBarSizeVariable;
var init_constants4 = __esm({
  "node_modules/react-remove-scroll-bar/dist/es2015/constants.js"() {
    zeroRightClassName = "right-scroll-bar-position";
    fullWidthClassName = "width-before-scroll-bar";
    noScrollbarsClassName = "with-scroll-bars-hidden";
    removedBarSizeVariable = "--removed-body-scroll-bar-size";
  }
});

// node_modules/use-callback-ref/dist/es2015/assignRef.js
function assignRef(ref, value) {
  if (typeof ref === "function") {
    ref(value);
  } else if (ref) {
    ref.current = value;
  }
  return ref;
}
var init_assignRef = __esm({
  "node_modules/use-callback-ref/dist/es2015/assignRef.js"() {
  }
});

// node_modules/use-callback-ref/dist/es2015/useRef.js
function useCallbackRef2(initialValue, callback) {
  var ref = (0, import_react64.useState)(function() {
    return {
      value: initialValue,
      callback,
      facade: {
        get current() {
          return ref.value;
        },
        set current(value) {
          var last7 = ref.value;
          if (last7 !== value) {
            ref.value = value;
            ref.callback(value, last7);
          }
        }
      }
    };
  })[0];
  ref.callback = callback;
  return ref.facade;
}
var import_react64;
var init_useRef = __esm({
  "node_modules/use-callback-ref/dist/es2015/useRef.js"() {
    import_react64 = __toESM(require_react());
  }
});

// node_modules/use-callback-ref/dist/es2015/useMergeRef.js
function useMergeRefs(refs, defaultValue) {
  var callbackRef = useCallbackRef2(defaultValue || null, function(newValue) {
    return refs.forEach(function(ref) {
      return assignRef(ref, newValue);
    });
  });
  useIsomorphicLayoutEffect(function() {
    var oldValue = currentValues.get(callbackRef);
    if (oldValue) {
      var prevRefs_1 = new Set(oldValue);
      var nextRefs_1 = new Set(refs);
      var current_1 = callbackRef.current;
      prevRefs_1.forEach(function(ref) {
        if (!nextRefs_1.has(ref)) {
          assignRef(ref, null);
        }
      });
      nextRefs_1.forEach(function(ref) {
        if (!prevRefs_1.has(ref)) {
          assignRef(ref, current_1);
        }
      });
    }
    currentValues.set(callbackRef, refs);
  }, [refs]);
  return callbackRef;
}
var React32, useIsomorphicLayoutEffect, currentValues;
var init_useMergeRef = __esm({
  "node_modules/use-callback-ref/dist/es2015/useMergeRef.js"() {
    React32 = __toESM(require_react());
    init_assignRef();
    init_useRef();
    useIsomorphicLayoutEffect = typeof window !== "undefined" ? React32.useLayoutEffect : React32.useEffect;
    currentValues = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/use-callback-ref/dist/es2015/index.js
var init_es2015 = __esm({
  "node_modules/use-callback-ref/dist/es2015/index.js"() {
    init_useMergeRef();
  }
});

// node_modules/use-sidecar/dist/es2015/medium.js
function ItoI(a2) {
  return a2;
}
function innerCreateMedium(defaults2, middleware) {
  if (middleware === void 0) {
    middleware = ItoI;
  }
  var buffer = [];
  var assigned = false;
  var medium = {
    read: function() {
      if (assigned) {
        throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
      }
      if (buffer.length) {
        return buffer[buffer.length - 1];
      }
      return defaults2;
    },
    useMedium: function(data) {
      var item = middleware(data, assigned);
      buffer.push(item);
      return function() {
        buffer = buffer.filter(function(x2) {
          return x2 !== item;
        });
      };
    },
    assignSyncMedium: function(cb) {
      assigned = true;
      while (buffer.length) {
        var cbs = buffer;
        buffer = [];
        cbs.forEach(cb);
      }
      buffer = {
        push: function(x2) {
          return cb(x2);
        },
        filter: function() {
          return buffer;
        }
      };
    },
    assignMedium: function(cb) {
      assigned = true;
      var pendingQueue = [];
      if (buffer.length) {
        var cbs = buffer;
        buffer = [];
        cbs.forEach(cb);
        pendingQueue = buffer;
      }
      var executeQueue = function() {
        var cbs2 = pendingQueue;
        pendingQueue = [];
        cbs2.forEach(cb);
      };
      var cycle = function() {
        return Promise.resolve().then(executeQueue);
      };
      cycle();
      buffer = {
        push: function(x2) {
          pendingQueue.push(x2);
          cycle();
        },
        filter: function(filter2) {
          pendingQueue = pendingQueue.filter(filter2);
          return buffer;
        }
      };
    }
  };
  return medium;
}
function createSidecarMedium(options) {
  if (options === void 0) {
    options = {};
  }
  var medium = innerCreateMedium(null);
  medium.options = __assign({ async: true, ssr: false }, options);
  return medium;
}
var init_medium = __esm({
  "node_modules/use-sidecar/dist/es2015/medium.js"() {
    init_modules();
  }
});

// node_modules/use-sidecar/dist/es2015/exports.js
function exportSidecar(medium, exported) {
  medium.useMedium(exported);
  return SideCar;
}
var React33, SideCar;
var init_exports = __esm({
  "node_modules/use-sidecar/dist/es2015/exports.js"() {
    init_modules();
    React33 = __toESM(require_react());
    SideCar = function(_a) {
      var sideCar = _a.sideCar, rest = __rest(_a, ["sideCar"]);
      if (!sideCar) {
        throw new Error("Sidecar: please provide `sideCar` property to import the right car");
      }
      var Target = sideCar.read();
      if (!Target) {
        throw new Error("Sidecar medium not found");
      }
      return React33.createElement(Target, __assign({}, rest));
    };
    SideCar.isSideCarExport = true;
  }
});

// node_modules/use-sidecar/dist/es2015/index.js
var init_es20152 = __esm({
  "node_modules/use-sidecar/dist/es2015/index.js"() {
    init_medium();
    init_exports();
  }
});

// node_modules/react-remove-scroll/dist/es2015/medium.js
var effectCar;
var init_medium2 = __esm({
  "node_modules/react-remove-scroll/dist/es2015/medium.js"() {
    init_es20152();
    effectCar = createSidecarMedium();
  }
});

// node_modules/react-remove-scroll/dist/es2015/UI.js
var React34, nothing, RemoveScroll;
var init_UI = __esm({
  "node_modules/react-remove-scroll/dist/es2015/UI.js"() {
    init_modules();
    React34 = __toESM(require_react());
    init_constants4();
    init_es2015();
    init_medium2();
    nothing = function() {
      return;
    };
    RemoveScroll = React34.forwardRef(function(props, parentRef) {
      var ref = React34.useRef(null);
      var _a = React34.useState({
        onScrollCapture: nothing,
        onWheelCapture: nothing,
        onTouchMoveCapture: nothing
      }), callbacks = _a[0], setCallbacks = _a[1];
      var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? "div" : _b, gapMode = props.gapMode, rest = __rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]);
      var SideCar2 = sideCar;
      var containerRef = useMergeRefs([ref, parentRef]);
      var containerProps = __assign(__assign({}, rest), callbacks);
      return React34.createElement(React34.Fragment, null, enabled && React34.createElement(SideCar2, { sideCar: effectCar, removeScrollBar, shards, noIsolation, inert, setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode }), forwardProps ? React34.cloneElement(React34.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef })) : React34.createElement(Container, __assign({}, containerProps, { className, ref: containerRef }), children));
    });
    RemoveScroll.defaultProps = {
      enabled: true,
      removeScrollBar: true,
      inert: false
    };
    RemoveScroll.classNames = {
      fullWidth: fullWidthClassName,
      zeroRight: zeroRightClassName
    };
  }
});

// node_modules/get-nonce/dist/es2015/index.js
var currentNonce, getNonce;
var init_es20153 = __esm({
  "node_modules/get-nonce/dist/es2015/index.js"() {
    getNonce = function() {
      if (currentNonce) {
        return currentNonce;
      }
      if (typeof __webpack_nonce__ !== "undefined") {
        return __webpack_nonce__;
      }
      return void 0;
    };
  }
});

// node_modules/react-style-singleton/dist/es2015/singleton.js
function makeStyleTag() {
  if (!document)
    return null;
  var tag = document.createElement("style");
  tag.type = "text/css";
  var nonce = getNonce();
  if (nonce) {
    tag.setAttribute("nonce", nonce);
  }
  return tag;
}
function injectStyles(tag, css) {
  if (tag.styleSheet) {
    tag.styleSheet.cssText = css;
  } else {
    tag.appendChild(document.createTextNode(css));
  }
}
function insertStyleTag(tag) {
  var head = document.head || document.getElementsByTagName("head")[0];
  head.appendChild(tag);
}
var stylesheetSingleton;
var init_singleton = __esm({
  "node_modules/react-style-singleton/dist/es2015/singleton.js"() {
    init_es20153();
    stylesheetSingleton = function() {
      var counter = 0;
      var stylesheet = null;
      return {
        add: function(style) {
          if (counter == 0) {
            if (stylesheet = makeStyleTag()) {
              injectStyles(stylesheet, style);
              insertStyleTag(stylesheet);
            }
          }
          counter++;
        },
        remove: function() {
          counter--;
          if (!counter && stylesheet) {
            stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);
            stylesheet = null;
          }
        }
      };
    };
  }
});

// node_modules/react-style-singleton/dist/es2015/hook.js
var React35, styleHookSingleton;
var init_hook = __esm({
  "node_modules/react-style-singleton/dist/es2015/hook.js"() {
    React35 = __toESM(require_react());
    init_singleton();
    styleHookSingleton = function() {
      var sheet = stylesheetSingleton();
      return function(styles3, isDynamic) {
        React35.useEffect(function() {
          sheet.add(styles3);
          return function() {
            sheet.remove();
          };
        }, [styles3 && isDynamic]);
      };
    };
  }
});

// node_modules/react-style-singleton/dist/es2015/component.js
var styleSingleton;
var init_component = __esm({
  "node_modules/react-style-singleton/dist/es2015/component.js"() {
    init_hook();
    styleSingleton = function() {
      var useStyle = styleHookSingleton();
      var Sheet = function(_a) {
        var styles3 = _a.styles, dynamic = _a.dynamic;
        useStyle(styles3, dynamic);
        return null;
      };
      return Sheet;
    };
  }
});

// node_modules/react-style-singleton/dist/es2015/index.js
var init_es20154 = __esm({
  "node_modules/react-style-singleton/dist/es2015/index.js"() {
    init_component();
    init_singleton();
    init_hook();
  }
});

// node_modules/react-remove-scroll-bar/dist/es2015/utils.js
var zeroGap, parse, getOffset, getGapWidth;
var init_utils2 = __esm({
  "node_modules/react-remove-scroll-bar/dist/es2015/utils.js"() {
    zeroGap = {
      left: 0,
      top: 0,
      right: 0,
      gap: 0
    };
    parse = function(x2) {
      return parseInt(x2 || "", 10) || 0;
    };
    getOffset = function(gapMode) {
      var cs = window.getComputedStyle(document.body);
      var left2 = cs[gapMode === "padding" ? "paddingLeft" : "marginLeft"];
      var top2 = cs[gapMode === "padding" ? "paddingTop" : "marginTop"];
      var right2 = cs[gapMode === "padding" ? "paddingRight" : "marginRight"];
      return [parse(left2), parse(top2), parse(right2)];
    };
    getGapWidth = function(gapMode) {
      if (gapMode === void 0) {
        gapMode = "margin";
      }
      if (typeof window === "undefined") {
        return zeroGap;
      }
      var offsets = getOffset(gapMode);
      var documentWidth = document.documentElement.clientWidth;
      var windowWidth = window.innerWidth;
      return {
        left: offsets[0],
        top: offsets[1],
        right: offsets[2],
        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0])
      };
    };
  }
});

// node_modules/react-remove-scroll-bar/dist/es2015/component.js
var React36, Style, lockAttribute, getStyles, getCurrentUseCounter, useLockAttribute, RemoveScrollBar;
var init_component2 = __esm({
  "node_modules/react-remove-scroll-bar/dist/es2015/component.js"() {
    React36 = __toESM(require_react());
    init_es20154();
    init_constants4();
    init_utils2();
    Style = styleSingleton();
    lockAttribute = "data-scroll-locked";
    getStyles = function(_a, allowRelative, gapMode, important) {
      var left2 = _a.left, top2 = _a.top, right2 = _a.right, gap = _a.gap;
      if (gapMode === void 0) {
        gapMode = "margin";
      }
      return "\n  .".concat(noScrollbarsClassName, " {\n   overflow: hidden ").concat(important, ";\n   padding-right: ").concat(gap, "px ").concat(important, ";\n  }\n  body[").concat(lockAttribute, "] {\n    overflow: hidden ").concat(important, ";\n    overscroll-behavior: contain;\n    ").concat([
        allowRelative && "position: relative ".concat(important, ";"),
        gapMode === "margin" && "\n    padding-left: ".concat(left2, "px;\n    padding-top: ").concat(top2, "px;\n    padding-right: ").concat(right2, "px;\n    margin-left:0;\n    margin-top:0;\n    margin-right: ").concat(gap, "px ").concat(important, ";\n    "),
        gapMode === "padding" && "padding-right: ".concat(gap, "px ").concat(important, ";")
      ].filter(Boolean).join(""), "\n  }\n  \n  .").concat(zeroRightClassName, " {\n    right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " {\n    margin-right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(zeroRightClassName, " .").concat(zeroRightClassName, " {\n    right: 0 ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " .").concat(fullWidthClassName, " {\n    margin-right: 0 ").concat(important, ";\n  }\n  \n  body[").concat(lockAttribute, "] {\n    ").concat(removedBarSizeVariable, ": ").concat(gap, "px;\n  }\n");
    };
    getCurrentUseCounter = function() {
      var counter = parseInt(document.body.getAttribute(lockAttribute) || "0", 10);
      return isFinite(counter) ? counter : 0;
    };
    useLockAttribute = function() {
      React36.useEffect(function() {
        document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString());
        return function() {
          var newCounter = getCurrentUseCounter() - 1;
          if (newCounter <= 0) {
            document.body.removeAttribute(lockAttribute);
          } else {
            document.body.setAttribute(lockAttribute, newCounter.toString());
          }
        };
      }, []);
    };
    RemoveScrollBar = function(_a) {
      var noRelative = _a.noRelative, noImportant = _a.noImportant, _b = _a.gapMode, gapMode = _b === void 0 ? "margin" : _b;
      useLockAttribute();
      var gap = React36.useMemo(function() {
        return getGapWidth(gapMode);
      }, [gapMode]);
      return React36.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? "!important" : "") });
    };
  }
});

// node_modules/react-remove-scroll-bar/dist/es2015/index.js
var init_es20155 = __esm({
  "node_modules/react-remove-scroll-bar/dist/es2015/index.js"() {
    init_component2();
    init_constants4();
    init_utils2();
  }
});

// node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js
var passiveSupported, options, nonPassive;
var init_aggresiveCapture = __esm({
  "node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js"() {
    passiveSupported = false;
    if (typeof window !== "undefined") {
      try {
        options = Object.defineProperty({}, "passive", {
          get: function() {
            passiveSupported = true;
            return true;
          }
        });
        window.addEventListener("test", options, options);
        window.removeEventListener("test", options, options);
      } catch (err) {
        passiveSupported = false;
      }
    }
    nonPassive = passiveSupported ? { passive: false } : false;
  }
});

// node_modules/react-remove-scroll/dist/es2015/handleScroll.js
var alwaysContainsScroll, elementCanBeScrolled, elementCouldBeVScrolled, elementCouldBeHScrolled, locationCouldBeScrolled, getVScrollVariables, getHScrollVariables, elementCouldBeScrolled, getScrollVariables, getDirectionFactor, handleScroll;
var init_handleScroll = __esm({
  "node_modules/react-remove-scroll/dist/es2015/handleScroll.js"() {
    alwaysContainsScroll = function(node) {
      return node.tagName === "TEXTAREA";
    };
    elementCanBeScrolled = function(node, overflow) {
      if (!(node instanceof Element)) {
        return false;
      }
      var styles3 = window.getComputedStyle(node);
      return styles3[overflow] !== "hidden" && !(styles3.overflowY === styles3.overflowX && !alwaysContainsScroll(node) && styles3[overflow] === "visible");
    };
    elementCouldBeVScrolled = function(node) {
      return elementCanBeScrolled(node, "overflowY");
    };
    elementCouldBeHScrolled = function(node) {
      return elementCanBeScrolled(node, "overflowX");
    };
    locationCouldBeScrolled = function(axis, node) {
      var ownerDocument = node.ownerDocument;
      var current = node;
      do {
        if (typeof ShadowRoot !== "undefined" && current instanceof ShadowRoot) {
          current = current.host;
        }
        var isScrollable = elementCouldBeScrolled(axis, current);
        if (isScrollable) {
          var _a = getScrollVariables(axis, current), scrollHeight = _a[1], clientHeight = _a[2];
          if (scrollHeight > clientHeight) {
            return true;
          }
        }
        current = current.parentNode;
      } while (current && current !== ownerDocument.body);
      return false;
    };
    getVScrollVariables = function(_a) {
      var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
      return [
        scrollTop,
        scrollHeight,
        clientHeight
      ];
    };
    getHScrollVariables = function(_a) {
      var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;
      return [
        scrollLeft,
        scrollWidth,
        clientWidth
      ];
    };
    elementCouldBeScrolled = function(axis, node) {
      return axis === "v" ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);
    };
    getScrollVariables = function(axis, node) {
      return axis === "v" ? getVScrollVariables(node) : getHScrollVariables(node);
    };
    getDirectionFactor = function(axis, direction) {
      return axis === "h" && direction === "rtl" ? -1 : 1;
    };
    handleScroll = function(axis, endTarget, event, sourceDelta, noOverscroll) {
      var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);
      var delta = directionFactor * sourceDelta;
      var target = event.target;
      var targetInLock = endTarget.contains(target);
      var shouldCancelScroll = false;
      var isDeltaPositive = delta > 0;
      var availableScroll = 0;
      var availableScrollTop = 0;
      do {
        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];
        var elementScroll = scroll_1 - capacity - directionFactor * position;
        if (position || elementScroll) {
          if (elementCouldBeScrolled(axis, target)) {
            availableScroll += elementScroll;
            availableScrollTop += position;
          }
        }
        if (target instanceof ShadowRoot) {
          target = target.host;
        } else {
          target = target.parentNode;
        }
      } while (!targetInLock && target !== document.body || targetInLock && (endTarget.contains(target) || endTarget === target));
      if (isDeltaPositive && (noOverscroll && Math.abs(availableScroll) < 1 || !noOverscroll && delta > availableScroll)) {
        shouldCancelScroll = true;
      } else if (!isDeltaPositive && (noOverscroll && Math.abs(availableScrollTop) < 1 || !noOverscroll && -delta > availableScrollTop)) {
        shouldCancelScroll = true;
      }
      return shouldCancelScroll;
    };
  }
});

// node_modules/react-remove-scroll/dist/es2015/SideEffect.js
function RemoveScrollSideCar(props) {
  var shouldPreventQueue = React37.useRef([]);
  var touchStartRef = React37.useRef([0, 0]);
  var activeAxis = React37.useRef();
  var id = React37.useState(idCounter++)[0];
  var Style2 = React37.useState(styleSingleton)[0];
  var lastProps = React37.useRef(props);
  React37.useEffect(function() {
    lastProps.current = props;
  }, [props]);
  React37.useEffect(function() {
    if (props.inert) {
      document.body.classList.add("block-interactivity-".concat(id));
      var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
      allow_1.forEach(function(el) {
        return el.classList.add("allow-interactivity-".concat(id));
      });
      return function() {
        document.body.classList.remove("block-interactivity-".concat(id));
        allow_1.forEach(function(el) {
          return el.classList.remove("allow-interactivity-".concat(id));
        });
      };
    }
    return;
  }, [props.inert, props.lockRef.current, props.shards]);
  var shouldCancelEvent = React37.useCallback(function(event, parent) {
    if ("touches" in event && event.touches.length === 2 || event.type === "wheel" && event.ctrlKey) {
      return !lastProps.current.allowPinchZoom;
    }
    var touch = getTouchXY(event);
    var touchStart = touchStartRef.current;
    var deltaX = "deltaX" in event ? event.deltaX : touchStart[0] - touch[0];
    var deltaY = "deltaY" in event ? event.deltaY : touchStart[1] - touch[1];
    var currentAxis;
    var target = event.target;
    var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "h" : "v";
    if ("touches" in event && moveDirection === "h" && target.type === "range") {
      return false;
    }
    var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
    if (!canBeScrolledInMainDirection) {
      return true;
    }
    if (canBeScrolledInMainDirection) {
      currentAxis = moveDirection;
    } else {
      currentAxis = moveDirection === "v" ? "h" : "v";
      canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
    }
    if (!canBeScrolledInMainDirection) {
      return false;
    }
    if (!activeAxis.current && "changedTouches" in event && (deltaX || deltaY)) {
      activeAxis.current = currentAxis;
    }
    if (!currentAxis) {
      return true;
    }
    var cancelingAxis = activeAxis.current || currentAxis;
    return handleScroll(cancelingAxis, parent, event, cancelingAxis === "h" ? deltaX : deltaY, true);
  }, []);
  var shouldPrevent = React37.useCallback(function(_event) {
    var event = _event;
    if (!lockStack.length || lockStack[lockStack.length - 1] !== Style2) {
      return;
    }
    var delta = "deltaY" in event ? getDeltaXY(event) : getTouchXY(event);
    var sourceEvent = shouldPreventQueue.current.filter(function(e2) {
      return e2.name === event.type && (e2.target === event.target || event.target === e2.shadowParent) && deltaCompare(e2.delta, delta);
    })[0];
    if (sourceEvent && sourceEvent.should) {
      if (event.cancelable) {
        event.preventDefault();
      }
      return;
    }
    if (!sourceEvent) {
      var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function(node) {
        return node.contains(event.target);
      });
      var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;
      if (shouldStop) {
        if (event.cancelable) {
          event.preventDefault();
        }
      }
    }
  }, []);
  var shouldCancel = React37.useCallback(function(name, delta, target, should) {
    var event = { name, delta, target, should, shadowParent: getOutermostShadowParent(target) };
    shouldPreventQueue.current.push(event);
    setTimeout(function() {
      shouldPreventQueue.current = shouldPreventQueue.current.filter(function(e2) {
        return e2 !== event;
      });
    }, 1);
  }, []);
  var scrollTouchStart = React37.useCallback(function(event) {
    touchStartRef.current = getTouchXY(event);
    activeAxis.current = void 0;
  }, []);
  var scrollWheel = React37.useCallback(function(event) {
    shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
  }, []);
  var scrollTouchMove = React37.useCallback(function(event) {
    shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
  }, []);
  React37.useEffect(function() {
    lockStack.push(Style2);
    props.setCallbacks({
      onScrollCapture: scrollWheel,
      onWheelCapture: scrollWheel,
      onTouchMoveCapture: scrollTouchMove
    });
    document.addEventListener("wheel", shouldPrevent, nonPassive);
    document.addEventListener("touchmove", shouldPrevent, nonPassive);
    document.addEventListener("touchstart", scrollTouchStart, nonPassive);
    return function() {
      lockStack = lockStack.filter(function(inst3) {
        return inst3 !== Style2;
      });
      document.removeEventListener("wheel", shouldPrevent, nonPassive);
      document.removeEventListener("touchmove", shouldPrevent, nonPassive);
      document.removeEventListener("touchstart", scrollTouchStart, nonPassive);
    };
  }, []);
  var removeScrollBar = props.removeScrollBar, inert = props.inert;
  return React37.createElement(React37.Fragment, null, inert ? React37.createElement(Style2, { styles: generateStyle(id) }) : null, removeScrollBar ? React37.createElement(RemoveScrollBar, { gapMode: props.gapMode }) : null);
}
function getOutermostShadowParent(node) {
  var shadowParent = null;
  while (node !== null) {
    if (node instanceof ShadowRoot) {
      shadowParent = node.host;
      node = node.host;
    }
    node = node.parentNode;
  }
  return shadowParent;
}
var React37, getTouchXY, getDeltaXY, extractRef, deltaCompare, generateStyle, idCounter, lockStack;
var init_SideEffect = __esm({
  "node_modules/react-remove-scroll/dist/es2015/SideEffect.js"() {
    init_modules();
    React37 = __toESM(require_react());
    init_es20155();
    init_es20154();
    init_aggresiveCapture();
    init_handleScroll();
    getTouchXY = function(event) {
      return "changedTouches" in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
    };
    getDeltaXY = function(event) {
      return [event.deltaX, event.deltaY];
    };
    extractRef = function(ref) {
      return ref && "current" in ref ? ref.current : ref;
    };
    deltaCompare = function(x2, y2) {
      return x2[0] === y2[0] && x2[1] === y2[1];
    };
    generateStyle = function(id) {
      return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n");
    };
    idCounter = 0;
    lockStack = [];
  }
});

// node_modules/react-remove-scroll/dist/es2015/sidecar.js
var sidecar_default;
var init_sidecar = __esm({
  "node_modules/react-remove-scroll/dist/es2015/sidecar.js"() {
    init_es20152();
    init_SideEffect();
    init_medium2();
    sidecar_default = exportSidecar(effectCar, RemoveScrollSideCar);
  }
});

// node_modules/react-remove-scroll/dist/es2015/Combination.js
var React38, ReactRemoveScroll, Combination_default;
var init_Combination = __esm({
  "node_modules/react-remove-scroll/dist/es2015/Combination.js"() {
    init_modules();
    React38 = __toESM(require_react());
    init_UI();
    init_sidecar();
    ReactRemoveScroll = React38.forwardRef(function(props, ref) {
      return React38.createElement(RemoveScroll, __assign({}, props, { ref, sideCar: sidecar_default }));
    });
    ReactRemoveScroll.classNames = RemoveScroll.classNames;
    Combination_default = ReactRemoveScroll;
  }
});

// node_modules/react-remove-scroll/dist/es2015/index.js
var init_es20156 = __esm({
  "node_modules/react-remove-scroll/dist/es2015/index.js"() {
    init_Combination();
  }
});

// node_modules/aria-hidden/dist/es2015/index.js
var getDefaultParent, counterMap, uncontrolledNodes, markerMap, lockCount, unwrapHost, correctTargets, applyAttributeToOthers, hideOthers;
var init_es20157 = __esm({
  "node_modules/aria-hidden/dist/es2015/index.js"() {
    getDefaultParent = function(originalTarget) {
      if (typeof document === "undefined") {
        return null;
      }
      var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
      return sampleTarget.ownerDocument.body;
    };
    counterMap = /* @__PURE__ */ new WeakMap();
    uncontrolledNodes = /* @__PURE__ */ new WeakMap();
    markerMap = {};
    lockCount = 0;
    unwrapHost = function(node) {
      return node && (node.host || unwrapHost(node.parentNode));
    };
    correctTargets = function(parent, targets) {
      return targets.map(function(target) {
        if (parent.contains(target)) {
          return target;
        }
        var correctedTarget = unwrapHost(target);
        if (correctedTarget && parent.contains(correctedTarget)) {
          return correctedTarget;
        }
        console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing");
        return null;
      }).filter(function(x2) {
        return Boolean(x2);
      });
    };
    applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) {
      var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
      if (!markerMap[markerName]) {
        markerMap[markerName] = /* @__PURE__ */ new WeakMap();
      }
      var markerCounter = markerMap[markerName];
      var hiddenNodes = [];
      var elementsToKeep = /* @__PURE__ */ new Set();
      var elementsToStop = new Set(targets);
      var keep = function(el) {
        if (!el || elementsToKeep.has(el)) {
          return;
        }
        elementsToKeep.add(el);
        keep(el.parentNode);
      };
      targets.forEach(keep);
      var deep = function(parent) {
        if (!parent || elementsToStop.has(parent)) {
          return;
        }
        Array.prototype.forEach.call(parent.children, function(node) {
          if (elementsToKeep.has(node)) {
            deep(node);
          } else {
            try {
              var attr = node.getAttribute(controlAttribute);
              var alreadyHidden = attr !== null && attr !== "false";
              var counterValue = (counterMap.get(node) || 0) + 1;
              var markerValue = (markerCounter.get(node) || 0) + 1;
              counterMap.set(node, counterValue);
              markerCounter.set(node, markerValue);
              hiddenNodes.push(node);
              if (counterValue === 1 && alreadyHidden) {
                uncontrolledNodes.set(node, true);
              }
              if (markerValue === 1) {
                node.setAttribute(markerName, "true");
              }
              if (!alreadyHidden) {
                node.setAttribute(controlAttribute, "true");
              }
            } catch (e2) {
              console.error("aria-hidden: cannot operate on ", node, e2);
            }
          }
        });
      };
      deep(parentNode);
      elementsToKeep.clear();
      lockCount++;
      return function() {
        hiddenNodes.forEach(function(node) {
          var counterValue = counterMap.get(node) - 1;
          var markerValue = markerCounter.get(node) - 1;
          counterMap.set(node, counterValue);
          markerCounter.set(node, markerValue);
          if (!counterValue) {
            if (!uncontrolledNodes.has(node)) {
              node.removeAttribute(controlAttribute);
            }
            uncontrolledNodes.delete(node);
          }
          if (!markerValue) {
            node.removeAttribute(markerName);
          }
        });
        lockCount--;
        if (!lockCount) {
          counterMap = /* @__PURE__ */ new WeakMap();
          counterMap = /* @__PURE__ */ new WeakMap();
          uncontrolledNodes = /* @__PURE__ */ new WeakMap();
          markerMap = {};
        }
      };
    };
    hideOthers = function(originalTarget, parentNode, markerName) {
      if (markerName === void 0) {
        markerName = "data-aria-hidden";
      }
      var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
      var activeParentNode = parentNode || getDefaultParent(originalTarget);
      if (!activeParentNode) {
        return function() {
          return null;
        };
      }
      targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live]")));
      return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
    };
  }
});

// node_modules/@radix-ui/react-dialog/dist/index.mjs
function getState(open) {
  return open ? "open" : "closed";
}
var React39, import_jsx_runtime72, DIALOG_NAME, createDialogContext, createDialogScope, DialogProvider, useDialogContext, Dialog, TRIGGER_NAME, DialogTrigger, PORTAL_NAME2, PortalProvider, usePortalContext, DialogPortal, OVERLAY_NAME, DialogOverlay, DialogOverlayImpl, CONTENT_NAME, DialogContent, DialogContentModal, DialogContentNonModal, DialogContentImpl, TITLE_NAME, DialogTitle, DESCRIPTION_NAME, DialogDescription, CLOSE_NAME, DialogClose, TITLE_WARNING_NAME, WarningProvider, useWarningContext, TitleWarning, DESCRIPTION_WARNING_NAME, DescriptionWarning, Root2, Portal2, Overlay, Content;
var init_dist16 = __esm({
  "node_modules/@radix-ui/react-dialog/dist/index.mjs"() {
    React39 = __toESM(require_react(), 1);
    init_dist();
    init_dist2();
    init_dist3();
    init_dist5();
    init_dist7();
    init_dist11();
    init_dist12();
    init_dist13();
    init_dist14();
    init_dist9();
    init_dist15();
    init_es20156();
    init_es20157();
    init_dist8();
    import_jsx_runtime72 = __toESM(require_jsx_runtime(), 1);
    "use client";
    DIALOG_NAME = "Dialog";
    [createDialogContext, createDialogScope] = createContextScope(DIALOG_NAME);
    [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME);
    Dialog = (props) => {
      const {
        __scopeDialog,
        children,
        open: openProp,
        defaultOpen,
        onOpenChange,
        modal = true
      } = props;
      const triggerRef = React39.useRef(null);
      const contentRef = React39.useRef(null);
      const [open = false, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogProvider, {
        scope: __scopeDialog,
        triggerRef,
        contentRef,
        contentId: useId2(),
        titleId: useId2(),
        descriptionId: useId2(),
        open,
        onOpenChange: setOpen,
        onOpenToggle: React39.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
        modal,
        children
      });
    };
    Dialog.displayName = DIALOG_NAME;
    TRIGGER_NAME = "DialogTrigger";
    DialogTrigger = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, ...triggerProps } = props;
      const context = useDialogContext(TRIGGER_NAME, __scopeDialog);
      const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Primitive.button, {
        type: "button",
        "aria-haspopup": "dialog",
        "aria-expanded": context.open,
        "aria-controls": context.contentId,
        "data-state": getState(context.open),
        ...triggerProps,
        ref: composedTriggerRef,
        onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
      });
    });
    DialogTrigger.displayName = TRIGGER_NAME;
    PORTAL_NAME2 = "DialogPortal";
    [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME2, {
      forceMount: void 0
    });
    DialogPortal = (props) => {
      const { __scopeDialog, forceMount, children, container } = props;
      const context = useDialogContext(PORTAL_NAME2, __scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(PortalProvider, { scope: __scopeDialog, forceMount, children: React39.Children.map(children, (child) => /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Portal, { asChild: true, container, children: child }) })) });
    };
    DialogPortal.displayName = PORTAL_NAME2;
    OVERLAY_NAME = "DialogOverlay";
    DialogOverlay = React39.forwardRef((props, forwardedRef) => {
      const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog);
      const { forceMount = portalContext.forceMount, ...overlayProps } = props;
      const context = useDialogContext(OVERLAY_NAME, props.__scopeDialog);
      return context.modal ? /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogOverlayImpl, { ...overlayProps, ref: forwardedRef }) }) : null;
    });
    DialogOverlay.displayName = OVERLAY_NAME;
    DialogOverlayImpl = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, ...overlayProps } = props;
      const context = useDialogContext(OVERLAY_NAME, __scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Combination_default, { as: Slot, allowPinchZoom: true, shards: [context.contentRef], children: /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Primitive.div, {
        "data-state": getState(context.open),
        ...overlayProps,
        ref: forwardedRef,
        style: { pointerEvents: "auto", ...overlayProps.style }
      }) });
    });
    CONTENT_NAME = "DialogContent";
    DialogContent = React39.forwardRef((props, forwardedRef) => {
      const portalContext = usePortalContext(CONTENT_NAME, props.__scopeDialog);
      const { forceMount = portalContext.forceMount, ...contentProps } = props;
      const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Presence, { present: forceMount || context.open, children: context.modal ? /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogContentNonModal, { ...contentProps, ref: forwardedRef }) });
    });
    DialogContent.displayName = CONTENT_NAME;
    DialogContentModal = React39.forwardRef((props, forwardedRef) => {
      const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
      const contentRef = React39.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, context.contentRef, contentRef);
      React39.useEffect(() => {
        const content = contentRef.current;
        if (content)
          return hideOthers(content);
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogContentImpl, {
        ...props,
        ref: composedRefs,
        trapFocus: context.open,
        disableOutsidePointerEvents: true,
        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
          event.preventDefault();
          context.triggerRef.current?.focus();
        }),
        onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
          const originalEvent = event.detail.originalEvent;
          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
          if (isRightClick)
            event.preventDefault();
        }),
        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => event.preventDefault())
      });
    });
    DialogContentNonModal = React39.forwardRef((props, forwardedRef) => {
      const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
      const hasInteractedOutsideRef = React39.useRef(false);
      const hasPointerDownOutsideRef = React39.useRef(false);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DialogContentImpl, {
        ...props,
        ref: forwardedRef,
        trapFocus: false,
        disableOutsidePointerEvents: false,
        onCloseAutoFocus: (event) => {
          props.onCloseAutoFocus?.(event);
          if (!event.defaultPrevented) {
            if (!hasInteractedOutsideRef.current)
              context.triggerRef.current?.focus();
            event.preventDefault();
          }
          hasInteractedOutsideRef.current = false;
          hasPointerDownOutsideRef.current = false;
        },
        onInteractOutside: (event) => {
          props.onInteractOutside?.(event);
          if (!event.defaultPrevented) {
            hasInteractedOutsideRef.current = true;
            if (event.detail.originalEvent.type === "pointerdown") {
              hasPointerDownOutsideRef.current = true;
            }
          }
          const target = event.target;
          const targetIsTrigger = context.triggerRef.current?.contains(target);
          if (targetIsTrigger)
            event.preventDefault();
          if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) {
            event.preventDefault();
          }
        }
      });
    });
    DialogContentImpl = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;
      const context = useDialogContext(CONTENT_NAME, __scopeDialog);
      const contentRef = React39.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, contentRef);
      useFocusGuards();
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsxs)(import_jsx_runtime72.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(FocusScope, {
          asChild: true,
          loop: true,
          trapped: trapFocus,
          onMountAutoFocus: onOpenAutoFocus,
          onUnmountAutoFocus: onCloseAutoFocus,
          children: /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DismissableLayer, {
            role: "dialog",
            id: context.contentId,
            "aria-describedby": context.descriptionId,
            "aria-labelledby": context.titleId,
            "data-state": getState(context.open),
            ...contentProps,
            ref: composedRefs,
            onDismiss: () => context.onOpenChange(false)
          })
        }),
        /* @__PURE__ */ (0, import_jsx_runtime72.jsxs)(import_jsx_runtime72.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(TitleWarning, { titleId: context.titleId }),
          /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(DescriptionWarning, { contentRef, descriptionId: context.descriptionId })
        ] })
      ] });
    });
    TITLE_NAME = "DialogTitle";
    DialogTitle = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, ...titleProps } = props;
      const context = useDialogContext(TITLE_NAME, __scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Primitive.h2, { id: context.titleId, ...titleProps, ref: forwardedRef });
    });
    DialogTitle.displayName = TITLE_NAME;
    DESCRIPTION_NAME = "DialogDescription";
    DialogDescription = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, ...descriptionProps } = props;
      const context = useDialogContext(DESCRIPTION_NAME, __scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Primitive.p, { id: context.descriptionId, ...descriptionProps, ref: forwardedRef });
    });
    DialogDescription.displayName = DESCRIPTION_NAME;
    CLOSE_NAME = "DialogClose";
    DialogClose = React39.forwardRef((props, forwardedRef) => {
      const { __scopeDialog, ...closeProps } = props;
      const context = useDialogContext(CLOSE_NAME, __scopeDialog);
      return /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(Primitive.button, {
        type: "button",
        ...closeProps,
        ref: forwardedRef,
        onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false))
      });
    });
    DialogClose.displayName = CLOSE_NAME;
    TITLE_WARNING_NAME = "DialogTitleWarning";
    [WarningProvider, useWarningContext] = createContext22(TITLE_WARNING_NAME, {
      contentName: CONTENT_NAME,
      titleName: TITLE_NAME,
      docsSlug: "dialog"
    });
    TitleWarning = ({ titleId }) => {
      const titleWarningContext = useWarningContext(TITLE_WARNING_NAME);
      const MESSAGE = `\`${titleWarningContext.contentName}\` requires a \`${titleWarningContext.titleName}\` for the component to be accessible for screen reader users.

If you want to hide the \`${titleWarningContext.titleName}\`, you can wrap it with our VisuallyHidden component.

For more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`;
      React39.useEffect(() => {
        if (titleId) {
          const hasTitle = document.getElementById(titleId);
          if (!hasTitle)
            console.error(MESSAGE);
        }
      }, [MESSAGE, titleId]);
      return null;
    };
    DESCRIPTION_WARNING_NAME = "DialogDescriptionWarning";
    DescriptionWarning = ({ contentRef, descriptionId }) => {
      const descriptionWarningContext = useWarningContext(DESCRIPTION_WARNING_NAME);
      const MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${descriptionWarningContext.contentName}}.`;
      React39.useEffect(() => {
        const describedById = contentRef.current?.getAttribute("aria-describedby");
        if (descriptionId && describedById) {
          const hasDescription = document.getElementById(descriptionId);
          if (!hasDescription)
            console.warn(MESSAGE);
        }
      }, [MESSAGE, contentRef, descriptionId]);
      return null;
    };
    Root2 = Dialog;
    Portal2 = DialogPortal;
    Overlay = DialogOverlay;
    Content = DialogContent;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/events.mjs
function UiEventsProvider({ onEvent, children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime73.jsx)(EventsContext.Provider, { value: onEvent ?? defaultEventHandler, children });
}
function useUiEvents() {
  const eventHandler2 = React40.useContext(EventsContext);
  return eventHandler2 ?? defaultEventHandler;
}
var import_jsx_runtime73, React40, defaultEventHandler, EventsContext;
var init_events = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/events.mjs"() {
    import_jsx_runtime73 = __toESM(require_jsx_runtime(), 1);
    React40 = __toESM(require_react(), 1);
    defaultEventHandler = () => void 0;
    EventsContext = React40.createContext(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/dialogs.mjs
function DialogsProvider({ children }) {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const [dialogs, setDialogs] = (0, import_react65.useState)([]);
  const addDialog = (0, import_react65.useCallback)((dialog) => {
    const id = dialog.id ?? uniqueId();
    setDialogs((d2) => {
      return [...d2.filter((m2) => m2.id !== dialog.id), { ...dialog, id }];
    });
    trackEvent("open-menu", { source: "dialog", id });
    editor.addOpenMenu(id);
    return id;
  }, [editor, trackEvent]);
  const updateDialog = (0, import_react65.useCallback)((id, newDialogData) => {
    setDialogs((d2) => d2.map((m2) => {
      if (m2.id === id) {
        return {
          ...m2,
          ...newDialogData
        };
      }
      return m2;
    }));
    trackEvent("open-menu", { source: "dialog", id });
    editor.addOpenMenu(id);
    return id;
  }, [editor, trackEvent]);
  const removeDialog = (0, import_react65.useCallback)((id) => {
    setDialogs((d2) => d2.filter((m2) => {
      if (m2.id === id) {
        m2.onClose?.();
        return false;
      }
      return true;
    }));
    trackEvent("close-menu", { source: "dialog", id });
    editor.deleteOpenMenu(id);
    return id;
  }, [editor, trackEvent]);
  const clearDialogs = (0, import_react65.useCallback)(() => {
    setDialogs((d2) => {
      d2.forEach((m2) => {
        m2.onClose?.();
        trackEvent("close-menu", { source: "dialog", id: m2.id });
        editor.deleteOpenMenu(m2.id);
      });
      return [];
    });
  }, [editor, trackEvent]);
  return /* @__PURE__ */ (0, import_jsx_runtime74.jsx)(DialogsContext.Provider, {
    value: { dialogs, addDialog, removeDialog, clearDialogs, updateDialog },
    children
  });
}
function useDialogs() {
  const ctx = (0, import_react65.useContext)(DialogsContext);
  if (!ctx) {
    throw new Error("useDialogs must be used within a DialogsProvider");
  }
  return ctx;
}
var import_jsx_runtime74, import_react65, DialogsContext;
var init_dialogs = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/dialogs.mjs"() {
    import_jsx_runtime74 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react65 = __toESM(require_react(), 1);
    init_events();
    DialogsContext = (0, import_react65.createContext)(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Dialogs.mjs
function _Dialogs() {
  const { dialogs } = useDialogs();
  return dialogs.map((dialog) => /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(Dialog2, { ...dialog }, dialog.id));
}
var import_jsx_runtime75, import_react66, Dialog2, Dialogs;
var init_Dialogs = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Dialogs.mjs"() {
    import_jsx_runtime75 = __toESM(require_jsx_runtime(), 1);
    init_dist16();
    init_dist_esm10();
    import_react66 = __toESM(require_react(), 1);
    init_dialogs();
    Dialog2 = ({ id, component: ModalContent, onClose }) => {
      const { removeDialog } = useDialogs();
      const container = useContainer();
      const handleOpenChange = (0, import_react66.useCallback)((isOpen) => {
        if (!isOpen) {
          if (onClose) {
            try {
              onClose();
            } catch (err) {
              console.warn(err);
            }
          }
          removeDialog(id);
        }
      }, [id, onClose, removeDialog]);
      return /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(Root2, { onOpenChange: handleOpenChange, defaultOpen: true, children: /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(Portal2, { container, children: /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(Overlay, {
        dir: "ltr",
        className: "tlui-dialog__overlay",
        onClick: (e2) => {
          if (e2.target === e2.currentTarget)
            handleOpenChange(false);
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(Content, { dir: "ltr", className: "tlui-dialog__content", children: /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(ModalContent, { onClose: () => handleOpenChange(false) }) })
      }) }) });
    };
    Dialogs = import_react66.default.memo(_Dialogs);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/FollowingIndicator.mjs
function FollowingIndicator() {
  const editor = useEditor();
  const followingUserId = useValue("follow", () => editor.getInstanceState().followingUserId, [
    editor
  ]);
  if (!followingUserId)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime76.jsx)(FollowingIndicatorInner, { userId: followingUserId });
}
function FollowingIndicatorInner({ userId }) {
  const presence = usePresence(userId);
  if (!presence)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime76.jsx)("div", { className: "tlui-following-indicator", style: { borderColor: presence.color } });
}
var import_jsx_runtime76;
var init_FollowingIndicator = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/FollowingIndicator.mjs"() {
    import_jsx_runtime76 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
  }
});

// node_modules/@radix-ui/react-collection/dist/index.mjs
function createCollection(name) {
  const PROVIDER_NAME2 = name + "CollectionProvider";
  const [createCollectionContext, createCollectionScope5] = createContextScope(PROVIDER_NAME2);
  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME2, { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() });
  const CollectionProvider = (props) => {
    const { scope, children } = props;
    const ref = import_react67.default.useRef(null);
    const itemMap = import_react67.default.useRef(/* @__PURE__ */ new Map()).current;
    return /* @__PURE__ */ (0, import_jsx_runtime77.jsx)(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
  };
  CollectionProvider.displayName = PROVIDER_NAME2;
  const COLLECTION_SLOT_NAME = name + "CollectionSlot";
  const CollectionSlot = import_react67.default.forwardRef((props, forwardedRef) => {
    const { scope, children } = props;
    const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
    const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
    return /* @__PURE__ */ (0, import_jsx_runtime77.jsx)(Slot, { ref: composedRefs, children });
  });
  CollectionSlot.displayName = COLLECTION_SLOT_NAME;
  const ITEM_SLOT_NAME = name + "CollectionItemSlot";
  const ITEM_DATA_ATTR = "data-radix-collection-item";
  const CollectionItemSlot = import_react67.default.forwardRef((props, forwardedRef) => {
    const { scope, children, ...itemData } = props;
    const ref = import_react67.default.useRef(null);
    const composedRefs = useComposedRefs(forwardedRef, ref);
    const context = useCollectionContext(ITEM_SLOT_NAME, scope);
    import_react67.default.useEffect(() => {
      context.itemMap.set(ref, { ref, ...itemData });
      return () => void context.itemMap.delete(ref);
    });
    return /* @__PURE__ */ (0, import_jsx_runtime77.jsx)(Slot, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
  });
  CollectionItemSlot.displayName = ITEM_SLOT_NAME;
  function useCollection5(scope) {
    const context = useCollectionContext(name + "CollectionConsumer", scope);
    const getItems = import_react67.default.useCallback(() => {
      const collectionNode = context.collectionRef.current;
      if (!collectionNode)
        return [];
      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
      const items = Array.from(context.itemMap.values());
      const orderedItems = items.sort((a2, b2) => orderedNodes.indexOf(a2.ref.current) - orderedNodes.indexOf(b2.ref.current));
      return orderedItems;
    }, [context.collectionRef, context.itemMap]);
    return getItems;
  }
  return [
    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
    useCollection5,
    createCollectionScope5
  ];
}
var import_react67, import_jsx_runtime77;
var init_dist17 = __esm({
  "node_modules/@radix-ui/react-collection/dist/index.mjs"() {
    import_react67 = __toESM(require_react(), 1);
    init_dist3();
    init_dist2();
    init_dist8();
    import_jsx_runtime77 = __toESM(require_jsx_runtime(), 1);
    "use client";
  }
});

// node_modules/@radix-ui/react-toast/node_modules/@radix-ui/react-visually-hidden/dist/index.mjs
var React43, import_jsx_runtime78, NAME, VisuallyHidden;
var init_dist18 = __esm({
  "node_modules/@radix-ui/react-toast/node_modules/@radix-ui/react-visually-hidden/dist/index.mjs"() {
    React43 = __toESM(require_react(), 1);
    init_dist9();
    import_jsx_runtime78 = __toESM(require_jsx_runtime(), 1);
    NAME = "VisuallyHidden";
    VisuallyHidden = React43.forwardRef((props, forwardedRef) => {
      return /* @__PURE__ */ (0, import_jsx_runtime78.jsx)(Primitive.span, {
        ...props,
        ref: forwardedRef,
        style: {
          position: "absolute",
          border: 0,
          width: 1,
          height: 1,
          padding: 0,
          margin: -1,
          overflow: "hidden",
          clip: "rect(0, 0, 0, 0)",
          whiteSpace: "nowrap",
          wordWrap: "normal",
          ...props.style
        }
      });
    });
    VisuallyHidden.displayName = NAME;
  }
});

// node_modules/@radix-ui/react-toast/dist/index.mjs
function getAnnounceTextContent(container) {
  const textContent = [];
  const childNodes = Array.from(container.childNodes);
  childNodes.forEach((node) => {
    if (node.nodeType === node.TEXT_NODE && node.textContent)
      textContent.push(node.textContent);
    if (isHTMLElement(node)) {
      const isHidden2 = node.ariaHidden || node.hidden || node.style.display === "none";
      const isExcluded = node.dataset.radixToastAnnounceExclude === "";
      if (!isHidden2) {
        if (isExcluded) {
          const altText = node.dataset.radixToastAnnounceAlt;
          if (altText)
            textContent.push(altText);
        } else {
          textContent.push(...getAnnounceTextContent(node));
        }
      }
    }
  });
  return textContent;
}
function handleAndDispatchCustomEvent2(name, handler, detail, { discrete }) {
  const currentTarget = detail.originalEvent.currentTarget;
  const event = new CustomEvent(name, { bubbles: true, cancelable: true, detail });
  if (handler)
    currentTarget.addEventListener(name, handler, { once: true });
  if (discrete) {
    dispatchDiscreteCustomEvent(currentTarget, event);
  } else {
    currentTarget.dispatchEvent(event);
  }
}
function useNextFrame(callback = () => {
}) {
  const fn3 = useCallbackRef(callback);
  useLayoutEffect22(() => {
    let raf1 = 0;
    let raf2 = 0;
    raf1 = window.requestAnimationFrame(() => raf2 = window.requestAnimationFrame(fn3));
    return () => {
      window.cancelAnimationFrame(raf1);
      window.cancelAnimationFrame(raf2);
    };
  }, [fn3]);
}
function isHTMLElement(node) {
  return node.nodeType === node.ELEMENT_NODE;
}
function getTabbableCandidates2(container) {
  const nodes = [];
  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
    acceptNode: (node) => {
      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
      if (node.disabled || node.hidden || isHiddenInput)
        return NodeFilter.FILTER_SKIP;
      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
    }
  });
  while (walker.nextNode())
    nodes.push(walker.currentNode);
  return nodes;
}
function focusFirst2(candidates) {
  const previouslyFocusedElement = document.activeElement;
  return candidates.some((candidate) => {
    if (candidate === previouslyFocusedElement)
      return true;
    candidate.focus();
    return document.activeElement !== previouslyFocusedElement;
  });
}
var React44, ReactDOM3, import_jsx_runtime79, PROVIDER_NAME, Collection, useCollection, createCollectionScope, createToastContext, createToastScope, ToastProviderProvider, useToastProviderContext, ToastProvider, VIEWPORT_NAME, VIEWPORT_DEFAULT_HOTKEY, VIEWPORT_PAUSE, VIEWPORT_RESUME, ToastViewport, FOCUS_PROXY_NAME, FocusProxy, TOAST_NAME, TOAST_SWIPE_START, TOAST_SWIPE_MOVE, TOAST_SWIPE_CANCEL, TOAST_SWIPE_END, Toast, ToastInteractiveProvider, useToastInteractiveContext, ToastImpl, ToastAnnounce, TITLE_NAME2, ToastTitle, DESCRIPTION_NAME2, ToastDescription, ACTION_NAME, ToastAction, CLOSE_NAME2, ToastClose, ToastAnnounceExclude, isDeltaInDirection, Root22, Title, Description, Action, Close;
var init_dist19 = __esm({
  "node_modules/@radix-ui/react-toast/dist/index.mjs"() {
    React44 = __toESM(require_react(), 1);
    ReactDOM3 = __toESM(require_react_dom(), 1);
    init_dist();
    init_dist2();
    init_dist17();
    init_dist3();
    init_dist11();
    init_dist13();
    init_dist14();
    init_dist9();
    init_dist6();
    init_dist7();
    init_dist4();
    init_dist18();
    import_jsx_runtime79 = __toESM(require_jsx_runtime(), 1);
    "use client";
    PROVIDER_NAME = "ToastProvider";
    [Collection, useCollection, createCollectionScope] = createCollection("Toast");
    [createToastContext, createToastScope] = createContextScope("Toast", [createCollectionScope]);
    [ToastProviderProvider, useToastProviderContext] = createToastContext(PROVIDER_NAME);
    ToastProvider = (props) => {
      const {
        __scopeToast,
        label = "Notification",
        duration = 5e3,
        swipeDirection = "right",
        swipeThreshold = 50,
        children
      } = props;
      const [viewport2, setViewport] = React44.useState(null);
      const [toastCount, setToastCount] = React44.useState(0);
      const isFocusedToastEscapeKeyDownRef = React44.useRef(false);
      const isClosePausedRef = React44.useRef(false);
      if (!label.trim()) {
        console.error(`Invalid prop \`label\` supplied to \`${PROVIDER_NAME}\`. Expected non-empty \`string\`.`);
      }
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Collection.Provider, { scope: __scopeToast, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastProviderProvider, {
        scope: __scopeToast,
        label,
        duration,
        swipeDirection,
        swipeThreshold,
        toastCount,
        viewport: viewport2,
        onViewportChange: setViewport,
        onToastAdd: React44.useCallback(() => setToastCount((prevCount) => prevCount + 1), []),
        onToastRemove: React44.useCallback(() => setToastCount((prevCount) => prevCount - 1), []),
        isFocusedToastEscapeKeyDownRef,
        isClosePausedRef,
        children
      }) });
    };
    ToastProvider.displayName = PROVIDER_NAME;
    VIEWPORT_NAME = "ToastViewport";
    VIEWPORT_DEFAULT_HOTKEY = ["F8"];
    VIEWPORT_PAUSE = "toast.viewportPause";
    VIEWPORT_RESUME = "toast.viewportResume";
    ToastViewport = React44.forwardRef((props, forwardedRef) => {
      const {
        __scopeToast,
        hotkey = VIEWPORT_DEFAULT_HOTKEY,
        label = "Notifications ({hotkey})",
        ...viewportProps
      } = props;
      const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
      const getItems = useCollection(__scopeToast);
      const wrapperRef = React44.useRef(null);
      const headFocusProxyRef = React44.useRef(null);
      const tailFocusProxyRef = React44.useRef(null);
      const ref = React44.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
      const hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
      const hasToasts = context.toastCount > 0;
      React44.useEffect(() => {
        const handleKeyDown = (event) => {
          const isHotkeyPressed = hotkey.length !== 0 && hotkey.every((key) => event[key] || event.code === key);
          if (isHotkeyPressed)
            ref.current?.focus();
        };
        document.addEventListener("keydown", handleKeyDown);
        return () => document.removeEventListener("keydown", handleKeyDown);
      }, [hotkey]);
      React44.useEffect(() => {
        const wrapper = wrapperRef.current;
        const viewport2 = ref.current;
        if (hasToasts && wrapper && viewport2) {
          const handlePause = () => {
            if (!context.isClosePausedRef.current) {
              const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
              viewport2.dispatchEvent(pauseEvent);
              context.isClosePausedRef.current = true;
            }
          };
          const handleResume = () => {
            if (context.isClosePausedRef.current) {
              const resumeEvent = new CustomEvent(VIEWPORT_RESUME);
              viewport2.dispatchEvent(resumeEvent);
              context.isClosePausedRef.current = false;
            }
          };
          const handleFocusOutResume = (event) => {
            const isFocusMovingOutside = !wrapper.contains(event.relatedTarget);
            if (isFocusMovingOutside)
              handleResume();
          };
          const handlePointerLeaveResume = () => {
            const isFocusInside = wrapper.contains(document.activeElement);
            if (!isFocusInside)
              handleResume();
          };
          wrapper.addEventListener("focusin", handlePause);
          wrapper.addEventListener("focusout", handleFocusOutResume);
          wrapper.addEventListener("pointermove", handlePause);
          wrapper.addEventListener("pointerleave", handlePointerLeaveResume);
          window.addEventListener("blur", handlePause);
          window.addEventListener("focus", handleResume);
          return () => {
            wrapper.removeEventListener("focusin", handlePause);
            wrapper.removeEventListener("focusout", handleFocusOutResume);
            wrapper.removeEventListener("pointermove", handlePause);
            wrapper.removeEventListener("pointerleave", handlePointerLeaveResume);
            window.removeEventListener("blur", handlePause);
            window.removeEventListener("focus", handleResume);
          };
        }
      }, [hasToasts, context.isClosePausedRef]);
      const getSortedTabbableCandidates = React44.useCallback(({ tabbingDirection }) => {
        const toastItems = getItems();
        const tabbableCandidates = toastItems.map((toastItem) => {
          const toastNode = toastItem.ref.current;
          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates2(toastNode)];
          return tabbingDirection === "forwards" ? toastTabbableCandidates : toastTabbableCandidates.reverse();
        });
        return (tabbingDirection === "forwards" ? tabbableCandidates.reverse() : tabbableCandidates).flat();
      }, [getItems]);
      React44.useEffect(() => {
        const viewport2 = ref.current;
        if (viewport2) {
          const handleKeyDown = (event) => {
            const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
            const isTabKey = event.key === "Tab" && !isMetaKey;
            if (isTabKey) {
              const focusedElement = document.activeElement;
              const isTabbingBackwards = event.shiftKey;
              const targetIsViewport = event.target === viewport2;
              if (targetIsViewport && isTabbingBackwards) {
                headFocusProxyRef.current?.focus();
                return;
              }
              const tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
              const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });
              const index3 = sortedCandidates.findIndex((candidate) => candidate === focusedElement);
              if (focusFirst2(sortedCandidates.slice(index3 + 1))) {
                event.preventDefault();
              } else {
                isTabbingBackwards ? headFocusProxyRef.current?.focus() : tailFocusProxyRef.current?.focus();
              }
            }
          };
          viewport2.addEventListener("keydown", handleKeyDown);
          return () => viewport2.removeEventListener("keydown", handleKeyDown);
        }
      }, [getItems, getSortedTabbableCandidates]);
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsxs)(Branch, {
        ref: wrapperRef,
        role: "region",
        "aria-label": label.replace("{hotkey}", hotkeyLabel),
        tabIndex: -1,
        style: { pointerEvents: hasToasts ? void 0 : "none" },
        children: [
          hasToasts && /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(FocusProxy, {
            ref: headFocusProxyRef,
            onFocusFromOutsideViewport: () => {
              const tabbableCandidates = getSortedTabbableCandidates({
                tabbingDirection: "forwards"
              });
              focusFirst2(tabbableCandidates);
            }
          }),
          /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Collection.Slot, { scope: __scopeToast, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.ol, { tabIndex: -1, ...viewportProps, ref: composedRefs }) }),
          hasToasts && /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(FocusProxy, {
            ref: tailFocusProxyRef,
            onFocusFromOutsideViewport: () => {
              const tabbableCandidates = getSortedTabbableCandidates({
                tabbingDirection: "backwards"
              });
              focusFirst2(tabbableCandidates);
            }
          })
        ]
      });
    });
    ToastViewport.displayName = VIEWPORT_NAME;
    FOCUS_PROXY_NAME = "ToastFocusProxy";
    FocusProxy = React44.forwardRef((props, forwardedRef) => {
      const { __scopeToast, onFocusFromOutsideViewport, ...proxyProps } = props;
      const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(VisuallyHidden, {
        "aria-hidden": true,
        tabIndex: 0,
        ...proxyProps,
        ref: forwardedRef,
        style: { position: "fixed" },
        onFocus: (event) => {
          const prevFocusedElement = event.relatedTarget;
          const isFocusFromOutsideViewport = !context.viewport?.contains(prevFocusedElement);
          if (isFocusFromOutsideViewport)
            onFocusFromOutsideViewport();
        }
      });
    });
    FocusProxy.displayName = FOCUS_PROXY_NAME;
    TOAST_NAME = "Toast";
    TOAST_SWIPE_START = "toast.swipeStart";
    TOAST_SWIPE_MOVE = "toast.swipeMove";
    TOAST_SWIPE_CANCEL = "toast.swipeCancel";
    TOAST_SWIPE_END = "toast.swipeEnd";
    Toast = React44.forwardRef((props, forwardedRef) => {
      const { forceMount, open: openProp, defaultOpen, onOpenChange, ...toastProps } = props;
      const [open = true, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Presence, { present: forceMount || open, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastImpl, {
        open,
        ...toastProps,
        ref: forwardedRef,
        onClose: () => setOpen(false),
        onPause: useCallbackRef(props.onPause),
        onResume: useCallbackRef(props.onResume),
        onSwipeStart: composeEventHandlers(props.onSwipeStart, (event) => {
          event.currentTarget.setAttribute("data-swipe", "start");
        }),
        onSwipeMove: composeEventHandlers(props.onSwipeMove, (event) => {
          const { x: x2, y: y2 } = event.detail.delta;
          event.currentTarget.setAttribute("data-swipe", "move");
          event.currentTarget.style.setProperty("--radix-toast-swipe-move-x", `${x2}px`);
          event.currentTarget.style.setProperty("--radix-toast-swipe-move-y", `${y2}px`);
        }),
        onSwipeCancel: composeEventHandlers(props.onSwipeCancel, (event) => {
          event.currentTarget.setAttribute("data-swipe", "cancel");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-x");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-y");
        }),
        onSwipeEnd: composeEventHandlers(props.onSwipeEnd, (event) => {
          const { x: x2, y: y2 } = event.detail.delta;
          event.currentTarget.setAttribute("data-swipe", "end");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
          event.currentTarget.style.setProperty("--radix-toast-swipe-end-x", `${x2}px`);
          event.currentTarget.style.setProperty("--radix-toast-swipe-end-y", `${y2}px`);
          setOpen(false);
        })
      }) });
    });
    Toast.displayName = TOAST_NAME;
    [ToastInteractiveProvider, useToastInteractiveContext] = createToastContext(TOAST_NAME, {
      onClose() {
      }
    });
    ToastImpl = React44.forwardRef((props, forwardedRef) => {
      const {
        __scopeToast,
        type = "foreground",
        duration: durationProp,
        open,
        onClose,
        onEscapeKeyDown,
        onPause,
        onResume,
        onSwipeStart,
        onSwipeMove,
        onSwipeCancel,
        onSwipeEnd,
        ...toastProps
      } = props;
      const context = useToastProviderContext(TOAST_NAME, __scopeToast);
      const [node, setNode] = React44.useState(null);
      const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
      const pointerStartRef = React44.useRef(null);
      const swipeDeltaRef = React44.useRef(null);
      const duration = durationProp || context.duration;
      const closeTimerStartTimeRef = React44.useRef(0);
      const closeTimerRemainingTimeRef = React44.useRef(duration);
      const closeTimerRef = React44.useRef(0);
      const { onToastAdd, onToastRemove } = context;
      const handleClose = useCallbackRef(() => {
        const isFocusInToast = node?.contains(document.activeElement);
        if (isFocusInToast)
          context.viewport?.focus();
        onClose();
      });
      const startTimer = React44.useCallback((duration2) => {
        if (!duration2 || duration2 === Infinity)
          return;
        window.clearTimeout(closeTimerRef.current);
        closeTimerStartTimeRef.current = (/* @__PURE__ */ new Date()).getTime();
        closeTimerRef.current = window.setTimeout(handleClose, duration2);
      }, [handleClose]);
      React44.useEffect(() => {
        const viewport2 = context.viewport;
        if (viewport2) {
          const handleResume = () => {
            startTimer(closeTimerRemainingTimeRef.current);
            onResume?.();
          };
          const handlePause = () => {
            const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTimeRef.current;
            closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
            window.clearTimeout(closeTimerRef.current);
            onPause?.();
          };
          viewport2.addEventListener(VIEWPORT_PAUSE, handlePause);
          viewport2.addEventListener(VIEWPORT_RESUME, handleResume);
          return () => {
            viewport2.removeEventListener(VIEWPORT_PAUSE, handlePause);
            viewport2.removeEventListener(VIEWPORT_RESUME, handleResume);
          };
        }
      }, [context.viewport, duration, onPause, onResume, startTimer]);
      React44.useEffect(() => {
        if (open && !context.isClosePausedRef.current)
          startTimer(duration);
      }, [open, duration, context.isClosePausedRef, startTimer]);
      React44.useEffect(() => {
        onToastAdd();
        return () => onToastRemove();
      }, [onToastAdd, onToastRemove]);
      const announceTextContent = React44.useMemo(() => {
        return node ? getAnnounceTextContent(node) : null;
      }, [node]);
      if (!context.viewport)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsxs)(import_jsx_runtime79.Fragment, { children: [
        announceTextContent && /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastAnnounce, {
          __scopeToast,
          role: "status",
          "aria-live": type === "foreground" ? "assertive" : "polite",
          "aria-atomic": true,
          children: announceTextContent
        }),
        /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastInteractiveProvider, { scope: __scopeToast, onClose: handleClose, children: ReactDOM3.createPortal(/* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Collection.ItemSlot, { scope: __scopeToast, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Root, {
          asChild: true,
          onEscapeKeyDown: composeEventHandlers(onEscapeKeyDown, () => {
            if (!context.isFocusedToastEscapeKeyDownRef.current)
              handleClose();
            context.isFocusedToastEscapeKeyDownRef.current = false;
          }),
          children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.li, {
            role: "status",
            "aria-live": "off",
            "aria-atomic": true,
            tabIndex: 0,
            "data-state": open ? "open" : "closed",
            "data-swipe-direction": context.swipeDirection,
            ...toastProps,
            ref: composedRefs,
            style: { userSelect: "none", touchAction: "none", ...props.style },
            onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
              if (event.key !== "Escape")
                return;
              onEscapeKeyDown?.(event.nativeEvent);
              if (!event.nativeEvent.defaultPrevented) {
                context.isFocusedToastEscapeKeyDownRef.current = true;
                handleClose();
              }
            }),
            onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
              if (event.button !== 0)
                return;
              pointerStartRef.current = { x: event.clientX, y: event.clientY };
            }),
            onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
              if (!pointerStartRef.current)
                return;
              const x2 = event.clientX - pointerStartRef.current.x;
              const y2 = event.clientY - pointerStartRef.current.y;
              const hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);
              const isHorizontalSwipe = ["left", "right"].includes(context.swipeDirection);
              const clamp4 = ["left", "up"].includes(context.swipeDirection) ? Math.min : Math.max;
              const clampedX = isHorizontalSwipe ? clamp4(0, x2) : 0;
              const clampedY = !isHorizontalSwipe ? clamp4(0, y2) : 0;
              const moveStartBuffer = event.pointerType === "touch" ? 10 : 2;
              const delta = { x: clampedX, y: clampedY };
              const eventDetail = { originalEvent: event, delta };
              if (hasSwipeMoveStarted) {
                swipeDeltaRef.current = delta;
                handleAndDispatchCustomEvent2(TOAST_SWIPE_MOVE, onSwipeMove, eventDetail, {
                  discrete: false
                });
              } else if (isDeltaInDirection(delta, context.swipeDirection, moveStartBuffer)) {
                swipeDeltaRef.current = delta;
                handleAndDispatchCustomEvent2(TOAST_SWIPE_START, onSwipeStart, eventDetail, {
                  discrete: false
                });
                event.target.setPointerCapture(event.pointerId);
              } else if (Math.abs(x2) > moveStartBuffer || Math.abs(y2) > moveStartBuffer) {
                pointerStartRef.current = null;
              }
            }),
            onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {
              const delta = swipeDeltaRef.current;
              const target = event.target;
              if (target.hasPointerCapture(event.pointerId)) {
                target.releasePointerCapture(event.pointerId);
              }
              swipeDeltaRef.current = null;
              pointerStartRef.current = null;
              if (delta) {
                const toast = event.currentTarget;
                const eventDetail = { originalEvent: event, delta };
                if (isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold)) {
                  handleAndDispatchCustomEvent2(TOAST_SWIPE_END, onSwipeEnd, eventDetail, {
                    discrete: true
                  });
                } else {
                  handleAndDispatchCustomEvent2(TOAST_SWIPE_CANCEL, onSwipeCancel, eventDetail, {
                    discrete: true
                  });
                }
                toast.addEventListener("click", (event2) => event2.preventDefault(), {
                  once: true
                });
              }
            })
          })
        }) }), context.viewport) })
      ] });
    });
    ToastAnnounce = (props) => {
      const { __scopeToast, children, ...announceProps } = props;
      const context = useToastProviderContext(TOAST_NAME, __scopeToast);
      const [renderAnnounceText, setRenderAnnounceText] = React44.useState(false);
      const [isAnnounced, setIsAnnounced] = React44.useState(false);
      useNextFrame(() => setRenderAnnounceText(true));
      React44.useEffect(() => {
        const timer = window.setTimeout(() => setIsAnnounced(true), 1e3);
        return () => window.clearTimeout(timer);
      }, []);
      return isAnnounced ? null : /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Portal, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(VisuallyHidden, { ...announceProps, children: renderAnnounceText && /* @__PURE__ */ (0, import_jsx_runtime79.jsxs)(import_jsx_runtime79.Fragment, { children: [
        context.label,
        " ",
        children
      ] }) }) });
    };
    TITLE_NAME2 = "ToastTitle";
    ToastTitle = React44.forwardRef((props, forwardedRef) => {
      const { __scopeToast, ...titleProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.div, { ...titleProps, ref: forwardedRef });
    });
    ToastTitle.displayName = TITLE_NAME2;
    DESCRIPTION_NAME2 = "ToastDescription";
    ToastDescription = React44.forwardRef((props, forwardedRef) => {
      const { __scopeToast, ...descriptionProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.div, { ...descriptionProps, ref: forwardedRef });
    });
    ToastDescription.displayName = DESCRIPTION_NAME2;
    ACTION_NAME = "ToastAction";
    ToastAction = React44.forwardRef((props, forwardedRef) => {
      const { altText, ...actionProps } = props;
      if (!altText.trim()) {
        console.error(`Invalid prop \`altText\` supplied to \`${ACTION_NAME}\`. Expected non-empty \`string\`.`);
        return null;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastAnnounceExclude, { altText, asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastClose, { ...actionProps, ref: forwardedRef }) });
    });
    ToastAction.displayName = ACTION_NAME;
    CLOSE_NAME2 = "ToastClose";
    ToastClose = React44.forwardRef((props, forwardedRef) => {
      const { __scopeToast, ...closeProps } = props;
      const interactiveContext = useToastInteractiveContext(CLOSE_NAME2, __scopeToast);
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(ToastAnnounceExclude, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.button, {
        type: "button",
        ...closeProps,
        ref: forwardedRef,
        onClick: composeEventHandlers(props.onClick, interactiveContext.onClose)
      }) });
    });
    ToastClose.displayName = CLOSE_NAME2;
    ToastAnnounceExclude = React44.forwardRef((props, forwardedRef) => {
      const { __scopeToast, altText, ...announceExcludeProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(Primitive.div, {
        "data-radix-toast-announce-exclude": "",
        "data-radix-toast-announce-alt": altText || void 0,
        ...announceExcludeProps,
        ref: forwardedRef
      });
    });
    isDeltaInDirection = (delta, direction, threshold = 0) => {
      const deltaX = Math.abs(delta.x);
      const deltaY = Math.abs(delta.y);
      const isDeltaX = deltaX > deltaY;
      if (direction === "left" || direction === "right") {
        return isDeltaX && deltaX > threshold;
      } else {
        return !isDeltaX && deltaY > threshold;
      }
    };
    Root22 = Toast;
    Title = ToastTitle;
    Description = ToastDescription;
    Action = ToastAction;
    Close = ToastClose;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/toasts.mjs
function ToastsProvider({ children }) {
  const [toasts, setToasts] = (0, import_react68.useState)([]);
  const addToast = (0, import_react68.useCallback)((toast) => {
    const id = toast.id ?? uniqueId();
    setToasts((d2) => [...d2.filter((m2) => m2.id !== toast.id), { ...toast, id }]);
    return id;
  }, []);
  const removeToast = (0, import_react68.useCallback)((id) => {
    setToasts((d2) => d2.filter((m2) => m2.id !== id));
    return id;
  }, []);
  const clearToasts = (0, import_react68.useCallback)(() => {
    setToasts(() => []);
  }, []);
  return /* @__PURE__ */ (0, import_jsx_runtime80.jsx)(ToastProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime80.jsx)(ToastsContext.Provider, { value: { toasts, addToast, removeToast, clearToasts }, children }) });
}
function useToasts() {
  const ctx = (0, import_react68.useContext)(ToastsContext);
  if (!ctx) {
    throw new Error("useToasts must be used within a ToastsProvider");
  }
  return ctx;
}
var import_jsx_runtime80, import_react68, ToastsContext;
var init_toasts = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/toasts.mjs"() {
    import_jsx_runtime80 = __toESM(require_jsx_runtime(), 1);
    init_dist19();
    init_dist_esm10();
    import_react68 = __toESM(require_react(), 1);
    ToastsContext = (0, import_react68.createContext)(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButton.mjs
var import_jsx_runtime81, import_classnames19, React45, TldrawUiButton;
var init_TldrawUiButton = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButton.mjs"() {
    import_jsx_runtime81 = __toESM(require_jsx_runtime(), 1);
    import_classnames19 = __toESM(require_classnames(), 1);
    React45 = __toESM(require_react(), 1);
    TldrawUiButton = React45.forwardRef(function TldrawUiButton2({ children, disabled, type, ...props }, ref) {
      return /* @__PURE__ */ (0, import_jsx_runtime81.jsx)("button", {
        ref,
        type: "button",
        draggable: false,
        disabled,
        ...props,
        className: (0, import_classnames19.default)("tlui-button", `tlui-button__${type}`, props.className),
        children
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonLabel.mjs
function TldrawUiButtonLabel({ children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime82.jsx)("span", { className: "tlui-button__label", children });
}
var import_jsx_runtime82;
var init_TldrawUiButtonLabel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonLabel.mjs"() {
    import_jsx_runtime82 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiIcon.mjs
var import_jsx_runtime83, import_classnames20, import_react69, TldrawUiIcon;
var init_TldrawUiIcon = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiIcon.mjs"() {
    import_jsx_runtime83 = __toESM(require_jsx_runtime(), 1);
    import_classnames20 = __toESM(require_classnames(), 1);
    import_react69 = __toESM(require_react(), 1);
    init_asset_urls();
    TldrawUiIcon = (0, import_react69.memo)(function TldrawUiIcon2({
      small,
      invertIcon,
      icon,
      color,
      className,
      ...props
    }) {
      const assetUrls = useAssetUrls();
      const asset = assetUrls.icons[icon] ?? assetUrls.icons["question-mark-circle"];
      const ref = (0, import_react69.useRef)(null);
      (0, import_react69.useLayoutEffect)(() => {
        if (!asset) {
          console.error(`Icon not found: ${icon}. Add it to the assetUrls.icons object.`);
        }
        if (ref?.current) {
          ref.current.style.webkitMask = `url(${asset}) center 100% / 100% no-repeat`;
        }
      }, [ref, asset, icon]);
      if (icon === "none") {
        return /* @__PURE__ */ (0, import_jsx_runtime83.jsx)("div", {
          className: (0, import_classnames20.default)("tlui-icon tlui-icon__placeholder", { "tlui-icon__small": small }, className)
        });
      }
      return /* @__PURE__ */ (0, import_jsx_runtime83.jsx)("div", {
        ...props,
        ref,
        className: (0, import_classnames20.default)("tlui-icon", { "tlui-icon__small": small }, className),
        style: {
          color,
          mask: `url(${asset}) center 100% / 100% no-repeat`,
          transform: invertIcon ? "scale(-1, 1)" : void 0
        }
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Toasts.mjs
function Toast2({ toast }) {
  const { removeToast } = useToasts();
  const msg2 = useTranslation();
  const onOpenChange = (isOpen) => {
    if (!isOpen) {
      removeToast(toast.id);
    }
  };
  const hasActions = toast.actions && toast.actions.length > 0;
  const icon = toast.icon || toast.severity && SEVERITY_TO_ICON[toast.severity];
  return /* @__PURE__ */ (0, import_jsx_runtime84.jsxs)(Root22, {
    onOpenChange,
    className: "tlui-toast__container",
    duration: toast.keepOpen ? Infinity : 5e3,
    "data-severity": toast.severity,
    children: [
      icon && /* @__PURE__ */ (0, import_jsx_runtime84.jsx)("div", { className: "tlui-toast__icon", children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiIcon, { icon }) }),
      /* @__PURE__ */ (0, import_jsx_runtime84.jsxs)("div", { className: "tlui-toast__main", children: [
        /* @__PURE__ */ (0, import_jsx_runtime84.jsxs)("div", { className: "tlui-toast__content", children: [
          toast.title && /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Title, { className: "tlui-toast__title", children: toast.title }),
          toast.description && /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Description, { className: "tlui-toast__description", children: toast.description })
        ] }),
        toast.actions && /* @__PURE__ */ (0, import_jsx_runtime84.jsxs)("div", { className: "tlui-toast__actions", children: [
          toast.actions.map((action, i2) => /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Action, { altText: action.label, asChild: true, onClick: action.onClick, children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButton, { type: action.type, children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButtonLabel, { children: action.label }) }) }, i2)),
          /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Close, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButton, {
            type: "normal",
            className: "tlui-toast__close",
            style: { marginLeft: "auto" },
            children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButtonLabel, { children: toast.closeLabel ?? msg2("toast.close") })
          }) })
        ] })
      ] }),
      !hasActions && /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Close, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButton, { type: "normal", className: "tlui-toast__close", children: /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(TldrawUiButtonLabel, { children: toast.closeLabel ?? msg2("toast.close") }) }) })
    ]
  });
}
function _Toasts() {
  const { toasts } = useToasts();
  return toasts.map((toast) => /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Toast2, { toast }, toast.id));
}
function ToastViewport2() {
  const editor = useEditor();
  const { toasts } = useToasts();
  const [hasToasts, setHasToasts] = React46.useState(false);
  React46.useEffect(() => {
    let timeoutId = -1;
    if (toasts.length) {
      setHasToasts(true);
    } else {
      timeoutId = editor.timers.setTimeout(() => {
        setHasToasts(false);
      }, 1e3);
    }
    return () => {
      clearTimeout(timeoutId);
    };
  }, [toasts.length, setHasToasts, editor]);
  if (!hasToasts)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(ToastViewport, { className: "tlui-toast__viewport" });
}
var import_jsx_runtime84, React46, SEVERITY_TO_ICON, Toasts;
var init_Toasts = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Toasts.mjs"() {
    import_jsx_runtime84 = __toESM(require_jsx_runtime(), 1);
    init_dist19();
    init_dist_esm10();
    React46 = __toESM(require_react(), 1);
    init_toasts();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonLabel();
    init_TldrawUiIcon();
    SEVERITY_TO_ICON = {
      success: "check-circle",
      warning: "warning-triangle",
      error: "cross-circle",
      info: "info-circle"
    };
    Toasts = React46.memo(_Toasts);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonIcon.mjs
function TldrawUiButtonIcon({ icon, small, invertIcon }) {
  return /* @__PURE__ */ (0, import_jsx_runtime85.jsx)(TldrawUiIcon, { className: "tlui-button__icon", icon, small, invertIcon });
}
var import_jsx_runtime85;
var init_TldrawUiButtonIcon = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonIcon.mjs"() {
    import_jsx_runtime85 = __toESM(require_jsx_runtime(), 1);
    init_TldrawUiIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/constants.mjs
var PORTRAIT_BREAKPOINTS, PORTRAIT_BREAKPOINT;
var init_constants5 = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/constants.mjs"() {
    PORTRAIT_BREAKPOINTS = [0, 390, 428, 468, 580, 640, 840, 1023];
    PORTRAIT_BREAKPOINT = /* @__PURE__ */ ((PORTRAIT_BREAKPOINT2) => {
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["ZERO"] = 0] = "ZERO";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["MOBILE_XXS"] = 1] = "MOBILE_XXS";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["MOBILE_XS"] = 2] = "MOBILE_XS";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["MOBILE_SM"] = 3] = "MOBILE_SM";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["MOBILE"] = 4] = "MOBILE";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["TABLET_SM"] = 5] = "TABLET_SM";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["TABLET"] = 6] = "TABLET";
      PORTRAIT_BREAKPOINT2[PORTRAIT_BREAKPOINT2["DESKTOP"] = 7] = "DESKTOP";
      return PORTRAIT_BREAKPOINT2;
    })(PORTRAIT_BREAKPOINT || {});
  }
});

// node_modules/tldraw/dist-esm/lib/utils/static-assets/assetUrls.mjs
function useDefaultEditorAssetsWithOverrides(overrides) {
  return (0, import_react70.useMemo)(() => {
    if (!overrides)
      return defaultEditorAssetUrls;
    return {
      fonts: { ...defaultEditorAssetUrls.fonts, ...overrides?.fonts }
    };
  }, [overrides]);
}
var import_react70, defaultEditorAssetUrls;
var init_assetUrls = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/static-assets/assetUrls.mjs"() {
    init_dist_esm10();
    import_react70 = __toESM(require_react(), 1);
    defaultEditorAssetUrls = {
      fonts: {
        draw: `${getDefaultCdnBaseUrl()}/fonts/Shantell_Sans-Tldrawish.woff2`,
        serif: `${getDefaultCdnBaseUrl()}/fonts/IBMPlexSerif-Medium.woff2`,
        sansSerif: `${getDefaultCdnBaseUrl()}/fonts/IBMPlexSans-Medium.woff2`,
        monospace: `${getDefaultCdnBaseUrl()}/fonts/IBMPlexMono-Medium.woff2`
      }
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/icon-types.mjs
var iconTypes;
var init_icon_types = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/icon-types.mjs"() {
    iconTypes = [
      "align-bottom",
      "align-center-horizontal",
      "align-center-vertical",
      "align-left",
      "align-right",
      "align-top",
      "arrow-left",
      "arrowhead-arrow",
      "arrowhead-bar",
      "arrowhead-diamond",
      "arrowhead-dot",
      "arrowhead-none",
      "arrowhead-square",
      "arrowhead-triangle-inverted",
      "arrowhead-triangle",
      "blob",
      "bring-forward",
      "bring-to-front",
      "broken",
      "check-circle",
      "check",
      "chevron-down",
      "chevron-left",
      "chevron-right",
      "chevron-up",
      "chevrons-ne",
      "chevrons-sw",
      "clipboard-copied",
      "clipboard-copy",
      "color",
      "cross-2",
      "cross-circle",
      "dash-dashed",
      "dash-dotted",
      "dash-draw",
      "dash-solid",
      "disconnected",
      "discord",
      "distribute-horizontal",
      "distribute-vertical",
      "dot",
      "dots-horizontal",
      "dots-vertical",
      "drag-handle-dots",
      "duplicate",
      "edit",
      "external-link",
      "fill-fill",
      "fill-none",
      "fill-pattern",
      "fill-semi",
      "fill-solid",
      "follow",
      "following",
      "font-draw",
      "font-mono",
      "font-sans",
      "font-serif",
      "geo-arrow-down",
      "geo-arrow-left",
      "geo-arrow-right",
      "geo-arrow-up",
      "geo-check-box",
      "geo-cloud",
      "geo-diamond",
      "geo-ellipse",
      "geo-heart",
      "geo-hexagon",
      "geo-octagon",
      "geo-oval",
      "geo-pentagon",
      "geo-rectangle",
      "geo-rhombus-2",
      "geo-rhombus",
      "geo-star",
      "geo-trapezoid",
      "geo-triangle",
      "geo-x-box",
      "github",
      "group",
      "horizontal-align-end",
      "horizontal-align-middle",
      "horizontal-align-start",
      "info-circle",
      "leading",
      "link",
      "lock",
      "menu",
      "minus",
      "mixed",
      "pack",
      "plus",
      "question-mark-circle",
      "question-mark",
      "redo",
      "reset-zoom",
      "rotate-ccw",
      "rotate-cw",
      "send-backward",
      "send-to-back",
      "share-1",
      "size-extra-large",
      "size-large",
      "size-medium",
      "size-small",
      "spline-cubic",
      "spline-line",
      "stack-horizontal",
      "stack-vertical",
      "status-offline",
      "stretch-horizontal",
      "stretch-vertical",
      "text-align-center",
      "text-align-left",
      "text-align-right",
      "toggle-off",
      "toggle-on",
      "tool-arrow",
      "tool-eraser",
      "tool-frame",
      "tool-hand",
      "tool-highlight",
      "tool-laser",
      "tool-line",
      "tool-media",
      "tool-note",
      "tool-pencil",
      "tool-pointer",
      "tool-screenshot",
      "tool-text",
      "trash",
      "twitter",
      "undo",
      "ungroup",
      "unlock",
      "vertical-align-end",
      "vertical-align-middle",
      "vertical-align-start",
      "warning-triangle",
      "zoom-in",
      "zoom-out"
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/ui/assetUrls.mjs
function useDefaultUiAssetUrlsWithOverrides(overrides) {
  if (!overrides)
    return defaultUiAssetUrls;
  return {
    fonts: Object.assign({ ...defaultUiAssetUrls.fonts }, { ...overrides?.fonts }),
    icons: Object.assign({ ...defaultUiAssetUrls.icons }, { ...overrides?.icons }),
    embedIcons: Object.assign({ ...defaultUiAssetUrls.embedIcons }, { ...overrides?.embedIcons }),
    translations: Object.assign({ ...defaultUiAssetUrls.translations }, { ...overrides?.translations })
  };
}
var defaultUiAssetUrls;
var init_assetUrls2 = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/assetUrls.mjs"() {
    init_dist_esm10();
    init_assetUrls();
    init_icon_types();
    defaultUiAssetUrls = {
      ...defaultEditorAssetUrls,
      icons: Object.fromEntries(iconTypes.map((name) => [name, `${getDefaultCdnBaseUrl()}/icons/icon/${name}.svg`])),
      translations: Object.fromEntries(LANGUAGES.map((lang) => [
        lang.locale,
        `${getDefaultCdnBaseUrl()}/translations/${lang.locale}.json`
      ])),
      embedIcons: Object.fromEntries(EMBED_DEFINITIONS.map((def) => [
        def.type,
        `${getDefaultCdnBaseUrl()}/embed-icons/${def.type}.png`
      ]))
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiDialog.mjs
function TldrawUiDialogHeader({ className, children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime86.jsx)("div", { className: (0, import_classnames21.default)("tlui-dialog__header", className), children });
}
function TldrawUiDialogTitle({ className, children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime86.jsx)(DialogTitle, { dir: "ltr", className: (0, import_classnames21.default)("tlui-dialog__header__title", className), children });
}
function TldrawUiDialogCloseButton() {
  return /* @__PURE__ */ (0, import_jsx_runtime86.jsx)("div", { className: "tlui-dialog__header__close", children: /* @__PURE__ */ (0, import_jsx_runtime86.jsx)(DialogClose, { "data-testid": "dialog.close", dir: "ltr", asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime86.jsx)(TldrawUiButton, {
    type: "icon",
    "aria-label": "Close",
    onTouchEnd: (e2) => e2.target.click(),
    children: /* @__PURE__ */ (0, import_jsx_runtime86.jsx)(TldrawUiButtonIcon, { small: true, icon: "cross-2" })
  }) }) });
}
function TldrawUiDialogBody({ className, children, style }) {
  return /* @__PURE__ */ (0, import_jsx_runtime86.jsx)("div", { className: (0, import_classnames21.default)("tlui-dialog__body", className), style, children });
}
function TldrawUiDialogFooter({ className, children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime86.jsx)("div", { className: (0, import_classnames21.default)("tlui-dialog__footer", className), children });
}
var import_jsx_runtime86, import_classnames21;
var init_TldrawUiDialog = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiDialog.mjs"() {
    import_jsx_runtime86 = __toESM(require_jsx_runtime(), 1);
    init_dist16();
    import_classnames21 = __toESM(require_classnames(), 1);
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiInput.mjs
var import_jsx_runtime87, import_classnames22, React47, TldrawUiInput;
var init_TldrawUiInput = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiInput.mjs"() {
    import_jsx_runtime87 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames22 = __toESM(require_classnames(), 1);
    React47 = __toESM(require_react(), 1);
    init_useTranslation();
    init_TldrawUiIcon();
    TldrawUiInput = React47.forwardRef(function TldrawUiInput2({
      className,
      label,
      icon,
      iconLeft,
      autoSelect = false,
      autoFocus = false,
      defaultValue,
      placeholder,
      onComplete,
      onValueChange,
      onCancel,
      onFocus,
      onBlur,
      shouldManuallyMaintainScrollPositionWhenFocused = false,
      children,
      value
    }, ref) {
      const editor = useEditor();
      const rInputRef = React47.useRef(null);
      React47.useImperativeHandle(ref, () => rInputRef.current);
      const msg2 = useTranslation();
      const rInitialValue = React47.useRef(defaultValue ?? "");
      const rCurrentValue = React47.useRef(defaultValue ?? "");
      const [isFocused, setIsFocused] = React47.useState(false);
      const handleFocus = React47.useCallback((e2) => {
        setIsFocused(true);
        const elm = e2.currentTarget;
        rCurrentValue.current = elm.value;
        editor.timers.requestAnimationFrame(() => {
          if (autoSelect) {
            elm.select();
          }
        });
        onFocus?.();
      }, [autoSelect, onFocus, editor.timers]);
      const handleChange = React47.useCallback((e2) => {
        const value2 = e2.currentTarget.value;
        rCurrentValue.current = value2;
        onValueChange?.(value2);
      }, [onValueChange]);
      const handleKeyUp = React47.useCallback((e2) => {
        switch (e2.key) {
          case "Enter": {
            e2.currentTarget.blur();
            stopEventPropagation(e2);
            onComplete?.(e2.currentTarget.value);
            break;
          }
          case "Escape": {
            e2.currentTarget.value = rInitialValue.current;
            e2.currentTarget.blur();
            stopEventPropagation(e2);
            onCancel?.(e2.currentTarget.value);
            break;
          }
        }
      }, [onComplete, onCancel]);
      const handleBlur = React47.useCallback((e2) => {
        setIsFocused(false);
        const value2 = e2.currentTarget.value;
        onBlur?.(value2);
      }, [onBlur]);
      React47.useEffect(() => {
        if (!editor.environment.isIos)
          return;
        const visualViewport = window.visualViewport;
        if (isFocused && shouldManuallyMaintainScrollPositionWhenFocused && visualViewport) {
          const onViewportChange = () => {
            rInputRef.current?.scrollIntoView({ block: "center" });
          };
          visualViewport.addEventListener("resize", onViewportChange);
          visualViewport.addEventListener("scroll", onViewportChange);
          editor.timers.requestAnimationFrame(() => {
            rInputRef.current?.scrollIntoView({ block: "center" });
          });
          return () => {
            visualViewport.removeEventListener("resize", onViewportChange);
            visualViewport.removeEventListener("scroll", onViewportChange);
          };
        }
      }, [editor, isFocused, shouldManuallyMaintainScrollPositionWhenFocused]);
      return /* @__PURE__ */ (0, import_jsx_runtime87.jsxs)("div", { draggable: false, className: "tlui-input__wrapper", children: [
        children,
        label && /* @__PURE__ */ (0, import_jsx_runtime87.jsx)("label", { children: msg2(label) }),
        iconLeft && /* @__PURE__ */ (0, import_jsx_runtime87.jsx)(TldrawUiIcon, { icon: iconLeft, className: "tlui-icon-left", small: true }),
        /* @__PURE__ */ (0, import_jsx_runtime87.jsx)("input", {
          ref: rInputRef,
          className: (0, import_classnames22.default)("tlui-input", className),
          type: "text",
          defaultValue,
          onKeyUp: handleKeyUp,
          onChange: handleChange,
          onFocus: handleFocus,
          onBlur: handleBlur,
          autoFocus,
          placeholder,
          value
        }),
        icon && /* @__PURE__ */ (0, import_jsx_runtime87.jsx)(TldrawUiIcon, { icon, small: !!label })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/EmbedDialog.mjs
var import_jsx_runtime88, import_react71, EmbedDialog;
var init_EmbedDialog = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/EmbedDialog.mjs"() {
    import_jsx_runtime88 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react71 = __toESM(require_react(), 1);
    init_embeds();
    init_asset_urls();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonLabel();
    init_TldrawUiDialog();
    init_TldrawUiIcon();
    init_TldrawUiInput();
    EmbedDialog = track(function EmbedDialog2({ onClose }) {
      const editor = useEditor();
      const msg2 = useTranslation();
      const assetUrls = useAssetUrls();
      const [embedDefinition, setEmbedDefinition] = (0, import_react71.useState)(null);
      const [url, setUrl] = (0, import_react71.useState)("");
      const [embedInfoForUrl, setEmbedInfoForUrl] = (0, import_react71.useState)(null);
      const [showError, setShowError] = (0, import_react71.useState)(false);
      const rShowErrorTimeout = (0, import_react71.useRef)(-1);
      return /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(import_jsx_runtime88.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(TldrawUiDialogHeader, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiDialogTitle, { children: embedDefinition ? `${msg2("embed-dialog.title")} \u2014 ${embedDefinition.title}` : msg2("embed-dialog.title") }),
          /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiDialogCloseButton, {})
        ] }),
        embedDefinition ? /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(import_jsx_runtime88.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(TldrawUiDialogBody, { className: "tlui-embed-dialog__enter", children: [
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiInput, {
              className: "tlui-embed-dialog__input",
              label: "embed-dialog.url",
              placeholder: "http://example.com",
              autoFocus: true,
              onValueChange: (value) => {
                setUrl(value);
                const embedInfo = getEmbedInfo(value);
                setEmbedInfoForUrl(embedInfo && embedInfo.definition.type === embedDefinition.type ? embedInfo : null);
                setShowError(false);
                clearTimeout(rShowErrorTimeout.current);
                rShowErrorTimeout.current = editor.timers.setTimeout(() => setShowError(!embedInfo), 320);
              }
            }),
            url === "" ? /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)("div", { className: "tlui-embed-dialog__instruction", children: [
              /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("span", { children: msg2("embed-dialog.instruction") }),
              " ",
              embedDefinition.instructionLink && /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)("a", {
                target: "_blank",
                rel: "noopener noreferrer",
                href: embedDefinition.instructionLink,
                className: "tlui-embed-dialog__instruction__link",
                children: [
                  "Learn more.",
                  /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiIcon, { icon: "external-link", small: true })
                ]
              })
            ] }) : /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("div", { className: "tlui-embed-dialog__warning", children: showError ? msg2("embed-dialog.invalid-url") : "\xA0" })
          ] }),
          /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(TldrawUiDialogFooter, { className: "tlui-dialog__footer__actions", children: [
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButton, {
              type: "normal",
              onClick: () => {
                setEmbedDefinition(null);
                setEmbedInfoForUrl(null);
                setUrl("");
              },
              children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButtonLabel, { children: msg2("embed-dialog.back") })
            }),
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("div", { className: "tlui-embed__spacer" }),
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButton, { type: "normal", onClick: onClose, children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButtonLabel, { children: msg2("embed-dialog.cancel") }) }),
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButton, {
              type: "primary",
              disabled: !embedInfoForUrl,
              onClick: () => {
                if (!embedInfoForUrl)
                  return;
                editor.putExternalContent({
                  type: "embed",
                  url,
                  point: editor.getViewportPageBounds().center,
                  embed: embedInfoForUrl.definition
                });
                onClose();
              },
              children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButtonLabel, { children: msg2("embed-dialog.create") })
            })
          ] })
        ] }) : /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(import_jsx_runtime88.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiDialogBody, { className: "tlui-embed-dialog__list", children: EMBED_DEFINITIONS.map((def) => {
          return /* @__PURE__ */ (0, import_jsx_runtime88.jsxs)(TldrawUiButton, { type: "menu", onClick: () => setEmbedDefinition(def), children: [
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(TldrawUiButtonLabel, { children: untranslated(def.title) }),
            /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("div", {
              className: "tlui-embed-dialog__item__image",
              style: { backgroundImage: `url(${assetUrls.embedIcons[def.type]})` }
            })
          ] }, def.type);
        }) }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useInsertMedia.mjs
function useInsertMedia() {
  const editor = useEditor();
  const inputRef = (0, import_react72.useRef)();
  (0, import_react72.useEffect)(() => {
    const input = window.document.createElement("input");
    input.type = "file";
    input.accept = DEFAULT_SUPPORTED_MEDIA_TYPE_LIST;
    input.multiple = true;
    inputRef.current = input;
    async function onchange(e2) {
      const fileList = e2.target.files;
      if (!fileList || fileList.length === 0)
        return;
      editor.mark("insert media");
      await editor.putExternalContent({
        type: "files",
        files: Array.from(fileList),
        point: editor.getViewportPageBounds().center,
        ignoreParent: false
      });
      input.value = "";
    }
    input.addEventListener("change", onchange);
    return () => {
      inputRef.current = void 0;
      input.removeEventListener("change", onchange);
    };
  }, [editor]);
  return (0, import_react72.useCallback)(() => {
    inputRef.current?.click();
  }, [inputRef]);
}
var import_react72;
var init_useInsertMedia = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useInsertMedia.mjs"() {
    init_dist_esm10();
    import_react72 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useTools.mjs
function ToolsProvider({ overrides, children }) {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const { addDialog } = useDialogs();
  const insertMedia = useInsertMedia();
  const tools = React48.useMemo(() => {
    const toolsArray = [
      {
        id: "select",
        label: "tool.select",
        icon: "tool-pointer",
        kbd: "v",
        readonlyOk: true,
        onSelect(source) {
          editor.setCurrentTool("select");
          trackEvent("select-tool", { source, id: "select" });
        }
      },
      {
        id: "hand",
        label: "tool.hand",
        icon: "tool-hand",
        kbd: "h",
        readonlyOk: true,
        onSelect(source) {
          editor.setCurrentTool("hand");
          trackEvent("select-tool", { source, id: "hand" });
        }
      },
      {
        id: "eraser",
        label: "tool.eraser",
        icon: "tool-eraser",
        kbd: "e",
        onSelect(source) {
          editor.setCurrentTool("eraser");
          trackEvent("select-tool", { source, id: "eraser" });
        }
      },
      {
        id: "draw",
        label: "tool.draw",
        icon: "tool-pencil",
        kbd: "d,b,x",
        onSelect(source) {
          editor.setCurrentTool("draw");
          trackEvent("select-tool", { source, id: "draw" });
        }
      },
      ...[...GeoShapeGeoStyle.values].map((id) => ({
        id,
        label: `tool.${id}`,
        meta: {
          geo: id
        },
        kbd: id === "rectangle" ? "r" : id === "ellipse" ? "o" : void 0,
        icon: "geo-" + id,
        onSelect(source) {
          editor.run(() => {
            editor.setStyleForNextShapes(GeoShapeGeoStyle, id);
            editor.setCurrentTool("geo");
            trackEvent("select-tool", { source, id: `geo-${id}` });
          });
        }
      })),
      {
        id: "arrow",
        label: "tool.arrow",
        icon: "tool-arrow",
        kbd: "a",
        onSelect(source) {
          editor.setCurrentTool("arrow");
          trackEvent("select-tool", { source, id: "arrow" });
        }
      },
      {
        id: "line",
        label: "tool.line",
        icon: "tool-line",
        kbd: "l",
        onSelect(source) {
          editor.setCurrentTool("line");
          trackEvent("select-tool", { source, id: "line" });
        }
      },
      {
        id: "frame",
        label: "tool.frame",
        icon: "tool-frame",
        kbd: "f",
        onSelect(source) {
          editor.setCurrentTool("frame");
          trackEvent("select-tool", { source, id: "frame" });
        }
      },
      {
        id: "text",
        label: "tool.text",
        icon: "tool-text",
        kbd: "t",
        onSelect(source) {
          editor.setCurrentTool("text");
          trackEvent("select-tool", { source, id: "text" });
        }
      },
      {
        id: "asset",
        label: "tool.asset",
        icon: "tool-media",
        kbd: "$u",
        onSelect(source) {
          insertMedia();
          trackEvent("select-tool", { source, id: "media" });
        }
      },
      {
        id: "note",
        label: "tool.note",
        icon: "tool-note",
        kbd: "n",
        onSelect(source) {
          editor.setCurrentTool("note");
          trackEvent("select-tool", { source, id: "note" });
        }
      },
      {
        id: "laser",
        label: "tool.laser",
        readonlyOk: true,
        icon: "tool-laser",
        kbd: "k",
        onSelect(source) {
          editor.setCurrentTool("laser");
          trackEvent("select-tool", { source, id: "laser" });
        }
      },
      {
        id: "embed",
        label: "tool.embed",
        icon: "dot",
        onSelect(source) {
          addDialog({ component: EmbedDialog });
          trackEvent("select-tool", { source, id: "embed" });
        }
      },
      {
        id: "highlight",
        label: "tool.highlight",
        icon: "tool-highlight",
        kbd: "!d",
        onSelect(source) {
          editor.setCurrentTool("highlight");
          trackEvent("select-tool", { source, id: "highlight" });
        }
      }
    ];
    toolsArray.push();
    const tools2 = Object.fromEntries(toolsArray.map((t3) => [t3.id, t3]));
    if (overrides) {
      return overrides(editor, tools2, { insertMedia });
    }
    return tools2;
  }, [overrides, editor, trackEvent, insertMedia, addDialog]);
  return /* @__PURE__ */ (0, import_jsx_runtime89.jsx)(ToolsContext.Provider, { value: tools, children });
}
function useTools() {
  const ctx = React48.useContext(ToolsContext);
  if (!ctx) {
    throw new Error("useTools must be used within a ToolProvider");
  }
  return ctx;
}
var import_jsx_runtime89, React48, ToolsContext;
var init_useTools = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useTools.mjs"() {
    import_jsx_runtime89 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    React48 = __toESM(require_react(), 1);
    init_EmbedDialog();
    init_dialogs();
    init_events();
    init_useInsertMedia();
    ToolsContext = React48.createContext(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/breakpoints.mjs
function BreakPointProvider({ forceMobile = false, children }) {
  const editor = useEditor();
  const breakpoint = useValue("breakpoint", () => {
    const { width } = editor.getViewportScreenBounds();
    const maxBreakpoint = forceMobile ? PORTRAIT_BREAKPOINT.MOBILE_SM : PORTRAIT_BREAKPOINTS.length - 1;
    for (let i2 = 0; i2 < maxBreakpoint; i2++) {
      if (width > PORTRAIT_BREAKPOINTS[i2] && width <= PORTRAIT_BREAKPOINTS[i2 + 1]) {
        return i2;
      }
    }
    return maxBreakpoint;
  }, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime90.jsx)(BreakpointContext.Provider, { value: breakpoint, children });
}
function useBreakpoint() {
  const breakpoint = (0, import_react73.useContext)(BreakpointContext);
  if (breakpoint === null) {
    throw new Error("useBreakpoint must be used inside of the <BreakpointProvider /> component");
  }
  return breakpoint;
}
var import_jsx_runtime90, import_react73, BreakpointContext;
var init_breakpoints = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/breakpoints.mjs"() {
    import_jsx_runtime90 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react73 = __toESM(require_react(), 1);
    init_constants5();
    BreakpointContext = import_react73.default.createContext(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/overrides.mjs
function useDefaultHelpers() {
  const { addToast, removeToast, clearToasts } = useToasts();
  const { addDialog, clearDialogs, removeDialog, updateDialog } = useDialogs();
  const breakpoint = useBreakpoint();
  const isMobile = breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM;
  const msg2 = useTranslation();
  return (0, import_react74.useMemo)(() => ({
    addToast,
    removeToast,
    clearToasts,
    addDialog,
    clearDialogs,
    removeDialog,
    updateDialog,
    msg: msg2,
    isMobile
  }), [
    addDialog,
    addToast,
    clearDialogs,
    clearToasts,
    msg2,
    removeDialog,
    removeToast,
    updateDialog,
    isMobile
  ]);
}
function mergeOverrides(overrides, defaultHelpers) {
  const mergedTranslations = {};
  for (const override of overrides) {
    if (override.translations) {
      for (const [key, value] of objectMapEntries(override.translations)) {
        let strings = mergedTranslations[key];
        if (!strings) {
          strings = mergedTranslations[key] = {};
        }
        Object.assign(strings, value);
      }
    }
  }
  return {
    actions: (editor, schema) => {
      for (const override of overrides) {
        if (override.actions) {
          schema = override.actions(editor, schema, defaultHelpers);
        }
      }
      return schema;
    },
    tools: (editor, schema, helpers) => {
      for (const override of overrides) {
        if (override.tools) {
          schema = override.tools(editor, schema, { ...defaultHelpers, ...helpers });
        }
      }
      return schema;
    },
    translations: mergedTranslations
  };
}
function useShallowArrayEquality(array2) {
  return (0, import_react74.useMemo)(() => array2, array2);
}
function useMergedTranslationOverrides(overrides) {
  const overridesArray = useShallowArrayEquality(overrides == null ? [] : Array.isArray(overrides) ? overrides : [overrides]);
  return (0, import_react74.useMemo)(() => {
    const mergedTranslations = {};
    for (const override of overridesArray) {
      if (override.translations) {
        for (const [key, value] of objectMapEntries(override.translations)) {
          let strings = mergedTranslations[key];
          if (!strings) {
            strings = mergedTranslations[key] = {};
          }
          Object.assign(strings, value);
        }
      }
    }
    return mergedTranslations;
  }, [overridesArray]);
}
function useMergedOverrides(overrides) {
  const defaultHelpers = useDefaultHelpers();
  const overridesArray = useShallowArrayEquality(overrides == null ? [] : Array.isArray(overrides) ? overrides : [overrides]);
  return (0, import_react74.useMemo)(() => mergeOverrides(overridesArray, defaultHelpers), [overridesArray, defaultHelpers]);
}
var import_react74;
var init_overrides = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/overrides.mjs"() {
    init_dist_esm10();
    import_react74 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_dialogs();
    init_toasts();
    init_useTranslation();
  }
});

// node_modules/tldraw/dist-esm/lib/utils/frames/frames.mjs
function removeFrame(editor, ids) {
  const frames = compact(ids.map((id) => editor.getShape(id)).filter((f2) => f2 && editor.isShapeOfType(f2, "frame")));
  if (!frames.length)
    return;
  const allChildren = [];
  editor.run(() => {
    frames.map((frame3) => {
      const children = editor.getSortedChildIdsForParent(frame3.id);
      if (children.length) {
        editor.reparentShapes(children, frame3.parentId, frame3.index);
        allChildren.push(...children);
      }
    });
    editor.setSelectedShapes(allChildren);
    editor.deleteShapes(ids);
  });
}
function fitFrameToContent(editor, id, opts = {}) {
  const frame3 = editor.getShape(id);
  if (!frame3)
    return;
  const childIds = editor.getSortedChildIdsForParent(frame3.id);
  const children = compact(childIds.map((id2) => editor.getShape(id2)));
  if (!children.length)
    return;
  const bounds = Box.FromPoints(children.flatMap((shape) => {
    const geometry = editor.getShapeGeometry(shape.id);
    return editor.getShapeLocalTransform(shape).applyToPoints(geometry.vertices);
  }));
  const { padding = DEFAULT_FRAME_PADDING } = opts;
  const w2 = bounds.w + 2 * padding;
  const h2 = bounds.h + 2 * padding;
  const dx = padding - bounds.minX;
  const dy = padding - bounds.minY;
  if (dx === 0 && dy === 0 && frame3.props.w === w2 && frame3.props.h === h2)
    return;
  const diff = new Vec(dx, dy).rot(frame3.rotation);
  editor.run(() => {
    const changes = childIds.map((child) => {
      const shape = editor.getShape(child);
      return {
        id: shape.id,
        type: shape.type,
        x: shape.x + dx,
        y: shape.y + dy
      };
    });
    changes.push({
      id: frame3.id,
      type: frame3.type,
      x: frame3.x - diff.x,
      y: frame3.y - diff.y,
      props: {
        w: w2,
        h: h2
      }
    });
    editor.updateShapes(changes);
  });
}
var DEFAULT_FRAME_PADDING;
var init_frames = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/frames/frames.mjs"() {
    init_dist_esm10();
    DEFAULT_FRAME_PADDING = 50;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/EditLinkDialog.mjs
function validateUrl(url) {
  if (validation_exports.linkUrl.isValid(url)) {
    return { isValid: true, hasProtocol: true };
  }
  if (validation_exports.linkUrl.isValid("https://" + url)) {
    return { isValid: true, hasProtocol: false };
  }
  return { isValid: false, hasProtocol: false };
}
var import_jsx_runtime91, import_react75, EditLinkDialog, EditLinkDialogInner;
var init_EditLinkDialog = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/EditLinkDialog.mjs"() {
    import_jsx_runtime91 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react75 = __toESM(require_react(), 1);
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonLabel();
    init_TldrawUiDialog();
    init_TldrawUiInput();
    EditLinkDialog = track(function EditLinkDialog2({ onClose }) {
      const editor = useEditor();
      const selectedShape = editor.getOnlySelectedShape();
      if (!(selectedShape && "url" in selectedShape.props && typeof selectedShape.props.url === "string")) {
        return null;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(EditLinkDialogInner, { onClose, selectedShape });
    });
    EditLinkDialogInner = track(function EditLinkDialogInner2({
      onClose,
      selectedShape
    }) {
      const editor = useEditor();
      const msg2 = useTranslation();
      const rInput = (0, import_react75.useRef)(null);
      (0, import_react75.useEffect)(() => {
        editor.timers.requestAnimationFrame(() => rInput.current?.focus());
      }, [editor]);
      const rInitialValue = (0, import_react75.useRef)(selectedShape.props.url);
      const [urlInputState, setUrlInputState] = (0, import_react75.useState)(() => {
        const urlValidResult = validateUrl(selectedShape.props.url);
        const initialValue = urlValidResult.isValid === true ? urlValidResult.hasProtocol ? selectedShape.props.url : "https://" + selectedShape.props.url : "https://";
        return {
          actual: initialValue,
          safe: initialValue,
          valid: true
        };
      });
      const handleChange = (0, import_react75.useCallback)((rawValue) => {
        const fixedRawValue = rawValue.replace(/https?:\/\/(https?:\/\/)/, (_match, arg1) => {
          return arg1;
        });
        const urlValidResult = validateUrl(fixedRawValue);
        const safeValue = urlValidResult.isValid === true ? urlValidResult.hasProtocol ? fixedRawValue : "https://" + fixedRawValue : "https://";
        setUrlInputState({
          actual: fixedRawValue,
          safe: safeValue,
          valid: urlValidResult.isValid
        });
      }, []);
      const handleClear = (0, import_react75.useCallback)(() => {
        const onlySelectedShape = editor.getOnlySelectedShape();
        if (!onlySelectedShape)
          return;
        editor.updateShapes([
          { id: onlySelectedShape.id, type: onlySelectedShape.type, props: { url: "" } }
        ]);
        onClose();
      }, [editor, onClose]);
      const handleComplete = (0, import_react75.useCallback)(() => {
        const onlySelectedShape = editor.getOnlySelectedShape();
        if (!onlySelectedShape)
          return;
        if (onlySelectedShape && "url" in onlySelectedShape.props) {
          if (onlySelectedShape.props.url !== urlInputState.safe) {
            editor.updateShapes([
              {
                id: onlySelectedShape.id,
                type: onlySelectedShape.type,
                props: { url: urlInputState.safe }
              }
            ]);
          }
        }
        onClose();
      }, [editor, onClose, urlInputState]);
      const handleCancel = (0, import_react75.useCallback)(() => {
        onClose();
      }, [onClose]);
      if (!selectedShape) {
        onClose();
        return null;
      }
      const isRemoving = rInitialValue.current && !urlInputState.valid;
      return /* @__PURE__ */ (0, import_jsx_runtime91.jsxs)(import_jsx_runtime91.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime91.jsxs)(TldrawUiDialogHeader, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiDialogTitle, { children: msg2("edit-link-dialog.title") }),
          /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiDialogCloseButton, {})
        ] }),
        /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiDialogBody, { children: /* @__PURE__ */ (0, import_jsx_runtime91.jsxs)("div", { className: "tlui-edit-link-dialog", children: [
          /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiInput, {
            ref: rInput,
            className: "tlui-edit-link-dialog__input",
            label: "edit-link-dialog.url",
            autoFocus: true,
            value: urlInputState.actual,
            onValueChange: handleChange,
            onComplete: handleComplete,
            onCancel: handleCancel
          }),
          /* @__PURE__ */ (0, import_jsx_runtime91.jsx)("div", { children: urlInputState.valid ? msg2("edit-link-dialog.detail") : msg2("edit-link-dialog.invalid-url") })
        ] }) }),
        /* @__PURE__ */ (0, import_jsx_runtime91.jsxs)(TldrawUiDialogFooter, { className: "tlui-dialog__footer__actions", children: [
          /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButton, { type: "normal", onClick: handleCancel, onTouchEnd: handleCancel, children: /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButtonLabel, { children: msg2("edit-link-dialog.cancel") }) }),
          isRemoving ? /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButton, { type: "danger", onTouchEnd: handleClear, onClick: handleClear, children: /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButtonLabel, { children: msg2("edit-link-dialog.clear") }) }) : /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButton, {
            type: "primary",
            disabled: !urlInputState.valid,
            onTouchEnd: handleComplete,
            onClick: handleComplete,
            children: /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(TldrawUiButtonLabel, { children: msg2("edit-link-dialog.save") })
          })
        ] })
      ] });
    });
  }
});

// node_modules/lz-string/libs/lz-string.js
var require_lz_string = __commonJS({
  "node_modules/lz-string/libs/lz-string.js"(exports, module2) {
    var LZString = function() {
      var f2 = String.fromCharCode;
      var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
      var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
      var baseReverseDic = {};
      function getBaseValue(alphabet, character) {
        if (!baseReverseDic[alphabet]) {
          baseReverseDic[alphabet] = {};
          for (var i2 = 0; i2 < alphabet.length; i2++) {
            baseReverseDic[alphabet][alphabet.charAt(i2)] = i2;
          }
        }
        return baseReverseDic[alphabet][character];
      }
      var LZString2 = {
        compressToBase64: function(input) {
          if (input == null)
            return "";
          var res = LZString2._compress(input, 6, function(a2) {
            return keyStrBase64.charAt(a2);
          });
          switch (res.length % 4) {
            default:
            case 0:
              return res;
            case 1:
              return res + "===";
            case 2:
              return res + "==";
            case 3:
              return res + "=";
          }
        },
        decompressFromBase64: function(input) {
          if (input == null)
            return "";
          if (input == "")
            return null;
          return LZString2._decompress(input.length, 32, function(index3) {
            return getBaseValue(keyStrBase64, input.charAt(index3));
          });
        },
        compressToUTF16: function(input) {
          if (input == null)
            return "";
          return LZString2._compress(input, 15, function(a2) {
            return f2(a2 + 32);
          }) + " ";
        },
        decompressFromUTF16: function(compressed) {
          if (compressed == null)
            return "";
          if (compressed == "")
            return null;
          return LZString2._decompress(compressed.length, 16384, function(index3) {
            return compressed.charCodeAt(index3) - 32;
          });
        },
        compressToUint8Array: function(uncompressed) {
          var compressed = LZString2.compress(uncompressed);
          var buf = new Uint8Array(compressed.length * 2);
          for (var i2 = 0, TotalLen = compressed.length; i2 < TotalLen; i2++) {
            var current_value = compressed.charCodeAt(i2);
            buf[i2 * 2] = current_value >>> 8;
            buf[i2 * 2 + 1] = current_value % 256;
          }
          return buf;
        },
        decompressFromUint8Array: function(compressed) {
          if (compressed === null || compressed === void 0) {
            return LZString2.decompress(compressed);
          } else {
            var buf = new Array(compressed.length / 2);
            for (var i2 = 0, TotalLen = buf.length; i2 < TotalLen; i2++) {
              buf[i2] = compressed[i2 * 2] * 256 + compressed[i2 * 2 + 1];
            }
            var result = [];
            buf.forEach(function(c2) {
              result.push(f2(c2));
            });
            return LZString2.decompress(result.join(""));
          }
        },
        compressToEncodedURIComponent: function(input) {
          if (input == null)
            return "";
          return LZString2._compress(input, 6, function(a2) {
            return keyStrUriSafe.charAt(a2);
          });
        },
        decompressFromEncodedURIComponent: function(input) {
          if (input == null)
            return "";
          if (input == "")
            return null;
          input = input.replace(/ /g, "+");
          return LZString2._decompress(input.length, 32, function(index3) {
            return getBaseValue(keyStrUriSafe, input.charAt(index3));
          });
        },
        compress: function(uncompressed) {
          return LZString2._compress(uncompressed, 16, function(a2) {
            return f2(a2);
          });
        },
        _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
          if (uncompressed == null)
            return "";
          var i2, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
          for (ii = 0; ii < uncompressed.length; ii += 1) {
            context_c = uncompressed.charAt(ii);
            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
              context_dictionary[context_c] = context_dictSize++;
              context_dictionaryToCreate[context_c] = true;
            }
            context_wc = context_w + context_c;
            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
              context_w = context_wc;
            } else {
              if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
                if (context_w.charCodeAt(0) < 256) {
                  for (i2 = 0; i2 < context_numBits; i2++) {
                    context_data_val = context_data_val << 1;
                    if (context_data_position == bitsPerChar - 1) {
                      context_data_position = 0;
                      context_data.push(getCharFromInt(context_data_val));
                      context_data_val = 0;
                    } else {
                      context_data_position++;
                    }
                  }
                  value = context_w.charCodeAt(0);
                  for (i2 = 0; i2 < 8; i2++) {
                    context_data_val = context_data_val << 1 | value & 1;
                    if (context_data_position == bitsPerChar - 1) {
                      context_data_position = 0;
                      context_data.push(getCharFromInt(context_data_val));
                      context_data_val = 0;
                    } else {
                      context_data_position++;
                    }
                    value = value >> 1;
                  }
                } else {
                  value = 1;
                  for (i2 = 0; i2 < context_numBits; i2++) {
                    context_data_val = context_data_val << 1 | value;
                    if (context_data_position == bitsPerChar - 1) {
                      context_data_position = 0;
                      context_data.push(getCharFromInt(context_data_val));
                      context_data_val = 0;
                    } else {
                      context_data_position++;
                    }
                    value = 0;
                  }
                  value = context_w.charCodeAt(0);
                  for (i2 = 0; i2 < 16; i2++) {
                    context_data_val = context_data_val << 1 | value & 1;
                    if (context_data_position == bitsPerChar - 1) {
                      context_data_position = 0;
                      context_data.push(getCharFromInt(context_data_val));
                      context_data_val = 0;
                    } else {
                      context_data_position++;
                    }
                    value = value >> 1;
                  }
                }
                context_enlargeIn--;
                if (context_enlargeIn == 0) {
                  context_enlargeIn = Math.pow(2, context_numBits);
                  context_numBits++;
                }
                delete context_dictionaryToCreate[context_w];
              } else {
                value = context_dictionary[context_w];
                for (i2 = 0; i2 < context_numBits; i2++) {
                  context_data_val = context_data_val << 1 | value & 1;
                  if (context_data_position == bitsPerChar - 1) {
                    context_data_position = 0;
                    context_data.push(getCharFromInt(context_data_val));
                    context_data_val = 0;
                  } else {
                    context_data_position++;
                  }
                  value = value >> 1;
                }
              }
              context_enlargeIn--;
              if (context_enlargeIn == 0) {
                context_enlargeIn = Math.pow(2, context_numBits);
                context_numBits++;
              }
              context_dictionary[context_wc] = context_dictSize++;
              context_w = String(context_c);
            }
          }
          if (context_w !== "") {
            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
              if (context_w.charCodeAt(0) < 256) {
                for (i2 = 0; i2 < context_numBits; i2++) {
                  context_data_val = context_data_val << 1;
                  if (context_data_position == bitsPerChar - 1) {
                    context_data_position = 0;
                    context_data.push(getCharFromInt(context_data_val));
                    context_data_val = 0;
                  } else {
                    context_data_position++;
                  }
                }
                value = context_w.charCodeAt(0);
                for (i2 = 0; i2 < 8; i2++) {
                  context_data_val = context_data_val << 1 | value & 1;
                  if (context_data_position == bitsPerChar - 1) {
                    context_data_position = 0;
                    context_data.push(getCharFromInt(context_data_val));
                    context_data_val = 0;
                  } else {
                    context_data_position++;
                  }
                  value = value >> 1;
                }
              } else {
                value = 1;
                for (i2 = 0; i2 < context_numBits; i2++) {
                  context_data_val = context_data_val << 1 | value;
                  if (context_data_position == bitsPerChar - 1) {
                    context_data_position = 0;
                    context_data.push(getCharFromInt(context_data_val));
                    context_data_val = 0;
                  } else {
                    context_data_position++;
                  }
                  value = 0;
                }
                value = context_w.charCodeAt(0);
                for (i2 = 0; i2 < 16; i2++) {
                  context_data_val = context_data_val << 1 | value & 1;
                  if (context_data_position == bitsPerChar - 1) {
                    context_data_position = 0;
                    context_data.push(getCharFromInt(context_data_val));
                    context_data_val = 0;
                  } else {
                    context_data_position++;
                  }
                  value = value >> 1;
                }
              }
              context_enlargeIn--;
              if (context_enlargeIn == 0) {
                context_enlargeIn = Math.pow(2, context_numBits);
                context_numBits++;
              }
              delete context_dictionaryToCreate[context_w];
            } else {
              value = context_dictionary[context_w];
              for (i2 = 0; i2 < context_numBits; i2++) {
                context_data_val = context_data_val << 1 | value & 1;
                if (context_data_position == bitsPerChar - 1) {
                  context_data_position = 0;
                  context_data.push(getCharFromInt(context_data_val));
                  context_data_val = 0;
                } else {
                  context_data_position++;
                }
                value = value >> 1;
              }
            }
            context_enlargeIn--;
            if (context_enlargeIn == 0) {
              context_enlargeIn = Math.pow(2, context_numBits);
              context_numBits++;
            }
          }
          value = 2;
          for (i2 = 0; i2 < context_numBits; i2++) {
            context_data_val = context_data_val << 1 | value & 1;
            if (context_data_position == bitsPerChar - 1) {
              context_data_position = 0;
              context_data.push(getCharFromInt(context_data_val));
              context_data_val = 0;
            } else {
              context_data_position++;
            }
            value = value >> 1;
          }
          while (true) {
            context_data_val = context_data_val << 1;
            if (context_data_position == bitsPerChar - 1) {
              context_data.push(getCharFromInt(context_data_val));
              break;
            } else
              context_data_position++;
          }
          return context_data.join("");
        },
        decompress: function(compressed) {
          if (compressed == null)
            return "";
          if (compressed == "")
            return null;
          return LZString2._decompress(compressed.length, 32768, function(index3) {
            return compressed.charCodeAt(index3);
          });
        },
        _decompress: function(length, resetValue, getNextValue) {
          var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i2, w2, bits, resb, maxpower, power, c2, data = { val: getNextValue(0), position: resetValue, index: 1 };
          for (i2 = 0; i2 < 3; i2 += 1) {
            dictionary[i2] = i2;
          }
          bits = 0;
          maxpower = Math.pow(2, 2);
          power = 1;
          while (power != maxpower) {
            resb = data.val & data.position;
            data.position >>= 1;
            if (data.position == 0) {
              data.position = resetValue;
              data.val = getNextValue(data.index++);
            }
            bits |= (resb > 0 ? 1 : 0) * power;
            power <<= 1;
          }
          switch (next = bits) {
            case 0:
              bits = 0;
              maxpower = Math.pow(2, 8);
              power = 1;
              while (power != maxpower) {
                resb = data.val & data.position;
                data.position >>= 1;
                if (data.position == 0) {
                  data.position = resetValue;
                  data.val = getNextValue(data.index++);
                }
                bits |= (resb > 0 ? 1 : 0) * power;
                power <<= 1;
              }
              c2 = f2(bits);
              break;
            case 1:
              bits = 0;
              maxpower = Math.pow(2, 16);
              power = 1;
              while (power != maxpower) {
                resb = data.val & data.position;
                data.position >>= 1;
                if (data.position == 0) {
                  data.position = resetValue;
                  data.val = getNextValue(data.index++);
                }
                bits |= (resb > 0 ? 1 : 0) * power;
                power <<= 1;
              }
              c2 = f2(bits);
              break;
            case 2:
              return "";
          }
          dictionary[3] = c2;
          w2 = c2;
          result.push(c2);
          while (true) {
            if (data.index > length) {
              return "";
            }
            bits = 0;
            maxpower = Math.pow(2, numBits);
            power = 1;
            while (power != maxpower) {
              resb = data.val & data.position;
              data.position >>= 1;
              if (data.position == 0) {
                data.position = resetValue;
                data.val = getNextValue(data.index++);
              }
              bits |= (resb > 0 ? 1 : 0) * power;
              power <<= 1;
            }
            switch (c2 = bits) {
              case 0:
                bits = 0;
                maxpower = Math.pow(2, 8);
                power = 1;
                while (power != maxpower) {
                  resb = data.val & data.position;
                  data.position >>= 1;
                  if (data.position == 0) {
                    data.position = resetValue;
                    data.val = getNextValue(data.index++);
                  }
                  bits |= (resb > 0 ? 1 : 0) * power;
                  power <<= 1;
                }
                dictionary[dictSize++] = f2(bits);
                c2 = dictSize - 1;
                enlargeIn--;
                break;
              case 1:
                bits = 0;
                maxpower = Math.pow(2, 16);
                power = 1;
                while (power != maxpower) {
                  resb = data.val & data.position;
                  data.position >>= 1;
                  if (data.position == 0) {
                    data.position = resetValue;
                    data.val = getNextValue(data.index++);
                  }
                  bits |= (resb > 0 ? 1 : 0) * power;
                  power <<= 1;
                }
                dictionary[dictSize++] = f2(bits);
                c2 = dictSize - 1;
                enlargeIn--;
                break;
              case 2:
                return result.join("");
            }
            if (enlargeIn == 0) {
              enlargeIn = Math.pow(2, numBits);
              numBits++;
            }
            if (dictionary[c2]) {
              entry = dictionary[c2];
            } else {
              if (c2 === dictSize) {
                entry = w2 + w2.charAt(0);
              } else {
                return null;
              }
            }
            result.push(entry);
            dictionary[dictSize++] = w2 + entry.charAt(0);
            enlargeIn--;
            w2 = entry;
            if (enlargeIn == 0) {
              enlargeIn = Math.pow(2, numBits);
              numBits++;
            }
          }
        }
      };
      return LZString2;
    }();
    if (typeof define === "function" && define.amd) {
      define(function() {
        return LZString;
      });
    } else if (typeof module2 !== "undefined" && module2 != null) {
      module2.exports = LZString;
    } else if (typeof angular !== "undefined" && angular != null) {
      angular.module("LZString", []).factory("LZString", function() {
        return LZString;
      });
    }
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteExcalidrawContent.mjs
async function pasteExcalidrawContent(editor, clipboard, point) {
  const { elements, files } = clipboard;
  const tldrawContent = {
    shapes: [],
    bindings: [],
    rootShapeIds: [],
    assets: [],
    schema: editor.store.schema.serialize()
  };
  const groupShapeIdToChildren = /* @__PURE__ */ new Map();
  const rotatedElements = /* @__PURE__ */ new Map();
  const currentPageId = editor.getCurrentPageId();
  const excElementIdsToTldrawShapeIds = /* @__PURE__ */ new Map();
  const rootShapeIds = [];
  const skipIds = /* @__PURE__ */ new Set();
  elements.forEach((element) => {
    excElementIdsToTldrawShapeIds.set(element.id, createShapeId());
    if (element.boundElements !== null) {
      for (const boundElement of element.boundElements) {
        if (boundElement.type === "text") {
          skipIds.add(boundElement.id);
        }
      }
    }
  });
  let index3 = ZERO_INDEX_KEY;
  for (const element of elements) {
    if (skipIds.has(element.id)) {
      continue;
    }
    const id = excElementIdsToTldrawShapeIds.get(element.id);
    const base = {
      id,
      typeName: "shape",
      parentId: currentPageId,
      index: index3,
      x: element.x,
      y: element.y,
      rotation: 0,
      isLocked: element.locked,
      opacity: getOpacity(element.opacity),
      meta: {}
    };
    if (element.angle !== 0) {
      rotatedElements.set(id, element.angle);
    }
    if (element.groupIds && element.groupIds.length > 0) {
      if (groupShapeIdToChildren.has(element.groupIds[0])) {
        groupShapeIdToChildren.get(element.groupIds[0])?.push(id);
      } else {
        groupShapeIdToChildren.set(element.groupIds[0], [id]);
      }
    } else {
      rootShapeIds.push(id);
    }
    switch (element.type) {
      case "rectangle":
      case "ellipse":
      case "diamond": {
        let text = "";
        let align = "middle";
        if (element.boundElements !== null) {
          for (const boundElement of element.boundElements) {
            if (boundElement.type === "text") {
              const labelElement = elements.find((elm) => elm.id === boundElement.id);
              if (labelElement) {
                text = labelElement.text;
                align = textAlignToAlignTypes[labelElement.textAlign];
              }
            }
          }
        }
        const colorToUse = element.backgroundColor === "transparent" ? element.strokeColor : element.backgroundColor;
        tldrawContent.shapes.push({
          ...base,
          type: "geo",
          props: {
            geo: element.type,
            url: element.link ?? "",
            w: element.width,
            h: element.height,
            size: strokeWidthsToSizes[element.strokeWidth] ?? "draw",
            color: colorsToColors[colorToUse] ?? "black",
            text,
            align,
            dash: getDash(element),
            fill: getFill(element)
          }
        });
        break;
      }
      case "freedraw": {
        tldrawContent.shapes.push({
          ...base,
          type: "draw",
          props: {
            dash: getDash(element),
            size: strokeWidthsToSizes[element.strokeWidth],
            color: colorsToColors[element.strokeColor] ?? "black",
            segments: [
              {
                type: "free",
                points: element.points.map(([x2, y2, z = 0.5]) => ({
                  x: x2,
                  y: y2,
                  z
                }))
              }
            ]
          }
        });
        break;
      }
      case "line": {
        const points = element.points.slice();
        if (points.length < 2) {
          break;
        }
        const indices = getIndices(element.points.length);
        tldrawContent.shapes.push({
          ...base,
          type: "line",
          props: {
            dash: getDash(element),
            size: strokeWidthsToSizes[element.strokeWidth],
            color: colorsToColors[element.strokeColor] ?? "black",
            spline: element.roundness ? "cubic" : "line",
            points: {
              ...Object.fromEntries(element.points.map(([x2, y2], i2) => {
                const index22 = indices[i2];
                return [index22, { id: index22, index: index22, x: x2, y: y2 }];
              }))
            }
          }
        });
        break;
      }
      case "arrow": {
        let text = "";
        if (element.boundElements !== null) {
          for (const boundElement of element.boundElements) {
            if (boundElement.type === "text") {
              const labelElement = elements.find((elm) => elm.id === boundElement.id);
              if (labelElement) {
                text = labelElement.text;
              }
            }
          }
        }
        const start2 = element.points[0];
        const end2 = element.points[element.points.length - 1];
        const startTargetId = excElementIdsToTldrawShapeIds.get(element.startBinding?.elementId);
        const endTargetId = excElementIdsToTldrawShapeIds.get(element.endBinding?.elementId);
        tldrawContent.shapes.push({
          ...base,
          type: "arrow",
          props: {
            text,
            bend: getBend(element, start2, end2),
            dash: getDash(element),
            size: strokeWidthsToSizes[element.strokeWidth] ?? "m",
            color: colorsToColors[element.strokeColor] ?? "black",
            start: { x: start2[0], y: start2[1] },
            end: { x: end2[0], y: end2[1] },
            arrowheadEnd: arrowheadsToArrowheadTypes[element.endArrowhead] ?? "none",
            arrowheadStart: arrowheadsToArrowheadTypes[element.startArrowhead] ?? "none"
          }
        });
        if (startTargetId) {
          tldrawContent.bindings.push({
            id: createBindingId(),
            typeName: "binding",
            type: "arrow",
            fromId: id,
            toId: startTargetId,
            props: {
              terminal: "start",
              normalizedAnchor: { x: 0.5, y: 0.5 },
              isPrecise: false,
              isExact: false
            },
            meta: {}
          });
        }
        if (endTargetId) {
          tldrawContent.bindings.push({
            id: createBindingId(),
            typeName: "binding",
            type: "arrow",
            fromId: id,
            toId: endTargetId,
            props: {
              terminal: "end",
              normalizedAnchor: { x: 0.5, y: 0.5 },
              isPrecise: false,
              isExact: false
            },
            meta: {}
          });
        }
        break;
      }
      case "text": {
        const { size: size4, scale } = getFontSizeAndScale(element.fontSize);
        tldrawContent.shapes.push({
          ...base,
          type: "text",
          props: {
            size: size4,
            scale,
            font: fontFamilyToFontType[element.fontFamily] ?? "draw",
            color: colorsToColors[element.strokeColor] ?? "black",
            text: element.text,
            textAlign: textAlignToTextAlignTypes[element.textAlign]
          }
        });
        break;
      }
      case "image": {
        const file = files[element.fileId];
        if (!file)
          break;
        const assetId = AssetRecordType.createId();
        tldrawContent.assets.push({
          id: assetId,
          typeName: "asset",
          type: "image",
          props: {
            w: element.width,
            h: element.height,
            fileSize: file.size,
            name: element.id ?? "Untitled",
            isAnimated: false,
            mimeType: file.mimeType,
            src: file.dataURL
          },
          meta: {}
        });
        tldrawContent.shapes.push({
          ...base,
          type: "image",
          props: {
            w: element.width,
            h: element.height,
            assetId
          }
        });
      }
    }
    index3 = getIndexAbove(index3);
  }
  const p2 = point ?? (editor.inputs.shiftKey ? editor.inputs.currentPagePoint : void 0);
  editor.mark("paste");
  editor.putContentOntoCurrentPage(tldrawContent, {
    point: p2,
    select: false,
    preserveIds: true
  });
  for (const groupedShapeIds of groupShapeIdToChildren.values()) {
    if (groupedShapeIds.length > 1) {
      editor.groupShapes(groupedShapeIds);
      const groupShape = editor.getShape(groupedShapeIds[0]);
      if (groupShape?.parentId && isShapeId(groupShape.parentId)) {
        rootShapeIds.push(groupShape.parentId);
      }
    }
  }
  for (const [id, angle] of rotatedElements) {
    editor.select(id);
    editor.rotateShapesBy([id], angle);
  }
  const rootShapes = compact(rootShapeIds.map((id) => editor.getShape(id)));
  const bounds = Box.Common(rootShapes.map((s2) => editor.getShapePageBounds(s2)));
  const viewPortCenter = editor.getViewportPageBounds().center;
  editor.updateShapes(rootShapes.map((s2) => {
    const delta = {
      x: (s2.x ?? 0) - (bounds.x + bounds.w / 2),
      y: (s2.y ?? 0) - (bounds.y + bounds.h / 2)
    };
    return {
      id: s2.id,
      type: s2.type,
      x: viewPortCenter.x + delta.x,
      y: viewPortCenter.y + delta.y
    };
  }));
  editor.setSelectedShapes(rootShapeIds);
}
function getFontSizeAndScale(fontSize) {
  const size4 = fontSizesToSizes[fontSize];
  if (size4) {
    return { size: size4, scale: 1 };
  }
  if (fontSize < 16) {
    return { size: "s", scale: fontSize / 16 };
  }
  if (fontSize > 36) {
    return { size: "xl", scale: fontSize / 36 };
  }
  return { size: "m", scale: 1 };
}
function getBend(element, startPoint, endPoint) {
  let bend = 0;
  if (element.points.length > 2) {
    const start2 = new Vec(startPoint[0], startPoint[1]);
    const end2 = new Vec(endPoint[0], endPoint[1]);
    const handle = new Vec(element.points[1][0], element.points[1][1]);
    const delta = Vec.Sub(end2, start2);
    const v2 = Vec.Per(delta);
    const med = Vec.Med(end2, start2);
    const A2 = Vec.Sub(med, v2);
    const B = Vec.Add(med, v2);
    const point = Vec.NearestPointOnLineSegment(A2, B, handle, false);
    bend = Vec.Dist(point, med);
    if (Vec.Clockwise(point, end2, med))
      bend *= -1;
  }
  return bend;
}
var getOpacity, strokeWidthsToSizes, fontSizesToSizes, fontFamilyToFontType, colorsToColors, strokeStylesToStrokeTypes, fillStylesToFillType, textAlignToAlignTypes, textAlignToTextAlignTypes, arrowheadsToArrowheadTypes, getDash, getFill;
var init_pasteExcalidrawContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteExcalidrawContent.mjs"() {
    init_dist_esm10();
    getOpacity = (opacity) => {
      const t3 = opacity / 100;
      if (t3 < 0.2) {
        return 0.1;
      } else if (t3 < 0.4) {
        return 0.25;
      } else if (t3 < 0.6) {
        return 0.5;
      } else if (t3 < 0.8) {
        return 0.75;
      }
      return 1;
    };
    strokeWidthsToSizes = {
      1: "s",
      2: "m",
      3: "l",
      4: "xl"
    };
    fontSizesToSizes = {
      16: "s",
      20: "m",
      28: "l",
      36: "xl"
    };
    fontFamilyToFontType = {
      1: "draw",
      2: "sans",
      3: "mono"
    };
    colorsToColors = {
      "#ffffff": "grey",
      "#000000": "black",
      "#343a40": "black",
      "#495057": "grey",
      "#c92a2a": "red",
      "#a61e4d": "light-red",
      "#862e9c": "violet",
      "#5f3dc4": "light-violet",
      "#364fc7": "blue",
      "#1864ab": "light-blue",
      "#0b7285": "light-green",
      "#087f5b": "light-green",
      "#2b8a3e": "green",
      "#5c940d": "light-green",
      "#e67700": "yellow",
      "#d9480f": "orange",
      "#ced4da": "grey",
      "#868e96": "grey",
      "#fa5252": "light-red",
      "#e64980": "red",
      "#be4bdb": "light-violet",
      "#7950f2": "violet",
      "#4c6ef5": "blue",
      "#228be6": "light-blue",
      "#15aabf": "light-green",
      "#12b886": "green",
      "#40c057": "green",
      "#82c91e": "light-green",
      "#fab005": "yellow",
      "#fd7e14": "orange",
      "#212529": "grey"
    };
    strokeStylesToStrokeTypes = {
      solid: "draw",
      dashed: "dashed",
      dotted: "dotted"
    };
    fillStylesToFillType = {
      "cross-hatch": "pattern",
      hachure: "pattern",
      solid: "solid"
    };
    textAlignToAlignTypes = {
      left: "start",
      center: "middle",
      right: "end"
    };
    textAlignToTextAlignTypes = {
      left: "start",
      center: "middle",
      right: "end"
    };
    arrowheadsToArrowheadTypes = {
      arrow: "arrow",
      dot: "dot",
      triangle: "triangle",
      bar: "pipe"
    };
    getDash = (element) => {
      let dash = strokeStylesToStrokeTypes[element.strokeStyle] ?? "draw";
      if (dash === "draw" && element.roughness === 0) {
        dash = "solid";
      }
      return dash;
    };
    getFill = (element) => {
      if (element.backgroundColor === "transparent") {
        return "none";
      }
      return fillStylesToFillType[element.fillStyle] ?? "solid";
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteFiles.mjs
async function pasteFiles(editor, urls, point, sources) {
  const blobs = await Promise.all(urls.map(async (url) => await (await fetch2(url)).blob()));
  const files = blobs.map((blob) => new File([blob], "tldrawFile", { type: blob.type }));
  editor.mark("paste");
  await editor.putExternalContent({
    type: "files",
    files,
    point,
    ignoreParent: false,
    sources
  });
  urls.forEach((url) => URL.revokeObjectURL(url));
}
var init_pasteFiles = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteFiles.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteTldrawContent.mjs
function pasteTldrawContent(editor, clipboard, point) {
  const selectionBoundsBefore = editor.getSelectionPageBounds();
  editor.mark("paste");
  editor.putContentOntoCurrentPage(clipboard, {
    point,
    select: true
  });
  const selectedBoundsAfter = editor.getSelectionPageBounds();
  if (selectionBoundsBefore && selectedBoundsAfter && selectionBoundsBefore?.collides(selectedBoundsAfter)) {
    editor.updateInstanceState({ isChangingStyle: true });
    editor.timers.setTimeout(() => {
      editor.updateInstanceState({ isChangingStyle: false });
    }, 150);
  }
}
var init_pasteTldrawContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteTldrawContent.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteUrl.mjs
async function pasteUrl(editor, url, point, sources) {
  editor.mark("paste");
  return await editor.putExternalContent({
    type: "url",
    point,
    url,
    sources
  });
}
var init_pasteUrl = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/clipboard/pasteUrl.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useClipboardEvents.mjs
function stripHtml(html) {
  const doc = document.implementation.createHTMLDocument("");
  doc.documentElement.innerHTML = html.trim();
  return doc.body.textContent || doc.body.innerText || "";
}
function disallowClipboardEvents(editor) {
  const { activeElement } = document;
  return editor.getIsMenuOpen() || activeElement && (activeElement.getAttribute("contenteditable") || INPUTS2.indexOf(activeElement.tagName.toLowerCase()) > -1);
}
async function handleClipboardThings(editor, things, point) {
  const files = things.filter((t3) => (t3.type === "file" || t3.type === "blob") && t3.source !== null);
  if (files.length) {
    const fileBlobs = await Promise.all(files.map((t3) => t3.source));
    const urls = fileBlobs.filter(Boolean).map((blob) => URL.createObjectURL(blob));
    return await pasteFiles(editor, urls, point);
  }
  const results = await Promise.all(things.filter((t3) => t3.type !== "file").map((t3) => new Promise((r2) => {
    const thing = t3;
    if (thing.type === "file") {
      r2({ type: "error", data: null, reason: "unexpected file" });
      return;
    }
    thing.source.then((text) => {
      const tldrawHtmlComment = text.match(/<div data-tldraw[^>]*>(.*)<\/div>/)?.[1];
      if (tldrawHtmlComment) {
        try {
          const jsonComment = import_lz_string.default.decompressFromBase64(tldrawHtmlComment);
          if (jsonComment === null) {
            r2({
              type: "error",
              data: jsonComment,
              reason: `found tldraw data comment but could not parse base64`
            });
            return;
          } else {
            const json = JSON.parse(jsonComment);
            if (json.type !== "application/tldraw") {
              r2({
                type: "error",
                data: json,
                reason: `found tldraw data comment but JSON was of a different type: ${json.type}`
              });
            }
            if (typeof json.data === "string") {
              r2({
                type: "error",
                data: json,
                reason: "found tldraw json but data was a string instead of a TLClipboardModel object"
              });
              return;
            }
            r2({ type: "tldraw", data: json.data });
            return;
          }
        } catch (e2) {
          r2({
            type: "error",
            data: tldrawHtmlComment,
            reason: "found tldraw json but data was a string instead of a TLClipboardModel object"
          });
          return;
        }
      } else {
        if (thing.type === "html") {
          r2({ type: "text", data: text, subtype: "html" });
          return;
        }
        if (thing.type === "url") {
          r2({ type: "text", data: text, subtype: "url" });
          return;
        }
        try {
          const json = JSON.parse(text);
          if (json.type === "excalidraw/clipboard") {
            r2({ type: "excalidraw", data: json });
            return;
          } else {
            r2({ type: "text", data: text, subtype: "json" });
            return;
          }
        } catch (e2) {
          r2({ type: "text", data: text, subtype: "text" });
          return;
        }
      }
      r2({ type: "error", data: text, reason: "unhandled case" });
    });
  })));
  for (const result of results) {
    if (result.type === "tldraw") {
      pasteTldrawContent(editor, result.data, point);
      return;
    }
  }
  for (const result of results) {
    if (result.type === "excalidraw") {
      pasteExcalidrawContent(editor, result.data, point);
      return;
    }
  }
  for (const result of results) {
    if (result.type === "text" && result.subtype === "html") {
      const rootNode = new DOMParser().parseFromString(result.data, "text/html");
      const bodyNode = rootNode.querySelector("body");
      const isHtmlSingleLink = bodyNode && Array.from(bodyNode.children).filter((el) => el.nodeType === 1).length === 1 && bodyNode.firstElementChild && bodyNode.firstElementChild.tagName === "A" && bodyNode.firstElementChild.hasAttribute("href") && bodyNode.firstElementChild.getAttribute("href") !== "";
      if (isHtmlSingleLink) {
        const href = bodyNode.firstElementChild.getAttribute("href");
        handleText(editor, href, point, results);
        return;
      }
      if (!results.some((r2) => r2.type === "text" && r2.subtype !== "html") && result.data.trim()) {
        handleText(editor, stripHtml(result.data), point, results);
        return;
      }
    }
  }
  for (const result of results) {
    if (result.type === "text" && result.subtype === "url") {
      pasteUrl(editor, result.data, point, results);
      return;
    }
  }
  for (const result of results) {
    if (result.type === "text" && result.subtype === "text" && result.data.trim()) {
      handleText(editor, result.data, point, results);
      return;
    }
  }
}
function useMenuClipboardEvents() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const copy = (0, import_react76.useCallback)(async function onCopy(source) {
    if (editor.getSelectedShapeIds().length === 0)
      return;
    await handleNativeOrMenuCopy(editor);
    trackEvent("copy", { source });
  }, [editor, trackEvent]);
  const cut = (0, import_react76.useCallback)(async function onCut(source) {
    if (editor.getSelectedShapeIds().length === 0)
      return;
    await handleNativeOrMenuCopy(editor);
    editor.deleteShapes(editor.getSelectedShapeIds());
    trackEvent("cut", { source });
  }, [editor, trackEvent]);
  const paste = (0, import_react76.useCallback)(async function onPaste(data, source, point) {
    if (editor.getEditingShapeId() !== null)
      return;
    if (Array.isArray(data) && data[0] instanceof ClipboardItem) {
      handlePasteFromClipboardApi(editor, data, point);
      trackEvent("paste", { source: "menu" });
    } else {
      navigator.clipboard.read().then((clipboardItems) => {
        paste(clipboardItems, source, point);
      });
    }
  }, [editor, trackEvent]);
  return {
    copy,
    cut,
    paste
  };
}
function useNativeClipboardEvents() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const appIsFocused = useValue("editor.isFocused", () => editor.getInstanceState().isFocused, [
    editor
  ]);
  (0, import_react76.useEffect)(() => {
    if (!appIsFocused)
      return;
    const copy = async (e2) => {
      if (editor.getSelectedShapeIds().length === 0 || editor.getEditingShapeId() !== null || disallowClipboardEvents(editor)) {
        return;
      }
      preventDefault(e2);
      await handleNativeOrMenuCopy(editor);
      trackEvent("copy", { source: "kbd" });
    };
    async function cut(e2) {
      if (editor.getSelectedShapeIds().length === 0 || editor.getEditingShapeId() !== null || disallowClipboardEvents(editor)) {
        return;
      }
      preventDefault(e2);
      await handleNativeOrMenuCopy(editor);
      editor.deleteShapes(editor.getSelectedShapeIds());
      trackEvent("cut", { source: "kbd" });
    }
    let disablingMiddleClickPaste = false;
    const pointerUpHandler = (e2) => {
      if (e2.button === 1) {
        disablingMiddleClickPaste = true;
        editor.timers.requestAnimationFrame(() => {
          disablingMiddleClickPaste = false;
        });
      }
    };
    const paste = (e2) => {
      if (disablingMiddleClickPaste) {
        stopEventPropagation(e2);
        return;
      }
      if (editor.getEditingShapeId() !== null || disallowClipboardEvents(editor))
        return;
      let point = void 0;
      let pasteAtCursor = false;
      if (editor.inputs.shiftKey)
        pasteAtCursor = true;
      if (editor.user.getIsPasteAtCursorMode())
        pasteAtCursor = !pasteAtCursor;
      if (pasteAtCursor)
        point = editor.inputs.currentPagePoint;
      if (e2.clipboardData && !editor.inputs.shiftKey) {
        handlePasteFromEventClipboardData(editor, e2.clipboardData, point);
      } else {
        navigator.clipboard.read().then((clipboardItems) => {
          if (Array.isArray(clipboardItems) && clipboardItems[0] instanceof ClipboardItem) {
            handlePasteFromClipboardApi(editor, clipboardItems, point);
          }
        });
      }
      preventDefault(e2);
      trackEvent("paste", { source: "kbd" });
    };
    document.addEventListener("copy", copy);
    document.addEventListener("cut", cut);
    document.addEventListener("paste", paste);
    document.addEventListener("pointerup", pointerUpHandler);
    return () => {
      document.removeEventListener("copy", copy);
      document.removeEventListener("cut", cut);
      document.removeEventListener("paste", paste);
      document.removeEventListener("pointerup", pointerUpHandler);
    };
  }, [editor, trackEvent, appIsFocused]);
}
var import_lz_string, import_react76, isValidHttpURL, getValidHttpURLList, isSvgText, INPUTS2, isFile, handleText, handlePasteFromEventClipboardData, handlePasteFromClipboardApi, handleNativeOrMenuCopy;
var init_useClipboardEvents = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useClipboardEvents.mjs"() {
    init_dist_esm10();
    import_lz_string = __toESM(require_lz_string(), 1);
    import_react76 = __toESM(require_react(), 1);
    init_events();
    init_pasteExcalidrawContent();
    init_pasteFiles();
    init_pasteTldrawContent();
    init_pasteUrl();
    isValidHttpURL = (url) => {
      try {
        const u2 = new URL(url);
        return u2.protocol === "http:" || u2.protocol === "https:";
      } catch (e2) {
        return false;
      }
    };
    getValidHttpURLList = (url) => {
      const urls = url.split(/[\n\s]/);
      for (const url2 of urls) {
        try {
          const u2 = new URL(url2);
          if (!(u2.protocol === "http:" || u2.protocol === "https:")) {
            return;
          }
        } catch (e2) {
          return;
        }
      }
      return uniq(urls);
    };
    isSvgText = (text) => {
      return /^<svg/.test(text);
    };
    INPUTS2 = ["input", "select", "textarea"];
    isFile = (item) => {
      return item.types.find((i2) => i2.match(/^image\//));
    };
    handleText = (editor, data, point, sources) => {
      const validUrlList = getValidHttpURLList(data);
      if (validUrlList) {
        for (const url of validUrlList) {
          pasteUrl(editor, url, point);
        }
      } else if (isValidHttpURL(data)) {
        pasteUrl(editor, data, point);
      } else if (isSvgText(data)) {
        editor.mark("paste");
        editor.putExternalContent({
          type: "svg-text",
          text: data,
          point,
          sources
        });
      } else {
        editor.mark("paste");
        editor.putExternalContent({
          type: "text",
          text: data,
          point,
          sources
        });
      }
    };
    handlePasteFromEventClipboardData = async (editor, clipboardData, point) => {
      if (editor.getEditingShapeId() !== null)
        return;
      if (!clipboardData) {
        throw Error("No clipboard data");
      }
      const things = [];
      for (const item of Object.values(clipboardData.items)) {
        switch (item.kind) {
          case "file": {
            things.push({
              type: "file",
              source: new Promise((r2) => r2(item.getAsFile()))
            });
            break;
          }
          case "string": {
            if (item.type === "text/html") {
              things.push({
                type: "html",
                source: new Promise((r2) => item.getAsString(r2))
              });
            } else if (item.type === "text/plain") {
              things.push({
                type: "text",
                source: new Promise((r2) => item.getAsString(r2))
              });
            } else {
              things.push({ type: item.type, source: new Promise((r2) => item.getAsString(r2)) });
            }
            break;
          }
        }
      }
      handleClipboardThings(editor, things, point);
    };
    handlePasteFromClipboardApi = async (editor, clipboardItems, point) => {
      const things = [];
      for (const item of clipboardItems) {
        if (isFile(item)) {
          for (const type of item.types) {
            if (type.match(/^image\//)) {
              things.push({ type: "blob", source: item.getType(type) });
            }
          }
        }
        if (item.types.includes("text/html")) {
          things.push({
            type: "html",
            source: (async () => {
              const blob = await item.getType("text/html");
              return await FileHelpers.blobToText(blob);
            })()
          });
        }
        if (item.types.includes("text/uri-list")) {
          things.push({
            type: "url",
            source: (async () => {
              const blob = await item.getType("text/uri-list");
              return await FileHelpers.blobToText(blob);
            })()
          });
        }
        if (item.types.includes("text/plain")) {
          things.push({
            type: "text",
            source: (async () => {
              const blob = await item.getType("text/plain");
              return await FileHelpers.blobToText(blob);
            })()
          });
        }
      }
      return await handleClipboardThings(editor, things, point);
    };
    handleNativeOrMenuCopy = async (editor) => {
      const content = await editor.resolveAssetsInContent(editor.getContentFromCurrentPage(editor.getSelectedShapeIds()));
      if (!content) {
        if (navigator && navigator.clipboard) {
          navigator.clipboard.writeText("");
        }
        return;
      }
      const stringifiedClipboard = import_lz_string.default.compressToBase64(JSON.stringify({
        type: "application/tldraw",
        kind: "content",
        data: content
      }));
      if (typeof navigator === "undefined") {
        return;
      } else {
        const textItems = content.shapes.map((shape) => {
          if (editor.isShapeOfType(shape, "text") || editor.isShapeOfType(shape, "geo") || editor.isShapeOfType(shape, "arrow")) {
            return shape.props.text;
          }
          if (editor.isShapeOfType(shape, "bookmark") || editor.isShapeOfType(shape, "embed")) {
            return shape.props.url;
          }
          return null;
        }).filter(isNonNull);
        if (navigator.clipboard?.write) {
          const htmlBlob = new Blob([`<div data-tldraw>${stringifiedClipboard}</div>`], {
            type: "text/html"
          });
          let textContent = textItems.join(" ");
          if (textContent === "") {
            textContent = " ";
          }
          navigator.clipboard.write([
            new ClipboardItem({
              "text/html": htmlBlob,
              "text/plain": new Blob([textContent], { type: "text/plain" })
            })
          ]);
        } else if (navigator.clipboard.writeText) {
          navigator.clipboard.writeText(`<div data-tldraw>${stringifiedClipboard}</div>`);
        }
      }
    };
  }
});

// node_modules/tldraw/dist-esm/lib/utils/export/export.mjs
async function getSvgAsImage(editor, svgString, options) {
  const { type, quality, scale, width, height } = options;
  let [clampedWidth, clampedHeight] = await clampToBrowserMaxCanvasSize(width * scale, height * scale);
  clampedWidth = Math.floor(clampedWidth);
  clampedHeight = Math.floor(clampedHeight);
  const effectiveScale = clampedWidth / width;
  const svgUrl = URL.createObjectURL(new Blob([svgString], { type: "image/svg+xml" }));
  const canvas = await new Promise((resolve) => {
    const image = Image();
    image.crossOrigin = "anonymous";
    image.onload = async () => {
      if (editor.environment.isSafari) {
        await new Promise((resolve2) => editor.timers.setTimeout(resolve2, 250));
      }
      const canvas2 = document.createElement("canvas");
      const ctx = canvas2.getContext("2d");
      canvas2.width = clampedWidth;
      canvas2.height = clampedHeight;
      ctx.imageSmoothingEnabled = true;
      ctx.imageSmoothingQuality = "high";
      ctx.drawImage(image, 0, 0, clampedWidth, clampedHeight);
      URL.revokeObjectURL(svgUrl);
      resolve(canvas2);
    };
    image.onerror = () => {
      resolve(null);
    };
    image.src = svgUrl;
  });
  if (!canvas)
    return null;
  const blob = await new Promise((resolve) => canvas.toBlob((blob2) => {
    if (!blob2 || debugFlags.throwToBlob.get()) {
      resolve(null);
    }
    resolve(blob2);
  }, "image/" + type, quality));
  if (!blob)
    return null;
  if (type === "png") {
    const view = new DataView(await blob.arrayBuffer());
    return PngHelpers.setPhysChunk(view, effectiveScale, {
      type: "image/" + type
    });
  } else {
    return blob;
  }
}
async function getSvgString(editor, ids, opts) {
  const svg = await editor.getSvgString(ids?.length ? ids : [...editor.getCurrentPageShapeIds()], {
    scale: 1,
    background: editor.getInstanceState().exportBackground,
    ...opts
  });
  if (!svg) {
    throw new Error("Could not construct SVG.");
  }
  return svg;
}
async function exportToString(editor, ids, format2, opts = {}) {
  switch (format2) {
    case "svg": {
      return (await getSvgString(editor, ids, opts))?.svg;
    }
    case "json": {
      const data = await editor.resolveAssetsInContent(editor.getContentFromCurrentPage(ids));
      return JSON.stringify(data);
    }
    default: {
      exhaustiveSwitchError(format2);
    }
  }
}
async function exportToBlob({
  editor,
  ids,
  format: format2,
  opts = {}
}) {
  switch (format2) {
    case "svg":
      return new Blob([await exportToString(editor, ids, "svg", opts)], { type: "text/plain" });
    case "json":
      return new Blob([await exportToString(editor, ids, "json", opts)], { type: "text/plain" });
    case "jpeg":
    case "png":
    case "webp": {
      const svgResult = await getSvgString(editor, ids, opts);
      if (!svgResult)
        throw new Error("Could not construct image.");
      const image = await getSvgAsImage(editor, svgResult.svg, {
        type: format2,
        quality: 1,
        scale: 2,
        width: svgResult.width,
        height: svgResult.height
      });
      if (!image) {
        throw new Error("Could not construct image.");
      }
      return image;
    }
    default: {
      exhaustiveSwitchError(format2);
    }
  }
}
function exportToBlobPromise(editor, ids, format2, opts = {}) {
  return {
    blobPromise: exportToBlob({ editor, ids, format: format2, opts }),
    mimeType: mimeTypeByFormat[format2]
  };
}
var mimeTypeByFormat;
var init_export = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/export/export.mjs"() {
    init_dist_esm10();
    init_getBrowserCanvasMaxSize();
    mimeTypeByFormat = {
      jpeg: "image/jpeg",
      png: "image/png",
      webp: "image/webp",
      json: "text/plain",
      svg: "text/plain"
    };
  }
});

// node_modules/tldraw/dist-esm/lib/utils/export/copyAs.mjs
function copyAs(editor, ids, format2 = "svg", opts = {}) {
  if (!window.navigator.clipboard)
    return Promise.reject(new Error("Copy not supported"));
  if (window.navigator.clipboard.write) {
    const { blobPromise, mimeType } = exportToBlobPromise(editor, ids, format2, opts);
    return window.navigator.clipboard.write([new ClipboardItem({ [mimeType]: blobPromise })]).catch((err) => {
      console.error(err);
      return blobPromise.then((blob) => {
        return window.navigator.clipboard.write([new ClipboardItem({ [mimeType]: blob })]);
      });
    });
  }
  switch (format2) {
    case "json":
    case "svg":
      return fallbackWriteTextAsync(async () => exportToString(editor, ids, format2, opts));
    case "jpeg":
    case "png":
      throw new Error("Copy not supported");
    default:
      exhaustiveSwitchError(format2);
  }
}
async function fallbackWriteTextAsync(getText) {
  await navigator.clipboard?.writeText?.(await getText());
}
var init_copyAs = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/export/copyAs.mjs"() {
    init_dist_esm10();
    init_export();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useCopyAs.mjs
function useCopyAs() {
  const editor = useEditor();
  const { addToast } = useToasts();
  const msg2 = useTranslation();
  return (0, import_react77.useCallback)((ids, format2 = "svg") => {
    copyAs(editor, ids, format2).catch(() => {
      addToast({
        id: "copy-fail",
        severity: "warning",
        title: msg2("toast.error.copy-fail.title"),
        description: msg2("toast.error.copy-fail.desc")
      });
    });
  }, [editor, addToast, msg2]);
}
var import_react77;
var init_useCopyAs = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useCopyAs.mjs"() {
    init_dist_esm10();
    import_react77 = __toESM(require_react(), 1);
    init_copyAs();
    init_toasts();
    init_useTranslation();
  }
});

// node_modules/tldraw/dist-esm/lib/utils/export/exportAs.mjs
async function exportAs(editor, ids, format2 = "png", name, opts = {}) {
  if (!name) {
    name = `shapes at ${getTimestamp2()}`;
    if (ids.length === 1) {
      const first = editor.getShape(ids[0]);
      if (editor.isShapeOfType(first, "frame")) {
        name = first.props.name ?? "frame";
      } else {
        name = `${first.id.replace(/:/, "_")} at ${getTimestamp2()}`;
      }
    }
  }
  name += `.${format2}`;
  const blob = await exportToBlob({ editor, ids, format: format2, opts });
  const file = new File([blob], name, { type: blob.type });
  downloadFile(file);
}
function getTimestamp2() {
  const now = /* @__PURE__ */ new Date();
  const year = String(now.getFullYear()).slice(2);
  const month = String(now.getMonth() + 1).padStart(2, "0");
  const day = String(now.getDate()).padStart(2, "0");
  const hours = String(now.getHours()).padStart(2, "0");
  const minutes = String(now.getMinutes()).padStart(2, "0");
  const seconds = String(now.getSeconds()).padStart(2, "0");
  return `${year}-${month}-${day} ${hours}.${minutes}.${seconds}`;
}
function downloadFile(file) {
  const link = document.createElement("a");
  const url = URL.createObjectURL(file);
  link.href = url;
  link.download = file.name;
  link.click();
  URL.revokeObjectURL(url);
}
var init_exportAs = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/export/exportAs.mjs"() {
    init_export();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useExportAs.mjs
function useExportAs() {
  const editor = useEditor();
  const { addToast } = useToasts();
  const msg2 = useTranslation();
  return (0, import_react78.useCallback)((ids, format2 = "png", name) => {
    exportAs(editor, ids, format2, name, {
      scale: 1,
      background: editor.getInstanceState().exportBackground
    }).catch((e2) => {
      console.error(e2.message);
      addToast({
        id: "export-fail",
        title: msg2("toast.error.export-fail.title"),
        description: msg2("toast.error.export-fail.desc"),
        severity: "error"
      });
    });
  }, [editor, addToast, msg2]);
}
var import_react78;
var init_useExportAs = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useExportAs.mjs"() {
    init_dist_esm10();
    import_react78 = __toESM(require_react(), 1);
    init_exportAs();
    init_toasts();
    init_useTranslation();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useFlatten.mjs
async function flattenShapesToImages(editor, shapeIds, flattenImageBoundsExpand) {
  const shapes = compact(shapeIds.map((id) => {
    const shape = editor.getShape(id);
    if (!shape)
      return;
    const util = editor.getShapeUtil(shape.type);
    if (util.toSvg === void 0)
      return;
    return shape;
  }));
  if (shapes.length === 0)
    return;
  if (shapes.length === 1) {
    const shape = shapes[0];
    if (!shape)
      return;
    if (editor.isShapeOfType(shape, "image"))
      return;
  }
  const groups = [];
  if (flattenImageBoundsExpand !== void 0) {
    const expandedBounds = shapes.map((shape) => {
      return {
        shape,
        bounds: editor.getShapeMaskedPageBounds(shape).clone().expandBy(flattenImageBoundsExpand)
      };
    });
    for (let i2 = 0; i2 < expandedBounds.length; i2++) {
      const item = expandedBounds[i2];
      if (i2 === 0) {
        groups[0] = {
          shapes: [item.shape],
          bounds: item.bounds
        };
        continue;
      }
      let didLand = false;
      for (const group of groups) {
        if (group.bounds.includes(item.bounds)) {
          group.shapes.push(item.shape);
          group.bounds.expand(item.bounds);
          didLand = true;
          break;
        }
      }
      if (!didLand) {
        groups.push({
          shapes: [item.shape],
          bounds: item.bounds
        });
      }
    }
  } else {
    const bounds = Box.Common(shapes.map((shape) => editor.getShapeMaskedPageBounds(shape)));
    groups.push({
      shapes,
      bounds
    });
  }
  const padding = editor.options.flattenImageBoundsPadding;
  for (const group of groups) {
    if (flattenImageBoundsExpand !== void 0) {
      group.bounds.expandBy(-flattenImageBoundsExpand);
    }
    const svgResult = await editor.getSvgString(group.shapes, {
      padding
    });
    if (!svgResult?.svg)
      continue;
    const blob = new Blob([svgResult.svg], { type: "image/svg+xml" });
    const asset = await editor.getAssetForExternalContent({
      type: "file",
      file: new File([blob], "asset.svg", { type: "image/svg+xml" })
    });
    if (!asset)
      continue;
    group.asset = asset;
  }
  const createdShapeIds = [];
  transact(() => {
    for (const group of groups) {
      const { asset, bounds, shapes: shapes2 } = group;
      if (!asset)
        continue;
      const commonAncestorId = editor.findCommonAncestor(shapes2) ?? editor.getCurrentPageId();
      if (!commonAncestorId)
        continue;
      let index3 = "a1";
      for (const shape of shapes2) {
        if (shape.parentId === commonAncestorId) {
          if (shape.index > index3) {
            index3 = shape.index;
          }
          break;
        }
      }
      let x2;
      let y2;
      let rotation;
      if (isShapeId(commonAncestorId)) {
        const commonAncestor = editor.getShape(commonAncestorId);
        if (!commonAncestor)
          continue;
        const point = editor.getPointInShapeSpace(commonAncestor, {
          x: bounds.x,
          y: bounds.y
        });
        rotation = editor.getShapePageTransform(commonAncestorId).rotation();
        point.sub(new Vec(padding, padding).rot(-rotation));
        x2 = point.x;
        y2 = point.y;
      } else {
        x2 = bounds.x - padding;
        y2 = bounds.y - padding;
        rotation = 0;
      }
      editor.deleteShapes(shapes2);
      editor.createAssets([{ ...asset, id: asset.id }]);
      const shapeId = createShapeId();
      editor.createShape({
        id: shapeId,
        type: "image",
        index: index3,
        parentId: commonAncestorId,
        x: x2,
        y: y2,
        rotation: -rotation,
        props: {
          assetId: asset.id,
          w: bounds.w + padding * 2,
          h: bounds.h + padding * 2
        }
      });
      createdShapeIds.push(shapeId);
    }
  });
  return createdShapeIds;
}
var import_react79;
var init_useFlatten = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useFlatten.mjs"() {
    init_dist_esm10();
    import_react79 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useIsMultiplayer.mjs
function useShowCollaborationUi() {
  const editor = useEditor();
  return editor.store.props.collaboration !== void 0;
}
function useCollaborationStatus() {
  const editor = useEditor();
  return useValue("sync status", () => {
    if (!editor.store.props.collaboration?.status) {
      return null;
    }
    return editor.store.props.collaboration.status.get();
  }, [editor]);
}
var init_useIsMultiplayer = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useIsMultiplayer.mjs"() {
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/usePrint.mjs
function usePrint() {
  const editor = useEditor();
  const prevPrintEl = (0, import_react80.useRef)(null);
  const prevStyleEl = (0, import_react80.useRef)(null);
  return (0, import_react80.useCallback)(async function printSelectionOrPages() {
    const el = document.createElement("div");
    const style = document.createElement("style");
    const clearElements = (printEl, styleEl) => {
      if (printEl)
        printEl.innerHTML = "";
      if (styleEl && document.head.contains(styleEl))
        document.head.removeChild(styleEl);
      if (printEl && document.body.contains(printEl)) {
        document.body.removeChild(printEl);
      }
    };
    clearElements(prevPrintEl.current, prevStyleEl.current);
    prevPrintEl.current = el;
    prevStyleEl.current = style;
    const className = `tl-print-surface-${uniqueId()}`;
    el.className = className;
    const enableMargins = false;
    const allowAllPages = false;
    style.innerHTML = `
			.${className} {
				display: none;
			}

			.${className} svg {
				max-width: 100%;
				height: 100%;
				display: block;
			}

			@media print {				  
				html, body {
					min-height: 100%;
					height: 100%;
					margin: 0;
				}

				body {
					position: relative;
				}

				body > * {
					display: none;
				}

				.tldraw__editor {
					display: none;
				}

				.${className} {
					display: block !important;
					background: white;
					min-height: 100%;
					height: 100%;
					max-width: 100%;
				}

				.${className}__item {
					padding: 10mm;
					display: flex;
					min-height: 100%;
					flex-direction: column;
					page-break-after: always;
					position: relative;
					overflow: hidden;
					height: 100%;
				}

				.${className}__item__main {
					flex: 1;
					display: flex;
					align-items: center;
					justify-content: center;
					max-height: 100%;
				}

				.${className}__item__header {
					display: none;
				}

				.${className}__item__footer {
					display: none;
					text-align: right;
				}

				.${className}__item__footer__hide {
					display: none;
				}

				${!enableMargins ? "" : `
					/**
					 * Note: Safari doesn't support removing the page margins to remove them all!
					 */
					@page {
						margin:0;
					}

					.${className} .${className}__item__header {
						display: block;
					}

					.${className} .${className}__item__footer {
						display: block;
					}
				`}
			}

		`;
    const beforePrintHandler = () => {
      document.head.appendChild(style);
      document.body.appendChild(el);
    };
    const afterPrintHandler = () => {
      editor.once("tick", () => {
        clearElements(el, style);
      });
    };
    window.addEventListener("beforeprint", beforePrintHandler);
    window.addEventListener("afterprint", afterPrintHandler);
    function addPageToPrint(title, footer, svg) {
      try {
        el.innerHTML += `<div class="${className}__item">
        <div class="${className}__item__header">
          ${title.replace(/</g, "&lt;").replace(/>/g, "&gt;")}
        </div>
        <div class="${className}__item__main">
          ${svg}
        </div>
        <div class="${className}__item__footer ${className}__item__footer__${footer ? "" : "hide"}">
          ${footer ?? ""}
        </div>
      </div>`;
      } catch (e2) {
        console.error(e2);
      }
    }
    function triggerPrint() {
      if (editor.environment.isChromeForIos) {
        beforePrintHandler();
        window.print();
      } else if (editor.environment.isSafari) {
        beforePrintHandler();
        document.execCommand("print", false);
      } else {
        window.print();
      }
    }
    const selectedShapeIds = editor.getSelectedShapeIds();
    const currentPageId = editor.getCurrentPageId();
    const pages = editor.getPages();
    const preserveAspectRatio = "xMidYMid meet";
    const svgOpts = {
      scale: 1,
      background: false,
      darkMode: false,
      preserveAspectRatio
    };
    if (editor.getSelectedShapeIds().length > 0) {
      const svgExport = await editor.getSvgString(selectedShapeIds, svgOpts);
      if (svgExport) {
        const page = pages.find((p2) => p2.id === currentPageId);
        addPageToPrint(`tldraw \u2014 ${page?.name}`, null, svgExport.svg);
        triggerPrint();
      }
    } else {
      if (allowAllPages) {
        for (let i2 = 0; i2 < pages.length; i2++) {
          const page = pages[i2];
          const svgExport = await editor.getSvgString(editor.getSortedChildIdsForParent(page.id), svgOpts);
          if (svgExport) {
            addPageToPrint(`tldraw \u2014 ${page.name}`, `${i2}/${pages.length}`, svgExport.svg);
          }
        }
        triggerPrint();
      } else {
        const page = editor.getCurrentPage();
        const svgExport = await editor.getSvgString(editor.getSortedChildIdsForParent(page.id), svgOpts);
        if (svgExport) {
          addPageToPrint(`tldraw \u2014 ${page.name}`, null, svgExport.svg);
          triggerPrint();
        }
      }
    }
    window.removeEventListener("beforeprint", beforePrintHandler);
    window.removeEventListener("afterprint", afterPrintHandler);
  }, [editor]);
}
var import_react80;
var init_usePrint = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/usePrint.mjs"() {
    init_dist_esm10();
    import_react80 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/actions.mjs
function makeActions(actions) {
  return Object.fromEntries(actions.map((action) => [action.id, action]));
}
function getExportName(editor, defaultName) {
  const selectedShapes = editor.getSelectedShapes();
  if (selectedShapes.length === 0) {
    return editor.getDocumentSettings().name || defaultName;
  }
  return void 0;
}
function ActionsProvider({ overrides, children }) {
  const editor = useEditor();
  const showCollaborationUi = useShowCollaborationUi();
  const { addDialog, clearDialogs } = useDialogs();
  const { clearToasts, addToast } = useToasts();
  const msg2 = useTranslation();
  const insertMedia = useInsertMedia();
  const printSelectionOrPages = usePrint();
  const { cut, copy, paste } = useMenuClipboardEvents();
  const copyAs2 = useCopyAs();
  const exportAs2 = useExportAs();
  const defaultDocumentName = msg2("document.default-name");
  const trackEvent = useUiEvents();
  const actions = React50.useMemo(() => {
    function mustGoBackToSelectToolFirst() {
      if (!editor.isIn("select")) {
        editor.complete();
        editor.setCurrentTool("select");
        return false;
      }
      return false;
    }
    function canApplySelectionAction() {
      return editor.isIn("select") && editor.getSelectedShapeIds().length > 0;
    }
    const actionItems = [
      {
        id: "edit-link",
        label: "action.edit-link",
        icon: "link",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("edit-link", { source });
          editor.mark("edit-link");
          addDialog({ component: EditLinkDialog });
        }
      },
      {
        id: "insert-embed",
        label: "action.insert-embed",
        kbd: "$i",
        onSelect(source) {
          trackEvent("insert-embed", { source });
          addDialog({ component: EmbedDialog });
        }
      },
      {
        id: "insert-media",
        label: "action.insert-media",
        kbd: "$u",
        onSelect(source) {
          trackEvent("insert-media", { source });
          insertMedia();
        }
      },
      {
        id: "undo",
        label: "action.undo",
        icon: "undo",
        kbd: "$z",
        onSelect(source) {
          trackEvent("undo", { source });
          editor.undo();
        }
      },
      {
        id: "redo",
        label: "action.redo",
        icon: "redo",
        kbd: "$!z",
        onSelect(source) {
          trackEvent("redo", { source });
          editor.redo();
        }
      },
      {
        id: "export-as-svg",
        label: {
          default: "action.export-as-svg",
          menu: "action.export-as-svg.short",
          ["context-menu"]: "action.export-as-svg.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-as", { format: "svg", source });
          exportAs2(ids, "svg", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "export-as-png",
        label: {
          default: "action.export-as-png",
          menu: "action.export-as-png.short",
          ["context-menu"]: "action.export-as-png.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-as", { format: "png", source });
          exportAs2(ids, "png", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "export-as-json",
        label: {
          default: "action.export-as-json",
          menu: "action.export-as-json.short",
          ["context-menu"]: "action.export-as-json.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-as", { format: "json", source });
          exportAs2(ids, "json", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "export-all-as-svg",
        label: {
          default: "action.export-all-as-svg",
          menu: "action.export-all-as-svg.short",
          ["context-menu"]: "action.export-all-as-svg.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-all-as", { format: "svg", source });
          exportAs2(Array.from(editor.getCurrentPageShapeIds()), "svg", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "export-all-as-png",
        label: {
          default: "action.export-all-as-png",
          menu: "action.export-all-as-png.short",
          ["context-menu"]: "action.export-all-as-png.short"
        },
        readonlyOk: true,
        onSelect(source) {
          const ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-all-as", { format: "png", source });
          exportAs2(ids, "png", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "export-all-as-json",
        label: {
          default: "action.export-all-as-json",
          menu: "action.export-all-as-json.short",
          ["context-menu"]: "action.export-all-as-json.short"
        },
        readonlyOk: true,
        onSelect(source) {
          const ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("export-all-as", { format: "json", source });
          exportAs2(ids, "json", getExportName(editor, defaultDocumentName));
        }
      },
      {
        id: "copy-as-svg",
        label: {
          default: "action.copy-as-svg",
          menu: "action.copy-as-svg.short",
          ["context-menu"]: "action.copy-as-svg.short"
        },
        kbd: "$!c",
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("copy-as", { format: "svg", source });
          copyAs2(ids, "svg");
        }
      },
      {
        id: "copy-as-png",
        label: {
          default: "action.copy-as-png",
          menu: "action.copy-as-png.short",
          ["context-menu"]: "action.copy-as-png.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("copy-as", { format: "png", source });
          copyAs2(ids, "png");
        }
      },
      {
        id: "copy-as-json",
        label: {
          default: "action.copy-as-json",
          menu: "action.copy-as-json.short",
          ["context-menu"]: "action.copy-as-json.short"
        },
        readonlyOk: true,
        onSelect(source) {
          let ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            ids = Array.from(editor.getCurrentPageShapeIds().values());
          if (ids.length === 0)
            return;
          trackEvent("copy-as", { format: "json", source });
          copyAs2(ids, "json");
        }
      },
      {
        id: "toggle-auto-size",
        label: "action.toggle-auto-size",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("toggle-auto-size", { source });
          editor.mark("toggling auto size");
          const shapes = editor.getSelectedShapes().filter((shape) => editor.isShapeOfType(shape, "text") && shape.props.autoSize === false);
          editor.updateShapes(shapes.map((shape) => {
            return {
              id: shape.id,
              type: shape.type,
              props: {
                ...shape.props,
                w: 8,
                autoSize: true
              }
            };
          }));
          kickoutOccludedShapes(editor, shapes.map((shape) => shape.id));
        }
      },
      {
        id: "open-embed-link",
        label: "action.open-embed-link",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("open-embed-link", { source });
          const ids = editor.getSelectedShapeIds();
          const warnMsg = "No embed shapes selected";
          if (ids.length !== 1) {
            console.error(warnMsg);
            return;
          }
          const shape = editor.getShape(ids[0]);
          if (!shape || !editor.isShapeOfType(shape, "embed")) {
            console.error(warnMsg);
            return;
          }
          openWindow(shape.props.url, "_blank");
        }
      },
      {
        id: "select-zoom-tool",
        readonlyOk: true,
        kbd: "z",
        onSelect(source) {
          if (editor.root.getCurrent()?.id === "zoom")
            return;
          trackEvent("zoom-tool", { source });
          if (!(editor.inputs.shiftKey || editor.inputs.ctrlKey)) {
            const currentTool = editor.root.getCurrent();
            if (currentTool && currentTool.getCurrent()?.id === "idle") {
              editor.setCurrentTool("zoom", { onInteractionEnd: currentTool.id, maskAs: "zoom" });
            }
          }
        }
      },
      {
        id: "convert-to-bookmark",
        label: "action.convert-to-bookmark",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          editor.run(() => {
            trackEvent("convert-to-bookmark", { source });
            const shapes = editor.getSelectedShapes();
            const createList = [];
            const deleteList = [];
            for (const shape of shapes) {
              if (!shape || !editor.isShapeOfType(shape, "embed") || !shape.props.url)
                continue;
              const newPos = new Vec(shape.x, shape.y);
              newPos.rot(-shape.rotation);
              newPos.add(new Vec(shape.props.w / 2 - 300 / 2, shape.props.h / 2 - 320 / 2));
              newPos.rot(shape.rotation);
              const partial = {
                id: createShapeId(),
                type: "bookmark",
                rotation: shape.rotation,
                x: newPos.x,
                y: newPos.y,
                opacity: 1,
                props: {
                  url: shape.props.url
                }
              };
              createList.push(partial);
              deleteList.push(shape.id);
            }
            editor.mark("convert shapes to bookmark");
            editor.deleteShapes(deleteList);
            editor.createShapes(createList);
          });
        }
      },
      {
        id: "convert-to-embed",
        label: "action.convert-to-embed",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("convert-to-embed", { source });
          editor.run(() => {
            const ids = editor.getSelectedShapeIds();
            const shapes = compact(ids.map((id) => editor.getShape(id)));
            const createList = [];
            const deleteList = [];
            for (const shape of shapes) {
              if (!editor.isShapeOfType(shape, "bookmark"))
                continue;
              const { url } = shape.props;
              const embedInfo = getEmbedInfo(shape.props.url);
              if (!embedInfo)
                continue;
              if (!embedInfo.definition)
                continue;
              const { width, height } = embedInfo.definition;
              const newPos = new Vec(shape.x, shape.y);
              newPos.rot(-shape.rotation);
              newPos.add(new Vec(shape.props.w / 2 - width / 2, shape.props.h / 2 - height / 2));
              newPos.rot(shape.rotation);
              const shapeToCreate = {
                id: createShapeId(),
                type: "embed",
                x: newPos.x,
                y: newPos.y,
                rotation: shape.rotation,
                props: {
                  url,
                  w: width,
                  h: height
                }
              };
              createList.push(shapeToCreate);
              deleteList.push(shape.id);
            }
            editor.mark("convert shapes to embed");
            editor.deleteShapes(deleteList);
            editor.createShapes(createList);
          });
        }
      },
      {
        id: "duplicate",
        kbd: "$d",
        label: "action.duplicate",
        icon: "duplicate",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("duplicate-shapes", { source });
          const instanceState = editor.getInstanceState();
          let ids;
          let offset5;
          if (instanceState.duplicateProps) {
            ids = instanceState.duplicateProps.shapeIds;
            offset5 = instanceState.duplicateProps.offset;
          } else {
            ids = editor.getSelectedShapeIds();
            const commonBounds = Box.Common(compact(ids.map((id) => editor.getShapePageBounds(id))));
            offset5 = editor.getCameraOptions().isLocked ? {
              x: editor.options.adjacentShapeMargin,
              y: editor.options.adjacentShapeMargin
            } : {
              x: commonBounds.width + editor.options.adjacentShapeMargin,
              y: 0
            };
          }
          editor.mark("duplicate shapes");
          editor.duplicateShapes(ids, offset5);
          if (instanceState.duplicateProps) {
            editor.updateInstanceState({
              duplicateProps: {
                ...instanceState.duplicateProps,
                shapeIds: editor.getSelectedShapeIds()
              }
            });
          }
        }
      },
      {
        id: "ungroup",
        label: "action.ungroup",
        kbd: "$!g",
        icon: "ungroup",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("ungroup-shapes", { source });
          editor.mark("ungroup");
          editor.ungroupShapes(editor.getSelectedShapeIds());
        }
      },
      {
        id: "group",
        label: "action.group",
        kbd: "$g",
        icon: "group",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("group-shapes", { source });
          const onlySelectedShape = editor.getOnlySelectedShape();
          if (onlySelectedShape && editor.isShapeOfType(onlySelectedShape, "group")) {
            editor.mark("ungroup");
            editor.ungroupShapes(editor.getSelectedShapeIds());
          } else {
            editor.mark("group");
            editor.groupShapes(editor.getSelectedShapeIds());
          }
        }
      },
      {
        id: "remove-frame",
        label: "action.remove-frame",
        kbd: "$!f",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          trackEvent("remove-frame", { source });
          const selectedShapes = editor.getSelectedShapes();
          if (selectedShapes.length > 0 && selectedShapes.every((shape) => editor.isShapeOfType(shape, "frame"))) {
            editor.mark("remove-frame");
            removeFrame(editor, selectedShapes.map((shape) => shape.id));
          }
        }
      },
      {
        id: "fit-frame-to-content",
        label: "action.fit-frame-to-content",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          trackEvent("fit-frame-to-content", { source });
          const onlySelectedShape = editor.getOnlySelectedShape();
          if (onlySelectedShape && editor.isShapeOfType(onlySelectedShape, "frame")) {
            editor.mark("fit-frame-to-content");
            fitFrameToContent(editor, onlySelectedShape.id);
          }
        }
      },
      {
        id: "align-left",
        label: "action.align-left",
        kbd: "?A",
        icon: "align-left",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "left", source });
          editor.mark("align left");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "left");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "align-center-horizontal",
        label: {
          default: "action.align-center-horizontal",
          ["context-menu"]: "action.align-center-horizontal.short"
        },
        kbd: "?H",
        icon: "align-center-horizontal",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "center-horizontal", source });
          editor.mark("align center horizontal");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "center-horizontal");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "align-right",
        label: "action.align-right",
        kbd: "?D",
        icon: "align-right",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "right", source });
          editor.mark("align right");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "right");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "align-center-vertical",
        label: {
          default: "action.align-center-vertical",
          ["context-menu"]: "action.align-center-vertical.short"
        },
        kbd: "?V",
        icon: "align-center-vertical",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "center-vertical", source });
          editor.mark("align center vertical");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "center-vertical");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "align-top",
        label: "action.align-top",
        icon: "align-top",
        kbd: "?W",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "top", source });
          editor.mark("align top");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "top");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "align-bottom",
        label: "action.align-bottom",
        icon: "align-bottom",
        kbd: "?S",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("align-shapes", { operation: "bottom", source });
          editor.mark("align bottom");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.alignShapes(selectedShapeIds, "bottom");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "distribute-horizontal",
        label: {
          default: "action.distribute-horizontal",
          ["context-menu"]: "action.distribute-horizontal.short"
        },
        icon: "distribute-horizontal",
        kbd: "?!h",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("distribute-shapes", { operation: "horizontal", source });
          editor.mark("distribute horizontal");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.distributeShapes(selectedShapeIds, "horizontal");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "distribute-vertical",
        label: {
          default: "action.distribute-vertical",
          ["context-menu"]: "action.distribute-vertical.short"
        },
        icon: "distribute-vertical",
        kbd: "?!V",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("distribute-shapes", { operation: "vertical", source });
          editor.mark("distribute vertical");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.distributeShapes(selectedShapeIds, "vertical");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "stretch-horizontal",
        label: {
          default: "action.stretch-horizontal",
          ["context-menu"]: "action.stretch-horizontal.short"
        },
        icon: "stretch-horizontal",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("stretch-shapes", { operation: "horizontal", source });
          editor.mark("stretch horizontal");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.stretchShapes(selectedShapeIds, "horizontal");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "stretch-vertical",
        label: {
          default: "action.stretch-vertical",
          ["context-menu"]: "action.stretch-vertical.short"
        },
        icon: "stretch-vertical",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("stretch-shapes", { operation: "vertical", source });
          editor.mark("stretch vertical");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.stretchShapes(selectedShapeIds, "vertical");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "flip-horizontal",
        label: {
          default: "action.flip-horizontal",
          ["context-menu"]: "action.flip-horizontal.short"
        },
        kbd: "!h",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("flip-shapes", { operation: "horizontal", source });
          editor.mark("flip horizontal");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.flipShapes(selectedShapeIds, "horizontal");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "flip-vertical",
        label: { default: "action.flip-vertical", ["context-menu"]: "action.flip-vertical.short" },
        kbd: "!v",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("flip-shapes", { operation: "vertical", source });
          editor.mark("flip vertical");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.flipShapes(selectedShapeIds, "vertical");
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "pack",
        label: "action.pack",
        icon: "pack",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("pack-shapes", { source });
          editor.mark("pack");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.packShapes(selectedShapeIds, editor.options.adjacentShapeMargin);
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "stack-vertical",
        label: {
          default: "action.stack-vertical",
          ["context-menu"]: "action.stack-vertical.short"
        },
        icon: "stack-vertical",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("stack-shapes", { operation: "vertical", source });
          editor.mark("stack-vertical");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.stackShapes(selectedShapeIds, "vertical", 16);
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "stack-horizontal",
        label: {
          default: "action.stack-horizontal",
          ["context-menu"]: "action.stack-horizontal.short"
        },
        icon: "stack-horizontal",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("stack-shapes", { operation: "horizontal", source });
          editor.mark("stack-horizontal");
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.stackShapes(selectedShapeIds, "horizontal", 16);
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "bring-to-front",
        label: "action.bring-to-front",
        kbd: "]",
        icon: "bring-to-front",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("reorder-shapes", { operation: "toFront", source });
          editor.mark("bring to front");
          editor.bringToFront(editor.getSelectedShapeIds());
        }
      },
      {
        id: "bring-forward",
        label: "action.bring-forward",
        icon: "bring-forward",
        kbd: "?]",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("reorder-shapes", { operation: "forward", source });
          editor.mark("bring forward");
          editor.bringForward(editor.getSelectedShapeIds());
        }
      },
      {
        id: "send-backward",
        label: "action.send-backward",
        icon: "send-backward",
        kbd: "?[",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("reorder-shapes", { operation: "backward", source });
          editor.mark("send backward");
          editor.sendBackward(editor.getSelectedShapeIds());
        }
      },
      {
        id: "send-to-back",
        label: "action.send-to-back",
        icon: "send-to-back",
        kbd: "[",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("reorder-shapes", { operation: "toBack", source });
          editor.mark("send to back");
          editor.sendToBack(editor.getSelectedShapeIds());
        }
      },
      {
        id: "cut",
        label: "action.cut",
        kbd: "$x",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          editor.mark("cut");
          cut(source);
        }
      },
      {
        id: "copy",
        label: "action.copy",
        kbd: "$c",
        readonlyOk: true,
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          copy(source);
        }
      },
      {
        id: "paste",
        label: "action.paste",
        kbd: "$v",
        onSelect(source) {
          navigator.clipboard?.read().then((clipboardItems) => {
            paste(clipboardItems, source, source === "context-menu" ? editor.inputs.currentPagePoint : void 0);
          }).catch(() => {
            addToast({
              title: msg2("action.paste-error-title"),
              description: msg2("action.paste-error-description"),
              severity: "error"
            });
          });
        }
      },
      {
        id: "select-all",
        label: "action.select-all",
        kbd: "$a",
        readonlyOk: true,
        onSelect(source) {
          editor.run(() => {
            if (mustGoBackToSelectToolFirst())
              return;
            trackEvent("select-all-shapes", { source });
            editor.mark("select all kbd");
            editor.selectAll();
          });
        }
      },
      {
        id: "select-none",
        label: "action.select-none",
        readonlyOk: true,
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("select-none-shapes", { source });
          editor.mark("select none");
          editor.selectNone();
        }
      },
      {
        id: "delete",
        label: "action.delete",
        kbd: "\u232B,del,backspace",
        icon: "trash",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("delete-shapes", { source });
          editor.mark("delete");
          editor.deleteShapes(editor.getSelectedShapeIds());
        }
      },
      {
        id: "rotate-cw",
        label: "action.rotate-cw",
        icon: "rotate-cw",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("rotate-cw", { source });
          editor.mark("rotate-cw");
          const offset5 = editor.getSelectionRotation() % (HALF_PI / 2);
          const dontUseOffset = approximately(offset5, 0) || approximately(offset5, HALF_PI / 2);
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.rotateShapesBy(selectedShapeIds, HALF_PI / 2 - (dontUseOffset ? 0 : offset5));
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "rotate-ccw",
        label: "action.rotate-ccw",
        icon: "rotate-ccw",
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("rotate-ccw", { source });
          editor.mark("rotate-ccw");
          const offset5 = editor.getSelectionRotation() % (HALF_PI / 2);
          const offsetCloseToZero = approximately(offset5, 0);
          const selectedShapeIds = editor.getSelectedShapeIds();
          editor.rotateShapesBy(selectedShapeIds, offsetCloseToZero ? -(HALF_PI / 2) : -offset5);
          kickoutOccludedShapes(editor, selectedShapeIds);
        }
      },
      {
        id: "zoom-in",
        label: "action.zoom-in",
        kbd: "$=,=",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("zoom-in", { source });
          editor.zoomIn(void 0, {
            animation: { duration: editor.options.animationMediumMs }
          });
        }
      },
      {
        id: "zoom-out",
        label: "action.zoom-out",
        kbd: "$-,-",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("zoom-out", { source });
          editor.zoomOut(void 0, {
            animation: { duration: editor.options.animationMediumMs }
          });
        }
      },
      {
        id: "zoom-to-100",
        label: "action.zoom-to-100",
        icon: "reset-zoom",
        kbd: "!0",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("reset-zoom", { source });
          editor.resetZoom(void 0, {
            animation: { duration: editor.options.animationMediumMs }
          });
        }
      },
      {
        id: "zoom-to-fit",
        label: "action.zoom-to-fit",
        kbd: "!1",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("zoom-to-fit", { source });
          editor.zoomToFit({ animation: { duration: editor.options.animationMediumMs } });
        }
      },
      {
        id: "zoom-to-selection",
        label: "action.zoom-to-selection",
        kbd: "!2",
        readonlyOk: true,
        onSelect(source) {
          if (!canApplySelectionAction())
            return;
          if (mustGoBackToSelectToolFirst())
            return;
          trackEvent("zoom-to-selection", { source });
          editor.zoomToSelection({ animation: { duration: editor.options.animationMediumMs } });
        }
      },
      {
        id: "toggle-snap-mode",
        label: {
          default: "action.toggle-snap-mode",
          menu: "action.toggle-snap-mode.menu"
        },
        onSelect(source) {
          trackEvent("toggle-snap-mode", { source });
          editor.user.updateUserPreferences({ isSnapMode: !editor.user.getIsSnapMode() });
        },
        checkbox: true
      },
      {
        id: "toggle-dark-mode",
        label: {
          default: "action.toggle-dark-mode",
          menu: "action.toggle-dark-mode.menu"
        },
        kbd: "$/",
        readonlyOk: true,
        onSelect(source) {
          const value = editor.user.getIsDarkMode() ? "light" : "dark";
          trackEvent("color-scheme", { source, value });
          editor.user.updateUserPreferences({
            colorScheme: value
          });
        },
        checkbox: true
      },
      {
        id: "toggle-wrap-mode",
        label: {
          default: "action.toggle-wrap-mode",
          menu: "action.toggle-wrap-mode.menu"
        },
        readonlyOk: true,
        onSelect(source) {
          trackEvent("toggle-wrap-mode", { source });
          editor.user.updateUserPreferences({
            isWrapMode: !editor.user.getIsWrapMode()
          });
        },
        checkbox: true
      },
      {
        id: "toggle-dynamic-size-mode",
        label: {
          default: "action.toggle-dynamic-size-mode",
          menu: "action.toggle-dynamic-size-mode.menu"
        },
        readonlyOk: false,
        onSelect(source) {
          trackEvent("toggle-dynamic-size-mode", { source });
          editor.user.updateUserPreferences({
            isDynamicSizeMode: !editor.user.getIsDynamicResizeMode()
          });
        },
        checkbox: true
      },
      {
        id: "toggle-paste-at-cursor",
        label: {
          default: "action.toggle-paste-at-cursor",
          menu: "action.toggle-paste-at-cursor.menu"
        },
        readonlyOk: false,
        onSelect(source) {
          trackEvent("toggle-paste-at-cursor", { source });
          editor.user.updateUserPreferences({
            isPasteAtCursorMode: !editor.user.getIsPasteAtCursorMode()
          });
        },
        checkbox: true
      },
      {
        id: "toggle-reduce-motion",
        label: {
          default: "action.toggle-reduce-motion",
          menu: "action.toggle-reduce-motion.menu"
        },
        readonlyOk: true,
        onSelect(source) {
          trackEvent("toggle-reduce-motion", { source });
          editor.user.updateUserPreferences({
            animationSpeed: editor.user.getAnimationSpeed() === 0 ? 1 : 0
          });
        },
        checkbox: true
      },
      {
        id: "toggle-edge-scrolling",
        label: {
          default: "action.toggle-edge-scrolling",
          menu: "action.toggle-edge-scrolling.menu"
        },
        readonlyOk: true,
        onSelect(source) {
          trackEvent("toggle-edge-scrolling", { source });
          editor.user.updateUserPreferences({
            edgeScrollSpeed: editor.user.getEdgeScrollSpeed() === 0 ? 1 : 0
          });
        },
        checkbox: true
      },
      {
        id: "toggle-transparent",
        label: {
          default: "action.toggle-transparent",
          menu: "action.toggle-transparent.menu",
          ["context-menu"]: "action.toggle-transparent.context-menu"
        },
        readonlyOk: true,
        onSelect(source) {
          trackEvent("toggle-transparent", { source });
          editor.updateInstanceState({
            exportBackground: !editor.getInstanceState().exportBackground
          });
        },
        checkbox: true
      },
      {
        id: "toggle-tool-lock",
        label: {
          default: "action.toggle-tool-lock",
          menu: "action.toggle-tool-lock.menu"
        },
        kbd: "q",
        onSelect(source) {
          trackEvent("toggle-tool-lock", { source });
          editor.updateInstanceState({ isToolLocked: !editor.getInstanceState().isToolLocked });
        },
        checkbox: true
      },
      {
        id: "unlock-all",
        label: "action.unlock-all",
        onSelect(source) {
          trackEvent("unlock-all", { source });
          const updates = [];
          for (const shape of editor.getCurrentPageShapes()) {
            if (shape.isLocked) {
              updates.push({ id: shape.id, type: shape.type, isLocked: false });
            }
          }
          if (updates.length > 0) {
            editor.updateShapes(updates);
          }
        }
      },
      {
        id: "toggle-focus-mode",
        label: {
          default: "action.toggle-focus-mode",
          menu: "action.toggle-focus-mode.menu"
        },
        readonlyOk: true,
        kbd: "$.",
        checkbox: true,
        onSelect(source) {
          editor.timers.requestAnimationFrame(() => {
            editor.run(() => {
              trackEvent("toggle-focus-mode", { source });
              clearDialogs();
              clearToasts();
              editor.updateInstanceState({ isFocusMode: !editor.getInstanceState().isFocusMode });
            });
          });
        }
      },
      {
        id: "toggle-grid",
        label: {
          default: "action.toggle-grid",
          menu: "action.toggle-grid.menu"
        },
        readonlyOk: true,
        kbd: "$'",
        onSelect(source) {
          trackEvent("toggle-grid-mode", { source });
          editor.updateInstanceState({ isGridMode: !editor.getInstanceState().isGridMode });
        },
        checkbox: true
      },
      {
        id: "toggle-debug-mode",
        label: {
          default: "action.toggle-debug-mode",
          menu: "action.toggle-debug-mode.menu"
        },
        readonlyOk: true,
        onSelect(source) {
          trackEvent("toggle-debug-mode", { source });
          editor.updateInstanceState({
            isDebugMode: !editor.getInstanceState().isDebugMode
          });
        },
        checkbox: true
      },
      {
        id: "print",
        label: "action.print",
        kbd: "$p",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("print", { source });
          printSelectionOrPages();
        }
      },
      {
        id: "exit-pen-mode",
        label: "action.exit-pen-mode",
        icon: "cross-2",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("exit-pen-mode", { source });
          editor.updateInstanceState({ isPenMode: false });
        }
      },
      {
        id: "stop-following",
        label: "action.stop-following",
        icon: "cross-2",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("stop-following", { source });
          editor.stopFollowingUser();
        }
      },
      {
        id: "back-to-content",
        label: "action.back-to-content",
        icon: "arrow-left",
        readonlyOk: true,
        onSelect(source) {
          trackEvent("zoom-to-content", { source });
          const bounds = editor.getSelectionPageBounds() ?? editor.getCurrentPageBounds();
          if (!bounds)
            return;
          editor.zoomToBounds(bounds, {
            targetZoom: Math.min(1, editor.getZoomLevel()),
            animation: { duration: 220 }
          });
        }
      },
      {
        id: "toggle-lock",
        label: "action.toggle-lock",
        kbd: "!l",
        onSelect(source) {
          editor.mark("locking");
          trackEvent("toggle-lock", { source });
          editor.toggleLock(editor.getSelectedShapeIds());
        }
      },
      {
        id: "move-to-new-page",
        label: "context.pages.new-page",
        onSelect(source) {
          const newPageId = PageRecordType.createId();
          const ids = editor.getSelectedShapeIds();
          editor.run(() => {
            editor.mark("move_shapes_to_page");
            editor.createPage({ name: msg2("page-menu.new-page-initial-name"), id: newPageId });
            editor.moveShapesToPage(ids, newPageId);
          });
          trackEvent("move-to-new-page", { source });
        }
      },
      {
        id: "select-white-color",
        label: "color-style.white",
        kbd: "?t",
        onSelect(source) {
          const style = DefaultColorStyle;
          editor.run(() => {
            editor.mark("change-color");
            if (editor.isIn("select")) {
              editor.setStyleForSelectedShapes(style, "white");
            }
            editor.setStyleForNextShapes(style, "white");
          });
          trackEvent("set-style", { source, id: style.id, value: "white" });
        }
      },
      {
        id: "select-fill-fill",
        label: "fill-style.fill",
        kbd: "?f",
        onSelect(source) {
          const style = DefaultFillStyle;
          editor.run(() => {
            editor.mark("change-fill");
            if (editor.isIn("select")) {
              editor.setStyleForSelectedShapes(style, "fill");
            }
            editor.setStyleForNextShapes(style, "fill");
          });
          trackEvent("set-style", { source, id: style.id, value: "fill" });
        }
      },
      {
        id: "flatten-to-image",
        label: "action.flatten-to-image",
        kbd: "!f",
        onSelect: async (source) => {
          const ids = editor.getSelectedShapeIds();
          if (ids.length === 0)
            return;
          editor.mark("flattening to image");
          trackEvent("flatten-to-image", { source });
          const newShapeIds = await flattenShapesToImages(editor, ids, editor.options.flattenImageBoundsExpand);
          if (newShapeIds?.length) {
            editor.setSelectedShapes(newShapeIds);
          }
        }
      }
    ];
    if (showCollaborationUi) {
      actionItems.push({
        id: "open-cursor-chat",
        label: "action.open-cursor-chat",
        readonlyOk: true,
        kbd: "/",
        onSelect(source) {
          trackEvent("open-cursor-chat", { source });
          if (editor.getInstanceState().isCoarsePointer) {
            return;
          }
          editor.timers.requestAnimationFrame(() => {
            editor.updateInstanceState({ isChatting: true });
          });
        }
      });
    }
    const actions2 = makeActions(actionItems);
    if (overrides) {
      return overrides(editor, actions2, void 0);
    }
    return actions2;
  }, [
    editor,
    trackEvent,
    overrides,
    addDialog,
    addToast,
    insertMedia,
    exportAs2,
    copyAs2,
    cut,
    copy,
    paste,
    clearDialogs,
    clearToasts,
    printSelectionOrPages,
    msg2,
    defaultDocumentName,
    showCollaborationUi
  ]);
  return /* @__PURE__ */ (0, import_jsx_runtime92.jsx)(ActionsContext.Provider, { value: asActions(actions), children });
}
function useActions() {
  const ctx = React50.useContext(ActionsContext);
  if (!ctx) {
    throw new Error("useTools must be used within a ToolProvider");
  }
  return ctx;
}
function asActions(actions) {
  return actions;
}
function unwrapLabel(label, menuType) {
  return label ? typeof label === "string" ? label : menuType ? label[menuType] ?? label["default"] : void 0 : void 0;
}
var import_jsx_runtime92, React50, ActionsContext;
var init_actions = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/actions.mjs"() {
    import_jsx_runtime92 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    React50 = __toESM(require_react(), 1);
    init_selectHelpers();
    init_embeds();
    init_frames();
    init_EditLinkDialog();
    init_EmbedDialog();
    init_useClipboardEvents();
    init_useCopyAs();
    init_useExportAs();
    init_useFlatten();
    init_useInsertMedia();
    init_useIsMultiplayer();
    init_usePrint();
    init_useTranslation();
    init_dialogs();
    init_events();
    init_toasts();
    ActionsContext = React50.createContext(null);
  }
});

// node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
function clamp2(start2, value, end2) {
  return max(start2, min2(value, end2));
}
function evaluate(value, param) {
  return typeof value === "function" ? value(param) : value;
}
function getSide(placement) {
  return placement.split("-")[0];
}
function getAlignment(placement) {
  return placement.split("-")[1];
}
function getOppositeAxis(axis) {
  return axis === "x" ? "y" : "x";
}
function getAxisLength(axis) {
  return axis === "y" ? "height" : "width";
}
function getSideAxis(placement) {
  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
}
function getAlignmentAxis(placement) {
  return getOppositeAxis(getSideAxis(placement));
}
function getAlignmentSides(placement, rects, rtl) {
  if (rtl === void 0) {
    rtl = false;
  }
  const alignment = getAlignment(placement);
  const alignmentAxis = getAlignmentAxis(placement);
  const length = getAxisLength(alignmentAxis);
  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
  if (rects.reference[length] > rects.floating[length]) {
    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
  }
  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
}
function getExpandedPlacements(placement) {
  const oppositePlacement = getOppositePlacement(placement);
  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
}
function getOppositeAlignmentPlacement(placement) {
  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
}
function getSideList(side, isStart, rtl) {
  const lr = ["left", "right"];
  const rl = ["right", "left"];
  const tb = ["top", "bottom"];
  const bt = ["bottom", "top"];
  switch (side) {
    case "top":
    case "bottom":
      if (rtl)
        return isStart ? rl : lr;
      return isStart ? lr : rl;
    case "left":
    case "right":
      return isStart ? tb : bt;
    default:
      return [];
  }
}
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
  const alignment = getAlignment(placement);
  let list = getSideList(getSide(placement), direction === "start", rtl);
  if (alignment) {
    list = list.map((side) => side + "-" + alignment);
    if (flipAlignment) {
      list = list.concat(list.map(getOppositeAlignmentPlacement));
    }
  }
  return list;
}
function getOppositePlacement(placement) {
  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
}
function expandPaddingObject(padding) {
  return {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    ...padding
  };
}
function getPaddingObject(padding) {
  return typeof padding !== "number" ? expandPaddingObject(padding) : {
    top: padding,
    right: padding,
    bottom: padding,
    left: padding
  };
}
function rectToClientRect(rect) {
  const {
    x: x2,
    y: y2,
    width,
    height
  } = rect;
  return {
    width,
    height,
    top: y2,
    left: x2,
    right: x2 + width,
    bottom: y2 + height,
    x: x2,
    y: y2
  };
}
var sides, min2, max, round2, floor, createCoords, oppositeSideMap, oppositeAlignmentMap;
var init_floating_ui_utils = __esm({
  "node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"() {
    sides = ["top", "right", "bottom", "left"];
    min2 = Math.min;
    max = Math.max;
    round2 = Math.round;
    floor = Math.floor;
    createCoords = (v2) => ({
      x: v2,
      y: v2
    });
    oppositeSideMap = {
      left: "right",
      right: "left",
      bottom: "top",
      top: "bottom"
    };
    oppositeAlignmentMap = {
      start: "end",
      end: "start"
    };
  }
});

// node_modules/@floating-ui/core/dist/floating-ui.core.mjs
function computeCoordsFromPlacement(_ref, placement, rtl) {
  let {
    reference: reference2,
    floating
  } = _ref;
  const sideAxis = getSideAxis(placement);
  const alignmentAxis = getAlignmentAxis(placement);
  const alignLength = getAxisLength(alignmentAxis);
  const side = getSide(placement);
  const isVertical = sideAxis === "y";
  const commonX = reference2.x + reference2.width / 2 - floating.width / 2;
  const commonY = reference2.y + reference2.height / 2 - floating.height / 2;
  const commonAlign = reference2[alignLength] / 2 - floating[alignLength] / 2;
  let coords;
  switch (side) {
    case "top":
      coords = {
        x: commonX,
        y: reference2.y - floating.height
      };
      break;
    case "bottom":
      coords = {
        x: commonX,
        y: reference2.y + reference2.height
      };
      break;
    case "right":
      coords = {
        x: reference2.x + reference2.width,
        y: commonY
      };
      break;
    case "left":
      coords = {
        x: reference2.x - floating.width,
        y: commonY
      };
      break;
    default:
      coords = {
        x: reference2.x,
        y: reference2.y
      };
  }
  switch (getAlignment(placement)) {
    case "start":
      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
      break;
    case "end":
      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
      break;
  }
  return coords;
}
async function detectOverflow(state, options) {
  var _await$platform$isEle;
  if (options === void 0) {
    options = {};
  }
  const {
    x: x2,
    y: y2,
    platform: platform2,
    rects,
    elements,
    strategy
  } = state;
  const {
    boundary = "clippingAncestors",
    rootBoundary = "viewport",
    elementContext = "floating",
    altBoundary = false,
    padding = 0
  } = evaluate(options, state);
  const paddingObject = getPaddingObject(padding);
  const altContext = elementContext === "floating" ? "reference" : "floating";
  const element = elements[altBoundary ? altContext : elementContext];
  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
    boundary,
    rootBoundary,
    strategy
  }));
  const rect = elementContext === "floating" ? {
    x: x2,
    y: y2,
    width: rects.floating.width,
    height: rects.floating.height
  } : rects.reference;
  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
    x: 1,
    y: 1
  } : {
    x: 1,
    y: 1
  };
  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
    elements,
    rect,
    offsetParent,
    strategy
  }) : rect);
  return {
    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
  };
}
function getSideOffsets(overflow, rect) {
  return {
    top: overflow.top - rect.height,
    right: overflow.right - rect.width,
    bottom: overflow.bottom - rect.height,
    left: overflow.left - rect.width
  };
}
function isAnySideFullyClipped(overflow) {
  return sides.some((side) => overflow[side] >= 0);
}
async function convertValueToCoords(state, options) {
  const {
    placement,
    platform: platform2,
    elements
  } = state;
  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
  const side = getSide(placement);
  const alignment = getAlignment(placement);
  const isVertical = getSideAxis(placement) === "y";
  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
  const crossAxisMulti = rtl && isVertical ? -1 : 1;
  const rawValue = evaluate(options, state);
  let {
    mainAxis,
    crossAxis,
    alignmentAxis
  } = typeof rawValue === "number" ? {
    mainAxis: rawValue,
    crossAxis: 0,
    alignmentAxis: null
  } : {
    mainAxis: rawValue.mainAxis || 0,
    crossAxis: rawValue.crossAxis || 0,
    alignmentAxis: rawValue.alignmentAxis
  };
  if (alignment && typeof alignmentAxis === "number") {
    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
  }
  return isVertical ? {
    x: crossAxis * crossAxisMulti,
    y: mainAxis * mainAxisMulti
  } : {
    x: mainAxis * mainAxisMulti,
    y: crossAxis * crossAxisMulti
  };
}
var computePosition, arrow, flip, hide, offset, shift, limitShift, size;
var init_floating_ui_core = __esm({
  "node_modules/@floating-ui/core/dist/floating-ui.core.mjs"() {
    init_floating_ui_utils();
    init_floating_ui_utils();
    computePosition = async (reference2, floating, config) => {
      const {
        placement = "bottom",
        strategy = "absolute",
        middleware = [],
        platform: platform2
      } = config;
      const validMiddleware = middleware.filter(Boolean);
      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
      let rects = await platform2.getElementRects({
        reference: reference2,
        floating,
        strategy
      });
      let {
        x: x2,
        y: y2
      } = computeCoordsFromPlacement(rects, placement, rtl);
      let statefulPlacement = placement;
      let middlewareData = {};
      let resetCount = 0;
      for (let i2 = 0; i2 < validMiddleware.length; i2++) {
        const {
          name,
          fn: fn3
        } = validMiddleware[i2];
        const {
          x: nextX,
          y: nextY,
          data,
          reset
        } = await fn3({
          x: x2,
          y: y2,
          initialPlacement: placement,
          placement: statefulPlacement,
          strategy,
          middlewareData,
          rects,
          platform: platform2,
          elements: {
            reference: reference2,
            floating
          }
        });
        x2 = nextX != null ? nextX : x2;
        y2 = nextY != null ? nextY : y2;
        middlewareData = {
          ...middlewareData,
          [name]: {
            ...middlewareData[name],
            ...data
          }
        };
        if (reset && resetCount <= 50) {
          resetCount++;
          if (typeof reset === "object") {
            if (reset.placement) {
              statefulPlacement = reset.placement;
            }
            if (reset.rects) {
              rects = reset.rects === true ? await platform2.getElementRects({
                reference: reference2,
                floating,
                strategy
              }) : reset.rects;
            }
            ({
              x: x2,
              y: y2
            } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
          }
          i2 = -1;
        }
      }
      return {
        x: x2,
        y: y2,
        placement: statefulPlacement,
        strategy,
        middlewareData
      };
    };
    arrow = (options) => ({
      name: "arrow",
      options,
      async fn(state) {
        const {
          x: x2,
          y: y2,
          placement,
          rects,
          platform: platform2,
          elements,
          middlewareData
        } = state;
        const {
          element,
          padding = 0
        } = evaluate(options, state) || {};
        if (element == null) {
          return {};
        }
        const paddingObject = getPaddingObject(padding);
        const coords = {
          x: x2,
          y: y2
        };
        const axis = getAlignmentAxis(placement);
        const length = getAxisLength(axis);
        const arrowDimensions = await platform2.getDimensions(element);
        const isYAxis = axis === "y";
        const minProp = isYAxis ? "top" : "left";
        const maxProp = isYAxis ? "bottom" : "right";
        const clientProp = isYAxis ? "clientHeight" : "clientWidth";
        const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
        const startDiff = coords[axis] - rects.reference[axis];
        const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
        let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
        if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
          clientSize = elements.floating[clientProp] || rects.floating[length];
        }
        const centerToReference = endDiff / 2 - startDiff / 2;
        const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
        const minPadding = min2(paddingObject[minProp], largestPossiblePadding);
        const maxPadding = min2(paddingObject[maxProp], largestPossiblePadding);
        const min$1 = minPadding;
        const max3 = clientSize - arrowDimensions[length] - maxPadding;
        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
        const offset5 = clamp2(min$1, center, max3);
        const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset5 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
        const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max3 : 0;
        return {
          [axis]: coords[axis] + alignmentOffset,
          data: {
            [axis]: offset5,
            centerOffset: center - offset5 - alignmentOffset,
            ...shouldAddOffset && {
              alignmentOffset
            }
          },
          reset: shouldAddOffset
        };
      }
    });
    flip = function(options) {
      if (options === void 0) {
        options = {};
      }
      return {
        name: "flip",
        options,
        async fn(state) {
          var _middlewareData$arrow, _middlewareData$flip;
          const {
            placement,
            middlewareData,
            rects,
            initialPlacement,
            platform: platform2,
            elements
          } = state;
          const {
            mainAxis: checkMainAxis = true,
            crossAxis: checkCrossAxis = true,
            fallbackPlacements: specifiedFallbackPlacements,
            fallbackStrategy = "bestFit",
            fallbackAxisSideDirection = "none",
            flipAlignment = true,
            ...detectOverflowOptions
          } = evaluate(options, state);
          if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
            return {};
          }
          const side = getSide(placement);
          const initialSideAxis = getSideAxis(initialPlacement);
          const isBasePlacement = getSide(initialPlacement) === initialPlacement;
          const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
          const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
          const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
          if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
            fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
          }
          const placements3 = [initialPlacement, ...fallbackPlacements];
          const overflow = await detectOverflow(state, detectOverflowOptions);
          const overflows = [];
          let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
          if (checkMainAxis) {
            overflows.push(overflow[side]);
          }
          if (checkCrossAxis) {
            const sides2 = getAlignmentSides(placement, rects, rtl);
            overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
          }
          overflowsData = [...overflowsData, {
            placement,
            overflows
          }];
          if (!overflows.every((side2) => side2 <= 0)) {
            var _middlewareData$flip2, _overflowsData$filter;
            const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
            const nextPlacement = placements3[nextIndex];
            if (nextPlacement) {
              return {
                data: {
                  index: nextIndex,
                  overflows: overflowsData
                },
                reset: {
                  placement: nextPlacement
                }
              };
            }
            let resetPlacement = (_overflowsData$filter = overflowsData.filter((d2) => d2.overflows[0] <= 0).sort((a2, b2) => a2.overflows[1] - b2.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
            if (!resetPlacement) {
              switch (fallbackStrategy) {
                case "bestFit": {
                  var _overflowsData$filter2;
                  const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
                    if (hasFallbackAxisSideDirection) {
                      const currentSideAxis = getSideAxis(d2.placement);
                      return currentSideAxis === initialSideAxis || currentSideAxis === "y";
                    }
                    return true;
                  }).map((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
                  if (placement2) {
                    resetPlacement = placement2;
                  }
                  break;
                }
                case "initialPlacement":
                  resetPlacement = initialPlacement;
                  break;
              }
            }
            if (placement !== resetPlacement) {
              return {
                reset: {
                  placement: resetPlacement
                }
              };
            }
          }
          return {};
        }
      };
    };
    hide = function(options) {
      if (options === void 0) {
        options = {};
      }
      return {
        name: "hide",
        options,
        async fn(state) {
          const {
            rects
          } = state;
          const {
            strategy = "referenceHidden",
            ...detectOverflowOptions
          } = evaluate(options, state);
          switch (strategy) {
            case "referenceHidden": {
              const overflow = await detectOverflow(state, {
                ...detectOverflowOptions,
                elementContext: "reference"
              });
              const offsets = getSideOffsets(overflow, rects.reference);
              return {
                data: {
                  referenceHiddenOffsets: offsets,
                  referenceHidden: isAnySideFullyClipped(offsets)
                }
              };
            }
            case "escaped": {
              const overflow = await detectOverflow(state, {
                ...detectOverflowOptions,
                altBoundary: true
              });
              const offsets = getSideOffsets(overflow, rects.floating);
              return {
                data: {
                  escapedOffsets: offsets,
                  escaped: isAnySideFullyClipped(offsets)
                }
              };
            }
            default: {
              return {};
            }
          }
        }
      };
    };
    offset = function(options) {
      if (options === void 0) {
        options = 0;
      }
      return {
        name: "offset",
        options,
        async fn(state) {
          var _middlewareData$offse, _middlewareData$arrow;
          const {
            x: x2,
            y: y2,
            placement,
            middlewareData
          } = state;
          const diffCoords = await convertValueToCoords(state, options);
          if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
            return {};
          }
          return {
            x: x2 + diffCoords.x,
            y: y2 + diffCoords.y,
            data: {
              ...diffCoords,
              placement
            }
          };
        }
      };
    };
    shift = function(options) {
      if (options === void 0) {
        options = {};
      }
      return {
        name: "shift",
        options,
        async fn(state) {
          const {
            x: x2,
            y: y2,
            placement
          } = state;
          const {
            mainAxis: checkMainAxis = true,
            crossAxis: checkCrossAxis = false,
            limiter = {
              fn: (_ref) => {
                let {
                  x: x3,
                  y: y3
                } = _ref;
                return {
                  x: x3,
                  y: y3
                };
              }
            },
            ...detectOverflowOptions
          } = evaluate(options, state);
          const coords = {
            x: x2,
            y: y2
          };
          const overflow = await detectOverflow(state, detectOverflowOptions);
          const crossAxis = getSideAxis(getSide(placement));
          const mainAxis = getOppositeAxis(crossAxis);
          let mainAxisCoord = coords[mainAxis];
          let crossAxisCoord = coords[crossAxis];
          if (checkMainAxis) {
            const minSide = mainAxis === "y" ? "top" : "left";
            const maxSide = mainAxis === "y" ? "bottom" : "right";
            const min4 = mainAxisCoord + overflow[minSide];
            const max3 = mainAxisCoord - overflow[maxSide];
            mainAxisCoord = clamp2(min4, mainAxisCoord, max3);
          }
          if (checkCrossAxis) {
            const minSide = crossAxis === "y" ? "top" : "left";
            const maxSide = crossAxis === "y" ? "bottom" : "right";
            const min4 = crossAxisCoord + overflow[minSide];
            const max3 = crossAxisCoord - overflow[maxSide];
            crossAxisCoord = clamp2(min4, crossAxisCoord, max3);
          }
          const limitedCoords = limiter.fn({
            ...state,
            [mainAxis]: mainAxisCoord,
            [crossAxis]: crossAxisCoord
          });
          return {
            ...limitedCoords,
            data: {
              x: limitedCoords.x - x2,
              y: limitedCoords.y - y2,
              enabled: {
                [mainAxis]: checkMainAxis,
                [crossAxis]: checkCrossAxis
              }
            }
          };
        }
      };
    };
    limitShift = function(options) {
      if (options === void 0) {
        options = {};
      }
      return {
        options,
        fn(state) {
          const {
            x: x2,
            y: y2,
            placement,
            rects,
            middlewareData
          } = state;
          const {
            offset: offset5 = 0,
            mainAxis: checkMainAxis = true,
            crossAxis: checkCrossAxis = true
          } = evaluate(options, state);
          const coords = {
            x: x2,
            y: y2
          };
          const crossAxis = getSideAxis(placement);
          const mainAxis = getOppositeAxis(crossAxis);
          let mainAxisCoord = coords[mainAxis];
          let crossAxisCoord = coords[crossAxis];
          const rawOffset = evaluate(offset5, state);
          const computedOffset = typeof rawOffset === "number" ? {
            mainAxis: rawOffset,
            crossAxis: 0
          } : {
            mainAxis: 0,
            crossAxis: 0,
            ...rawOffset
          };
          if (checkMainAxis) {
            const len = mainAxis === "y" ? "height" : "width";
            const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
            const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
            if (mainAxisCoord < limitMin) {
              mainAxisCoord = limitMin;
            } else if (mainAxisCoord > limitMax) {
              mainAxisCoord = limitMax;
            }
          }
          if (checkCrossAxis) {
            var _middlewareData$offse, _middlewareData$offse2;
            const len = mainAxis === "y" ? "width" : "height";
            const isOriginSide = ["top", "left"].includes(getSide(placement));
            const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
            const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
            if (crossAxisCoord < limitMin) {
              crossAxisCoord = limitMin;
            } else if (crossAxisCoord > limitMax) {
              crossAxisCoord = limitMax;
            }
          }
          return {
            [mainAxis]: mainAxisCoord,
            [crossAxis]: crossAxisCoord
          };
        }
      };
    };
    size = function(options) {
      if (options === void 0) {
        options = {};
      }
      return {
        name: "size",
        options,
        async fn(state) {
          var _state$middlewareData, _state$middlewareData2;
          const {
            placement,
            rects,
            platform: platform2,
            elements
          } = state;
          const {
            apply = () => {
            },
            ...detectOverflowOptions
          } = evaluate(options, state);
          const overflow = await detectOverflow(state, detectOverflowOptions);
          const side = getSide(placement);
          const alignment = getAlignment(placement);
          const isYAxis = getSideAxis(placement) === "y";
          const {
            width,
            height
          } = rects.floating;
          let heightSide;
          let widthSide;
          if (side === "top" || side === "bottom") {
            heightSide = side;
            widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
          } else {
            widthSide = side;
            heightSide = alignment === "end" ? "top" : "bottom";
          }
          const maximumClippingHeight = height - overflow.top - overflow.bottom;
          const maximumClippingWidth = width - overflow.left - overflow.right;
          const overflowAvailableHeight = min2(height - overflow[heightSide], maximumClippingHeight);
          const overflowAvailableWidth = min2(width - overflow[widthSide], maximumClippingWidth);
          const noShift = !state.middlewareData.shift;
          let availableHeight = overflowAvailableHeight;
          let availableWidth = overflowAvailableWidth;
          if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
            availableWidth = maximumClippingWidth;
          }
          if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
            availableHeight = maximumClippingHeight;
          }
          if (noShift && !alignment) {
            const xMin = max(overflow.left, 0);
            const xMax = max(overflow.right, 0);
            const yMin = max(overflow.top, 0);
            const yMax = max(overflow.bottom, 0);
            if (isYAxis) {
              availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
            } else {
              availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
            }
          }
          await apply({
            ...state,
            availableWidth,
            availableHeight
          });
          const nextDimensions = await platform2.getDimensions(elements.floating);
          if (width !== nextDimensions.width || height !== nextDimensions.height) {
            return {
              reset: {
                rects: true
              }
            };
          }
          return {};
        }
      };
    };
  }
});

// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
function hasWindow() {
  return typeof window !== "undefined";
}
function getNodeName(node) {
  if (isNode(node)) {
    return (node.nodeName || "").toLowerCase();
  }
  return "#document";
}
function getWindow(node) {
  var _node$ownerDocument;
  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
}
function getDocumentElement(node) {
  var _ref;
  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
}
function isNode(value) {
  if (!hasWindow()) {
    return false;
  }
  return value instanceof Node || value instanceof getWindow(value).Node;
}
function isElement(value) {
  if (!hasWindow()) {
    return false;
  }
  return value instanceof Element || value instanceof getWindow(value).Element;
}
function isHTMLElement2(value) {
  if (!hasWindow()) {
    return false;
  }
  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
}
function isShadowRoot(value) {
  if (!hasWindow() || typeof ShadowRoot === "undefined") {
    return false;
  }
  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
}
function isOverflowElement(element) {
  const {
    overflow,
    overflowX,
    overflowY,
    display
  } = getComputedStyle2(element);
  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
}
function isTableElement(element) {
  return ["table", "td", "th"].includes(getNodeName(element));
}
function isTopLayer(element) {
  return [":popover-open", ":modal"].some((selector) => {
    try {
      return element.matches(selector);
    } catch (e2) {
      return false;
    }
  });
}
function isContainingBlock(elementOrCss) {
  const webkit = isWebKit();
  const css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
}
function getContainingBlock(element) {
  let currentNode = getParentNode(element);
  while (isHTMLElement2(currentNode) && !isLastTraversableNode(currentNode)) {
    if (isContainingBlock(currentNode)) {
      return currentNode;
    } else if (isTopLayer(currentNode)) {
      return null;
    }
    currentNode = getParentNode(currentNode);
  }
  return null;
}
function isWebKit() {
  if (typeof CSS === "undefined" || !CSS.supports)
    return false;
  return CSS.supports("-webkit-backdrop-filter", "none");
}
function isLastTraversableNode(node) {
  return ["html", "body", "#document"].includes(getNodeName(node));
}
function getComputedStyle2(element) {
  return getWindow(element).getComputedStyle(element);
}
function getNodeScroll(element) {
  if (isElement(element)) {
    return {
      scrollLeft: element.scrollLeft,
      scrollTop: element.scrollTop
    };
  }
  return {
    scrollLeft: element.scrollX,
    scrollTop: element.scrollY
  };
}
function getParentNode(node) {
  if (getNodeName(node) === "html") {
    return node;
  }
  const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
  return isShadowRoot(result) ? result.host : result;
}
function getNearestOverflowAncestor(node) {
  const parentNode = getParentNode(node);
  if (isLastTraversableNode(parentNode)) {
    return node.ownerDocument ? node.ownerDocument.body : node.body;
  }
  if (isHTMLElement2(parentNode) && isOverflowElement(parentNode)) {
    return parentNode;
  }
  return getNearestOverflowAncestor(parentNode);
}
function getOverflowAncestors(node, list, traverseIframes) {
  var _node$ownerDocument2;
  if (list === void 0) {
    list = [];
  }
  if (traverseIframes === void 0) {
    traverseIframes = true;
  }
  const scrollableAncestor = getNearestOverflowAncestor(node);
  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
  const win = getWindow(scrollableAncestor);
  if (isBody) {
    const frameElement = getFrameElement(win);
    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
  }
  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
}
function getFrameElement(win) {
  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
}
var init_floating_ui_utils_dom = __esm({
  "node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs"() {
  }
});

// node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
function getCssDimensions(element) {
  const css = getComputedStyle2(element);
  let width = parseFloat(css.width) || 0;
  let height = parseFloat(css.height) || 0;
  const hasOffset = isHTMLElement2(element);
  const offsetWidth = hasOffset ? element.offsetWidth : width;
  const offsetHeight = hasOffset ? element.offsetHeight : height;
  const shouldFallback = round2(width) !== offsetWidth || round2(height) !== offsetHeight;
  if (shouldFallback) {
    width = offsetWidth;
    height = offsetHeight;
  }
  return {
    width,
    height,
    $: shouldFallback
  };
}
function unwrapElement(element) {
  return !isElement(element) ? element.contextElement : element;
}
function getScale(element) {
  const domElement = unwrapElement(element);
  if (!isHTMLElement2(domElement)) {
    return createCoords(1);
  }
  const rect = domElement.getBoundingClientRect();
  const {
    width,
    height,
    $
  } = getCssDimensions(domElement);
  let x2 = ($ ? round2(rect.width) : rect.width) / width;
  let y2 = ($ ? round2(rect.height) : rect.height) / height;
  if (!x2 || !Number.isFinite(x2)) {
    x2 = 1;
  }
  if (!y2 || !Number.isFinite(y2)) {
    y2 = 1;
  }
  return {
    x: x2,
    y: y2
  };
}
function getVisualOffsets(element) {
  const win = getWindow(element);
  if (!isWebKit() || !win.visualViewport) {
    return noOffsets;
  }
  return {
    x: win.visualViewport.offsetLeft,
    y: win.visualViewport.offsetTop
  };
}
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
  if (isFixed === void 0) {
    isFixed = false;
  }
  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
    return false;
  }
  return isFixed;
}
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
  if (includeScale === void 0) {
    includeScale = false;
  }
  if (isFixedStrategy === void 0) {
    isFixedStrategy = false;
  }
  const clientRect = element.getBoundingClientRect();
  const domElement = unwrapElement(element);
  let scale = createCoords(1);
  if (includeScale) {
    if (offsetParent) {
      if (isElement(offsetParent)) {
        scale = getScale(offsetParent);
      }
    } else {
      scale = getScale(element);
    }
  }
  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
  let x2 = (clientRect.left + visualOffsets.x) / scale.x;
  let y2 = (clientRect.top + visualOffsets.y) / scale.y;
  let width = clientRect.width / scale.x;
  let height = clientRect.height / scale.y;
  if (domElement) {
    const win = getWindow(domElement);
    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
    let currentWin = win;
    let currentIFrame = getFrameElement(currentWin);
    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
      const iframeScale = getScale(currentIFrame);
      const iframeRect = currentIFrame.getBoundingClientRect();
      const css = getComputedStyle2(currentIFrame);
      const left2 = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
      const top2 = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
      x2 *= iframeScale.x;
      y2 *= iframeScale.y;
      width *= iframeScale.x;
      height *= iframeScale.y;
      x2 += left2;
      y2 += top2;
      currentWin = getWindow(currentIFrame);
      currentIFrame = getFrameElement(currentWin);
    }
  }
  return rectToClientRect({
    width,
    height,
    x: x2,
    y: y2
  });
}
function getWindowScrollBarX(element, rect) {
  const leftScroll = getNodeScroll(element).scrollLeft;
  if (!rect) {
    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
  }
  return rect.left + leftScroll;
}
function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
  if (ignoreScrollbarX === void 0) {
    ignoreScrollbarX = false;
  }
  const htmlRect = documentElement.getBoundingClientRect();
  const x2 = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 : getWindowScrollBarX(documentElement, htmlRect));
  const y2 = htmlRect.top + scroll.scrollTop;
  return {
    x: x2,
    y: y2
  };
}
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
  let {
    elements,
    rect,
    offsetParent,
    strategy
  } = _ref;
  const isFixed = strategy === "fixed";
  const documentElement = getDocumentElement(offsetParent);
  const topLayer = elements ? isTopLayer(elements.floating) : false;
  if (offsetParent === documentElement || topLayer && isFixed) {
    return rect;
  }
  let scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  let scale = createCoords(1);
  const offsets = createCoords(0);
  const isOffsetParentAnElement = isHTMLElement2(offsetParent);
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
      scroll = getNodeScroll(offsetParent);
    }
    if (isHTMLElement2(offsetParent)) {
      const offsetRect = getBoundingClientRect(offsetParent);
      scale = getScale(offsetParent);
      offsets.x = offsetRect.x + offsetParent.clientLeft;
      offsets.y = offsetRect.y + offsetParent.clientTop;
    }
  }
  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
  return {
    width: rect.width * scale.x,
    height: rect.height * scale.y,
    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
  };
}
function getClientRects(element) {
  return Array.from(element.getClientRects());
}
function getDocumentRect(element) {
  const html = getDocumentElement(element);
  const scroll = getNodeScroll(element);
  const body = element.ownerDocument.body;
  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
  let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
  const y2 = -scroll.scrollTop;
  if (getComputedStyle2(body).direction === "rtl") {
    x2 += max(html.clientWidth, body.clientWidth) - width;
  }
  return {
    width,
    height,
    x: x2,
    y: y2
  };
}
function getViewportRect(element, strategy) {
  const win = getWindow(element);
  const html = getDocumentElement(element);
  const visualViewport = win.visualViewport;
  let width = html.clientWidth;
  let height = html.clientHeight;
  let x2 = 0;
  let y2 = 0;
  if (visualViewport) {
    width = visualViewport.width;
    height = visualViewport.height;
    const visualViewportBased = isWebKit();
    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
      x2 = visualViewport.offsetLeft;
      y2 = visualViewport.offsetTop;
    }
  }
  return {
    width,
    height,
    x: x2,
    y: y2
  };
}
function getInnerBoundingClientRect(element, strategy) {
  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
  const top2 = clientRect.top + element.clientTop;
  const left2 = clientRect.left + element.clientLeft;
  const scale = isHTMLElement2(element) ? getScale(element) : createCoords(1);
  const width = element.clientWidth * scale.x;
  const height = element.clientHeight * scale.y;
  const x2 = left2 * scale.x;
  const y2 = top2 * scale.y;
  return {
    width,
    height,
    x: x2,
    y: y2
  };
}
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
  let rect;
  if (clippingAncestor === "viewport") {
    rect = getViewportRect(element, strategy);
  } else if (clippingAncestor === "document") {
    rect = getDocumentRect(getDocumentElement(element));
  } else if (isElement(clippingAncestor)) {
    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
  } else {
    const visualOffsets = getVisualOffsets(element);
    rect = {
      x: clippingAncestor.x - visualOffsets.x,
      y: clippingAncestor.y - visualOffsets.y,
      width: clippingAncestor.width,
      height: clippingAncestor.height
    };
  }
  return rectToClientRect(rect);
}
function hasFixedPositionAncestor(element, stopNode) {
  const parentNode = getParentNode(element);
  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
    return false;
  }
  return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
}
function getClippingElementAncestors(element, cache) {
  const cachedResult = cache.get(element);
  if (cachedResult) {
    return cachedResult;
  }
  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
  let currentContainingBlockComputedStyle = null;
  const elementIsFixed = getComputedStyle2(element).position === "fixed";
  let currentNode = elementIsFixed ? getParentNode(element) : element;
  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
    const computedStyle = getComputedStyle2(currentNode);
    const currentNodeIsContaining = isContainingBlock(currentNode);
    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
      currentContainingBlockComputedStyle = null;
    }
    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
    if (shouldDropCurrentNode) {
      result = result.filter((ancestor) => ancestor !== currentNode);
    } else {
      currentContainingBlockComputedStyle = computedStyle;
    }
    currentNode = getParentNode(currentNode);
  }
  cache.set(element, result);
  return result;
}
function getClippingRect(_ref) {
  let {
    element,
    boundary,
    rootBoundary,
    strategy
  } = _ref;
  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
  const firstClippingAncestor = clippingAncestors[0];
  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
    accRect.top = max(rect.top, accRect.top);
    accRect.right = min2(rect.right, accRect.right);
    accRect.bottom = min2(rect.bottom, accRect.bottom);
    accRect.left = max(rect.left, accRect.left);
    return accRect;
  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
  return {
    width: clippingRect.right - clippingRect.left,
    height: clippingRect.bottom - clippingRect.top,
    x: clippingRect.left,
    y: clippingRect.top
  };
}
function getDimensions(element) {
  const {
    width,
    height
  } = getCssDimensions(element);
  return {
    width,
    height
  };
}
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
  const isOffsetParentAnElement = isHTMLElement2(offsetParent);
  const documentElement = getDocumentElement(offsetParent);
  const isFixed = strategy === "fixed";
  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
  let scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  const offsets = createCoords(0);
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
      scroll = getNodeScroll(offsetParent);
    }
    if (isOffsetParentAnElement) {
      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
      offsets.x = offsetRect.x + offsetParent.clientLeft;
      offsets.y = offsetRect.y + offsetParent.clientTop;
    } else if (documentElement) {
      offsets.x = getWindowScrollBarX(documentElement);
    }
  }
  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
  const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
  const y2 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
  return {
    x: x2,
    y: y2,
    width: rect.width,
    height: rect.height
  };
}
function isStaticPositioned(element) {
  return getComputedStyle2(element).position === "static";
}
function getTrueOffsetParent(element, polyfill) {
  if (!isHTMLElement2(element) || getComputedStyle2(element).position === "fixed") {
    return null;
  }
  if (polyfill) {
    return polyfill(element);
  }
  let rawOffsetParent = element.offsetParent;
  if (getDocumentElement(element) === rawOffsetParent) {
    rawOffsetParent = rawOffsetParent.ownerDocument.body;
  }
  return rawOffsetParent;
}
function getOffsetParent(element, polyfill) {
  const win = getWindow(element);
  if (isTopLayer(element)) {
    return win;
  }
  if (!isHTMLElement2(element)) {
    let svgOffsetParent = getParentNode(element);
    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
        return svgOffsetParent;
      }
      svgOffsetParent = getParentNode(svgOffsetParent);
    }
    return win;
  }
  let offsetParent = getTrueOffsetParent(element, polyfill);
  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
  }
  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
    return win;
  }
  return offsetParent || getContainingBlock(element) || win;
}
function isRTL(element) {
  return getComputedStyle2(element).direction === "rtl";
}
function observeMove(element, onMove) {
  let io = null;
  let timeoutId;
  const root = getDocumentElement(element);
  function cleanup() {
    var _io;
    clearTimeout(timeoutId);
    (_io = io) == null || _io.disconnect();
    io = null;
  }
  function refresh(skip, threshold) {
    if (skip === void 0) {
      skip = false;
    }
    if (threshold === void 0) {
      threshold = 1;
    }
    cleanup();
    const {
      left: left2,
      top: top2,
      width,
      height
    } = element.getBoundingClientRect();
    if (!skip) {
      onMove();
    }
    if (!width || !height) {
      return;
    }
    const insetTop = floor(top2);
    const insetRight = floor(root.clientWidth - (left2 + width));
    const insetBottom = floor(root.clientHeight - (top2 + height));
    const insetLeft = floor(left2);
    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
    const options = {
      rootMargin,
      threshold: max(0, min2(1, threshold)) || 1
    };
    let isFirstUpdate = true;
    function handleObserve(entries) {
      const ratio = entries[0].intersectionRatio;
      if (ratio !== threshold) {
        if (!isFirstUpdate) {
          return refresh();
        }
        if (!ratio) {
          timeoutId = setTimeout(() => {
            refresh(false, 1e-7);
          }, 1e3);
        } else {
          refresh(false, ratio);
        }
      }
      isFirstUpdate = false;
    }
    try {
      io = new IntersectionObserver(handleObserve, {
        ...options,
        root: root.ownerDocument
      });
    } catch (e2) {
      io = new IntersectionObserver(handleObserve, options);
    }
    io.observe(element);
  }
  refresh(true);
  return cleanup;
}
function autoUpdate(reference2, floating, update, options) {
  if (options === void 0) {
    options = {};
  }
  const {
    ancestorScroll = true,
    ancestorResize = true,
    elementResize = typeof ResizeObserver === "function",
    layoutShift = typeof IntersectionObserver === "function",
    animationFrame = false
  } = options;
  const referenceEl = unwrapElement(reference2);
  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
  ancestors.forEach((ancestor) => {
    ancestorScroll && ancestor.addEventListener("scroll", update, {
      passive: true
    });
    ancestorResize && ancestor.addEventListener("resize", update);
  });
  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
  let reobserveFrame = -1;
  let resizeObserver = null;
  if (elementResize) {
    resizeObserver = new ResizeObserver((_ref) => {
      let [firstEntry] = _ref;
      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
        resizeObserver.unobserve(floating);
        cancelAnimationFrame(reobserveFrame);
        reobserveFrame = requestAnimationFrame(() => {
          var _resizeObserver;
          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
        });
      }
      update();
    });
    if (referenceEl && !animationFrame) {
      resizeObserver.observe(referenceEl);
    }
    resizeObserver.observe(floating);
  }
  let frameId;
  let prevRefRect = animationFrame ? getBoundingClientRect(reference2) : null;
  if (animationFrame) {
    frameLoop();
  }
  function frameLoop() {
    const nextRefRect = getBoundingClientRect(reference2);
    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
      update();
    }
    prevRefRect = nextRefRect;
    frameId = requestAnimationFrame(frameLoop);
  }
  update();
  return () => {
    var _resizeObserver2;
    ancestors.forEach((ancestor) => {
      ancestorScroll && ancestor.removeEventListener("scroll", update);
      ancestorResize && ancestor.removeEventListener("resize", update);
    });
    cleanupIo == null || cleanupIo();
    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
    resizeObserver = null;
    if (animationFrame) {
      cancelAnimationFrame(frameId);
    }
  };
}
var noOffsets, getElementRects, platform, offset2, shift2, flip2, size2, hide2, arrow2, limitShift2, computePosition2;
var init_floating_ui_dom = __esm({
  "node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs"() {
    init_floating_ui_core();
    init_floating_ui_utils();
    init_floating_ui_utils_dom();
    noOffsets = /* @__PURE__ */ createCoords(0);
    getElementRects = async function(data) {
      const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
      const getDimensionsFn = this.getDimensions;
      const floatingDimensions = await getDimensionsFn(data.floating);
      return {
        reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
        floating: {
          x: 0,
          y: 0,
          width: floatingDimensions.width,
          height: floatingDimensions.height
        }
      };
    };
    platform = {
      convertOffsetParentRelativeRectToViewportRelativeRect,
      getDocumentElement,
      getClippingRect,
      getOffsetParent,
      getElementRects,
      getClientRects,
      getDimensions,
      getScale,
      isElement,
      isRTL
    };
    offset2 = offset;
    shift2 = shift;
    flip2 = flip;
    size2 = size;
    hide2 = hide;
    arrow2 = arrow;
    limitShift2 = limitShift;
    computePosition2 = (reference2, floating, options) => {
      const cache = /* @__PURE__ */ new Map();
      const mergedOptions = {
        platform,
        ...options
      };
      const platformWithCache = {
        ...mergedOptions.platform,
        _c: cache
      };
      return computePosition(reference2, floating, {
        ...mergedOptions,
        platform: platformWithCache
      });
    };
  }
});

// node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
function deepEqual(a2, b2) {
  if (a2 === b2) {
    return true;
  }
  if (typeof a2 !== typeof b2) {
    return false;
  }
  if (typeof a2 === "function" && a2.toString() === b2.toString()) {
    return true;
  }
  let length;
  let i2;
  let keys;
  if (a2 && b2 && typeof a2 === "object") {
    if (Array.isArray(a2)) {
      length = a2.length;
      if (length !== b2.length)
        return false;
      for (i2 = length; i2-- !== 0; ) {
        if (!deepEqual(a2[i2], b2[i2])) {
          return false;
        }
      }
      return true;
    }
    keys = Object.keys(a2);
    length = keys.length;
    if (length !== Object.keys(b2).length) {
      return false;
    }
    for (i2 = length; i2-- !== 0; ) {
      if (!{}.hasOwnProperty.call(b2, keys[i2])) {
        return false;
      }
    }
    for (i2 = length; i2-- !== 0; ) {
      const key = keys[i2];
      if (key === "_owner" && a2.$$typeof) {
        continue;
      }
      if (!deepEqual(a2[key], b2[key])) {
        return false;
      }
    }
    return true;
  }
  return a2 !== a2 && b2 !== b2;
}
function getDPR(element) {
  if (typeof window === "undefined") {
    return 1;
  }
  const win = element.ownerDocument.defaultView || window;
  return win.devicePixelRatio || 1;
}
function roundByDPR(element, value) {
  const dpr = getDPR(element);
  return Math.round(value * dpr) / dpr;
}
function useLatestRef(value) {
  const ref = React51.useRef(value);
  index(() => {
    ref.current = value;
  });
  return ref;
}
function useFloating(options) {
  if (options === void 0) {
    options = {};
  }
  const {
    placement = "bottom",
    strategy = "absolute",
    middleware = [],
    platform: platform2,
    elements: {
      reference: externalReference,
      floating: externalFloating
    } = {},
    transform = true,
    whileElementsMounted,
    open
  } = options;
  const [data, setData] = React51.useState({
    x: 0,
    y: 0,
    strategy,
    placement,
    middlewareData: {},
    isPositioned: false
  });
  const [latestMiddleware, setLatestMiddleware] = React51.useState(middleware);
  if (!deepEqual(latestMiddleware, middleware)) {
    setLatestMiddleware(middleware);
  }
  const [_reference, _setReference] = React51.useState(null);
  const [_floating, _setFloating] = React51.useState(null);
  const setReference = React51.useCallback((node) => {
    if (node !== referenceRef.current) {
      referenceRef.current = node;
      _setReference(node);
    }
  }, []);
  const setFloating = React51.useCallback((node) => {
    if (node !== floatingRef.current) {
      floatingRef.current = node;
      _setFloating(node);
    }
  }, []);
  const referenceEl = externalReference || _reference;
  const floatingEl = externalFloating || _floating;
  const referenceRef = React51.useRef(null);
  const floatingRef = React51.useRef(null);
  const dataRef = React51.useRef(data);
  const hasWhileElementsMounted = whileElementsMounted != null;
  const whileElementsMountedRef = useLatestRef(whileElementsMounted);
  const platformRef = useLatestRef(platform2);
  const openRef = useLatestRef(open);
  const update = React51.useCallback(() => {
    if (!referenceRef.current || !floatingRef.current) {
      return;
    }
    const config = {
      placement,
      strategy,
      middleware: latestMiddleware
    };
    if (platformRef.current) {
      config.platform = platformRef.current;
    }
    computePosition2(referenceRef.current, floatingRef.current, config).then((data2) => {
      const fullData = {
        ...data2,
        isPositioned: openRef.current !== false
      };
      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
        dataRef.current = fullData;
        ReactDOM4.flushSync(() => {
          setData(fullData);
        });
      }
    });
  }, [latestMiddleware, placement, strategy, platformRef, openRef]);
  index(() => {
    if (open === false && dataRef.current.isPositioned) {
      dataRef.current.isPositioned = false;
      setData((data2) => ({
        ...data2,
        isPositioned: false
      }));
    }
  }, [open]);
  const isMountedRef = React51.useRef(false);
  index(() => {
    isMountedRef.current = true;
    return () => {
      isMountedRef.current = false;
    };
  }, []);
  index(() => {
    if (referenceEl)
      referenceRef.current = referenceEl;
    if (floatingEl)
      floatingRef.current = floatingEl;
    if (referenceEl && floatingEl) {
      if (whileElementsMountedRef.current) {
        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
      }
      update();
    }
  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
  const refs = React51.useMemo(() => ({
    reference: referenceRef,
    floating: floatingRef,
    setReference,
    setFloating
  }), [setReference, setFloating]);
  const elements = React51.useMemo(() => ({
    reference: referenceEl,
    floating: floatingEl
  }), [referenceEl, floatingEl]);
  const floatingStyles = React51.useMemo(() => {
    const initialStyles = {
      position: strategy,
      left: 0,
      top: 0
    };
    if (!elements.floating) {
      return initialStyles;
    }
    const x2 = roundByDPR(elements.floating, data.x);
    const y2 = roundByDPR(elements.floating, data.y);
    if (transform) {
      return {
        ...initialStyles,
        transform: "translate(" + x2 + "px, " + y2 + "px)",
        ...getDPR(elements.floating) >= 1.5 && {
          willChange: "transform"
        }
      };
    }
    return {
      position: strategy,
      left: x2,
      top: y2
    };
  }, [strategy, transform, elements.floating, data.x, data.y]);
  return React51.useMemo(() => ({
    ...data,
    update,
    refs,
    elements,
    floatingStyles
  }), [data, update, refs, elements, floatingStyles]);
}
var React51, import_react81, ReactDOM4, index, arrow$1, offset3, shift3, limitShift3, flip3, size3, hide3, arrow3;
var init_floating_ui_react_dom = __esm({
  "node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs"() {
    init_floating_ui_dom();
    init_floating_ui_dom();
    React51 = __toESM(require_react(), 1);
    import_react81 = __toESM(require_react(), 1);
    ReactDOM4 = __toESM(require_react_dom(), 1);
    index = typeof document !== "undefined" ? import_react81.useLayoutEffect : import_react81.useEffect;
    arrow$1 = (options) => {
      function isRef(value) {
        return {}.hasOwnProperty.call(value, "current");
      }
      return {
        name: "arrow",
        options,
        fn(state) {
          const {
            element,
            padding
          } = typeof options === "function" ? options(state) : options;
          if (element && isRef(element)) {
            if (element.current != null) {
              return arrow2({
                element: element.current,
                padding
              }).fn(state);
            }
            return {};
          }
          if (element) {
            return arrow2({
              element,
              padding
            }).fn(state);
          }
          return {};
        }
      };
    };
    offset3 = (options, deps) => ({
      ...offset2(options),
      options: [options, deps]
    });
    shift3 = (options, deps) => ({
      ...shift2(options),
      options: [options, deps]
    });
    limitShift3 = (options, deps) => ({
      ...limitShift2(options),
      options: [options, deps]
    });
    flip3 = (options, deps) => ({
      ...flip2(options),
      options: [options, deps]
    });
    size3 = (options, deps) => ({
      ...size2(options),
      options: [options, deps]
    });
    hide3 = (options, deps) => ({
      ...hide2(options),
      options: [options, deps]
    });
    arrow3 = (options, deps) => ({
      ...arrow$1(options),
      options: [options, deps]
    });
  }
});

// node_modules/@radix-ui/react-arrow/dist/index.mjs
var React52, import_jsx_runtime93, NAME2, Arrow, Root3;
var init_dist20 = __esm({
  "node_modules/@radix-ui/react-arrow/dist/index.mjs"() {
    React52 = __toESM(require_react(), 1);
    init_dist9();
    import_jsx_runtime93 = __toESM(require_jsx_runtime(), 1);
    NAME2 = "Arrow";
    Arrow = React52.forwardRef((props, forwardedRef) => {
      const { children, width = 10, height = 5, ...arrowProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime93.jsx)(Primitive.svg, {
        ...arrowProps,
        ref: forwardedRef,
        width,
        height,
        viewBox: "0 0 30 10",
        preserveAspectRatio: "none",
        children: props.asChild ? children : /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("polygon", { points: "0,0 30,0 15,10" })
      });
    });
    Arrow.displayName = NAME2;
    Root3 = Arrow;
  }
});

// node_modules/@radix-ui/react-use-size/dist/index.mjs
function useSize(element) {
  const [size4, setSize] = React53.useState(void 0);
  useLayoutEffect22(() => {
    if (element) {
      setSize({ width: element.offsetWidth, height: element.offsetHeight });
      const resizeObserver = new ResizeObserver((entries) => {
        if (!Array.isArray(entries)) {
          return;
        }
        if (!entries.length) {
          return;
        }
        const entry = entries[0];
        let width;
        let height;
        if ("borderBoxSize" in entry) {
          const borderSizeEntry = entry["borderBoxSize"];
          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
          width = borderSize["inlineSize"];
          height = borderSize["blockSize"];
        } else {
          width = element.offsetWidth;
          height = element.offsetHeight;
        }
        setSize({ width, height });
      });
      resizeObserver.observe(element, { box: "border-box" });
      return () => resizeObserver.unobserve(element);
    } else {
      setSize(void 0);
    }
  }, [element]);
  return size4;
}
var React53;
var init_dist21 = __esm({
  "node_modules/@radix-ui/react-use-size/dist/index.mjs"() {
    React53 = __toESM(require_react(), 1);
    init_dist4();
  }
});

// node_modules/@radix-ui/react-popper/dist/index.mjs
function isNotNull(value) {
  return value !== null;
}
function getSideAndAlignFromPlacement(placement) {
  const [side, align = "center"] = placement.split("-");
  return [side, align];
}
var React54, import_jsx_runtime94, POPPER_NAME, createPopperContext, createPopperScope, PopperProvider, usePopperContext, Popper, ANCHOR_NAME, PopperAnchor, CONTENT_NAME2, PopperContentProvider, useContentContext, PopperContent, ARROW_NAME, OPPOSITE_SIDE, PopperArrow, transformOrigin, Root23, Anchor, Content2, Arrow2;
var init_dist22 = __esm({
  "node_modules/@radix-ui/react-popper/dist/index.mjs"() {
    React54 = __toESM(require_react(), 1);
    init_floating_ui_react_dom();
    init_dist20();
    init_dist2();
    init_dist3();
    init_dist9();
    init_dist6();
    init_dist4();
    init_dist21();
    import_jsx_runtime94 = __toESM(require_jsx_runtime(), 1);
    "use client";
    POPPER_NAME = "Popper";
    [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);
    [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);
    Popper = (props) => {
      const { __scopePopper, children } = props;
      const [anchor, setAnchor] = React54.useState(null);
      return /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(PopperProvider, { scope: __scopePopper, anchor, onAnchorChange: setAnchor, children });
    };
    Popper.displayName = POPPER_NAME;
    ANCHOR_NAME = "PopperAnchor";
    PopperAnchor = React54.forwardRef((props, forwardedRef) => {
      const { __scopePopper, virtualRef, ...anchorProps } = props;
      const context = usePopperContext(ANCHOR_NAME, __scopePopper);
      const ref = React54.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      React54.useEffect(() => {
        context.onAnchorChange(virtualRef?.current || ref.current);
      });
      return virtualRef ? null : /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(Primitive.div, { ...anchorProps, ref: composedRefs });
    });
    PopperAnchor.displayName = ANCHOR_NAME;
    CONTENT_NAME2 = "PopperContent";
    [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME2);
    PopperContent = React54.forwardRef((props, forwardedRef) => {
      const {
        __scopePopper,
        side = "bottom",
        sideOffset = 0,
        align = "center",
        alignOffset = 0,
        arrowPadding = 0,
        avoidCollisions = true,
        collisionBoundary = [],
        collisionPadding: collisionPaddingProp = 0,
        sticky = "partial",
        hideWhenDetached = false,
        updatePositionStrategy = "optimized",
        onPlaced,
        ...contentProps
      } = props;
      const context = usePopperContext(CONTENT_NAME2, __scopePopper);
      const [content, setContent2] = React54.useState(null);
      const composedRefs = useComposedRefs(forwardedRef, (node) => setContent2(node));
      const [arrow5, setArrow] = React54.useState(null);
      const arrowSize = useSize(arrow5);
      const arrowWidth = arrowSize?.width ?? 0;
      const arrowHeight = arrowSize?.height ?? 0;
      const desiredPlacement = side + (align !== "center" ? "-" + align : "");
      const collisionPadding = typeof collisionPaddingProp === "number" ? collisionPaddingProp : { top: 0, right: 0, bottom: 0, left: 0, ...collisionPaddingProp };
      const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [collisionBoundary];
      const hasExplicitBoundaries = boundary.length > 0;
      const detectOverflowOptions = {
        padding: collisionPadding,
        boundary: boundary.filter(isNotNull),
        altBoundary: hasExplicitBoundaries
      };
      const { refs, floatingStyles, placement, isPositioned, middlewareData } = useFloating({
        strategy: "fixed",
        placement: desiredPlacement,
        whileElementsMounted: (...args) => {
          const cleanup = autoUpdate(...args, {
            animationFrame: updatePositionStrategy === "always"
          });
          return cleanup;
        },
        elements: {
          reference: context.anchor
        },
        middleware: [
          offset3({ mainAxis: sideOffset + arrowHeight, alignmentAxis: alignOffset }),
          avoidCollisions && shift3({
            mainAxis: true,
            crossAxis: false,
            limiter: sticky === "partial" ? limitShift3() : void 0,
            ...detectOverflowOptions
          }),
          avoidCollisions && flip3({ ...detectOverflowOptions }),
          size3({
            ...detectOverflowOptions,
            apply: ({ elements, rects, availableWidth, availableHeight }) => {
              const { width: anchorWidth, height: anchorHeight } = rects.reference;
              const contentStyle = elements.floating.style;
              contentStyle.setProperty("--radix-popper-available-width", `${availableWidth}px`);
              contentStyle.setProperty("--radix-popper-available-height", `${availableHeight}px`);
              contentStyle.setProperty("--radix-popper-anchor-width", `${anchorWidth}px`);
              contentStyle.setProperty("--radix-popper-anchor-height", `${anchorHeight}px`);
            }
          }),
          arrow5 && arrow3({ element: arrow5, padding: arrowPadding }),
          transformOrigin({ arrowWidth, arrowHeight }),
          hideWhenDetached && hide3({ strategy: "referenceHidden", ...detectOverflowOptions })
        ]
      });
      const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
      const handlePlaced = useCallbackRef(onPlaced);
      useLayoutEffect22(() => {
        if (isPositioned) {
          handlePlaced?.();
        }
      }, [isPositioned, handlePlaced]);
      const arrowX = middlewareData.arrow?.x;
      const arrowY = middlewareData.arrow?.y;
      const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
      const [contentZIndex, setContentZIndex] = React54.useState();
      useLayoutEffect22(() => {
        if (content)
          setContentZIndex(window.getComputedStyle(content).zIndex);
      }, [content]);
      return /* @__PURE__ */ (0, import_jsx_runtime94.jsx)("div", {
        ref: refs.setFloating,
        "data-radix-popper-content-wrapper": "",
        style: {
          ...floatingStyles,
          transform: isPositioned ? floatingStyles.transform : "translate(0, -200%)",
          minWidth: "max-content",
          zIndex: contentZIndex,
          ["--radix-popper-transform-origin"]: [
            middlewareData.transformOrigin?.x,
            middlewareData.transformOrigin?.y
          ].join(" "),
          ...middlewareData.hide?.referenceHidden && {
            visibility: "hidden",
            pointerEvents: "none"
          }
        },
        dir: props.dir,
        children: /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(PopperContentProvider, {
          scope: __scopePopper,
          placedSide,
          onArrowChange: setArrow,
          arrowX,
          arrowY,
          shouldHideArrow: cannotCenterArrow,
          children: /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(Primitive.div, {
            "data-side": placedSide,
            "data-align": placedAlign,
            ...contentProps,
            ref: composedRefs,
            style: {
              ...contentProps.style,
              animation: !isPositioned ? "none" : void 0
            }
          })
        })
      });
    });
    PopperContent.displayName = CONTENT_NAME2;
    ARROW_NAME = "PopperArrow";
    OPPOSITE_SIDE = {
      top: "bottom",
      right: "left",
      bottom: "top",
      left: "right"
    };
    PopperArrow = React54.forwardRef(function PopperArrow2(props, forwardedRef) {
      const { __scopePopper, ...arrowProps } = props;
      const contentContext = useContentContext(ARROW_NAME, __scopePopper);
      const baseSide = OPPOSITE_SIDE[contentContext.placedSide];
      return /* @__PURE__ */ (0, import_jsx_runtime94.jsx)("span", {
        ref: contentContext.onArrowChange,
        style: {
          position: "absolute",
          left: contentContext.arrowX,
          top: contentContext.arrowY,
          [baseSide]: 0,
          transformOrigin: {
            top: "",
            right: "0 0",
            bottom: "center 0",
            left: "100% 0"
          }[contentContext.placedSide],
          transform: {
            top: "translateY(100%)",
            right: "translateY(50%) rotate(90deg) translateX(-50%)",
            bottom: `rotate(180deg)`,
            left: "translateY(50%) rotate(-90deg) translateX(50%)"
          }[contentContext.placedSide],
          visibility: contentContext.shouldHideArrow ? "hidden" : void 0
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(Root3, {
          ...arrowProps,
          ref: forwardedRef,
          style: {
            ...arrowProps.style,
            display: "block"
          }
        })
      });
    });
    PopperArrow.displayName = ARROW_NAME;
    transformOrigin = (options) => ({
      name: "transformOrigin",
      options,
      fn(data) {
        const { placement, rects, middlewareData } = data;
        const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
        const isArrowHidden = cannotCenterArrow;
        const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
        const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
        const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
        const noArrowAlign = { start: "0%", center: "50%", end: "100%" }[placedAlign];
        const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;
        const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;
        let x2 = "";
        let y2 = "";
        if (placedSide === "bottom") {
          x2 = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
          y2 = `${-arrowHeight}px`;
        } else if (placedSide === "top") {
          x2 = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
          y2 = `${rects.floating.height + arrowHeight}px`;
        } else if (placedSide === "right") {
          x2 = `${-arrowHeight}px`;
          y2 = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
        } else if (placedSide === "left") {
          x2 = `${rects.floating.width + arrowHeight}px`;
          y2 = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
        }
        return { data: { x: x2, y: y2 } };
      }
    });
    Root23 = Popper;
    Anchor = PopperAnchor;
    Content2 = PopperContent;
    Arrow2 = PopperArrow;
  }
});

// node_modules/@radix-ui/react-popover/dist/index.mjs
function getState2(open) {
  return open ? "open" : "closed";
}
var React55, import_jsx_runtime95, POPOVER_NAME, createPopoverContext, createPopoverScope, usePopperScope, PopoverProvider, usePopoverContext, Popover, ANCHOR_NAME2, PopoverAnchor, TRIGGER_NAME2, PopoverTrigger, PORTAL_NAME3, PortalProvider2, usePortalContext2, PopoverPortal, CONTENT_NAME3, PopoverContent, PopoverContentModal, PopoverContentNonModal, PopoverContentImpl, CLOSE_NAME3, PopoverClose, ARROW_NAME2, PopoverArrow, Root24, Trigger, Portal3, Content22;
var init_dist23 = __esm({
  "node_modules/@radix-ui/react-popover/dist/index.mjs"() {
    React55 = __toESM(require_react(), 1);
    init_dist();
    init_dist2();
    init_dist3();
    init_dist11();
    init_dist15();
    init_dist12();
    init_dist5();
    init_dist22();
    init_dist22();
    init_dist13();
    init_dist14();
    init_dist9();
    init_dist8();
    init_dist7();
    init_es20157();
    init_es20156();
    import_jsx_runtime95 = __toESM(require_jsx_runtime(), 1);
    "use client";
    POPOVER_NAME = "Popover";
    [createPopoverContext, createPopoverScope] = createContextScope(POPOVER_NAME, [
      createPopperScope
    ]);
    usePopperScope = createPopperScope();
    [PopoverProvider, usePopoverContext] = createPopoverContext(POPOVER_NAME);
    Popover = (props) => {
      const {
        __scopePopover,
        children,
        open: openProp,
        defaultOpen,
        onOpenChange,
        modal = false
      } = props;
      const popperScope = usePopperScope(__scopePopover);
      const triggerRef = React55.useRef(null);
      const [hasCustomAnchor, setHasCustomAnchor] = React55.useState(false);
      const [open = false, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Root23, { ...popperScope, children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PopoverProvider, {
        scope: __scopePopover,
        contentId: useId2(),
        triggerRef,
        open,
        onOpenChange: setOpen,
        onOpenToggle: React55.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
        hasCustomAnchor,
        onCustomAnchorAdd: React55.useCallback(() => setHasCustomAnchor(true), []),
        onCustomAnchorRemove: React55.useCallback(() => setHasCustomAnchor(false), []),
        modal,
        children
      }) });
    };
    Popover.displayName = POPOVER_NAME;
    ANCHOR_NAME2 = "PopoverAnchor";
    PopoverAnchor = React55.forwardRef((props, forwardedRef) => {
      const { __scopePopover, ...anchorProps } = props;
      const context = usePopoverContext(ANCHOR_NAME2, __scopePopover);
      const popperScope = usePopperScope(__scopePopover);
      const { onCustomAnchorAdd, onCustomAnchorRemove } = context;
      React55.useEffect(() => {
        onCustomAnchorAdd();
        return () => onCustomAnchorRemove();
      }, [onCustomAnchorAdd, onCustomAnchorRemove]);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Anchor, { ...popperScope, ...anchorProps, ref: forwardedRef });
    });
    PopoverAnchor.displayName = ANCHOR_NAME2;
    TRIGGER_NAME2 = "PopoverTrigger";
    PopoverTrigger = React55.forwardRef((props, forwardedRef) => {
      const { __scopePopover, ...triggerProps } = props;
      const context = usePopoverContext(TRIGGER_NAME2, __scopePopover);
      const popperScope = usePopperScope(__scopePopover);
      const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);
      const trigger2 = /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Primitive.button, {
        type: "button",
        "aria-haspopup": "dialog",
        "aria-expanded": context.open,
        "aria-controls": context.contentId,
        "data-state": getState2(context.open),
        ...triggerProps,
        ref: composedTriggerRef,
        onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
      });
      return context.hasCustomAnchor ? trigger2 : /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Anchor, { asChild: true, ...popperScope, children: trigger2 });
    });
    PopoverTrigger.displayName = TRIGGER_NAME2;
    PORTAL_NAME3 = "PopoverPortal";
    [PortalProvider2, usePortalContext2] = createPopoverContext(PORTAL_NAME3, {
      forceMount: void 0
    });
    PopoverPortal = (props) => {
      const { __scopePopover, forceMount, children, container } = props;
      const context = usePopoverContext(PORTAL_NAME3, __scopePopover);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PortalProvider2, { scope: __scopePopover, forceMount, children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Portal, { asChild: true, container, children }) }) });
    };
    PopoverPortal.displayName = PORTAL_NAME3;
    CONTENT_NAME3 = "PopoverContent";
    PopoverContent = React55.forwardRef((props, forwardedRef) => {
      const portalContext = usePortalContext2(CONTENT_NAME3, props.__scopePopover);
      const { forceMount = portalContext.forceMount, ...contentProps } = props;
      const context = usePopoverContext(CONTENT_NAME3, props.__scopePopover);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Presence, { present: forceMount || context.open, children: context.modal ? /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PopoverContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PopoverContentNonModal, { ...contentProps, ref: forwardedRef }) });
    });
    PopoverContent.displayName = CONTENT_NAME3;
    PopoverContentModal = React55.forwardRef((props, forwardedRef) => {
      const context = usePopoverContext(CONTENT_NAME3, props.__scopePopover);
      const contentRef = React55.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, contentRef);
      const isRightClickOutsideRef = React55.useRef(false);
      React55.useEffect(() => {
        const content = contentRef.current;
        if (content)
          return hideOthers(content);
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Combination_default, { as: Slot, allowPinchZoom: true, children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PopoverContentImpl, {
        ...props,
        ref: composedRefs,
        trapFocus: context.open,
        disableOutsidePointerEvents: true,
        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
          event.preventDefault();
          if (!isRightClickOutsideRef.current)
            context.triggerRef.current?.focus();
        }),
        onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
          const originalEvent = event.detail.originalEvent;
          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
          isRightClickOutsideRef.current = isRightClick;
        }, { checkForDefaultPrevented: false }),
        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => event.preventDefault(), { checkForDefaultPrevented: false })
      }) });
    });
    PopoverContentNonModal = React55.forwardRef((props, forwardedRef) => {
      const context = usePopoverContext(CONTENT_NAME3, props.__scopePopover);
      const hasInteractedOutsideRef = React55.useRef(false);
      const hasPointerDownOutsideRef = React55.useRef(false);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(PopoverContentImpl, {
        ...props,
        ref: forwardedRef,
        trapFocus: false,
        disableOutsidePointerEvents: false,
        onCloseAutoFocus: (event) => {
          props.onCloseAutoFocus?.(event);
          if (!event.defaultPrevented) {
            if (!hasInteractedOutsideRef.current)
              context.triggerRef.current?.focus();
            event.preventDefault();
          }
          hasInteractedOutsideRef.current = false;
          hasPointerDownOutsideRef.current = false;
        },
        onInteractOutside: (event) => {
          props.onInteractOutside?.(event);
          if (!event.defaultPrevented) {
            hasInteractedOutsideRef.current = true;
            if (event.detail.originalEvent.type === "pointerdown") {
              hasPointerDownOutsideRef.current = true;
            }
          }
          const target = event.target;
          const targetIsTrigger = context.triggerRef.current?.contains(target);
          if (targetIsTrigger)
            event.preventDefault();
          if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) {
            event.preventDefault();
          }
        }
      });
    });
    PopoverContentImpl = React55.forwardRef((props, forwardedRef) => {
      const {
        __scopePopover,
        trapFocus,
        onOpenAutoFocus,
        onCloseAutoFocus,
        disableOutsidePointerEvents,
        onEscapeKeyDown,
        onPointerDownOutside,
        onFocusOutside,
        onInteractOutside,
        ...contentProps
      } = props;
      const context = usePopoverContext(CONTENT_NAME3, __scopePopover);
      const popperScope = usePopperScope(__scopePopover);
      useFocusGuards();
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(FocusScope, {
        asChild: true,
        loop: true,
        trapped: trapFocus,
        onMountAutoFocus: onOpenAutoFocus,
        onUnmountAutoFocus: onCloseAutoFocus,
        children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(DismissableLayer, {
          asChild: true,
          disableOutsidePointerEvents,
          onInteractOutside,
          onEscapeKeyDown,
          onPointerDownOutside,
          onFocusOutside,
          onDismiss: () => context.onOpenChange(false),
          children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Content2, {
            "data-state": getState2(context.open),
            role: "dialog",
            id: context.contentId,
            ...popperScope,
            ...contentProps,
            ref: forwardedRef,
            style: {
              ...contentProps.style,
              ...{
                "--radix-popover-content-transform-origin": "var(--radix-popper-transform-origin)",
                "--radix-popover-content-available-width": "var(--radix-popper-available-width)",
                "--radix-popover-content-available-height": "var(--radix-popper-available-height)",
                "--radix-popover-trigger-width": "var(--radix-popper-anchor-width)",
                "--radix-popover-trigger-height": "var(--radix-popper-anchor-height)"
              }
            }
          })
        })
      });
    });
    CLOSE_NAME3 = "PopoverClose";
    PopoverClose = React55.forwardRef((props, forwardedRef) => {
      const { __scopePopover, ...closeProps } = props;
      const context = usePopoverContext(CLOSE_NAME3, __scopePopover);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Primitive.button, {
        type: "button",
        ...closeProps,
        ref: forwardedRef,
        onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false))
      });
    });
    PopoverClose.displayName = CLOSE_NAME3;
    ARROW_NAME2 = "PopoverArrow";
    PopoverArrow = React55.forwardRef((props, forwardedRef) => {
      const { __scopePopover, ...arrowProps } = props;
      const popperScope = usePopperScope(__scopePopover);
      return /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(Arrow2, { ...popperScope, ...arrowProps, ref: forwardedRef });
    });
    PopoverArrow.displayName = ARROW_NAME2;
    Root24 = Popover;
    Trigger = PopoverTrigger;
    Portal3 = PopoverPortal;
    Content22 = PopoverContent;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useMenuIsOpen.mjs
function useMenuIsOpen(id, cb) {
  const editor = useEditor();
  const rIsOpen = (0, import_react82.useRef)(false);
  const trackEvent = useUiEvents();
  const onOpenChange = (0, import_react82.useCallback)((isOpen2) => {
    rIsOpen.current = isOpen2;
    editor.run(() => {
      if (isOpen2) {
        editor.complete();
        editor.addOpenMenu(id);
      } else {
        editor.updateInstanceState({
          openMenus: editor.getOpenMenus().filter((m2) => !m2.startsWith(id))
        });
      }
      cb?.(isOpen2);
    });
  }, [editor, id, cb]);
  const isOpen = useValue("is menu open", () => editor.getOpenMenus().includes(id), [editor, id]);
  (0, import_react82.useEffect)(() => {
    if (rIsOpen.current) {
      trackEvent("open-menu", { source: "unknown", id });
      editor.addOpenMenu(id);
    }
    return () => {
      if (rIsOpen.current) {
        editor.deleteOpenMenu(id);
        editor.getOpenMenus().forEach((menuId) => {
          if (menuId.startsWith(id)) {
            trackEvent("close-menu", { source: "unknown", id });
            editor.deleteOpenMenu(menuId);
          }
        });
        rIsOpen.current = false;
      }
    };
  }, [editor, id, trackEvent]);
  return [isOpen, onOpenChange];
}
var import_react82;
var init_useMenuIsOpen = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useMenuIsOpen.mjs"() {
    init_dist_esm10();
    import_react82 = __toESM(require_react(), 1);
    init_events();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiPopover.mjs
function TldrawUiPopover({ id, children, onOpenChange, open }) {
  const [isOpen, handleOpenChange] = useMenuIsOpen(id, onOpenChange);
  return /* @__PURE__ */ (0, import_jsx_runtime96.jsx)(Root24, {
    onOpenChange: handleOpenChange,
    open: open || isOpen,
    children: /* @__PURE__ */ (0, import_jsx_runtime96.jsx)("div", { className: "tlui-popover", children })
  });
}
function TldrawUiPopoverTrigger({ children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime96.jsx)(Trigger, { asChild: true, dir: "ltr", children });
}
function TldrawUiPopoverContent({
  side,
  children,
  align = "center",
  sideOffset = 8,
  alignOffset = 0
}) {
  const container = useContainer();
  return /* @__PURE__ */ (0, import_jsx_runtime96.jsx)(Portal3, { container, children: /* @__PURE__ */ (0, import_jsx_runtime96.jsx)(Content22, {
    className: "tlui-popover__content",
    side,
    sideOffset,
    align,
    alignOffset,
    dir: "ltr",
    children
  }) });
}
var import_jsx_runtime96;
var init_TldrawUiPopover = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiPopover.mjs"() {
    import_jsx_runtime96 = __toESM(require_jsx_runtime(), 1);
    init_dist23();
    init_dist_esm10();
    init_useMenuIsOpen();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuContext.mjs
function useTldrawUiMenuContext() {
  const context = (0, import_react83.useContext)(menuContext);
  if (!context) {
    throw new Error("useTldrawUiMenuContext must be used within a TldrawUiMenuContextProvider");
  }
  return context;
}
function TldrawUiMenuContextProvider({
  type,
  sourceId,
  children
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime97.jsx)(menuContext.Provider, { value: { type, sourceId }, children });
}
var import_jsx_runtime97, import_react83, menuContext;
var init_TldrawUiMenuContext = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuContext.mjs"() {
    import_jsx_runtime97 = __toESM(require_jsx_runtime(), 1);
    import_react83 = __toESM(require_react(), 1);
    menuContext = (0, import_react83.createContext)(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/menu-hooks.mjs
function shapesWithUnboundArrows(editor) {
  const selectedShapeIds = editor.getSelectedShapeIds();
  const selectedShapes = selectedShapeIds.map((id) => {
    return editor.getShape(id);
  });
  return selectedShapes.filter((shape) => {
    if (!shape)
      return false;
    if (editor.isShapeOfType(shape, "arrow")) {
      const bindings = getArrowBindings(editor, shape);
      if (bindings.start || bindings.end)
        return false;
    }
    return true;
  });
}
function useAnySelectedShapesCount(min4, max3) {
  const editor = useEditor();
  return useValue("selectedShapes", () => {
    const len = editor.getSelectedShapes().length;
    if (min4 === void 0) {
      if (max3 === void 0) {
        return len;
      } else {
        return len <= max3;
      }
    } else {
      if (max3 === void 0) {
        return len >= min4;
      } else {
        return len >= min4 && len <= max3;
      }
    }
  }, [editor, min4, max3]);
}
function useUnlockedSelectedShapesCount(min4, max3) {
  const editor = useEditor();
  return useValue("selectedShapes", () => {
    const len = editor.getSelectedShapes().filter((s2) => !editor.isShapeOrAncestorLocked(s2)).length;
    if (min4 === void 0) {
      if (max3 === void 0) {
        return len;
      } else {
        return len <= max3;
      }
    } else {
      if (max3 === void 0) {
        return len >= min4;
      } else {
        return len >= min4 && len <= max3;
      }
    }
  }, [editor]);
}
function useShowAutoSizeToggle() {
  const editor = useEditor();
  return useValue("showAutoSizeToggle", () => {
    const selectedShapes = editor.getSelectedShapes();
    return selectedShapes.length === 1 && editor.isShapeOfType(selectedShapes[0], "text") && selectedShapes[0].props.autoSize === false;
  }, [editor]);
}
function useHasLinkShapeSelected() {
  const editor = useEditor();
  return useValue("hasLinkShapeSelected", () => {
    const onlySelectedShape = editor.getOnlySelectedShape();
    return !!(onlySelectedShape && onlySelectedShape.type !== "embed" && "url" in onlySelectedShape.props && !onlySelectedShape.isLocked);
  }, [editor]);
}
function useOnlyFlippableShape() {
  const editor = useEditor();
  return useValue("onlyFlippableShape", () => {
    const shape = editor.getOnlySelectedShape();
    return shape && (editor.isShapeOfType(shape, "group") || editor.isShapeOfType(shape, "image") || editor.isShapeOfType(shape, "arrow") || editor.isShapeOfType(shape, "line") || editor.isShapeOfType(shape, "draw"));
  }, [editor]);
}
function useCanRedo() {
  const editor = useEditor();
  return useValue("useCanRedo", () => editor.getCanRedo(), [editor]);
}
function useCanUndo() {
  const editor = useEditor();
  return useValue("useCanUndo", () => editor.getCanUndo(), [editor]);
}
var useThreeStackableItems, useIsInSelectState, useAllowGroup, useAllowUngroup, showMenuPaste;
var init_menu_hooks = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/menu-hooks.mjs"() {
    init_dist_esm10();
    init_shared();
    useThreeStackableItems = () => {
      const editor = useEditor();
      return useValue("threeStackableItems", () => shapesWithUnboundArrows(editor).length > 2, [editor]);
    };
    useIsInSelectState = () => {
      const editor = useEditor();
      return useValue("isInSelectState", () => editor.isIn("select"), [editor]);
    };
    useAllowGroup = () => {
      const editor = useEditor();
      return useValue("allow group", () => {
        const selectedShapes = editor.getSelectedShapes();
        if (selectedShapes.length < 2)
          return false;
        for (const shape of selectedShapes) {
          if (editor.isShapeOfType(shape, "arrow")) {
            const bindings = getArrowBindings(editor, shape);
            if (bindings.start) {
              if (!selectedShapes.some((s2) => s2.id === bindings.start.toId)) {
                return false;
              }
            }
            if (bindings.end) {
              if (!selectedShapes.some((s2) => s2.id === bindings.end.toId)) {
                return false;
              }
            }
          }
        }
        return true;
      }, [editor]);
    };
    useAllowUngroup = () => {
      const editor = useEditor();
      return useValue("allowUngroup", () => editor.getSelectedShapeIds().some((id) => editor.getShape(id)?.type === "group"), [editor]);
    };
    showMenuPaste = typeof window !== "undefined" && "navigator" in window && Boolean(navigator.clipboard) && Boolean(navigator.clipboard.read);
  }
});

// node_modules/@radix-ui/react-direction/dist/index.mjs
function useDirection(localDir) {
  const globalDir = React56.useContext(DirectionContext);
  return localDir || globalDir || "ltr";
}
var React56, import_jsx_runtime98, DirectionContext;
var init_dist24 = __esm({
  "node_modules/@radix-ui/react-direction/dist/index.mjs"() {
    React56 = __toESM(require_react(), 1);
    import_jsx_runtime98 = __toESM(require_jsx_runtime(), 1);
    DirectionContext = React56.createContext(void 0);
  }
});

// node_modules/@radix-ui/react-roving-focus/dist/index.mjs
function getDirectionAwareKey(key, dir) {
  if (dir !== "rtl")
    return key;
  return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
}
function getFocusIntent(event, orientation, dir) {
  const key = getDirectionAwareKey(event.key, dir);
  if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key))
    return void 0;
  if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key))
    return void 0;
  return MAP_KEY_TO_FOCUS_INTENT[key];
}
function focusFirst3(candidates, preventScroll = false) {
  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
  for (const candidate of candidates) {
    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT)
      return;
    candidate.focus({ preventScroll });
    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT)
      return;
  }
}
function wrapArray(array2, startIndex) {
  return array2.map((_2, index3) => array2[(startIndex + index3) % array2.length]);
}
var React57, import_jsx_runtime99, ENTRY_FOCUS, EVENT_OPTIONS2, GROUP_NAME, Collection2, useCollection2, createCollectionScope2, createRovingFocusGroupContext, createRovingFocusGroupScope, RovingFocusProvider, useRovingFocusContext, RovingFocusGroup, RovingFocusGroupImpl, ITEM_NAME, RovingFocusGroupItem, MAP_KEY_TO_FOCUS_INTENT, Root4, Item;
var init_dist25 = __esm({
  "node_modules/@radix-ui/react-roving-focus/dist/index.mjs"() {
    React57 = __toESM(require_react(), 1);
    init_dist();
    init_dist17();
    init_dist2();
    init_dist3();
    init_dist5();
    init_dist9();
    init_dist6();
    init_dist7();
    init_dist24();
    import_jsx_runtime99 = __toESM(require_jsx_runtime(), 1);
    "use client";
    ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
    EVENT_OPTIONS2 = { bubbles: false, cancelable: true };
    GROUP_NAME = "RovingFocusGroup";
    [Collection2, useCollection2, createCollectionScope2] = createCollection(GROUP_NAME);
    [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(GROUP_NAME, [createCollectionScope2]);
    [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);
    RovingFocusGroup = React57.forwardRef((props, forwardedRef) => {
      return /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(Collection2.Provider, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(Collection2.Slot, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(RovingFocusGroupImpl, { ...props, ref: forwardedRef }) }) });
    });
    RovingFocusGroup.displayName = GROUP_NAME;
    RovingFocusGroupImpl = React57.forwardRef((props, forwardedRef) => {
      const {
        __scopeRovingFocusGroup,
        orientation,
        loop = false,
        dir,
        currentTabStopId: currentTabStopIdProp,
        defaultCurrentTabStopId,
        onCurrentTabStopIdChange,
        onEntryFocus,
        preventScrollOnEntryFocus = false,
        ...groupProps
      } = props;
      const ref = React57.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      const direction = useDirection(dir);
      const [currentTabStopId = null, setCurrentTabStopId] = useControllableState({
        prop: currentTabStopIdProp,
        defaultProp: defaultCurrentTabStopId,
        onChange: onCurrentTabStopIdChange
      });
      const [isTabbingBackOut, setIsTabbingBackOut] = React57.useState(false);
      const handleEntryFocus = useCallbackRef(onEntryFocus);
      const getItems = useCollection2(__scopeRovingFocusGroup);
      const isClickFocusRef = React57.useRef(false);
      const [focusableItemsCount, setFocusableItemsCount] = React57.useState(0);
      React57.useEffect(() => {
        const node = ref.current;
        if (node) {
          node.addEventListener(ENTRY_FOCUS, handleEntryFocus);
          return () => node.removeEventListener(ENTRY_FOCUS, handleEntryFocus);
        }
      }, [handleEntryFocus]);
      return /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(RovingFocusProvider, {
        scope: __scopeRovingFocusGroup,
        orientation,
        dir: direction,
        loop,
        currentTabStopId,
        onItemFocus: React57.useCallback((tabStopId) => setCurrentTabStopId(tabStopId), [setCurrentTabStopId]),
        onItemShiftTab: React57.useCallback(() => setIsTabbingBackOut(true), []),
        onFocusableItemAdd: React57.useCallback(() => setFocusableItemsCount((prevCount) => prevCount + 1), []),
        onFocusableItemRemove: React57.useCallback(() => setFocusableItemsCount((prevCount) => prevCount - 1), []),
        children: /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(Primitive.div, {
          tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
          "data-orientation": orientation,
          ...groupProps,
          ref: composedRefs,
          style: { outline: "none", ...props.style },
          onMouseDown: composeEventHandlers(props.onMouseDown, () => {
            isClickFocusRef.current = true;
          }),
          onFocus: composeEventHandlers(props.onFocus, (event) => {
            const isKeyboardFocus = !isClickFocusRef.current;
            if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
              const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS2);
              event.currentTarget.dispatchEvent(entryFocusEvent);
              if (!entryFocusEvent.defaultPrevented) {
                const items = getItems().filter((item) => item.focusable);
                const activeItem = items.find((item) => item.active);
                const currentItem = items.find((item) => item.id === currentTabStopId);
                const candidateItems = [activeItem, currentItem, ...items].filter(Boolean);
                const candidateNodes = candidateItems.map((item) => item.ref.current);
                focusFirst3(candidateNodes, preventScrollOnEntryFocus);
              }
            }
            isClickFocusRef.current = false;
          }),
          onBlur: composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))
        })
      });
    });
    ITEM_NAME = "RovingFocusGroupItem";
    RovingFocusGroupItem = React57.forwardRef((props, forwardedRef) => {
      const {
        __scopeRovingFocusGroup,
        focusable = true,
        active = false,
        tabStopId,
        ...itemProps
      } = props;
      const autoId = useId2();
      const id = tabStopId || autoId;
      const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);
      const isCurrentTabStop = context.currentTabStopId === id;
      const getItems = useCollection2(__scopeRovingFocusGroup);
      const { onFocusableItemAdd, onFocusableItemRemove } = context;
      React57.useEffect(() => {
        if (focusable) {
          onFocusableItemAdd();
          return () => onFocusableItemRemove();
        }
      }, [focusable, onFocusableItemAdd, onFocusableItemRemove]);
      return /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(Collection2.ItemSlot, {
        scope: __scopeRovingFocusGroup,
        id,
        focusable,
        active,
        children: /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(Primitive.span, {
          tabIndex: isCurrentTabStop ? 0 : -1,
          "data-orientation": context.orientation,
          ...itemProps,
          ref: forwardedRef,
          onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
            if (!focusable)
              event.preventDefault();
            else
              context.onItemFocus(id);
          }),
          onFocus: composeEventHandlers(props.onFocus, () => context.onItemFocus(id)),
          onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
            if (event.key === "Tab" && event.shiftKey) {
              context.onItemShiftTab();
              return;
            }
            if (event.target !== event.currentTarget)
              return;
            const focusIntent = getFocusIntent(event, context.orientation, context.dir);
            if (focusIntent !== void 0) {
              if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey)
                return;
              event.preventDefault();
              const items = getItems().filter((item) => item.focusable);
              let candidateNodes = items.map((item) => item.ref.current);
              if (focusIntent === "last")
                candidateNodes.reverse();
              else if (focusIntent === "prev" || focusIntent === "next") {
                if (focusIntent === "prev")
                  candidateNodes.reverse();
                const currentIndex = candidateNodes.indexOf(event.currentTarget);
                candidateNodes = context.loop ? wrapArray(candidateNodes, currentIndex + 1) : candidateNodes.slice(currentIndex + 1);
              }
              setTimeout(() => focusFirst3(candidateNodes));
            }
          })
        })
      });
    });
    RovingFocusGroupItem.displayName = ITEM_NAME;
    MAP_KEY_TO_FOCUS_INTENT = {
      ArrowLeft: "prev",
      ArrowUp: "prev",
      ArrowRight: "next",
      ArrowDown: "next",
      PageUp: "first",
      Home: "first",
      PageDown: "last",
      End: "last"
    };
    Root4 = RovingFocusGroup;
    Item = RovingFocusGroupItem;
  }
});

// node_modules/@radix-ui/react-menu/dist/index.mjs
function getOpenState(open) {
  return open ? "open" : "closed";
}
function isIndeterminate(checked) {
  return checked === "indeterminate";
}
function getCheckedState(checked) {
  return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
}
function focusFirst4(candidates) {
  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
  for (const candidate of candidates) {
    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT)
      return;
    candidate.focus();
    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT)
      return;
  }
}
function wrapArray2(array2, startIndex) {
  return array2.map((_2, index3) => array2[(startIndex + index3) % array2.length]);
}
function getNextMatch(values, search, currentMatch) {
  const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
  const normalizedSearch = isRepeated ? search[0] : search;
  const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
  let wrappedValues = wrapArray2(values, Math.max(currentMatchIndex, 0));
  const excludeCurrentMatch = normalizedSearch.length === 1;
  if (excludeCurrentMatch)
    wrappedValues = wrappedValues.filter((v2) => v2 !== currentMatch);
  const nextMatch = wrappedValues.find((value) => value.toLowerCase().startsWith(normalizedSearch.toLowerCase()));
  return nextMatch !== currentMatch ? nextMatch : void 0;
}
function isPointInPolygon(point, polygon) {
  const { x: x2, y: y2 } = point;
  let inside = false;
  for (let i2 = 0, j2 = polygon.length - 1; i2 < polygon.length; j2 = i2++) {
    const xi = polygon[i2].x;
    const yi = polygon[i2].y;
    const xj = polygon[j2].x;
    const yj = polygon[j2].y;
    const intersect = yi > y2 !== yj > y2 && x2 < (xj - xi) * (y2 - yi) / (yj - yi) + xi;
    if (intersect)
      inside = !inside;
  }
  return inside;
}
function isPointerInGraceArea(event, area) {
  if (!area)
    return false;
  const cursorPos = { x: event.clientX, y: event.clientY };
  return isPointInPolygon(cursorPos, area);
}
function whenMouse(handler) {
  return (event) => event.pointerType === "mouse" ? handler(event) : void 0;
}
var React58, import_jsx_runtime100, SELECTION_KEYS, FIRST_KEYS, LAST_KEYS, FIRST_LAST_KEYS, SUB_OPEN_KEYS, SUB_CLOSE_KEYS, MENU_NAME, Collection3, useCollection3, createCollectionScope3, createMenuContext, createMenuScope, usePopperScope2, useRovingFocusGroupScope, MenuProvider, useMenuContext, MenuRootProvider, useMenuRootContext, Menu, ANCHOR_NAME3, MenuAnchor, PORTAL_NAME4, PortalProvider3, usePortalContext3, MenuPortal, CONTENT_NAME4, MenuContentProvider, useMenuContentContext, MenuContent, MenuRootContentModal, MenuRootContentNonModal, MenuContentImpl, GROUP_NAME2, MenuGroup, LABEL_NAME, MenuLabel, ITEM_NAME2, ITEM_SELECT, MenuItem, MenuItemImpl, CHECKBOX_ITEM_NAME, MenuCheckboxItem, RADIO_GROUP_NAME, RadioGroupProvider, useRadioGroupContext, MenuRadioGroup, RADIO_ITEM_NAME, MenuRadioItem, ITEM_INDICATOR_NAME, ItemIndicatorProvider, useItemIndicatorContext, MenuItemIndicator, SEPARATOR_NAME, MenuSeparator, ARROW_NAME3, MenuArrow, SUB_NAME, MenuSubProvider, useMenuSubContext, MenuSub, SUB_TRIGGER_NAME, MenuSubTrigger, SUB_CONTENT_NAME, MenuSubContent, Root32, Anchor2, Portal4, Content23, Group, Label, Item2, CheckboxItem, RadioGroup, RadioItem, ItemIndicator, Separator, Arrow22, Sub, SubTrigger, SubContent;
var init_dist26 = __esm({
  "node_modules/@radix-ui/react-menu/dist/index.mjs"() {
    React58 = __toESM(require_react(), 1);
    init_dist();
    init_dist17();
    init_dist2();
    init_dist3();
    init_dist24();
    init_dist11();
    init_dist15();
    init_dist12();
    init_dist5();
    init_dist22();
    init_dist22();
    init_dist13();
    init_dist14();
    init_dist9();
    init_dist25();
    init_dist25();
    init_dist8();
    init_dist6();
    init_es20157();
    init_es20156();
    import_jsx_runtime100 = __toESM(require_jsx_runtime(), 1);
    "use client";
    SELECTION_KEYS = ["Enter", " "];
    FIRST_KEYS = ["ArrowDown", "PageUp", "Home"];
    LAST_KEYS = ["ArrowUp", "PageDown", "End"];
    FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
    SUB_OPEN_KEYS = {
      ltr: [...SELECTION_KEYS, "ArrowRight"],
      rtl: [...SELECTION_KEYS, "ArrowLeft"]
    };
    SUB_CLOSE_KEYS = {
      ltr: ["ArrowLeft"],
      rtl: ["ArrowRight"]
    };
    MENU_NAME = "Menu";
    [Collection3, useCollection3, createCollectionScope3] = createCollection(MENU_NAME);
    [createMenuContext, createMenuScope] = createContextScope(MENU_NAME, [
      createCollectionScope3,
      createPopperScope,
      createRovingFocusGroupScope
    ]);
    usePopperScope2 = createPopperScope();
    useRovingFocusGroupScope = createRovingFocusGroupScope();
    [MenuProvider, useMenuContext] = createMenuContext(MENU_NAME);
    [MenuRootProvider, useMenuRootContext] = createMenuContext(MENU_NAME);
    Menu = (props) => {
      const { __scopeMenu, open = false, children, dir, onOpenChange, modal = true } = props;
      const popperScope = usePopperScope2(__scopeMenu);
      const [content, setContent2] = React58.useState(null);
      const isUsingKeyboardRef = React58.useRef(false);
      const handleOpenChange = useCallbackRef(onOpenChange);
      const direction = useDirection(dir);
      React58.useEffect(() => {
        const handleKeyDown = () => {
          isUsingKeyboardRef.current = true;
          document.addEventListener("pointerdown", handlePointer, { capture: true, once: true });
          document.addEventListener("pointermove", handlePointer, { capture: true, once: true });
        };
        const handlePointer = () => isUsingKeyboardRef.current = false;
        document.addEventListener("keydown", handleKeyDown, { capture: true });
        return () => {
          document.removeEventListener("keydown", handleKeyDown, { capture: true });
          document.removeEventListener("pointerdown", handlePointer, { capture: true });
          document.removeEventListener("pointermove", handlePointer, { capture: true });
        };
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Root23, { ...popperScope, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuProvider, {
        scope: __scopeMenu,
        open,
        onOpenChange: handleOpenChange,
        content,
        onContentChange: setContent2,
        children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuRootProvider, {
          scope: __scopeMenu,
          onClose: React58.useCallback(() => handleOpenChange(false), [handleOpenChange]),
          isUsingKeyboardRef,
          dir: direction,
          modal,
          children
        })
      }) });
    };
    Menu.displayName = MENU_NAME;
    ANCHOR_NAME3 = "MenuAnchor";
    MenuAnchor = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, ...anchorProps } = props;
      const popperScope = usePopperScope2(__scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Anchor, { ...popperScope, ...anchorProps, ref: forwardedRef });
    });
    MenuAnchor.displayName = ANCHOR_NAME3;
    PORTAL_NAME4 = "MenuPortal";
    [PortalProvider3, usePortalContext3] = createMenuContext(PORTAL_NAME4, {
      forceMount: void 0
    });
    MenuPortal = (props) => {
      const { __scopeMenu, forceMount, children, container } = props;
      const context = useMenuContext(PORTAL_NAME4, __scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(PortalProvider3, { scope: __scopeMenu, forceMount, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Portal, { asChild: true, container, children }) }) });
    };
    MenuPortal.displayName = PORTAL_NAME4;
    CONTENT_NAME4 = "MenuContent";
    [MenuContentProvider, useMenuContentContext] = createMenuContext(CONTENT_NAME4);
    MenuContent = React58.forwardRef((props, forwardedRef) => {
      const portalContext = usePortalContext3(CONTENT_NAME4, props.__scopeMenu);
      const { forceMount = portalContext.forceMount, ...contentProps } = props;
      const context = useMenuContext(CONTENT_NAME4, props.__scopeMenu);
      const rootContext = useMenuRootContext(CONTENT_NAME4, props.__scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Collection3.Provider, { scope: props.__scopeMenu, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Collection3.Slot, { scope: props.__scopeMenu, children: rootContext.modal ? /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuRootContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuRootContentNonModal, { ...contentProps, ref: forwardedRef }) }) }) });
    });
    MenuRootContentModal = React58.forwardRef((props, forwardedRef) => {
      const context = useMenuContext(CONTENT_NAME4, props.__scopeMenu);
      const ref = React58.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      React58.useEffect(() => {
        const content = ref.current;
        if (content)
          return hideOthers(content);
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuContentImpl, {
        ...props,
        ref: composedRefs,
        trapFocus: context.open,
        disableOutsidePointerEvents: context.open,
        disableOutsideScroll: true,
        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => event.preventDefault(), { checkForDefaultPrevented: false }),
        onDismiss: () => context.onOpenChange(false)
      });
    });
    MenuRootContentNonModal = React58.forwardRef((props, forwardedRef) => {
      const context = useMenuContext(CONTENT_NAME4, props.__scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuContentImpl, {
        ...props,
        ref: forwardedRef,
        trapFocus: false,
        disableOutsidePointerEvents: false,
        disableOutsideScroll: false,
        onDismiss: () => context.onOpenChange(false)
      });
    });
    MenuContentImpl = React58.forwardRef((props, forwardedRef) => {
      const {
        __scopeMenu,
        loop = false,
        trapFocus,
        onOpenAutoFocus,
        onCloseAutoFocus,
        disableOutsidePointerEvents,
        onEntryFocus,
        onEscapeKeyDown,
        onPointerDownOutside,
        onFocusOutside,
        onInteractOutside,
        onDismiss,
        disableOutsideScroll,
        ...contentProps
      } = props;
      const context = useMenuContext(CONTENT_NAME4, __scopeMenu);
      const rootContext = useMenuRootContext(CONTENT_NAME4, __scopeMenu);
      const popperScope = usePopperScope2(__scopeMenu);
      const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
      const getItems = useCollection3(__scopeMenu);
      const [currentItemId, setCurrentItemId] = React58.useState(null);
      const contentRef = React58.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, contentRef, context.onContentChange);
      const timerRef = React58.useRef(0);
      const searchRef = React58.useRef("");
      const pointerGraceTimerRef = React58.useRef(0);
      const pointerGraceIntentRef = React58.useRef(null);
      const pointerDirRef = React58.useRef("right");
      const lastPointerXRef = React58.useRef(0);
      const ScrollLockWrapper = disableOutsideScroll ? Combination_default : React58.Fragment;
      const scrollLockWrapperProps = disableOutsideScroll ? { as: Slot, allowPinchZoom: true } : void 0;
      const handleTypeaheadSearch = (key) => {
        const search = searchRef.current + key;
        const items = getItems().filter((item) => !item.disabled);
        const currentItem = document.activeElement;
        const currentMatch = items.find((item) => item.ref.current === currentItem)?.textValue;
        const values = items.map((item) => item.textValue);
        const nextMatch = getNextMatch(values, search, currentMatch);
        const newItem = items.find((item) => item.textValue === nextMatch)?.ref.current;
        (function updateSearch(value) {
          searchRef.current = value;
          window.clearTimeout(timerRef.current);
          if (value !== "")
            timerRef.current = window.setTimeout(() => updateSearch(""), 1e3);
        })(search);
        if (newItem) {
          setTimeout(() => newItem.focus());
        }
      };
      React58.useEffect(() => {
        return () => window.clearTimeout(timerRef.current);
      }, []);
      useFocusGuards();
      const isPointerMovingToSubmenu = React58.useCallback((event) => {
        const isMovingTowards = pointerDirRef.current === pointerGraceIntentRef.current?.side;
        return isMovingTowards && isPointerInGraceArea(event, pointerGraceIntentRef.current?.area);
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuContentProvider, {
        scope: __scopeMenu,
        searchRef,
        onItemEnter: React58.useCallback((event) => {
          if (isPointerMovingToSubmenu(event))
            event.preventDefault();
        }, [isPointerMovingToSubmenu]),
        onItemLeave: React58.useCallback((event) => {
          if (isPointerMovingToSubmenu(event))
            return;
          contentRef.current?.focus();
          setCurrentItemId(null);
        }, [isPointerMovingToSubmenu]),
        onTriggerLeave: React58.useCallback((event) => {
          if (isPointerMovingToSubmenu(event))
            event.preventDefault();
        }, [isPointerMovingToSubmenu]),
        pointerGraceTimerRef,
        onPointerGraceIntentChange: React58.useCallback((intent) => {
          pointerGraceIntentRef.current = intent;
        }, []),
        children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(ScrollLockWrapper, { ...scrollLockWrapperProps, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(FocusScope, {
          asChild: true,
          trapped: trapFocus,
          onMountAutoFocus: composeEventHandlers(onOpenAutoFocus, (event) => {
            event.preventDefault();
            contentRef.current?.focus({ preventScroll: true });
          }),
          onUnmountAutoFocus: onCloseAutoFocus,
          children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(DismissableLayer, {
            asChild: true,
            disableOutsidePointerEvents,
            onEscapeKeyDown,
            onPointerDownOutside,
            onFocusOutside,
            onInteractOutside,
            onDismiss,
            children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Root4, {
              asChild: true,
              ...rovingFocusGroupScope,
              dir: rootContext.dir,
              orientation: "vertical",
              loop,
              currentTabStopId: currentItemId,
              onCurrentTabStopIdChange: setCurrentItemId,
              onEntryFocus: composeEventHandlers(onEntryFocus, (event) => {
                if (!rootContext.isUsingKeyboardRef.current)
                  event.preventDefault();
              }),
              preventScrollOnEntryFocus: true,
              children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Content2, {
                role: "menu",
                "aria-orientation": "vertical",
                "data-state": getOpenState(context.open),
                "data-radix-menu-content": "",
                dir: rootContext.dir,
                ...popperScope,
                ...contentProps,
                ref: composedRefs,
                style: { outline: "none", ...contentProps.style },
                onKeyDown: composeEventHandlers(contentProps.onKeyDown, (event) => {
                  const target = event.target;
                  const isKeyDownInside = target.closest("[data-radix-menu-content]") === event.currentTarget;
                  const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
                  const isCharacterKey = event.key.length === 1;
                  if (isKeyDownInside) {
                    if (event.key === "Tab")
                      event.preventDefault();
                    if (!isModifierKey && isCharacterKey)
                      handleTypeaheadSearch(event.key);
                  }
                  const content = contentRef.current;
                  if (event.target !== content)
                    return;
                  if (!FIRST_LAST_KEYS.includes(event.key))
                    return;
                  event.preventDefault();
                  const items = getItems().filter((item) => !item.disabled);
                  const candidateNodes = items.map((item) => item.ref.current);
                  if (LAST_KEYS.includes(event.key))
                    candidateNodes.reverse();
                  focusFirst4(candidateNodes);
                }),
                onBlur: composeEventHandlers(props.onBlur, (event) => {
                  if (!event.currentTarget.contains(event.target)) {
                    window.clearTimeout(timerRef.current);
                    searchRef.current = "";
                  }
                }),
                onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event) => {
                  const target = event.target;
                  const pointerXHasChanged = lastPointerXRef.current !== event.clientX;
                  if (event.currentTarget.contains(target) && pointerXHasChanged) {
                    const newDir = event.clientX > lastPointerXRef.current ? "right" : "left";
                    pointerDirRef.current = newDir;
                    lastPointerXRef.current = event.clientX;
                  }
                }))
              })
            })
          })
        }) })
      });
    });
    MenuContent.displayName = CONTENT_NAME4;
    GROUP_NAME2 = "MenuGroup";
    MenuGroup = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, ...groupProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Primitive.div, { role: "group", ...groupProps, ref: forwardedRef });
    });
    MenuGroup.displayName = GROUP_NAME2;
    LABEL_NAME = "MenuLabel";
    MenuLabel = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, ...labelProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Primitive.div, { ...labelProps, ref: forwardedRef });
    });
    MenuLabel.displayName = LABEL_NAME;
    ITEM_NAME2 = "MenuItem";
    ITEM_SELECT = "menu.itemSelect";
    MenuItem = React58.forwardRef((props, forwardedRef) => {
      const { disabled = false, onSelect, ...itemProps } = props;
      const ref = React58.useRef(null);
      const rootContext = useMenuRootContext(ITEM_NAME2, props.__scopeMenu);
      const contentContext = useMenuContentContext(ITEM_NAME2, props.__scopeMenu);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      const isPointerDownRef = React58.useRef(false);
      const handleSelect = () => {
        const menuItem = ref.current;
        if (!disabled && menuItem) {
          const itemSelectEvent = new CustomEvent(ITEM_SELECT, { bubbles: true, cancelable: true });
          menuItem.addEventListener(ITEM_SELECT, (event) => onSelect?.(event), { once: true });
          dispatchDiscreteCustomEvent(menuItem, itemSelectEvent);
          if (itemSelectEvent.defaultPrevented) {
            isPointerDownRef.current = false;
          } else {
            rootContext.onClose();
          }
        }
      };
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuItemImpl, {
        ...itemProps,
        ref: composedRefs,
        disabled,
        onClick: composeEventHandlers(props.onClick, handleSelect),
        onPointerDown: (event) => {
          props.onPointerDown?.(event);
          isPointerDownRef.current = true;
        },
        onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {
          if (!isPointerDownRef.current)
            event.currentTarget?.click();
        }),
        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
          const isTypingAhead = contentContext.searchRef.current !== "";
          if (disabled || isTypingAhead && event.key === " ")
            return;
          if (SELECTION_KEYS.includes(event.key)) {
            event.currentTarget.click();
            event.preventDefault();
          }
        })
      });
    });
    MenuItem.displayName = ITEM_NAME2;
    MenuItemImpl = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, disabled = false, textValue, ...itemProps } = props;
      const contentContext = useMenuContentContext(ITEM_NAME2, __scopeMenu);
      const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
      const ref = React58.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      const [isFocused, setIsFocused] = React58.useState(false);
      const [textContent, setTextContent] = React58.useState("");
      React58.useEffect(() => {
        const menuItem = ref.current;
        if (menuItem) {
          setTextContent((menuItem.textContent ?? "").trim());
        }
      }, [itemProps.children]);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Collection3.ItemSlot, {
        scope: __scopeMenu,
        disabled,
        textValue: textValue ?? textContent,
        children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Item, { asChild: true, ...rovingFocusGroupScope, focusable: !disabled, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Primitive.div, {
          role: "menuitem",
          "data-highlighted": isFocused ? "" : void 0,
          "aria-disabled": disabled || void 0,
          "data-disabled": disabled ? "" : void 0,
          ...itemProps,
          ref: composedRefs,
          onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event) => {
            if (disabled) {
              contentContext.onItemLeave(event);
            } else {
              contentContext.onItemEnter(event);
              if (!event.defaultPrevented) {
                const item = event.currentTarget;
                item.focus({ preventScroll: true });
              }
            }
          })),
          onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse((event) => contentContext.onItemLeave(event))),
          onFocus: composeEventHandlers(props.onFocus, () => setIsFocused(true)),
          onBlur: composeEventHandlers(props.onBlur, () => setIsFocused(false))
        }) })
      });
    });
    CHECKBOX_ITEM_NAME = "MenuCheckboxItem";
    MenuCheckboxItem = React58.forwardRef((props, forwardedRef) => {
      const { checked = false, onCheckedChange, ...checkboxItemProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuItem, {
        role: "menuitemcheckbox",
        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
        ...checkboxItemProps,
        ref: forwardedRef,
        "data-state": getCheckedState(checked),
        onSelect: composeEventHandlers(checkboxItemProps.onSelect, () => onCheckedChange?.(isIndeterminate(checked) ? true : !checked), { checkForDefaultPrevented: false })
      }) });
    });
    MenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
    RADIO_GROUP_NAME = "MenuRadioGroup";
    [RadioGroupProvider, useRadioGroupContext] = createMenuContext(RADIO_GROUP_NAME, { value: void 0, onValueChange: () => {
    } });
    MenuRadioGroup = React58.forwardRef((props, forwardedRef) => {
      const { value, onValueChange, ...groupProps } = props;
      const handleValueChange = useCallbackRef(onValueChange);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(RadioGroupProvider, { scope: props.__scopeMenu, value, onValueChange: handleValueChange, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuGroup, { ...groupProps, ref: forwardedRef }) });
    });
    MenuRadioGroup.displayName = RADIO_GROUP_NAME;
    RADIO_ITEM_NAME = "MenuRadioItem";
    MenuRadioItem = React58.forwardRef((props, forwardedRef) => {
      const { value, ...radioItemProps } = props;
      const context = useRadioGroupContext(RADIO_ITEM_NAME, props.__scopeMenu);
      const checked = value === context.value;
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuItem, {
        role: "menuitemradio",
        "aria-checked": checked,
        ...radioItemProps,
        ref: forwardedRef,
        "data-state": getCheckedState(checked),
        onSelect: composeEventHandlers(radioItemProps.onSelect, () => context.onValueChange?.(value), { checkForDefaultPrevented: false })
      }) });
    });
    MenuRadioItem.displayName = RADIO_ITEM_NAME;
    ITEM_INDICATOR_NAME = "MenuItemIndicator";
    [ItemIndicatorProvider, useItemIndicatorContext] = createMenuContext(ITEM_INDICATOR_NAME, { checked: false });
    MenuItemIndicator = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, forceMount, ...itemIndicatorProps } = props;
      const indicatorContext = useItemIndicatorContext(ITEM_INDICATOR_NAME, __scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Presence, {
        present: forceMount || isIndeterminate(indicatorContext.checked) || indicatorContext.checked === true,
        children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Primitive.span, {
          ...itemIndicatorProps,
          ref: forwardedRef,
          "data-state": getCheckedState(indicatorContext.checked)
        })
      });
    });
    MenuItemIndicator.displayName = ITEM_INDICATOR_NAME;
    SEPARATOR_NAME = "MenuSeparator";
    MenuSeparator = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, ...separatorProps } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Primitive.div, {
        role: "separator",
        "aria-orientation": "horizontal",
        ...separatorProps,
        ref: forwardedRef
      });
    });
    MenuSeparator.displayName = SEPARATOR_NAME;
    ARROW_NAME3 = "MenuArrow";
    MenuArrow = React58.forwardRef((props, forwardedRef) => {
      const { __scopeMenu, ...arrowProps } = props;
      const popperScope = usePopperScope2(__scopeMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Arrow2, { ...popperScope, ...arrowProps, ref: forwardedRef });
    });
    MenuArrow.displayName = ARROW_NAME3;
    SUB_NAME = "MenuSub";
    [MenuSubProvider, useMenuSubContext] = createMenuContext(SUB_NAME);
    MenuSub = (props) => {
      const { __scopeMenu, children, open = false, onOpenChange } = props;
      const parentMenuContext = useMenuContext(SUB_NAME, __scopeMenu);
      const popperScope = usePopperScope2(__scopeMenu);
      const [trigger2, setTrigger] = React58.useState(null);
      const [content, setContent2] = React58.useState(null);
      const handleOpenChange = useCallbackRef(onOpenChange);
      React58.useEffect(() => {
        if (parentMenuContext.open === false)
          handleOpenChange(false);
        return () => handleOpenChange(false);
      }, [parentMenuContext.open, handleOpenChange]);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Root23, { ...popperScope, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuProvider, {
        scope: __scopeMenu,
        open,
        onOpenChange: handleOpenChange,
        content,
        onContentChange: setContent2,
        children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuSubProvider, {
          scope: __scopeMenu,
          contentId: useId2(),
          triggerId: useId2(),
          trigger: trigger2,
          onTriggerChange: setTrigger,
          children
        })
      }) });
    };
    MenuSub.displayName = SUB_NAME;
    SUB_TRIGGER_NAME = "MenuSubTrigger";
    MenuSubTrigger = React58.forwardRef((props, forwardedRef) => {
      const context = useMenuContext(SUB_TRIGGER_NAME, props.__scopeMenu);
      const rootContext = useMenuRootContext(SUB_TRIGGER_NAME, props.__scopeMenu);
      const subContext = useMenuSubContext(SUB_TRIGGER_NAME, props.__scopeMenu);
      const contentContext = useMenuContentContext(SUB_TRIGGER_NAME, props.__scopeMenu);
      const openTimerRef = React58.useRef(null);
      const { pointerGraceTimerRef, onPointerGraceIntentChange } = contentContext;
      const scope = { __scopeMenu: props.__scopeMenu };
      const clearOpenTimer = React58.useCallback(() => {
        if (openTimerRef.current)
          window.clearTimeout(openTimerRef.current);
        openTimerRef.current = null;
      }, []);
      React58.useEffect(() => clearOpenTimer, [clearOpenTimer]);
      React58.useEffect(() => {
        const pointerGraceTimer = pointerGraceTimerRef.current;
        return () => {
          window.clearTimeout(pointerGraceTimer);
          onPointerGraceIntentChange(null);
        };
      }, [pointerGraceTimerRef, onPointerGraceIntentChange]);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuAnchor, { asChild: true, ...scope, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuItemImpl, {
        id: subContext.triggerId,
        "aria-haspopup": "menu",
        "aria-expanded": context.open,
        "aria-controls": subContext.contentId,
        "data-state": getOpenState(context.open),
        ...props,
        ref: composeRefs(forwardedRef, subContext.onTriggerChange),
        onClick: (event) => {
          props.onClick?.(event);
          if (props.disabled || event.defaultPrevented)
            return;
          event.currentTarget.focus();
          if (!context.open)
            context.onOpenChange(true);
        },
        onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event) => {
          contentContext.onItemEnter(event);
          if (event.defaultPrevented)
            return;
          if (!props.disabled && !context.open && !openTimerRef.current) {
            contentContext.onPointerGraceIntentChange(null);
            openTimerRef.current = window.setTimeout(() => {
              context.onOpenChange(true);
              clearOpenTimer();
            }, 100);
          }
        })),
        onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse((event) => {
          clearOpenTimer();
          const contentRect = context.content?.getBoundingClientRect();
          if (contentRect) {
            const side = context.content?.dataset.side;
            const rightSide = side === "right";
            const bleed = rightSide ? -5 : 5;
            const contentNearEdge = contentRect[rightSide ? "left" : "right"];
            const contentFarEdge = contentRect[rightSide ? "right" : "left"];
            contentContext.onPointerGraceIntentChange({
              area: [
                { x: event.clientX + bleed, y: event.clientY },
                { x: contentNearEdge, y: contentRect.top },
                { x: contentFarEdge, y: contentRect.top },
                { x: contentFarEdge, y: contentRect.bottom },
                { x: contentNearEdge, y: contentRect.bottom }
              ],
              side
            });
            window.clearTimeout(pointerGraceTimerRef.current);
            pointerGraceTimerRef.current = window.setTimeout(() => contentContext.onPointerGraceIntentChange(null), 300);
          } else {
            contentContext.onTriggerLeave(event);
            if (event.defaultPrevented)
              return;
            contentContext.onPointerGraceIntentChange(null);
          }
        })),
        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
          const isTypingAhead = contentContext.searchRef.current !== "";
          if (props.disabled || isTypingAhead && event.key === " ")
            return;
          if (SUB_OPEN_KEYS[rootContext.dir].includes(event.key)) {
            context.onOpenChange(true);
            context.content?.focus();
            event.preventDefault();
          }
        })
      }) });
    });
    MenuSubTrigger.displayName = SUB_TRIGGER_NAME;
    SUB_CONTENT_NAME = "MenuSubContent";
    MenuSubContent = React58.forwardRef((props, forwardedRef) => {
      const portalContext = usePortalContext3(CONTENT_NAME4, props.__scopeMenu);
      const { forceMount = portalContext.forceMount, ...subContentProps } = props;
      const context = useMenuContext(CONTENT_NAME4, props.__scopeMenu);
      const rootContext = useMenuRootContext(CONTENT_NAME4, props.__scopeMenu);
      const subContext = useMenuSubContext(SUB_CONTENT_NAME, props.__scopeMenu);
      const ref = React58.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Collection3.Provider, { scope: props.__scopeMenu, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(Collection3.Slot, { scope: props.__scopeMenu, children: /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(MenuContentImpl, {
        id: subContext.contentId,
        "aria-labelledby": subContext.triggerId,
        ...subContentProps,
        ref: composedRefs,
        align: "start",
        side: rootContext.dir === "rtl" ? "left" : "right",
        disableOutsidePointerEvents: false,
        disableOutsideScroll: false,
        trapFocus: false,
        onOpenAutoFocus: (event) => {
          if (rootContext.isUsingKeyboardRef.current)
            ref.current?.focus();
          event.preventDefault();
        },
        onCloseAutoFocus: (event) => event.preventDefault(),
        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => {
          if (event.target !== subContext.trigger)
            context.onOpenChange(false);
        }),
        onEscapeKeyDown: composeEventHandlers(props.onEscapeKeyDown, (event) => {
          rootContext.onClose();
          event.preventDefault();
        }),
        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
          const isKeyDownInside = event.currentTarget.contains(event.target);
          const isCloseKey = SUB_CLOSE_KEYS[rootContext.dir].includes(event.key);
          if (isKeyDownInside && isCloseKey) {
            context.onOpenChange(false);
            subContext.trigger?.focus();
            event.preventDefault();
          }
        })
      }) }) }) });
    });
    MenuSubContent.displayName = SUB_CONTENT_NAME;
    Root32 = Menu;
    Anchor2 = MenuAnchor;
    Portal4 = MenuPortal;
    Content23 = MenuContent;
    Group = MenuGroup;
    Label = MenuLabel;
    Item2 = MenuItem;
    CheckboxItem = MenuCheckboxItem;
    RadioGroup = MenuRadioGroup;
    RadioItem = MenuRadioItem;
    ItemIndicator = MenuItemIndicator;
    Separator = MenuSeparator;
    Arrow22 = MenuArrow;
    Sub = MenuSub;
    SubTrigger = MenuSubTrigger;
    SubContent = MenuSubContent;
  }
});

// node_modules/@radix-ui/react-context-menu/dist/index.mjs
function whenTouchOrPen(handler) {
  return (event) => event.pointerType !== "mouse" ? handler(event) : void 0;
}
var React59, import_jsx_runtime101, CONTEXT_MENU_NAME, createContextMenuContext, createContextMenuScope, useMenuScope, ContextMenuProvider, useContextMenuContext, ContextMenu, TRIGGER_NAME3, ContextMenuTrigger, PORTAL_NAME5, ContextMenuPortal, CONTENT_NAME5, ContextMenuContent, GROUP_NAME3, ContextMenuGroup, LABEL_NAME2, ContextMenuLabel, ITEM_NAME3, ContextMenuItem, CHECKBOX_ITEM_NAME2, ContextMenuCheckboxItem, RADIO_GROUP_NAME2, ContextMenuRadioGroup, RADIO_ITEM_NAME2, ContextMenuRadioItem, INDICATOR_NAME, ContextMenuItemIndicator, SEPARATOR_NAME2, ContextMenuSeparator, ARROW_NAME4, ContextMenuArrow, SUB_NAME2, ContextMenuSub, SUB_TRIGGER_NAME2, ContextMenuSubTrigger, SUB_CONTENT_NAME2, ContextMenuSubContent, Root25, Trigger2, Portal22, Content24, CheckboxItem2;
var init_dist27 = __esm({
  "node_modules/@radix-ui/react-context-menu/dist/index.mjs"() {
    React59 = __toESM(require_react(), 1);
    init_dist();
    init_dist3();
    init_dist9();
    init_dist26();
    init_dist26();
    init_dist6();
    init_dist7();
    import_jsx_runtime101 = __toESM(require_jsx_runtime(), 1);
    "use client";
    CONTEXT_MENU_NAME = "ContextMenu";
    [createContextMenuContext, createContextMenuScope] = createContextScope(CONTEXT_MENU_NAME, [
      createMenuScope
    ]);
    useMenuScope = createMenuScope();
    [ContextMenuProvider, useContextMenuContext] = createContextMenuContext(CONTEXT_MENU_NAME);
    ContextMenu = (props) => {
      const { __scopeContextMenu, children, onOpenChange, dir, modal = true } = props;
      const [open, setOpen] = React59.useState(false);
      const menuScope = useMenuScope(__scopeContextMenu);
      const handleOpenChangeProp = useCallbackRef(onOpenChange);
      const handleOpenChange = React59.useCallback((open2) => {
        setOpen(open2);
        handleOpenChangeProp(open2);
      }, [handleOpenChangeProp]);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(ContextMenuProvider, {
        scope: __scopeContextMenu,
        open,
        onOpenChange: handleOpenChange,
        modal,
        children: /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Root32, {
          ...menuScope,
          dir,
          open,
          onOpenChange: handleOpenChange,
          modal,
          children
        })
      });
    };
    ContextMenu.displayName = CONTEXT_MENU_NAME;
    TRIGGER_NAME3 = "ContextMenuTrigger";
    ContextMenuTrigger = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, disabled = false, ...triggerProps } = props;
      const context = useContextMenuContext(TRIGGER_NAME3, __scopeContextMenu);
      const menuScope = useMenuScope(__scopeContextMenu);
      const pointRef = React59.useRef({ x: 0, y: 0 });
      const virtualRef = React59.useRef({
        getBoundingClientRect: () => DOMRect.fromRect({ width: 0, height: 0, ...pointRef.current })
      });
      const longPressTimerRef = React59.useRef(0);
      const clearLongPress = React59.useCallback(() => window.clearTimeout(longPressTimerRef.current), []);
      const handleOpen = (event) => {
        pointRef.current = { x: event.clientX, y: event.clientY };
        context.onOpenChange(true);
      };
      React59.useEffect(() => clearLongPress, [clearLongPress]);
      React59.useEffect(() => void (disabled && clearLongPress()), [disabled, clearLongPress]);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsxs)(import_jsx_runtime101.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Anchor2, { ...menuScope, virtualRef }),
        /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Primitive.span, {
          "data-state": context.open ? "open" : "closed",
          "data-disabled": disabled ? "" : void 0,
          ...triggerProps,
          ref: forwardedRef,
          style: { WebkitTouchCallout: "none", ...props.style },
          onContextMenu: disabled ? props.onContextMenu : composeEventHandlers(props.onContextMenu, (event) => {
            clearLongPress();
            handleOpen(event);
            event.preventDefault();
          }),
          onPointerDown: disabled ? props.onPointerDown : composeEventHandlers(props.onPointerDown, whenTouchOrPen((event) => {
            clearLongPress();
            longPressTimerRef.current = window.setTimeout(() => handleOpen(event), 700);
          })),
          onPointerMove: disabled ? props.onPointerMove : composeEventHandlers(props.onPointerMove, whenTouchOrPen(clearLongPress)),
          onPointerCancel: disabled ? props.onPointerCancel : composeEventHandlers(props.onPointerCancel, whenTouchOrPen(clearLongPress)),
          onPointerUp: disabled ? props.onPointerUp : composeEventHandlers(props.onPointerUp, whenTouchOrPen(clearLongPress))
        })
      ] });
    });
    ContextMenuTrigger.displayName = TRIGGER_NAME3;
    PORTAL_NAME5 = "ContextMenuPortal";
    ContextMenuPortal = (props) => {
      const { __scopeContextMenu, ...portalProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Portal4, { ...menuScope, ...portalProps });
    };
    ContextMenuPortal.displayName = PORTAL_NAME5;
    CONTENT_NAME5 = "ContextMenuContent";
    ContextMenuContent = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...contentProps } = props;
      const context = useContextMenuContext(CONTENT_NAME5, __scopeContextMenu);
      const menuScope = useMenuScope(__scopeContextMenu);
      const hasInteractedOutsideRef = React59.useRef(false);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Content23, {
        ...menuScope,
        ...contentProps,
        ref: forwardedRef,
        side: "right",
        sideOffset: 2,
        align: "start",
        onCloseAutoFocus: (event) => {
          props.onCloseAutoFocus?.(event);
          if (!event.defaultPrevented && hasInteractedOutsideRef.current) {
            event.preventDefault();
          }
          hasInteractedOutsideRef.current = false;
        },
        onInteractOutside: (event) => {
          props.onInteractOutside?.(event);
          if (!event.defaultPrevented && !context.modal)
            hasInteractedOutsideRef.current = true;
        },
        style: {
          ...props.style,
          ...{
            "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
            "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
            "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
            "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
            "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
          }
        }
      });
    });
    ContextMenuContent.displayName = CONTENT_NAME5;
    GROUP_NAME3 = "ContextMenuGroup";
    ContextMenuGroup = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...groupProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Group, { ...menuScope, ...groupProps, ref: forwardedRef });
    });
    ContextMenuGroup.displayName = GROUP_NAME3;
    LABEL_NAME2 = "ContextMenuLabel";
    ContextMenuLabel = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...labelProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Label, { ...menuScope, ...labelProps, ref: forwardedRef });
    });
    ContextMenuLabel.displayName = LABEL_NAME2;
    ITEM_NAME3 = "ContextMenuItem";
    ContextMenuItem = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...itemProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Item2, { ...menuScope, ...itemProps, ref: forwardedRef });
    });
    ContextMenuItem.displayName = ITEM_NAME3;
    CHECKBOX_ITEM_NAME2 = "ContextMenuCheckboxItem";
    ContextMenuCheckboxItem = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...checkboxItemProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });
    });
    ContextMenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME2;
    RADIO_GROUP_NAME2 = "ContextMenuRadioGroup";
    ContextMenuRadioGroup = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...radioGroupProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(RadioGroup, { ...menuScope, ...radioGroupProps, ref: forwardedRef });
    });
    ContextMenuRadioGroup.displayName = RADIO_GROUP_NAME2;
    RADIO_ITEM_NAME2 = "ContextMenuRadioItem";
    ContextMenuRadioItem = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...radioItemProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(RadioItem, { ...menuScope, ...radioItemProps, ref: forwardedRef });
    });
    ContextMenuRadioItem.displayName = RADIO_ITEM_NAME2;
    INDICATOR_NAME = "ContextMenuItemIndicator";
    ContextMenuItemIndicator = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...itemIndicatorProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(ItemIndicator, { ...menuScope, ...itemIndicatorProps, ref: forwardedRef });
    });
    ContextMenuItemIndicator.displayName = INDICATOR_NAME;
    SEPARATOR_NAME2 = "ContextMenuSeparator";
    ContextMenuSeparator = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...separatorProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Separator, { ...menuScope, ...separatorProps, ref: forwardedRef });
    });
    ContextMenuSeparator.displayName = SEPARATOR_NAME2;
    ARROW_NAME4 = "ContextMenuArrow";
    ContextMenuArrow = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...arrowProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Arrow22, { ...menuScope, ...arrowProps, ref: forwardedRef });
    });
    ContextMenuArrow.displayName = ARROW_NAME4;
    SUB_NAME2 = "ContextMenuSub";
    ContextMenuSub = (props) => {
      const { __scopeContextMenu, children, onOpenChange, open: openProp, defaultOpen } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      const [open, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(Sub, { ...menuScope, open, onOpenChange: setOpen, children });
    };
    ContextMenuSub.displayName = SUB_NAME2;
    SUB_TRIGGER_NAME2 = "ContextMenuSubTrigger";
    ContextMenuSubTrigger = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...triggerItemProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(SubTrigger, { ...menuScope, ...triggerItemProps, ref: forwardedRef });
    });
    ContextMenuSubTrigger.displayName = SUB_TRIGGER_NAME2;
    SUB_CONTENT_NAME2 = "ContextMenuSubContent";
    ContextMenuSubContent = React59.forwardRef((props, forwardedRef) => {
      const { __scopeContextMenu, ...subContentProps } = props;
      const menuScope = useMenuScope(__scopeContextMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime101.jsx)(SubContent, {
        ...menuScope,
        ...subContentProps,
        ref: forwardedRef,
        style: {
          ...props.style,
          ...{
            "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
            "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
            "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
            "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
            "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
          }
        }
      });
    });
    ContextMenuSubContent.displayName = SUB_CONTENT_NAME2;
    Root25 = ContextMenu;
    Trigger2 = ContextMenuTrigger;
    Portal22 = ContextMenuPortal;
    Content24 = ContextMenuContent;
    CheckboxItem2 = ContextMenuCheckboxItem;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/kbd-utils.mjs
function kbd(str) {
  return str.split(",")[0].split("").map((sub) => {
    const subStr = sub.replace(/\$/g, cmdKey).replace(/\?/g, altKey).replace(/!/g, "\u21E7");
    return subStr[0].toUpperCase() + subStr.slice(1);
  });
}
function kbdStr(str) {
  return "\u2014 " + kbd(str).join("\u2009");
}
var isDarwin, cmdKey, altKey;
var init_kbd_utils = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/kbd-utils.mjs"() {
    isDarwin = typeof window === "undefined" ? false : window.navigator.userAgent.toLowerCase().indexOf("mac") > -1;
    cmdKey = isDarwin ? "\u2318" : "Ctrl";
    altKey = isDarwin ? "\u2325" : "Alt";
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Spinner.mjs
function Spinner(props) {
  return /* @__PURE__ */ (0, import_jsx_runtime102.jsx)("svg", { width: 16, height: 16, viewBox: "0 0 16 16", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime102.jsxs)("g", { strokeWidth: 2, fill: "none", fillRule: "evenodd", children: [
    /* @__PURE__ */ (0, import_jsx_runtime102.jsx)("circle", { strokeOpacity: 0.25, cx: 8, cy: 8, r: 7, stroke: "currentColor" }),
    /* @__PURE__ */ (0, import_jsx_runtime102.jsx)("path", { strokeLinecap: "round", d: "M15 8c0-4.5-4.5-7-7-7", stroke: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime102.jsx)("animateTransform", {
      attributeName: "transform",
      type: "rotate",
      from: "0 8 8",
      to: "360 8 8",
      dur: "1s",
      repeatCount: "indefinite"
    }) })
  ] }) });
}
var import_jsx_runtime102;
var init_Spinner = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Spinner.mjs"() {
    import_jsx_runtime102 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/@radix-ui/react-dropdown-menu/dist/index.mjs
var React60, import_jsx_runtime103, DROPDOWN_MENU_NAME, createDropdownMenuContext, createDropdownMenuScope, useMenuScope2, DropdownMenuProvider, useDropdownMenuContext, DropdownMenu, TRIGGER_NAME4, DropdownMenuTrigger, PORTAL_NAME6, DropdownMenuPortal, CONTENT_NAME6, DropdownMenuContent, GROUP_NAME4, DropdownMenuGroup, LABEL_NAME3, DropdownMenuLabel, ITEM_NAME4, DropdownMenuItem, CHECKBOX_ITEM_NAME3, DropdownMenuCheckboxItem, RADIO_GROUP_NAME3, DropdownMenuRadioGroup, RADIO_ITEM_NAME3, DropdownMenuRadioItem, INDICATOR_NAME2, DropdownMenuItemIndicator, SEPARATOR_NAME3, DropdownMenuSeparator, ARROW_NAME5, DropdownMenuArrow, DropdownMenuSub, SUB_TRIGGER_NAME3, DropdownMenuSubTrigger, SUB_CONTENT_NAME3, DropdownMenuSubContent, Root26, Trigger3, Portal23, Content25, Group2, Item22, CheckboxItem22, Sub2, SubTrigger2, SubContent2;
var init_dist28 = __esm({
  "node_modules/@radix-ui/react-dropdown-menu/dist/index.mjs"() {
    React60 = __toESM(require_react(), 1);
    init_dist();
    init_dist2();
    init_dist3();
    init_dist7();
    init_dist9();
    init_dist26();
    init_dist26();
    init_dist5();
    import_jsx_runtime103 = __toESM(require_jsx_runtime(), 1);
    "use client";
    DROPDOWN_MENU_NAME = "DropdownMenu";
    [createDropdownMenuContext, createDropdownMenuScope] = createContextScope(DROPDOWN_MENU_NAME, [createMenuScope]);
    useMenuScope2 = createMenuScope();
    [DropdownMenuProvider, useDropdownMenuContext] = createDropdownMenuContext(DROPDOWN_MENU_NAME);
    DropdownMenu = (props) => {
      const {
        __scopeDropdownMenu,
        children,
        dir,
        open: openProp,
        defaultOpen,
        onOpenChange,
        modal = true
      } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      const triggerRef = React60.useRef(null);
      const [open = false, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(DropdownMenuProvider, {
        scope: __scopeDropdownMenu,
        triggerId: useId2(),
        triggerRef,
        contentId: useId2(),
        open,
        onOpenChange: setOpen,
        onOpenToggle: React60.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
        modal,
        children: /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Root32, { ...menuScope, open, onOpenChange: setOpen, dir, modal, children })
      });
    };
    DropdownMenu.displayName = DROPDOWN_MENU_NAME;
    TRIGGER_NAME4 = "DropdownMenuTrigger";
    DropdownMenuTrigger = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, disabled = false, ...triggerProps } = props;
      const context = useDropdownMenuContext(TRIGGER_NAME4, __scopeDropdownMenu);
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Anchor2, { asChild: true, ...menuScope, children: /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Primitive.button, {
        type: "button",
        id: context.triggerId,
        "aria-haspopup": "menu",
        "aria-expanded": context.open,
        "aria-controls": context.open ? context.contentId : void 0,
        "data-state": context.open ? "open" : "closed",
        "data-disabled": disabled ? "" : void 0,
        disabled,
        ...triggerProps,
        ref: composeRefs(forwardedRef, context.triggerRef),
        onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
          if (!disabled && event.button === 0 && event.ctrlKey === false) {
            context.onOpenToggle();
            if (!context.open)
              event.preventDefault();
          }
        }),
        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
          if (disabled)
            return;
          if (["Enter", " "].includes(event.key))
            context.onOpenToggle();
          if (event.key === "ArrowDown")
            context.onOpenChange(true);
          if (["Enter", " ", "ArrowDown"].includes(event.key))
            event.preventDefault();
        })
      }) });
    });
    DropdownMenuTrigger.displayName = TRIGGER_NAME4;
    PORTAL_NAME6 = "DropdownMenuPortal";
    DropdownMenuPortal = (props) => {
      const { __scopeDropdownMenu, ...portalProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Portal4, { ...menuScope, ...portalProps });
    };
    DropdownMenuPortal.displayName = PORTAL_NAME6;
    CONTENT_NAME6 = "DropdownMenuContent";
    DropdownMenuContent = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...contentProps } = props;
      const context = useDropdownMenuContext(CONTENT_NAME6, __scopeDropdownMenu);
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      const hasInteractedOutsideRef = React60.useRef(false);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Content23, {
        id: context.contentId,
        "aria-labelledby": context.triggerId,
        ...menuScope,
        ...contentProps,
        ref: forwardedRef,
        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
          if (!hasInteractedOutsideRef.current)
            context.triggerRef.current?.focus();
          hasInteractedOutsideRef.current = false;
          event.preventDefault();
        }),
        onInteractOutside: composeEventHandlers(props.onInteractOutside, (event) => {
          const originalEvent = event.detail.originalEvent;
          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
          if (!context.modal || isRightClick)
            hasInteractedOutsideRef.current = true;
        }),
        style: {
          ...props.style,
          ...{
            "--radix-dropdown-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
            "--radix-dropdown-menu-content-available-width": "var(--radix-popper-available-width)",
            "--radix-dropdown-menu-content-available-height": "var(--radix-popper-available-height)",
            "--radix-dropdown-menu-trigger-width": "var(--radix-popper-anchor-width)",
            "--radix-dropdown-menu-trigger-height": "var(--radix-popper-anchor-height)"
          }
        }
      });
    });
    DropdownMenuContent.displayName = CONTENT_NAME6;
    GROUP_NAME4 = "DropdownMenuGroup";
    DropdownMenuGroup = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...groupProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Group, { ...menuScope, ...groupProps, ref: forwardedRef });
    });
    DropdownMenuGroup.displayName = GROUP_NAME4;
    LABEL_NAME3 = "DropdownMenuLabel";
    DropdownMenuLabel = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...labelProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Label, { ...menuScope, ...labelProps, ref: forwardedRef });
    });
    DropdownMenuLabel.displayName = LABEL_NAME3;
    ITEM_NAME4 = "DropdownMenuItem";
    DropdownMenuItem = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...itemProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Item2, { ...menuScope, ...itemProps, ref: forwardedRef });
    });
    DropdownMenuItem.displayName = ITEM_NAME4;
    CHECKBOX_ITEM_NAME3 = "DropdownMenuCheckboxItem";
    DropdownMenuCheckboxItem = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...checkboxItemProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });
    });
    DropdownMenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME3;
    RADIO_GROUP_NAME3 = "DropdownMenuRadioGroup";
    DropdownMenuRadioGroup = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...radioGroupProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(RadioGroup, { ...menuScope, ...radioGroupProps, ref: forwardedRef });
    });
    DropdownMenuRadioGroup.displayName = RADIO_GROUP_NAME3;
    RADIO_ITEM_NAME3 = "DropdownMenuRadioItem";
    DropdownMenuRadioItem = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...radioItemProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(RadioItem, { ...menuScope, ...radioItemProps, ref: forwardedRef });
    });
    DropdownMenuRadioItem.displayName = RADIO_ITEM_NAME3;
    INDICATOR_NAME2 = "DropdownMenuItemIndicator";
    DropdownMenuItemIndicator = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...itemIndicatorProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(ItemIndicator, { ...menuScope, ...itemIndicatorProps, ref: forwardedRef });
    });
    DropdownMenuItemIndicator.displayName = INDICATOR_NAME2;
    SEPARATOR_NAME3 = "DropdownMenuSeparator";
    DropdownMenuSeparator = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...separatorProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Separator, { ...menuScope, ...separatorProps, ref: forwardedRef });
    });
    DropdownMenuSeparator.displayName = SEPARATOR_NAME3;
    ARROW_NAME5 = "DropdownMenuArrow";
    DropdownMenuArrow = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...arrowProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Arrow22, { ...menuScope, ...arrowProps, ref: forwardedRef });
    });
    DropdownMenuArrow.displayName = ARROW_NAME5;
    DropdownMenuSub = (props) => {
      const { __scopeDropdownMenu, children, open: openProp, onOpenChange, defaultOpen } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      const [open = false, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen,
        onChange: onOpenChange
      });
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(Sub, { ...menuScope, open, onOpenChange: setOpen, children });
    };
    SUB_TRIGGER_NAME3 = "DropdownMenuSubTrigger";
    DropdownMenuSubTrigger = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...subTriggerProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(SubTrigger, { ...menuScope, ...subTriggerProps, ref: forwardedRef });
    });
    DropdownMenuSubTrigger.displayName = SUB_TRIGGER_NAME3;
    SUB_CONTENT_NAME3 = "DropdownMenuSubContent";
    DropdownMenuSubContent = React60.forwardRef((props, forwardedRef) => {
      const { __scopeDropdownMenu, ...subContentProps } = props;
      const menuScope = useMenuScope2(__scopeDropdownMenu);
      return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(SubContent, {
        ...menuScope,
        ...subContentProps,
        ref: forwardedRef,
        style: {
          ...props.style,
          ...{
            "--radix-dropdown-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
            "--radix-dropdown-menu-content-available-width": "var(--radix-popper-available-width)",
            "--radix-dropdown-menu-content-available-height": "var(--radix-popper-available-height)",
            "--radix-dropdown-menu-trigger-width": "var(--radix-popper-anchor-width)",
            "--radix-dropdown-menu-trigger-height": "var(--radix-popper-anchor-height)"
          }
        }
      });
    });
    DropdownMenuSubContent.displayName = SUB_CONTENT_NAME3;
    Root26 = DropdownMenu;
    Trigger3 = DropdownMenuTrigger;
    Portal23 = DropdownMenuPortal;
    Content25 = DropdownMenuContent;
    Group2 = DropdownMenuGroup;
    Item22 = DropdownMenuItem;
    CheckboxItem22 = DropdownMenuCheckboxItem;
    Sub2 = DropdownMenuSub;
    SubTrigger2 = DropdownMenuSubTrigger;
    SubContent2 = DropdownMenuSubContent;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiDropdownMenu.mjs
function TldrawUiDropdownMenuRoot({
  id,
  children,
  modal = false,
  debugOpen = false
}) {
  const [open, onOpenChange] = useMenuIsOpen(id);
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Root26, {
    open: debugOpen || open,
    dir: "ltr",
    modal,
    onOpenChange,
    children
  });
}
function TldrawUiDropdownMenuTrigger({ children, ...rest }) {
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Trigger3, {
    dir: "ltr",
    asChild: true,
    onTouchEnd: (e2) => preventDefault(e2),
    ...rest,
    children
  });
}
function TldrawUiDropdownMenuContent({
  side = "bottom",
  align = "start",
  sideOffset = 8,
  alignOffset = 8,
  children
}) {
  const container = useContainer();
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Portal23, { container, children: /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Content25, {
    className: "tlui-menu",
    side,
    sideOffset,
    align,
    alignOffset,
    collisionPadding: 4,
    children
  }) });
}
function TldrawUiDropdownMenuSub({ id, children }) {
  const [open, onOpenChange] = useMenuIsOpen(id);
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Sub2, { open, onOpenChange, children });
}
function TldrawUiDropdownMenuSubTrigger({
  id,
  label,
  title,
  disabled
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(SubTrigger2, { dir: "ltr", asChild: true, disabled, children: /* @__PURE__ */ (0, import_jsx_runtime104.jsxs)(TldrawUiButton, {
    "data-testid": id,
    type: "menu",
    className: "tlui-menu__submenu__trigger",
    disabled,
    title,
    children: [
      /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(TldrawUiButtonLabel, { children: label }),
      /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(TldrawUiButtonIcon, { icon: "chevron-right", small: true })
    ]
  }) });
}
function TldrawUiDropdownMenuSubContent({
  id,
  alignOffset = -1,
  sideOffset = -4,
  size: size4 = "small",
  children
}) {
  const container = useContainer();
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Portal23, { container, children: /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(SubContent2, {
    "data-testid": id,
    className: "tlui-menu tlui-menu__submenu__content",
    alignOffset,
    sideOffset,
    collisionPadding: 4,
    "data-size": size4,
    children
  }) });
}
function TldrawUiDropdownMenuGroup({ children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Group2, { dir: "ltr", className: "tlui-menu__group", children });
}
function TldrawUiDropdownMenuItem({ noClose, children }) {
  return /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Item22, { dir: "ltr", asChild: true, onClick: noClose ? preventDefault : void 0, children });
}
var import_jsx_runtime104;
var init_TldrawUiDropdownMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiDropdownMenu.mjs"() {
    import_jsx_runtime104 = __toESM(require_jsx_runtime(), 1);
    init_dist28();
    init_dist_esm10();
    init_useMenuIsOpen();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiKbd.mjs
function TldrawUiKbd({ children, visibleOnMobileLayout = false }) {
  const breakpoint = useBreakpoint();
  if (!visibleOnMobileLayout && breakpoint < PORTRAIT_BREAKPOINT.MOBILE)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime105.jsx)("kbd", { className: "tlui-kbd", children: kbd(children).map((k2, i2) => /* @__PURE__ */ (0, import_jsx_runtime105.jsx)("span", { children: k2 }, i2)) });
}
var import_jsx_runtime105;
var init_TldrawUiKbd = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiKbd.mjs"() {
    import_jsx_runtime105 = __toESM(require_jsx_runtime(), 1);
    init_constants5();
    init_breakpoints();
    init_kbd_utils();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuItem.mjs
function TldrawUiMenuItem({
  disabled = false,
  spinner = false,
  readonlyOk = false,
  id,
  kbd: kbd2,
  label,
  icon,
  onSelect,
  noClose,
  isSelected
}) {
  const { type: menuType, sourceId } = useTldrawUiMenuContext();
  const msg2 = useTranslation();
  const [disableClicks, setDisableClicks] = (0, import_react84.useState)(false);
  const isReadonlyMode = useReadonly();
  if (isReadonlyMode && !readonlyOk)
    return null;
  const labelToUse = unwrapLabel(label, menuType);
  const kbdTouse = kbd2 ? kbdStr(kbd2) : void 0;
  const labelStr = labelToUse ? msg2(labelToUse) : void 0;
  const titleStr = labelStr && kbdTouse ? `${labelStr} ${kbdTouse}` : labelStr;
  switch (menuType) {
    case "menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiDropdownMenuItem, { children: /* @__PURE__ */ (0, import_jsx_runtime106.jsxs)(TldrawUiButton, {
        type: "menu",
        "data-testid": `${sourceId}.${id}`,
        disabled,
        title: titleStr,
        onClick: (e2) => {
          if (noClose) {
            preventDefault(e2);
          }
          if (disableClicks) {
            setDisableClicks(false);
          } else {
            onSelect(sourceId);
          }
        },
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonLabel, { children: labelStr }),
          kbd2 && /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiKbd, { children: kbd2 })
        ]
      }) });
    }
    case "context-menu": {
      if (disabled)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsxs)(ContextMenuItem, {
        dir: "ltr",
        title: titleStr,
        draggable: false,
        className: "tlui-button tlui-button__menu",
        "data-testid": `${sourceId}.${id}`,
        onSelect: (e2) => {
          if (noClose)
            preventDefault(e2);
          if (disableClicks) {
            setDisableClicks(false);
          } else {
            onSelect(sourceId);
          }
        },
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime106.jsx)("span", { className: "tlui-button__label", draggable: false, children: labelStr }),
          kbd2 && /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiKbd, { children: kbd2 }),
          spinner && /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(Spinner, {})
        ]
      });
    }
    case "panel": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsxs)(TldrawUiButton, {
        "data-testid": `${sourceId}.${id}`,
        type: "menu",
        title: titleStr,
        disabled,
        onClick: () => onSelect(sourceId),
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonLabel, { children: labelStr }),
          icon && /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonIcon, { icon })
        ]
      });
    }
    case "small-icons":
    case "icons": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButton, {
        "data-testid": `${sourceId}.${id}`,
        type: "icon",
        title: titleStr,
        disabled,
        onClick: () => onSelect(sourceId),
        children: /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonIcon, { icon, small: menuType === "small-icons" })
      });
    }
    case "keyboard-shortcuts": {
      if (!kbd2) {
        console.warn(`Menu item '${label}' isn't shown in the keyboard shortcuts dialog because it doesn't have a keyboard shortcut.`);
        return null;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsxs)("div", { className: "tlui-shortcuts-dialog__key-pair", "data-testid": `${sourceId}.${id}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime106.jsx)("div", { className: "tlui-shortcuts-dialog__key-pair__key", children: labelStr }),
        /* @__PURE__ */ (0, import_jsx_runtime106.jsx)("div", { className: "tlui-shortcuts-dialog__key-pair__value", children: /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiKbd, { visibleOnMobileLayout: true, children: kbd2 }) })
      ] });
    }
    case "helper-buttons": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsxs)(TldrawUiButton, { type: "low", onClick: () => onSelect(sourceId), children: [
        /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonIcon, { icon }),
        /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonLabel, { children: labelStr })
      ] });
    }
    case "toolbar": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButton, {
        type: "tool",
        "data-testid": `tools.${id}`,
        "aria-label": labelToUse,
        "data-value": id,
        onClick: () => onSelect("toolbar"),
        title: titleStr,
        onTouchStart: (e2) => {
          preventDefault(e2);
          onSelect("toolbar");
        },
        role: "radio",
        "aria-checked": isSelected ? "true" : "false",
        children: /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonIcon, { icon })
      });
    }
    case "toolbar-overflow": {
      return /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiDropdownMenuItem, { "aria-label": label, children: /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButton, {
        type: "icon",
        className: "tlui-button-grid__button",
        onClick: () => {
          onSelect("toolbar");
        },
        "data-testid": `tools.more.${id}`,
        title: titleStr,
        role: "radio",
        "aria-checked": isSelected ? "true" : "false",
        "data-value": id,
        children: /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(TldrawUiButtonIcon, { icon })
      }) });
    }
    default: {
      throw exhaustiveSwitchError(menuType);
    }
  }
}
var import_jsx_runtime106, import_react84;
var init_TldrawUiMenuItem = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuItem.mjs"() {
    import_jsx_runtime106 = __toESM(require_jsx_runtime(), 1);
    init_dist27();
    init_dist_esm10();
    import_react84 = __toESM(require_react(), 1);
    init_actions();
    init_useReadonly();
    init_useTranslation();
    init_kbd_utils();
    init_Spinner();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiDropdownMenu();
    init_TldrawUiKbd();
    init_TldrawUiMenuContext();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ActionsMenu/DefaultActionsMenuContent.mjs
function DefaultActionsMenuContent() {
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsxs)(import_jsx_runtime107.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(AlignMenuItems, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(DistributeMenuItems, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(StackMenuItems, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(ReorderMenuItems, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(ZoomOrRotateMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(RotateCWMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(EditLinkMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(GroupOrUngroupMenuItem, {})
  ] });
}
function AlignMenuItems() {
  const actions = useActions();
  const twoSelected = useUnlockedSelectedShapesCount(2);
  const isInSelectState = useIsInSelectState();
  const enabled = twoSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsxs)(import_jsx_runtime107.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-left"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-center-horizontal"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-right"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["stretch-horizontal"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-top"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-center-vertical"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["align-bottom"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["stretch-vertical"], disabled: !enabled })
  ] });
}
function DistributeMenuItems() {
  const actions = useActions();
  const threeSelected = useUnlockedSelectedShapesCount(3);
  const isInSelectState = useIsInSelectState();
  const enabled = threeSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsxs)(import_jsx_runtime107.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["distribute-horizontal"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["distribute-vertical"], disabled: !enabled })
  ] });
}
function StackMenuItems() {
  const actions = useActions();
  const threeStackableItems = useThreeStackableItems();
  const isInSelectState = useIsInSelectState();
  const enabled = threeStackableItems && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsxs)(import_jsx_runtime107.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["stack-horizontal"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["stack-vertical"], disabled: !enabled })
  ] });
}
function ReorderMenuItems() {
  const actions = useActions();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  const isInSelectState = useIsInSelectState();
  const enabled = oneSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsxs)(import_jsx_runtime107.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["send-to-back"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["send-backward"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["bring-forward"], disabled: !enabled }),
    /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["bring-to-front"], disabled: !enabled })
  ] });
}
function ZoomOrRotateMenuItem() {
  const breakpoint = useBreakpoint();
  return breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM ? /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(ZoomTo100MenuItem, {}) : /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(RotateCCWMenuItem, {});
}
function ZoomTo100MenuItem() {
  const actions = useActions();
  const editor = useEditor();
  const isZoomedTo100 = useValue("zoom is 1", () => editor.getZoomLevel() === 1, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["zoom-to-100"], disabled: isZoomedTo100 });
}
function RotateCCWMenuItem() {
  const actions = useActions();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  const isInSelectState = useIsInSelectState();
  const enabled = oneSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["rotate-ccw"], disabled: !enabled });
}
function RotateCWMenuItem() {
  const actions = useActions();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  const isInSelectState = useIsInSelectState();
  const enabled = oneSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["rotate-cw"], disabled: !enabled });
}
function EditLinkMenuItem() {
  const actions = useActions();
  const showEditLink = useHasLinkShapeSelected();
  const isInSelectState = useIsInSelectState();
  const enabled = showEditLink && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["edit-link"], disabled: !enabled });
}
function GroupOrUngroupMenuItem() {
  const allowGroup = useAllowGroup();
  const allowUngroup = useAllowUngroup();
  return allowGroup ? /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(GroupMenuItem, {}) : allowUngroup ? /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(UngroupMenuItem, {}) : /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(GroupMenuItem, {});
}
function GroupMenuItem() {
  const actions = useActions();
  const twoSelected = useUnlockedSelectedShapesCount(2);
  const isInSelectState = useIsInSelectState();
  const enabled = twoSelected && isInSelectState;
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["group"], disabled: !enabled });
}
function UngroupMenuItem() {
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(TldrawUiMenuItem, { ...actions["ungroup"] });
}
var import_jsx_runtime107;
var init_DefaultActionsMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ActionsMenu/DefaultActionsMenuContent.mjs"() {
    import_jsx_runtime107 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_constants5();
    init_actions();
    init_breakpoints();
    init_menu_hooks();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ActionsMenu/DefaultActionsMenu.mjs
var import_jsx_runtime108, import_react85, DefaultActionsMenu;
var init_DefaultActionsMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ActionsMenu/DefaultActionsMenu.mjs"() {
    import_jsx_runtime108 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react85 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_useReadonly();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiPopover();
    init_TldrawUiMenuContext();
    init_DefaultActionsMenuContent();
    DefaultActionsMenu = (0, import_react85.memo)(function DefaultActionsMenu2({
      children
    }) {
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const isReadonlyMode = useReadonly();
      const editor = useEditor();
      const isInAcceptableReadonlyState = useValue("should display quick actions when in readonly", () => editor.isInAny("hand", "zoom"), [editor]);
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(DefaultActionsMenuContent, {});
      if (isReadonlyMode && !isInAcceptableReadonlyState)
        return;
      return /* @__PURE__ */ (0, import_jsx_runtime108.jsxs)(TldrawUiPopover, { id: "actions-menu", children: [
        /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(TldrawUiPopoverTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(TldrawUiButton, {
          type: "icon",
          "data-testid": "actions-menu.button",
          title: msg2("actions-menu.title"),
          children: /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(TldrawUiButtonIcon, { icon: "dots-vertical", small: true })
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(TldrawUiPopoverContent, {
          side: breakpoint >= PORTRAIT_BREAKPOINT.TABLET ? "bottom" : "top",
          sideOffset: 6,
          children: /* @__PURE__ */ (0, import_jsx_runtime108.jsx)("div", { className: "tlui-actions-menu tlui-buttons__grid", "data-testid": "actions-menu.content", children: /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(TldrawUiMenuContextProvider, { type: "icons", sourceId: "actions-menu", children: content }) })
        })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuCheckboxItem.mjs
function TldrawUiMenuCheckboxItem({
  id,
  kbd: kbd2,
  label,
  readonlyOk,
  onSelect,
  toggle = false,
  disabled = false,
  checked = false
}) {
  const { type: menuType, sourceId } = useTldrawUiMenuContext();
  const isReadonlyMode = useReadonly();
  const msg2 = useTranslation();
  if (isReadonlyMode && !readonlyOk)
    return null;
  const labelToUse = unwrapLabel(label, menuType);
  const labelStr = labelToUse ? msg2(labelToUse) : void 0;
  switch (menuType) {
    case "menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)(CheckboxItem22, {
        dir: "ltr",
        className: "tlui-button tlui-button__menu tlui-button__checkbox",
        title: labelStr,
        onSelect: (e2) => {
          onSelect?.(sourceId);
          preventDefault(e2);
        },
        disabled,
        checked,
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(TldrawUiIcon, {
            small: true,
            icon: toggle ? checked ? "toggle-on" : "toggle-off" : checked ? "check" : "none"
          }),
          labelStr && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)("span", { className: "tlui-button__label", draggable: false, children: labelStr }),
          kbd2 && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(TldrawUiKbd, { children: kbd2 })
        ]
      });
    }
    case "context-menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)(CheckboxItem2, {
        className: "tlui-button tlui-button__menu tlui-button__checkbox",
        dir: "ltr",
        title: labelStr,
        onSelect: (e2) => {
          onSelect(sourceId);
          preventDefault(e2);
        },
        disabled,
        checked,
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(TldrawUiIcon, {
            small: true,
            icon: toggle ? checked ? "toggle-on" : "toggle-off" : checked ? "check" : "none"
          }),
          labelStr && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)("span", { className: "tlui-button__label", draggable: false, children: labelStr }),
          kbd2 && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(TldrawUiKbd, { children: kbd2 })
        ]
      }, id);
    }
    default: {
      return null;
    }
  }
}
var import_jsx_runtime109;
var init_TldrawUiMenuCheckboxItem = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuCheckboxItem.mjs"() {
    import_jsx_runtime109 = __toESM(require_jsx_runtime(), 1);
    init_dist27();
    init_dist28();
    init_dist_esm10();
    init_actions();
    init_useReadonly();
    init_useTranslation();
    init_TldrawUiIcon();
    init_TldrawUiKbd();
    init_TldrawUiMenuContext();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuGroup.mjs
function TldrawUiMenuGroup({ id, label, children }) {
  const { type: menuType, sourceId } = useTldrawUiMenuContext();
  const msg2 = useTranslation();
  const labelToUse = unwrapLabel(label, menuType);
  const labelStr = labelToUse ? msg2(labelToUse) : void 0;
  switch (menuType) {
    case "panel": {
      return /* @__PURE__ */ (0, import_jsx_runtime110.jsx)("div", { className: "tlui-menu__group", "data-testid": `${sourceId}-group.${id}`, children });
    }
    case "menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime110.jsx)(TldrawUiDropdownMenuGroup, { "data-testid": `${sourceId}-group.${id}`, children });
    }
    case "context-menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime110.jsx)(ContextMenuGroup, {
        dir: "ltr",
        className: "tlui-menu__group",
        "data-testid": `${sourceId}-group.${id}`,
        children
      });
    }
    case "keyboard-shortcuts": {
      return /* @__PURE__ */ (0, import_jsx_runtime110.jsxs)("div", { className: "tlui-shortcuts-dialog__group", "data-testid": `${sourceId}-group.${id}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime110.jsx)("h2", { className: "tlui-shortcuts-dialog__group__title", children: labelStr }),
        /* @__PURE__ */ (0, import_jsx_runtime110.jsx)("div", { className: "tlui-shortcuts-dialog__group__content", children })
      ] });
    }
    default: {
      return children;
    }
  }
}
var import_jsx_runtime110;
var init_TldrawUiMenuGroup = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuGroup.mjs"() {
    import_jsx_runtime110 = __toESM(require_jsx_runtime(), 1);
    init_dist27();
    init_actions();
    init_useTranslation();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuSubmenu.mjs
function TldrawUiMenuSubmenu({
  id,
  disabled = false,
  label,
  size: size4 = "small",
  children
}) {
  const { type: menuType, sourceId } = useTldrawUiMenuContext();
  const container = useContainer();
  const msg2 = useTranslation();
  const labelToUse = label ? typeof label === "string" ? label : label[menuType] ?? label["default"] : void 0;
  const labelStr = labelToUse ? msg2(labelToUse) : void 0;
  switch (menuType) {
    case "menu": {
      return /* @__PURE__ */ (0, import_jsx_runtime111.jsxs)(TldrawUiDropdownMenuSub, { id: `${sourceId}-sub.${id}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(TldrawUiDropdownMenuSubTrigger, {
          id: `${sourceId}-sub.${labelStr ? labelStr.toLowerCase() + "-button" : ""}`,
          disabled,
          label: labelStr,
          title: labelStr
        }),
        /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(TldrawUiDropdownMenuSubContent, {
          id: `${sourceId}-sub.${labelStr ? labelStr.toLowerCase() + "-content" : ""}`,
          size: size4,
          children
        })
      ] });
    }
    case "context-menu": {
      if (disabled)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime111.jsxs)(ContextMenuSubWithMenu, { id: `${sourceId}-sub.${id}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(ContextMenuSubTrigger, { dir: "ltr", disabled, asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime111.jsxs)(TldrawUiButton, {
          "data-testid": `${sourceId}-sub-trigger.${id}`,
          type: "menu",
          className: "tlui-menu__submenu__trigger",
          children: [
            /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(TldrawUiButtonLabel, { children: labelStr }),
            /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(TldrawUiButtonIcon, { icon: "chevron-right", small: true })
          ]
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(ContextMenuPortal, { container, children: /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(ContextMenuSubContent, {
          "data-testid": `${sourceId}-sub-content.${id}`,
          className: "tlui-menu tlui-menu__submenu__content",
          alignOffset: -1,
          sideOffset: -4,
          collisionPadding: 4,
          "data-size": size4,
          children
        }) })
      ] });
    }
    default: {
      return children;
    }
  }
}
function ContextMenuSubWithMenu({ id, children }) {
  const [open, onOpenChange] = useMenuIsOpen(id);
  return /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(ContextMenuSub, { open, onOpenChange, children });
}
var import_jsx_runtime111;
var init_TldrawUiMenuSubmenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/menus/TldrawUiMenuSubmenu.mjs"() {
    import_jsx_runtime111 = __toESM(require_jsx_runtime(), 1);
    init_dist27();
    init_dist_esm10();
    init_useMenuIsOpen();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/menu-items.mjs
function ToggleAutoSizeMenuItem() {
  const actions = useActions();
  const shouldDisplay = useShowAutoSizeToggle();
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["toggle-auto-size"] });
}
function EditLinkMenuItem2() {
  const actions = useActions();
  const shouldDisplay = useHasLinkShapeSelected();
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["edit-link"] });
}
function DuplicateMenuItem() {
  const actions = useActions();
  const shouldDisplay = useUnlockedSelectedShapesCount(1);
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["duplicate"] });
}
function FlattenMenuItem() {
  const actions = useActions();
  const editor = useEditor();
  const shouldDisplay = useValue("should display flatten option", () => {
    const selectedShapeIds = editor.getSelectedShapeIds();
    if (selectedShapeIds.length === 0)
      return false;
    const onlySelectedShape = editor.getOnlySelectedShape();
    if (onlySelectedShape && editor.isShapeOfType(onlySelectedShape, "image")) {
      return false;
    }
    return true;
  }, [editor]);
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["flatten-to-image"] });
}
function GroupMenuItem2() {
  const actions = useActions();
  const shouldDisplay = useAllowGroup();
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["group"] });
}
function UngroupMenuItem2() {
  const actions = useActions();
  const shouldDisplay = useAllowUngroup();
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["ungroup"] });
}
function RemoveFrameMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const shouldDisplay = useValue("allow unframe", () => {
    const selectedShapes = editor.getSelectedShapes();
    if (selectedShapes.length === 0)
      return false;
    return selectedShapes.every((shape) => editor.isShapeOfType(shape, "frame"));
  }, [editor]);
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["remove-frame"] });
}
function FitFrameToContentMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const shouldDisplay = useValue("allow fit frame to content", () => {
    const onlySelectedShape = editor.getOnlySelectedShape();
    if (!onlySelectedShape)
      return false;
    return editor.isShapeOfType(onlySelectedShape, "frame") && editor.getSortedChildIdsForParent(onlySelectedShape).length > 0;
  }, [editor]);
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["fit-frame-to-content"] });
}
function ToggleLockMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const shouldDisplay = useValue("selected shapes", () => editor.getSelectedShapes().length > 0, [
    editor
  ]);
  if (!shouldDisplay)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["toggle-lock"] });
}
function ToggleTransparentBgMenuItem() {
  const actions = useActions();
  const editor = useEditor();
  const isTransparentBg = useValue("isTransparentBg", () => !editor.getInstanceState().exportBackground, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-transparent"], checked: isTransparentBg, toggle: true });
}
function UnlockAllMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const shouldDisplay = useValue("any shapes", () => editor.getCurrentPageShapeIds().size > 0, [
    editor
  ]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["unlock-all"], disabled: !shouldDisplay });
}
function ZoomTo100MenuItem2() {
  const editor = useEditor();
  const isZoomedTo100 = useValue("zoomed to 100", () => editor.getZoomLevel() === 1, [editor]);
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["zoom-to-100"], noClose: true, disabled: isZoomedTo100 });
}
function ZoomToFitMenuItem() {
  const editor = useEditor();
  const hasShapes = useValue("has shapes", () => editor.getCurrentPageShapeIds().size > 0, [editor]);
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, {
    ...actions["zoom-to-fit"],
    disabled: !hasShapes,
    "data-testid": "minimap.zoom-menu.zoom-to-fit",
    noClose: true
  });
}
function ZoomToSelectionMenuItem() {
  const editor = useEditor();
  const hasSelected = useValue("has shapes", () => editor.getSelectedShapeIds().length > 0, [
    editor
  ]);
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, {
    ...actions["zoom-to-selection"],
    disabled: !hasSelected,
    "data-testid": "minimap.zoom-menu.zoom-to-selection",
    noClose: true
  });
}
function ClipboardMenuGroup() {
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "clipboard", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(CutMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(CopyMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(PasteMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(DuplicateMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(DeleteMenuItem, {})
  ] });
}
function CopyAsMenuGroup() {
  const editor = useEditor();
  const actions = useActions();
  const atLeastOneShapeOnPage = useValue("atLeastOneShapeOnPage", () => editor.getCurrentPageShapeIds().size > 0, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuSubmenu, {
    id: "copy-as",
    label: "context-menu.copy-as",
    size: "small",
    disabled: !atLeastOneShapeOnPage,
    children: [
      /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "copy-as-group", children: [
        /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["copy-as-svg"] }),
        Boolean(window.navigator.clipboard?.write) && /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["copy-as-png"] }),
        /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["copy-as-json"] })
      ] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuGroup, { id: "copy-as-bg", children: /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ToggleTransparentBgMenuItem, {}) })
    ]
  });
}
function CutMenuItem() {
  const actions = useActions();
  const shouldDisplay = useUnlockedSelectedShapesCount(1);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["cut"], disabled: !shouldDisplay });
}
function CopyMenuItem() {
  const actions = useActions();
  const shouldDisplay = useAnySelectedShapesCount(1);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["copy"], disabled: !shouldDisplay });
}
function PasteMenuItem() {
  const actions = useActions();
  const shouldDisplay = showMenuPaste;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["paste"], disabled: !shouldDisplay });
}
function ConversionsMenuGroup() {
  const editor = useEditor();
  const actions = useActions();
  const atLeastOneShapeOnPage = useValue("atLeastOneShapeOnPage", () => editor.getCurrentPageShapeIds().size > 0, [editor]);
  if (!atLeastOneShapeOnPage)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "conversions", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(CopyAsMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuSubmenu, { id: "export-as", label: "context-menu.export-as", size: "small", children: [
      /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "export-as-group", children: [
        /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["export-as-svg"] }),
        /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["export-as-png"] }),
        /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["export-as-json"] })
      ] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuGroup, { id: "export-as-bg", children: /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ToggleTransparentBgMenuItem, {}) })
    ] })
  ] });
}
function SelectAllMenuItem() {
  const actions = useActions();
  const editor = useEditor();
  const atLeastOneShapeOnPage = useValue("atLeastOneShapeOnPage", () => editor.getCurrentPageShapeIds().size > 0, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["select-all"], disabled: !atLeastOneShapeOnPage });
}
function DeleteMenuItem() {
  const actions = useActions();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["delete"], disabled: !oneSelected });
}
function EditMenuSubmenu() {
  if (!useAnySelectedShapesCount(1))
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuSubmenu, { id: "edit", label: "context-menu.edit", size: "small", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(GroupMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(UngroupMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(FlattenMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(EditLinkMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(FitFrameToContentMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(RemoveFrameMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ConvertToEmbedMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ConvertToBookmarkMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ToggleAutoSizeMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(ToggleLockMenuItem, {})
  ] });
}
function ArrangeMenuSubmenu() {
  const twoSelected = useUnlockedSelectedShapesCount(2);
  const onlyFlippableShapeSelected = useOnlyFlippableShape();
  const actions = useActions();
  if (!(twoSelected || onlyFlippableShapeSelected))
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuSubmenu, { id: "arrange", label: "context-menu.arrange", size: "small", children: [
    twoSelected && /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "align", children: [
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-left"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-center-horizontal"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-right"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-top"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-center-vertical"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["align-bottom"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(DistributeMenuGroup, {}),
    twoSelected && /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "stretch", children: [
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["stretch-horizontal"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["stretch-vertical"] })
    ] }),
    (twoSelected || onlyFlippableShapeSelected) && /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "flip", children: [
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["flip-horizontal"] }),
      /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["flip-vertical"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(OrderMenuGroup, {})
  ] });
}
function DistributeMenuGroup() {
  const actions = useActions();
  const threeSelected = useUnlockedSelectedShapesCount(3);
  if (!threeSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "distribute", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["distribute-horizontal"] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["distribute-vertical"] })
  ] });
}
function OrderMenuGroup() {
  const actions = useActions();
  const twoSelected = useUnlockedSelectedShapesCount(2);
  const threeStackableItems = useThreeStackableItems();
  if (!twoSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "order", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["pack"] }),
    threeStackableItems && /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["stack-horizontal"] }),
    threeStackableItems && /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["stack-vertical"] })
  ] });
}
function ReorderMenuSubmenu() {
  const actions = useActions();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  if (!oneSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuSubmenu, { id: "reorder", label: "context-menu.reorder", size: "small", children: /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuGroup, { id: "reorder", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["bring-to-front"] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["bring-forward"] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["send-backward"] }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["send-to-back"] })
  ] }) });
}
function MoveToPageMenu() {
  const editor = useEditor();
  const pages = useValue("pages", () => editor.getPages(), [editor]);
  const currentPageId = useValue("current page id", () => editor.getCurrentPageId(), [editor]);
  const { addToast } = useToasts();
  const actions = useActions();
  const trackEvent = useUiEvents();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  if (!oneSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsxs)(TldrawUiMenuSubmenu, { id: "move-to-page", label: "context-menu.move-to-page", size: "small", children: [
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuGroup, { id: "pages", children: pages.map((page) => /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, {
      id: page.id,
      disabled: currentPageId === page.id,
      label: page.name,
      onSelect: () => {
        editor.mark("move_shapes_to_page");
        editor.moveShapesToPage(editor.getSelectedShapeIds(), page.id);
        const toPage = editor.getPage(page.id);
        if (toPage) {
          addToast({
            title: "Changed Page",
            description: `Moved to ${toPage.name}.`,
            actions: [
              {
                label: "Go Back",
                type: "primary",
                onClick: () => {
                  editor.mark("change-page");
                  editor.setCurrentPage(currentPageId);
                }
              }
            ]
          });
        }
        trackEvent("move-to-page", { source: "context-menu" });
      }
    }, page.id)) }),
    /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuGroup, { id: "new-page", children: /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["move-to-new-page"] }) })
  ] });
}
function ConvertToBookmarkMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const oneEmbedSelected = useValue("oneEmbedSelected", () => {
    const onlySelectedShape = editor.getOnlySelectedShape();
    if (!onlySelectedShape)
      return false;
    return !!(editor.isShapeOfType(onlySelectedShape, "embed") && onlySelectedShape.props.url && !editor.isShapeOrAncestorLocked(onlySelectedShape));
  }, [editor]);
  if (!oneEmbedSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["convert-to-bookmark"] });
}
function ConvertToEmbedMenuItem() {
  const editor = useEditor();
  const actions = useActions();
  const oneEmbeddableBookmarkSelected = useValue("oneEmbeddableBookmarkSelected", () => {
    const onlySelectedShape = editor.getOnlySelectedShape();
    if (!onlySelectedShape)
      return false;
    return !!(editor.isShapeOfType(onlySelectedShape, "bookmark") && onlySelectedShape.props.url && getEmbedInfo(onlySelectedShape.props.url) && !editor.isShapeOrAncestorLocked(onlySelectedShape));
  }, [editor]);
  if (!oneEmbeddableBookmarkSelected)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["convert-to-embed"] });
}
function ToggleSnapModeItem() {
  const actions = useActions();
  const editor = useEditor();
  const isSnapMode = useValue("isSnapMode", () => editor.user.getIsSnapMode(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-snap-mode"], checked: isSnapMode });
}
function ToggleToolLockItem() {
  const actions = useActions();
  const editor = useEditor();
  const isToolLock = useValue("isToolLock", () => editor.getInstanceState().isToolLocked, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-tool-lock"], checked: isToolLock });
}
function ToggleGridItem() {
  const actions = useActions();
  const editor = useEditor();
  const isGridMode = useValue("isGridMode", () => editor.getInstanceState().isGridMode, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-grid"], checked: isGridMode });
}
function ToggleWrapModeItem() {
  const actions = useActions();
  const editor = useEditor();
  const isWrapMode = useValue("isWrapMode", () => editor.user.getIsWrapMode(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-wrap-mode"], checked: isWrapMode });
}
function ToggleFocusModeItem() {
  const actions = useActions();
  const editor = useEditor();
  const isFocusMode = useValue("isFocusMode", () => editor.getInstanceState().isFocusMode, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-focus-mode"], checked: isFocusMode });
}
function ToggleEdgeScrollingItem() {
  const actions = useActions();
  const editor = useEditor();
  const edgeScrollSpeed = useValue("edgeScrollSpeed", () => editor.user.getEdgeScrollSpeed(), [
    editor
  ]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, {
    ...actions["toggle-edge-scrolling"],
    checked: edgeScrollSpeed === 1
  });
}
function ToggleReduceMotionItem() {
  const actions = useActions();
  const editor = useEditor();
  const animationSpeed = useValue("animationSpeed", () => editor.user.getAnimationSpeed(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-reduce-motion"], checked: animationSpeed === 0 });
}
function ToggleDebugModeItem() {
  const actions = useActions();
  const editor = useEditor();
  const isDebugMode = useValue("isDebugMode", () => editor.getInstanceState().isDebugMode, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-debug-mode"], checked: isDebugMode });
}
function ToggleDynamicSizeModeItem() {
  const actions = useActions();
  const editor = useEditor();
  const isDynamicResizeMode = useValue("dynamic resize", () => editor.user.getIsDynamicResizeMode(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, {
    ...actions["toggle-dynamic-size-mode"],
    checked: isDynamicResizeMode
  });
}
function TogglePasteAtCursorItem() {
  const actions = useActions();
  const editor = useEditor();
  const pasteAtCursor = useValue("paste at cursor", () => editor.user.getIsPasteAtCursorMode(), [
    editor
  ]);
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuCheckboxItem, { ...actions["toggle-paste-at-cursor"], checked: pasteAtCursor });
}
function CursorChatItem() {
  const editor = useEditor();
  const actions = useActions();
  const shouldShow = useValue("show cursor chat", () => editor.getCurrentToolId() === "select" && !editor.getInstanceState().isCoarsePointer, [editor]);
  if (!shouldShow)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(TldrawUiMenuItem, { ...actions["open-cursor-chat"] });
}
var import_jsx_runtime112;
var init_menu_items = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/menu-items.mjs"() {
    import_jsx_runtime112 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_embeds();
    init_actions();
    init_events();
    init_toasts();
    init_menu_hooks();
    init_TldrawUiMenuCheckboxItem();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
    init_TldrawUiMenuSubmenu();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ContextMenu/DefaultContextMenuContent.mjs
function DefaultContextMenuContent() {
  const editor = useEditor();
  const showCollaborationUi = useShowCollaborationUi();
  const selectToolActive = useValue("isSelectToolActive", () => editor.getCurrentToolId() === "select", [editor]);
  if (!selectToolActive)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime113.jsxs)(import_jsx_runtime113.Fragment, { children: [
    showCollaborationUi && /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(CursorChatItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime113.jsxs)(TldrawUiMenuGroup, { id: "modify", children: [
      /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(EditMenuSubmenu, {}),
      /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(ArrangeMenuSubmenu, {}),
      /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(ReorderMenuSubmenu, {}),
      /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(MoveToPageMenu, {})
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(ClipboardMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(ConversionsMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(TldrawUiMenuGroup, { id: "select-all", children: /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(SelectAllMenuItem, {}) })
  ] });
}
var import_jsx_runtime113;
var init_DefaultContextMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ContextMenu/DefaultContextMenuContent.mjs"() {
    import_jsx_runtime113 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_useIsMultiplayer();
    init_menu_items();
    init_TldrawUiMenuGroup();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ContextMenu/DefaultContextMenu.mjs
var import_jsx_runtime114, import_react86, DefaultContextMenu;
var init_DefaultContextMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ContextMenu/DefaultContextMenu.mjs"() {
    import_jsx_runtime114 = __toESM(require_jsx_runtime(), 1);
    init_dist27();
    init_dist_esm10();
    import_react86 = __toESM(require_react(), 1);
    init_useMenuIsOpen();
    init_TldrawUiMenuContext();
    init_DefaultContextMenuContent();
    DefaultContextMenu = (0, import_react86.memo)(function DefaultContextMenu2({
      children
    }) {
      const editor = useEditor();
      const { Canvas } = useEditorComponents();
      const cb = (0, import_react86.useCallback)((isOpen2) => {
        if (!isOpen2) {
          const onlySelectedShape = editor.getOnlySelectedShape();
          if (onlySelectedShape && editor.isShapeOrAncestorLocked(onlySelectedShape)) {
            editor.setSelectedShapes([]);
          }
        } else {
          if (editor.getInstanceState().isCoarsePointer) {
            const selectedShapes = editor.getSelectedShapes();
            const {
              inputs: { currentPagePoint }
            } = editor;
            const shapesAtPoint = editor.getShapesAtPoint(currentPagePoint);
            if (!editor.getSelectedShapes().length || !shapesAtPoint.some((s2) => selectedShapes.includes(s2))) {
              const lockedShapes = shapesAtPoint.filter((s2) => editor.isShapeOrAncestorLocked(s2));
              if (lockedShapes.length) {
                editor.select(...lockedShapes.map((s2) => s2.id));
              }
            }
          }
        }
      }, [editor]);
      const container = useContainer();
      const [isOpen, handleOpenChange] = useMenuIsOpen("context menu", cb);
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(DefaultContextMenuContent, {});
      return /* @__PURE__ */ (0, import_jsx_runtime114.jsxs)(Root25, { dir: "ltr", onOpenChange: handleOpenChange, modal: false, children: [
        /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(Trigger2, { onContextMenu: void 0, dir: "ltr", children: Canvas ? /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(Canvas, {}) : null }),
        isOpen && /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(Portal22, { container, children: /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(Content24, {
          className: "tlui-menu scrollable",
          "data-testid": "context-menu",
          alignOffset: -4,
          collisionPadding: 4,
          onContextMenu: preventDefault,
          children: /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(TldrawUiMenuContextProvider, { type: "context-menu", sourceId: "context-menu", children: content })
        }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/CursorChatBubble.mjs
function usePositionBubble(ref) {
  const editor = useEditor();
  (0, import_react87.useLayoutEffect)(() => {
    const elm = ref.current;
    if (!elm)
      return;
    const { x: x2, y: y2 } = editor.inputs.currentScreenPoint;
    ref.current?.style.setProperty("transform", `translate(${x2}px, ${y2}px)`);
    function positionChatBubble(e2) {
      const { minX, minY } = editor.getViewportScreenBounds();
      ref.current?.style.setProperty("transform", `translate(${e2.clientX - minX}px, ${e2.clientY - minY}px)`);
    }
    window.addEventListener("pointermove", positionChatBubble);
    return () => {
      window.removeEventListener("pointermove", positionChatBubble);
    };
  }, [ref, editor]);
}
var import_jsx_runtime115, import_react87, CHAT_MESSAGE_TIMEOUT_CLOSING, CHAT_MESSAGE_TIMEOUT_CHATTING, CursorChatBubble, NotEditingChatMessage, CursorChatInput;
var init_CursorChatBubble = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/CursorChatBubble.mjs"() {
    import_jsx_runtime115 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react87 = __toESM(require_react(), 1);
    init_useTranslation();
    CHAT_MESSAGE_TIMEOUT_CLOSING = 2e3;
    CHAT_MESSAGE_TIMEOUT_CHATTING = 5e3;
    CursorChatBubble = track(function CursorChatBubble2() {
      const editor = useEditor();
      const { isChatting, chatMessage } = editor.getInstanceState();
      const rTimeout = (0, import_react87.useRef)(-1);
      const [value, setValue] = (0, import_react87.useState)("");
      (0, import_react87.useEffect)(() => {
        const closingUp = !isChatting && chatMessage;
        if (closingUp || isChatting) {
          const duration = isChatting ? CHAT_MESSAGE_TIMEOUT_CHATTING : CHAT_MESSAGE_TIMEOUT_CLOSING;
          rTimeout.current = editor.timers.setTimeout(() => {
            editor.updateInstanceState({ chatMessage: "", isChatting: false });
            setValue("");
            editor.focus();
          }, duration);
        }
        return () => {
          clearTimeout(rTimeout.current);
        };
      }, [editor, chatMessage, isChatting]);
      if (isChatting)
        return /* @__PURE__ */ (0, import_jsx_runtime115.jsx)(CursorChatInput, { value, setValue, chatMessage });
      return chatMessage.trim() ? /* @__PURE__ */ (0, import_jsx_runtime115.jsx)(NotEditingChatMessage, { chatMessage }) : null;
    });
    NotEditingChatMessage = ({ chatMessage }) => {
      const editor = useEditor();
      const ref = (0, import_react87.useRef)(null);
      usePositionBubble(ref);
      return /* @__PURE__ */ (0, import_jsx_runtime115.jsx)("div", {
        ref,
        className: "tl-cursor-chat tl-cursor-chat__bubble",
        style: { backgroundColor: editor.user.getColor() },
        children: chatMessage
      });
    };
    CursorChatInput = track(function CursorChatInput2({
      chatMessage,
      value,
      setValue
    }) {
      const editor = useEditor();
      const msg2 = useTranslation();
      const ref = (0, import_react87.useRef)(null);
      const placeholder = chatMessage || msg2("cursor-chat.type-to-chat");
      usePositionBubble(ref);
      (0, import_react87.useLayoutEffect)(() => {
        const elm = ref.current;
        if (!elm)
          return;
        const textMeasurement = editor.textMeasure.measureText(value || placeholder, {
          fontFamily: "var(--font-body)",
          fontSize: 12,
          fontWeight: "500",
          fontStyle: "normal",
          maxWidth: null,
          lineHeight: 1,
          padding: "6px"
        });
        elm.style.setProperty("width", textMeasurement.w + "px");
      }, [editor, value, placeholder]);
      (0, import_react87.useLayoutEffect)(() => {
        const raf = editor.timers.requestAnimationFrame(() => {
          ref.current?.focus();
        });
        return () => {
          cancelAnimationFrame(raf);
        };
      }, [editor]);
      const stopChatting = (0, import_react87.useCallback)(() => {
        editor.updateInstanceState({ isChatting: false });
        editor.focus();
      }, [editor]);
      const handleChange = (0, import_react87.useCallback)((e2) => {
        const { value: value2 } = e2.target;
        setValue(value2.slice(0, 64));
        editor.updateInstanceState({ chatMessage: value2 });
      }, [editor, setValue]);
      const handleKeyDown = (0, import_react87.useCallback)((e2) => {
        const elm = ref.current;
        if (!elm)
          return;
        const { value: currentValue } = elm;
        switch (e2.key) {
          case "Enter": {
            preventDefault(e2);
            e2.stopPropagation();
            if (!currentValue) {
              stopChatting();
              return;
            }
            setValue("");
            break;
          }
          case "Escape": {
            preventDefault(e2);
            e2.stopPropagation();
            stopChatting();
            break;
          }
        }
      }, [stopChatting, setValue]);
      const handlePaste = (0, import_react87.useCallback)((e2) => {
        e2.stopPropagation();
      }, []);
      return /* @__PURE__ */ (0, import_jsx_runtime115.jsx)("input", {
        ref,
        className: `tl-cursor-chat`,
        style: { backgroundColor: editor.user.getColor() },
        onBlur: stopChatting,
        onChange: handleChange,
        onKeyDown: handleKeyDown,
        onPaste: handlePaste,
        value,
        placeholder,
        spellCheck: false
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonCheck.mjs
function TldrawUiButtonCheck({ checked }) {
  return /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(TldrawUiIcon, { icon: checked ? "check" : "none", className: "tlui-button__icon", small: true });
}
var import_jsx_runtime116;
var init_TldrawUiButtonCheck = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/Button/TldrawUiButtonCheck.mjs"() {
    import_jsx_runtime116 = __toESM(require_jsx_runtime(), 1);
    init_TldrawUiIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/DebugMenu/DefaultDebugMenuContent.mjs
function DefaultDebugMenuContent() {
  const editor = useEditor();
  const { addToast } = useToasts();
  const { addDialog } = useDialogs();
  const [error2, setError] = import_react88.default.useState(false);
  return /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(import_jsx_runtime117.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(TldrawUiMenuGroup, { id: "items", children: [
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, {
        id: "add-toast",
        onSelect: () => {
          addToast({
            id: uniqueId(),
            title: "Something good happened",
            description: "Hey, attend to this thing over here. It might be important!",
            keepOpen: true,
            severity: "success"
          });
          addToast({
            id: uniqueId(),
            title: "Something happened",
            description: "Hey, attend to this thing over here. It might be important!",
            keepOpen: true,
            severity: "info",
            actions: [
              {
                label: "Primary",
                type: "primary",
                onClick: () => {
                }
              },
              {
                label: "Normal",
                type: "normal",
                onClick: () => {
                }
              },
              {
                label: "Danger",
                type: "danger",
                onClick: () => {
                }
              }
            ]
          });
          addToast({
            id: uniqueId(),
            title: "Something maybe bad happened",
            description: "Hey, attend to this thing over here. It might be important!",
            keepOpen: true,
            severity: "warning",
            actions: [
              {
                label: "Primary",
                type: "primary",
                onClick: () => {
                }
              },
              {
                label: "Normal",
                type: "normal",
                onClick: () => {
                }
              },
              {
                label: "Danger",
                type: "danger",
                onClick: () => {
                }
              }
            ]
          });
          addToast({
            id: uniqueId(),
            title: "Something bad happened",
            severity: "error",
            keepOpen: true
          });
        },
        label: untranslated("Show toast")
      }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, {
        id: "show-dialog",
        label: "Show dialog",
        onSelect: () => {
          addDialog({
            component: ({ onClose }) => /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(ExampleDialog, {
              displayDontShowAgain: true,
              onCancel: () => onClose(),
              onContinue: () => onClose()
            }),
            onClose: () => {
            }
          });
        }
      }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, {
        id: "create-shapes",
        label: "Create 100 shapes",
        onSelect: () => createNShapes(editor, 100)
      }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, {
        id: "count-nodes",
        label: "Count shapes / nodes",
        onSelect: () => {
          const selectedShapes = editor.getSelectedShapes();
          const shapes = selectedShapes.length === 0 ? editor.getRenderingShapes() : selectedShapes;
          window.alert(`Shapes ${shapes.length}, DOM nodes:${document.querySelector(".tl-shapes").querySelectorAll("*")?.length}`);
        }
      }),
      (() => {
        if (error2)
          throw Error("oh no!");
        return null;
      })(),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, { id: "throw-error", onSelect: () => setError(true), label: "Throw error" }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuItem, { id: "hard-reset", onSelect: hardResetEditor, label: "Hard reset" })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(TldrawUiMenuGroup, { id: "flags", children: [
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(DebugFlags, {}),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(FeatureFlags, {})
    ] })
  ] });
}
function DebugFlags() {
  const items = Object.values(debugFlags);
  if (!items.length)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuSubmenu, { id: "debug flags", label: "Debug Flags", children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuGroup, { id: "debug flags", children: items.map((flag) => /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(DebugFlagToggle, { flag }, flag.name)) }) });
}
function FeatureFlags() {
  const items = Object.values(featureFlags);
  if (!items.length)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuSubmenu, { id: "feature flags", label: "Feature Flags", children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuGroup, { id: "feature flags", children: items.map((flag) => /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(DebugFlagToggle, { flag }, flag.name)) }) });
}
function ExampleDialog({
  title = "title",
  body = "hello hello hello",
  cancel = "Cancel",
  confirm = "Continue",
  displayDontShowAgain = false,
  onCancel,
  onContinue
}) {
  const [dontShowAgain, setDontShowAgain] = import_react88.default.useState(false);
  return /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(import_jsx_runtime117.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(TldrawUiDialogHeader, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiDialogTitle, { children: title }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiDialogCloseButton, {})
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiDialogBody, { style: { maxWidth: 350 }, children: body }),
    /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(TldrawUiDialogFooter, { className: "tlui-dialog__footer__actions", children: [
      displayDontShowAgain && /* @__PURE__ */ (0, import_jsx_runtime117.jsxs)(TldrawUiButton, {
        type: "normal",
        onClick: () => setDontShowAgain(!dontShowAgain),
        style: { marginRight: "auto" },
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButtonCheck, { checked: dontShowAgain }),
          /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButtonLabel, { children: "Don\u2019t show again" })
        ]
      }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButton, { type: "normal", onClick: onCancel, children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButtonLabel, { children: cancel }) }),
      /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButton, { type: "primary", onClick: async () => onContinue(), children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiButtonLabel, { children: confirm }) })
    ] })
  ] });
}
function createNShapes(editor, n2) {
  const shapesToCreate = Array(n2);
  const cols = Math.floor(Math.sqrt(n2));
  for (let i2 = 0; i2 < n2; i2++) {
    t2++;
    shapesToCreate[i2] = {
      id: createShapeId("box" + t2),
      type: "geo",
      x: i2 % cols * 132,
      y: Math.floor(i2 / cols) * 132
    };
  }
  editor.run(() => {
    editor.createShapes(shapesToCreate).setSelectedShapes(shapesToCreate.map((s2) => s2.id));
  });
}
var import_jsx_runtime117, import_react88, DebugFlagToggle, t2;
var init_DefaultDebugMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/DebugMenu/DefaultDebugMenuContent.mjs"() {
    import_jsx_runtime117 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react88 = __toESM(require_react(), 1);
    init_dialogs();
    init_toasts();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonCheck();
    init_TldrawUiButtonLabel();
    init_TldrawUiDialog();
    init_TldrawUiMenuCheckboxItem();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
    init_TldrawUiMenuSubmenu();
    DebugFlagToggle = track(function DebugFlagToggle2({
      flag,
      onChange
    }) {
      const value = flag.get();
      return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(TldrawUiMenuCheckboxItem, {
        id: flag.name,
        title: flag.name,
        label: flag.name.replace(/([a-z0-9])([A-Z])/g, (m2) => `${m2[0]} ${m2[1].toLowerCase()}`).replace(/^[a-z]/, (m2) => m2.toUpperCase()),
        checked: value,
        onSelect: () => {
          flag.set(!value);
          onChange?.(!value);
        }
      });
    });
    t2 = 0;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/DebugMenu/DefaultDebugMenu.mjs
function DefaultDebugMenu({ children }) {
  const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(DefaultDebugMenuContent, {});
  return /* @__PURE__ */ (0, import_jsx_runtime118.jsxs)(TldrawUiDropdownMenuRoot, { id: "debug", children: [
    /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(TldrawUiButton, { type: "icon", title: "Debug menu", children: /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(TldrawUiButtonIcon, { icon: "dots-horizontal" }) }) }),
    /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(TldrawUiDropdownMenuContent, { side: "top", align: "end", alignOffset: 0, children: /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(TldrawUiMenuContextProvider, { type: "menu", sourceId: "debug-panel", children: content }) })
  ] });
}
var import_jsx_runtime118;
var init_DefaultDebugMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/DebugMenu/DefaultDebugMenu.mjs"() {
    import_jsx_runtime118 = __toESM(require_jsx_runtime(), 1);
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
    init_DefaultDebugMenuContent();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/DefaultDebugPanel.mjs
function useTick2(isEnabled = true) {
  const [_2, setTick] = (0, import_react89.useState)(0);
  const editor = useEditor();
  (0, import_react89.useEffect)(() => {
    if (!isEnabled)
      return;
    const update = () => setTick((tick3) => tick3 + 1);
    editor.on("tick", update);
    return () => {
      editor.off("tick", update);
    };
  }, [editor, isEnabled]);
}
function FPS() {
  const editor = useEditor();
  const showFps = useValue("show_fps", () => debugFlags.showFps.get(), [debugFlags]);
  const fpsRef = (0, import_react89.useRef)(null);
  (0, import_react89.useEffect)(() => {
    if (!showFps)
      return;
    const TICK_LENGTH = 250;
    let maxKnownFps = 0;
    let raf = -1;
    let start2 = performance.now();
    let currentTickLength = 0;
    let framesInCurrentTick = 0;
    let isSlow = false;
    function loop() {
      framesInCurrentTick++;
      currentTickLength = performance.now() - start2;
      if (currentTickLength > TICK_LENGTH) {
        const fps = Math.round(framesInCurrentTick * (TICK_LENGTH / currentTickLength) * (1e3 / TICK_LENGTH));
        if (fps > maxKnownFps) {
          maxKnownFps = fps;
        }
        const slowFps = maxKnownFps * 0.75;
        if (fps < slowFps && !isSlow || fps >= slowFps && isSlow) {
          isSlow = !isSlow;
        }
        fpsRef.current.innerHTML = `FPS ${fps.toString()}`;
        fpsRef.current.className = `tlui-debug-panel__fps` + (isSlow ? ` tlui-debug-panel__fps__slow` : ``);
        currentTickLength -= TICK_LENGTH;
        framesInCurrentTick = 0;
        start2 = performance.now();
      }
      raf = editor.timers.requestAnimationFrame(loop);
    }
    loop();
    return () => {
      cancelAnimationFrame(raf);
    };
  }, [showFps, editor]);
  if (!showFps)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime119.jsx)("div", { ref: fpsRef });
}
var import_jsx_runtime119, import_react89, DefaultDebugPanel, CurrentState;
var init_DefaultDebugPanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/DefaultDebugPanel.mjs"() {
    import_jsx_runtime119 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react89 = __toESM(require_react(), 1);
    init_components();
    DefaultDebugPanel = (0, import_react89.memo)(function DefaultDebugPanel2() {
      const { DebugMenu } = useTldrawUiComponents();
      return /* @__PURE__ */ (0, import_jsx_runtime119.jsxs)("div", { className: "tlui-debug-panel", children: [
        /* @__PURE__ */ (0, import_jsx_runtime119.jsx)(CurrentState, {}),
        /* @__PURE__ */ (0, import_jsx_runtime119.jsx)(FPS, {}),
        DebugMenu && /* @__PURE__ */ (0, import_jsx_runtime119.jsx)(DebugMenu, {})
      ] });
    });
    CurrentState = track(function CurrentState2() {
      useTick2();
      const editor = useEditor();
      const path = editor.getPath();
      const hoverShape = editor.getHoveredShape();
      const selectedShape = editor.getOnlySelectedShape();
      const shape = path === "select.idle" || !path.includes("select.") ? hoverShape : selectedShape;
      const shapeInfo = shape && path.includes("select.") ? ` / ${shape.type || ""}${"geo" in shape.props ? " / " + shape.props.geo : ""} / [${Vec.ToInt(editor.getPointInShapeSpace(shape, editor.inputs.currentPagePoint))}]` : "";
      const ruler = path.startsWith("select.") && !path.includes(".idle") ? ` / [${Vec.ToInt(editor.inputs.originPagePoint)}] \u2192 [${Vec.ToInt(editor.inputs.currentPagePoint)}] = ${Vec.Dist(editor.inputs.originPagePoint, editor.inputs.currentPagePoint).toFixed(0)}` : "";
      return /* @__PURE__ */ (0, import_jsx_runtime119.jsx)("div", { className: "tlui-debug-panel__current-state", children: `${path}${shapeInfo}${ruler}` });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/DefaultMenuPanel.mjs
var import_jsx_runtime120, import_react90, DefaultMenuPanel;
var init_DefaultMenuPanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/DefaultMenuPanel.mjs"() {
    import_jsx_runtime120 = __toESM(require_jsx_runtime(), 1);
    import_react90 = __toESM(require_react(), 1);
    init_breakpoints();
    init_components();
    DefaultMenuPanel = (0, import_react90.memo)(function MenuPanel() {
      const breakpoint = useBreakpoint();
      const { MainMenu, QuickActions, ActionsMenu, PageMenu } = useTldrawUiComponents();
      if (!MainMenu && !PageMenu && breakpoint < 6)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime120.jsx)("div", { className: "tlui-menu-zone", children: /* @__PURE__ */ (0, import_jsx_runtime120.jsxs)("div", { className: "tlui-buttons__horizontal", children: [
        MainMenu && /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(MainMenu, {}),
        PageMenu && /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(PageMenu, {}),
        breakpoint < 6 ? null : /* @__PURE__ */ (0, import_jsx_runtime120.jsxs)(import_jsx_runtime120.Fragment, { children: [
          QuickActions && /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(QuickActions, {}),
          ActionsMenu && /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(ActionsMenu, {})
        ] })
      ] }) });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/BackToContent.mjs
function BackToContent() {
  const editor = useEditor();
  const actions = useActions();
  const [showBackToContent, setShowBackToContent] = (0, import_react91.useState)(false);
  const rIsShowing = (0, import_react91.useRef)(false);
  useQuickReactor("toggle showback to content", () => {
    const showBackToContentPrev = rIsShowing.current;
    const shapeIds = editor.getCurrentPageShapeIds();
    let showBackToContentNow = false;
    if (shapeIds.size) {
      showBackToContentNow = shapeIds.size === editor.getCulledShapes().size;
    }
    if (showBackToContentPrev !== showBackToContentNow) {
      setShowBackToContent(showBackToContentNow);
      rIsShowing.current = showBackToContentNow;
    }
  }, [editor]);
  if (!showBackToContent)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime121.jsx)(TldrawUiMenuItem, {
    ...actions["back-to-content"],
    onSelect: () => {
      actions["back-to-content"].onSelect("helper-buttons");
      setShowBackToContent(false);
    }
  });
}
var import_jsx_runtime121, import_react91;
var init_BackToContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/BackToContent.mjs"() {
    import_jsx_runtime121 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react91 = __toESM(require_react(), 1);
    init_actions();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/ExitPenMode.mjs
function ExitPenMode() {
  const editor = useEditor();
  const actions = useActions();
  const isPenMode = useValue("is pen mode", () => editor.getInstanceState().isPenMode, [editor]);
  if (!isPenMode)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime122.jsx)(TldrawUiMenuItem, { ...actions["exit-pen-mode"] });
}
var import_jsx_runtime122;
var init_ExitPenMode = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/ExitPenMode.mjs"() {
    import_jsx_runtime122 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_actions();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/StopFollowing.mjs
function StopFollowing() {
  const editor = useEditor();
  const actions = useActions();
  const followingUser = useValue("is following user", () => !!editor.getInstanceState().followingUserId, [editor]);
  if (!followingUser)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime123.jsx)(TldrawUiMenuItem, { ...actions["stop-following"] });
}
var import_jsx_runtime123;
var init_StopFollowing = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/StopFollowing.mjs"() {
    import_jsx_runtime123 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_actions();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/DefaultHelperButtonsContent.mjs
function DefaultHelperButtonsContent() {
  return /* @__PURE__ */ (0, import_jsx_runtime124.jsxs)(import_jsx_runtime124.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(ExitPenMode, {}),
    /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(BackToContent, {}),
    /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(StopFollowing, {})
  ] });
}
var import_jsx_runtime124;
var init_DefaultHelperButtonsContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/DefaultHelperButtonsContent.mjs"() {
    import_jsx_runtime124 = __toESM(require_jsx_runtime(), 1);
    init_BackToContent();
    init_ExitPenMode();
    init_StopFollowing();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/DefaultHelperButtons.mjs
function DefaultHelperButtons({ children }) {
  const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime125.jsx)(DefaultHelperButtonsContent, {});
  return /* @__PURE__ */ (0, import_jsx_runtime125.jsx)("div", { className: "tlui-helper-buttons", children: /* @__PURE__ */ (0, import_jsx_runtime125.jsx)(TldrawUiMenuContextProvider, { type: "helper-buttons", sourceId: "helper-buttons", children: content }) });
}
var import_jsx_runtime125;
var init_DefaultHelperButtons = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelperButtons/DefaultHelperButtons.mjs"() {
    import_jsx_runtime125 = __toESM(require_jsx_runtime(), 1);
    init_TldrawUiMenuContext();
    init_DefaultHelperButtonsContent();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/KeyboardShortcutsDialog/DefaultKeyboardShortcutsDialogContent.mjs
function DefaultKeyboardShortcutsDialogContent() {
  const actions = useActions();
  const tools = useTools();
  const showCollaborationUi = useShowCollaborationUi();
  return /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(import_jsx_runtime126.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(TldrawUiMenuGroup, { label: "shortcuts-dialog.tools", id: "tools", children: [
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["toggle-tool-lock"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["insert-media"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["select"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["draw"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["eraser"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["hand"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["rectangle"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["ellipse"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["arrow"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["line"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["text"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["frame"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["note"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...tools["laser"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(TldrawUiMenuGroup, { label: "shortcuts-dialog.preferences", id: "preferences", children: [
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["toggle-dark-mode"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["toggle-focus-mode"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["toggle-grid"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(TldrawUiMenuGroup, { label: "shortcuts-dialog.edit", id: "edit", children: [
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["undo"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["redo"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["cut"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["copy"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["paste"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["select-all"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["delete"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["duplicate"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(TldrawUiMenuGroup, { label: "shortcuts-dialog.view", id: "view", children: [
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["zoom-in"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["zoom-out"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["zoom-to-100"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["zoom-to-fit"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["zoom-to-selection"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(TldrawUiMenuGroup, { label: "shortcuts-dialog.transform", id: "transform", children: [
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["bring-to-front"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["bring-forward"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["send-backward"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["send-to-back"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["group"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["ungroup"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["flip-horizontal"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["flip-vertical"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-top"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-center-vertical"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-bottom"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-left"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-center-horizontal"] }),
      /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["align-right"] })
    ] }),
    showCollaborationUi && /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuGroup, { label: "shortcuts-dialog.collaboration", id: "collaboration", children: /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(TldrawUiMenuItem, { ...actions["open-cursor-chat"] }) })
  ] });
}
var import_jsx_runtime126;
var init_DefaultKeyboardShortcutsDialogContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/KeyboardShortcutsDialog/DefaultKeyboardShortcutsDialogContent.mjs"() {
    import_jsx_runtime126 = __toESM(require_jsx_runtime(), 1);
    init_actions();
    init_useIsMultiplayer();
    init_useTools();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/KeyboardShortcutsDialog/DefaultKeyboardShortcutsDialog.mjs
var import_jsx_runtime127, import_classnames23, import_react92, DefaultKeyboardShortcutsDialog;
var init_DefaultKeyboardShortcutsDialog = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/KeyboardShortcutsDialog/DefaultKeyboardShortcutsDialog.mjs"() {
    import_jsx_runtime127 = __toESM(require_jsx_runtime(), 1);
    import_classnames23 = __toESM(require_classnames(), 1);
    import_react92 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_useTranslation();
    init_TldrawUiDialog();
    init_TldrawUiMenuContext();
    init_DefaultKeyboardShortcutsDialogContent();
    DefaultKeyboardShortcutsDialog = (0, import_react92.memo)(function DefaultKeyboardShortcutsDialog2({
      children
    }) {
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(DefaultKeyboardShortcutsDialogContent, {});
      return /* @__PURE__ */ (0, import_jsx_runtime127.jsxs)(import_jsx_runtime127.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime127.jsxs)(TldrawUiDialogHeader, { className: "tlui-shortcuts-dialog__header", children: [
          /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(TldrawUiDialogTitle, { children: msg2("shortcuts-dialog.title") }),
          /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(TldrawUiDialogCloseButton, {})
        ] }),
        /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(TldrawUiDialogBody, {
          className: (0, import_classnames23.default)("tlui-shortcuts-dialog__body", {
            "tlui-shortcuts-dialog__body__mobile": breakpoint <= PORTRAIT_BREAKPOINT.MOBILE_XS,
            "tlui-shortcuts-dialog__body__tablet": breakpoint <= PORTRAIT_BREAKPOINT.TABLET
          }),
          children: /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(TldrawUiMenuContextProvider, { type: "keyboard-shortcuts", sourceId: "kbd", children: content })
        }),
        /* @__PURE__ */ (0, import_jsx_runtime127.jsx)("div", { className: "tlui-dialog__scrim" })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ColorSchemeMenu.mjs
function ColorSchemeMenu() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const currentColorScheme = useValue("colorScheme", () => editor.user.getUserPreferences().colorScheme ?? editor.user.getIsDarkMode() ? "dark" : "light", [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime128.jsx)(TldrawUiMenuSubmenu, { id: "help menu color-scheme", label: "menu.theme", children: /* @__PURE__ */ (0, import_jsx_runtime128.jsx)(TldrawUiMenuGroup, { id: "languages", children: COLOR_SCHEMES.map(({ colorScheme, label }) => /* @__PURE__ */ (0, import_jsx_runtime128.jsx)(TldrawUiMenuCheckboxItem, {
    id: `color-scheme-${colorScheme}`,
    label,
    checked: colorScheme === currentColorScheme,
    onSelect: () => {
      editor.user.updateUserPreferences({ colorScheme });
      trackEvent("color-scheme", { source: "menu", value: colorScheme });
    }
  }, colorScheme)) }) });
}
var import_jsx_runtime128, COLOR_SCHEMES;
var init_ColorSchemeMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ColorSchemeMenu.mjs"() {
    import_jsx_runtime128 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_events();
    init_TldrawUiMenuCheckboxItem();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuSubmenu();
    COLOR_SCHEMES = [
      { colorScheme: "light", label: "theme.light" },
      { colorScheme: "dark", label: "theme.dark" },
      { colorScheme: "system", label: "theme.system" }
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/LanguageMenu.mjs
function LanguageMenu() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const currentLanguage = useValue("locale", () => editor.user.getLocale(), [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(TldrawUiMenuSubmenu, { id: "help menu language", label: "menu.language", children: /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(TldrawUiMenuGroup, { id: "languages", children: LANGUAGES.map(({ locale, label }) => /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(TldrawUiMenuCheckboxItem, {
    id: `language-${locale}`,
    title: locale,
    label,
    checked: locale === currentLanguage,
    onSelect: () => {
      editor.user.updateUserPreferences({ locale });
      trackEvent("change-language", { source: "menu", locale });
    }
  }, locale)) }) });
}
var import_jsx_runtime129;
var init_LanguageMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/LanguageMenu.mjs"() {
    import_jsx_runtime129 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_events();
    init_TldrawUiMenuCheckboxItem();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuSubmenu();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelpMenu/DefaultHelpMenuContent.mjs
function DefaultHelpMenuContent() {
  return /* @__PURE__ */ (0, import_jsx_runtime130.jsxs)(import_jsx_runtime130.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime130.jsx)(LanguageMenu, {}),
    /* @__PURE__ */ (0, import_jsx_runtime130.jsx)(KeyboardShortcutsMenuItem, {})
  ] });
}
function KeyboardShortcutsMenuItem() {
  const { KeyboardShortcutsDialog } = useTldrawUiComponents();
  const { addDialog } = useDialogs();
  if (!KeyboardShortcutsDialog)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime130.jsx)(TldrawUiMenuItem, {
    id: "keyboard-shortcuts-button",
    label: "help-menu.keyboard-shortcuts",
    readonlyOk: true,
    onSelect: () => {
      addDialog({ component: KeyboardShortcutsDialog });
    }
  });
}
var import_jsx_runtime130;
var init_DefaultHelpMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelpMenu/DefaultHelpMenuContent.mjs"() {
    import_jsx_runtime130 = __toESM(require_jsx_runtime(), 1);
    init_components();
    init_dialogs();
    init_LanguageMenu();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/MainMenu/DefaultMainMenuContent.mjs
function DefaultMainMenuContent() {
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(import_jsx_runtime131.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(EditSubmenu, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ViewSubmenu, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ExportFileContentSubMenu, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ExtrasGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(PreferencesGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(HelpGroup, {})
  ] });
}
function ExportFileContentSubMenu() {
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuSubmenu, { id: "export-all-as", label: "context-menu.export-all-as", size: "small", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "export-all-as-group", children: [
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["export-all-as-svg"] }),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["export-all-as-png"] }),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["export-all-as-json"] })
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "export-all-as-bg", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleTransparentBgMenuItem, {}) })
  ] });
}
function EditSubmenu() {
  const editor = useEditor();
  const selectToolActive = useValue("isSelectToolActive", () => editor.getCurrentToolId() === "select", [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuSubmenu, { id: "edit", label: "menu.edit", disabled: !selectToolActive, children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(UndoRedoGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ClipboardMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ConversionsMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(MiscMenuGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(LockGroup, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "select-all", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(SelectAllMenuItem, {}) })
  ] });
}
function MiscMenuGroup() {
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "misc", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(GroupMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(UngroupMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(EditLinkMenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleAutoSizeMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(RemoveFrameMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(FitFrameToContentMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ConvertToEmbedMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ConvertToBookmarkMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(FlattenMenuItem, {})
  ] });
}
function LockGroup() {
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "lock", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleLockMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(UnlockAllMenuItem, {})
  ] });
}
function UndoRedoGroup() {
  const actions = useActions();
  const canUndo = useCanUndo();
  const canRedo = useCanRedo();
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "undo-redo", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["undo"], disabled: !canUndo }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["redo"], disabled: !canRedo })
  ] });
}
function ViewSubmenu() {
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuSubmenu, { id: "view", label: "menu.view", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "view-actions", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["zoom-in"] }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["zoom-out"] }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ZoomTo100MenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ZoomToFitMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ZoomToSelectionMenuItem, {})
  ] }) });
}
function ExtrasGroup() {
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "extras", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["insert-embed"] }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, { ...actions["insert-media"] })
  ] });
}
function HelpGroup() {
  function openUrl(url) {
    window.open(url, "_blank");
  }
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "help", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuSubmenu, { id: "help", label: "menu.help", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "help-actions", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(KeyboardShortcutsMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuItem, {
      id: "about",
      label: "help-menu.docs",
      icon: "external-link",
      readonlyOk: true,
      onSelect: () => {
        openUrl("https://tldraw.dev");
      }
    })
  ] }) }) });
}
function PreferencesGroup() {
  return /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "preferences", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuSubmenu, { id: "preferences", label: "menu.preferences", children: [
    /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(TldrawUiMenuGroup, { id: "preferences-actions", children: [
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleSnapModeItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleToolLockItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleGridItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleWrapModeItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleFocusModeItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleEdgeScrollingItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleReduceMotionItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleDynamicSizeModeItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TogglePasteAtCursorItem, {}),
      /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ToggleDebugModeItem, {})
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "color-scheme", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(ColorSchemeMenu, {}) }),
    /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(TldrawUiMenuGroup, { id: "language", children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(LanguageMenu, {}) })
  ] }) });
}
var import_jsx_runtime131;
var init_DefaultMainMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/MainMenu/DefaultMainMenuContent.mjs"() {
    import_jsx_runtime131 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_actions();
    init_menu_hooks();
    init_ColorSchemeMenu();
    init_DefaultHelpMenuContent();
    init_LanguageMenu();
    init_menu_items();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
    init_TldrawUiMenuSubmenu();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/MainMenu/DefaultMainMenu.mjs
var import_jsx_runtime132, import_react93, DefaultMainMenu;
var init_DefaultMainMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/MainMenu/DefaultMainMenu.mjs"() {
    import_jsx_runtime132 = __toESM(require_jsx_runtime(), 1);
    init_dist28();
    init_dist_esm10();
    import_react93 = __toESM(require_react(), 1);
    init_useMenuIsOpen();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiMenuContext();
    init_DefaultMainMenuContent();
    DefaultMainMenu = (0, import_react93.memo)(function DefaultMainMenu2({ children }) {
      const container = useContainer();
      const [isOpen, onOpenChange] = useMenuIsOpen("main menu");
      const msg2 = useTranslation();
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(DefaultMainMenuContent, {});
      return /* @__PURE__ */ (0, import_jsx_runtime132.jsxs)(Root26, { dir: "ltr", open: isOpen, onOpenChange, modal: false, children: [
        /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(Trigger3, { asChild: true, dir: "ltr", children: /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(TldrawUiButton, { type: "icon", "data-testid": "main-menu.button", title: msg2("menu.title"), children: /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(TldrawUiButtonIcon, { icon: "menu", small: true }) }) }),
        /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(Portal23, { container, children: /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(Content25, {
          className: "tlui-menu",
          side: "bottom",
          align: "start",
          collisionPadding: 4,
          alignOffset: 0,
          sideOffset: 6,
          children: /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(TldrawUiMenuContextProvider, { type: "menu", sourceId: "main-menu", children: content })
        }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Minimap/getRgba.mjs
function getRgba(colorString) {
  if (memo15[colorString]) {
    return memo15[colorString];
  }
  const canvas = document.createElement("canvas");
  const context = canvas.getContext("2d");
  context.fillStyle = colorString;
  context.fillRect(0, 0, 1, 1);
  const [r2, g2, b2, a2] = context.getImageData(0, 0, 1, 1).data;
  const result = new Float32Array([r2 / 255, g2 / 255, b2 / 255, a2 / 255]);
  memo15[colorString] = result;
  return result;
}
var memo15;
var init_getRgba = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Minimap/getRgba.mjs"() {
    memo15 = {};
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Minimap/minimap-webgl-shapes.mjs
function pie(array2, {
  center,
  radius,
  numArcSegments = 20,
  startAngle = 0,
  endAngle = PI2,
  offset: offset5 = 0
}) {
  const angle = (endAngle - startAngle) / numArcSegments;
  let i2 = offset5;
  for (let a2 = startAngle; a2 < endAngle; a2 += angle) {
    array2[i2++] = center.x;
    array2[i2++] = center.y;
    array2[i2++] = center.x + Math.cos(a2) * radius;
    array2[i2++] = center.y + Math.sin(a2) * radius;
    array2[i2++] = center.x + Math.cos(a2 + angle) * radius;
    array2[i2++] = center.y + Math.sin(a2 + angle) * radius;
  }
  return array2;
}
function rectangle(array2, offset5, x2, y2, w2, h2) {
  array2[offset5++] = x2;
  array2[offset5++] = y2;
  array2[offset5++] = x2;
  array2[offset5++] = y2 + h2;
  array2[offset5++] = x2 + w2;
  array2[offset5++] = y2;
  array2[offset5++] = x2 + w2;
  array2[offset5++] = y2;
  array2[offset5++] = x2;
  array2[offset5++] = y2 + h2;
  array2[offset5++] = x2 + w2;
  array2[offset5++] = y2 + h2;
}
function roundedRectangle(data, box, radius) {
  const numArcSegments = numArcSegmentsPerCorner;
  radius = Math.min(radius, Math.min(box.w, box.h) / 2);
  const innerBox = Box.ExpandBy(box, -radius);
  if (innerBox.w <= 0 || innerBox.h <= 0) {
    pie(data, { center: box.center, radius, numArcSegments: numArcSegmentsPerCorner * 4 });
    return numArcSegmentsPerCorner * 4 * 6;
  }
  let offset5 = 0;
  rectangle(data, offset5, innerBox.minX, innerBox.minY, innerBox.w, innerBox.h);
  offset5 += 12;
  rectangle(data, offset5, innerBox.minX, box.minY, innerBox.w, radius);
  offset5 += 12;
  rectangle(data, offset5, innerBox.maxX, innerBox.minY, radius, innerBox.h);
  offset5 += 12;
  rectangle(data, offset5, innerBox.minX, innerBox.maxY, innerBox.w, radius);
  offset5 += 12;
  rectangle(data, offset5, box.minX, innerBox.minY, radius, innerBox.h);
  offset5 += 12;
  pie(data, {
    numArcSegments,
    offset: offset5,
    center: innerBox.point,
    radius,
    startAngle: PI,
    endAngle: PI * 1.5
  });
  offset5 += numArcSegments * 6;
  pie(data, {
    numArcSegments,
    offset: offset5,
    center: Vec.Add(innerBox.point, new Vec(innerBox.w, 0)),
    radius,
    startAngle: PI * 1.5,
    endAngle: PI2
  });
  offset5 += numArcSegments * 6;
  pie(data, {
    numArcSegments,
    offset: offset5,
    center: Vec.Add(innerBox.point, innerBox.size),
    radius,
    startAngle: 0,
    endAngle: HALF_PI
  });
  offset5 += numArcSegments * 6;
  pie(data, {
    numArcSegments,
    offset: offset5,
    center: Vec.Add(innerBox.point, new Vec(0, innerBox.h)),
    radius,
    startAngle: HALF_PI,
    endAngle: PI
  });
  return roundedRectangleDataSize;
}
var numArcSegmentsPerCorner, roundedRectangleDataSize;
var init_minimap_webgl_shapes = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Minimap/minimap-webgl-shapes.mjs"() {
    init_dist_esm10();
    numArcSegmentsPerCorner = 10;
    roundedRectangleDataSize = 4 * 6 * numArcSegmentsPerCorner + 12 + 4 * 12;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Minimap/minimap-webgl-setup.mjs
function setupWebGl(canvas) {
  if (!canvas)
    throw new Error("Canvas element not found");
  const context = canvas.getContext("webgl2", {
    premultipliedAlpha: false
  });
  if (!context)
    throw new Error("Failed to get webgl2 context");
  const vertexShaderSourceCode = `#version 300 es
  precision mediump float;
  
  in vec2 shapeVertexPosition;

	uniform vec4 canvasPageBounds;

	// taken (with thanks) from
	// https://webglfundamentals.org/webgl/lessons/webgl-2d-matrices.html
  void main() {
		// convert the position from pixels to 0.0 to 1.0
		vec2 zeroToOne = (shapeVertexPosition - canvasPageBounds.xy) / canvasPageBounds.zw;
	
		// convert from 0->1 to 0->2
		vec2 zeroToTwo = zeroToOne * 2.0;
	
		// convert from 0->2 to -1->+1 (clipspace)
		vec2 clipSpace = zeroToTwo - 1.0;
	
		gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
  }`;
  const vertexShader = context.createShader(context.VERTEX_SHADER);
  if (!vertexShader) {
    throw new Error("Failed to create vertex shader");
  }
  context.shaderSource(vertexShader, vertexShaderSourceCode);
  context.compileShader(vertexShader);
  if (!context.getShaderParameter(vertexShader, context.COMPILE_STATUS)) {
    throw new Error("Failed to compile vertex shader");
  }
  const fragmentShaderSourceCode = `#version 300 es
  precision mediump float;
  
	uniform vec4 fillColor;
  out vec4 outputColor;

  void main() {
	outputColor = fillColor;
  }`;
  const fragmentShader = context.createShader(context.FRAGMENT_SHADER);
  if (!fragmentShader) {
    throw new Error("Failed to create fragment shader");
  }
  context.shaderSource(fragmentShader, fragmentShaderSourceCode);
  context.compileShader(fragmentShader);
  if (!context.getShaderParameter(fragmentShader, context.COMPILE_STATUS)) {
    throw new Error("Failed to compile fragment shader");
  }
  const program = context.createProgram();
  if (!program) {
    throw new Error("Failed to create program");
  }
  context.attachShader(program, vertexShader);
  context.attachShader(program, fragmentShader);
  context.linkProgram(program);
  if (!context.getProgramParameter(program, context.LINK_STATUS)) {
    throw new Error("Failed to link program");
  }
  context.useProgram(program);
  const shapeVertexPositionAttributeLocation = context.getAttribLocation(program, "shapeVertexPosition");
  if (shapeVertexPositionAttributeLocation < 0) {
    throw new Error("Failed to get shapeVertexPosition attribute location");
  }
  context.enableVertexAttribArray(shapeVertexPositionAttributeLocation);
  const canvasPageBoundsLocation = context.getUniformLocation(program, "canvasPageBounds");
  const fillColorLocation = context.getUniformLocation(program, "fillColor");
  const selectedShapesBuffer = context.createBuffer();
  if (!selectedShapesBuffer)
    throw new Error("Failed to create buffer");
  const unselectedShapesBuffer = context.createBuffer();
  if (!unselectedShapesBuffer)
    throw new Error("Failed to create buffer");
  return {
    context,
    selectedShapes: allocateBuffer(context, 1024),
    unselectedShapes: allocateBuffer(context, 4096),
    viewport: allocateBuffer(context, roundedRectangleDataSize),
    collaborators: allocateBuffer(context, 1024),
    prepareTriangles(stuff, len) {
      context.bindBuffer(context.ARRAY_BUFFER, stuff.buffer);
      context.bufferData(context.ARRAY_BUFFER, stuff.vertices, context.STATIC_DRAW, 0, len);
      context.enableVertexAttribArray(shapeVertexPositionAttributeLocation);
      context.vertexAttribPointer(shapeVertexPositionAttributeLocation, 2, context.FLOAT, false, 0, 0);
    },
    drawTrianglesTransparently(len) {
      context.enable(context.BLEND);
      context.blendFunc(context.SRC_ALPHA, context.ONE_MINUS_SRC_ALPHA);
      context.drawArrays(context.TRIANGLES, 0, len / 2);
      context.disable(context.BLEND);
    },
    drawTriangles(len) {
      context.drawArrays(context.TRIANGLES, 0, len / 2);
    },
    setFillColor(color) {
      context.uniform4fv(fillColorLocation, color);
    },
    setCanvasPageBounds(bounds) {
      context.uniform4fv(canvasPageBoundsLocation, bounds);
    }
  };
}
function allocateBuffer(context, size4) {
  const buffer = context.createBuffer();
  if (!buffer)
    throw new Error("Failed to create buffer");
  return { buffer, vertices: new Float32Array(size4) };
}
function appendVertices(bufferStuff, offset5, data) {
  let len = bufferStuff.vertices.length;
  while (len < offset5 + data.length) {
    len *= 2;
  }
  if (len != bufferStuff.vertices.length) {
    const newVertices = new Float32Array(len);
    newVertices.set(bufferStuff.vertices);
    bufferStuff.vertices = newVertices;
  }
  bufferStuff.vertices.set(data, offset5);
}
var init_minimap_webgl_setup = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Minimap/minimap-webgl-setup.mjs"() {
    init_minimap_webgl_shapes();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Minimap/MinimapManager.mjs
var __defProp7, __getOwnPropDesc7, __decorateClass6, MinimapManager;
var init_MinimapManager = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Minimap/MinimapManager.mjs"() {
    init_dist_esm10();
    init_getRgba();
    init_minimap_webgl_setup();
    init_minimap_webgl_shapes();
    __defProp7 = Object.defineProperty;
    __getOwnPropDesc7 = Object.getOwnPropertyDescriptor;
    __decorateClass6 = (decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc7(target, key) : target;
      for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
        if (decorator = decorators[i2])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp7(target, key, result);
      return result;
    };
    MinimapManager = class {
      constructor(editor, elem, container) {
        __publicField(this, "disposables", []);
        __publicField(this, "close", () => this.disposables.forEach((d2) => d2()));
        __publicField(this, "gl");
        __publicField(this, "shapeGeometryCache");
        __publicField(this, "colors");
        __publicField(this, "id", uniqueId());
        __publicField(this, "canvasBoundingClientRect", atom2("canvasBoundingClientRect", new Box()));
        __publicField(this, "originPagePoint", new Vec());
        __publicField(this, "originPageCenter", new Vec());
        __publicField(this, "isInViewport", false);
        __publicField(this, "getMinimapPagePoint", (clientX, clientY) => {
          const canvasPageBounds = this.getCanvasPageBounds();
          const canvasScreenBounds = this.getCanvasScreenBounds();
          let x2 = clientX - canvasScreenBounds.x;
          let y2 = clientY - canvasScreenBounds.y;
          x2 *= canvasPageBounds.width / canvasScreenBounds.width;
          y2 *= canvasPageBounds.height / canvasScreenBounds.height;
          x2 += canvasPageBounds.minX;
          y2 += canvasPageBounds.minY;
          return new Vec(x2, y2, 1);
        });
        __publicField(this, "minimapScreenPointToPagePoint", (x2, y2, shiftKey = false, clampToBounds = false) => {
          const { editor } = this;
          const vpPageBounds = editor.getViewportPageBounds();
          let { x: px, y: py } = this.getMinimapPagePoint(x2, y2);
          if (clampToBounds) {
            const shapesPageBounds = this.editor.getCurrentPageBounds() ?? new Box();
            const minX = shapesPageBounds.minX - vpPageBounds.width / 2;
            const maxX = shapesPageBounds.maxX + vpPageBounds.width / 2;
            const minY = shapesPageBounds.minY - vpPageBounds.height / 2;
            const maxY = shapesPageBounds.maxY + vpPageBounds.height / 2;
            const lx = Math.max(0, minX + vpPageBounds.width - px);
            const rx = Math.max(0, -(maxX - vpPageBounds.width - px));
            const ly = Math.max(0, minY + vpPageBounds.height - py);
            const ry = Math.max(0, -(maxY - vpPageBounds.height - py));
            px += (lx - rx) / 2;
            py += (ly - ry) / 2;
            px = clamp(px, minX, maxX);
            py = clamp(py, minY, maxY);
          }
          if (shiftKey) {
            const { originPagePoint } = this;
            const dx = Math.abs(px - originPagePoint.x);
            const dy = Math.abs(py - originPagePoint.y);
            if (dx > dy) {
              py = originPagePoint.y;
            } else {
              px = originPagePoint.x;
            }
          }
          return new Vec(px, py);
        });
        __publicField(this, "render", () => {
          const context = this.gl.context;
          const canvasSize2 = this.getCanvasSize();
          this.gl.setCanvasPageBounds(this.getCanvasPageBoundsArray());
          this.elem.width = canvasSize2.x;
          this.elem.height = canvasSize2.y;
          context.viewport(0, 0, canvasSize2.x, canvasSize2.y);
          context.clearColor(this.colors.background[0], this.colors.background[1], this.colors.background[2], 1);
          context.clear(context.COLOR_BUFFER_BIT);
          const selectedShapes = new Set(this.editor.getSelectedShapeIds());
          const colors = this.colors;
          let selectedShapeOffset = 0;
          let unselectedShapeOffset = 0;
          const ids = this.editor.getCurrentPageShapeIdsSorted();
          for (let i2 = 0, len = ids.length; i2 < len; i2++) {
            const shapeId = ids[i2];
            const geometry = this.shapeGeometryCache.get(shapeId);
            if (!geometry)
              continue;
            const len2 = geometry.length;
            if (selectedShapes.has(shapeId)) {
              appendVertices(this.gl.selectedShapes, selectedShapeOffset, geometry);
              selectedShapeOffset += len2;
            } else {
              appendVertices(this.gl.unselectedShapes, unselectedShapeOffset, geometry);
              unselectedShapeOffset += len2;
            }
          }
          this.drawShapes(this.gl.unselectedShapes, unselectedShapeOffset, colors.shapeFill);
          this.drawShapes(this.gl.selectedShapes, selectedShapeOffset, colors.selectFill);
          this.drawViewport();
          this.drawCollaborators();
        });
        this.editor = editor;
        this.elem = elem;
        this.container = container;
        this.gl = setupWebGl(elem);
        this.shapeGeometryCache = editor.store.createComputedCache("webgl-geometry", (r2) => {
          const bounds = editor.getShapeMaskedPageBounds(r2.id);
          if (!bounds)
            return null;
          const arr = new Float32Array(12);
          rectangle(arr, 0, bounds.x, bounds.y, bounds.w, bounds.h);
          return arr;
        });
        this.colors = this._getColors();
        this.disposables.push(this._listenForCanvasResize(), react("minimap render", this.render));
      }
      _getColors() {
        const style = getComputedStyle(this.editor.getContainer());
        return {
          shapeFill: getRgba(style.getPropertyValue("--color-text-3").trim()),
          selectFill: getRgba(style.getPropertyValue("--color-selected").trim()),
          viewportFill: getRgba(style.getPropertyValue("--color-muted-1").trim()),
          background: getRgba(style.getPropertyValue("--color-low").trim())
        };
      }
      updateColors() {
        this.colors = this._getColors();
      }
      getDpr() {
        return this.editor.getInstanceState().devicePixelRatio;
      }
      getContentPageBounds() {
        const viewportPageBounds = this.editor.getViewportPageBounds();
        const commonShapeBounds = this.editor.getCurrentPageBounds();
        return commonShapeBounds ? Box.Expand(commonShapeBounds, viewportPageBounds) : viewportPageBounds;
      }
      getContentScreenBounds() {
        const contentPageBounds = this.getContentPageBounds();
        const topLeft = this.editor.pageToScreen(contentPageBounds.point);
        const bottomRight = this.editor.pageToScreen(new Vec(contentPageBounds.maxX, contentPageBounds.maxY));
        return new Box(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
      }
      _getCanvasBoundingRect() {
        const { x: x2, y: y2, width, height } = this.elem.getBoundingClientRect();
        return new Box(x2, y2, width, height);
      }
      getCanvasScreenBounds() {
        return this.canvasBoundingClientRect.get();
      }
      _listenForCanvasResize() {
        const observer = new ResizeObserver(() => {
          const rect = this._getCanvasBoundingRect();
          this.canvasBoundingClientRect.set(rect);
        });
        observer.observe(this.elem);
        observer.observe(this.container);
        return () => observer.disconnect();
      }
      getCanvasSize() {
        const rect = this.canvasBoundingClientRect.get();
        const dpr = this.getDpr();
        return new Vec(rect.width * dpr, rect.height * dpr);
      }
      getCanvasClientPosition() {
        return this.canvasBoundingClientRect.get().point;
      }
      getCanvasPageBounds() {
        const canvasScreenBounds = this.getCanvasScreenBounds();
        const contentPageBounds = this.getContentPageBounds();
        const aspectRatio = canvasScreenBounds.width / canvasScreenBounds.height;
        let targetWidth = contentPageBounds.width;
        let targetHeight = targetWidth / aspectRatio;
        if (targetHeight < contentPageBounds.height) {
          targetHeight = contentPageBounds.height;
          targetWidth = targetHeight * aspectRatio;
        }
        const box = new Box(0, 0, targetWidth, targetHeight);
        box.center = contentPageBounds.center;
        return box;
      }
      getZoom() {
        return this.getCanvasPageBounds().width / this.getCanvasScreenBounds().width;
      }
      getCanvasPageBoundsArray() {
        const { x: x2, y: y2, w: w2, h: h2 } = this.getCanvasPageBounds();
        return new Float32Array([x2, y2, w2, h2]);
      }
      drawShapes(stuff, len, color) {
        this.gl.prepareTriangles(stuff, len);
        this.gl.setFillColor(color);
        this.gl.drawTriangles(len);
      }
      drawViewport() {
        const viewport2 = this.editor.getViewportPageBounds();
        const len = roundedRectangle(this.gl.viewport.vertices, viewport2, 4 * this.getZoom());
        this.gl.prepareTriangles(this.gl.viewport, len);
        this.gl.setFillColor(this.colors.viewportFill);
        this.gl.drawTrianglesTransparently(len);
        if (this.editor.environment.isSafari) {
          this.gl.drawTrianglesTransparently(len);
          this.gl.drawTrianglesTransparently(len);
          this.gl.drawTrianglesTransparently(len);
        }
      }
      drawCollaborators() {
        const collaborators = this.editor.getCollaboratorsOnCurrentPage();
        if (!collaborators.length)
          return;
        const numSegmentsPerCircle = 20;
        const dataSizePerCircle = numSegmentsPerCircle * 6;
        const totalSize = dataSizePerCircle * collaborators.length;
        if (this.gl.collaborators.vertices.length < totalSize) {
          this.gl.collaborators.vertices = new Float32Array(totalSize);
        }
        const vertices = this.gl.collaborators.vertices;
        let offset5 = 0;
        const zoom = this.getZoom();
        for (const { cursor } of collaborators) {
          pie(vertices, {
            center: Vec.From(cursor),
            radius: 3 * zoom,
            offset: offset5,
            numArcSegments: numSegmentsPerCircle
          });
          offset5 += dataSizePerCircle;
        }
        this.gl.prepareTriangles(this.gl.collaborators, totalSize);
        offset5 = 0;
        for (const { color } of collaborators) {
          this.gl.setFillColor(getRgba(color));
          this.gl.context.drawArrays(this.gl.context.TRIANGLES, offset5 / 2, dataSizePerCircle / 2);
          offset5 += dataSizePerCircle;
        }
      }
    };
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getDpr", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getContentPageBounds", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getContentScreenBounds", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getCanvasSize", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getCanvasClientPosition", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getCanvasPageBounds", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getZoom", 1);
    __decorateClass6([
      computed
    ], MinimapManager.prototype, "getCanvasPageBoundsArray", 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Minimap/DefaultMinimap.mjs
function DefaultMinimap() {
  const editor = useEditor();
  const container = useContainer();
  const rCanvas = React62.useRef(null);
  const rPointing = React62.useRef(false);
  const minimapRef = React62.useRef();
  React62.useEffect(() => {
    try {
      const minimap = new MinimapManager(editor, rCanvas.current, container);
      minimapRef.current = minimap;
      return minimapRef.current.close;
    } catch (e2) {
      editor.annotateError(e2, {
        origin: "minimap",
        willCrashApp: false
      });
      editor.timers.setTimeout(() => {
        throw e2;
      });
    }
  }, [editor, container]);
  const onDoubleClick = React62.useCallback((e2) => {
    if (!editor.getCurrentPageShapeIds().size)
      return;
    if (!minimapRef.current)
      return;
    const point = minimapRef.current.minimapScreenPointToPagePoint(e2.clientX, e2.clientY, false, false);
    const clampedPoint = minimapRef.current.minimapScreenPointToPagePoint(e2.clientX, e2.clientY, false, true);
    minimapRef.current.originPagePoint.setTo(clampedPoint);
    minimapRef.current.originPageCenter.setTo(editor.getViewportPageBounds().center);
    editor.centerOnPoint(point, { animation: { duration: editor.options.animationMediumMs } });
  }, [editor]);
  const onPointerDown = React62.useCallback((e2) => {
    if (!minimapRef.current)
      return;
    const elm = e2.currentTarget;
    setPointerCapture(elm, e2);
    if (!editor.getCurrentPageShapeIds().size)
      return;
    rPointing.current = true;
    minimapRef.current.isInViewport = false;
    const point = minimapRef.current.minimapScreenPointToPagePoint(e2.clientX, e2.clientY, false, false);
    const _vpPageBounds = editor.getViewportPageBounds();
    const commonBounds = minimapRef.current.getContentPageBounds();
    const allowedBounds = new Box(commonBounds.x - _vpPageBounds.width / 2, commonBounds.y - _vpPageBounds.height / 2, commonBounds.width + _vpPageBounds.width, commonBounds.height + _vpPageBounds.height);
    if (allowedBounds.containsPoint(point) && !_vpPageBounds.containsPoint(point)) {
      minimapRef.current.isInViewport = _vpPageBounds.containsPoint(point);
      const delta = Vec.Sub(_vpPageBounds.center, _vpPageBounds.point);
      const pagePoint = Vec.Add(point, delta);
      minimapRef.current.originPagePoint.setTo(pagePoint);
      minimapRef.current.originPageCenter.setTo(point);
      editor.centerOnPoint(point, { animation: { duration: editor.options.animationMediumMs } });
    } else {
      const clampedPoint = minimapRef.current.minimapScreenPointToPagePoint(e2.clientX, e2.clientY, false, true);
      minimapRef.current.isInViewport = _vpPageBounds.containsPoint(clampedPoint);
      minimapRef.current.originPagePoint.setTo(clampedPoint);
      minimapRef.current.originPageCenter.setTo(_vpPageBounds.center);
    }
    function release(e22) {
      if (elm) {
        releasePointerCapture(elm, e22);
      }
      rPointing.current = false;
      document.body.removeEventListener("pointerup", release);
    }
    document.body.addEventListener("pointerup", release);
  }, [editor]);
  const onPointerMove = React62.useCallback((e2) => {
    if (!minimapRef.current)
      return;
    const point = minimapRef.current.minimapScreenPointToPagePoint(e2.clientX, e2.clientY, e2.shiftKey, true);
    if (rPointing.current) {
      if (minimapRef.current.isInViewport) {
        const delta = minimapRef.current.originPagePoint.clone().sub(minimapRef.current.originPageCenter);
        editor.centerOnPoint(Vec.Sub(point, delta));
        return;
      }
      editor.centerOnPoint(point);
    }
    const pagePoint = minimapRef.current.getMinimapPagePoint(e2.clientX, e2.clientY);
    const screenPoint = editor.pageToScreen(pagePoint);
    const info2 = {
      type: "pointer",
      target: "canvas",
      name: "pointer_move",
      ...getPointerInfo(e2),
      point: screenPoint,
      isPen: editor.getInstanceState().isPenMode
    };
    editor.dispatch(info2);
  }, [editor]);
  const onWheel = React62.useCallback((e2) => {
    const offset5 = normalizeWheel(e2);
    editor.dispatch({
      type: "wheel",
      name: "wheel",
      delta: offset5,
      point: new Vec(e2.clientX, e2.clientY),
      shiftKey: e2.shiftKey,
      altKey: e2.altKey,
      ctrlKey: e2.metaKey || e2.ctrlKey
    });
  }, [editor]);
  const isDarkMode = useIsDarkMode();
  React62.useEffect(() => {
    editor.timers.setTimeout(() => {
      minimapRef.current?.updateColors();
      minimapRef.current?.render();
    });
  }, [isDarkMode, editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime133.jsx)("div", { className: "tlui-minimap", children: /* @__PURE__ */ (0, import_jsx_runtime133.jsx)("canvas", {
    role: "img",
    "aria-label": "minimap",
    ref: rCanvas,
    className: "tlui-minimap__canvas",
    onDoubleClick,
    onPointerMove,
    onPointerDown,
    onWheel
  }) });
}
var import_jsx_runtime133, React62;
var init_DefaultMinimap = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Minimap/DefaultMinimap.mjs"() {
    import_jsx_runtime133 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    React62 = __toESM(require_react(), 1);
    init_MinimapManager();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useLocalStorageState.mjs
function useLocalStorageState(key, defaultValue) {
  const [state, setState] = import_react94.default.useState(defaultValue);
  import_react94.default.useLayoutEffect(() => {
    const value = getFromLocalStorage(key);
    if (value) {
      try {
        setState(JSON.parse(value));
      } catch (e2) {
        console.error(`Could not restore value ${key} from local storage.`);
      }
    }
  }, [key]);
  const updateValue = import_react94.default.useCallback((setter) => {
    setState((s2) => {
      const value = typeof setter === "function" ? setter(s2) : setter;
      setInLocalStorage(key, JSON.stringify(value));
      return value;
    });
  }, [key]);
  return [state, updateValue];
}
var import_react94;
var init_useLocalStorageState = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useLocalStorageState.mjs"() {
    init_dist_esm10();
    import_react94 = __toESM(require_react(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/NavigationPanel/DefaultNavigationPanel.mjs
var import_jsx_runtime134, import_react95, DefaultNavigationPanel;
var init_DefaultNavigationPanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/NavigationPanel/DefaultNavigationPanel.mjs"() {
    import_jsx_runtime134 = __toESM(require_jsx_runtime(), 1);
    import_react95 = __toESM(require_react(), 1);
    init_constants5();
    init_actions();
    init_breakpoints();
    init_components();
    init_useLocalStorageState();
    init_useTranslation();
    init_kbd_utils();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    DefaultNavigationPanel = (0, import_react95.memo)(function DefaultNavigationPanel2() {
      const actions = useActions();
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const [collapsed, setCollapsed] = useLocalStorageState("minimap", true);
      const toggleMinimap = (0, import_react95.useCallback)(() => {
        setCollapsed((s2) => !s2);
      }, [setCollapsed]);
      const { ZoomMenu, Minimap } = useTldrawUiComponents();
      if (breakpoint < PORTRAIT_BREAKPOINT.MOBILE) {
        return null;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime134.jsxs)("div", { className: "tlui-navigation-panel", children: [
        /* @__PURE__ */ (0, import_jsx_runtime134.jsx)("div", { className: "tlui-buttons__horizontal", children: ZoomMenu && breakpoint < PORTRAIT_BREAKPOINT.TABLET ? /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(ZoomMenu, {}) : collapsed ? /* @__PURE__ */ (0, import_jsx_runtime134.jsxs)(import_jsx_runtime134.Fragment, { children: [
          ZoomMenu && /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(ZoomMenu, {}),
          Minimap && /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButton, {
            type: "icon",
            "data-testid": "minimap.toggle-button",
            title: msg2("navigation-zone.toggle-minimap"),
            className: "tlui-navigation-panel__toggle",
            onClick: toggleMinimap,
            children: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButtonIcon, { icon: collapsed ? "chevrons-ne" : "chevrons-sw" })
          })
        ] }) : /* @__PURE__ */ (0, import_jsx_runtime134.jsxs)(import_jsx_runtime134.Fragment, { children: [
          /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButton, {
            type: "icon",
            "data-testid": "minimap.zoom-out",
            title: `${msg2(unwrapLabel(actions["zoom-out"].label))} ${kbdStr(actions["zoom-out"].kbd)}`,
            onClick: () => actions["zoom-out"].onSelect("navigation-zone"),
            children: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButtonIcon, { icon: "minus" })
          }),
          ZoomMenu && /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(ZoomMenu, {}),
          /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButton, {
            type: "icon",
            "data-testid": "minimap.zoom-in",
            title: `${msg2(unwrapLabel(actions["zoom-in"].label))} ${kbdStr(actions["zoom-in"].kbd)}`,
            onClick: () => actions["zoom-in"].onSelect("navigation-zone"),
            children: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButtonIcon, { icon: "plus" })
          }),
          Minimap && /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButton, {
            type: "icon",
            "data-testid": "minimap.toggle-button",
            title: msg2("navigation-zone.toggle-minimap"),
            className: "tlui-navigation-panel__toggle",
            onClick: toggleMinimap,
            children: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(TldrawUiButtonIcon, { icon: collapsed ? "chevrons-ne" : "chevrons-sw" })
          })
        ] }) }),
        Minimap && breakpoint >= PORTRAIT_BREAKPOINT.TABLET && !collapsed && /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(Minimap, {})
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/PageItemInput.mjs
var import_jsx_runtime135, import_react96, PageItemInput;
var init_PageItemInput = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/PageItemInput.mjs"() {
    import_jsx_runtime135 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react96 = __toESM(require_react(), 1);
    init_events();
    init_TldrawUiInput();
    PageItemInput = function PageItemInput2({
      name,
      id,
      isCurrentPage
    }) {
      const editor = useEditor();
      const trackEvent = useUiEvents();
      const rInput = (0, import_react96.useRef)(null);
      const handleFocus = (0, import_react96.useCallback)(() => {
        editor.mark("rename page");
      }, [editor]);
      const handleChange = (0, import_react96.useCallback)((value) => {
        editor.renamePage(id, value || "New Page");
        trackEvent("rename-page", { source: "page-menu" });
      }, [editor, id, trackEvent]);
      return /* @__PURE__ */ (0, import_jsx_runtime135.jsx)(TldrawUiInput, {
        className: "tlui-page-menu__item__input",
        ref: (el) => rInput.current = el,
        defaultValue: name,
        onValueChange: handleChange,
        onFocus: handleFocus,
        shouldManuallyMaintainScrollPositionWhenFocused: true,
        autoFocus: isCurrentPage,
        autoSelect: true
      });
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/edit-pages-shared.mjs
var onMovePage;
var init_edit_pages_shared = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/edit-pages-shared.mjs"() {
    init_dist_esm10();
    onMovePage = (editor, id, from, to, trackEvent) => {
      let index3;
      const pages = editor.getPages();
      const below = from > to ? pages[to - 1] : pages[to];
      const above = from > to ? pages[to] : pages[to + 1];
      if (below && !above) {
        index3 = getIndexAbove(below.index);
      } else if (!below && above) {
        index3 = getIndexBelow(pages[0].index);
      } else {
        index3 = getIndexBetween(below.index, above.index);
      }
      if (index3 !== pages[from].index) {
        editor.mark("moving page");
        editor.updatePage({
          id,
          index: index3
        });
        trackEvent("move-page", { source: "page-menu" });
      }
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/PageItemSubmenu.mjs
var import_jsx_runtime136, import_react97, PageItemSubmenu;
var init_PageItemSubmenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/PageItemSubmenu.mjs"() {
    import_jsx_runtime136 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react97 = __toESM(require_react(), 1);
    init_events();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
    init_edit_pages_shared();
    PageItemSubmenu = track(function PageItemSubmenu2({
      index: index3,
      listSize,
      item,
      onRename
    }) {
      const editor = useEditor();
      const msg2 = useTranslation();
      const pages = editor.getPages();
      const trackEvent = useUiEvents();
      const onDuplicate = (0, import_react97.useCallback)(() => {
        editor.mark("creating page");
        const newId = PageRecordType.createId();
        editor.duplicatePage(item.id, newId);
        trackEvent("duplicate-page", { source: "page-menu" });
      }, [editor, item, trackEvent]);
      const onMoveUp = (0, import_react97.useCallback)(() => {
        onMovePage(editor, item.id, index3, index3 - 1, trackEvent);
      }, [editor, item, index3, trackEvent]);
      const onMoveDown = (0, import_react97.useCallback)(() => {
        onMovePage(editor, item.id, index3, index3 + 1, trackEvent);
      }, [editor, item, index3, trackEvent]);
      const onDelete = (0, import_react97.useCallback)(() => {
        editor.mark("deleting page");
        editor.deletePage(item.id);
        trackEvent("delete-page", { source: "page-menu" });
      }, [editor, item, trackEvent]);
      return /* @__PURE__ */ (0, import_jsx_runtime136.jsxs)(TldrawUiDropdownMenuRoot, { id: `page item submenu ${index3}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiButton, { type: "icon", title: msg2("page-menu.submenu.title"), children: /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiButtonIcon, { icon: "dots-vertical" }) }) }),
        /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiDropdownMenuContent, { alignOffset: 0, side: "right", sideOffset: -4, children: /* @__PURE__ */ (0, import_jsx_runtime136.jsxs)(TldrawUiMenuContextProvider, { type: "menu", sourceId: "page-menu", children: [
          /* @__PURE__ */ (0, import_jsx_runtime136.jsxs)(TldrawUiMenuGroup, { id: "modify", children: [
            onRename && /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuItem, { id: "rename", label: "page-menu.submenu.rename", onSelect: onRename }),
            /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuItem, {
              id: "duplicate",
              label: "page-menu.submenu.duplicate-page",
              onSelect: onDuplicate,
              disabled: pages.length >= editor.options.maxPages
            }),
            index3 > 0 && /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuItem, {
              id: "move-up",
              onSelect: onMoveUp,
              label: "page-menu.submenu.move-up"
            }),
            index3 < listSize - 1 && /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuItem, {
              id: "move-down",
              label: "page-menu.submenu.move-down",
              onSelect: onMoveDown
            })
          ] }),
          listSize > 1 && /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuGroup, { id: "delete", children: /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(TldrawUiMenuItem, { id: "delete", onSelect: onDelete, label: "page-menu.submenu.delete" }) })
        ] }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/DefaultPageMenu.mjs
var import_jsx_runtime137, import_react98, DefaultPageMenu;
var init_DefaultPageMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/PageMenu/DefaultPageMenu.mjs"() {
    import_jsx_runtime137 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react98 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_events();
    init_useMenuIsOpen();
    init_useReadonly();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonCheck();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiPopover();
    init_PageItemInput();
    init_PageItemSubmenu();
    init_edit_pages_shared();
    DefaultPageMenu = (0, import_react98.memo)(function DefaultPageMenu2() {
      const editor = useEditor();
      const trackEvent = useUiEvents();
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const handleOpenChange = (0, import_react98.useCallback)(() => setIsEditing(false), []);
      const [isOpen, onOpenChange] = useMenuIsOpen("page-menu", handleOpenChange);
      const ITEM_HEIGHT = 36;
      const rSortableContainer = (0, import_react98.useRef)(null);
      const pages = useValue("pages", () => editor.getPages(), [editor]);
      const currentPage = useValue("currentPage", () => editor.getCurrentPage(), [editor]);
      const currentPageId = useValue("currentPageId", () => editor.getCurrentPageId(), [editor]);
      const isReadonlyMode = useReadonly();
      const maxPageCountReached = useValue("maxPageCountReached", () => editor.getPages().length >= editor.options.maxPages, [editor]);
      const isCoarsePointer = useValue("isCoarsePointer", () => editor.getInstanceState().isCoarsePointer, [editor]);
      const [isEditing, setIsEditing] = (0, import_react98.useState)(false);
      const toggleEditing = (0, import_react98.useCallback)(() => {
        if (isReadonlyMode)
          return;
        setIsEditing((s2) => !s2);
      }, [isReadonlyMode]);
      const rMutables = (0, import_react98.useRef)({
        isPointing: false,
        status: "idle",
        pointing: null,
        startY: 0,
        startIndex: 0,
        dragIndex: 0
      });
      const [sortablePositionItems, setSortablePositionItems] = (0, import_react98.useState)(Object.fromEntries(pages.map((page, i2) => [page.id, { y: i2 * ITEM_HEIGHT, offsetY: 0, isSelected: false }])));
      (0, import_react98.useLayoutEffect)(() => {
        setSortablePositionItems(Object.fromEntries(pages.map((page, i2) => [page.id, { y: i2 * ITEM_HEIGHT, offsetY: 0, isSelected: false }])));
      }, [ITEM_HEIGHT, pages]);
      (0, import_react98.useEffect)(() => {
        if (!isOpen)
          return;
        editor.timers.requestAnimationFrame(() => {
          const elm = document.querySelector(`[data-testid="page-menu-item-${currentPageId}"]`);
          if (elm) {
            const container = rSortableContainer.current;
            if (!container)
              return;
            const elmTopPosition = elm.offsetTop;
            const containerScrollTopPosition = container.scrollTop;
            if (elmTopPosition < containerScrollTopPosition) {
              container.scrollTo({ top: elmTopPosition });
            }
            const elmBottomPosition = elmTopPosition + ITEM_HEIGHT;
            const containerScrollBottomPosition = container.scrollTop + container.offsetHeight;
            if (elmBottomPosition > containerScrollBottomPosition) {
              container.scrollTo({ top: elmBottomPosition - container.offsetHeight });
            }
          }
        });
      }, [ITEM_HEIGHT, currentPageId, isOpen, editor]);
      const handlePointerDown = (0, import_react98.useCallback)((e2) => {
        const { clientY, currentTarget } = e2;
        const {
          dataset: { id, index: index3 }
        } = currentTarget;
        if (!id || !index3)
          return;
        const mut = rMutables.current;
        setPointerCapture(e2.currentTarget, e2);
        mut.status = "pointing";
        mut.pointing = { id, index: +index3 };
        const current = sortablePositionItems[id];
        const dragY = current.y;
        mut.startY = clientY;
        mut.startIndex = Math.max(0, Math.min(Math.round(dragY / ITEM_HEIGHT), pages.length - 1));
      }, [ITEM_HEIGHT, pages.length, sortablePositionItems]);
      const handlePointerMove = (0, import_react98.useCallback)((e2) => {
        const mut = rMutables.current;
        if (mut.status === "pointing") {
          const { clientY } = e2;
          const offset5 = clientY - mut.startY;
          if (Math.abs(offset5) > 5) {
            mut.status = "dragging";
          }
        }
        if (mut.status === "dragging") {
          const { clientY } = e2;
          const offsetY = clientY - mut.startY;
          const current = sortablePositionItems[mut.pointing.id];
          const { startIndex, pointing } = mut;
          const dragY = current.y + offsetY;
          const dragIndex = Math.max(0, Math.min(Math.round(dragY / ITEM_HEIGHT), pages.length - 1));
          const next = { ...sortablePositionItems };
          next[pointing.id] = {
            y: current.y,
            offsetY,
            isSelected: true
          };
          if (dragIndex !== mut.dragIndex) {
            mut.dragIndex = dragIndex;
            for (let i2 = 0; i2 < pages.length; i2++) {
              const item = pages[i2];
              if (item.id === mut.pointing.id) {
                continue;
              }
              let { y: y2 } = next[item.id];
              if (dragIndex === startIndex) {
                y2 = i2 * ITEM_HEIGHT;
              } else if (dragIndex < startIndex) {
                if (dragIndex <= i2 && i2 < startIndex) {
                  y2 = (i2 + 1) * ITEM_HEIGHT;
                } else {
                  y2 = i2 * ITEM_HEIGHT;
                }
              } else if (dragIndex > startIndex) {
                if (dragIndex >= i2 && i2 > startIndex) {
                  y2 = (i2 - 1) * ITEM_HEIGHT;
                } else {
                  y2 = i2 * ITEM_HEIGHT;
                }
              }
              if (y2 !== next[item.id].y) {
                next[item.id] = { y: y2, offsetY: 0, isSelected: true };
              }
            }
          }
          setSortablePositionItems(next);
        }
      }, [ITEM_HEIGHT, pages, sortablePositionItems]);
      const handlePointerUp = (0, import_react98.useCallback)((e2) => {
        const mut = rMutables.current;
        if (mut.status === "dragging") {
          const { id, index: index3 } = mut.pointing;
          onMovePage(editor, id, index3, mut.dragIndex, trackEvent);
        }
        releasePointerCapture(e2.currentTarget, e2);
        mut.status = "idle";
      }, [editor, trackEvent]);
      const handleKeyDown = (0, import_react98.useCallback)((e2) => {
        const mut = rMutables.current;
        if (e2.key === "Escape") {
          if (mut.status === "dragging") {
            setSortablePositionItems(Object.fromEntries(pages.map((page, i2) => [
              page.id,
              { y: i2 * ITEM_HEIGHT, offsetY: 0, isSelected: false }
            ])));
          }
          mut.status = "idle";
        }
      }, [ITEM_HEIGHT, pages]);
      const handleCreatePageClick = (0, import_react98.useCallback)(() => {
        if (isReadonlyMode)
          return;
        editor.run(() => {
          editor.mark("creating page");
          const newPageId = PageRecordType.createId();
          editor.createPage({ name: msg2("page-menu.new-page-initial-name"), id: newPageId });
          editor.setCurrentPage(newPageId);
          setIsEditing(true);
        });
        trackEvent("new-page", { source: "page-menu" });
      }, [editor, msg2, isReadonlyMode, trackEvent]);
      const changePage = (0, import_react98.useCallback)((id) => {
        editor.setCurrentPage(id);
        trackEvent("change-page", { source: "page-menu" });
      }, [editor, trackEvent]);
      const renamePage = (0, import_react98.useCallback)((id, name) => {
        editor.renamePage(id, name);
        trackEvent("rename-page", { source: "page-menu" });
      }, [editor, trackEvent]);
      return /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(TldrawUiPopover, { id: "pages", onOpenChange, open: isOpen, children: [
        /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiPopoverTrigger, { "data-testid": "main.page-menu", children: /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(TldrawUiButton, {
          type: "menu",
          title: currentPage.name,
          "data-testid": "page-menu.button",
          className: "tlui-page-menu__trigger",
          children: [
            /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", { className: "tlui-page-menu__name", children: currentPage.name }),
            /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonIcon, { icon: "chevron-down", small: true })
          ]
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiPopoverContent, { side: "bottom", align: "start", sideOffset: 6, children: /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)("div", { className: "tlui-page-menu__wrapper", children: [
          /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)("div", { className: "tlui-page-menu__header", children: [
            /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", { className: "tlui-page-menu__header__title", children: msg2("page-menu.title") }),
            !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)("div", { className: "tlui-buttons__horizontal", children: [
              /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButton, {
                type: "icon",
                "data-testid": "page-menu.edit",
                title: msg2(isEditing ? "page-menu.edit-done" : "page-menu.edit-start"),
                onClick: toggleEditing,
                children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonIcon, { icon: isEditing ? "check" : "edit" })
              }),
              /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButton, {
                type: "icon",
                "data-testid": "page-menu.create",
                title: msg2(maxPageCountReached ? "page-menu.max-page-count-reached" : "page-menu.create-new-page"),
                disabled: maxPageCountReached,
                onClick: handleCreatePageClick,
                children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonIcon, { icon: "plus" })
              })
            ] })
          ] }),
          /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", {
            "data-testid": "page-menu.list",
            className: "tlui-page-menu__list tlui-menu__group",
            style: { height: ITEM_HEIGHT * pages.length + 4 },
            ref: rSortableContainer,
            children: pages.map((page, index3) => {
              const position = sortablePositionItems[page.id] ?? {
                position: index3 * 40,
                offsetY: 0
              };
              return isEditing ? /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)("div", {
                "data-testid": "page-menu.item",
                className: "tlui-page_menu__item__sortable",
                style: {
                  zIndex: page.id === currentPage.id ? 888 : index3,
                  transform: `translate(0px, ${position.y + position.offsetY}px)`
                },
                children: [
                  /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButton, {
                    type: "icon",
                    tabIndex: -1,
                    className: "tlui-page_menu__item__sortable__handle",
                    onPointerDown: handlePointerDown,
                    onPointerUp: handlePointerUp,
                    onPointerMove: handlePointerMove,
                    onKeyDown: handleKeyDown,
                    "data-id": page.id,
                    "data-index": index3,
                    children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonIcon, { icon: "drag-handle-dots" })
                  }),
                  breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM && isCoarsePointer ? /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(TldrawUiButton, {
                    type: "normal",
                    className: "tlui-page-menu__item__button",
                    onClick: () => {
                      const name = window.prompt("Rename page", page.name);
                      if (name && name !== page.name) {
                        renamePage(page.id, name);
                      }
                    },
                    onDoubleClick: toggleEditing,
                    children: [
                      /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonCheck, { checked: page.id === currentPage.id }),
                      /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonLabel, { children: page.name })
                    ]
                  }) : /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", {
                    className: "tlui-page_menu__item__sortable__title",
                    style: { height: ITEM_HEIGHT },
                    children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(PageItemInput, {
                      id: page.id,
                      name: page.name,
                      isCurrentPage: page.id === currentPage.id
                    })
                  }),
                  !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", { className: "tlui-page_menu__item__submenu", "data-isediting": isEditing, children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(PageItemSubmenu, { index: index3, item: page, listSize: pages.length }) })
                ]
              }, page.id + "_editing") : /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)("div", { "data-testid": "page-menu.item", className: "tlui-page-menu__item", children: [
                /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(TldrawUiButton, {
                  type: "normal",
                  className: "tlui-page-menu__item__button",
                  onClick: () => changePage(page.id),
                  onDoubleClick: toggleEditing,
                  title: msg2("page-menu.go-to-page"),
                  children: [
                    /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonCheck, { checked: page.id === currentPage.id }),
                    /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(TldrawUiButtonLabel, { children: page.name })
                  ]
                }),
                !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime137.jsx)("div", { className: "tlui-page_menu__item__submenu", children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(PageItemSubmenu, {
                  index: index3,
                  item: page,
                  listSize: pages.length,
                  onRename: () => {
                    if (editor.environment.isIos) {
                      const name = window.prompt("Rename page", page.name);
                      if (name && name !== page.name) {
                        renamePage(page.id, name);
                      }
                    } else {
                      setIsEditing(true);
                      if (currentPageId !== page.id) {
                        changePage(page.id);
                      }
                    }
                  }
                }) })
              ] }, page.id);
            })
          })
        ] }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/QuickActions/DefaultQuickActionsContent.mjs
function DefaultQuickActionsContent() {
  const actions = useActions();
  const editor = useEditor();
  const canUndo = useCanUndo();
  const canRedo = useCanRedo();
  const oneSelected = useUnlockedSelectedShapesCount(1);
  const isReadonlyMode = useReadonly();
  const isInAcceptableReadonlyState = useValue("should display quick actions", () => editor.isInAny("select", "hand", "zoom"), [editor]);
  const isInSelectState = useIsInSelectState();
  const selectDependentActionsEnabled = oneSelected && isInSelectState;
  if (isReadonlyMode && !isInAcceptableReadonlyState)
    return;
  return /* @__PURE__ */ (0, import_jsx_runtime138.jsxs)(import_jsx_runtime138.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime138.jsx)(TldrawUiMenuItem, { ...actions["undo"], disabled: !canUndo }),
    /* @__PURE__ */ (0, import_jsx_runtime138.jsx)(TldrawUiMenuItem, { ...actions["redo"], disabled: !canRedo }),
    /* @__PURE__ */ (0, import_jsx_runtime138.jsx)(TldrawUiMenuItem, { ...actions["delete"], disabled: !selectDependentActionsEnabled }),
    /* @__PURE__ */ (0, import_jsx_runtime138.jsx)(TldrawUiMenuItem, { ...actions["duplicate"], disabled: !selectDependentActionsEnabled })
  ] });
}
var import_jsx_runtime138;
var init_DefaultQuickActionsContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/QuickActions/DefaultQuickActionsContent.mjs"() {
    import_jsx_runtime138 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_actions();
    init_menu_hooks();
    init_useReadonly();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/QuickActions/DefaultQuickActions.mjs
var import_jsx_runtime139, import_react99, DefaultQuickActions;
var init_DefaultQuickActions = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/QuickActions/DefaultQuickActions.mjs"() {
    import_jsx_runtime139 = __toESM(require_jsx_runtime(), 1);
    import_react99 = __toESM(require_react(), 1);
    init_TldrawUiMenuContext();
    init_DefaultQuickActionsContent();
    DefaultQuickActions = (0, import_react99.memo)(function DefaultQuickActions2({
      children
    }) {
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(DefaultQuickActionsContent, {});
      return /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(TldrawUiMenuContextProvider, { type: "small-icons", sourceId: "quick-actions", children: content });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuAvatar.mjs
function PeopleMenuAvatar({ userId }) {
  const presence = usePresence(userId);
  if (!presence)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime140.jsx)("div", {
    className: "tlui-people-menu__avatar",
    style: {
      backgroundColor: presence.color
    },
    children: presence.userName === "New User" ? "" : presence.userName[0] ?? ""
  }, userId);
}
var import_jsx_runtime140;
var init_PeopleMenuAvatar = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuAvatar.mjs"() {
    import_jsx_runtime140 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuItem.mjs
var import_jsx_runtime141, import_react100, PeopleMenuItem;
var init_PeopleMenuItem = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuItem.mjs"() {
    import_jsx_runtime141 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react100 = __toESM(require_react(), 1);
    init_events();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiIcon();
    PeopleMenuItem = track(function PeopleMenuItem2({ userId }) {
      const editor = useEditor();
      const msg2 = useTranslation();
      const trackEvent = useUiEvents();
      const presence = usePresence(userId);
      const handleFollowClick = (0, import_react100.useCallback)(() => {
        if (editor.getInstanceState().followingUserId === userId) {
          editor.stopFollowingUser();
          trackEvent("stop-following", { source: "people-menu" });
        } else {
          editor.startFollowingUser(userId);
          trackEvent("start-following", { source: "people-menu" });
        }
      }, [editor, userId, trackEvent]);
      const theyAreFollowingYou = presence?.followingUserId === editor.user.getId();
      const youAreFollowingThem = editor.getInstanceState().followingUserId === userId;
      if (!presence)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime141.jsxs)("div", { className: "tlui-people-menu__item tlui-buttons__horizontal", children: [
        /* @__PURE__ */ (0, import_jsx_runtime141.jsxs)(TldrawUiButton, {
          type: "menu",
          className: "tlui-people-menu__item__button",
          onClick: () => editor.zoomToUser(userId),
          onDoubleClick: handleFollowClick,
          children: [
            /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(TldrawUiIcon, { icon: "color", color: presence.color }),
            /* @__PURE__ */ (0, import_jsx_runtime141.jsx)("div", { className: "tlui-people-menu__name", children: presence.userName ?? "New User" })
          ]
        }),
        /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(TldrawUiButton, {
          type: "icon",
          className: "tlui-people-menu__item__follow",
          title: theyAreFollowingYou ? msg2("people-menu.leading") : youAreFollowingThem ? msg2("people-menu.following") : msg2("people-menu.follow"),
          onClick: handleFollowClick,
          disabled: theyAreFollowingYou,
          "data-active": youAreFollowingThem || theyAreFollowingYou,
          children: /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(TldrawUiButtonIcon, {
            icon: theyAreFollowingYou ? "leading" : youAreFollowingThem ? "following" : "follow"
          })
        })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuMore.mjs
function PeopleMenuMore({ count: count3 }) {
  return /* @__PURE__ */ (0, import_jsx_runtime142.jsx)("div", { className: "tlui-people-menu__more", children: "+" + Math.abs(count3) });
}
var import_jsx_runtime142;
var init_PeopleMenuMore = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenuMore.mjs"() {
    import_jsx_runtime142 = __toESM(require_jsx_runtime(), 1);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/UserPresenceColorPicker.mjs
var import_jsx_runtime143, import_react101, UserPresenceColorPicker;
var init_UserPresenceColorPicker = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/UserPresenceColorPicker.mjs"() {
    import_jsx_runtime143 = __toESM(require_jsx_runtime(), 1);
    init_dist23();
    init_dist_esm10();
    import_react101 = __toESM(require_react(), 1);
    init_events();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    UserPresenceColorPicker = track(function UserPresenceColorPicker2() {
      const editor = useEditor();
      const container = useContainer();
      const msg2 = useTranslation();
      const trackEvent = useUiEvents();
      const rPointing = (0, import_react101.useRef)(false);
      const [isOpen, setIsOpen] = (0, import_react101.useState)(false);
      const handleOpenChange = (0, import_react101.useCallback)((isOpen2) => {
        setIsOpen(isOpen2);
      }, []);
      const value = editor.user.getColor();
      const onValueChange = (0, import_react101.useCallback)((item) => {
        editor.user.updateUserPreferences({ color: item });
        trackEvent("set-color", { source: "people-menu" });
      }, [editor, trackEvent]);
      const {
        handleButtonClick,
        handleButtonPointerDown,
        handleButtonPointerEnter,
        handleButtonPointerUp
      } = import_react101.default.useMemo(() => {
        const handlePointerUp = () => {
          rPointing.current = false;
          window.removeEventListener("pointerup", handlePointerUp);
        };
        const handleButtonClick2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          if (!id)
            return;
          if (value === id)
            return;
          onValueChange(id);
        };
        const handleButtonPointerDown2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          if (!id)
            return;
          onValueChange(id);
          rPointing.current = true;
          window.addEventListener("pointerup", handlePointerUp);
        };
        const handleButtonPointerEnter2 = (e2) => {
          if (!rPointing.current)
            return;
          const { id } = e2.currentTarget.dataset;
          if (!id)
            return;
          onValueChange(id);
        };
        const handleButtonPointerUp2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          if (!id)
            return;
          onValueChange(id);
        };
        return {
          handleButtonClick: handleButtonClick2,
          handleButtonPointerDown: handleButtonPointerDown2,
          handleButtonPointerEnter: handleButtonPointerEnter2,
          handleButtonPointerUp: handleButtonPointerUp2
        };
      }, [value, onValueChange]);
      return /* @__PURE__ */ (0, import_jsx_runtime143.jsxs)(Root24, { onOpenChange: handleOpenChange, open: isOpen, children: [
        /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(Trigger, { dir: "ltr", asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(TldrawUiButton, {
          type: "icon",
          className: "tlui-people-menu__user__color",
          style: { color: editor.user.getColor() },
          title: msg2("people-menu.change-color"),
          children: /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(TldrawUiButtonIcon, { icon: "color" })
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(Portal3, { container, children: /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(Content22, {
          dir: "ltr",
          className: "tlui-menu tlui-people-menu__user__color-picker",
          align: "start",
          side: "left",
          sideOffset: 8,
          children: /* @__PURE__ */ (0, import_jsx_runtime143.jsx)("div", { className: "tlui-buttons__grid", children: USER_COLORS.map((item) => /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(TldrawUiButton, {
            type: "icon",
            "data-id": item,
            "data-testid": item,
            "aria-label": item,
            "data-state": value === item ? "hinted" : void 0,
            title: item,
            className: "tlui-button-grid__button",
            style: { color: item },
            onPointerEnter: handleButtonPointerEnter,
            onPointerDown: handleButtonPointerDown,
            onPointerUp: handleButtonPointerUp,
            onClick: handleButtonClick,
            children: /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(TldrawUiButtonIcon, { icon: "color" })
          }, item)) })
        }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/UserPresenceEditor.mjs
function UserPresenceEditor() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  const userName = useValue("userName", () => editor.user.getName(), []);
  const msg2 = useTranslation();
  const rOriginalName = (0, import_react102.useRef)(userName);
  const rCurrentName = (0, import_react102.useRef)(userName);
  const [isEditingName, setIsEditingName] = (0, import_react102.useState)(false);
  const toggleEditingName = (0, import_react102.useCallback)(() => {
    setIsEditingName((s2) => !s2);
  }, []);
  const handleValueChange = (0, import_react102.useCallback)((value) => {
    rCurrentName.current = value;
    editor.user.updateUserPreferences({ name: value });
  }, [editor]);
  const handleBlur = (0, import_react102.useCallback)(() => {
    if (rOriginalName.current === rCurrentName.current)
      return;
    trackEvent("change-user-name", { source: "people-menu" });
    rOriginalName.current = rCurrentName.current;
  }, [trackEvent]);
  return /* @__PURE__ */ (0, import_jsx_runtime144.jsxs)("div", { className: "tlui-people-menu__user", children: [
    /* @__PURE__ */ (0, import_jsx_runtime144.jsx)(UserPresenceColorPicker, {}),
    isEditingName ? /* @__PURE__ */ (0, import_jsx_runtime144.jsx)(TldrawUiInput, {
      className: "tlui-people-menu__user__input",
      defaultValue: userName,
      onValueChange: handleValueChange,
      onComplete: toggleEditingName,
      onCancel: toggleEditingName,
      onBlur: handleBlur,
      shouldManuallyMaintainScrollPositionWhenFocused: true,
      autoFocus: true,
      autoSelect: true
    }) : /* @__PURE__ */ (0, import_jsx_runtime144.jsxs)(import_jsx_runtime144.Fragment, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime144.jsx)("div", {
        className: "tlui-people-menu__user__name",
        onDoubleClick: () => {
          if (!isEditingName)
            setIsEditingName(true);
        },
        children: userName
      }),
      userName === "New User" ? /* @__PURE__ */ (0, import_jsx_runtime144.jsx)("div", { className: "tlui-people-menu__user__label", children: msg2("people-menu.user") }) : null
    ] }),
    /* @__PURE__ */ (0, import_jsx_runtime144.jsx)(TldrawUiButton, {
      type: "icon",
      className: "tlui-people-menu__user__edit",
      "data-testid": "people-menu.change-name",
      title: msg2("people-menu.change-name"),
      onClick: toggleEditingName,
      children: /* @__PURE__ */ (0, import_jsx_runtime144.jsx)(TldrawUiButtonIcon, { icon: isEditingName ? "check" : "edit" })
    })
  ] });
}
var import_jsx_runtime144, import_react102;
var init_UserPresenceEditor = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/UserPresenceEditor.mjs"() {
    import_jsx_runtime144 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react102 = __toESM(require_react(), 1);
    init_events();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiInput();
    init_UserPresenceColorPicker();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenu.mjs
var import_jsx_runtime145, PeopleMenu;
var init_PeopleMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/PeopleMenu.mjs"() {
    import_jsx_runtime145 = __toESM(require_jsx_runtime(), 1);
    init_dist23();
    init_dist_esm10();
    init_useMenuIsOpen();
    init_useTranslation();
    init_PeopleMenuAvatar();
    init_PeopleMenuItem();
    init_PeopleMenuMore();
    init_UserPresenceEditor();
    PeopleMenu = track(function PeopleMenu2({ children }) {
      const msg2 = useTranslation();
      const container = useContainer();
      const editor = useEditor();
      const userIds = usePeerIds();
      const userColor = useValue("user", () => editor.user.getColor(), [editor]);
      const userName = useValue("user", () => editor.user.getName(), [editor]);
      const [isOpen, onOpenChange] = useMenuIsOpen("people menu");
      return /* @__PURE__ */ (0, import_jsx_runtime145.jsxs)(Root24, { onOpenChange, open: isOpen, children: [
        /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(Trigger, { dir: "ltr", asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime145.jsxs)("button", { className: "tlui-people-menu__avatars-button", title: msg2("people-menu.title"), children: [
          userIds.length > 5 && /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(PeopleMenuMore, { count: userIds.length - 5 }),
          /* @__PURE__ */ (0, import_jsx_runtime145.jsxs)("div", { className: "tlui-people-menu__avatars", children: [
            userIds.slice(-5).map((userId) => /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(PeopleMenuAvatar, { userId }, userId)),
            /* @__PURE__ */ (0, import_jsx_runtime145.jsx)("div", {
              className: "tlui-people-menu__avatar",
              style: {
                backgroundColor: userColor
              },
              children: userName === "New User" ? "" : userName[0] ?? ""
            })
          ] })
        ] }) }),
        /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(Portal3, { container, children: /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(Content22, {
          dir: "ltr",
          className: "tlui-menu",
          align: "end",
          side: "bottom",
          sideOffset: 2,
          alignOffset: -5,
          children: /* @__PURE__ */ (0, import_jsx_runtime145.jsxs)("div", { className: "tlui-people-menu__wrapper", children: [
            /* @__PURE__ */ (0, import_jsx_runtime145.jsx)("div", { className: "tlui-people-menu__section", children: /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(UserPresenceEditor, {}) }),
            userIds.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime145.jsx)("div", { className: "tlui-people-menu__section", children: userIds.map((userId) => {
              return /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(PeopleMenuItem, { userId }, userId + "_presence");
            }) }),
            children
          ] })
        }) })
      ] });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/DefaultSharePanel.mjs
function DefaultSharePanel() {
  return /* @__PURE__ */ (0, import_jsx_runtime146.jsx)("div", { className: "tlui-share-zone", draggable: false, children: /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(PeopleMenu, {}) });
}
var import_jsx_runtime146;
var init_DefaultSharePanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/SharePanel/DefaultSharePanel.mjs"() {
    import_jsx_runtime146 = __toESM(require_jsx_runtime(), 1);
    init_PeopleMenu();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useRelevantStyles.mjs
function useRelevantStyles(stylesToCheck = selectToolStyles) {
  const editor = useEditor();
  return useValue("getRelevantStyles", () => {
    const styles3 = new SharedStyleMap(editor.getSharedStyles());
    const isInShapeSpecificTool = !!editor.root.getCurrent()?.shapeType;
    const hasShapesSelected = editor.isIn("select") && editor.getSelectedShapeIds().length > 0;
    if (styles3.size === 0 && editor.isIn("select") && editor.getSelectedShapeIds().length === 0) {
      for (const style of stylesToCheck) {
        styles3.applyValue(style, editor.getStyleForNextShape(style));
      }
    }
    if (isInShapeSpecificTool || hasShapesSelected || styles3.size > 0) {
      return styles3;
    }
    return null;
  }, [editor]);
}
var selectToolStyles;
var init_useRelevantStyles = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useRelevantStyles.mjs"() {
    init_dist_esm10();
    selectToolStyles = Object.freeze([
      DefaultColorStyle,
      DefaultDashStyle,
      DefaultFillStyle,
      DefaultSizeStyle
    ]);
  }
});

// node_modules/tldraw/dist-esm/lib/styles.mjs
var STYLES;
var init_styles = __esm({
  "node_modules/tldraw/dist-esm/lib/styles.mjs"() {
    STYLES = {
      color: [
        { value: "black", icon: "color" },
        { value: "grey", icon: "color" },
        { value: "light-violet", icon: "color" },
        { value: "violet", icon: "color" },
        { value: "blue", icon: "color" },
        { value: "light-blue", icon: "color" },
        { value: "yellow", icon: "color" },
        { value: "orange", icon: "color" },
        { value: "green", icon: "color" },
        { value: "light-green", icon: "color" },
        { value: "light-red", icon: "color" },
        { value: "red", icon: "color" }
      ],
      fill: [
        { value: "none", icon: "fill-none" },
        { value: "semi", icon: "fill-semi" },
        { value: "solid", icon: "fill-solid" },
        { value: "pattern", icon: "fill-pattern" }
      ],
      dash: [
        { value: "draw", icon: "dash-draw" },
        { value: "dashed", icon: "dash-dashed" },
        { value: "dotted", icon: "dash-dotted" },
        { value: "solid", icon: "dash-solid" }
      ],
      size: [
        { value: "s", icon: "size-small" },
        { value: "m", icon: "size-medium" },
        { value: "l", icon: "size-large" },
        { value: "xl", icon: "size-extra-large" }
      ],
      font: [
        { value: "draw", icon: "font-draw" },
        { value: "sans", icon: "font-sans" },
        { value: "serif", icon: "font-serif" },
        { value: "mono", icon: "font-mono" }
      ],
      textAlign: [
        { value: "start", icon: "text-align-left" },
        { value: "middle", icon: "text-align-center" },
        { value: "end", icon: "text-align-right" }
      ],
      horizontalAlign: [
        { value: "start", icon: "horizontal-align-start" },
        { value: "middle", icon: "horizontal-align-middle" },
        { value: "end", icon: "horizontal-align-end" }
      ],
      verticalAlign: [
        { value: "start", icon: "vertical-align-start" },
        { value: "middle", icon: "vertical-align-middle" },
        { value: "end", icon: "vertical-align-end" }
      ],
      geo: [
        { value: "rectangle", icon: "geo-rectangle" },
        { value: "ellipse", icon: "geo-ellipse" },
        { value: "triangle", icon: "geo-triangle" },
        { value: "diamond", icon: "geo-diamond" },
        { value: "star", icon: "geo-star" },
        { value: "pentagon", icon: "geo-pentagon" },
        { value: "hexagon", icon: "geo-hexagon" },
        { value: "octagon", icon: "geo-octagon" },
        { value: "rhombus", icon: "geo-rhombus" },
        { value: "rhombus-2", icon: "geo-rhombus-2" },
        { value: "oval", icon: "geo-oval" },
        { value: "trapezoid", icon: "geo-trapezoid" },
        { value: "arrow-left", icon: "geo-arrow-left" },
        { value: "arrow-up", icon: "geo-arrow-up" },
        { value: "arrow-down", icon: "geo-arrow-down" },
        { value: "arrow-right", icon: "geo-arrow-right" },
        { value: "cloud", icon: "geo-cloud" },
        { value: "x-box", icon: "geo-x-box" },
        { value: "check-box", icon: "geo-check-box" },
        { value: "heart", icon: "geo-heart" }
      ],
      arrowheadStart: [
        { value: "none", icon: "arrowhead-none" },
        { value: "arrow", icon: "arrowhead-arrow" },
        { value: "triangle", icon: "arrowhead-triangle" },
        { value: "square", icon: "arrowhead-square" },
        { value: "dot", icon: "arrowhead-dot" },
        { value: "diamond", icon: "arrowhead-diamond" },
        { value: "inverted", icon: "arrowhead-triangle-inverted" },
        { value: "bar", icon: "arrowhead-bar" }
      ],
      arrowheadEnd: [
        { value: "none", icon: "arrowhead-none" },
        { value: "arrow", icon: "arrowhead-arrow" },
        { value: "triangle", icon: "arrowhead-triangle" },
        { value: "square", icon: "arrowhead-square" },
        { value: "dot", icon: "arrowhead-dot" },
        { value: "diamond", icon: "arrowhead-diamond" },
        { value: "inverted", icon: "arrowhead-triangle-inverted" },
        { value: "bar", icon: "arrowhead-bar" }
      ],
      spline: [
        { value: "line", icon: "spline-line" },
        { value: "cubic", icon: "spline-cubic" }
      ]
    };
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiButtonPicker.mjs
var import_jsx_runtime147, import_classnames24, import_react103, TldrawUiButtonPicker;
var init_TldrawUiButtonPicker = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiButtonPicker.mjs"() {
    import_jsx_runtime147 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames24 = __toESM(require_classnames(), 1);
    import_react103 = __toESM(require_react(), 1);
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    TldrawUiButtonPicker = (0, import_react103.memo)(function TldrawUiButtonPicker2(props) {
      const {
        uiType,
        items,
        title,
        style,
        value,
        onValueChange,
        theme
      } = props;
      const editor = useEditor();
      const msg2 = useTranslation();
      const rPointing = (0, import_react103.useRef)(false);
      const rPointingOriginalActiveElement = (0, import_react103.useRef)(null);
      const {
        handleButtonClick,
        handleButtonPointerDown,
        handleButtonPointerEnter,
        handleButtonPointerUp
      } = (0, import_react103.useMemo)(() => {
        const handlePointerUp = () => {
          rPointing.current = false;
          window.removeEventListener("pointerup", handlePointerUp);
          const origActiveEl = rPointingOriginalActiveElement.current;
          if (origActiveEl && ["TEXTAREA", "INPUT"].includes(origActiveEl.nodeName)) {
            origActiveEl.focus();
          }
          rPointingOriginalActiveElement.current = null;
        };
        const handleButtonClick2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          if (value.type === "shared" && value.value === id)
            return;
          editor.mark("point picker item");
          onValueChange(style, id);
        };
        const handleButtonPointerDown2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          editor.mark("point picker item");
          onValueChange(style, id);
          rPointing.current = true;
          rPointingOriginalActiveElement.current = document.activeElement;
          window.addEventListener("pointerup", handlePointerUp);
        };
        const handleButtonPointerEnter2 = (e2) => {
          if (!rPointing.current)
            return;
          const { id } = e2.currentTarget.dataset;
          onValueChange(style, id);
        };
        const handleButtonPointerUp2 = (e2) => {
          const { id } = e2.currentTarget.dataset;
          if (value.type === "shared" && value.value === id)
            return;
          onValueChange(style, id);
        };
        return {
          handleButtonClick: handleButtonClick2,
          handleButtonPointerDown: handleButtonPointerDown2,
          handleButtonPointerEnter: handleButtonPointerEnter2,
          handleButtonPointerUp: handleButtonPointerUp2
        };
      }, [value, editor, onValueChange, style]);
      return /* @__PURE__ */ (0, import_jsx_runtime147.jsx)("div", { "data-testid": `style.${uiType}`, className: (0, import_classnames24.default)("tlui-buttons__grid"), children: items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(TldrawUiButton, {
        type: "icon",
        "data-id": item.value,
        "data-testid": `style.${uiType}.${item.value}`,
        "aria-label": item.value,
        "data-state": value.type === "shared" && value.value === item.value ? "hinted" : void 0,
        title: title + " \u2014 " + msg2(`${uiType}-style.${item.value}`),
        className: (0, import_classnames24.default)("tlui-button-grid__button"),
        style: style === DefaultColorStyle ? { color: theme[item.value].solid } : void 0,
        onPointerEnter: handleButtonPointerEnter,
        onPointerDown: handleButtonPointerDown,
        onPointerUp: handleButtonPointerUp,
        onClick: handleButtonClick,
        children: /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(TldrawUiButtonIcon, { icon: item.icon })
      }, item.value)) });
    });
  }
});

// node_modules/@radix-ui/react-slider/node_modules/@radix-ui/number/dist/index.mjs
function clamp3(value, [min4, max3]) {
  return Math.min(max3, Math.max(min4, value));
}
var init_dist29 = __esm({
  "node_modules/@radix-ui/react-slider/node_modules/@radix-ui/number/dist/index.mjs"() {
  }
});

// node_modules/@radix-ui/react-slider/node_modules/@radix-ui/react-use-previous/dist/index.mjs
function usePrevious(value) {
  const ref = React65.useRef({ value, previous: value });
  return React65.useMemo(() => {
    if (ref.current.value !== value) {
      ref.current.previous = ref.current.value;
      ref.current.value = value;
    }
    return ref.current.previous;
  }, [value]);
}
var React65;
var init_dist30 = __esm({
  "node_modules/@radix-ui/react-slider/node_modules/@radix-ui/react-use-previous/dist/index.mjs"() {
    React65 = __toESM(require_react(), 1);
  }
});

// node_modules/@radix-ui/react-slider/dist/index.mjs
function getNextSortedValues(prevValues = [], nextValue, atIndex) {
  const nextValues = [...prevValues];
  nextValues[atIndex] = nextValue;
  return nextValues.sort((a2, b2) => a2 - b2);
}
function convertValueToPercentage(value, min4, max3) {
  const maxSteps = max3 - min4;
  const percentPerStep = 100 / maxSteps;
  const percentage = percentPerStep * (value - min4);
  return clamp3(percentage, [0, 100]);
}
function getLabel(index3, totalValues) {
  if (totalValues > 2) {
    return `Value ${index3 + 1} of ${totalValues}`;
  } else if (totalValues === 2) {
    return ["Minimum", "Maximum"][index3];
  } else {
    return void 0;
  }
}
function getClosestValueIndex(values, nextValue) {
  if (values.length === 1)
    return 0;
  const distances = values.map((value) => Math.abs(value - nextValue));
  const closestDistance = Math.min(...distances);
  return distances.indexOf(closestDistance);
}
function getThumbInBoundsOffset(width, left2, direction) {
  const halfWidth = width / 2;
  const halfPercent = 50;
  const offset5 = linearScale([0, halfPercent], [0, halfWidth]);
  return (halfWidth - offset5(left2) * direction) * direction;
}
function getStepsBetweenValues(values) {
  return values.slice(0, -1).map((value, index3) => values[index3 + 1] - value);
}
function hasMinStepsBetweenValues(values, minStepsBetweenValues) {
  if (minStepsBetweenValues > 0) {
    const stepsBetweenValues = getStepsBetweenValues(values);
    const actualMinStepsBetweenValues = Math.min(...stepsBetweenValues);
    return actualMinStepsBetweenValues >= minStepsBetweenValues;
  }
  return true;
}
function linearScale(input, output) {
  return (value) => {
    if (input[0] === input[1] || output[0] === output[1])
      return output[0];
    const ratio = (output[1] - output[0]) / (input[1] - input[0]);
    return output[0] + ratio * (value - input[0]);
  };
}
function getDecimalCount(value) {
  return (String(value).split(".")[1] || "").length;
}
function roundValue(value, decimalCount) {
  const rounder = Math.pow(10, decimalCount);
  return Math.round(value * rounder) / rounder;
}
var React66, import_jsx_runtime148, PAGE_KEYS, ARROW_KEYS, BACK_KEYS, SLIDER_NAME, Collection4, useCollection4, createCollectionScope4, createSliderContext, createSliderScope, SliderProvider, useSliderContext, Slider, SliderOrientationProvider, useSliderOrientationContext, SliderHorizontal, SliderVertical, SliderImpl, TRACK_NAME, SliderTrack, RANGE_NAME, SliderRange, THUMB_NAME, SliderThumb, SliderThumbImpl, BubbleInput, Root5, Track, Range2, Thumb;
var init_dist31 = __esm({
  "node_modules/@radix-ui/react-slider/dist/index.mjs"() {
    React66 = __toESM(require_react(), 1);
    init_dist29();
    init_dist();
    init_dist2();
    init_dist3();
    init_dist7();
    init_dist24();
    init_dist30();
    init_dist21();
    init_dist9();
    init_dist17();
    import_jsx_runtime148 = __toESM(require_jsx_runtime(), 1);
    "use client";
    PAGE_KEYS = ["PageUp", "PageDown"];
    ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
    BACK_KEYS = {
      "from-left": ["Home", "PageDown", "ArrowDown", "ArrowLeft"],
      "from-right": ["Home", "PageDown", "ArrowDown", "ArrowRight"],
      "from-bottom": ["Home", "PageDown", "ArrowDown", "ArrowLeft"],
      "from-top": ["Home", "PageDown", "ArrowUp", "ArrowLeft"]
    };
    SLIDER_NAME = "Slider";
    [Collection4, useCollection4, createCollectionScope4] = createCollection(SLIDER_NAME);
    [createSliderContext, createSliderScope] = createContextScope(SLIDER_NAME, [
      createCollectionScope4
    ]);
    [SliderProvider, useSliderContext] = createSliderContext(SLIDER_NAME);
    Slider = React66.forwardRef((props, forwardedRef) => {
      const {
        name,
        min: min4 = 0,
        max: max3 = 100,
        step = 1,
        orientation = "horizontal",
        disabled = false,
        minStepsBetweenThumbs = 0,
        defaultValue = [min4],
        value,
        onValueChange = () => {
        },
        onValueCommit = () => {
        },
        inverted = false,
        form,
        ...sliderProps
      } = props;
      const thumbRefs = React66.useRef(/* @__PURE__ */ new Set());
      const valueIndexToChangeRef = React66.useRef(0);
      const isHorizontal = orientation === "horizontal";
      const SliderOrientation = isHorizontal ? SliderHorizontal : SliderVertical;
      const [values = [], setValues] = useControllableState({
        prop: value,
        defaultProp: defaultValue,
        onChange: (value2) => {
          const thumbs = [...thumbRefs.current];
          thumbs[valueIndexToChangeRef.current]?.focus();
          onValueChange(value2);
        }
      });
      const valuesBeforeSlideStartRef = React66.useRef(values);
      function handleSlideStart(value2) {
        const closestIndex = getClosestValueIndex(values, value2);
        updateValues(value2, closestIndex);
      }
      function handleSlideMove(value2) {
        updateValues(value2, valueIndexToChangeRef.current);
      }
      function handleSlideEnd() {
        const prevValue = valuesBeforeSlideStartRef.current[valueIndexToChangeRef.current];
        const nextValue = values[valueIndexToChangeRef.current];
        const hasChanged = nextValue !== prevValue;
        if (hasChanged)
          onValueCommit(values);
      }
      function updateValues(value2, atIndex, { commit } = { commit: false }) {
        const decimalCount = getDecimalCount(step);
        const snapToStep = roundValue(Math.round((value2 - min4) / step) * step + min4, decimalCount);
        const nextValue = clamp3(snapToStep, [min4, max3]);
        setValues((prevValues = []) => {
          const nextValues = getNextSortedValues(prevValues, nextValue, atIndex);
          if (hasMinStepsBetweenValues(nextValues, minStepsBetweenThumbs * step)) {
            valueIndexToChangeRef.current = nextValues.indexOf(nextValue);
            const hasChanged = String(nextValues) !== String(prevValues);
            if (hasChanged && commit)
              onValueCommit(nextValues);
            return hasChanged ? nextValues : prevValues;
          } else {
            return prevValues;
          }
        });
      }
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderProvider, {
        scope: props.__scopeSlider,
        name,
        disabled,
        min: min4,
        max: max3,
        valueIndexToChangeRef,
        thumbs: thumbRefs.current,
        values,
        orientation,
        form,
        children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Collection4.Provider, { scope: props.__scopeSlider, children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Collection4.Slot, { scope: props.__scopeSlider, children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderOrientation, {
          "aria-disabled": disabled,
          "data-disabled": disabled ? "" : void 0,
          ...sliderProps,
          ref: forwardedRef,
          onPointerDown: composeEventHandlers(sliderProps.onPointerDown, () => {
            if (!disabled)
              valuesBeforeSlideStartRef.current = values;
          }),
          min: min4,
          max: max3,
          inverted,
          onSlideStart: disabled ? void 0 : handleSlideStart,
          onSlideMove: disabled ? void 0 : handleSlideMove,
          onSlideEnd: disabled ? void 0 : handleSlideEnd,
          onHomeKeyDown: () => !disabled && updateValues(min4, 0, { commit: true }),
          onEndKeyDown: () => !disabled && updateValues(max3, values.length - 1, { commit: true }),
          onStepKeyDown: ({ event, direction: stepDirection }) => {
            if (!disabled) {
              const isPageKey = PAGE_KEYS.includes(event.key);
              const isSkipKey = isPageKey || event.shiftKey && ARROW_KEYS.includes(event.key);
              const multiplier = isSkipKey ? 10 : 1;
              const atIndex = valueIndexToChangeRef.current;
              const value2 = values[atIndex];
              const stepInDirection = step * multiplier * stepDirection;
              updateValues(value2 + stepInDirection, atIndex, { commit: true });
            }
          }
        }) }) })
      });
    });
    Slider.displayName = SLIDER_NAME;
    [SliderOrientationProvider, useSliderOrientationContext] = createSliderContext(SLIDER_NAME, {
      startEdge: "left",
      endEdge: "right",
      size: "width",
      direction: 1
    });
    SliderHorizontal = React66.forwardRef((props, forwardedRef) => {
      const {
        min: min4,
        max: max3,
        dir,
        inverted,
        onSlideStart,
        onSlideMove,
        onSlideEnd,
        onStepKeyDown,
        ...sliderProps
      } = props;
      const [slider, setSlider] = React66.useState(null);
      const composedRefs = useComposedRefs(forwardedRef, (node) => setSlider(node));
      const rectRef = React66.useRef(void 0);
      const direction = useDirection(dir);
      const isDirectionLTR = direction === "ltr";
      const isSlidingFromLeft = isDirectionLTR && !inverted || !isDirectionLTR && inverted;
      function getValueFromPointer(pointerPosition) {
        const rect = rectRef.current || slider.getBoundingClientRect();
        const input = [0, rect.width];
        const output = isSlidingFromLeft ? [min4, max3] : [max3, min4];
        const value = linearScale(input, output);
        rectRef.current = rect;
        return value(pointerPosition - rect.left);
      }
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderOrientationProvider, {
        scope: props.__scopeSlider,
        startEdge: isSlidingFromLeft ? "left" : "right",
        endEdge: isSlidingFromLeft ? "right" : "left",
        direction: isSlidingFromLeft ? 1 : -1,
        size: "width",
        children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderImpl, {
          dir: direction,
          "data-orientation": "horizontal",
          ...sliderProps,
          ref: composedRefs,
          style: {
            ...sliderProps.style,
            ["--radix-slider-thumb-transform"]: "translateX(-50%)"
          },
          onSlideStart: (event) => {
            const value = getValueFromPointer(event.clientX);
            onSlideStart?.(value);
          },
          onSlideMove: (event) => {
            const value = getValueFromPointer(event.clientX);
            onSlideMove?.(value);
          },
          onSlideEnd: () => {
            rectRef.current = void 0;
            onSlideEnd?.();
          },
          onStepKeyDown: (event) => {
            const slideDirection = isSlidingFromLeft ? "from-left" : "from-right";
            const isBackKey = BACK_KEYS[slideDirection].includes(event.key);
            onStepKeyDown?.({ event, direction: isBackKey ? -1 : 1 });
          }
        })
      });
    });
    SliderVertical = React66.forwardRef((props, forwardedRef) => {
      const {
        min: min4,
        max: max3,
        inverted,
        onSlideStart,
        onSlideMove,
        onSlideEnd,
        onStepKeyDown,
        ...sliderProps
      } = props;
      const sliderRef = React66.useRef(null);
      const ref = useComposedRefs(forwardedRef, sliderRef);
      const rectRef = React66.useRef(void 0);
      const isSlidingFromBottom = !inverted;
      function getValueFromPointer(pointerPosition) {
        const rect = rectRef.current || sliderRef.current.getBoundingClientRect();
        const input = [0, rect.height];
        const output = isSlidingFromBottom ? [max3, min4] : [min4, max3];
        const value = linearScale(input, output);
        rectRef.current = rect;
        return value(pointerPosition - rect.top);
      }
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderOrientationProvider, {
        scope: props.__scopeSlider,
        startEdge: isSlidingFromBottom ? "bottom" : "top",
        endEdge: isSlidingFromBottom ? "top" : "bottom",
        size: "height",
        direction: isSlidingFromBottom ? 1 : -1,
        children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderImpl, {
          "data-orientation": "vertical",
          ...sliderProps,
          ref,
          style: {
            ...sliderProps.style,
            ["--radix-slider-thumb-transform"]: "translateY(50%)"
          },
          onSlideStart: (event) => {
            const value = getValueFromPointer(event.clientY);
            onSlideStart?.(value);
          },
          onSlideMove: (event) => {
            const value = getValueFromPointer(event.clientY);
            onSlideMove?.(value);
          },
          onSlideEnd: () => {
            rectRef.current = void 0;
            onSlideEnd?.();
          },
          onStepKeyDown: (event) => {
            const slideDirection = isSlidingFromBottom ? "from-bottom" : "from-top";
            const isBackKey = BACK_KEYS[slideDirection].includes(event.key);
            onStepKeyDown?.({ event, direction: isBackKey ? -1 : 1 });
          }
        })
      });
    });
    SliderImpl = React66.forwardRef((props, forwardedRef) => {
      const {
        __scopeSlider,
        onSlideStart,
        onSlideMove,
        onSlideEnd,
        onHomeKeyDown,
        onEndKeyDown,
        onStepKeyDown,
        ...sliderProps
      } = props;
      const context = useSliderContext(SLIDER_NAME, __scopeSlider);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Primitive.span, {
        ...sliderProps,
        ref: forwardedRef,
        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
          if (event.key === "Home") {
            onHomeKeyDown(event);
            event.preventDefault();
          } else if (event.key === "End") {
            onEndKeyDown(event);
            event.preventDefault();
          } else if (PAGE_KEYS.concat(ARROW_KEYS).includes(event.key)) {
            onStepKeyDown(event);
            event.preventDefault();
          }
        }),
        onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
          const target = event.target;
          target.setPointerCapture(event.pointerId);
          event.preventDefault();
          if (context.thumbs.has(target)) {
            target.focus();
          } else {
            onSlideStart(event);
          }
        }),
        onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
          const target = event.target;
          if (target.hasPointerCapture(event.pointerId))
            onSlideMove(event);
        }),
        onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {
          const target = event.target;
          if (target.hasPointerCapture(event.pointerId)) {
            target.releasePointerCapture(event.pointerId);
            onSlideEnd(event);
          }
        })
      });
    });
    TRACK_NAME = "SliderTrack";
    SliderTrack = React66.forwardRef((props, forwardedRef) => {
      const { __scopeSlider, ...trackProps } = props;
      const context = useSliderContext(TRACK_NAME, __scopeSlider);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Primitive.span, {
        "data-disabled": context.disabled ? "" : void 0,
        "data-orientation": context.orientation,
        ...trackProps,
        ref: forwardedRef
      });
    });
    SliderTrack.displayName = TRACK_NAME;
    RANGE_NAME = "SliderRange";
    SliderRange = React66.forwardRef((props, forwardedRef) => {
      const { __scopeSlider, ...rangeProps } = props;
      const context = useSliderContext(RANGE_NAME, __scopeSlider);
      const orientation = useSliderOrientationContext(RANGE_NAME, __scopeSlider);
      const ref = React66.useRef(null);
      const composedRefs = useComposedRefs(forwardedRef, ref);
      const valuesCount = context.values.length;
      const percentages = context.values.map((value) => convertValueToPercentage(value, context.min, context.max));
      const offsetStart = valuesCount > 1 ? Math.min(...percentages) : 0;
      const offsetEnd = 100 - Math.max(...percentages);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Primitive.span, {
        "data-orientation": context.orientation,
        "data-disabled": context.disabled ? "" : void 0,
        ...rangeProps,
        ref: composedRefs,
        style: {
          ...props.style,
          [orientation.startEdge]: offsetStart + "%",
          [orientation.endEdge]: offsetEnd + "%"
        }
      });
    });
    SliderRange.displayName = RANGE_NAME;
    THUMB_NAME = "SliderThumb";
    SliderThumb = React66.forwardRef((props, forwardedRef) => {
      const getItems = useCollection4(props.__scopeSlider);
      const [thumb, setThumb] = React66.useState(null);
      const composedRefs = useComposedRefs(forwardedRef, (node) => setThumb(node));
      const index3 = React66.useMemo(() => thumb ? getItems().findIndex((item) => item.ref.current === thumb) : -1, [getItems, thumb]);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(SliderThumbImpl, { ...props, ref: composedRefs, index: index3 });
    });
    SliderThumbImpl = React66.forwardRef((props, forwardedRef) => {
      const { __scopeSlider, index: index3, name, ...thumbProps } = props;
      const context = useSliderContext(THUMB_NAME, __scopeSlider);
      const orientation = useSliderOrientationContext(THUMB_NAME, __scopeSlider);
      const [thumb, setThumb] = React66.useState(null);
      const composedRefs = useComposedRefs(forwardedRef, (node) => setThumb(node));
      const isFormControl = thumb ? context.form || !!thumb.closest("form") : true;
      const size4 = useSize(thumb);
      const value = context.values[index3];
      const percent = value === void 0 ? 0 : convertValueToPercentage(value, context.min, context.max);
      const label = getLabel(index3, context.values.length);
      const orientationSize = size4?.[orientation.size];
      const thumbInBoundsOffset = orientationSize ? getThumbInBoundsOffset(orientationSize, percent, orientation.direction) : 0;
      React66.useEffect(() => {
        if (thumb) {
          context.thumbs.add(thumb);
          return () => {
            context.thumbs.delete(thumb);
          };
        }
      }, [thumb, context.thumbs]);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsxs)("span", {
        style: {
          transform: "var(--radix-slider-thumb-transform)",
          position: "absolute",
          [orientation.startEdge]: `calc(${percent}% + ${thumbInBoundsOffset}px)`
        },
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Collection4.ItemSlot, { scope: props.__scopeSlider, children: /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(Primitive.span, {
            role: "slider",
            "aria-label": props["aria-label"] || label,
            "aria-valuemin": context.min,
            "aria-valuenow": value,
            "aria-valuemax": context.max,
            "aria-orientation": context.orientation,
            "data-orientation": context.orientation,
            "data-disabled": context.disabled ? "" : void 0,
            tabIndex: context.disabled ? void 0 : 0,
            ...thumbProps,
            ref: composedRefs,
            style: value === void 0 ? { display: "none" } : props.style,
            onFocus: composeEventHandlers(props.onFocus, () => {
              context.valueIndexToChangeRef.current = index3;
            })
          }) }),
          isFormControl && /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(BubbleInput, {
            name: name ?? (context.name ? context.name + (context.values.length > 1 ? "[]" : "") : void 0),
            form: context.form,
            value
          }, index3)
        ]
      });
    });
    SliderThumb.displayName = THUMB_NAME;
    BubbleInput = (props) => {
      const { value, ...inputProps } = props;
      const ref = React66.useRef(null);
      const prevValue = usePrevious(value);
      React66.useEffect(() => {
        const input = ref.current;
        const inputProto = window.HTMLInputElement.prototype;
        const descriptor = Object.getOwnPropertyDescriptor(inputProto, "value");
        const setValue = descriptor.set;
        if (prevValue !== value && setValue) {
          const event = new Event("input", { bubbles: true });
          setValue.call(input, value);
          input.dispatchEvent(event);
        }
      }, [prevValue, value]);
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)("input", { style: { display: "none" }, ...inputProps, ref, defaultValue: value });
    };
    Root5 = Slider;
    Track = SliderTrack;
    Range2 = SliderRange;
    Thumb = SliderThumb;
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiSlider.mjs
var import_jsx_runtime149, import_react104, TldrawUiSlider;
var init_TldrawUiSlider = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/primitives/TldrawUiSlider.mjs"() {
    import_jsx_runtime149 = __toESM(require_jsx_runtime(), 1);
    init_dist31();
    init_dist_esm10();
    import_react104 = __toESM(require_react(), 1);
    init_useTranslation();
    TldrawUiSlider = (0, import_react104.memo)(function Slider2(props) {
      const { title, steps, value, label, onValueChange } = props;
      const editor = useEditor();
      const msg2 = useTranslation();
      const handleValueChange = (0, import_react104.useCallback)((value2) => {
        onValueChange(value2[0]);
      }, [onValueChange]);
      const handlePointerDown = (0, import_react104.useCallback)(() => {
        editor.mark("click slider");
      }, [editor]);
      const handlePointerUp = (0, import_react104.useCallback)(() => {
        if (!value)
          return;
        onValueChange(value);
      }, [value, onValueChange]);
      return /* @__PURE__ */ (0, import_jsx_runtime149.jsx)("div", { className: "tlui-slider__container", children: /* @__PURE__ */ (0, import_jsx_runtime149.jsxs)(Root5, {
        "data-testid": props["data-testid"],
        className: "tlui-slider",
        "area-label": "Opacity",
        dir: "ltr",
        min: 0,
        max: steps,
        step: 1,
        value: value ? [value] : void 0,
        onPointerDown: handlePointerDown,
        onValueChange: handleValueChange,
        onPointerUp: handlePointerUp,
        title: title + " \u2014 " + msg2(label),
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime149.jsx)(Track, { className: "tlui-slider__track", dir: "ltr", children: value !== null && /* @__PURE__ */ (0, import_jsx_runtime149.jsx)(Range2, { className: "tlui-slider__range", dir: "ltr" }) }),
          value !== null && /* @__PURE__ */ (0, import_jsx_runtime149.jsx)(Thumb, { className: "tlui-slider__thumb", dir: "ltr" })
        ]
      }) });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DoubleDropdownPicker.mjs
function _DoubleDropdownPicker({
  label,
  uiTypeA,
  uiTypeB,
  labelA,
  labelB,
  itemsA,
  itemsB,
  styleA,
  styleB,
  valueA,
  valueB,
  onValueChange
}) {
  const msg2 = useTranslation();
  const iconA = React67.useMemo(() => itemsA.find((item) => valueA.type === "shared" && valueA.value === item.value)?.icon ?? "mixed", [itemsA, valueA]);
  const iconB = React67.useMemo(() => itemsB.find((item) => valueB.type === "shared" && valueB.value === item.value)?.icon ?? "mixed", [itemsB, valueB]);
  if (valueA === void 0 && valueB === void 0)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)("div", { className: "tlui-style-panel__double-select-picker", children: [
    /* @__PURE__ */ (0, import_jsx_runtime150.jsx)("div", { title: msg2(label), className: "tlui-style-panel__double-select-picker-label", children: msg2(label) }),
    /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)("div", { className: "tlui-buttons__horizontal", children: [
      /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)(TldrawUiDropdownMenuRoot, { id: `style panel ${uiTypeA} A`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButton, {
          type: "icon",
          "data-testid": `style.${uiTypeA}`,
          title: msg2(labelA) + " \u2014 " + (valueA === null || valueA.type === "mixed" ? msg2("style-panel.mixed") : msg2(`${uiTypeA}-style.${valueA.value}`)),
          children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButtonIcon, { icon: iconA, small: true, invertIcon: true })
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuContent, { side: "left", align: "center", sideOffset: 80, alignOffset: 0, children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)("div", { className: "tlui-buttons__grid", children: itemsA.map((item, i2) => {
          return /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuItem, { "data-testid": `style.${uiTypeA}.${item.value}`, children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButton, {
            type: "icon",
            onClick: () => onValueChange(styleA, item.value),
            title: `${msg2(labelA)} \u2014 ${msg2(`${uiTypeA}-style.${item.value}`)}`,
            children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButtonIcon, { icon: item.icon, invertIcon: true })
          }, item.value) }, i2);
        }) }) })
      ] }),
      /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)(TldrawUiDropdownMenuRoot, { id: `style panel ${uiTypeB}`, children: [
        /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButton, {
          type: "icon",
          "data-testid": `style.${uiTypeB}`,
          title: msg2(labelB) + " \u2014 " + (valueB === null || valueB.type === "mixed" ? msg2("style-panel.mixed") : msg2(`${uiTypeB}-style.${valueB.value}`)),
          children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButtonIcon, { icon: iconB, small: true })
        }) }),
        /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuContent, { side: "left", align: "center", sideOffset: 116, alignOffset: 0, children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)("div", { className: "tlui-buttons__grid", children: itemsB.map((item) => {
          return /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiDropdownMenuItem, { children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButton, {
            type: "icon",
            title: `${msg2(labelB)} \u2014 ${msg2(`${uiTypeB}-style.${item.value}`)}`,
            "data-testid": `style.${uiTypeB}.${item.value}`,
            onClick: () => onValueChange(styleB, item.value),
            children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(TldrawUiButtonIcon, { icon: item.icon })
          }) }, item.value);
        }) }) })
      ] })
    ] })
  ] });
}
var import_jsx_runtime150, React67, DoubleDropdownPicker;
var init_DoubleDropdownPicker = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DoubleDropdownPicker.mjs"() {
    import_jsx_runtime150 = __toESM(require_jsx_runtime(), 1);
    React67 = __toESM(require_react(), 1);
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiDropdownMenu();
    DoubleDropdownPicker = React67.memo(_DoubleDropdownPicker);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DropdownPicker.mjs
function _DropdownPicker({
  id,
  label,
  uiType,
  style,
  items,
  type,
  value,
  onValueChange
}) {
  const msg2 = useTranslation();
  const editor = useEditor();
  const icon = React68.useMemo(() => items.find((item) => value.type === "shared" && item.value === value.value)?.icon, [items, value]);
  const titleStr = value.type === "mixed" ? msg2("style-panel.mixed") : msg2(`${uiType}-style.${value.value}`);
  const labelStr = label ? msg2(label) : "";
  return /* @__PURE__ */ (0, import_jsx_runtime151.jsxs)(TldrawUiDropdownMenuRoot, { id: `style panel ${id}`, children: [
    /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime151.jsxs)(TldrawUiButton, { type, "data-testid": `style.${uiType}`, title: titleStr, children: [
      /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiButtonLabel, { children: labelStr }),
      /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiButtonIcon, { icon: icon ?? "mixed" })
    ] }) }),
    /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiDropdownMenuContent, { side: "left", align: "center", alignOffset: 0, children: /* @__PURE__ */ (0, import_jsx_runtime151.jsx)("div", { className: "tlui-buttons__grid", children: items.map((item) => {
      return /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiDropdownMenuItem, { children: /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiButton, {
        type: "icon",
        "data-testid": `style.${uiType}.${item.value}`,
        title: msg2(`${uiType}-style.${item.value}`),
        onClick: () => {
          editor.mark("select style dropdown item");
          onValueChange(style, item.value);
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(TldrawUiButtonIcon, { icon: item.icon })
      }) }, item.value);
    }) }) })
  ] });
}
var import_jsx_runtime151, React68, DropdownPicker;
var init_DropdownPicker = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DropdownPicker.mjs"() {
    import_jsx_runtime151 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    React68 = __toESM(require_react(), 1);
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiDropdownMenu();
    DropdownPicker = React68.memo(_DropdownPicker);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DefaultStylePanelContent.mjs
function DefaultStylePanelContent({ styles: styles3 }) {
  const isDarkMode = useIsDarkMode();
  if (!styles3)
    return null;
  const geo = styles3.get(GeoShapeGeoStyle);
  const arrowheadEnd = styles3.get(ArrowShapeArrowheadEndStyle);
  const arrowheadStart = styles3.get(ArrowShapeArrowheadStartStyle);
  const spline = styles3.get(LineShapeSplineStyle);
  const font = styles3.get(DefaultFontStyle);
  const hideGeo = geo === void 0;
  const hideArrowHeads = arrowheadEnd === void 0 && arrowheadStart === void 0;
  const hideSpline = spline === void 0;
  const hideText = font === void 0;
  const theme = getDefaultColorTheme({ isDarkMode });
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)(import_jsx_runtime152.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(CommonStylePickerSet, { theme, styles: styles3 }),
    !hideText && /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TextStylePickerSet, { theme, styles: styles3 }),
    !(hideGeo && hideArrowHeads && hideSpline) && /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", { className: "tlui-style-panel__section", "aria-label": "style panel styles", children: [
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(GeoStylePickerSet, { styles: styles3 }),
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(ArrowheadStylePickerSet, { styles: styles3 }),
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(SplineStylePickerSet, { styles: styles3 })
    ] })
  ] });
}
function useStyleChangeCallback() {
  const editor = useEditor();
  const trackEvent = useUiEvents();
  return import_react105.default.useMemo(() => function handleStyleChange(style, value) {
    editor.run(() => {
      if (editor.isIn("select")) {
        editor.setStyleForSelectedShapes(style, value);
      }
      editor.setStyleForNextShapes(style, value);
      editor.updateInstanceState({ isChangingStyle: true });
    });
    trackEvent("set-style", { source: "style-panel", id: style.id, value });
  }, [editor, trackEvent]);
}
function CommonStylePickerSet({ styles: styles3, theme }) {
  const msg2 = useTranslation();
  const editor = useEditor();
  const handleValueChange = useStyleChangeCallback();
  const color = styles3.get(DefaultColorStyle);
  const fill = styles3.get(DefaultFillStyle);
  const dash = styles3.get(DefaultDashStyle);
  const size4 = styles3.get(DefaultSizeStyle);
  const showPickers = fill !== void 0 || dash !== void 0 || size4 !== void 0;
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)(import_jsx_runtime152.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", {
      tabIndex: -1,
      className: "tlui-style-panel__section__common",
      "aria-label": "style panel styles",
      "data-testid": "style.panel",
      children: [
        color === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
          title: msg2("style-panel.color"),
          uiType: "color",
          style: DefaultColorStyle,
          items: STYLES.color,
          value: color,
          onValueChange: handleValueChange,
          theme
        }),
        /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(OpacitySlider, {})
      ]
    }),
    showPickers && /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", { className: "tlui-style-panel__section", "aria-label": "style panel styles", children: [
      fill === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
        title: msg2("style-panel.fill"),
        uiType: "fill",
        style: DefaultFillStyle,
        items: STYLES.fill,
        value: fill,
        onValueChange: handleValueChange,
        theme
      }),
      dash === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
        title: msg2("style-panel.dash"),
        uiType: "dash",
        style: DefaultDashStyle,
        items: STYLES.dash,
        value: dash,
        onValueChange: handleValueChange,
        theme
      }),
      size4 === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
        title: msg2("style-panel.size"),
        uiType: "size",
        style: DefaultSizeStyle,
        items: STYLES.size,
        value: size4,
        onValueChange: (style, value) => {
          handleValueChange(style, value);
          const selectedShapeIds = editor.getSelectedShapeIds();
          if (selectedShapeIds.length > 0) {
            kickoutOccludedShapes(editor, selectedShapeIds);
          }
        },
        theme
      })
    ] })
  ] });
}
function TextStylePickerSet({ theme, styles: styles3 }) {
  const msg2 = useTranslation();
  const handleValueChange = useStyleChangeCallback();
  const font = styles3.get(DefaultFontStyle);
  const textAlign = styles3.get(DefaultTextAlignStyle);
  const labelAlign = styles3.get(DefaultHorizontalAlignStyle);
  const verticalLabelAlign = styles3.get(DefaultVerticalAlignStyle);
  if (font === void 0 && labelAlign === void 0) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", { className: "tlui-style-panel__section", "aria-label": "style panel text", children: [
    font === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
      title: msg2("style-panel.font"),
      uiType: "font",
      style: DefaultFontStyle,
      items: STYLES.font,
      value: font,
      onValueChange: handleValueChange,
      theme
    }),
    textAlign === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", { className: "tlui-style-panel__row", children: [
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
        title: msg2("style-panel.align"),
        uiType: "align",
        style: DefaultTextAlignStyle,
        items: STYLES.textAlign,
        value: textAlign,
        onValueChange: handleValueChange,
        theme
      }),
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)("div", { className: "tlui-style-panel__row__extra-button", children: /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButton, {
        type: "icon",
        title: msg2("style-panel.vertical-align"),
        "data-testid": "vertical-align",
        disabled: true,
        children: /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonIcon, { icon: "vertical-align-middle" })
      }) })
    ] }),
    labelAlign === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)("div", { className: "tlui-style-panel__row", children: [
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonPicker, {
        title: msg2("style-panel.align"),
        uiType: "align",
        style: DefaultHorizontalAlignStyle,
        items: STYLES.horizontalAlign,
        value: labelAlign,
        onValueChange: handleValueChange,
        theme
      }),
      /* @__PURE__ */ (0, import_jsx_runtime152.jsx)("div", { className: "tlui-style-panel__row__extra-button", children: verticalLabelAlign === void 0 ? /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButton, {
        type: "icon",
        title: msg2("style-panel.vertical-align"),
        "data-testid": "vertical-align",
        disabled: true,
        children: /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiButtonIcon, { icon: "vertical-align-middle" })
      }) : /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(DropdownPicker, {
        type: "icon",
        id: "geo-vertical-alignment",
        uiType: "verticalAlign",
        style: DefaultVerticalAlignStyle,
        items: STYLES.verticalAlign,
        value: verticalLabelAlign,
        onValueChange: handleValueChange
      }) })
    ] })
  ] });
}
function GeoStylePickerSet({ styles: styles3 }) {
  const handleValueChange = useStyleChangeCallback();
  const geo = styles3.get(GeoShapeGeoStyle);
  if (geo === void 0) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(DropdownPicker, {
    id: "geo",
    type: "menu",
    label: "style-panel.geo",
    uiType: "geo",
    style: GeoShapeGeoStyle,
    items: STYLES.geo,
    value: geo,
    onValueChange: handleValueChange
  });
}
function SplineStylePickerSet({ styles: styles3 }) {
  const handleValueChange = useStyleChangeCallback();
  const spline = styles3.get(LineShapeSplineStyle);
  if (spline === void 0) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(DropdownPicker, {
    id: "spline",
    type: "menu",
    label: "style-panel.spline",
    uiType: "spline",
    style: LineShapeSplineStyle,
    items: STYLES.spline,
    value: spline,
    onValueChange: handleValueChange
  });
}
function ArrowheadStylePickerSet({ styles: styles3 }) {
  const handleValueChange = useStyleChangeCallback();
  const arrowheadEnd = styles3.get(ArrowShapeArrowheadEndStyle);
  const arrowheadStart = styles3.get(ArrowShapeArrowheadStartStyle);
  if (!arrowheadEnd || !arrowheadStart) {
    return null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(DoubleDropdownPicker, {
    label: "style-panel.arrowheads",
    uiTypeA: "arrowheadStart",
    styleA: ArrowShapeArrowheadStartStyle,
    itemsA: STYLES.arrowheadStart,
    valueA: arrowheadStart,
    uiTypeB: "arrowheadEnd",
    styleB: ArrowShapeArrowheadEndStyle,
    itemsB: STYLES.arrowheadEnd,
    valueB: arrowheadEnd,
    onValueChange: handleValueChange,
    labelA: "style-panel.arrowhead-start",
    labelB: "style-panel.arrowhead-end"
  });
}
function OpacitySlider() {
  const editor = useEditor();
  const opacity = useValue("opacity", () => editor.getSharedOpacity(), [editor]);
  const trackEvent = useUiEvents();
  const msg2 = useTranslation();
  const handleOpacityValueChange = import_react105.default.useCallback((value) => {
    const item = tldrawSupportedOpacities[value];
    editor.run(() => {
      if (editor.isIn("select")) {
        editor.setOpacityForSelectedShapes(item);
      }
      editor.setOpacityForNextShapes(item);
      editor.updateInstanceState({ isChangingStyle: true });
    });
    trackEvent("set-style", { source: "style-panel", id: "opacity", value });
  }, [editor, trackEvent]);
  if (opacity === void 0)
    return null;
  const opacityIndex = opacity.type === "mixed" ? -1 : tldrawSupportedOpacities.indexOf(minBy(tldrawSupportedOpacities, (supportedOpacity) => Math.abs(supportedOpacity - opacity.value)));
  return /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(TldrawUiSlider, {
    "data-testid": "style.opacity",
    value: opacityIndex >= 0 ? opacityIndex : tldrawSupportedOpacities.length - 1,
    label: opacity.type === "mixed" ? "style-panel.mixed" : `opacity-style.${opacity.value}`,
    onValueChange: handleOpacityValueChange,
    steps: tldrawSupportedOpacities.length - 1,
    title: msg2("style-panel.opacity")
  });
}
var import_jsx_runtime152, import_react105, tldrawSupportedOpacities;
var init_DefaultStylePanelContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DefaultStylePanelContent.mjs"() {
    import_jsx_runtime152 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react105 = __toESM(require_react(), 1);
    init_styles();
    init_selectHelpers();
    init_events();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonPicker();
    init_TldrawUiSlider();
    init_DoubleDropdownPicker();
    init_DropdownPicker();
    tldrawSupportedOpacities = [0.1, 0.25, 0.5, 0.75, 1];
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DefaultStylePanel.mjs
var import_jsx_runtime153, import_classnames25, import_react106, DefaultStylePanel;
var init_DefaultStylePanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/StylePanel/DefaultStylePanel.mjs"() {
    import_jsx_runtime153 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames25 = __toESM(require_classnames(), 1);
    import_react106 = __toESM(require_react(), 1);
    init_useRelevantStyles();
    init_DefaultStylePanelContent();
    DefaultStylePanel = (0, import_react106.memo)(function DefaultStylePanel2({
      isMobile,
      children
    }) {
      const editor = useEditor();
      const styles3 = useRelevantStyles();
      const handlePointerOut = (0, import_react106.useCallback)(() => {
        if (!isMobile) {
          editor.updateInstanceState({ isChangingStyle: false });
        }
      }, [editor, isMobile]);
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(DefaultStylePanelContent, { styles: styles3 });
      return /* @__PURE__ */ (0, import_jsx_runtime153.jsx)("div", {
        className: (0, import_classnames25.default)("tlui-style-panel", { "tlui-style-panel__wrapper": !isMobile }),
        "data-ismobile": isMobile,
        onPointerLeave: handlePointerOut,
        children: content
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/MobileStylePanel.mjs
function MobileStylePanel() {
  const editor = useEditor();
  const msg2 = useTranslation();
  const relevantStyles = useRelevantStyles();
  const color = relevantStyles?.get(DefaultColorStyle);
  const theme = getDefaultColorTheme({ isDarkMode: editor.user.getIsDarkMode() });
  const currentColor = (color?.type === "shared" ? theme[color.value] : theme.black).solid;
  const disableStylePanel = useValue("disable style panel", () => editor.isInAny("hand", "zoom", "eraser", "laser"), [editor]);
  const handleStylesOpenChange = (0, import_react107.useCallback)((isOpen) => {
    if (!isOpen) {
      editor.updateInstanceState({ isChangingStyle: false });
    }
  }, [editor]);
  const { StylePanel } = useTldrawUiComponents();
  if (!StylePanel)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime154.jsxs)(TldrawUiPopover, { id: "mobile style menu", onOpenChange: handleStylesOpenChange, children: [
    /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(TldrawUiPopoverTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(TldrawUiButton, {
      type: "tool",
      "data-testid": "mobile-styles.button",
      style: {
        color: disableStylePanel ? "var(--color-muted-1)" : currentColor
      },
      title: msg2("style-panel.title"),
      disabled: disableStylePanel,
      children: /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(TldrawUiButtonIcon, {
        icon: disableStylePanel ? "blob" : color?.type === "mixed" ? "mixed" : "blob"
      })
    }) }),
    /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(TldrawUiPopoverContent, { side: "top", align: "end", children: StylePanel && /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(StylePanel, { isMobile: true }) })
  ] });
}
var import_jsx_runtime154, import_react107;
var init_MobileStylePanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/MobileStylePanel.mjs"() {
    import_jsx_runtime154 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react107 = __toESM(require_react(), 1);
    init_components();
    init_useRelevantStyles();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiPopover();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/DefaultToolbarContent.mjs
function DefaultToolbarContent() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsxs)(import_jsx_runtime155.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(SelectToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(HandToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(DrawToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(EraserToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ArrowToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(TextToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(NoteToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(AssetToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(RectangleToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(EllipseToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(TriangleToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(DiamondToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(HexagonToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(OvalToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(RhombusToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(StarToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(CloudToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(HeartToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(XBoxToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(CheckBoxToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ArrowLeftToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ArrowUpToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ArrowDownToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ArrowRightToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(LineToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(HighlightToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(LaserToolbarItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(FrameToolbarItem, {})
  ] });
}
function useIsToolSelected(tool) {
  const editor = useEditor();
  const geo = tool.meta?.geo;
  return useValue("is tool selected", () => {
    const activeToolId = editor.getCurrentToolId();
    const geoState = editor.getSharedStyles().getAsKnownValue(GeoShapeGeoStyle);
    return geo ? activeToolId === "geo" && geoState === geo : activeToolId === tool.id;
  }, [editor, tool.id, geo]);
}
function ToolbarItem({ tool }) {
  const tools = useTools();
  const isSelected = useIsToolSelected(tools[tool]);
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(TldrawUiMenuItem, { ...tools[tool], isSelected });
}
function SelectToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "select" });
}
function HandToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "hand" });
}
function DrawToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "draw" });
}
function EraserToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "eraser" });
}
function ArrowToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "arrow" });
}
function TextToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "text" });
}
function NoteToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "note" });
}
function AssetToolbarItem() {
  const tools = useTools();
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(TldrawUiMenuItem, { ...tools["asset"] });
}
function RectangleToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "rectangle" });
}
function EllipseToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "ellipse" });
}
function DiamondToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "diamond" });
}
function TriangleToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "triangle" });
}
function RhombusToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "rhombus" });
}
function HeartToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "heart" });
}
function HexagonToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "hexagon" });
}
function CloudToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "cloud" });
}
function StarToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "star" });
}
function OvalToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "oval" });
}
function XBoxToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "x-box" });
}
function CheckBoxToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "check-box" });
}
function ArrowLeftToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "arrow-left" });
}
function ArrowUpToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "arrow-up" });
}
function ArrowDownToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "arrow-down" });
}
function ArrowRightToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "arrow-right" });
}
function LineToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "line" });
}
function HighlightToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "highlight" });
}
function FrameToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "frame" });
}
function LaserToolbarItem() {
  return /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(ToolbarItem, { tool: "laser" });
}
var import_jsx_runtime155;
var init_DefaultToolbarContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/DefaultToolbarContent.mjs"() {
    import_jsx_runtime155 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    init_useTools();
    init_TldrawUiMenuItem();
  }
});

// node_modules/hotkeys-js/dist/hotkeys.esm.js
function addEvent(object2, event, method, useCapture) {
  if (object2.addEventListener) {
    object2.addEventListener(event, method, useCapture);
  } else if (object2.attachEvent) {
    object2.attachEvent("on".concat(event), method);
  }
}
function removeEvent(object2, event, method, useCapture) {
  if (object2.removeEventListener) {
    object2.removeEventListener(event, method, useCapture);
  } else if (object2.detachEvent) {
    object2.detachEvent("on".concat(event), method);
  }
}
function getMods(modifier, key) {
  const mods = key.slice(0, key.length - 1);
  for (let i2 = 0; i2 < mods.length; i2++)
    mods[i2] = modifier[mods[i2].toLowerCase()];
  return mods;
}
function getKeys(key) {
  if (typeof key !== "string")
    key = "";
  key = key.replace(/\s/g, "");
  const keys = key.split(",");
  let index3 = keys.lastIndexOf("");
  for (; index3 >= 0; ) {
    keys[index3 - 1] += ",";
    keys.splice(index3, 1);
    index3 = keys.lastIndexOf("");
  }
  return keys;
}
function compareArray(a1, a2) {
  const arr1 = a1.length >= a2.length ? a1 : a2;
  const arr2 = a1.length >= a2.length ? a2 : a1;
  let isIndex = true;
  for (let i2 = 0; i2 < arr1.length; i2++) {
    if (arr2.indexOf(arr1[i2]) === -1)
      isIndex = false;
  }
  return isIndex;
}
function setScope(scope) {
  _scope = scope || "all";
}
function getScope() {
  return _scope || "all";
}
function getPressedKeyCodes() {
  return _downKeys.slice(0);
}
function getPressedKeyString() {
  return _downKeys.map((c2) => getKey(c2) || getModifier(c2) || String.fromCharCode(c2));
}
function getAllKeyCodes() {
  const result = [];
  Object.keys(_handlers).forEach((k2) => {
    _handlers[k2].forEach((_ref) => {
      let {
        key,
        scope,
        mods,
        shortcut
      } = _ref;
      result.push({
        scope,
        shortcut,
        mods,
        keys: key.split("+").map((v2) => code(v2))
      });
    });
  });
  return result;
}
function filter(event) {
  const target = event.target || event.srcElement;
  const {
    tagName
  } = target;
  let flag = true;
  const isInput = tagName === "INPUT" && !["checkbox", "radio", "range", "button", "file", "reset", "submit", "color"].includes(target.type);
  if (target.isContentEditable || (isInput || tagName === "TEXTAREA" || tagName === "SELECT") && !target.readOnly) {
    flag = false;
  }
  return flag;
}
function isPressed(keyCode) {
  if (typeof keyCode === "string") {
    keyCode = code(keyCode);
  }
  return _downKeys.indexOf(keyCode) !== -1;
}
function deleteScope(scope, newScope) {
  let handlers;
  let i2;
  if (!scope)
    scope = getScope();
  for (const key in _handlers) {
    if (Object.prototype.hasOwnProperty.call(_handlers, key)) {
      handlers = _handlers[key];
      for (i2 = 0; i2 < handlers.length; ) {
        if (handlers[i2].scope === scope) {
          const deleteItems = handlers.splice(i2, 1);
          deleteItems.forEach((_ref2) => {
            let {
              element
            } = _ref2;
            return removeKeyEvent(element);
          });
        } else {
          i2++;
        }
      }
    }
  }
  if (getScope() === scope)
    setScope(newScope || "all");
}
function clearModifier(event) {
  let key = event.keyCode || event.which || event.charCode;
  const i2 = _downKeys.indexOf(key);
  if (i2 >= 0) {
    _downKeys.splice(i2, 1);
  }
  if (event.key && event.key.toLowerCase() === "meta") {
    _downKeys.splice(0, _downKeys.length);
  }
  if (key === 93 || key === 224)
    key = 91;
  if (key in _mods) {
    _mods[key] = false;
    for (const k2 in _modifier)
      if (_modifier[k2] === key)
        hotkeys[k2] = false;
  }
}
function unbind(keysInfo) {
  if (typeof keysInfo === "undefined") {
    Object.keys(_handlers).forEach((key) => {
      Array.isArray(_handlers[key]) && _handlers[key].forEach((info2) => eachUnbind(info2));
      delete _handlers[key];
    });
    removeKeyEvent(null);
  } else if (Array.isArray(keysInfo)) {
    keysInfo.forEach((info2) => {
      if (info2.key)
        eachUnbind(info2);
    });
  } else if (typeof keysInfo === "object") {
    if (keysInfo.key)
      eachUnbind(keysInfo);
  } else if (typeof keysInfo === "string") {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    let [scope, method] = args;
    if (typeof scope === "function") {
      method = scope;
      scope = "";
    }
    eachUnbind({
      key: keysInfo,
      scope,
      method,
      splitKey: "+"
    });
  }
}
function eventHandler(event, handler, scope, element) {
  if (handler.element !== element) {
    return;
  }
  let modifiersMatch;
  if (handler.scope === scope || handler.scope === "all") {
    modifiersMatch = handler.mods.length > 0;
    for (const y2 in _mods) {
      if (Object.prototype.hasOwnProperty.call(_mods, y2)) {
        if (!_mods[y2] && handler.mods.indexOf(+y2) > -1 || _mods[y2] && handler.mods.indexOf(+y2) === -1) {
          modifiersMatch = false;
        }
      }
    }
    if (handler.mods.length === 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91] || modifiersMatch || handler.shortcut === "*") {
      handler.keys = [];
      handler.keys = handler.keys.concat(_downKeys);
      if (handler.method(event, handler) === false) {
        if (event.preventDefault)
          event.preventDefault();
        else
          event.returnValue = false;
        if (event.stopPropagation)
          event.stopPropagation();
        if (event.cancelBubble)
          event.cancelBubble = true;
      }
    }
  }
}
function dispatch(event, element) {
  const asterisk = _handlers["*"];
  let key = event.keyCode || event.which || event.charCode;
  if (!hotkeys.filter.call(this, event))
    return;
  if (key === 93 || key === 224)
    key = 91;
  if (_downKeys.indexOf(key) === -1 && key !== 229)
    _downKeys.push(key);
  ["metaKey", "ctrlKey", "altKey", "shiftKey"].forEach((keyName) => {
    const keyNum = modifierMap[keyName];
    if (event[keyName] && _downKeys.indexOf(keyNum) === -1) {
      _downKeys.push(keyNum);
    } else if (!event[keyName] && _downKeys.indexOf(keyNum) > -1) {
      _downKeys.splice(_downKeys.indexOf(keyNum), 1);
    } else if (keyName === "metaKey" && event[keyName]) {
      _downKeys = _downKeys.filter((k2) => k2 in modifierMap || k2 === key);
    }
  });
  if (key in _mods) {
    _mods[key] = true;
    for (const k2 in _modifier) {
      if (_modifier[k2] === key)
        hotkeys[k2] = true;
    }
    if (!asterisk)
      return;
  }
  for (const e2 in _mods) {
    if (Object.prototype.hasOwnProperty.call(_mods, e2)) {
      _mods[e2] = event[modifierMap[e2]];
    }
  }
  if (event.getModifierState && !(event.altKey && !event.ctrlKey) && event.getModifierState("AltGraph")) {
    if (_downKeys.indexOf(17) === -1) {
      _downKeys.push(17);
    }
    if (_downKeys.indexOf(18) === -1) {
      _downKeys.push(18);
    }
    _mods[17] = true;
    _mods[18] = true;
  }
  const scope = getScope();
  if (asterisk) {
    for (let i2 = 0; i2 < asterisk.length; i2++) {
      if (asterisk[i2].scope === scope && (event.type === "keydown" && asterisk[i2].keydown || event.type === "keyup" && asterisk[i2].keyup)) {
        eventHandler(event, asterisk[i2], scope, element);
      }
    }
  }
  if (!(key in _handlers))
    return;
  const handlerKey = _handlers[key];
  const keyLen = handlerKey.length;
  for (let i2 = 0; i2 < keyLen; i2++) {
    if (event.type === "keydown" && handlerKey[i2].keydown || event.type === "keyup" && handlerKey[i2].keyup) {
      if (handlerKey[i2].key) {
        const record = handlerKey[i2];
        const {
          splitKey
        } = record;
        const keyShortcut = record.key.split(splitKey);
        const _downKeysCurrent = [];
        for (let a2 = 0; a2 < keyShortcut.length; a2++) {
          _downKeysCurrent.push(code(keyShortcut[a2]));
        }
        if (_downKeysCurrent.sort().join("") === _downKeys.sort().join("")) {
          eventHandler(event, record, scope, element);
        }
      }
    }
  }
}
function hotkeys(key, option, method) {
  _downKeys = [];
  const keys = getKeys(key);
  let mods = [];
  let scope = "all";
  let element = document;
  let i2 = 0;
  let keyup = false;
  let keydown = true;
  let splitKey = "+";
  let capture = false;
  let single = false;
  if (method === void 0 && typeof option === "function") {
    method = option;
  }
  if (Object.prototype.toString.call(option) === "[object Object]") {
    if (option.scope)
      scope = option.scope;
    if (option.element)
      element = option.element;
    if (option.keyup)
      keyup = option.keyup;
    if (option.keydown !== void 0)
      keydown = option.keydown;
    if (option.capture !== void 0)
      capture = option.capture;
    if (typeof option.splitKey === "string")
      splitKey = option.splitKey;
    if (option.single === true)
      single = true;
  }
  if (typeof option === "string")
    scope = option;
  if (single)
    unbind(key, scope);
  for (; i2 < keys.length; i2++) {
    key = keys[i2].split(splitKey);
    mods = [];
    if (key.length > 1)
      mods = getMods(_modifier, key);
    key = key[key.length - 1];
    key = key === "*" ? "*" : code(key);
    if (!(key in _handlers))
      _handlers[key] = [];
    _handlers[key].push({
      keyup,
      keydown,
      scope,
      mods,
      shortcut: keys[i2],
      method,
      key: keys[i2],
      splitKey,
      element
    });
  }
  if (typeof element !== "undefined" && window) {
    if (!elementEventMap.has(element)) {
      const keydownListener = function() {
        let event = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : window.event;
        return dispatch(event, element);
      };
      const keyupListenr = function() {
        let event = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : window.event;
        dispatch(event, element);
        clearModifier(event);
      };
      elementEventMap.set(element, {
        keydownListener,
        keyupListenr,
        capture
      });
      addEvent(element, "keydown", keydownListener, capture);
      addEvent(element, "keyup", keyupListenr, capture);
    }
    if (!winListendFocus) {
      const listener = () => {
        _downKeys = [];
      };
      winListendFocus = {
        listener,
        capture
      };
      addEvent(window, "focus", listener, capture);
    }
  }
}
function trigger(shortcut) {
  let scope = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "all";
  Object.keys(_handlers).forEach((key) => {
    const dataList = _handlers[key].filter((item) => item.scope === scope && item.shortcut === shortcut);
    dataList.forEach((data) => {
      if (data && data.method) {
        data.method();
      }
    });
  });
}
function removeKeyEvent(element) {
  const values = Object.values(_handlers).flat();
  const findindex = values.findIndex((_ref4) => {
    let {
      element: el
    } = _ref4;
    return el === element;
  });
  if (findindex < 0) {
    const {
      keydownListener,
      keyupListenr,
      capture
    } = elementEventMap.get(element) || {};
    if (keydownListener && keyupListenr) {
      removeEvent(element, "keyup", keyupListenr, capture);
      removeEvent(element, "keydown", keydownListener, capture);
      elementEventMap.delete(element);
    }
  }
  if (values.length <= 0 || elementEventMap.size <= 0) {
    const eventKeys = Object.keys(elementEventMap);
    eventKeys.forEach((el) => {
      const {
        keydownListener,
        keyupListenr,
        capture
      } = elementEventMap.get(el) || {};
      if (keydownListener && keyupListenr) {
        removeEvent(el, "keyup", keyupListenr, capture);
        removeEvent(el, "keydown", keydownListener, capture);
        elementEventMap.delete(el);
      }
    });
    elementEventMap.clear();
    Object.keys(_handlers).forEach((key) => delete _handlers[key]);
    if (winListendFocus) {
      const {
        listener,
        capture
      } = winListendFocus;
      removeEvent(window, "focus", listener, capture);
      winListendFocus = null;
    }
  }
}
var isff, _keyMap, _modifier, modifierMap, _mods, _handlers, _downKeys, winListendFocus, _scope, elementEventMap, code, getKey, getModifier, eachUnbind, _api;
var init_hotkeys_esm = __esm({
  "node_modules/hotkeys-js/dist/hotkeys.esm.js"() {
    isff = typeof navigator !== "undefined" ? navigator.userAgent.toLowerCase().indexOf("firefox") > 0 : false;
    _keyMap = {
      backspace: 8,
      "\u232B": 8,
      tab: 9,
      clear: 12,
      enter: 13,
      "\u21A9": 13,
      return: 13,
      esc: 27,
      escape: 27,
      space: 32,
      left: 37,
      up: 38,
      right: 39,
      down: 40,
      del: 46,
      delete: 46,
      ins: 45,
      insert: 45,
      home: 36,
      end: 35,
      pageup: 33,
      pagedown: 34,
      capslock: 20,
      num_0: 96,
      num_1: 97,
      num_2: 98,
      num_3: 99,
      num_4: 100,
      num_5: 101,
      num_6: 102,
      num_7: 103,
      num_8: 104,
      num_9: 105,
      num_multiply: 106,
      num_add: 107,
      num_enter: 108,
      num_subtract: 109,
      num_decimal: 110,
      num_divide: 111,
      "\u21EA": 20,
      ",": 188,
      ".": 190,
      "/": 191,
      "`": 192,
      "-": isff ? 173 : 189,
      "=": isff ? 61 : 187,
      ";": isff ? 59 : 186,
      "'": 222,
      "[": 219,
      "]": 221,
      "\\": 220
    };
    _modifier = {
      "\u21E7": 16,
      shift: 16,
      "\u2325": 18,
      alt: 18,
      option: 18,
      "\u2303": 17,
      ctrl: 17,
      control: 17,
      "\u2318": 91,
      cmd: 91,
      command: 91
    };
    modifierMap = {
      16: "shiftKey",
      18: "altKey",
      17: "ctrlKey",
      91: "metaKey",
      shiftKey: 16,
      ctrlKey: 17,
      altKey: 18,
      metaKey: 91
    };
    _mods = {
      16: false,
      18: false,
      17: false,
      91: false
    };
    _handlers = {};
    for (let k2 = 1; k2 < 20; k2++) {
      _keyMap["f".concat(k2)] = 111 + k2;
    }
    _downKeys = [];
    winListendFocus = null;
    _scope = "all";
    elementEventMap = /* @__PURE__ */ new Map();
    code = (x2) => _keyMap[x2.toLowerCase()] || _modifier[x2.toLowerCase()] || x2.toUpperCase().charCodeAt(0);
    getKey = (x2) => Object.keys(_keyMap).find((k2) => _keyMap[k2] === x2);
    getModifier = (x2) => Object.keys(_modifier).find((k2) => _modifier[k2] === x2);
    eachUnbind = (_ref3) => {
      let {
        key,
        scope,
        method,
        splitKey = "+"
      } = _ref3;
      const multipleKeys = getKeys(key);
      multipleKeys.forEach((originKey) => {
        const unbindKeys = originKey.split(splitKey);
        const len = unbindKeys.length;
        const lastKey = unbindKeys[len - 1];
        const keyCode = lastKey === "*" ? "*" : code(lastKey);
        if (!_handlers[keyCode])
          return;
        if (!scope)
          scope = getScope();
        const mods = len > 1 ? getMods(_modifier, unbindKeys) : [];
        const unbindElements = [];
        _handlers[keyCode] = _handlers[keyCode].filter((record) => {
          const isMatchingMethod = method ? record.method === method : true;
          const isUnbind = isMatchingMethod && record.scope === scope && compareArray(record.mods, mods);
          if (isUnbind)
            unbindElements.push(record.element);
          return !isUnbind;
        });
        unbindElements.forEach((element) => removeKeyEvent(element));
      });
    };
    _api = {
      getPressedKeyString,
      setScope,
      getScope,
      deleteScope,
      getPressedKeyCodes,
      getAllKeyCodes,
      isPressed,
      filter,
      trigger,
      unbind,
      keyMap: _keyMap,
      modifier: _modifier,
      modifierMap
    };
    for (const a2 in _api) {
      if (Object.prototype.hasOwnProperty.call(_api, a2)) {
        hotkeys[a2] = _api[a2];
      }
    }
    if (typeof window !== "undefined") {
      const _hotkeys = window.hotkeys;
      hotkeys.noConflict = (deep) => {
        if (deep && window.hotkeys === hotkeys) {
          window.hotkeys = _hotkeys;
        }
        return hotkeys;
      };
      window.hotkeys = hotkeys;
    }
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useKeyboardShortcuts.mjs
function useKeyboardShortcuts() {
  const editor = useEditor();
  const isReadonlyMode = useReadonly();
  const actions = useActions();
  const tools = useTools();
  const isFocused = useValue("is focused", () => editor.getInstanceState().isFocused, [editor]);
  (0, import_react108.useEffect)(() => {
    if (!isFocused)
      return;
    const disposables = new Array();
    const hot = (keys, callback) => {
      hotkeys(keys, { element: document.body }, callback);
      disposables.push(() => {
        hotkeys.unbind(keys, callback);
      });
    };
    const hotUp = (keys, callback) => {
      hotkeys(keys, { element: document.body, keyup: true, keydown: false }, callback);
      disposables.push(() => {
        hotkeys.unbind(keys, callback);
      });
    };
    for (const action of Object.values(actions)) {
      if (!action.kbd)
        continue;
      if (isReadonlyMode && !action.readonlyOk)
        continue;
      if (SKIP_KBDS.includes(action.id))
        continue;
      hot(getHotkeysStringFromKbd(action.kbd), (event) => {
        if (areShortcutsDisabled(editor))
          return;
        preventDefault(event);
        action.onSelect("kbd");
      });
    }
    for (const tool of Object.values(tools)) {
      if (!tool.kbd || !tool.readonlyOk && editor.getInstanceState().isReadonly) {
        continue;
      }
      if (SKIP_KBDS.includes(tool.id))
        continue;
      hot(getHotkeysStringFromKbd(tool.kbd), (event) => {
        if (areShortcutsDisabled(editor))
          return;
        preventDefault(event);
        tool.onSelect("kbd");
      });
    }
    hot(",", (e2) => {
      if (areShortcutsDisabled(editor))
        return;
      if (editor.inputs.keys.has("Comma"))
        return;
      preventDefault(e2);
      editor.focus();
      editor.inputs.keys.add("Comma");
      const { x: x2, y: y2, z } = editor.inputs.currentScreenPoint;
      const info2 = {
        type: "pointer",
        name: "pointer_down",
        point: { x: x2, y: y2, z },
        shiftKey: e2.shiftKey,
        altKey: e2.altKey,
        ctrlKey: e2.metaKey || e2.ctrlKey,
        pointerId: 0,
        button: 0,
        isPen: editor.getInstanceState().isPenMode,
        target: "canvas"
      };
      editor.dispatch(info2);
    });
    hotUp(",", (e2) => {
      if (areShortcutsDisabled(editor))
        return;
      if (!editor.inputs.keys.has("Comma"))
        return;
      editor.inputs.keys.delete("Comma");
      const { x: x2, y: y2, z } = editor.inputs.currentScreenPoint;
      const info2 = {
        type: "pointer",
        name: "pointer_up",
        point: { x: x2, y: y2, z },
        shiftKey: e2.shiftKey,
        altKey: e2.altKey,
        ctrlKey: e2.metaKey || e2.ctrlKey,
        pointerId: 0,
        button: 0,
        isPen: editor.getInstanceState().isPenMode,
        target: "canvas"
      };
      editor.dispatch(info2);
    });
    return () => {
      disposables.forEach((d2) => d2());
    };
  }, [actions, tools, isReadonlyMode, editor, isFocused]);
}
function getHotkeysStringFromKbd(kbd2) {
  return getKeys2(kbd2).map((kbd22) => {
    let str = "";
    const chars = kbd22.split("");
    if (chars.length === 1) {
      str = chars[0];
    } else {
      if (chars[0] === "!") {
        str = `shift+${chars[1]}`;
      } else if (chars[0] === "?") {
        if (chars.length === 3 && chars[1] === "!") {
          str = `alt+shift+${chars[2]}`;
        } else {
          str = `alt+${chars[1]}`;
        }
      } else if (chars[0] === "$") {
        if (chars[1] === "!") {
          str = `cmd+shift+${chars[2]},ctrl+shift+${chars[2]}`;
        } else if (chars[1] === "?") {
          str = `cmd+\u2325+${chars[2]},ctrl+alt+${chars[2]}`;
        } else {
          str = `cmd+${chars[1]},ctrl+${chars[1]}`;
        }
      } else {
        str = kbd22;
      }
    }
    return str;
  }).join(",");
}
function getKeys2(key) {
  if (typeof key !== "string")
    key = "";
  key = key.replace(/\s/g, "");
  const keys = key.split(",");
  let index3 = keys.lastIndexOf("");
  for (; index3 >= 0; ) {
    keys[index3 - 1] += ",";
    keys.splice(index3, 1);
    index3 = keys.lastIndexOf("");
  }
  return keys;
}
function areShortcutsDisabled(editor) {
  return editor.getIsMenuOpen() || editor.getEditingShapeId() !== null || editor.getCrashingError();
}
var import_react108, SKIP_KBDS;
var init_useKeyboardShortcuts = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useKeyboardShortcuts.mjs"() {
    init_dist_esm10();
    init_hotkeys_esm();
    import_react108 = __toESM(require_react(), 1);
    init_actions();
    init_useReadonly();
    init_useTools();
    SKIP_KBDS = [
      "copy",
      "cut",
      "paste",
      "asset"
    ];
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/OverflowingToolbar.mjs
function OverflowingToolbar({ children }) {
  const editor = useEditor();
  const id = useSafeId();
  const breakpoint = useBreakpoint();
  const msg2 = useTranslation();
  const overflowIndex = Math.min(8, 5 + breakpoint);
  const [totalItems, setTotalItems] = (0, import_react109.useState)(0);
  const mainToolsRef = (0, import_react109.useRef)(null);
  const [lastActiveOverflowItem, setLastActiveOverflowItem] = (0, import_react109.useState)(null);
  const css = (0, import_react109.useMemo)(() => {
    const activeCss = lastActiveOverflowItem ? `:not([data-value="${lastActiveOverflowItem}"])` : "";
    return `
			#${id}_main > *:nth-child(n + ${overflowIndex + (lastActiveOverflowItem ? 1 : 2)})${activeCss} {
				display: none;
			}
			#${id}_more > *:nth-child(-n + ${overflowIndex}) {
				display: none;
			}
        `;
  }, [lastActiveOverflowItem, id, overflowIndex]);
  const onDomUpdate = useEvent(() => {
    if (!mainToolsRef.current)
      return;
    const children2 = Array.from(mainToolsRef.current.children);
    setTotalItems(children2.length);
    const lastActiveElementIdx = children2.findIndex((el) => el.getAttribute("data-value") === lastActiveOverflowItem);
    if (lastActiveElementIdx <= overflowIndex) {
      setLastActiveOverflowItem(null);
    }
    const activeElementIdx = Array.from(mainToolsRef.current.children).findIndex((el) => el.getAttribute("aria-checked") === "true");
    if (activeElementIdx === -1)
      return;
    if (activeElementIdx >= overflowIndex) {
      setLastActiveOverflowItem(children2[activeElementIdx].getAttribute("data-value"));
    }
  });
  (0, import_react109.useLayoutEffect)(() => {
    onDomUpdate();
  });
  (0, import_react109.useLayoutEffect)(() => {
    if (!mainToolsRef.current)
      return;
    const mutationObserver = new MutationObserver(onDomUpdate);
    mutationObserver.observe(mainToolsRef.current, {
      childList: true,
      subtree: true,
      attributeFilter: ["data-value", "aria-checked"]
    });
    return () => {
      mutationObserver.disconnect();
    };
  }, [onDomUpdate]);
  (0, import_react109.useEffect)(() => {
    const keys = [
      ["1", 0],
      ["2", 1],
      ["3", 2],
      ["4", 3],
      ["5", 4],
      ["6", 5],
      ["7", 6],
      ["8", 7],
      ["9", 8],
      ["0", 9]
    ];
    for (const [key, index3] of keys) {
      hotkeys(key, (event) => {
        if (areShortcutsDisabled(editor))
          return;
        preventDefault(event);
        const relevantEls = Array.from(mainToolsRef.current?.children ?? []).filter((el2) => {
          if (!(el2 instanceof HTMLElement))
            return false;
          if (el2.tagName.toLowerCase() !== "button")
            return false;
          return !!(el2.offsetWidth || el2.offsetHeight);
        });
        const el = relevantEls[index3];
        if (el)
          el.click();
      });
    }
    return () => {
      hotkeys.unbind("1,2,3,4,5,6,7,8,9,0");
    };
  }, [editor]);
  return /* @__PURE__ */ (0, import_jsx_runtime156.jsxs)(import_jsx_runtime156.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime156.jsx)("style", { children: css }),
    /* @__PURE__ */ (0, import_jsx_runtime156.jsxs)("div", {
      className: (0, import_classnames26.default)("tlui-toolbar__tools", {
        "tlui-toolbar__tools__mobile": breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM
      }),
      role: "radiogroup",
      children: [
        /* @__PURE__ */ (0, import_jsx_runtime156.jsx)("div", { id: `${id}_main`, ref: mainToolsRef, className: "tlui-toolbar__tools__list", children: /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiMenuContextProvider, { type: "toolbar", sourceId: "toolbar", children }) }),
        totalItems > overflowIndex + 1 && /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(IsInOverflowContext.Provider, { value: true, children: /* @__PURE__ */ (0, import_jsx_runtime156.jsxs)(TldrawUiDropdownMenuRoot, { id: "toolbar overflow", modal: false, children: [
          /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiButton, {
            title: msg2("tool-panel.more"),
            type: "tool",
            className: "tlui-toolbar__overflow",
            "data-testid": "tools.more-button",
            children: /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiButtonIcon, { icon: "chevron-up" })
          }) }),
          /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiDropdownMenuContent, { side: "top", align: "center", children: /* @__PURE__ */ (0, import_jsx_runtime156.jsx)("div", {
            className: "tlui-buttons__grid",
            "data-testid": "tools.more-content",
            id: `${id}_more`,
            children: /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(TldrawUiMenuContextProvider, { type: "toolbar-overflow", sourceId: "toolbar", children })
          }) })
        ] }) })
      ]
    })
  ] });
}
var import_jsx_runtime156, import_classnames26, import_react109, IsInOverflowContext;
var init_OverflowingToolbar = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/OverflowingToolbar.mjs"() {
    import_jsx_runtime156 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames26 = __toESM(require_classnames(), 1);
    init_hotkeys_esm();
    import_react109 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_useKeyboardShortcuts();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
    IsInOverflowContext = (0, import_react109.createContext)(false);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/ToggleToolLockedButton.mjs
function ToggleToolLockedButton({ activeToolId }) {
  const editor = useEditor();
  const breakpoint = useBreakpoint();
  const msg2 = useTranslation();
  const isToolLocked = useValue("is tool locked", () => editor.getInstanceState().isToolLocked, [
    editor
  ]);
  const tool = useValue("current tool", () => editor.getCurrentTool(), [editor]);
  if (!activeToolId || !tool.isLockable)
    return null;
  return /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(TldrawUiButton, {
    type: "normal",
    title: msg2("action.toggle-tool-lock"),
    "data-testid": "tool-lock",
    className: (0, import_classnames27.default)("tlui-toolbar__lock-button", {
      "tlui-toolbar__lock-button__mobile": breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM
    }),
    onClick: () => editor.updateInstanceState({ isToolLocked: !isToolLocked }),
    children: /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(TldrawUiButtonIcon, { icon: isToolLocked ? "lock" : "unlock", small: true })
  });
}
var import_jsx_runtime157, import_classnames27;
var init_ToggleToolLockedButton = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/ToggleToolLockedButton.mjs"() {
    import_jsx_runtime157 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames27 = __toESM(require_classnames(), 1);
    init_constants5();
    init_breakpoints();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/DefaultToolbar.mjs
var import_jsx_runtime158, import_react110, DefaultToolbar;
var init_DefaultToolbar = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/Toolbar/DefaultToolbar.mjs"() {
    import_jsx_runtime158 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react110 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_components();
    init_useReadonly();
    init_MobileStylePanel();
    init_DefaultToolbarContent();
    init_OverflowingToolbar();
    init_ToggleToolLockedButton();
    DefaultToolbar = (0, import_react110.memo)(function DefaultToolbar2({ children }) {
      const editor = useEditor();
      const breakpoint = useBreakpoint();
      const isReadonlyMode = useReadonly();
      const activeToolId = useValue("current tool id", () => editor.getCurrentToolId(), [editor]);
      const { ActionsMenu, QuickActions } = useTldrawUiComponents();
      return /* @__PURE__ */ (0, import_jsx_runtime158.jsx)("div", { className: "tlui-toolbar", children: /* @__PURE__ */ (0, import_jsx_runtime158.jsxs)("div", { className: "tlui-toolbar__inner", children: [
        /* @__PURE__ */ (0, import_jsx_runtime158.jsxs)("div", { className: "tlui-toolbar__left", children: [
          !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime158.jsxs)("div", { className: "tlui-toolbar__extras", children: [
            breakpoint < PORTRAIT_BREAKPOINT.TABLET && /* @__PURE__ */ (0, import_jsx_runtime158.jsxs)("div", { className: "tlui-toolbar__extras__controls tlui-buttons__horizontal", children: [
              QuickActions && /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(QuickActions, {}),
              ActionsMenu && /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(ActionsMenu, {})
            ] }),
            /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(ToggleToolLockedButton, { activeToolId })
          ] }),
          /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(OverflowingToolbar, { children: children ?? /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(DefaultToolbarContent, {}) })
        ] }),
        breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM && !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime158.jsx)("div", { className: "tlui-toolbar__tools", children: /* @__PURE__ */ (0, import_jsx_runtime158.jsx)(MobileStylePanel, {}) })
      ] }) });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/OfflineIndicator/OfflineIndicator.mjs
function OfflineIndicator() {
  const msg2 = useTranslation();
  return /* @__PURE__ */ (0, import_jsx_runtime159.jsxs)("div", { className: (0, import_classnames28.default)("tlui-offline-indicator"), children: [
    msg2("status.offline"),
    /* @__PURE__ */ (0, import_jsx_runtime159.jsx)(TldrawUiIcon, { "aria-label": "offline", icon: "status-offline", small: true })
  ] });
}
var import_jsx_runtime159, import_classnames28;
var init_OfflineIndicator = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/OfflineIndicator/OfflineIndicator.mjs"() {
    import_jsx_runtime159 = __toESM(require_jsx_runtime(), 1);
    import_classnames28 = __toESM(require_classnames(), 1);
    init_useTranslation();
    init_TldrawUiIcon();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/TopPanel/CenteredTopPanelContainer.mjs
function CenteredTopPanelContainer({
  maxWidth: maxWidth2 = 420,
  ignoreRightWidth = 0,
  stylePanelWidth = 148,
  marginBetweenZones = 12,
  squeezeAmount = 52,
  children
}) {
  const ref = (0, import_react111.useRef)(null);
  const breakpoint = useBreakpoint();
  const updateLayout = (0, import_react111.useCallback)(() => {
    const element = ref.current;
    if (!element)
      return;
    const layoutTop = element.parentElement.parentElement;
    const leftPanel = layoutTop.querySelector(".tlui-layout__top__left");
    const rightPanel = layoutTop.querySelector(".tlui-layout__top__right");
    const totalWidth = layoutTop.offsetWidth;
    const leftWidth = leftPanel.offsetWidth;
    const rightWidth = rightPanel.offsetWidth;
    const selfWidth = element.offsetWidth - ignoreRightWidth;
    let xCoordIfCentered = (totalWidth - selfWidth) / 2;
    if (totalWidth % 2 !== 0) {
      xCoordIfCentered -= 0.5;
    }
    const xCoordIfLeftAligned = leftWidth + marginBetweenZones;
    const left2 = element.offsetLeft;
    const maxWidthProperty = Math.min(totalWidth - rightWidth - leftWidth - 2 * marginBetweenZones, maxWidth2);
    const xCoord = Math.max(xCoordIfCentered, xCoordIfLeftAligned) - left2;
    if (rightPanel.offsetWidth > stylePanelWidth && breakpoint <= 6) {
      element.style.setProperty("max-width", maxWidthProperty - squeezeAmount + "px");
    } else {
      element.style.setProperty("max-width", maxWidthProperty + "px");
    }
    element.style.setProperty("transform", `translate(${xCoord}px, 0px)`);
  }, [breakpoint, ignoreRightWidth, marginBetweenZones, maxWidth2, squeezeAmount, stylePanelWidth]);
  (0, import_react111.useLayoutEffect)(() => {
    const element = ref.current;
    if (!element)
      return;
    const layoutTop = element.parentElement.parentElement;
    const leftPanel = layoutTop.querySelector(".tlui-layout__top__left");
    const rightPanel = layoutTop.querySelector(".tlui-layout__top__right");
    const observer = new ResizeObserver(updateLayout);
    observer.observe(leftPanel);
    observer.observe(rightPanel);
    observer.observe(layoutTop);
    observer.observe(element);
    updateLayout();
    return () => {
      observer.disconnect();
    };
  }, [updateLayout]);
  (0, import_react111.useLayoutEffect)(() => {
    updateLayout();
  });
  return /* @__PURE__ */ (0, import_jsx_runtime160.jsx)("div", { ref, className: "tlui-top-panel__container", children });
}
var import_jsx_runtime160, import_react111;
var init_CenteredTopPanelContainer = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/TopPanel/CenteredTopPanelContainer.mjs"() {
    import_jsx_runtime160 = __toESM(require_jsx_runtime(), 1);
    import_react111 = __toESM(require_react(), 1);
    init_breakpoints();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/TopPanel/DefaultTopPanel.mjs
function DefaultTopPanel() {
  const isOffline = useCollaborationStatus() === "offline";
  return /* @__PURE__ */ (0, import_jsx_runtime161.jsx)(CenteredTopPanelContainer, { children: isOffline && /* @__PURE__ */ (0, import_jsx_runtime161.jsx)(OfflineIndicator, {}) });
}
var import_jsx_runtime161;
var init_DefaultTopPanel = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/TopPanel/DefaultTopPanel.mjs"() {
    import_jsx_runtime161 = __toESM(require_jsx_runtime(), 1);
    init_useIsMultiplayer();
    init_OfflineIndicator();
    init_CenteredTopPanelContainer();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ZoomMenu/DefaultZoomMenuContent.mjs
function DefaultZoomMenuContent() {
  const actions = useActions();
  return /* @__PURE__ */ (0, import_jsx_runtime162.jsxs)(import_jsx_runtime162.Fragment, { children: [
    /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(TldrawUiMenuItem, { ...actions["zoom-in"], noClose: true }),
    /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(TldrawUiMenuItem, { ...actions["zoom-out"], noClose: true }),
    /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(ZoomTo100MenuItem2, {}),
    /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(ZoomToFitMenuItem, {}),
    /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(ZoomToSelectionMenuItem, {})
  ] });
}
var import_jsx_runtime162;
var init_DefaultZoomMenuContent = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ZoomMenu/DefaultZoomMenuContent.mjs"() {
    import_jsx_runtime162 = __toESM(require_jsx_runtime(), 1);
    init_actions();
    init_menu_items();
    init_TldrawUiMenuItem();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/ZoomMenu/DefaultZoomMenu.mjs
var import_jsx_runtime163, import_react112, DefaultZoomMenu, ZoomTriggerButton;
var init_DefaultZoomMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/ZoomMenu/DefaultZoomMenu.mjs"() {
    import_jsx_runtime163 = __toESM(require_jsx_runtime(), 1);
    init_dist28();
    init_dist_esm10();
    import_react112 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_useMenuIsOpen();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiMenuContext();
    init_DefaultZoomMenuContent();
    DefaultZoomMenu = (0, import_react112.memo)(function DefaultZoomMenu2({ children }) {
      const container = useContainer();
      const [isOpen, onOpenChange] = useMenuIsOpen("zoom menu");
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(DefaultZoomMenuContent, {});
      return /* @__PURE__ */ (0, import_jsx_runtime163.jsxs)(Root26, { dir: "ltr", open: isOpen, onOpenChange, modal: false, children: [
        /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(Trigger3, { asChild: true, dir: "ltr", children: /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(ZoomTriggerButton, {}) }),
        /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(Portal23, { container, children: /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(Content25, {
          className: "tlui-menu",
          side: "top",
          align: "start",
          alignOffset: 0,
          sideOffset: 8,
          collisionPadding: 4,
          children: /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(TldrawUiMenuContextProvider, { type: "menu", sourceId: "zoom-menu", children: content })
        }) })
      ] });
    });
    ZoomTriggerButton = (0, import_react112.forwardRef)(function ZoomTriggerButton2(props, ref) {
      const editor = useEditor();
      const breakpoint = useBreakpoint();
      const zoom = useValue("zoom", () => editor.getZoomLevel(), [editor]);
      const msg2 = useTranslation();
      const handleDoubleClick = (0, import_react112.useCallback)(() => {
        editor.resetZoom(editor.getViewportScreenCenter(), {
          animation: { duration: editor.options.animationMediumMs }
        });
      }, [editor]);
      return /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(TldrawUiButton, {
        ref,
        ...props,
        type: "icon",
        title: `${msg2("navigation-zone.zoom")}`,
        "data-testid": "minimap.zoom-menu-button",
        className: breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM ? "tlui-zoom-menu__button" : "tlui-zoom-menu__button__pct",
        onDoubleClick: handleDoubleClick,
        icon: breakpoint < PORTRAIT_BREAKPOINT.MOBILE ? "zoom-in" : void 0,
        children: breakpoint < PORTRAIT_BREAKPOINT.MOBILE ? null : /* @__PURE__ */ (0, import_jsx_runtime163.jsxs)("span", { style: { flexGrow: 0, textAlign: "center" }, children: [
          Math.floor(zoom * 100),
          "%"
        ] })
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/components.mjs
function TldrawUiComponentsProvider({
  overrides = {},
  children
}) {
  const _overrides = useShallowObjectIdentity(overrides);
  const showCollaborationUi = useShowCollaborationUi();
  return /* @__PURE__ */ (0, import_jsx_runtime164.jsx)(TldrawUiComponentsContext.Provider, {
    value: (0, import_react113.useMemo)(() => ({
      ContextMenu: DefaultContextMenu,
      ActionsMenu: DefaultActionsMenu,
      HelpMenu: null,
      ZoomMenu: DefaultZoomMenu,
      MainMenu: DefaultMainMenu,
      Minimap: DefaultMinimap,
      StylePanel: DefaultStylePanel,
      PageMenu: DefaultPageMenu,
      NavigationPanel: DefaultNavigationPanel,
      Toolbar: DefaultToolbar,
      KeyboardShortcutsDialog: DefaultKeyboardShortcutsDialog,
      QuickActions: DefaultQuickActions,
      HelperButtons: DefaultHelperButtons,
      DebugPanel: DefaultDebugPanel,
      DebugMenu: DefaultDebugMenu,
      MenuPanel: DefaultMenuPanel,
      SharePanel: showCollaborationUi ? DefaultSharePanel : null,
      CursorChatBubble: showCollaborationUi ? CursorChatBubble : null,
      TopPanel: showCollaborationUi ? DefaultTopPanel : null,
      ..._overrides
    }), [_overrides, showCollaborationUi]),
    children
  });
}
function useTldrawUiComponents() {
  const components = (0, import_react113.useContext)(TldrawUiComponentsContext);
  if (!components) {
    throw new Error("useTldrawUiComponents must be used within a TldrawUiComponentsProvider");
  }
  return components;
}
var import_jsx_runtime164, import_react113, TldrawUiComponentsContext;
var init_components = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/components.mjs"() {
    import_jsx_runtime164 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react113 = __toESM(require_react(), 1);
    init_DefaultActionsMenu();
    init_DefaultContextMenu();
    init_CursorChatBubble();
    init_DefaultDebugMenu();
    init_DefaultDebugPanel();
    init_DefaultMenuPanel();
    init_DefaultHelperButtons();
    init_DefaultKeyboardShortcutsDialog();
    init_DefaultMainMenu();
    init_DefaultMinimap();
    init_DefaultNavigationPanel();
    init_DefaultPageMenu();
    init_DefaultQuickActions();
    init_DefaultSharePanel();
    init_DefaultStylePanel();
    init_DefaultToolbar();
    init_DefaultTopPanel();
    init_DefaultZoomMenu();
    init_useIsMultiplayer();
    TldrawUiComponentsContext = (0, import_react113.createContext)(null);
  }
});

// node_modules/tldraw/dist-esm/lib/ui/context/TldrawUiContextProvider.mjs
function TldrawUiContextProvider({
  overrides,
  components,
  assetUrls,
  onUiEvent,
  forceMobile,
  children
}) {
  return /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(AssetUrlsProvider, { assetUrls: useDefaultUiAssetUrlsWithOverrides(assetUrls), children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(TranslationProvider, { overrides: useMergedTranslationOverrides(overrides), children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(UiEventsProvider, { onEvent: onUiEvent, children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(ToastsProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(DialogsProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(BreakPointProvider, { forceMobile, children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(TldrawUiComponentsProvider, { overrides: components, children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(InternalProviders, { overrides, children }) }) }) }) }) }) }) });
}
function InternalProviders({
  overrides,
  children
}) {
  const mergedOverrides = useMergedOverrides(overrides);
  return /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(ActionsProvider, { overrides: mergedOverrides.actions, children: /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(ToolsProvider, { overrides: mergedOverrides.tools, children }) });
}
var import_jsx_runtime165;
var init_TldrawUiContextProvider = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/context/TldrawUiContextProvider.mjs"() {
    import_jsx_runtime165 = __toESM(require_jsx_runtime(), 1);
    init_assetUrls2();
    init_useTools();
    init_useTranslation();
    init_overrides();
    init_actions();
    init_asset_urls();
    init_breakpoints();
    init_components();
    init_dialogs();
    init_events();
    init_toasts();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/useEditorEvents.mjs
function useEditorEvents() {
  const editor = useEditor();
  const { addToast } = useToasts();
  (0, import_react114.useEffect)(() => {
    function handleMaxShapes({ name, count: count3 }) {
      addToast({
        title: "Maximum Shapes Reached",
        description: `You've reached the maximum number of shapes allowed on ${name} (${count3}). Please delete some shapes or move to a different page to continue.`,
        severity: "warning"
      });
    }
    editor.addListener("max-shapes", handleMaxShapes);
    return () => {
      editor.removeListener("max-shapes", handleMaxShapes);
    };
  }, [editor, addToast]);
}
var import_react114;
var init_useEditorEvents = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/useEditorEvents.mjs"() {
    init_dist_esm10();
    import_react114 = __toESM(require_react(), 1);
    init_toasts();
  }
});

// node_modules/tldraw/dist-esm/lib/ui/TldrawUi.mjs
var import_jsx_runtime166, import_classnames29, import_react115, TldrawUi, TldrawUiInner, TldrawUiContent;
var init_TldrawUi = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/TldrawUi.mjs"() {
    import_jsx_runtime166 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_classnames29 = __toESM(require_classnames(), 1);
    import_react115 = __toESM(require_react(), 1);
    init_Dialogs();
    init_FollowingIndicator();
    init_Toasts();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_constants5();
    init_TldrawUiContextProvider();
    init_actions();
    init_breakpoints();
    init_components();
    init_useClipboardEvents();
    init_useEditorEvents();
    init_useKeyboardShortcuts();
    init_useReadonly();
    init_useTranslation();
    TldrawUi = import_react115.default.memo(function TldrawUi2({
      renderDebugMenuItems,
      children,
      hideUi,
      components,
      ...rest
    }) {
      return /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TldrawUiContextProvider, { ...rest, components, children: /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TldrawUiInner, { hideUi, renderDebugMenuItems, children }) });
    });
    TldrawUiInner = import_react115.default.memo(function TldrawUiInner2({
      children,
      hideUi,
      ...rest
    }) {
      return /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)(import_jsx_runtime166.Fragment, { children: [
        children,
        hideUi ? null : /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TldrawUiContent, { ...rest })
      ] });
    });
    TldrawUiContent = import_react115.default.memo(function TldrawUI() {
      const editor = useEditor();
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const isReadonlyMode = useReadonly();
      const isFocusMode = useValue("focus", () => editor.getInstanceState().isFocusMode, [editor]);
      const isDebugMode = useValue("debug", () => editor.getInstanceState().isDebugMode, [editor]);
      const {
        SharePanel,
        TopPanel,
        MenuPanel: MenuPanel2,
        StylePanel,
        Toolbar,
        HelpMenu,
        NavigationPanel,
        HelperButtons,
        DebugPanel,
        CursorChatBubble: CursorChatBubble3
      } = useTldrawUiComponents();
      useKeyboardShortcuts();
      useNativeClipboardEvents();
      useEditorEvents();
      const { "toggle-focus-mode": toggleFocus } = useActions();
      return /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", {
        className: (0, import_classnames29.default)("tlui-layout", {
          "tlui-layout__mobile": breakpoint < PORTRAIT_BREAKPOINT.TABLET_SM
        }),
        "data-breakpoint": breakpoint,
        children: [
          isFocusMode ? /* @__PURE__ */ (0, import_jsx_runtime166.jsx)("div", { className: "tlui-layout__top", children: /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TldrawUiButton, {
            type: "icon",
            className: "tlui-focus-button",
            title: msg2("focus-mode.toggle-focus-mode"),
            onClick: () => toggleFocus.onSelect("menu"),
            children: /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TldrawUiButtonIcon, { icon: "dot" })
          }) }) : /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)(import_jsx_runtime166.Fragment, { children: [
            /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", { className: "tlui-layout__top", children: [
              /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", { className: "tlui-layout__top__left", children: [
                MenuPanel2 && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(MenuPanel2, {}),
                HelperButtons && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(HelperButtons, {})
              ] }),
              /* @__PURE__ */ (0, import_jsx_runtime166.jsx)("div", { className: "tlui-layout__top__center", children: TopPanel && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(TopPanel, {}) }),
              /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", { className: "tlui-layout__top__right", children: [
                SharePanel && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(SharePanel, {}),
                StylePanel && breakpoint >= PORTRAIT_BREAKPOINT.TABLET_SM && !isReadonlyMode && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(StylePanel, {})
              ] })
            ] }),
            /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", { className: "tlui-layout__bottom", children: [
              /* @__PURE__ */ (0, import_jsx_runtime166.jsxs)("div", { className: "tlui-layout__bottom__main", children: [
                NavigationPanel && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(NavigationPanel, {}),
                Toolbar && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(Toolbar, {}),
                HelpMenu && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(HelpMenu, {})
              ] }),
              isDebugMode && DebugPanel && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(DebugPanel, {})
            ] })
          ] }),
          /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(Toasts, {}),
          /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(Dialogs, {}),
          /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(ToastViewport2, {}),
          /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(FollowingIndicator, {}),
          CursorChatBubble3 && /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(CursorChatBubble3, {})
        ]
      });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/utils/assets/preload-font.mjs
async function preloadFont(id, font) {
  const {
    url,
    style = "normal",
    weight = "500",
    display,
    featureSettings,
    stretch,
    unicodeRange,
    variant,
    format: format2
  } = font;
  const descriptors = {
    style,
    weight,
    display,
    featureSettings,
    stretch,
    unicodeRange,
    variant
  };
  const fontInstance = new FontFace(id, `url(${url})`, descriptors);
  await fontInstance.load();
  document.fonts.add(fontInstance);
  fontInstance.$$_url = url;
  fontInstance.$$_fontface = `
@font-face {
	font-family: ${fontInstance.family};
	font-stretch: ${fontInstance.stretch};
	font-weight: ${fontInstance.weight};
	font-style: ${fontInstance.style};
	src: url("${url}") format("${format2}")
}`;
  return fontInstance;
}
var init_preload_font = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/assets/preload-font.mjs"() {
  }
});

// node_modules/tldraw/dist-esm/lib/ui/hooks/usePreloadAssets.mjs
function getTypefaces(assetUrls) {
  return {
    draw: {
      url: assetUrls.fonts.draw,
      format: assetUrls.fonts.draw.split(".").pop()
    },
    serif: {
      url: assetUrls.fonts.serif,
      format: assetUrls.fonts.serif.split(".").pop()
    },
    sansSerif: {
      url: assetUrls.fonts.sansSerif,
      format: assetUrls.fonts.sansSerif.split(".").pop()
    },
    monospace: {
      url: assetUrls.fonts.monospace,
      format: assetUrls.fonts.monospace.split(".").pop()
    }
  };
}
function usePreloadAssets(assetUrls) {
  const typefaces = (0, import_react116.useMemo)(() => getTypefaces(assetUrls), [assetUrls]);
  const results = [
    usePreloadFont("tldraw_draw", typefaces.draw),
    usePreloadFont("tldraw_serif", typefaces.serif),
    usePreloadFont("tldraw_sans", typefaces.sansSerif),
    usePreloadFont("tldraw_mono", typefaces.monospace)
  ];
  return {
    error: results.some((result) => result === 1),
    done: !results.some((result) => result === 2)
  };
}
var import_react116, usePreloadFont;
var init_usePreloadAssets = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/hooks/usePreloadAssets.mjs"() {
    import_react116 = __toESM(require_react(), 1);
    init_preload_font();
    usePreloadFont = (id, font) => {
      const [state, setState] = (0, import_react116.useState)(2);
      (0, import_react116.useEffect)(() => {
        let cancelled = false;
        setState(2);
        preloadFont(id, font).then(() => {
          if (cancelled)
            return;
          setState(0);
        }).catch((err) => {
          if (cancelled)
            return;
          console.error(err);
          setState(1);
        });
        return () => {
          cancelled = true;
        };
      }, [id, font]);
      return state;
    };
  }
});

// node_modules/tldraw/dist-esm/lib/Tldraw.mjs
var import_jsx_runtime167, import_react117;
var init_Tldraw = __esm({
  "node_modules/tldraw/dist-esm/lib/Tldraw.mjs"() {
    import_jsx_runtime167 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react117 = __toESM(require_react(), 1);
    init_TldrawHandles();
    init_TldrawScribble();
    init_TldrawSelectionBackground();
    init_TldrawSelectionForeground();
    init_TldrawShapeIndicators();
    init_defaultBindingUtils();
    init_defaultExternalContentHandlers();
    init_defaultShapeTools();
    init_defaultShapeUtils();
    init_defaultSideEffects();
    init_defaultTools();
    init_TldrawUi();
    init_components();
    init_toasts();
    init_usePreloadAssets();
    init_useTranslation();
    init_assetUrls();
  }
});

// node_modules/tldraw/dist-esm/lib/TldrawImage.mjs
var import_jsx_runtime168, import_react118, TldrawImage;
var init_TldrawImage = __esm({
  "node_modules/tldraw/dist-esm/lib/TldrawImage.mjs"() {
    import_jsx_runtime168 = __toESM(require_jsx_runtime(), 1);
    init_dist_esm10();
    import_react118 = __toESM(require_react(), 1);
    init_defaultBindingUtils();
    init_defaultShapeUtils();
    init_usePreloadAssets();
    init_export();
    init_assetUrls();
    TldrawImage = (0, import_react118.memo)(function TldrawImage2(props) {
      const [url, setUrl] = (0, import_react118.useState)(null);
      const [container, setContainer] = (0, import_react118.useState)(null);
      const shapeUtils = useShallowArrayIdentity(props.shapeUtils ?? []);
      const shapeUtilsWithDefaults = (0, import_react118.useMemo)(() => [...defaultShapeUtils, ...shapeUtils], [shapeUtils]);
      const bindingUtils = useShallowArrayIdentity(props.bindingUtils ?? []);
      const bindingUtilsWithDefaults = (0, import_react118.useMemo)(() => [...defaultBindingUtils, ...bindingUtils], [bindingUtils]);
      const store = useTLStore({ snapshot: props.snapshot, shapeUtils: shapeUtilsWithDefaults });
      const assets = useDefaultEditorAssetsWithOverrides();
      const { done: preloadingComplete, error: preloadingError } = usePreloadAssets(assets);
      const {
        pageId,
        bounds,
        scale,
        background,
        padding,
        darkMode,
        preserveAspectRatio,
        format: format2 = "svg",
        licenseKey
      } = props;
      (0, import_react118.useLayoutEffect)(() => {
        if (!container)
          return;
        if (!store)
          return;
        if (!preloadingComplete)
          return;
        let isCancelled = false;
        const tempElm = document.createElement("div");
        container.appendChild(tempElm);
        container.classList.add("tl-container", "tl-theme__light");
        const editor = new Editor({
          store,
          shapeUtils: shapeUtilsWithDefaults,
          bindingUtils: bindingUtilsWithDefaults,
          tools: [],
          getContainer: () => tempElm,
          licenseKey
        });
        if (pageId)
          editor.setCurrentPage(pageId);
        const shapeIds = editor.getCurrentPageShapeIds();
        async function setSvg() {
          const svgResult = await editor.getSvgString([...shapeIds], {
            bounds,
            scale,
            background,
            padding,
            darkMode,
            preserveAspectRatio
          });
          if (svgResult && !isCancelled) {
            if (format2 === "svg") {
              if (!isCancelled) {
                const blob = new Blob([svgResult.svg], { type: "image/svg+xml" });
                const url2 = URL.createObjectURL(blob);
                setUrl(url2);
              }
            } else if (format2 === "png") {
              const blob = await getSvgAsImage(editor, svgResult.svg, {
                type: format2,
                quality: 1,
                scale: 2,
                width: svgResult.width,
                height: svgResult.height
              });
              if (blob && !isCancelled) {
                const url2 = URL.createObjectURL(blob);
                setUrl(url2);
              }
            }
          }
          editor.dispose();
        }
        setSvg();
        return () => {
          isCancelled = true;
        };
      }, [
        format2,
        container,
        store,
        shapeUtilsWithDefaults,
        bindingUtilsWithDefaults,
        pageId,
        bounds,
        scale,
        background,
        padding,
        darkMode,
        preserveAspectRatio,
        preloadingComplete,
        preloadingError,
        licenseKey
      ]);
      if (preloadingError) {
        return /* @__PURE__ */ (0, import_jsx_runtime168.jsx)(ErrorScreen, { children: "Could not load assets." });
      }
      if (!preloadingComplete) {
        return /* @__PURE__ */ (0, import_jsx_runtime168.jsx)(LoadingScreen, { children: /* @__PURE__ */ (0, import_jsx_runtime168.jsx)(DefaultSpinner, {}) });
      }
      return /* @__PURE__ */ (0, import_jsx_runtime168.jsx)("div", { ref: setContainer, style: { position: "relative", width: "100%", height: "100%" }, children: url && /* @__PURE__ */ (0, import_jsx_runtime168.jsx)("img", {
        src: url,
        referrerPolicy: "strict-origin-when-cross-origin",
        style: { width: "100%", height: "100%" }
      }) });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/ui/components/HelpMenu/DefaultHelpMenu.mjs
var import_jsx_runtime169, import_react119, DefaultHelpMenu;
var init_DefaultHelpMenu = __esm({
  "node_modules/tldraw/dist-esm/lib/ui/components/HelpMenu/DefaultHelpMenu.mjs"() {
    import_jsx_runtime169 = __toESM(require_jsx_runtime(), 1);
    import_react119 = __toESM(require_react(), 1);
    init_constants5();
    init_breakpoints();
    init_useTranslation();
    init_TldrawUiButton();
    init_TldrawUiButtonIcon();
    init_TldrawUiDropdownMenu();
    init_TldrawUiMenuContext();
    init_DefaultHelpMenuContent();
    DefaultHelpMenu = (0, import_react119.memo)(function DefaultHelpMenu2({ children }) {
      const msg2 = useTranslation();
      const breakpoint = useBreakpoint();
      const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(DefaultHelpMenuContent, {});
      if (breakpoint < PORTRAIT_BREAKPOINT.MOBILE)
        return null;
      return /* @__PURE__ */ (0, import_jsx_runtime169.jsx)("div", { className: "tlui-help-menu", children: /* @__PURE__ */ (0, import_jsx_runtime169.jsxs)(TldrawUiDropdownMenuRoot, { id: "help menu", children: [
        /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(TldrawUiDropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(TldrawUiButton, { type: "help", title: msg2("help-menu.title"), "data-testid": "help-menu.button", children: /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(TldrawUiButtonIcon, { icon: "question-mark", small: true }) }) }),
        /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(TldrawUiDropdownMenuContent, { side: "top", align: "end", alignOffset: 0, sideOffset: 8, children: /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(TldrawUiMenuContextProvider, { type: "menu", sourceId: "help-menu", children: content }) })
      ] }) });
    });
  }
});

// node_modules/tldraw/dist-esm/lib/utils/tldr/buildFromV1Document.mjs
var init_buildFromV1Document = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/tldr/buildFromV1Document.mjs"() {
    init_dist_esm10();
    init_shared();
  }
});

// node_modules/tldraw/dist-esm/lib/utils/tldr/file.mjs
var schemaV1, schemaV2, tldrawFileValidator;
var init_file5 = __esm({
  "node_modules/tldraw/dist-esm/lib/utils/tldr/file.mjs"() {
    init_dist_esm10();
    init_buildFromV1Document();
    schemaV1 = validation_exports.object({
      schemaVersion: validation_exports.literal(1),
      storeVersion: validation_exports.positiveInteger,
      recordVersions: validation_exports.dict(validation_exports.string, validation_exports.object({
        version: validation_exports.positiveInteger,
        subTypeVersions: validation_exports.dict(validation_exports.string, validation_exports.positiveInteger).optional(),
        subTypeKey: validation_exports.string.optional()
      }))
    });
    schemaV2 = validation_exports.object({
      schemaVersion: validation_exports.literal(2),
      sequences: validation_exports.dict(validation_exports.string, validation_exports.positiveInteger)
    });
    tldrawFileValidator = validation_exports.object({
      tldrawFileFormatVersion: validation_exports.nonZeroInteger,
      schema: validation_exports.numberUnion("schemaVersion", {
        1: schemaV1,
        2: schemaV2
      }),
      records: validation_exports.arrayOf(validation_exports.object({
        id: validation_exports.string,
        typeName: validation_exports.string
      }).allowUnknownProperties())
    });
  }
});

// node_modules/tldraw/dist-esm/index.mjs
var init_dist_esm11 = __esm({
  "node_modules/tldraw/dist-esm/index.mjs"() {
    init_dist_esm10();
    init_Tldraw();
    init_TldrawImage();
    init_ArrowBindingUtil();
    init_TldrawHandles();
    init_TldrawScribble();
    init_TldrawSelectionBackground();
    init_TldrawSelectionForeground();
    init_TldrawShapeIndicators();
    init_defaultBindingUtils();
    init_defaultExternalContentHandlers();
    init_defaultShapeTools();
    init_defaultShapeUtils();
    init_defaultSideEffects();
    init_defaultTools();
    init_ArrowShapeTool();
    init_ArrowShapeUtil();
    init_shared();
    init_BookmarkShapeUtil();
    init_DrawShapeTool();
    init_DrawShapeUtil();
    init_EmbedShapeUtil();
    init_FrameShapeTool();
    init_FrameShapeUtil();
    init_GeoShapeTool();
    init_GeoShapeUtil();
    init_HighlightShapeTool();
    init_HighlightShapeUtil();
    init_ImageShapeUtil();
    init_LineShapeTool();
    init_LineShapeUtil();
    init_NoteShapeTool();
    init_NoteShapeUtil();
    init_TextLabel();
    init_default_shape_constants();
    init_getPerfectDashProps2();
    init_useDefaultColorTheme();
    init_useEditableText();
    init_TextShapeTool();
    init_TextShapeUtil();
    init_VideoShapeUtil();
    init_EraserTool();
    init_HandTool();
    init_LaserTool();
    init_SelectTool();
    init_selectHelpers();
    init_ZoomTool();
    init_TldrawUi();
    init_assetUrls2();
    init_DefaultActionsMenu();
    init_DefaultActionsMenuContent();
    init_DefaultContextMenu();
    init_DefaultContextMenuContent();
    init_DefaultDebugMenu();
    init_DefaultDebugMenuContent();
    init_DefaultMenuPanel();
    init_DefaultHelpMenu();
    init_DefaultHelpMenuContent();
    init_DefaultHelperButtons();
    init_DefaultHelperButtonsContent();
    init_DefaultKeyboardShortcutsDialog();
    init_DefaultKeyboardShortcutsDialogContent();
    init_LanguageMenu();
    init_DefaultMainMenu();
    init_DefaultMainMenuContent();
    init_DefaultMinimap();
    init_DefaultNavigationPanel();
    init_OfflineIndicator();
    init_DefaultPageMenu();
    init_PageItemInput();
    init_PageItemSubmenu();
    init_DefaultQuickActions();
    init_DefaultQuickActionsContent();
    init_DefaultSharePanel();
    init_PeopleMenu();
    init_Spinner();
    init_DefaultStylePanel();
    init_DefaultStylePanelContent();
    init_DefaultToolbar();
    init_DefaultToolbarContent();
    init_CenteredTopPanelContainer();
    init_DefaultTopPanel();
    init_DefaultZoomMenu();
    init_DefaultZoomMenuContent();
    init_menu_items();
    init_TldrawUiButton();
    init_TldrawUiButtonCheck();
    init_TldrawUiButtonIcon();
    init_TldrawUiButtonLabel();
    init_TldrawUiButtonPicker();
    init_TldrawUiDialog();
    init_TldrawUiDropdownMenu();
    init_TldrawUiIcon();
    init_TldrawUiInput();
    init_TldrawUiKbd();
    init_TldrawUiPopover();
    init_TldrawUiSlider();
    init_TldrawUiMenuCheckboxItem();
    init_TldrawUiMenuContext();
    init_TldrawUiMenuGroup();
    init_TldrawUiMenuItem();
    init_TldrawUiMenuSubmenu();
    init_constants5();
    init_TldrawUiContextProvider();
    init_actions();
    init_asset_urls();
    init_breakpoints();
    init_components();
    init_dialogs();
    init_events();
    init_toasts();
    init_menu_hooks();
    init_useClipboardEvents();
    init_useCopyAs();
    init_useExportAs();
    init_useIsMultiplayer();
    init_useKeyboardShortcuts();
    init_useLocalStorageState();
    init_useMenuIsOpen();
    init_usePreloadAssets();
    init_useReadonly();
    init_useRelevantStyles();
    init_useTools();
    init_useTranslation();
    init_overrides();
    init_assets2();
    init_preload_font();
    init_embeds();
    init_copyAs();
    init_export();
    init_exportAs();
    init_frames();
    init_assetUrls();
    init_text();
    init_buildFromV1Document();
    init_file5();
  }
});

// node_modules/@tldraw/tldraw/dist-esm/index.mjs
var init_dist_esm12 = __esm({
  "node_modules/@tldraw/tldraw/dist-esm/index.mjs"() {
    init_dist_esm11();
  }
});

// node_modules/chalk/source/vendor/ansi-styles/index.js
function assembleStyles() {
  const codes = /* @__PURE__ */ new Map();
  for (const [groupName, group] of Object.entries(styles)) {
    for (const [styleName, style] of Object.entries(group)) {
      styles[styleName] = {
        open: `\x1B[${style[0]}m`,
        close: `\x1B[${style[1]}m`
      };
      group[styleName] = styles[styleName];
      codes.set(style[0], style[1]);
    }
    Object.defineProperty(styles, groupName, {
      value: group,
      enumerable: false
    });
  }
  Object.defineProperty(styles, "codes", {
    value: codes,
    enumerable: false
  });
  styles.color.close = "\x1B[39m";
  styles.bgColor.close = "\x1B[49m";
  styles.color.ansi = wrapAnsi16();
  styles.color.ansi256 = wrapAnsi256();
  styles.color.ansi16m = wrapAnsi16m();
  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
  Object.defineProperties(styles, {
    rgbToAnsi256: {
      value(red, green, blue) {
        if (red === green && green === blue) {
          if (red < 8) {
            return 16;
          }
          if (red > 248) {
            return 231;
          }
          return Math.round((red - 8) / 247 * 24) + 232;
        }
        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
      },
      enumerable: false
    },
    hexToRgb: {
      value(hex) {
        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
        if (!matches) {
          return [0, 0, 0];
        }
        let [colorString] = matches;
        if (colorString.length === 3) {
          colorString = [...colorString].map((character) => character + character).join("");
        }
        const integer2 = Number.parseInt(colorString, 16);
        return [
          integer2 >> 16 & 255,
          integer2 >> 8 & 255,
          integer2 & 255
        ];
      },
      enumerable: false
    },
    hexToAnsi256: {
      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
      enumerable: false
    },
    ansi256ToAnsi: {
      value(code2) {
        if (code2 < 8) {
          return 30 + code2;
        }
        if (code2 < 16) {
          return 90 + (code2 - 8);
        }
        let red;
        let green;
        let blue;
        if (code2 >= 232) {
          red = ((code2 - 232) * 10 + 8) / 255;
          green = red;
          blue = red;
        } else {
          code2 -= 16;
          const remainder = code2 % 36;
          red = Math.floor(code2 / 36) / 5;
          green = Math.floor(remainder / 6) / 5;
          blue = remainder % 6 / 5;
        }
        const value = Math.max(red, green, blue) * 2;
        if (value === 0) {
          return 30;
        }
        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
        if (value === 2) {
          result += 60;
        }
        return result;
      },
      enumerable: false
    },
    rgbToAnsi: {
      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
      enumerable: false
    },
    hexToAnsi: {
      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
      enumerable: false
    }
  });
  return styles;
}
var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
var init_ansi_styles = __esm({
  "node_modules/chalk/source/vendor/ansi-styles/index.js"() {
    ANSI_BACKGROUND_OFFSET = 10;
    wrapAnsi16 = (offset5 = 0) => (code2) => `\x1B[${code2 + offset5}m`;
    wrapAnsi256 = (offset5 = 0) => (code2) => `\x1B[${38 + offset5};5;${code2}m`;
    wrapAnsi16m = (offset5 = 0) => (red, green, blue) => `\x1B[${38 + offset5};2;${red};${green};${blue}m`;
    styles = {
      modifier: {
        reset: [0, 0],
        bold: [1, 22],
        dim: [2, 22],
        italic: [3, 23],
        underline: [4, 24],
        overline: [53, 55],
        inverse: [7, 27],
        hidden: [8, 28],
        strikethrough: [9, 29]
      },
      color: {
        black: [30, 39],
        red: [31, 39],
        green: [32, 39],
        yellow: [33, 39],
        blue: [34, 39],
        magenta: [35, 39],
        cyan: [36, 39],
        white: [37, 39],
        blackBright: [90, 39],
        gray: [90, 39],
        grey: [90, 39],
        redBright: [91, 39],
        greenBright: [92, 39],
        yellowBright: [93, 39],
        blueBright: [94, 39],
        magentaBright: [95, 39],
        cyanBright: [96, 39],
        whiteBright: [97, 39]
      },
      bgColor: {
        bgBlack: [40, 49],
        bgRed: [41, 49],
        bgGreen: [42, 49],
        bgYellow: [43, 49],
        bgBlue: [44, 49],
        bgMagenta: [45, 49],
        bgCyan: [46, 49],
        bgWhite: [47, 49],
        bgBlackBright: [100, 49],
        bgGray: [100, 49],
        bgGrey: [100, 49],
        bgRedBright: [101, 49],
        bgGreenBright: [102, 49],
        bgYellowBright: [103, 49],
        bgBlueBright: [104, 49],
        bgMagentaBright: [105, 49],
        bgCyanBright: [106, 49],
        bgWhiteBright: [107, 49]
      }
    };
    modifierNames = Object.keys(styles.modifier);
    foregroundColorNames = Object.keys(styles.color);
    backgroundColorNames = Object.keys(styles.bgColor);
    colorNames = [...foregroundColorNames, ...backgroundColorNames];
    ansiStyles = assembleStyles();
    ansi_styles_default = ansiStyles;
  }
});

// node_modules/chalk/source/vendor/supports-color/browser.js
var level, colorSupport, supportsColor, browser_default;
var init_browser = __esm({
  "node_modules/chalk/source/vendor/supports-color/browser.js"() {
    level = (() => {
      if (!("navigator" in globalThis)) {
        return 0;
      }
      if (globalThis.navigator.userAgentData) {
        const brand = navigator.userAgentData.brands.find(({ brand: brand2 }) => brand2 === "Chromium");
        if (brand && brand.version > 93) {
          return 3;
        }
      }
      if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {
        return 1;
      }
      return 0;
    })();
    colorSupport = level !== 0 && {
      level,
      hasBasic: true,
      has256: level >= 2,
      has16m: level >= 3
    };
    supportsColor = {
      stdout: colorSupport,
      stderr: colorSupport
    };
    browser_default = supportsColor;
  }
});

// node_modules/chalk/source/utilities.js
function stringReplaceAll(string2, substring, replacer) {
  let index3 = string2.indexOf(substring);
  if (index3 === -1) {
    return string2;
  }
  const substringLength = substring.length;
  let endIndex = 0;
  let returnValue = "";
  do {
    returnValue += string2.slice(endIndex, index3) + substring + replacer;
    endIndex = index3 + substringLength;
    index3 = string2.indexOf(substring, endIndex);
  } while (index3 !== -1);
  returnValue += string2.slice(endIndex);
  return returnValue;
}
function stringEncaseCRLFWithFirstIndex(string2, prefix, postfix, index3) {
  let endIndex = 0;
  let returnValue = "";
  do {
    const gotCR = string2[index3 - 1] === "\r";
    returnValue += string2.slice(endIndex, gotCR ? index3 - 1 : index3) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
    endIndex = index3 + 1;
    index3 = string2.indexOf("\n", endIndex);
  } while (index3 !== -1);
  returnValue += string2.slice(endIndex);
  return returnValue;
}
var init_utilities = __esm({
  "node_modules/chalk/source/utilities.js"() {
  }
});

// node_modules/chalk/source/index.js
function createChalk(options) {
  return chalkFactory(options);
}
var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
var init_source = __esm({
  "node_modules/chalk/source/index.js"() {
    init_ansi_styles();
    init_browser();
    init_utilities();
    ({ stdout: stdoutColor, stderr: stderrColor } = browser_default);
    GENERATOR = Symbol("GENERATOR");
    STYLER = Symbol("STYLER");
    IS_EMPTY = Symbol("IS_EMPTY");
    levelMapping = [
      "ansi",
      "ansi",
      "ansi256",
      "ansi16m"
    ];
    styles2 = /* @__PURE__ */ Object.create(null);
    applyOptions = (object2, options = {}) => {
      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
        throw new Error("The `level` option should be an integer from 0 to 3");
      }
      const colorLevel = stdoutColor ? stdoutColor.level : 0;
      object2.level = options.level === void 0 ? colorLevel : options.level;
    };
    chalkFactory = (options) => {
      const chalk2 = (...strings) => strings.join(" ");
      applyOptions(chalk2, options);
      Object.setPrototypeOf(chalk2, createChalk.prototype);
      return chalk2;
    };
    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
      styles2[styleName] = {
        get() {
          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
          Object.defineProperty(this, styleName, { value: builder });
          return builder;
        }
      };
    }
    styles2.visible = {
      get() {
        const builder = createBuilder(this, this[STYLER], true);
        Object.defineProperty(this, "visible", { value: builder });
        return builder;
      }
    };
    getModelAnsi = (model2, level2, type, ...arguments_) => {
      if (model2 === "rgb") {
        if (level2 === "ansi16m") {
          return ansi_styles_default[type].ansi16m(...arguments_);
        }
        if (level2 === "ansi256") {
          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
        }
        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
      }
      if (model2 === "hex") {
        return getModelAnsi("rgb", level2, type, ...ansi_styles_default.hexToRgb(...arguments_));
      }
      return ansi_styles_default[type][model2](...arguments_);
    };
    usedModels = ["rgb", "hex", "ansi256"];
    for (const model2 of usedModels) {
      styles2[model2] = {
        get() {
          const { level: level2 } = this;
          return function(...arguments_) {
            const styler = createStyler(getModelAnsi(model2, levelMapping[level2], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
            return createBuilder(this, styler, this[IS_EMPTY]);
          };
        }
      };
      const bgModel = "bg" + model2[0].toUpperCase() + model2.slice(1);
      styles2[bgModel] = {
        get() {
          const { level: level2 } = this;
          return function(...arguments_) {
            const styler = createStyler(getModelAnsi(model2, levelMapping[level2], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
            return createBuilder(this, styler, this[IS_EMPTY]);
          };
        }
      };
    }
    proto = Object.defineProperties(() => {
    }, {
      ...styles2,
      level: {
        enumerable: true,
        get() {
          return this[GENERATOR].level;
        },
        set(level2) {
          this[GENERATOR].level = level2;
        }
      }
    });
    createStyler = (open, close, parent) => {
      let openAll;
      let closeAll;
      if (parent === void 0) {
        openAll = open;
        closeAll = close;
      } else {
        openAll = parent.openAll + open;
        closeAll = close + parent.closeAll;
      }
      return {
        open,
        close,
        openAll,
        closeAll,
        parent
      };
    };
    createBuilder = (self2, _styler, _isEmpty) => {
      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
      Object.setPrototypeOf(builder, proto);
      builder[GENERATOR] = self2;
      builder[STYLER] = _styler;
      builder[IS_EMPTY] = _isEmpty;
      return builder;
    };
    applyStyle = (self2, string2) => {
      if (self2.level <= 0 || !string2) {
        return self2[IS_EMPTY] ? "" : string2;
      }
      let styler = self2[STYLER];
      if (styler === void 0) {
        return string2;
      }
      const { openAll, closeAll } = styler;
      if (string2.includes("\x1B")) {
        while (styler !== void 0) {
          string2 = stringReplaceAll(string2, styler.close, styler.open);
          styler = styler.parent;
        }
      }
      const lfIndex = string2.indexOf("\n");
      if (lfIndex !== -1) {
        string2 = stringEncaseCRLFWithFirstIndex(string2, closeAll, openAll, lfIndex);
      }
      return openAll + string2 + closeAll;
    };
    Object.defineProperties(createChalk.prototype, styles2);
    chalk = createChalk();
    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
    source_default = chalk;
  }
});

// src/logic/utils/universal-dev-logging.ts
function getTimestamp3() {
  const now = new Date();
  const hours = String(now.getHours()).padStart(2, "0");
  const minutes = String(now.getMinutes()).padStart(2, "0");
  const seconds = String(now.getSeconds()).padStart(2, "0");
  const milliseconds = String(now.getMilliseconds()).padStart(3, "0");
  return `${hours}:${minutes}:${seconds}.${milliseconds}`;
}
function inkDebugLog(entry) {
  try {
    console.debug("[InkDebug]", JSON.stringify({ ...entry, timestamp: Date.now() }));
  } catch {
  }
}
function stringifyForLogFragment(value) {
  if (typeof value === "string")
    return value;
  if (typeof value === "number" || typeof value === "boolean") {
    return `${value}`;
  }
  if (typeof value === "bigint") {
    return `${value.toString()}n`;
  }
  if (typeof value === "symbol") {
    const description = value.description;
    return description !== void 0 ? `Symbol(${description})` : "Symbol()";
  }
  if (typeof value === "function") {
    const nameProp = Reflect.get(value, "name");
    const functionName = typeof nameProp === "string" ? nameProp : "";
    return functionName.length > 0 ? `[Function: ${functionName}]` : "[Function: anonymous]";
  }
  if (value === void 0)
    return "undefined";
  if (value === null)
    return "null";
  try {
    return JSON.stringify(value);
  } catch {
    return "[unavailable]";
  }
}
function info(_data, _options = {}) {
  print(source_default.blue.bold("Ink info:"), _data, _options);
}
function warn(_data, _options = {}) {
  print(source_default.yellow.bold("Ink warn:"), _data, _options);
}
function error(_data, _options = {}) {
  print(source_default.red.bold("Ink error:"), _data, _options);
}
function debug(_data, _options = {}) {
  print(source_default.green.bold("Ink debug:"), _data, _options);
}
function verbose(_data, _options = {}) {
  print(source_default.cyan.bold("Ink verbose:"), _data, _options);
}
function print(_label, _data, _options = {}) {
  if (Array.isArray(_data)) {
    printArray(_label, _data, _options);
  } else if (_data !== null && typeof _data === "object") {
    printTimestampAndLabel(_label);
    printObj(_data, _options);
    printEmptyLine();
  } else {
    printStr(`${getTimestampAndLabel(_label)} ${stringifyForLogFragment(_data)}`);
  }
}
function printArray(_label, _data, _options = {}) {
  let accString = "";
  if (_data.length > 0 && _data[0] !== null && typeof _data[0] === "object") {
    printTimestampAndLabel(_label);
  }
  for (let i2 = 0; i2 < _data.length; i2++) {
    if (_data[i2] !== null && typeof _data[i2] === "object") {
      if (accString.length) {
        printStr(accString);
        accString = "";
      }
      printObj(_data[i2], _options);
    } else {
      if (i2 === 0) {
        accString = `${getTimestampAndLabel(_label)} ${stringifyForLogFragment(_data[i2])}`;
      } else {
        if (accString.length) {
          accString = `${accString} ${stringifyForLogFragment(_data[i2])}`;
        } else {
          accString = `${_label} ${stringifyForLogFragment(_data[i2])}`;
        }
      }
      if (i2 === _data.length - 1) {
        printStr(accString);
      }
    }
  }
  if (_data[_data.length - 1] !== null && typeof _data[_data.length - 1] === "object") {
    printEmptyLine();
  }
}
function printStr(_str) {
  console.debug(`${_str}`);
}
function printObj(_data, _options) {
  let data;
  if (_options.freeze) {
    data = JSON.parse(JSON.stringify(_data));
  } else {
    data = _data;
  }
  if (_options.stringify) {
    data = JSON.stringify(data, null, 2);
  }
  console.debug(data);
}
function printTimestampAndLabel(_label) {
  console.debug(getTimestampAndLabel(_label));
}
function printEmptyLine() {
  console.debug("");
}
function getTimestampAndLabel(_label) {
  return `${source_default.grey(getTimestamp3())} ${_label}`;
}
var init_universal_dev_logging = __esm({
  "src/logic/utils/universal-dev-logging.ts"() {
    init_source();
  }
});

// src/components/jsx-components/writing-menu/writing-menu.scss
var init_2 = __esm({
  "src/components/jsx-components/writing-menu/writing-menu.scss"() {
  }
});

// src/graphics/icons/erase-icon.tsx
var React73, EraseIcon;
var init_erase_icon = __esm({
  "src/graphics/icons/erase-icon.tsx"() {
    React73 = __toESM(require_react());
    EraseIcon = (props) => /* @__PURE__ */ React73.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React73.createElement("path", {
      d: "M690-240h150q17 0 28.5 11.5T880-200q0 17-11.5 28.5T840-160H610l80-80Zm-483 80q-8 0-15.5-3t-13.5-9l-73-73q-23-23-23.5-57t22.5-58l440-456q23-24 56.5-24t56.5 23l199 199q23 23 23 57t-23 57L532-172q-6 6-13.5 9t-15.5 3H207Zm279-80 314-322-198-198-442 456 64 64h262Zm-6-240Z"
    }));
  }
});

// src/graphics/icons/select-icon.tsx
var React74, SelectIcon;
var init_select_icon = __esm({
  "src/graphics/icons/select-icon.tsx"() {
    React74 = __toESM(require_react());
    SelectIcon = (props) => /* @__PURE__ */ React74.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React74.createElement("path", {
      d: "m320-410 79-110h170L320-716v306Zm286 305q-23 11-46 2.5T526-134L406-392l-93 130q-17 24-45 15t-28-38v-513q0-25 22.5-36t42.5 5l404 318q23 17 13.5 44T684-440H516l119 255q11 23 2.5 46T606-105ZM399-520Z"
    }));
  }
});

// src/graphics/icons/expand-icon.tsx
var React75, ExpandIcon;
var init_expand_icon = __esm({
  "src/graphics/icons/expand-icon.tsx"() {
    React75 = __toESM(require_react());
    ExpandIcon = (props) => /* @__PURE__ */ React75.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React75.createElement("path", {
      d: "M200-200v-240h80v160h160v80H200Zm480-320v-160H520v-80h240v240h-80Z"
    }));
  }
});

// node_modules/@popperjs/core/lib/enums.js
var top, bottom, right, left, auto, basePlacements, start, end, clippingParents, viewport, popper, reference, variationPlacements, placements2, beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite, modifierPhases;
var init_enums = __esm({
  "node_modules/@popperjs/core/lib/enums.js"() {
    top = "top";
    bottom = "bottom";
    right = "right";
    left = "left";
    auto = "auto";
    basePlacements = [top, bottom, right, left];
    start = "start";
    end = "end";
    clippingParents = "clippingParents";
    viewport = "viewport";
    popper = "popper";
    reference = "reference";
    variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) {
      return acc.concat([placement + "-" + start, placement + "-" + end]);
    }, []);
    placements2 = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
      return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
    }, []);
    beforeRead = "beforeRead";
    read = "read";
    afterRead = "afterRead";
    beforeMain = "beforeMain";
    main = "main";
    afterMain = "afterMain";
    beforeWrite = "beforeWrite";
    write = "write";
    afterWrite = "afterWrite";
    modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
function getNodeName2(element) {
  return element ? (element.nodeName || "").toLowerCase() : null;
}
var init_getNodeName = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getNodeName.js"() {
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getWindow.js
function getWindow2(node) {
  if (node == null) {
    return window;
  }
  if (node.toString() !== "[object Window]") {
    var ownerDocument = node.ownerDocument;
    return ownerDocument ? ownerDocument.defaultView || window : window;
  }
  return node;
}
var init_getWindow = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getWindow.js"() {
  }
});

// node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
function isElement2(node) {
  var OwnElement = getWindow2(node).Element;
  return node instanceof OwnElement || node instanceof Element;
}
function isHTMLElement3(node) {
  var OwnElement = getWindow2(node).HTMLElement;
  return node instanceof OwnElement || node instanceof HTMLElement;
}
function isShadowRoot2(node) {
  if (typeof ShadowRoot === "undefined") {
    return false;
  }
  var OwnElement = getWindow2(node).ShadowRoot;
  return node instanceof OwnElement || node instanceof ShadowRoot;
}
var init_instanceOf = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/instanceOf.js"() {
    init_getWindow();
  }
});

// node_modules/@popperjs/core/lib/modifiers/applyStyles.js
function applyStyles(_ref) {
  var state = _ref.state;
  Object.keys(state.elements).forEach(function(name) {
    var style = state.styles[name] || {};
    var attributes = state.attributes[name] || {};
    var element = state.elements[name];
    if (!isHTMLElement3(element) || !getNodeName2(element)) {
      return;
    }
    Object.assign(element.style, style);
    Object.keys(attributes).forEach(function(name2) {
      var value = attributes[name2];
      if (value === false) {
        element.removeAttribute(name2);
      } else {
        element.setAttribute(name2, value === true ? "" : value);
      }
    });
  });
}
function effect(_ref2) {
  var state = _ref2.state;
  var initialStyles = {
    popper: {
      position: state.options.strategy,
      left: "0",
      top: "0",
      margin: "0"
    },
    arrow: {
      position: "absolute"
    },
    reference: {}
  };
  Object.assign(state.elements.popper.style, initialStyles.popper);
  state.styles = initialStyles;
  if (state.elements.arrow) {
    Object.assign(state.elements.arrow.style, initialStyles.arrow);
  }
  return function() {
    Object.keys(state.elements).forEach(function(name) {
      var element = state.elements[name];
      var attributes = state.attributes[name] || {};
      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
      var style = styleProperties.reduce(function(style2, property) {
        style2[property] = "";
        return style2;
      }, {});
      if (!isHTMLElement3(element) || !getNodeName2(element)) {
        return;
      }
      Object.assign(element.style, style);
      Object.keys(attributes).forEach(function(attribute) {
        element.removeAttribute(attribute);
      });
    });
  };
}
var applyStyles_default;
var init_applyStyles = __esm({
  "node_modules/@popperjs/core/lib/modifiers/applyStyles.js"() {
    init_getNodeName();
    init_instanceOf();
    applyStyles_default = {
      name: "applyStyles",
      enabled: true,
      phase: "write",
      fn: applyStyles,
      effect,
      requires: ["computeStyles"]
    };
  }
});

// node_modules/@popperjs/core/lib/utils/getBasePlacement.js
function getBasePlacement(placement) {
  return placement.split("-")[0];
}
var init_getBasePlacement = __esm({
  "node_modules/@popperjs/core/lib/utils/getBasePlacement.js"() {
  }
});

// node_modules/@popperjs/core/lib/utils/math.js
var max2, min3, round3;
var init_math = __esm({
  "node_modules/@popperjs/core/lib/utils/math.js"() {
    max2 = Math.max;
    min3 = Math.min;
    round3 = Math.round;
  }
});

// node_modules/@popperjs/core/lib/utils/userAgent.js
function getUAString() {
  var uaData = navigator.userAgentData;
  if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
    return uaData.brands.map(function(item) {
      return item.brand + "/" + item.version;
    }).join(" ");
  }
  return navigator.userAgent;
}
var init_userAgent = __esm({
  "node_modules/@popperjs/core/lib/utils/userAgent.js"() {
  }
});

// node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js
function isLayoutViewport() {
  return !/^((?!chrome|android).)*safari/i.test(getUAString());
}
var init_isLayoutViewport = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js"() {
    init_userAgent();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
function getBoundingClientRect2(element, includeScale, isFixedStrategy) {
  if (includeScale === void 0) {
    includeScale = false;
  }
  if (isFixedStrategy === void 0) {
    isFixedStrategy = false;
  }
  var clientRect = element.getBoundingClientRect();
  var scaleX = 1;
  var scaleY = 1;
  if (includeScale && isHTMLElement3(element)) {
    scaleX = element.offsetWidth > 0 ? round3(clientRect.width) / element.offsetWidth || 1 : 1;
    scaleY = element.offsetHeight > 0 ? round3(clientRect.height) / element.offsetHeight || 1 : 1;
  }
  var _ref = isElement2(element) ? getWindow2(element) : window, visualViewport = _ref.visualViewport;
  var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
  var x2 = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
  var y2 = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
  var width = clientRect.width / scaleX;
  var height = clientRect.height / scaleY;
  return {
    width,
    height,
    top: y2,
    right: x2 + width,
    bottom: y2 + height,
    left: x2,
    x: x2,
    y: y2
  };
}
var init_getBoundingClientRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js"() {
    init_instanceOf();
    init_math();
    init_getWindow();
    init_isLayoutViewport();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
function getLayoutRect(element) {
  var clientRect = getBoundingClientRect2(element);
  var width = element.offsetWidth;
  var height = element.offsetHeight;
  if (Math.abs(clientRect.width - width) <= 1) {
    width = clientRect.width;
  }
  if (Math.abs(clientRect.height - height) <= 1) {
    height = clientRect.height;
  }
  return {
    x: element.offsetLeft,
    y: element.offsetTop,
    width,
    height
  };
}
var init_getLayoutRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js"() {
    init_getBoundingClientRect();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/contains.js
function contains(parent, child) {
  var rootNode = child.getRootNode && child.getRootNode();
  if (parent.contains(child)) {
    return true;
  } else if (rootNode && isShadowRoot2(rootNode)) {
    var next = child;
    do {
      if (next && parent.isSameNode(next)) {
        return true;
      }
      next = next.parentNode || next.host;
    } while (next);
  }
  return false;
}
var init_contains = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/contains.js"() {
    init_instanceOf();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
function getComputedStyle3(element) {
  return getWindow2(element).getComputedStyle(element);
}
var init_getComputedStyle = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js"() {
    init_getWindow();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
function isTableElement2(element) {
  return ["table", "td", "th"].indexOf(getNodeName2(element)) >= 0;
}
var init_isTableElement = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/isTableElement.js"() {
    init_getNodeName();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
function getDocumentElement2(element) {
  return ((isElement2(element) ? element.ownerDocument : element.document) || window.document).documentElement;
}
var init_getDocumentElement = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js"() {
    init_instanceOf();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
function getParentNode2(element) {
  if (getNodeName2(element) === "html") {
    return element;
  }
  return element.assignedSlot || element.parentNode || (isShadowRoot2(element) ? element.host : null) || getDocumentElement2(element);
}
var init_getParentNode = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getParentNode.js"() {
    init_getNodeName();
    init_getDocumentElement();
    init_instanceOf();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js
function getTrueOffsetParent2(element) {
  if (!isHTMLElement3(element) || getComputedStyle3(element).position === "fixed") {
    return null;
  }
  return element.offsetParent;
}
function getContainingBlock2(element) {
  var isFirefox = /firefox/i.test(getUAString());
  var isIE = /Trident/i.test(getUAString());
  if (isIE && isHTMLElement3(element)) {
    var elementCss = getComputedStyle3(element);
    if (elementCss.position === "fixed") {
      return null;
    }
  }
  var currentNode = getParentNode2(element);
  if (isShadowRoot2(currentNode)) {
    currentNode = currentNode.host;
  }
  while (isHTMLElement3(currentNode) && ["html", "body"].indexOf(getNodeName2(currentNode)) < 0) {
    var css = getComputedStyle3(currentNode);
    if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
      return currentNode;
    } else {
      currentNode = currentNode.parentNode;
    }
  }
  return null;
}
function getOffsetParent2(element) {
  var window3 = getWindow2(element);
  var offsetParent = getTrueOffsetParent2(element);
  while (offsetParent && isTableElement2(offsetParent) && getComputedStyle3(offsetParent).position === "static") {
    offsetParent = getTrueOffsetParent2(offsetParent);
  }
  if (offsetParent && (getNodeName2(offsetParent) === "html" || getNodeName2(offsetParent) === "body" && getComputedStyle3(offsetParent).position === "static")) {
    return window3;
  }
  return offsetParent || getContainingBlock2(element) || window3;
}
var init_getOffsetParent = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js"() {
    init_getWindow();
    init_getNodeName();
    init_getComputedStyle();
    init_instanceOf();
    init_isTableElement();
    init_getParentNode();
    init_userAgent();
  }
});

// node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
function getMainAxisFromPlacement(placement) {
  return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
}
var init_getMainAxisFromPlacement = __esm({
  "node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js"() {
  }
});

// node_modules/@popperjs/core/lib/utils/within.js
function within(min4, value, max3) {
  return max2(min4, min3(value, max3));
}
function withinMaxClamp(min4, value, max3) {
  var v2 = within(min4, value, max3);
  return v2 > max3 ? max3 : v2;
}
var init_within = __esm({
  "node_modules/@popperjs/core/lib/utils/within.js"() {
    init_math();
  }
});

// node_modules/@popperjs/core/lib/utils/getFreshSideObject.js
function getFreshSideObject() {
  return {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0
  };
}
var init_getFreshSideObject = __esm({
  "node_modules/@popperjs/core/lib/utils/getFreshSideObject.js"() {
  }
});

// node_modules/@popperjs/core/lib/utils/mergePaddingObject.js
function mergePaddingObject(paddingObject) {
  return Object.assign({}, getFreshSideObject(), paddingObject);
}
var init_mergePaddingObject = __esm({
  "node_modules/@popperjs/core/lib/utils/mergePaddingObject.js"() {
    init_getFreshSideObject();
  }
});

// node_modules/@popperjs/core/lib/utils/expandToHashMap.js
function expandToHashMap(value, keys) {
  return keys.reduce(function(hashMap, key) {
    hashMap[key] = value;
    return hashMap;
  }, {});
}
var init_expandToHashMap = __esm({
  "node_modules/@popperjs/core/lib/utils/expandToHashMap.js"() {
  }
});

// node_modules/@popperjs/core/lib/modifiers/arrow.js
function arrow4(_ref) {
  var _state$modifiersData$;
  var state = _ref.state, name = _ref.name, options = _ref.options;
  var arrowElement = state.elements.arrow;
  var popperOffsets2 = state.modifiersData.popperOffsets;
  var basePlacement = getBasePlacement(state.placement);
  var axis = getMainAxisFromPlacement(basePlacement);
  var isVertical = [left, right].indexOf(basePlacement) >= 0;
  var len = isVertical ? "height" : "width";
  if (!arrowElement || !popperOffsets2) {
    return;
  }
  var paddingObject = toPaddingObject(options.padding, state);
  var arrowRect = getLayoutRect(arrowElement);
  var minProp = axis === "y" ? top : left;
  var maxProp = axis === "y" ? bottom : right;
  var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
  var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
  var arrowOffsetParent = getOffsetParent2(arrowElement);
  var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
  var centerToReference = endDiff / 2 - startDiff / 2;
  var min4 = paddingObject[minProp];
  var max3 = clientSize - arrowRect[len] - paddingObject[maxProp];
  var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
  var offset5 = within(min4, center, max3);
  var axisProp = axis;
  state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset5, _state$modifiersData$.centerOffset = offset5 - center, _state$modifiersData$);
}
function effect2(_ref2) {
  var state = _ref2.state, options = _ref2.options;
  var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
  if (arrowElement == null) {
    return;
  }
  if (typeof arrowElement === "string") {
    arrowElement = state.elements.popper.querySelector(arrowElement);
    if (!arrowElement) {
      return;
    }
  }
  if (!contains(state.elements.popper, arrowElement)) {
    return;
  }
  state.elements.arrow = arrowElement;
}
var toPaddingObject, arrow_default;
var init_arrow = __esm({
  "node_modules/@popperjs/core/lib/modifiers/arrow.js"() {
    init_getBasePlacement();
    init_getLayoutRect();
    init_contains();
    init_getOffsetParent();
    init_getMainAxisFromPlacement();
    init_within();
    init_mergePaddingObject();
    init_expandToHashMap();
    init_enums();
    toPaddingObject = function toPaddingObject2(padding, state) {
      padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
        placement: state.placement
      })) : padding;
      return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
    };
    arrow_default = {
      name: "arrow",
      enabled: true,
      phase: "main",
      fn: arrow4,
      effect: effect2,
      requires: ["popperOffsets"],
      requiresIfExists: ["preventOverflow"]
    };
  }
});

// node_modules/@popperjs/core/lib/utils/getVariation.js
function getVariation(placement) {
  return placement.split("-")[1];
}
var init_getVariation = __esm({
  "node_modules/@popperjs/core/lib/utils/getVariation.js"() {
  }
});

// node_modules/@popperjs/core/lib/modifiers/computeStyles.js
function roundOffsetsByDPR(_ref, win) {
  var x2 = _ref.x, y2 = _ref.y;
  var dpr = win.devicePixelRatio || 1;
  return {
    x: round3(x2 * dpr) / dpr || 0,
    y: round3(y2 * dpr) / dpr || 0
  };
}
function mapToStyles(_ref2) {
  var _Object$assign2;
  var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
  var _offsets$x = offsets.x, x2 = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y2 = _offsets$y === void 0 ? 0 : _offsets$y;
  var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
    x: x2,
    y: y2
  }) : {
    x: x2,
    y: y2
  };
  x2 = _ref3.x;
  y2 = _ref3.y;
  var hasX = offsets.hasOwnProperty("x");
  var hasY = offsets.hasOwnProperty("y");
  var sideX = left;
  var sideY = top;
  var win = window;
  if (adaptive) {
    var offsetParent = getOffsetParent2(popper2);
    var heightProp = "clientHeight";
    var widthProp = "clientWidth";
    if (offsetParent === getWindow2(popper2)) {
      offsetParent = getDocumentElement2(popper2);
      if (getComputedStyle3(offsetParent).position !== "static" && position === "absolute") {
        heightProp = "scrollHeight";
        widthProp = "scrollWidth";
      }
    }
    offsetParent = offsetParent;
    if (placement === top || (placement === left || placement === right) && variation === end) {
      sideY = bottom;
      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
      y2 -= offsetY - popperRect.height;
      y2 *= gpuAcceleration ? 1 : -1;
    }
    if (placement === left || (placement === top || placement === bottom) && variation === end) {
      sideX = right;
      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
      x2 -= offsetX - popperRect.width;
      x2 *= gpuAcceleration ? 1 : -1;
    }
  }
  var commonStyles = Object.assign({
    position
  }, adaptive && unsetSides);
  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
    x: x2,
    y: y2
  }, getWindow2(popper2)) : {
    x: x2,
    y: y2
  };
  x2 = _ref4.x;
  y2 = _ref4.y;
  if (gpuAcceleration) {
    var _Object$assign;
    return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x2 + "px, " + y2 + "px)" : "translate3d(" + x2 + "px, " + y2 + "px, 0)", _Object$assign));
  }
  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y2 + "px" : "", _Object$assign2[sideX] = hasX ? x2 + "px" : "", _Object$assign2.transform = "", _Object$assign2));
}
function computeStyles(_ref5) {
  var state = _ref5.state, options = _ref5.options;
  var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
  var commonStyles = {
    placement: getBasePlacement(state.placement),
    variation: getVariation(state.placement),
    popper: state.elements.popper,
    popperRect: state.rects.popper,
    gpuAcceleration,
    isFixed: state.options.strategy === "fixed"
  };
  if (state.modifiersData.popperOffsets != null) {
    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
      offsets: state.modifiersData.popperOffsets,
      position: state.options.strategy,
      adaptive,
      roundOffsets
    })));
  }
  if (state.modifiersData.arrow != null) {
    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
      offsets: state.modifiersData.arrow,
      position: "absolute",
      adaptive: false,
      roundOffsets
    })));
  }
  state.attributes.popper = Object.assign({}, state.attributes.popper, {
    "data-popper-placement": state.placement
  });
}
var unsetSides, computeStyles_default;
var init_computeStyles = __esm({
  "node_modules/@popperjs/core/lib/modifiers/computeStyles.js"() {
    init_enums();
    init_getOffsetParent();
    init_getWindow();
    init_getDocumentElement();
    init_getComputedStyle();
    init_getBasePlacement();
    init_getVariation();
    init_math();
    unsetSides = {
      top: "auto",
      right: "auto",
      bottom: "auto",
      left: "auto"
    };
    computeStyles_default = {
      name: "computeStyles",
      enabled: true,
      phase: "beforeWrite",
      fn: computeStyles,
      data: {}
    };
  }
});

// node_modules/@popperjs/core/lib/modifiers/eventListeners.js
function effect3(_ref) {
  var state = _ref.state, instance = _ref.instance, options = _ref.options;
  var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
  var window3 = getWindow2(state.elements.popper);
  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
  if (scroll) {
    scrollParents.forEach(function(scrollParent) {
      scrollParent.addEventListener("scroll", instance.update, passive);
    });
  }
  if (resize) {
    window3.addEventListener("resize", instance.update, passive);
  }
  return function() {
    if (scroll) {
      scrollParents.forEach(function(scrollParent) {
        scrollParent.removeEventListener("scroll", instance.update, passive);
      });
    }
    if (resize) {
      window3.removeEventListener("resize", instance.update, passive);
    }
  };
}
var passive, eventListeners_default;
var init_eventListeners = __esm({
  "node_modules/@popperjs/core/lib/modifiers/eventListeners.js"() {
    init_getWindow();
    passive = {
      passive: true
    };
    eventListeners_default = {
      name: "eventListeners",
      enabled: true,
      phase: "write",
      fn: function fn() {
      },
      effect: effect3,
      data: {}
    };
  }
});

// node_modules/@popperjs/core/lib/utils/getOppositePlacement.js
function getOppositePlacement2(placement) {
  return placement.replace(/left|right|bottom|top/g, function(matched) {
    return hash[matched];
  });
}
var hash;
var init_getOppositePlacement = __esm({
  "node_modules/@popperjs/core/lib/utils/getOppositePlacement.js"() {
    hash = {
      left: "right",
      right: "left",
      bottom: "top",
      top: "bottom"
    };
  }
});

// node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js
function getOppositeVariationPlacement(placement) {
  return placement.replace(/start|end/g, function(matched) {
    return hash2[matched];
  });
}
var hash2;
var init_getOppositeVariationPlacement = __esm({
  "node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js"() {
    hash2 = {
      start: "end",
      end: "start"
    };
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
function getWindowScroll(node) {
  var win = getWindow2(node);
  var scrollLeft = win.pageXOffset;
  var scrollTop = win.pageYOffset;
  return {
    scrollLeft,
    scrollTop
  };
}
var init_getWindowScroll = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js"() {
    init_getWindow();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
function getWindowScrollBarX2(element) {
  return getBoundingClientRect2(getDocumentElement2(element)).left + getWindowScroll(element).scrollLeft;
}
var init_getWindowScrollBarX = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js"() {
    init_getBoundingClientRect();
    init_getDocumentElement();
    init_getWindowScroll();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js
function getViewportRect2(element, strategy) {
  var win = getWindow2(element);
  var html = getDocumentElement2(element);
  var visualViewport = win.visualViewport;
  var width = html.clientWidth;
  var height = html.clientHeight;
  var x2 = 0;
  var y2 = 0;
  if (visualViewport) {
    width = visualViewport.width;
    height = visualViewport.height;
    var layoutViewport = isLayoutViewport();
    if (layoutViewport || !layoutViewport && strategy === "fixed") {
      x2 = visualViewport.offsetLeft;
      y2 = visualViewport.offsetTop;
    }
  }
  return {
    width,
    height,
    x: x2 + getWindowScrollBarX2(element),
    y: y2
  };
}
var init_getViewportRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js"() {
    init_getWindow();
    init_getDocumentElement();
    init_getWindowScrollBarX();
    init_isLayoutViewport();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js
function getDocumentRect2(element) {
  var _element$ownerDocumen;
  var html = getDocumentElement2(element);
  var winScroll = getWindowScroll(element);
  var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
  var width = max2(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
  var height = max2(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
  var x2 = -winScroll.scrollLeft + getWindowScrollBarX2(element);
  var y2 = -winScroll.scrollTop;
  if (getComputedStyle3(body || html).direction === "rtl") {
    x2 += max2(html.clientWidth, body ? body.clientWidth : 0) - width;
  }
  return {
    width,
    height,
    x: x2,
    y: y2
  };
}
var init_getDocumentRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js"() {
    init_getDocumentElement();
    init_getComputedStyle();
    init_getWindowScrollBarX();
    init_getWindowScroll();
    init_math();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
function isScrollParent(element) {
  var _getComputedStyle = getComputedStyle3(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
}
var init_isScrollParent = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js"() {
    init_getComputedStyle();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
function getScrollParent(node) {
  if (["html", "body", "#document"].indexOf(getNodeName2(node)) >= 0) {
    return node.ownerDocument.body;
  }
  if (isHTMLElement3(node) && isScrollParent(node)) {
    return node;
  }
  return getScrollParent(getParentNode2(node));
}
var init_getScrollParent = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js"() {
    init_getParentNode();
    init_isScrollParent();
    init_getNodeName();
    init_instanceOf();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
function listScrollParents(element, list) {
  var _element$ownerDocumen;
  if (list === void 0) {
    list = [];
  }
  var scrollParent = getScrollParent(element);
  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
  var win = getWindow2(scrollParent);
  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
  var updatedList = list.concat(target);
  return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode2(target)));
}
var init_listScrollParents = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js"() {
    init_getScrollParent();
    init_getParentNode();
    init_getWindow();
    init_isScrollParent();
  }
});

// node_modules/@popperjs/core/lib/utils/rectToClientRect.js
function rectToClientRect2(rect) {
  return Object.assign({}, rect, {
    left: rect.x,
    top: rect.y,
    right: rect.x + rect.width,
    bottom: rect.y + rect.height
  });
}
var init_rectToClientRect = __esm({
  "node_modules/@popperjs/core/lib/utils/rectToClientRect.js"() {
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js
function getInnerBoundingClientRect2(element, strategy) {
  var rect = getBoundingClientRect2(element, false, strategy === "fixed");
  rect.top = rect.top + element.clientTop;
  rect.left = rect.left + element.clientLeft;
  rect.bottom = rect.top + element.clientHeight;
  rect.right = rect.left + element.clientWidth;
  rect.width = element.clientWidth;
  rect.height = element.clientHeight;
  rect.x = rect.left;
  rect.y = rect.top;
  return rect;
}
function getClientRectFromMixedType(element, clippingParent, strategy) {
  return clippingParent === viewport ? rectToClientRect2(getViewportRect2(element, strategy)) : isElement2(clippingParent) ? getInnerBoundingClientRect2(clippingParent, strategy) : rectToClientRect2(getDocumentRect2(getDocumentElement2(element)));
}
function getClippingParents(element) {
  var clippingParents2 = listScrollParents(getParentNode2(element));
  var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle3(element).position) >= 0;
  var clipperElement = canEscapeClipping && isHTMLElement3(element) ? getOffsetParent2(element) : element;
  if (!isElement2(clipperElement)) {
    return [];
  }
  return clippingParents2.filter(function(clippingParent) {
    return isElement2(clippingParent) && contains(clippingParent, clipperElement) && getNodeName2(clippingParent) !== "body";
  });
}
function getClippingRect2(element, boundary, rootBoundary, strategy) {
  var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
  var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
  var firstClippingParent = clippingParents2[0];
  var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
    var rect = getClientRectFromMixedType(element, clippingParent, strategy);
    accRect.top = max2(rect.top, accRect.top);
    accRect.right = min3(rect.right, accRect.right);
    accRect.bottom = min3(rect.bottom, accRect.bottom);
    accRect.left = max2(rect.left, accRect.left);
    return accRect;
  }, getClientRectFromMixedType(element, firstClippingParent, strategy));
  clippingRect.width = clippingRect.right - clippingRect.left;
  clippingRect.height = clippingRect.bottom - clippingRect.top;
  clippingRect.x = clippingRect.left;
  clippingRect.y = clippingRect.top;
  return clippingRect;
}
var init_getClippingRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js"() {
    init_enums();
    init_getViewportRect();
    init_getDocumentRect();
    init_listScrollParents();
    init_getOffsetParent();
    init_getDocumentElement();
    init_getComputedStyle();
    init_instanceOf();
    init_getBoundingClientRect();
    init_getParentNode();
    init_contains();
    init_getNodeName();
    init_rectToClientRect();
    init_math();
  }
});

// node_modules/@popperjs/core/lib/utils/computeOffsets.js
function computeOffsets(_ref) {
  var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
  var basePlacement = placement ? getBasePlacement(placement) : null;
  var variation = placement ? getVariation(placement) : null;
  var commonX = reference2.x + reference2.width / 2 - element.width / 2;
  var commonY = reference2.y + reference2.height / 2 - element.height / 2;
  var offsets;
  switch (basePlacement) {
    case top:
      offsets = {
        x: commonX,
        y: reference2.y - element.height
      };
      break;
    case bottom:
      offsets = {
        x: commonX,
        y: reference2.y + reference2.height
      };
      break;
    case right:
      offsets = {
        x: reference2.x + reference2.width,
        y: commonY
      };
      break;
    case left:
      offsets = {
        x: reference2.x - element.width,
        y: commonY
      };
      break;
    default:
      offsets = {
        x: reference2.x,
        y: reference2.y
      };
  }
  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
  if (mainAxis != null) {
    var len = mainAxis === "y" ? "height" : "width";
    switch (variation) {
      case start:
        offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
        break;
      case end:
        offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
        break;
      default:
    }
  }
  return offsets;
}
var init_computeOffsets = __esm({
  "node_modules/@popperjs/core/lib/utils/computeOffsets.js"() {
    init_getBasePlacement();
    init_getVariation();
    init_getMainAxisFromPlacement();
    init_enums();
  }
});

// node_modules/@popperjs/core/lib/utils/detectOverflow.js
function detectOverflow3(state, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
  var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
  var altContext = elementContext === popper ? reference : popper;
  var popperRect = state.rects.popper;
  var element = state.elements[altBoundary ? altContext : elementContext];
  var clippingClientRect = getClippingRect2(isElement2(element) ? element : element.contextElement || getDocumentElement2(state.elements.popper), boundary, rootBoundary, strategy);
  var referenceClientRect = getBoundingClientRect2(state.elements.reference);
  var popperOffsets2 = computeOffsets({
    reference: referenceClientRect,
    element: popperRect,
    strategy: "absolute",
    placement
  });
  var popperClientRect = rectToClientRect2(Object.assign({}, popperRect, popperOffsets2));
  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
  var overflowOffsets = {
    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
  };
  var offsetData = state.modifiersData.offset;
  if (elementContext === popper && offsetData) {
    var offset5 = offsetData[placement];
    Object.keys(overflowOffsets).forEach(function(key) {
      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
      var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
      overflowOffsets[key] += offset5[axis] * multiply;
    });
  }
  return overflowOffsets;
}
var init_detectOverflow = __esm({
  "node_modules/@popperjs/core/lib/utils/detectOverflow.js"() {
    init_getClippingRect();
    init_getDocumentElement();
    init_getBoundingClientRect();
    init_computeOffsets();
    init_rectToClientRect();
    init_enums();
    init_instanceOf();
    init_mergePaddingObject();
    init_expandToHashMap();
  }
});

// node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js
function computeAutoPlacement(state, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements2 : _options$allowedAutoP;
  var variation = getVariation(placement);
  var placements3 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
    return getVariation(placement2) === variation;
  }) : basePlacements;
  var allowedPlacements = placements3.filter(function(placement2) {
    return allowedAutoPlacements.indexOf(placement2) >= 0;
  });
  if (allowedPlacements.length === 0) {
    allowedPlacements = placements3;
  }
  var overflows = allowedPlacements.reduce(function(acc, placement2) {
    acc[placement2] = detectOverflow3(state, {
      placement: placement2,
      boundary,
      rootBoundary,
      padding
    })[getBasePlacement(placement2)];
    return acc;
  }, {});
  return Object.keys(overflows).sort(function(a2, b2) {
    return overflows[a2] - overflows[b2];
  });
}
var init_computeAutoPlacement = __esm({
  "node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js"() {
    init_getVariation();
    init_enums();
    init_detectOverflow();
    init_getBasePlacement();
  }
});

// node_modules/@popperjs/core/lib/modifiers/flip.js
function getExpandedFallbackPlacements(placement) {
  if (getBasePlacement(placement) === auto) {
    return [];
  }
  var oppositePlacement = getOppositePlacement2(placement);
  return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
}
function flip4(_ref) {
  var state = _ref.state, options = _ref.options, name = _ref.name;
  if (state.modifiersData[name]._skip) {
    return;
  }
  var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
  var preferredPlacement = state.options.placement;
  var basePlacement = getBasePlacement(preferredPlacement);
  var isBasePlacement = basePlacement === preferredPlacement;
  var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement2(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
  var placements3 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
    return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
      placement: placement2,
      boundary,
      rootBoundary,
      padding,
      flipVariations,
      allowedAutoPlacements
    }) : placement2);
  }, []);
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var checksMap = /* @__PURE__ */ new Map();
  var makeFallbackChecks = true;
  var firstFittingPlacement = placements3[0];
  for (var i2 = 0; i2 < placements3.length; i2++) {
    var placement = placements3[i2];
    var _basePlacement = getBasePlacement(placement);
    var isStartVariation = getVariation(placement) === start;
    var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
    var len = isVertical ? "width" : "height";
    var overflow = detectOverflow3(state, {
      placement,
      boundary,
      rootBoundary,
      altBoundary,
      padding
    });
    var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
    if (referenceRect[len] > popperRect[len]) {
      mainVariationSide = getOppositePlacement2(mainVariationSide);
    }
    var altVariationSide = getOppositePlacement2(mainVariationSide);
    var checks = [];
    if (checkMainAxis) {
      checks.push(overflow[_basePlacement] <= 0);
    }
    if (checkAltAxis) {
      checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
    }
    if (checks.every(function(check) {
      return check;
    })) {
      firstFittingPlacement = placement;
      makeFallbackChecks = false;
      break;
    }
    checksMap.set(placement, checks);
  }
  if (makeFallbackChecks) {
    var numberOfChecks = flipVariations ? 3 : 1;
    var _loop = function _loop2(_i2) {
      var fittingPlacement = placements3.find(function(placement2) {
        var checks2 = checksMap.get(placement2);
        if (checks2) {
          return checks2.slice(0, _i2).every(function(check) {
            return check;
          });
        }
      });
      if (fittingPlacement) {
        firstFittingPlacement = fittingPlacement;
        return "break";
      }
    };
    for (var _i = numberOfChecks; _i > 0; _i--) {
      var _ret = _loop(_i);
      if (_ret === "break")
        break;
    }
  }
  if (state.placement !== firstFittingPlacement) {
    state.modifiersData[name]._skip = true;
    state.placement = firstFittingPlacement;
    state.reset = true;
  }
}
var flip_default;
var init_flip = __esm({
  "node_modules/@popperjs/core/lib/modifiers/flip.js"() {
    init_getOppositePlacement();
    init_getBasePlacement();
    init_getOppositeVariationPlacement();
    init_detectOverflow();
    init_computeAutoPlacement();
    init_enums();
    init_getVariation();
    flip_default = {
      name: "flip",
      enabled: true,
      phase: "main",
      fn: flip4,
      requiresIfExists: ["offset"],
      data: {
        _skip: false
      }
    };
  }
});

// node_modules/@popperjs/core/lib/modifiers/hide.js
function getSideOffsets2(overflow, rect, preventedOffsets) {
  if (preventedOffsets === void 0) {
    preventedOffsets = {
      x: 0,
      y: 0
    };
  }
  return {
    top: overflow.top - rect.height - preventedOffsets.y,
    right: overflow.right - rect.width + preventedOffsets.x,
    bottom: overflow.bottom - rect.height + preventedOffsets.y,
    left: overflow.left - rect.width - preventedOffsets.x
  };
}
function isAnySideFullyClipped2(overflow) {
  return [top, right, bottom, left].some(function(side) {
    return overflow[side] >= 0;
  });
}
function hide4(_ref) {
  var state = _ref.state, name = _ref.name;
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var preventedOffsets = state.modifiersData.preventOverflow;
  var referenceOverflow = detectOverflow3(state, {
    elementContext: "reference"
  });
  var popperAltOverflow = detectOverflow3(state, {
    altBoundary: true
  });
  var referenceClippingOffsets = getSideOffsets2(referenceOverflow, referenceRect);
  var popperEscapeOffsets = getSideOffsets2(popperAltOverflow, popperRect, preventedOffsets);
  var isReferenceHidden = isAnySideFullyClipped2(referenceClippingOffsets);
  var hasPopperEscaped = isAnySideFullyClipped2(popperEscapeOffsets);
  state.modifiersData[name] = {
    referenceClippingOffsets,
    popperEscapeOffsets,
    isReferenceHidden,
    hasPopperEscaped
  };
  state.attributes.popper = Object.assign({}, state.attributes.popper, {
    "data-popper-reference-hidden": isReferenceHidden,
    "data-popper-escaped": hasPopperEscaped
  });
}
var hide_default;
var init_hide = __esm({
  "node_modules/@popperjs/core/lib/modifiers/hide.js"() {
    init_enums();
    init_detectOverflow();
    hide_default = {
      name: "hide",
      enabled: true,
      phase: "main",
      requiresIfExists: ["preventOverflow"],
      fn: hide4
    };
  }
});

// node_modules/@popperjs/core/lib/modifiers/offset.js
function distanceAndSkiddingToXY(placement, rects, offset5) {
  var basePlacement = getBasePlacement(placement);
  var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
  var _ref = typeof offset5 === "function" ? offset5(Object.assign({}, rects, {
    placement
  })) : offset5, skidding = _ref[0], distance = _ref[1];
  skidding = skidding || 0;
  distance = (distance || 0) * invertDistance;
  return [left, right].indexOf(basePlacement) >= 0 ? {
    x: distance,
    y: skidding
  } : {
    x: skidding,
    y: distance
  };
}
function offset4(_ref2) {
  var state = _ref2.state, options = _ref2.options, name = _ref2.name;
  var _options$offset = options.offset, offset5 = _options$offset === void 0 ? [0, 0] : _options$offset;
  var data = placements2.reduce(function(acc, placement) {
    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset5);
    return acc;
  }, {});
  var _data$state$placement = data[state.placement], x2 = _data$state$placement.x, y2 = _data$state$placement.y;
  if (state.modifiersData.popperOffsets != null) {
    state.modifiersData.popperOffsets.x += x2;
    state.modifiersData.popperOffsets.y += y2;
  }
  state.modifiersData[name] = data;
}
var offset_default;
var init_offset = __esm({
  "node_modules/@popperjs/core/lib/modifiers/offset.js"() {
    init_getBasePlacement();
    init_enums();
    offset_default = {
      name: "offset",
      enabled: true,
      phase: "main",
      requires: ["popperOffsets"],
      fn: offset4
    };
  }
});

// node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
function popperOffsets(_ref) {
  var state = _ref.state, name = _ref.name;
  state.modifiersData[name] = computeOffsets({
    reference: state.rects.reference,
    element: state.rects.popper,
    strategy: "absolute",
    placement: state.placement
  });
}
var popperOffsets_default;
var init_popperOffsets = __esm({
  "node_modules/@popperjs/core/lib/modifiers/popperOffsets.js"() {
    init_computeOffsets();
    popperOffsets_default = {
      name: "popperOffsets",
      enabled: true,
      phase: "read",
      fn: popperOffsets,
      data: {}
    };
  }
});

// node_modules/@popperjs/core/lib/utils/getAltAxis.js
function getAltAxis(axis) {
  return axis === "x" ? "y" : "x";
}
var init_getAltAxis = __esm({
  "node_modules/@popperjs/core/lib/utils/getAltAxis.js"() {
  }
});

// node_modules/@popperjs/core/lib/modifiers/preventOverflow.js
function preventOverflow(_ref) {
  var state = _ref.state, options = _ref.options, name = _ref.name;
  var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
  var overflow = detectOverflow3(state, {
    boundary,
    rootBoundary,
    padding,
    altBoundary
  });
  var basePlacement = getBasePlacement(state.placement);
  var variation = getVariation(state.placement);
  var isBasePlacement = !variation;
  var mainAxis = getMainAxisFromPlacement(basePlacement);
  var altAxis = getAltAxis(mainAxis);
  var popperOffsets2 = state.modifiersData.popperOffsets;
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
    placement: state.placement
  })) : tetherOffset;
  var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
    mainAxis: tetherOffsetValue,
    altAxis: tetherOffsetValue
  } : Object.assign({
    mainAxis: 0,
    altAxis: 0
  }, tetherOffsetValue);
  var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
  var data = {
    x: 0,
    y: 0
  };
  if (!popperOffsets2) {
    return;
  }
  if (checkMainAxis) {
    var _offsetModifierState$;
    var mainSide = mainAxis === "y" ? top : left;
    var altSide = mainAxis === "y" ? bottom : right;
    var len = mainAxis === "y" ? "height" : "width";
    var offset5 = popperOffsets2[mainAxis];
    var min4 = offset5 + overflow[mainSide];
    var max3 = offset5 - overflow[altSide];
    var additive = tether ? -popperRect[len] / 2 : 0;
    var minLen = variation === start ? referenceRect[len] : popperRect[len];
    var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
    var arrowElement = state.elements.arrow;
    var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
      width: 0,
      height: 0
    };
    var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
    var arrowPaddingMin = arrowPaddingObject[mainSide];
    var arrowPaddingMax = arrowPaddingObject[altSide];
    var arrowLen = within(0, referenceRect[len], arrowRect[len]);
    var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
    var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
    var arrowOffsetParent = state.elements.arrow && getOffsetParent2(state.elements.arrow);
    var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
    var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
    var tetherMin = offset5 + minOffset - offsetModifierValue - clientOffset;
    var tetherMax = offset5 + maxOffset - offsetModifierValue;
    var preventedOffset = within(tether ? min3(min4, tetherMin) : min4, offset5, tether ? max2(max3, tetherMax) : max3);
    popperOffsets2[mainAxis] = preventedOffset;
    data[mainAxis] = preventedOffset - offset5;
  }
  if (checkAltAxis) {
    var _offsetModifierState$2;
    var _mainSide = mainAxis === "x" ? top : left;
    var _altSide = mainAxis === "x" ? bottom : right;
    var _offset = popperOffsets2[altAxis];
    var _len = altAxis === "y" ? "height" : "width";
    var _min = _offset + overflow[_mainSide];
    var _max = _offset - overflow[_altSide];
    var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
    var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
    var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
    var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
    var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
    popperOffsets2[altAxis] = _preventedOffset;
    data[altAxis] = _preventedOffset - _offset;
  }
  state.modifiersData[name] = data;
}
var preventOverflow_default;
var init_preventOverflow = __esm({
  "node_modules/@popperjs/core/lib/modifiers/preventOverflow.js"() {
    init_enums();
    init_getBasePlacement();
    init_getMainAxisFromPlacement();
    init_getAltAxis();
    init_within();
    init_getLayoutRect();
    init_getOffsetParent();
    init_detectOverflow();
    init_getVariation();
    init_getFreshSideObject();
    init_math();
    preventOverflow_default = {
      name: "preventOverflow",
      enabled: true,
      phase: "main",
      fn: preventOverflow,
      requiresIfExists: ["offset"]
    };
  }
});

// node_modules/@popperjs/core/lib/modifiers/index.js
var init_modifiers = __esm({
  "node_modules/@popperjs/core/lib/modifiers/index.js"() {
    init_applyStyles();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
function getHTMLElementScroll(element) {
  return {
    scrollLeft: element.scrollLeft,
    scrollTop: element.scrollTop
  };
}
var init_getHTMLElementScroll = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js"() {
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
function getNodeScroll2(node) {
  if (node === getWindow2(node) || !isHTMLElement3(node)) {
    return getWindowScroll(node);
  } else {
    return getHTMLElementScroll(node);
  }
}
var init_getNodeScroll = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js"() {
    init_getWindowScroll();
    init_getWindow();
    init_instanceOf();
    init_getHTMLElementScroll();
  }
});

// node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
function isElementScaled(element) {
  var rect = element.getBoundingClientRect();
  var scaleX = round3(rect.width) / element.offsetWidth || 1;
  var scaleY = round3(rect.height) / element.offsetHeight || 1;
  return scaleX !== 1 || scaleY !== 1;
}
function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
  if (isFixed === void 0) {
    isFixed = false;
  }
  var isOffsetParentAnElement = isHTMLElement3(offsetParent);
  var offsetParentIsScaled = isHTMLElement3(offsetParent) && isElementScaled(offsetParent);
  var documentElement = getDocumentElement2(offsetParent);
  var rect = getBoundingClientRect2(elementOrVirtualElement, offsetParentIsScaled, isFixed);
  var scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  var offsets = {
    x: 0,
    y: 0
  };
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName2(offsetParent) !== "body" || isScrollParent(documentElement)) {
      scroll = getNodeScroll2(offsetParent);
    }
    if (isHTMLElement3(offsetParent)) {
      offsets = getBoundingClientRect2(offsetParent, true);
      offsets.x += offsetParent.clientLeft;
      offsets.y += offsetParent.clientTop;
    } else if (documentElement) {
      offsets.x = getWindowScrollBarX2(documentElement);
    }
  }
  return {
    x: rect.left + scroll.scrollLeft - offsets.x,
    y: rect.top + scroll.scrollTop - offsets.y,
    width: rect.width,
    height: rect.height
  };
}
var init_getCompositeRect = __esm({
  "node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js"() {
    init_getBoundingClientRect();
    init_getNodeScroll();
    init_getNodeName();
    init_instanceOf();
    init_getWindowScrollBarX();
    init_getDocumentElement();
    init_isScrollParent();
    init_math();
  }
});

// node_modules/@popperjs/core/lib/utils/orderModifiers.js
function order(modifiers) {
  var map = /* @__PURE__ */ new Map();
  var visited = /* @__PURE__ */ new Set();
  var result = [];
  modifiers.forEach(function(modifier) {
    map.set(modifier.name, modifier);
  });
  function sort(modifier) {
    visited.add(modifier.name);
    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
    requires.forEach(function(dep) {
      if (!visited.has(dep)) {
        var depModifier = map.get(dep);
        if (depModifier) {
          sort(depModifier);
        }
      }
    });
    result.push(modifier);
  }
  modifiers.forEach(function(modifier) {
    if (!visited.has(modifier.name)) {
      sort(modifier);
    }
  });
  return result;
}
function orderModifiers(modifiers) {
  var orderedModifiers = order(modifiers);
  return modifierPhases.reduce(function(acc, phase2) {
    return acc.concat(orderedModifiers.filter(function(modifier) {
      return modifier.phase === phase2;
    }));
  }, []);
}
var init_orderModifiers = __esm({
  "node_modules/@popperjs/core/lib/utils/orderModifiers.js"() {
    init_enums();
  }
});

// node_modules/@popperjs/core/lib/utils/debounce.js
function debounce5(fn3) {
  var pending;
  return function() {
    if (!pending) {
      pending = new Promise(function(resolve) {
        Promise.resolve().then(function() {
          pending = void 0;
          resolve(fn3());
        });
      });
    }
    return pending;
  };
}
var init_debounce5 = __esm({
  "node_modules/@popperjs/core/lib/utils/debounce.js"() {
  }
});

// node_modules/@popperjs/core/lib/utils/mergeByName.js
function mergeByName(modifiers) {
  var merged = modifiers.reduce(function(merged2, current) {
    var existing = merged2[current.name];
    merged2[current.name] = existing ? Object.assign({}, existing, current, {
      options: Object.assign({}, existing.options, current.options),
      data: Object.assign({}, existing.data, current.data)
    }) : current;
    return merged2;
  }, {});
  return Object.keys(merged).map(function(key) {
    return merged[key];
  });
}
var init_mergeByName = __esm({
  "node_modules/@popperjs/core/lib/utils/mergeByName.js"() {
  }
});

// node_modules/@popperjs/core/lib/createPopper.js
function areValidElements() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  return !args.some(function(element) {
    return !(element && typeof element.getBoundingClientRect === "function");
  });
}
function popperGenerator(generatorOptions) {
  if (generatorOptions === void 0) {
    generatorOptions = {};
  }
  var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
  return function createPopper2(reference2, popper2, options) {
    if (options === void 0) {
      options = defaultOptions;
    }
    var state = {
      placement: "bottom",
      orderedModifiers: [],
      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
      modifiersData: {},
      elements: {
        reference: reference2,
        popper: popper2
      },
      attributes: {},
      styles: {}
    };
    var effectCleanupFns = [];
    var isDestroyed = false;
    var instance = {
      state,
      setOptions: function setOptions(setOptionsAction) {
        var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
        cleanupModifierEffects();
        state.options = Object.assign({}, defaultOptions, state.options, options2);
        state.scrollParents = {
          reference: isElement2(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
          popper: listScrollParents(popper2)
        };
        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
        state.orderedModifiers = orderedModifiers.filter(function(m2) {
          return m2.enabled;
        });
        runModifierEffects();
        return instance.update();
      },
      forceUpdate: function forceUpdate() {
        if (isDestroyed) {
          return;
        }
        var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
        if (!areValidElements(reference3, popper3)) {
          return;
        }
        state.rects = {
          reference: getCompositeRect(reference3, getOffsetParent2(popper3), state.options.strategy === "fixed"),
          popper: getLayoutRect(popper3)
        };
        state.reset = false;
        state.placement = state.options.placement;
        state.orderedModifiers.forEach(function(modifier) {
          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
        });
        for (var index3 = 0; index3 < state.orderedModifiers.length; index3++) {
          if (state.reset === true) {
            state.reset = false;
            index3 = -1;
            continue;
          }
          var _state$orderedModifie = state.orderedModifiers[index3], fn3 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
          if (typeof fn3 === "function") {
            state = fn3({
              state,
              options: _options,
              name,
              instance
            }) || state;
          }
        }
      },
      update: debounce5(function() {
        return new Promise(function(resolve) {
          instance.forceUpdate();
          resolve(state);
        });
      }),
      destroy: function destroy() {
        cleanupModifierEffects();
        isDestroyed = true;
      }
    };
    if (!areValidElements(reference2, popper2)) {
      return instance;
    }
    instance.setOptions(options).then(function(state2) {
      if (!isDestroyed && options.onFirstUpdate) {
        options.onFirstUpdate(state2);
      }
    });
    function runModifierEffects() {
      state.orderedModifiers.forEach(function(_ref) {
        var name = _ref.name, _ref$options = _ref.options, options2 = _ref$options === void 0 ? {} : _ref$options, effect5 = _ref.effect;
        if (typeof effect5 === "function") {
          var cleanupFn = effect5({
            state,
            name,
            instance,
            options: options2
          });
          var noopFn = function noopFn2() {
          };
          effectCleanupFns.push(cleanupFn || noopFn);
        }
      });
    }
    function cleanupModifierEffects() {
      effectCleanupFns.forEach(function(fn3) {
        return fn3();
      });
      effectCleanupFns = [];
    }
    return instance;
  };
}
var DEFAULT_OPTIONS;
var init_createPopper = __esm({
  "node_modules/@popperjs/core/lib/createPopper.js"() {
    init_getCompositeRect();
    init_getLayoutRect();
    init_listScrollParents();
    init_getOffsetParent();
    init_orderModifiers();
    init_debounce5();
    init_mergeByName();
    init_instanceOf();
    DEFAULT_OPTIONS = {
      placement: "bottom",
      modifiers: [],
      strategy: "absolute"
    };
  }
});

// node_modules/@popperjs/core/lib/popper.js
var defaultModifiers, createPopper;
var init_popper = __esm({
  "node_modules/@popperjs/core/lib/popper.js"() {
    init_createPopper();
    init_eventListeners();
    init_popperOffsets();
    init_computeStyles();
    init_applyStyles();
    init_offset();
    init_flip();
    init_preventOverflow();
    init_arrow();
    init_hide();
    init_modifiers();
    defaultModifiers = [eventListeners_default, popperOffsets_default, computeStyles_default, applyStyles_default, offset_default, flip_default, preventOverflow_default, arrow_default, hide_default];
    createPopper = /* @__PURE__ */ popperGenerator({
      defaultModifiers
    });
  }
});

// node_modules/@popperjs/core/lib/index.js
var init_lib = __esm({
  "node_modules/@popperjs/core/lib/index.js"() {
    init_enums();
    init_modifiers();
    init_popper();
  }
});

// node_modules/tippy.js/dist/tippy.esm.js
function getValueAtIndexOrReturn(value, index3, defaultValue) {
  if (Array.isArray(value)) {
    var v2 = value[index3];
    return v2 == null ? Array.isArray(defaultValue) ? defaultValue[index3] : defaultValue : v2;
  }
  return value;
}
function isType(value, type) {
  var str = {}.toString.call(value);
  return str.indexOf("[object") === 0 && str.indexOf(type + "]") > -1;
}
function invokeWithArgsOrReturn(value, args) {
  return typeof value === "function" ? value.apply(void 0, args) : value;
}
function debounce6(fn3, ms) {
  if (ms === 0) {
    return fn3;
  }
  var timeout;
  return function(arg) {
    clearTimeout(timeout);
    timeout = setTimeout(function() {
      fn3(arg);
    }, ms);
  };
}
function splitBySpaces(value) {
  return value.split(/\s+/).filter(Boolean);
}
function normalizeToArray(value) {
  return [].concat(value);
}
function pushIfUnique(arr, value) {
  if (arr.indexOf(value) === -1) {
    arr.push(value);
  }
}
function unique(arr) {
  return arr.filter(function(item, index3) {
    return arr.indexOf(item) === index3;
  });
}
function getBasePlacement2(placement) {
  return placement.split("-")[0];
}
function arrayFrom(value) {
  return [].slice.call(value);
}
function removeUndefinedProps(obj) {
  return Object.keys(obj).reduce(function(acc, key) {
    if (obj[key] !== void 0) {
      acc[key] = obj[key];
    }
    return acc;
  }, {});
}
function div() {
  return document.createElement("div");
}
function isElement3(value) {
  return ["Element", "Fragment"].some(function(type) {
    return isType(value, type);
  });
}
function isNodeList(value) {
  return isType(value, "NodeList");
}
function isMouseEvent(value) {
  return isType(value, "MouseEvent");
}
function isReferenceElement(value) {
  return !!(value && value._tippy && value._tippy.reference === value);
}
function getArrayOfElements(value) {
  if (isElement3(value)) {
    return [value];
  }
  if (isNodeList(value)) {
    return arrayFrom(value);
  }
  if (Array.isArray(value)) {
    return value;
  }
  return arrayFrom(document.querySelectorAll(value));
}
function setTransitionDuration(els, value) {
  els.forEach(function(el) {
    if (el) {
      el.style.transitionDuration = value + "ms";
    }
  });
}
function setVisibilityState(els, state) {
  els.forEach(function(el) {
    if (el) {
      el.setAttribute("data-state", state);
    }
  });
}
function getOwnerDocument(elementOrElements) {
  var _element$ownerDocumen;
  var _normalizeToArray = normalizeToArray(elementOrElements), element = _normalizeToArray[0];
  return element != null && (_element$ownerDocumen = element.ownerDocument) != null && _element$ownerDocumen.body ? element.ownerDocument : document;
}
function isCursorOutsideInteractiveBorder(popperTreeData, event) {
  var clientX = event.clientX, clientY = event.clientY;
  return popperTreeData.every(function(_ref) {
    var popperRect = _ref.popperRect, popperState = _ref.popperState, props = _ref.props;
    var interactiveBorder = props.interactiveBorder;
    var basePlacement = getBasePlacement2(popperState.placement);
    var offsetData = popperState.modifiersData.offset;
    if (!offsetData) {
      return true;
    }
    var topDistance = basePlacement === "bottom" ? offsetData.top.y : 0;
    var bottomDistance = basePlacement === "top" ? offsetData.bottom.y : 0;
    var leftDistance = basePlacement === "right" ? offsetData.left.x : 0;
    var rightDistance = basePlacement === "left" ? offsetData.right.x : 0;
    var exceedsTop = popperRect.top - clientY + topDistance > interactiveBorder;
    var exceedsBottom = clientY - popperRect.bottom - bottomDistance > interactiveBorder;
    var exceedsLeft = popperRect.left - clientX + leftDistance > interactiveBorder;
    var exceedsRight = clientX - popperRect.right - rightDistance > interactiveBorder;
    return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;
  });
}
function updateTransitionEndListener(box, action, listener) {
  var method = action + "EventListener";
  ["transitionend", "webkitTransitionEnd"].forEach(function(event) {
    box[method](event, listener);
  });
}
function actualContains(parent, child) {
  var target = child;
  while (target) {
    var _target$getRootNode;
    if (parent.contains(target)) {
      return true;
    }
    target = target.getRootNode == null ? void 0 : (_target$getRootNode = target.getRootNode()) == null ? void 0 : _target$getRootNode.host;
  }
  return false;
}
function onDocumentTouchStart() {
  if (currentInput.isTouch) {
    return;
  }
  currentInput.isTouch = true;
  if (window.performance) {
    document.addEventListener("mousemove", onDocumentMouseMove);
  }
}
function onDocumentMouseMove() {
  var now = performance.now();
  if (now - lastMouseMoveTime < 20) {
    currentInput.isTouch = false;
    document.removeEventListener("mousemove", onDocumentMouseMove);
  }
  lastMouseMoveTime = now;
}
function onWindowBlur() {
  var activeElement = document.activeElement;
  if (isReferenceElement(activeElement)) {
    var instance = activeElement._tippy;
    if (activeElement.blur && !instance.state.isVisible) {
      activeElement.blur();
    }
  }
}
function bindGlobalEventListeners() {
  document.addEventListener("touchstart", onDocumentTouchStart, TOUCH_OPTIONS);
  window.addEventListener("blur", onWindowBlur);
}
function getExtendedPassedProps(passedProps) {
  var plugins = passedProps.plugins || [];
  var pluginProps2 = plugins.reduce(function(acc, plugin) {
    var name = plugin.name, defaultValue = plugin.defaultValue;
    if (name) {
      var _name;
      acc[name] = passedProps[name] !== void 0 ? passedProps[name] : (_name = defaultProps[name]) != null ? _name : defaultValue;
    }
    return acc;
  }, {});
  return Object.assign({}, passedProps, pluginProps2);
}
function getDataAttributeProps(reference2, plugins) {
  var propKeys = plugins ? Object.keys(getExtendedPassedProps(Object.assign({}, defaultProps, {
    plugins
  }))) : defaultKeys;
  var props = propKeys.reduce(function(acc, key) {
    var valueAsString = (reference2.getAttribute("data-tippy-" + key) || "").trim();
    if (!valueAsString) {
      return acc;
    }
    if (key === "content") {
      acc[key] = valueAsString;
    } else {
      try {
        acc[key] = JSON.parse(valueAsString);
      } catch (e2) {
        acc[key] = valueAsString;
      }
    }
    return acc;
  }, {});
  return props;
}
function evaluateProps(reference2, props) {
  var out = Object.assign({}, props, {
    content: invokeWithArgsOrReturn(props.content, [reference2])
  }, props.ignoreAttributes ? {} : getDataAttributeProps(reference2, props.plugins));
  out.aria = Object.assign({}, defaultProps.aria, out.aria);
  out.aria = {
    expanded: out.aria.expanded === "auto" ? props.interactive : out.aria.expanded,
    content: out.aria.content === "auto" ? props.interactive ? null : "describedby" : out.aria.content
  };
  return out;
}
function dangerouslySetInnerHTML(element, html) {
  element[innerHTML()] = html;
}
function createArrowElement(value) {
  var arrow5 = div();
  if (value === true) {
    arrow5.className = ARROW_CLASS;
  } else {
    arrow5.className = SVG_ARROW_CLASS;
    if (isElement3(value)) {
      arrow5.appendChild(value);
    } else {
      dangerouslySetInnerHTML(arrow5, value);
    }
  }
  return arrow5;
}
function setContent(content, props) {
  if (isElement3(props.content)) {
    dangerouslySetInnerHTML(content, "");
    content.appendChild(props.content);
  } else if (typeof props.content !== "function") {
    if (props.allowHTML) {
      dangerouslySetInnerHTML(content, props.content);
    } else {
      content.textContent = props.content;
    }
  }
}
function getChildren(popper2) {
  var box = popper2.firstElementChild;
  var boxChildren = arrayFrom(box.children);
  return {
    box,
    content: boxChildren.find(function(node) {
      return node.classList.contains(CONTENT_CLASS);
    }),
    arrow: boxChildren.find(function(node) {
      return node.classList.contains(ARROW_CLASS) || node.classList.contains(SVG_ARROW_CLASS);
    }),
    backdrop: boxChildren.find(function(node) {
      return node.classList.contains(BACKDROP_CLASS);
    })
  };
}
function render(instance) {
  var popper2 = div();
  var box = div();
  box.className = BOX_CLASS;
  box.setAttribute("data-state", "hidden");
  box.setAttribute("tabindex", "-1");
  var content = div();
  content.className = CONTENT_CLASS;
  content.setAttribute("data-state", "hidden");
  setContent(content, instance.props);
  popper2.appendChild(box);
  box.appendChild(content);
  onUpdate(instance.props, instance.props);
  function onUpdate(prevProps, nextProps) {
    var _getChildren = getChildren(popper2), box2 = _getChildren.box, content2 = _getChildren.content, arrow5 = _getChildren.arrow;
    if (nextProps.theme) {
      box2.setAttribute("data-theme", nextProps.theme);
    } else {
      box2.removeAttribute("data-theme");
    }
    if (typeof nextProps.animation === "string") {
      box2.setAttribute("data-animation", nextProps.animation);
    } else {
      box2.removeAttribute("data-animation");
    }
    if (nextProps.inertia) {
      box2.setAttribute("data-inertia", "");
    } else {
      box2.removeAttribute("data-inertia");
    }
    box2.style.maxWidth = typeof nextProps.maxWidth === "number" ? nextProps.maxWidth + "px" : nextProps.maxWidth;
    if (nextProps.role) {
      box2.setAttribute("role", nextProps.role);
    } else {
      box2.removeAttribute("role");
    }
    if (prevProps.content !== nextProps.content || prevProps.allowHTML !== nextProps.allowHTML) {
      setContent(content2, instance.props);
    }
    if (nextProps.arrow) {
      if (!arrow5) {
        box2.appendChild(createArrowElement(nextProps.arrow));
      } else if (prevProps.arrow !== nextProps.arrow) {
        box2.removeChild(arrow5);
        box2.appendChild(createArrowElement(nextProps.arrow));
      }
    } else if (arrow5) {
      box2.removeChild(arrow5);
    }
  }
  return {
    popper: popper2,
    onUpdate
  };
}
function createTippy(reference2, passedProps) {
  var props = evaluateProps(reference2, Object.assign({}, defaultProps, getExtendedPassedProps(removeUndefinedProps(passedProps))));
  var showTimeout;
  var hideTimeout;
  var scheduleHideAnimationFrame;
  var isVisibleFromClick = false;
  var didHideDueToDocumentMouseDown = false;
  var didTouchMove = false;
  var ignoreOnFirstUpdate = false;
  var lastTriggerEvent;
  var currentTransitionEndListener;
  var onFirstUpdate;
  var listeners = [];
  var debouncedOnMouseMove = debounce6(onMouseMove, props.interactiveDebounce);
  var currentTarget;
  var id = idCounter2++;
  var popperInstance = null;
  var plugins = unique(props.plugins);
  var state = {
    isEnabled: true,
    isVisible: false,
    isDestroyed: false,
    isMounted: false,
    isShown: false
  };
  var instance = {
    id,
    reference: reference2,
    popper: div(),
    popperInstance,
    props,
    state,
    plugins,
    clearDelayTimeouts,
    setProps,
    setContent: setContent2,
    show,
    hide: hide5,
    hideWithInteractivity,
    enable,
    disable,
    unmount,
    destroy
  };
  if (!props.render) {
    if (false) {
      errorWhen(true, "render() function has not been supplied.");
    }
    return instance;
  }
  var _props$render = props.render(instance), popper2 = _props$render.popper, onUpdate = _props$render.onUpdate;
  popper2.setAttribute("data-tippy-root", "");
  popper2.id = "tippy-" + instance.id;
  instance.popper = popper2;
  reference2._tippy = instance;
  popper2._tippy = instance;
  var pluginsHooks = plugins.map(function(plugin) {
    return plugin.fn(instance);
  });
  var hasAriaExpanded = reference2.hasAttribute("aria-expanded");
  addListeners();
  handleAriaExpandedAttribute();
  handleStyles();
  invokeHook("onCreate", [instance]);
  if (props.showOnCreate) {
    scheduleShow();
  }
  popper2.addEventListener("mouseenter", function() {
    if (instance.props.interactive && instance.state.isVisible) {
      instance.clearDelayTimeouts();
    }
  });
  popper2.addEventListener("mouseleave", function() {
    if (instance.props.interactive && instance.props.trigger.indexOf("mouseenter") >= 0) {
      getDocument().addEventListener("mousemove", debouncedOnMouseMove);
    }
  });
  return instance;
  function getNormalizedTouchSettings() {
    var touch = instance.props.touch;
    return Array.isArray(touch) ? touch : [touch, 0];
  }
  function getIsCustomTouchBehavior() {
    return getNormalizedTouchSettings()[0] === "hold";
  }
  function getIsDefaultRenderFn() {
    var _instance$props$rende;
    return !!((_instance$props$rende = instance.props.render) != null && _instance$props$rende.$$tippy);
  }
  function getCurrentTarget() {
    return currentTarget || reference2;
  }
  function getDocument() {
    var parent = getCurrentTarget().parentNode;
    return parent ? getOwnerDocument(parent) : document;
  }
  function getDefaultTemplateChildren() {
    return getChildren(popper2);
  }
  function getDelay(isShow) {
    if (instance.state.isMounted && !instance.state.isVisible || currentInput.isTouch || lastTriggerEvent && lastTriggerEvent.type === "focus") {
      return 0;
    }
    return getValueAtIndexOrReturn(instance.props.delay, isShow ? 0 : 1, defaultProps.delay);
  }
  function handleStyles(fromHide) {
    if (fromHide === void 0) {
      fromHide = false;
    }
    popper2.style.pointerEvents = instance.props.interactive && !fromHide ? "" : "none";
    popper2.style.zIndex = "" + instance.props.zIndex;
  }
  function invokeHook(hook, args, shouldInvokePropsHook) {
    if (shouldInvokePropsHook === void 0) {
      shouldInvokePropsHook = true;
    }
    pluginsHooks.forEach(function(pluginHooks) {
      if (pluginHooks[hook]) {
        pluginHooks[hook].apply(pluginHooks, args);
      }
    });
    if (shouldInvokePropsHook) {
      var _instance$props;
      (_instance$props = instance.props)[hook].apply(_instance$props, args);
    }
  }
  function handleAriaContentAttribute() {
    var aria = instance.props.aria;
    if (!aria.content) {
      return;
    }
    var attr = "aria-" + aria.content;
    var id2 = popper2.id;
    var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
    nodes.forEach(function(node) {
      var currentValue = node.getAttribute(attr);
      if (instance.state.isVisible) {
        node.setAttribute(attr, currentValue ? currentValue + " " + id2 : id2);
      } else {
        var nextValue = currentValue && currentValue.replace(id2, "").trim();
        if (nextValue) {
          node.setAttribute(attr, nextValue);
        } else {
          node.removeAttribute(attr);
        }
      }
    });
  }
  function handleAriaExpandedAttribute() {
    if (hasAriaExpanded || !instance.props.aria.expanded) {
      return;
    }
    var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
    nodes.forEach(function(node) {
      if (instance.props.interactive) {
        node.setAttribute("aria-expanded", instance.state.isVisible && node === getCurrentTarget() ? "true" : "false");
      } else {
        node.removeAttribute("aria-expanded");
      }
    });
  }
  function cleanupInteractiveMouseListeners() {
    getDocument().removeEventListener("mousemove", debouncedOnMouseMove);
    mouseMoveListeners = mouseMoveListeners.filter(function(listener) {
      return listener !== debouncedOnMouseMove;
    });
  }
  function onDocumentPress(event) {
    if (currentInput.isTouch) {
      if (didTouchMove || event.type === "mousedown") {
        return;
      }
    }
    var actualTarget = event.composedPath && event.composedPath()[0] || event.target;
    if (instance.props.interactive && actualContains(popper2, actualTarget)) {
      return;
    }
    if (normalizeToArray(instance.props.triggerTarget || reference2).some(function(el) {
      return actualContains(el, actualTarget);
    })) {
      if (currentInput.isTouch) {
        return;
      }
      if (instance.state.isVisible && instance.props.trigger.indexOf("click") >= 0) {
        return;
      }
    } else {
      invokeHook("onClickOutside", [instance, event]);
    }
    if (instance.props.hideOnClick === true) {
      instance.clearDelayTimeouts();
      instance.hide();
      didHideDueToDocumentMouseDown = true;
      setTimeout(function() {
        didHideDueToDocumentMouseDown = false;
      });
      if (!instance.state.isMounted) {
        removeDocumentPress();
      }
    }
  }
  function onTouchMove() {
    didTouchMove = true;
  }
  function onTouchStart() {
    didTouchMove = false;
  }
  function addDocumentPress() {
    var doc = getDocument();
    doc.addEventListener("mousedown", onDocumentPress, true);
    doc.addEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
    doc.addEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
    doc.addEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
  }
  function removeDocumentPress() {
    var doc = getDocument();
    doc.removeEventListener("mousedown", onDocumentPress, true);
    doc.removeEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
    doc.removeEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
    doc.removeEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
  }
  function onTransitionedOut(duration, callback) {
    onTransitionEnd(duration, function() {
      if (!instance.state.isVisible && popper2.parentNode && popper2.parentNode.contains(popper2)) {
        callback();
      }
    });
  }
  function onTransitionedIn(duration, callback) {
    onTransitionEnd(duration, callback);
  }
  function onTransitionEnd(duration, callback) {
    var box = getDefaultTemplateChildren().box;
    function listener(event) {
      if (event.target === box) {
        updateTransitionEndListener(box, "remove", listener);
        callback();
      }
    }
    if (duration === 0) {
      return callback();
    }
    updateTransitionEndListener(box, "remove", currentTransitionEndListener);
    updateTransitionEndListener(box, "add", listener);
    currentTransitionEndListener = listener;
  }
  function on(eventType, handler, options) {
    if (options === void 0) {
      options = false;
    }
    var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
    nodes.forEach(function(node) {
      node.addEventListener(eventType, handler, options);
      listeners.push({
        node,
        eventType,
        handler,
        options
      });
    });
  }
  function addListeners() {
    if (getIsCustomTouchBehavior()) {
      on("touchstart", onTrigger2, {
        passive: true
      });
      on("touchend", onMouseLeave, {
        passive: true
      });
    }
    splitBySpaces(instance.props.trigger).forEach(function(eventType) {
      if (eventType === "manual") {
        return;
      }
      on(eventType, onTrigger2);
      switch (eventType) {
        case "mouseenter":
          on("mouseleave", onMouseLeave);
          break;
        case "focus":
          on(isIE11 ? "focusout" : "blur", onBlurOrFocusOut);
          break;
        case "focusin":
          on("focusout", onBlurOrFocusOut);
          break;
      }
    });
  }
  function removeListeners() {
    listeners.forEach(function(_ref) {
      var node = _ref.node, eventType = _ref.eventType, handler = _ref.handler, options = _ref.options;
      node.removeEventListener(eventType, handler, options);
    });
    listeners = [];
  }
  function onTrigger2(event) {
    var _lastTriggerEvent;
    var shouldScheduleClickHide = false;
    if (!instance.state.isEnabled || isEventListenerStopped(event) || didHideDueToDocumentMouseDown) {
      return;
    }
    var wasFocused = ((_lastTriggerEvent = lastTriggerEvent) == null ? void 0 : _lastTriggerEvent.type) === "focus";
    lastTriggerEvent = event;
    currentTarget = event.currentTarget;
    handleAriaExpandedAttribute();
    if (!instance.state.isVisible && isMouseEvent(event)) {
      mouseMoveListeners.forEach(function(listener) {
        return listener(event);
      });
    }
    if (event.type === "click" && (instance.props.trigger.indexOf("mouseenter") < 0 || isVisibleFromClick) && instance.props.hideOnClick !== false && instance.state.isVisible) {
      shouldScheduleClickHide = true;
    } else {
      scheduleShow(event);
    }
    if (event.type === "click") {
      isVisibleFromClick = !shouldScheduleClickHide;
    }
    if (shouldScheduleClickHide && !wasFocused) {
      scheduleHide(event);
    }
  }
  function onMouseMove(event) {
    var target = event.target;
    var isCursorOverReferenceOrPopper = getCurrentTarget().contains(target) || popper2.contains(target);
    if (event.type === "mousemove" && isCursorOverReferenceOrPopper) {
      return;
    }
    var popperTreeData = getNestedPopperTree().concat(popper2).map(function(popper3) {
      var _instance$popperInsta;
      var instance2 = popper3._tippy;
      var state2 = (_instance$popperInsta = instance2.popperInstance) == null ? void 0 : _instance$popperInsta.state;
      if (state2) {
        return {
          popperRect: popper3.getBoundingClientRect(),
          popperState: state2,
          props
        };
      }
      return null;
    }).filter(Boolean);
    if (isCursorOutsideInteractiveBorder(popperTreeData, event)) {
      cleanupInteractiveMouseListeners();
      scheduleHide(event);
    }
  }
  function onMouseLeave(event) {
    var shouldBail = isEventListenerStopped(event) || instance.props.trigger.indexOf("click") >= 0 && isVisibleFromClick;
    if (shouldBail) {
      return;
    }
    if (instance.props.interactive) {
      instance.hideWithInteractivity(event);
      return;
    }
    scheduleHide(event);
  }
  function onBlurOrFocusOut(event) {
    if (instance.props.trigger.indexOf("focusin") < 0 && event.target !== getCurrentTarget()) {
      return;
    }
    if (instance.props.interactive && event.relatedTarget && popper2.contains(event.relatedTarget)) {
      return;
    }
    scheduleHide(event);
  }
  function isEventListenerStopped(event) {
    return currentInput.isTouch ? getIsCustomTouchBehavior() !== event.type.indexOf("touch") >= 0 : false;
  }
  function createPopperInstance() {
    destroyPopperInstance();
    var _instance$props2 = instance.props, popperOptions = _instance$props2.popperOptions, placement = _instance$props2.placement, offset5 = _instance$props2.offset, getReferenceClientRect = _instance$props2.getReferenceClientRect, moveTransition = _instance$props2.moveTransition;
    var arrow5 = getIsDefaultRenderFn() ? getChildren(popper2).arrow : null;
    var computedReference = getReferenceClientRect ? {
      getBoundingClientRect: getReferenceClientRect,
      contextElement: getReferenceClientRect.contextElement || getCurrentTarget()
    } : reference2;
    var tippyModifier = {
      name: "$$tippy",
      enabled: true,
      phase: "beforeWrite",
      requires: ["computeStyles"],
      fn: function fn3(_ref2) {
        var state2 = _ref2.state;
        if (getIsDefaultRenderFn()) {
          var _getDefaultTemplateCh = getDefaultTemplateChildren(), box = _getDefaultTemplateCh.box;
          ["placement", "reference-hidden", "escaped"].forEach(function(attr) {
            if (attr === "placement") {
              box.setAttribute("data-placement", state2.placement);
            } else {
              if (state2.attributes.popper["data-popper-" + attr]) {
                box.setAttribute("data-" + attr, "");
              } else {
                box.removeAttribute("data-" + attr);
              }
            }
          });
          state2.attributes.popper = {};
        }
      }
    };
    var modifiers = [{
      name: "offset",
      options: {
        offset: offset5
      }
    }, {
      name: "preventOverflow",
      options: {
        padding: {
          top: 2,
          bottom: 2,
          left: 5,
          right: 5
        }
      }
    }, {
      name: "flip",
      options: {
        padding: 5
      }
    }, {
      name: "computeStyles",
      options: {
        adaptive: !moveTransition
      }
    }, tippyModifier];
    if (getIsDefaultRenderFn() && arrow5) {
      modifiers.push({
        name: "arrow",
        options: {
          element: arrow5,
          padding: 3
        }
      });
    }
    modifiers.push.apply(modifiers, (popperOptions == null ? void 0 : popperOptions.modifiers) || []);
    instance.popperInstance = createPopper(computedReference, popper2, Object.assign({}, popperOptions, {
      placement,
      onFirstUpdate,
      modifiers
    }));
  }
  function destroyPopperInstance() {
    if (instance.popperInstance) {
      instance.popperInstance.destroy();
      instance.popperInstance = null;
    }
  }
  function mount() {
    var appendTo = instance.props.appendTo;
    var parentNode;
    var node = getCurrentTarget();
    if (instance.props.interactive && appendTo === TIPPY_DEFAULT_APPEND_TO || appendTo === "parent") {
      parentNode = node.parentNode;
    } else {
      parentNode = invokeWithArgsOrReturn(appendTo, [node]);
    }
    if (!parentNode.contains(popper2)) {
      parentNode.appendChild(popper2);
    }
    instance.state.isMounted = true;
    createPopperInstance();
    if (false) {
      warnWhen(instance.props.interactive && appendTo === defaultProps.appendTo && node.nextElementSibling !== popper2, ["Interactive tippy element may not be accessible via keyboard", "navigation because it is not directly after the reference element", "in the DOM source order.", "\n\n", "Using a wrapper <div> or <span> tag around the reference element", "solves this by creating a new parentNode context.", "\n\n", "Specifying `appendTo: document.body` silences this warning, but it", "assumes you are using a focus management solution to handle", "keyboard navigation.", "\n\n", "See: https://atomiks.github.io/tippyjs/v6/accessibility/#interactivity"].join(" "));
    }
  }
  function getNestedPopperTree() {
    return arrayFrom(popper2.querySelectorAll("[data-tippy-root]"));
  }
  function scheduleShow(event) {
    instance.clearDelayTimeouts();
    if (event) {
      invokeHook("onTrigger", [instance, event]);
    }
    addDocumentPress();
    var delay = getDelay(true);
    var _getNormalizedTouchSe = getNormalizedTouchSettings(), touchValue = _getNormalizedTouchSe[0], touchDelay = _getNormalizedTouchSe[1];
    if (currentInput.isTouch && touchValue === "hold" && touchDelay) {
      delay = touchDelay;
    }
    if (delay) {
      showTimeout = setTimeout(function() {
        instance.show();
      }, delay);
    } else {
      instance.show();
    }
  }
  function scheduleHide(event) {
    instance.clearDelayTimeouts();
    invokeHook("onUntrigger", [instance, event]);
    if (!instance.state.isVisible) {
      removeDocumentPress();
      return;
    }
    if (instance.props.trigger.indexOf("mouseenter") >= 0 && instance.props.trigger.indexOf("click") >= 0 && ["mouseleave", "mousemove"].indexOf(event.type) >= 0 && isVisibleFromClick) {
      return;
    }
    var delay = getDelay(false);
    if (delay) {
      hideTimeout = setTimeout(function() {
        if (instance.state.isVisible) {
          instance.hide();
        }
      }, delay);
    } else {
      scheduleHideAnimationFrame = requestAnimationFrame(function() {
        instance.hide();
      });
    }
  }
  function enable() {
    instance.state.isEnabled = true;
  }
  function disable() {
    instance.hide();
    instance.state.isEnabled = false;
  }
  function clearDelayTimeouts() {
    clearTimeout(showTimeout);
    clearTimeout(hideTimeout);
    cancelAnimationFrame(scheduleHideAnimationFrame);
  }
  function setProps(partialProps) {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("setProps"));
    }
    if (instance.state.isDestroyed) {
      return;
    }
    invokeHook("onBeforeUpdate", [instance, partialProps]);
    removeListeners();
    var prevProps = instance.props;
    var nextProps = evaluateProps(reference2, Object.assign({}, prevProps, removeUndefinedProps(partialProps), {
      ignoreAttributes: true
    }));
    instance.props = nextProps;
    addListeners();
    if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) {
      cleanupInteractiveMouseListeners();
      debouncedOnMouseMove = debounce6(onMouseMove, nextProps.interactiveDebounce);
    }
    if (prevProps.triggerTarget && !nextProps.triggerTarget) {
      normalizeToArray(prevProps.triggerTarget).forEach(function(node) {
        node.removeAttribute("aria-expanded");
      });
    } else if (nextProps.triggerTarget) {
      reference2.removeAttribute("aria-expanded");
    }
    handleAriaExpandedAttribute();
    handleStyles();
    if (onUpdate) {
      onUpdate(prevProps, nextProps);
    }
    if (instance.popperInstance) {
      createPopperInstance();
      getNestedPopperTree().forEach(function(nestedPopper) {
        requestAnimationFrame(nestedPopper._tippy.popperInstance.forceUpdate);
      });
    }
    invokeHook("onAfterUpdate", [instance, partialProps]);
  }
  function setContent2(content) {
    instance.setProps({
      content
    });
  }
  function show() {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("show"));
    }
    var isAlreadyVisible = instance.state.isVisible;
    var isDestroyed = instance.state.isDestroyed;
    var isDisabled = !instance.state.isEnabled;
    var isTouchAndTouchDisabled = currentInput.isTouch && !instance.props.touch;
    var duration = getValueAtIndexOrReturn(instance.props.duration, 0, defaultProps.duration);
    if (isAlreadyVisible || isDestroyed || isDisabled || isTouchAndTouchDisabled) {
      return;
    }
    if (getCurrentTarget().hasAttribute("disabled")) {
      return;
    }
    invokeHook("onShow", [instance], false);
    if (instance.props.onShow(instance) === false) {
      return;
    }
    instance.state.isVisible = true;
    if (getIsDefaultRenderFn()) {
      popper2.style.visibility = "visible";
    }
    handleStyles();
    addDocumentPress();
    if (!instance.state.isMounted) {
      popper2.style.transition = "none";
    }
    if (getIsDefaultRenderFn()) {
      var _getDefaultTemplateCh2 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh2.box, content = _getDefaultTemplateCh2.content;
      setTransitionDuration([box, content], 0);
    }
    onFirstUpdate = function onFirstUpdate2() {
      var _instance$popperInsta2;
      if (!instance.state.isVisible || ignoreOnFirstUpdate) {
        return;
      }
      ignoreOnFirstUpdate = true;
      void popper2.offsetHeight;
      popper2.style.transition = instance.props.moveTransition;
      if (getIsDefaultRenderFn() && instance.props.animation) {
        var _getDefaultTemplateCh3 = getDefaultTemplateChildren(), _box = _getDefaultTemplateCh3.box, _content = _getDefaultTemplateCh3.content;
        setTransitionDuration([_box, _content], duration);
        setVisibilityState([_box, _content], "visible");
      }
      handleAriaContentAttribute();
      handleAriaExpandedAttribute();
      pushIfUnique(mountedInstances, instance);
      (_instance$popperInsta2 = instance.popperInstance) == null ? void 0 : _instance$popperInsta2.forceUpdate();
      invokeHook("onMount", [instance]);
      if (instance.props.animation && getIsDefaultRenderFn()) {
        onTransitionedIn(duration, function() {
          instance.state.isShown = true;
          invokeHook("onShown", [instance]);
        });
      }
    };
    mount();
  }
  function hide5() {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("hide"));
    }
    var isAlreadyHidden = !instance.state.isVisible;
    var isDestroyed = instance.state.isDestroyed;
    var isDisabled = !instance.state.isEnabled;
    var duration = getValueAtIndexOrReturn(instance.props.duration, 1, defaultProps.duration);
    if (isAlreadyHidden || isDestroyed || isDisabled) {
      return;
    }
    invokeHook("onHide", [instance], false);
    if (instance.props.onHide(instance) === false) {
      return;
    }
    instance.state.isVisible = false;
    instance.state.isShown = false;
    ignoreOnFirstUpdate = false;
    isVisibleFromClick = false;
    if (getIsDefaultRenderFn()) {
      popper2.style.visibility = "hidden";
    }
    cleanupInteractiveMouseListeners();
    removeDocumentPress();
    handleStyles(true);
    if (getIsDefaultRenderFn()) {
      var _getDefaultTemplateCh4 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh4.box, content = _getDefaultTemplateCh4.content;
      if (instance.props.animation) {
        setTransitionDuration([box, content], duration);
        setVisibilityState([box, content], "hidden");
      }
    }
    handleAriaContentAttribute();
    handleAriaExpandedAttribute();
    if (instance.props.animation) {
      if (getIsDefaultRenderFn()) {
        onTransitionedOut(duration, instance.unmount);
      }
    } else {
      instance.unmount();
    }
  }
  function hideWithInteractivity(event) {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("hideWithInteractivity"));
    }
    getDocument().addEventListener("mousemove", debouncedOnMouseMove);
    pushIfUnique(mouseMoveListeners, debouncedOnMouseMove);
    debouncedOnMouseMove(event);
  }
  function unmount() {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("unmount"));
    }
    if (instance.state.isVisible) {
      instance.hide();
    }
    if (!instance.state.isMounted) {
      return;
    }
    destroyPopperInstance();
    getNestedPopperTree().forEach(function(nestedPopper) {
      nestedPopper._tippy.unmount();
    });
    if (popper2.parentNode) {
      popper2.parentNode.removeChild(popper2);
    }
    mountedInstances = mountedInstances.filter(function(i2) {
      return i2 !== instance;
    });
    instance.state.isMounted = false;
    invokeHook("onHidden", [instance]);
  }
  function destroy() {
    if (false) {
      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning("destroy"));
    }
    if (instance.state.isDestroyed) {
      return;
    }
    instance.clearDelayTimeouts();
    instance.unmount();
    removeListeners();
    delete reference2._tippy;
    instance.state.isDestroyed = true;
    invokeHook("onDestroy", [instance]);
  }
}
function tippy(targets, optionalProps) {
  if (optionalProps === void 0) {
    optionalProps = {};
  }
  var plugins = defaultProps.plugins.concat(optionalProps.plugins || []);
  if (false) {
    validateTargets(targets);
    validateProps(optionalProps, plugins);
  }
  bindGlobalEventListeners();
  var passedProps = Object.assign({}, optionalProps, {
    plugins
  });
  var elements = getArrayOfElements(targets);
  if (false) {
    var isSingleContentElement = isElement3(passedProps.content);
    var isMoreThanOneReferenceElement = elements.length > 1;
    warnWhen(isSingleContentElement && isMoreThanOneReferenceElement, ["tippy() was passed an Element as the `content` prop, but more than", "one tippy instance was created by this invocation. This means the", "content element will only be appended to the last tippy instance.", "\n\n", "Instead, pass the .innerHTML of the element, or use a function that", "returns a cloned version of the element instead.", "\n\n", "1) content: element.innerHTML\n", "2) content: () => element.cloneNode(true)"].join(" "));
  }
  var instances = elements.reduce(function(acc, reference2) {
    var instance = reference2 && createTippy(reference2, passedProps);
    if (instance) {
      acc.push(instance);
    }
    return acc;
  }, []);
  return isElement3(targets) ? instances[0] : instances;
}
var BOX_CLASS, CONTENT_CLASS, BACKDROP_CLASS, ARROW_CLASS, SVG_ARROW_CLASS, TOUCH_OPTIONS, TIPPY_DEFAULT_APPEND_TO, currentInput, lastMouseMoveTime, isBrowser, isIE11, pluginProps, renderProps, defaultProps, defaultKeys, setDefaultProps, innerHTML, idCounter2, mouseMoveListeners, mountedInstances, applyStylesModifier, tippy_esm_default;
var init_tippy_esm = __esm({
  "node_modules/tippy.js/dist/tippy.esm.js"() {
    init_lib();
    BOX_CLASS = "tippy-box";
    CONTENT_CLASS = "tippy-content";
    BACKDROP_CLASS = "tippy-backdrop";
    ARROW_CLASS = "tippy-arrow";
    SVG_ARROW_CLASS = "tippy-svg-arrow";
    TOUCH_OPTIONS = {
      passive: true,
      capture: true
    };
    TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO2() {
      return document.body;
    };
    currentInput = {
      isTouch: false
    };
    lastMouseMoveTime = 0;
    isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
    isIE11 = isBrowser ? !!window.msCrypto : false;
    if (false) {
      resetVisitedMessages();
    }
    pluginProps = {
      animateFill: false,
      followCursor: false,
      inlinePositioning: false,
      sticky: false
    };
    renderProps = {
      allowHTML: false,
      animation: "fade",
      arrow: true,
      content: "",
      inertia: false,
      maxWidth: 350,
      role: "tooltip",
      theme: "",
      zIndex: 9999
    };
    defaultProps = Object.assign({
      appendTo: TIPPY_DEFAULT_APPEND_TO,
      aria: {
        content: "auto",
        expanded: "auto"
      },
      delay: 0,
      duration: [300, 250],
      getReferenceClientRect: null,
      hideOnClick: true,
      ignoreAttributes: false,
      interactive: false,
      interactiveBorder: 2,
      interactiveDebounce: 0,
      moveTransition: "",
      offset: [0, 10],
      onAfterUpdate: function onAfterUpdate() {
      },
      onBeforeUpdate: function onBeforeUpdate() {
      },
      onCreate: function onCreate() {
      },
      onDestroy: function onDestroy() {
      },
      onHidden: function onHidden() {
      },
      onHide: function onHide() {
      },
      onMount: function onMount() {
      },
      onShow: function onShow() {
      },
      onShown: function onShown() {
      },
      onTrigger: function onTrigger() {
      },
      onUntrigger: function onUntrigger() {
      },
      onClickOutside: function onClickOutside() {
      },
      placement: "top",
      plugins: [],
      popperOptions: {},
      render: null,
      showOnCreate: false,
      touch: true,
      trigger: "mouseenter focus",
      triggerTarget: null
    }, pluginProps, renderProps);
    defaultKeys = Object.keys(defaultProps);
    setDefaultProps = function setDefaultProps2(partialProps) {
      if (false) {
        validateProps(partialProps, []);
      }
      var keys = Object.keys(partialProps);
      keys.forEach(function(key) {
        defaultProps[key] = partialProps[key];
      });
    };
    innerHTML = function innerHTML2() {
      return "innerHTML";
    };
    render.$$tippy = true;
    idCounter2 = 1;
    mouseMoveListeners = [];
    mountedInstances = [];
    tippy.defaultProps = defaultProps;
    tippy.setDefaultProps = setDefaultProps;
    tippy.currentInput = currentInput;
    applyStylesModifier = Object.assign({}, applyStyles_default, {
      effect: function effect4(_ref) {
        var state = _ref.state;
        var initialStyles = {
          popper: {
            position: state.options.strategy,
            left: "0",
            top: "0",
            margin: "0"
          },
          arrow: {
            position: "absolute"
          },
          reference: {}
        };
        Object.assign(state.elements.popper.style, initialStyles.popper);
        state.styles = initialStyles;
        if (state.elements.arrow) {
          Object.assign(state.elements.arrow.style, initialStyles.arrow);
        }
      }
    });
    tippy.setDefaultProps({
      render
    });
    tippy_esm_default = tippy;
  }
});

// node_modules/@tippyjs/react/dist/tippy-react.esm.js
function _objectWithoutPropertiesLoose2(source, excluded) {
  if (source == null)
    return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i2;
  for (i2 = 0; i2 < sourceKeys.length; i2++) {
    key = sourceKeys[i2];
    if (excluded.indexOf(key) >= 0)
      continue;
    target[key] = source[key];
  }
  return target;
}
function preserveRef(ref, node) {
  if (ref) {
    if (typeof ref === "function") {
      ref(node);
    }
    if ({}.hasOwnProperty.call(ref, "current")) {
      ref.current = node;
    }
  }
}
function ssrSafeCreateDiv() {
  return isBrowser2 && document.createElement("div");
}
function toDataAttributes(attrs) {
  var dataAttrs = {
    "data-placement": attrs.placement
  };
  if (attrs.referenceHidden) {
    dataAttrs["data-reference-hidden"] = "";
  }
  if (attrs.escaped) {
    dataAttrs["data-escaped"] = "";
  }
  return dataAttrs;
}
function deepEqual2(x2, y2) {
  if (x2 === y2) {
    return true;
  } else if (typeof x2 === "object" && x2 != null && typeof y2 === "object" && y2 != null) {
    if (Object.keys(x2).length !== Object.keys(y2).length) {
      return false;
    }
    for (var prop in x2) {
      if (y2.hasOwnProperty(prop)) {
        if (!deepEqual2(x2[prop], y2[prop])) {
          return false;
        }
      } else {
        return false;
      }
    }
    return true;
  } else {
    return false;
  }
}
function uniqueByShape(arr) {
  var output = [];
  arr.forEach(function(item) {
    if (!output.find(function(outputItem) {
      return deepEqual2(item, outputItem);
    })) {
      output.push(item);
    }
  });
  return output;
}
function deepPreserveProps(instanceProps, componentProps) {
  var _instanceProps$popper, _componentProps$poppe;
  return Object.assign({}, componentProps, {
    popperOptions: Object.assign({}, instanceProps.popperOptions, componentProps.popperOptions, {
      modifiers: uniqueByShape([].concat(((_instanceProps$popper = instanceProps.popperOptions) == null ? void 0 : _instanceProps$popper.modifiers) || [], ((_componentProps$poppe = componentProps.popperOptions) == null ? void 0 : _componentProps$poppe.modifiers) || []))
    })
  });
}
function useMutableBox(initialValue) {
  var ref = (0, import_react121.useRef)();
  if (!ref.current) {
    ref.current = typeof initialValue === "function" ? initialValue() : initialValue;
  }
  return ref.current;
}
function updateClassName(box, action, classNames49) {
  classNames49.split(/\s+/).forEach(function(name) {
    if (name) {
      box.classList[action](name);
    }
  });
}
function TippyGenerator(tippy2) {
  function Tippy(_ref) {
    var children = _ref.children, content = _ref.content, visible = _ref.visible, singleton2 = _ref.singleton, render2 = _ref.render, reference2 = _ref.reference, _ref$disabled = _ref.disabled, disabled = _ref$disabled === void 0 ? false : _ref$disabled, _ref$ignoreAttributes = _ref.ignoreAttributes, ignoreAttributes = _ref$ignoreAttributes === void 0 ? true : _ref$ignoreAttributes, __source = _ref.__source, __self = _ref.__self, restOfNativeProps = _objectWithoutPropertiesLoose2(_ref, ["children", "content", "visible", "singleton", "render", "reference", "disabled", "ignoreAttributes", "__source", "__self"]);
    var isControlledMode = visible !== void 0;
    var isSingletonMode = singleton2 !== void 0;
    var _useState = (0, import_react121.useState)(false), mounted = _useState[0], setMounted = _useState[1];
    var _useState2 = (0, import_react121.useState)({}), attrs = _useState2[0], setAttrs = _useState2[1];
    var _useState3 = (0, import_react121.useState)(), singletonContent = _useState3[0], setSingletonContent = _useState3[1];
    var mutableBox = useMutableBox(function() {
      return {
        container: ssrSafeCreateDiv(),
        renders: 1
      };
    });
    var props = Object.assign({
      ignoreAttributes
    }, restOfNativeProps, {
      content: mutableBox.container
    });
    if (isControlledMode) {
      if (false) {
        ["trigger", "hideOnClick", "showOnCreate"].forEach(function(nativeStateProp) {
          if (props[nativeStateProp] !== void 0) {
            console.warn(["@tippyjs/react: Cannot specify `" + nativeStateProp + "` prop in", "controlled mode (`visible` prop)"].join(" "));
          }
        });
      }
      props.trigger = "manual";
      props.hideOnClick = false;
    }
    if (isSingletonMode) {
      disabled = true;
    }
    var computedProps = props;
    var plugins = props.plugins || [];
    if (render2) {
      computedProps = Object.assign({}, props, {
        plugins: isSingletonMode && singleton2.data != null ? [].concat(plugins, [{
          fn: function fn3() {
            return {
              onTrigger: function onTrigger2(instance, event) {
                var node = singleton2.data.children.find(function(_ref2) {
                  var instance2 = _ref2.instance;
                  return instance2.reference === event.currentTarget;
                });
                instance.state.$$activeSingletonInstance = node.instance;
                setSingletonContent(node.content);
              }
            };
          }
        }]) : plugins,
        render: function render3() {
          return {
            popper: mutableBox.container
          };
        }
      });
    }
    var deps = [reference2].concat(children ? [children.type] : []);
    useIsomorphicLayoutEffect2(function() {
      var element = reference2;
      if (reference2 && reference2.hasOwnProperty("current")) {
        element = reference2.current;
      }
      var instance = tippy2(element || mutableBox.ref || ssrSafeCreateDiv(), Object.assign({}, computedProps, {
        plugins: [classNamePlugin].concat(props.plugins || [])
      }));
      mutableBox.instance = instance;
      if (disabled) {
        instance.disable();
      }
      if (visible) {
        instance.show();
      }
      if (isSingletonMode) {
        singleton2.hook({
          instance,
          content,
          props: computedProps,
          setSingletonContent
        });
      }
      setMounted(true);
      return function() {
        instance.destroy();
        singleton2 == null ? void 0 : singleton2.cleanup(instance);
      };
    }, deps);
    useIsomorphicLayoutEffect2(function() {
      var _instance$popperInsta;
      if (mutableBox.renders === 1) {
        mutableBox.renders++;
        return;
      }
      var instance = mutableBox.instance;
      instance.setProps(deepPreserveProps(instance.props, computedProps));
      (_instance$popperInsta = instance.popperInstance) == null ? void 0 : _instance$popperInsta.forceUpdate();
      if (disabled) {
        instance.disable();
      } else {
        instance.enable();
      }
      if (isControlledMode) {
        if (visible) {
          instance.show();
        } else {
          instance.hide();
        }
      }
      if (isSingletonMode) {
        singleton2.hook({
          instance,
          content,
          props: computedProps,
          setSingletonContent
        });
      }
    });
    useIsomorphicLayoutEffect2(function() {
      var _instance$props$poppe;
      if (!render2) {
        return;
      }
      var instance = mutableBox.instance;
      instance.setProps({
        popperOptions: Object.assign({}, instance.props.popperOptions, {
          modifiers: [].concat((((_instance$props$poppe = instance.props.popperOptions) == null ? void 0 : _instance$props$poppe.modifiers) || []).filter(function(_ref3) {
            var name = _ref3.name;
            return name !== "$$tippyReact";
          }), [{
            name: "$$tippyReact",
            enabled: true,
            phase: "beforeWrite",
            requires: ["computeStyles"],
            fn: function fn3(_ref4) {
              var _state$modifiersData;
              var state = _ref4.state;
              var hideData = (_state$modifiersData = state.modifiersData) == null ? void 0 : _state$modifiersData.hide;
              if (attrs.placement !== state.placement || attrs.referenceHidden !== (hideData == null ? void 0 : hideData.isReferenceHidden) || attrs.escaped !== (hideData == null ? void 0 : hideData.hasPopperEscaped)) {
                setAttrs({
                  placement: state.placement,
                  referenceHidden: hideData == null ? void 0 : hideData.isReferenceHidden,
                  escaped: hideData == null ? void 0 : hideData.hasPopperEscaped
                });
              }
              state.attributes.popper = {};
            }
          }])
        })
      });
    }, [attrs.placement, attrs.referenceHidden, attrs.escaped].concat(deps));
    return /* @__PURE__ */ import_react121.default.createElement(import_react121.default.Fragment, null, children ? /* @__PURE__ */ (0, import_react121.cloneElement)(children, {
      ref: function ref(node) {
        mutableBox.ref = node;
        preserveRef(children.ref, node);
      }
    }) : null, mounted && /* @__PURE__ */ (0, import_react_dom4.createPortal)(render2 ? render2(toDataAttributes(attrs), singletonContent, mutableBox.instance) : content, mutableBox.container));
  }
  return Tippy;
}
var import_react121, import_react_dom4, isBrowser2, useIsomorphicLayoutEffect2, classNamePlugin, forwardRef25, index2, tippy_react_esm_default;
var init_tippy_react_esm = __esm({
  "node_modules/@tippyjs/react/dist/tippy-react.esm.js"() {
    init_tippy_esm();
    import_react121 = __toESM(require_react());
    import_react_dom4 = __toESM(require_react_dom());
    isBrowser2 = typeof window !== "undefined" && typeof document !== "undefined";
    useIsomorphicLayoutEffect2 = isBrowser2 ? import_react121.useLayoutEffect : import_react121.useEffect;
    classNamePlugin = {
      name: "className",
      defaultValue: "",
      fn: function fn2(instance) {
        var box = instance.popper.firstElementChild;
        var isDefaultRenderFn = function isDefaultRenderFn2() {
          var _instance$props$rende;
          return !!((_instance$props$rende = instance.props.render) == null ? void 0 : _instance$props$rende.$$tippy);
        };
        function add() {
          if (instance.props.className && !isDefaultRenderFn()) {
            if (false) {
              console.warn(["@tippyjs/react: Cannot use `className` prop in conjunction with", "`render` prop. Place the className on the element you are", "rendering."].join(" "));
            }
            return;
          }
          updateClassName(box, "add", instance.props.className);
        }
        function remove2() {
          if (isDefaultRenderFn()) {
            updateClassName(box, "remove", instance.props.className);
          }
        }
        return {
          onCreate: add,
          onBeforeUpdate: remove2,
          onAfterUpdate: add
        };
      }
    };
    forwardRef25 = function(Tippy, defaultProps2) {
      return /* @__PURE__ */ (0, import_react121.forwardRef)(function TippyWrapper(_ref, _ref2) {
        var children = _ref.children, props = _objectWithoutPropertiesLoose2(_ref, ["children"]);
        return /* @__PURE__ */ import_react121.default.createElement(Tippy, Object.assign({}, defaultProps2, props), children ? /* @__PURE__ */ (0, import_react121.cloneElement)(children, {
          ref: function ref(node) {
            preserveRef(_ref2, node);
            preserveRef(children.ref, node);
          }
        }) : null);
      });
    };
    index2 = /* @__PURE__ */ forwardRef25(/* @__PURE__ */ TippyGenerator(tippy_esm_default));
    tippy_react_esm_default = index2;
  }
});

// node_modules/tippy.js/dist/tippy.css
var init_3 = __esm({
  "node_modules/tippy.js/dist/tippy.css"() {
  }
});

// src/components/jsx-components/tooltip-button/tooltip-button.tsx
var React77, TooltipButton;
var init_tooltip_button = __esm({
  "src/components/jsx-components/tooltip-button/tooltip-button.tsx"() {
    React77 = __toESM(require_react());
    init_tippy_react_esm();
    init_3();
    TooltipButton = ({
      tooltip,
      onClick,
      onPointerDown,
      disabled,
      className,
      children
    }) => {
      const [tooltipVisible, setTooltipVisible] = React77.useState(false);
      const holdTimerRef = React77.useRef(null);
      React77.useEffect(() => {
        return () => {
          if (holdTimerRef.current)
            window.clearTimeout(holdTimerRef.current);
        };
      }, []);
      function startHoldTimer() {
        if (holdTimerRef.current)
          window.clearTimeout(holdTimerRef.current);
        holdTimerRef.current = window.setTimeout(() => {
          setTooltipVisible(true);
        }, 1e3);
      }
      function handlePointerEnter(e2) {
        if (e2.pointerType === "mouse")
          startHoldTimer();
      }
      function dismissTooltip() {
        if (holdTimerRef.current) {
          window.clearTimeout(holdTimerRef.current);
          holdTimerRef.current = null;
        }
        setTooltipVisible(false);
      }
      return /* @__PURE__ */ React77.createElement(tippy_react_esm_default, {
        content: tooltip,
        visible: tooltipVisible,
        placement: "top"
      }, /* @__PURE__ */ React77.createElement("button", {
        className,
        disabled,
        onPointerEnter: handlePointerEnter,
        onPointerDown: (e2) => {
          startHoldTimer();
          onPointerDown?.(e2);
        },
        onPointerUp: dismissTooltip,
        onPointerLeave: dismissTooltip,
        onPointerCancel: dismissTooltip,
        onClick
      }, children));
    };
  }
});

// src/components/jsx-components/primary-menu-bar/primary-menu-bar.scss
var init_4 = __esm({
  "src/components/jsx-components/primary-menu-bar/primary-menu-bar.scss"() {
  }
});

// src/components/jsx-components/primary-menu-bar/primary-menu-bar.tsx
var import_classnames31, React79, PrimaryMenuBar;
var init_primary_menu_bar = __esm({
  "src/components/jsx-components/primary-menu-bar/primary-menu-bar.tsx"() {
    import_classnames31 = __toESM(require_classnames());
    init_4();
    React79 = __toESM(require_react());
    PrimaryMenuBar = (props) => {
      const scrollContainerElRef = React79.useRef(null);
      const primaryMenuBarElRef = React79.useRef(null);
      const [menuActive] = React79.useState(true);
      React79.useEffect(() => {
        initScrollHandler();
        return () => {
          cleanUpScrollHandler();
        };
      });
      return /* @__PURE__ */ React79.createElement(React79.Fragment, null, /* @__PURE__ */ React79.createElement("div", {
        ref: primaryMenuBarElRef,
        className: (0, import_classnames31.default)([
          "ink_primary-menu-bar",
          menuActive && "ddc_ink_active"
        ])
      }, props.children));
      function initScrollHandler() {
        const primaryMenuBar = primaryMenuBarElRef.current;
        const scrollEl = primaryMenuBar?.closest(".cm-scroller");
        if (!scrollEl)
          return;
        scrollEl.addEventListener("scroll", handleScrolling);
        scrollEl.dispatchEvent(new CustomEvent("scroll"));
      }
      function cleanUpScrollHandler() {
        const scrollEl = scrollContainerElRef.current;
        scrollEl?.removeEventListener("scroll", handleScrolling);
      }
      function handleScrolling(e2) {
        const scrollAreaEl = e2.target;
        const primaryMenuBar = primaryMenuBarElRef.current;
        const embedEl = primaryMenuBar?.parentElement;
        if (!primaryMenuBar)
          return;
        if (!embedEl)
          return;
        const menuBarHeight = primaryMenuBar.getBoundingClientRect().height;
        const embedHeight = embedEl.getBoundingClientRect().height;
        let embedPosY = embedEl.getBoundingClientRect().top - scrollAreaEl.getBoundingClientRect().top || 0;
        if (menuActive) {
          embedPosY -= Number(menuBarHeight);
        }
        const embedOffsetY = embedPosY;
        const embedTopScrolledOffTop = embedOffsetY < 0;
        const embedBottomScrolledOffTop = embedOffsetY + embedHeight < 0;
        if (embedBottomScrolledOffTop) {
          const top2 = embedHeight + "px";
          primaryMenuBar.style.top = top2;
        } else if (embedTopScrolledOffTop) {
          const top2 = embedOffsetY * -1 + "px";
          primaryMenuBar.style.top = top2;
        } else {
          primaryMenuBar.style.removeProperty("top");
        }
      }
    };
  }
});

// src/graphics/icons/lock-icon.tsx
var React80, LockIcon;
var init_lock_icon = __esm({
  "src/graphics/icons/lock-icon.tsx"() {
    React80 = __toESM(require_react());
    LockIcon = (props) => /* @__PURE__ */ React80.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React80.createElement("path", {
      d: "M240-80q-33 0-56.5-23.5T160-160v-400q0-33 23.5-56.5T240-640h40v-80q0-83 58.5-141.5T480-920q83 0 141.5 58.5T680-720v80h40q33 0 56.5 23.5T800-560v400q0 33-23.5 56.5T720-80H240Zm0-80h480v-400H240v400Zm240-120q33 0 56.5-23.5T560-360q0-33-23.5-56.5T480-440q-33 0-56.5 23.5T400-360q0 33 23.5 56.5T480-280ZM360-640h240v-80q0-50-35-85t-85-35q-50 0-85 35t-35 85v80ZM240-160v-400 400Z"
    }));
  }
});

// src/components/jsx-components/extended-writing-menu/extended-writing-menu.scss
var init_5 = __esm({
  "src/components/jsx-components/extended-writing-menu/extended-writing-menu.scss"() {
  }
});

// src/components/jsx-components/overflow-menu/overflow-menu.scss
var init_6 = __esm({
  "src/components/jsx-components/overflow-menu/overflow-menu.scss"() {
  }
});

// src/graphics/icons/overflow-icon.tsx
var React81, OverflowIcon;
var init_overflow_icon = __esm({
  "src/graphics/icons/overflow-icon.tsx"() {
    React81 = __toESM(require_react());
    OverflowIcon = (props) => /* @__PURE__ */ React81.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React81.createElement("path", {
      d: "M480-160q-33 0-56.5-23.5T400-240q0-33 23.5-56.5T480-320q33 0 56.5 23.5T560-240q0 33-23.5 56.5T480-160Zm0-240q-33 0-56.5-23.5T400-480q0-33 23.5-56.5T480-560q33 0 56.5 23.5T560-480q0 33-23.5 56.5T480-400Zm0-240q-33 0-56.5-23.5T400-720q0-33 23.5-56.5T480-800q33 0 56.5 23.5T560-720q0 33-23.5 56.5T480-640Z"
    }));
  }
});

// src/components/jsx-components/overflow-menu/show-menu-options.ts
function isSeparator(option) {
  return "separator" in option && option.separator === true;
}
function populateMenu(menu, options) {
  options.forEach((option) => {
    if (isSeparator(option)) {
      menu.addSeparator();
      return;
    }
    menu.addItem((item) => {
      item.setTitle(option.text).onClick(() => {
        void option.action();
      });
      const menuItemDom = item.dom;
      if (option.destructive) {
        menuItemDom?.addClass("ddc_ink_menu-destructive");
      } else if (option.warning) {
        menuItemDom?.addClass("mod-warning");
      }
    });
  });
}
function buildMenuFromOptions(options) {
  const menu = new import_obsidian11.Menu();
  populateMenu(menu, options);
  return menu;
}
function showMenuOptionsAtMouseEvent(options, evt) {
  const menu = buildMenuFromOptions(options);
  menu.showAtMouseEvent(evt);
  return menu;
}
function showMenuOptionsAtPosition(options, position) {
  const menu = buildMenuFromOptions(options);
  menu.showAtPosition({ x: position.x, y: position.y });
  return menu;
}
var import_obsidian11;
var init_show_menu_options = __esm({
  "src/components/jsx-components/overflow-menu/show-menu-options.ts"() {
    import_obsidian11 = require("obsidian");
  }
});

// src/components/jsx-components/overflow-menu/overflow-menu.tsx
var React82, OverflowMenu, overflow_menu_default;
var init_overflow_menu = __esm({
  "src/components/jsx-components/overflow-menu/overflow-menu.tsx"() {
    init_6();
    React82 = __toESM(require_react());
    init_overflow_icon();
    init_show_menu_options();
    OverflowMenu = (props) => {
      const menuRef = React82.useRef(null);
      const isMenuOpenRef = React82.useRef(false);
      return /* @__PURE__ */ React82.createElement(React82.Fragment, null, /* @__PURE__ */ React82.createElement("div", {
        className: "ddc_ink_overflow-button-and-menu"
      }, /* @__PURE__ */ React82.createElement("button", {
        className: "ddc_ink_btn-slim",
        onClick: (e2) => {
          if (isMenuOpenRef.current && menuRef.current) {
            menuRef.current.hide();
            isMenuOpenRef.current = false;
            return;
          }
          const menu = showMenuOptionsAtMouseEvent(props.menuOptions, e2.nativeEvent);
          menu.onHide(() => {
            isMenuOpenRef.current = false;
            menuRef.current = null;
          });
          menuRef.current = menu;
          isMenuOpenRef.current = true;
        }
      }, /* @__PURE__ */ React82.createElement(OverflowIcon, null))));
    };
    overflow_menu_default = OverflowMenu;
  }
});

// src/components/jsx-components/extended-writing-menu/extended-writing-menu.tsx
var React83, ExtendedWritingMenu, extended_writing_menu_default;
var init_extended_writing_menu = __esm({
  "src/components/jsx-components/extended-writing-menu/extended-writing-menu.tsx"() {
    init_lock_icon();
    init_5();
    React83 = __toESM(require_react());
    init_overflow_menu();
    init_tooltip_button();
    ExtendedWritingMenu = (props) => {
      return /* @__PURE__ */ React83.createElement(React83.Fragment, null, /* @__PURE__ */ React83.createElement("div", {
        className: "ink_extended-writing-menu"
      }, props.onLockClick && /* @__PURE__ */ React83.createElement(TooltipButton, {
        tooltip: "Lock",
        onClick: () => props.onLockClick?.()
      }, /* @__PURE__ */ React83.createElement(LockIcon, null)), /* @__PURE__ */ React83.createElement(overflow_menu_default, {
        menuOptions: props.menuOptions
      })));
    };
    extended_writing_menu_default = ExtendedWritingMenu;
  }
});

// src/components/formats/current/drawing/drawing-embed/drawing-embed.scss
var init_7 = __esm({
  "src/components/formats/current/drawing/drawing-embed/drawing-embed.scss"() {
  }
});

// src/logic/device-settings/use-boox-connection-enabled.ts
function useBooxConnectionEnabled() {
  const [isEnabled, setIsEnabled] = (0, import_react123.useState)(() => getBooxConnectionEnabled());
  (0, import_react123.useEffect)(() => {
    setIsEnabled(getBooxConnectionEnabled());
    return subscribeDeviceSettingsChanged(() => {
      setIsEnabled(getBooxConnectionEnabled());
    });
  }, []);
  return isEnabled;
}
var import_react123;
var init_use_boox_connection_enabled = __esm({
  "src/logic/device-settings/use-boox-connection-enabled.ts"() {
    import_react123 = __toESM(require_react());
    init_device_settings();
  }
});

// src/logic/utils/getFullPageWidth.ts
function getFullPageWidth(childEl) {
  const visiblePageAreaEl = childEl?.closest(".cm-scroller") ?? childEl?.closest(".markdown-preview-view") ?? childEl?.closest(".markdown-rendered");
  if (!visiblePageAreaEl)
    return 500;
  return visiblePageAreaEl.getBoundingClientRect().width;
}
var init_getFullPageWidth = __esm({
  "src/logic/utils/getFullPageWidth.ts"() {
  }
});

// src/components/formats/current/writing/writing-view/writing-view.scss
var init_8 = __esm({
  "src/components/formats/current/writing/writing-view/writing-view.scss"() {
  }
});

// src/components/formats/current/writing/writing-editor/writing-editor.scss
var init_9 = __esm({
  "src/components/formats/current/writing/writing-editor/writing-editor.scss"() {
  }
});

// src/components/jsx-components/drawing-menu/drawing-menu.scss
var init_10 = __esm({
  "src/components/jsx-components/drawing-menu/drawing-menu.scss"() {
  }
});

// src/graphics/icons/draw-icon.tsx
var React85, DrawIcon;
var init_draw_icon = __esm({
  "src/graphics/icons/draw-icon.tsx"() {
    React85 = __toESM(require_react());
    DrawIcon = (props) => /* @__PURE__ */ React85.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: "1em",
      viewBox: "0 -960 960 960",
      width: "1em",
      ...props
    }, /* @__PURE__ */ React85.createElement("path", {
      d: "M554-120q-54 0-91-37t-37-89q0-76 61.5-137.5T641-460q-3-36-18-54.5T582-533q-30 0-65 25t-83 82q-78 93-114.5 121T241-277q-51 0-86-38t-35-92q0-54 23.5-110.5T223-653q19-26 28-44t9-29q0-7-2.5-10.5T250-740q-5 0-12 3t-15 11q-15 14-34.5 15T155-724q-15-16-15.5-37.5T155-797q24-21 48-32t47-11q46 0 78 32t32 80q0 29-15 64t-50 84q-38 54-56.5 95T220-413q0 17 5.5 26.5T241-377q10 0 17.5-5.5T286-409q13-14 31-34.5t44-50.5q63-75 114-107t107-32q67 0 110 45t49 123h49q21 0 35.5 14.5T840-415q0 21-14.5 35.5T790-365h-49q-8 112-58.5 178.5T554-120Zm2-100q32 0 54-36.5T640-358q-46 11-80 43.5T526-250q0 14 8 22t22 8Z"
    }));
  }
});

// src/graphics/icons/pointer-icon.tsx
var React86, PointerIcon;
var init_pointer_icon = __esm({
  "src/graphics/icons/pointer-icon.tsx"() {
    React86 = __toESM(require_react());
    PointerIcon = (props) => /* @__PURE__ */ React86.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      width: "1em",
      height: "1em",
      viewBox: "0 0 24 24",
      fill: "none",
      stroke: "currentColor",
      strokeWidth: "2",
      strokeLinecap: "round",
      strokeLinejoin: "round",
      ...props
    }, /* @__PURE__ */ React86.createElement("path", {
      d: "M22 14a8 8 0 0 1-8 8"
    }), /* @__PURE__ */ React86.createElement("path", {
      d: "M18 11v-1a2 2 0 0 0-2-2a2 2 0 0 0-2 2"
    }), /* @__PURE__ */ React86.createElement("path", {
      d: "M14 10V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1"
    }), /* @__PURE__ */ React86.createElement("path", {
      d: "M10 9.5V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v10"
    }), /* @__PURE__ */ React86.createElement("path", {
      d: "M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"
    }));
  }
});

// src/components/jsx-components/drawing-menu/ink-canvas-drawing-menu.tsx
function inkToolToMenuTool(inkTool) {
  if (inkTool === "select")
    return "select" /* select */;
  if (inkTool === "erase")
    return "eraser" /* eraser */;
  return "draw" /* draw */;
}
var React87, import_classnames32, InkCanvasDrawingMenu;
var init_ink_canvas_drawing_menu = __esm({
  "src/components/jsx-components/drawing-menu/ink-canvas-drawing-menu.tsx"() {
    init_10();
    init_2();
    React87 = __toESM(require_react());
    init_select_icon();
    init_erase_icon();
    init_draw_icon();
    init_expand_icon();
    init_pointer_icon();
    import_classnames32 = __toESM(require_classnames());
    init_tooltip_button();
    InkCanvasDrawingMenu = React87.forwardRef((props, ref) => {
      const [curTool, setCurTool] = React87.useState("draw" /* draw */);
      React87.useEffect(() => {
        let unsubscribe;
        let pollId;
        const trySubscribe = () => {
          const editor = props.getEditor();
          if (!editor?.subscribeToolChange)
            return false;
          unsubscribe = editor.subscribeToolChange((inkTool) => {
            setCurTool(inkToolToMenuTool(inkTool));
          });
          return true;
        };
        if (!trySubscribe()) {
          pollId = window.setInterval(() => {
            if (trySubscribe() && pollId !== void 0) {
              window.clearInterval(pollId);
              pollId = void 0;
            }
          }, 100);
        }
        return () => {
          if (pollId !== void 0)
            window.clearInterval(pollId);
          unsubscribe?.();
        };
      }, [props.getEditor]);
      function activateSelectTool() {
        const editor = props.getEditor();
        if (!editor)
          return;
        editor.setTool("select");
        setCurTool("select" /* select */);
        props.onActivateTool?.("select");
      }
      function activateDrawTool() {
        const editor = props.getEditor();
        if (!editor)
          return;
        editor.setTool("draw");
        setCurTool("draw" /* draw */);
        props.onActivateTool?.("draw");
      }
      function activateEraseTool() {
        const editor = props.getEditor();
        if (!editor)
          return;
        editor.setTool("erase");
        setCurTool("eraser" /* eraser */);
        props.onActivateTool?.("erase");
      }
      return /* @__PURE__ */ React87.createElement(React87.Fragment, null, /* @__PURE__ */ React87.createElement("div", {
        ref,
        className: (0, import_classnames32.default)([
          "ink_menu-bar",
          "ink_menu-bar_full"
        ])
      }, (props.showFingerDrawingToggle || props.onExpandClick) && /* @__PURE__ */ React87.createElement("div", {
        className: "ink_quick-menu"
      }, props.onExpandClick && /* @__PURE__ */ React87.createElement(TooltipButton, {
        tooltip: "Open in full view",
        onClick: () => props.onExpandClick?.()
      }, /* @__PURE__ */ React87.createElement(ExpandIcon, null)), props.showFingerDrawingToggle && /* @__PURE__ */ React87.createElement(TooltipButton, {
        tooltip: props.isFingerDrawingActive ? "Enable drawing with finger" : "Disable drawing with finger",
        className: props.isFingerDrawingActive ? "ink_menu-toggle--active" : void 0,
        onClick: () => props.onFingerDrawingToggle?.()
      }, /* @__PURE__ */ React87.createElement(PointerIcon, null))), /* @__PURE__ */ React87.createElement("div", {
        className: "ink_tool-menu"
      }, /* @__PURE__ */ React87.createElement(TooltipButton, {
        tooltip: "Select",
        onClick: activateSelectTool,
        disabled: curTool === "select" /* select */
      }, /* @__PURE__ */ React87.createElement(SelectIcon, null)), /* @__PURE__ */ React87.createElement(TooltipButton, {
        tooltip: "Draw",
        onClick: activateDrawTool,
        disabled: curTool === "draw" /* draw */
      }, /* @__PURE__ */ React87.createElement(DrawIcon, null)), /* @__PURE__ */ React87.createElement(TooltipButton, {
        tooltip: "Erase",
        onClick: activateEraseTool,
        disabled: curTool === "eraser" /* eraser */
      }, /* @__PURE__ */ React87.createElement(EraseIcon, null))), /* @__PURE__ */ React87.createElement("div", {
        className: "ink_other-menu"
      })));
    });
  }
});

// src/components/jsx-components/secondary-menu-bar/secondary-menu-bar.scss
var init_11 = __esm({
  "src/components/jsx-components/secondary-menu-bar/secondary-menu-bar.scss"() {
  }
});

// src/components/jsx-components/secondary-menu-bar/secondary-menu-bar.tsx
var import_classnames33, React88, SecondaryMenuBar;
var init_secondary_menu_bar = __esm({
  "src/components/jsx-components/secondary-menu-bar/secondary-menu-bar.tsx"() {
    import_classnames33 = __toESM(require_classnames());
    init_11();
    React88 = __toESM(require_react());
    SecondaryMenuBar = (props) => {
      const scrollContainerElRef = React88.useRef(null);
      const SecondaryMenuBarElRef = React88.useRef(null);
      const [menuActive] = React88.useState(true);
      React88.useEffect(() => {
        initScrollHandler();
        return () => {
          cleanUpScrollHandler();
        };
      });
      return /* @__PURE__ */ React88.createElement(React88.Fragment, null, /* @__PURE__ */ React88.createElement("div", {
        ref: SecondaryMenuBarElRef,
        className: (0, import_classnames33.default)([
          "ink_secondary-menu-bar",
          menuActive && "ddc_ink_active"
        ])
      }, props.children));
      function initScrollHandler() {
        const SecondaryMenuBar2 = SecondaryMenuBarElRef.current;
        const scrollEl = SecondaryMenuBar2?.closest(".cm-scroller");
        if (!scrollEl)
          return;
        scrollEl.addEventListener("scroll", handleScrolling);
        window.setTimeout(() => {
          scrollEl.dispatchEvent(new CustomEvent("scroll"));
        }, 500);
      }
      function cleanUpScrollHandler() {
        const scrollEl = scrollContainerElRef.current;
        scrollEl?.removeEventListener("scroll", handleScrolling);
      }
      function handleScrolling(e2) {
        const scrollAreaEl = e2.target;
        const SecondaryMenuBar2 = SecondaryMenuBarElRef.current;
        const embedEl = SecondaryMenuBar2?.parentElement;
        if (!SecondaryMenuBar2)
          return;
        if (!embedEl)
          return;
        const scrollAreaHeight = scrollAreaEl.getBoundingClientRect().height;
        const menuBarHeight = SecondaryMenuBar2.getBoundingClientRect().height;
        const embedHeight = embedEl.getBoundingClientRect().height;
        let embedPosY = embedEl.getBoundingClientRect().top - scrollAreaEl.getBoundingClientRect().top || 0;
        if (menuActive) {
          embedPosY += Number(menuBarHeight);
        }
        const embedOffsetY = embedPosY;
        const embedBottomScrolledOffScrollAreaBottom = embedOffsetY + embedHeight - menuBarHeight / 2 > scrollAreaHeight;
        const embedTopScrolledOffScrollAreaBottom = embedOffsetY > scrollAreaHeight;
        if (embedTopScrolledOffScrollAreaBottom) {
          const bottom2 = embedHeight + "px";
          SecondaryMenuBar2.style.bottom = bottom2;
        } else if (embedBottomScrolledOffScrollAreaBottom) {
          const bottom2 = embedOffsetY + embedHeight - scrollAreaHeight - menuBarHeight / 2 + "px";
          SecondaryMenuBar2.style.bottom = bottom2;
        } else {
          SecondaryMenuBar2.style.removeProperty("bottom");
        }
      }
    };
  }
});

// src/components/jsx-components/ink-canvas-modify-menu/modify-menu.scss
var init_12 = __esm({
  "src/components/jsx-components/ink-canvas-modify-menu/modify-menu.scss"() {
  }
});

// src/graphics/icons/undo-icon.tsx
var React89, UndoIcon;
var init_undo_icon = __esm({
  "src/graphics/icons/undo-icon.tsx"() {
    React89 = __toESM(require_react());
    UndoIcon = (props) => /* @__PURE__ */ React89.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React89.createElement("path", {
      d: "M320-200q-17 0-28.5-11.5T280-240q0-17 11.5-28.5T320-280h244q63 0 109.5-40T720-420q0-60-46.5-100T564-560H312l76 76q11 11 11 28t-11 28q-11 11-28 11t-28-11L188-572q-6-6-8.5-13t-2.5-15q0-8 2.5-15t8.5-13l144-144q11-11 28-11t28 11q11 11 11 28t-11 28l-76 76h252q97 0 166.5 63T800-420q0 94-69.5 157T564-200H320Z"
    }));
  }
});

// src/graphics/icons/redo-icon.tsx
var React90, RedoIcon;
var init_redo_icon = __esm({
  "src/graphics/icons/redo-icon.tsx"() {
    React90 = __toESM(require_react());
    RedoIcon = (props) => /* @__PURE__ */ React90.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React90.createElement("path", {
      d: "M648-560H396q-63 0-109.5 40T240-420q0 60 46.5 100T396-280h244q17 0 28.5 11.5T680-240q0 17-11.5 28.5T640-200H396q-97 0-166.5-63T160-420q0-94 69.5-157T396-640h252l-76-76q-11-11-11-28t11-28q11-11 28-11t28 11l144 144q6 6 8.5 13t2.5 15q0 8-2.5 15t-8.5 13L628-428q-11 11-28 11t-28-11q-11-11-11-28t11-28l76-76Z"
    }));
  }
});

// src/logic/undo-redo/ink-editor-registry.ts
function firstEmbedIdInLeaf(workspaceLeafId) {
  for (const [embedId, entry] of registry) {
    if (entry.workspaceLeafId === workspaceLeafId) {
      return embedId;
    }
  }
  return null;
}
function register(embedId, editor, containerEl, workspaceLeafId, applyResize) {
  registry.set(embedId, { editor, containerEl, workspaceLeafId, applyResize });
  activeEmbedIdByLeafId.set(workspaceLeafId, embedId);
  containerEl.addEventListener("mousedown", () => {
    setActiveEmbedForLeaf(workspaceLeafId, embedId);
  });
}
function setActiveEmbedForLeaf(workspaceLeafId, embedId) {
  const entry = registry.get(embedId);
  if (entry && entry.workspaceLeafId === workspaceLeafId) {
    activeEmbedIdByLeafId.set(workspaceLeafId, embedId);
  }
}
function unregister(embedId) {
  const entry = registry.get(embedId);
  if (!entry)
    return;
  const { workspaceLeafId } = entry;
  registry.delete(embedId);
  clearEmbedBaseline(workspaceLeafId, embedId);
  purgeEmbedEntriesFromStacks(workspaceLeafId, embedId);
  if (activeEmbedIdByLeafId.get(workspaceLeafId) === embedId) {
    const next = firstEmbedIdInLeaf(workspaceLeafId);
    if (next)
      activeEmbedIdByLeafId.set(workspaceLeafId, next);
    else
      activeEmbedIdByLeafId.delete(workspaceLeafId);
  }
}
function getEditor(embedId) {
  return registry.get(embedId)?.editor;
}
function getResizeApplier(embedId) {
  return registry.get(embedId)?.applyResize;
}
function getRegisteredEmbedCountForLeaf(workspaceLeafId) {
  let n2 = 0;
  for (const entry of registry.values()) {
    if (entry.workspaceLeafId === workspaceLeafId)
      n2++;
  }
  return n2;
}
function getRegisteredEmbedIdsForLeaf(workspaceLeafId) {
  const embedIds = [];
  for (const [embedId, entry] of registry) {
    if (entry.workspaceLeafId === workspaceLeafId) {
      embedIds.push(embedId);
    }
  }
  return embedIds;
}
function getActiveEmbedIdForLeaf(workspaceLeafId) {
  const id = activeEmbedIdByLeafId.get(workspaceLeafId);
  if (id && registry.has(id))
    return id;
  return null;
}
var registry, activeEmbedIdByLeafId;
var init_ink_editor_registry = __esm({
  "src/logic/undo-redo/ink-editor-registry.ts"() {
    init_unified_undo_stack();
    registry = /* @__PURE__ */ new Map();
    activeEmbedIdByLeafId = /* @__PURE__ */ new Map();
  }
});

// src/logic/undo-redo/obsidian-undo-depth.ts
function getMarkdownViewForLeaf(plugin, leafId) {
  let found = null;
  plugin.app.workspace.iterateAllLeaves((leaf) => {
    if (found)
      return;
    if (leaf.id === leafId && leaf.view instanceof import_obsidian12.MarkdownView) {
      found = leaf.view;
    }
  });
  return found;
}
function undoDepthFromMarkdownView(md) {
  const editor = md?.editor;
  if (!editor)
    return 0;
  const cmView = editor.cm;
  if (!cmView)
    return 0;
  try {
    return (0, import_commands.undoDepth)(cmView.state);
  } catch {
    return 0;
  }
}
function getObsidianUndoDepthForLeaf(plugin, leafId) {
  return undoDepthFromMarkdownView(getMarkdownViewForLeaf(plugin, leafId));
}
var import_commands, import_obsidian12;
var init_obsidian_undo_depth = __esm({
  "src/logic/undo-redo/obsidian-undo-depth.ts"() {
    import_commands = require("@codemirror/commands");
    import_obsidian12 = require("obsidian");
  }
});

// src/logic/undo-redo/tldraw-undo-depth.ts
function getTldrawNumUndos(editor) {
  if ("getUndoCount" in editor && typeof editor.getUndoCount === "function") {
    return editor.getUndoCount();
  }
  const history = editor.history;
  return history?.getNumUndos?.() ?? 0;
}
var init_tldraw_undo_depth = __esm({
  "src/logic/undo-redo/tldraw-undo-depth.ts"() {
  }
});

// src/logic/undo-redo/unified-undo-stack.ts
function getLeafState(leafId) {
  let s2 = leafStates.get(leafId);
  if (!s2) {
    s2 = {
      undoStack: [],
      redoStack: [],
      prevObsidianDepth: 0,
      prevTldrawUndosByEmbed: /* @__PURE__ */ new Map()
    };
    leafStates.set(leafId, s2);
  }
  return s2;
}
function pluginWithInkUndoFlags(plugin) {
  return plugin && typeof plugin === "object" ? plugin : null;
}
function setProgrammaticRedoInProgress(value, plugin) {
  const target = pluginWithInkUndoFlags(plugin ?? (() => {
    try {
      return getGlobals().plugin;
    } catch {
      return null;
    }
  })());
  if (target)
    target[PLUGIN_FLAG_KEY_REDO] = value;
}
function setProgrammaticUndoInProgress(value, plugin) {
  const target = pluginWithInkUndoFlags(plugin ?? (() => {
    try {
      return getGlobals().plugin;
    } catch {
      return null;
    }
  })());
  if (target)
    target[PLUGIN_FLAG_KEY_UNDO] = value;
}
function isProgrammaticRedoInProgress() {
  try {
    const plugin = pluginWithInkUndoFlags(getGlobals().plugin);
    return !!plugin?.[PLUGIN_FLAG_KEY_REDO];
  } catch {
    return false;
  }
}
function isProgrammaticUndoInProgress() {
  try {
    const plugin = pluginWithInkUndoFlags(getGlobals().plugin);
    return !!plugin?.[PLUGIN_FLAG_KEY_UNDO];
  } catch {
    return false;
  }
}
function formatEntry(entry) {
  if (entry.type === "obsidian")
    return "Obsidian";
  if (entry.type === "embed-resize")
    return `EmbedResize:${entry.embedId}`;
  return `Embed:${entry.embedId}`;
}
function formatStackForLog(stack2) {
  return "[" + stack2.map(formatEntry).join(", ") + "]";
}
function initialize(leafId, obsidianDepth, tldrawUndos, seedTldrawByEmbed, options) {
  const s2 = getLeafState(leafId);
  s2.prevObsidianDepth = obsidianDepth;
  if (options?.mergeWithExisting && options.embedId) {
    s2.prevTldrawUndosByEmbed.set(options.embedId, tldrawUndos ?? 0);
    return;
  }
  if (seedTldrawByEmbed) {
    s2.prevTldrawUndosByEmbed.clear();
    for (const [id, count3] of Object.entries(seedTldrawByEmbed)) {
      s2.prevTldrawUndosByEmbed.set(id, count3);
    }
  } else {
    s2.prevTldrawUndosByEmbed.clear();
  }
  s2.undoStack = [];
  s2.redoStack = [];
}
function syncUnifiedUndoHistory(leafId, embedId, options) {
  const editor = getEditor(embedId);
  if (!editor) {
    return;
  }
  const s2 = getLeafState(leafId);
  const plugin = getGlobals().plugin;
  const obsidianDepth = getObsidianUndoDepthForLeaf(plugin, leafId);
  const tldrawUndos = getTldrawNumUndos(editor);
  const prevTldrawUndos = s2.prevTldrawUndosByEmbed.get(embedId) ?? 0;
  const skipObsidian = options?.skipObsidian ?? false;
  const skipEmbed = options?.skipEmbed ?? false;
  const obsidianDelta = skipObsidian ? 0 : Math.max(0, obsidianDepth - s2.prevObsidianDepth);
  let tldrawDelta = skipEmbed ? 0 : Math.max(0, tldrawUndos - prevTldrawUndos);
  if (options?.maxTldrawDelta !== void 0) {
    tldrawDelta = Math.min(tldrawDelta, options.maxTldrawDelta);
  }
  if (isProgrammaticRedoInProgress()) {
    s2.prevObsidianDepth = obsidianDepth;
    s2.prevTldrawUndosByEmbed.set(embedId, tldrawUndos);
    return;
  }
  if (isProgrammaticUndoInProgress()) {
    return;
  }
  const added = [];
  for (let i2 = 0; i2 < obsidianDelta; i2++) {
    s2.undoStack.push({ type: "obsidian" });
    added.push("Obsidian");
  }
  for (let i2 = 0; i2 < tldrawDelta; i2++) {
    s2.undoStack.push({ type: "embed", embedId });
    added.push(`Embed:${embedId}`);
  }
  if (added.length > 0) {
    verbose(`[undo-redo] Undo stack before: ${formatStackForLog(s2.undoStack.slice(0, -added.length))}`);
    verbose(`[undo-redo] Undo stack after: ${formatStackForLog([...s2.undoStack])}`);
    s2.redoStack = [];
  }
  if (!skipObsidian) {
    s2.prevObsidianDepth = obsidianDepth;
  }
  if (!skipEmbed) {
    s2.prevTldrawUndosByEmbed.set(embedId, tldrawUndos);
  }
}
function pushEmbedCanvasActionToUnifiedStack(leafId, embedId) {
  if (isProgrammaticRedoInProgress() || isProgrammaticUndoInProgress()) {
    return;
  }
  const editor = getEditor(embedId);
  if (!editor)
    return;
  const s2 = getLeafState(leafId);
  const plugin = getGlobals().plugin;
  const obsidianDepth = getObsidianUndoDepthForLeaf(plugin, leafId);
  const obsidianDelta = Math.max(0, obsidianDepth - s2.prevObsidianDepth);
  const tldrawUndos = getTldrawNumUndos(editor);
  for (let i2 = 0; i2 < obsidianDelta; i2++) {
    s2.undoStack.push({ type: "obsidian" });
  }
  s2.undoStack.push({ type: "embed", embedId });
  s2.redoStack = [];
  s2.prevObsidianDepth = obsidianDepth;
  s2.prevTldrawUndosByEmbed.set(embedId, tldrawUndos);
}
function pushDrawingEmbedResize(leafId, entry) {
  const s2 = getLeafState(leafId);
  s2.undoStack.push(entry);
  s2.redoStack = [];
  verbose(`[undo-redo] Pushed embed-resize. Undo stack after: ${formatStackForLog([...s2.undoStack])}`);
}
function getUndoStackSnapshot(leafId) {
  return [...getLeafState(leafId).undoStack];
}
function popUndo(leafId) {
  return getLeafState(leafId).undoStack.pop() ?? null;
}
function pushRedo(leafId, entry) {
  getLeafState(leafId).redoStack.push(entry);
}
function popRedo(leafId) {
  return getLeafState(leafId).redoStack.pop() ?? null;
}
function pushUndo(leafId, entry) {
  getLeafState(leafId).undoStack.push(entry);
}
function isUndoStackEmpty(leafId) {
  return getLeafState(leafId).undoStack.length === 0;
}
function isRedoStackEmpty(leafId) {
  return getLeafState(leafId).redoStack.length === 0;
}
function notifyUndoExecuted(leafId, entry) {
  const s2 = getLeafState(leafId);
  if (entry.type === "obsidian") {
    s2.prevObsidianDepth = Math.max(0, s2.prevObsidianDepth - 1);
  } else if (entry.type === "embed-resize") {
  } else {
    const current = s2.prevTldrawUndosByEmbed.get(entry.embedId) ?? 0;
    s2.prevTldrawUndosByEmbed.set(entry.embedId, Math.max(0, current - 1));
  }
}
function notifyRedoExecuted(leafId, entry) {
  const s2 = getLeafState(leafId);
  if (entry.type === "obsidian") {
    s2.prevObsidianDepth += 1;
  } else if (entry.type === "embed-resize") {
  } else {
    const current = s2.prevTldrawUndosByEmbed.get(entry.embedId) ?? 0;
    s2.prevTldrawUndosByEmbed.set(entry.embedId, current + 1);
  }
}
function clearEmbedBaseline(leafId, embedId) {
  getLeafState(leafId).prevTldrawUndosByEmbed.delete(embedId);
}
function purgeEmbedEntriesFromStacks(leafId, embedId) {
  const s2 = getLeafState(leafId);
  const matchesEmbed = (e2) => e2.type === "embed" && e2.embedId === embedId || e2.type === "embed-resize" && e2.embedId === embedId;
  s2.undoStack = s2.undoStack.filter((e2) => !matchesEmbed(e2));
  s2.redoStack = s2.redoStack.filter((e2) => !matchesEmbed(e2));
}
function findTopmostEmbedIndex(stack2, embedId) {
  return stack2.findIndex((e2) => e2.type === "embed" && e2.embedId === embedId);
}
function popEmbedUndoAndPushToRedo(leafId, embedId) {
  const s2 = getLeafState(leafId);
  const index3 = findTopmostEmbedIndex(s2.undoStack, embedId);
  if (index3 < 0)
    return null;
  const entry = s2.undoStack.splice(index3, 1)[0];
  notifyUndoExecuted(leafId, entry);
  s2.redoStack.push(entry);
  verbose(`[undo-redo] Local embed undo: moved ${formatEntry(entry)} to redo. Undo stack after: ${formatStackForLog([...s2.undoStack])}`);
  return entry;
}
function popEmbedRedoAndPushToUndo(leafId, embedId) {
  const s2 = getLeafState(leafId);
  const index3 = findTopmostEmbedIndex(s2.redoStack, embedId);
  if (index3 < 0)
    return null;
  const entry = s2.redoStack.splice(index3, 1)[0];
  notifyRedoExecuted(leafId, entry);
  s2.undoStack.push(entry);
  verbose(`[undo-redo] Local embed redo: moved ${formatEntry(entry)} to undo. Undo stack after: ${formatStackForLog([...s2.undoStack])}`);
  return entry;
}
var leafStates, PLUGIN_FLAG_KEY_REDO, PLUGIN_FLAG_KEY_UNDO;
var init_unified_undo_stack = __esm({
  "src/logic/undo-redo/unified-undo-stack.ts"() {
    init_universal_dev_logging();
    init_global_store();
    init_ink_editor_registry();
    init_obsidian_undo_depth();
    init_tldraw_undo_depth();
    leafStates = /* @__PURE__ */ new Map();
    PLUGIN_FLAG_KEY_REDO = "__inkProgrammaticRedoInProgress";
    PLUGIN_FLAG_KEY_UNDO = "__inkProgrammaticUndoInProgress";
  }
});

// src/components/jsx-components/ink-canvas-modify-menu/ink-canvas-modify-menu.tsx
var React91, import_classnames34, InkCanvasModifyMenu;
var init_ink_canvas_modify_menu = __esm({
  "src/components/jsx-components/ink-canvas-modify-menu/ink-canvas-modify-menu.tsx"() {
    init_12();
    React91 = __toESM(require_react());
    init_undo_icon();
    init_redo_icon();
    import_classnames34 = __toESM(require_classnames());
    init_tooltip_button();
    init_unified_undo_stack();
    InkCanvasModifyMenu = React91.forwardRef((props, ref) => {
      const [canUndo, setCanUndo] = React91.useState(false);
      const [canRedo, setCanRedo] = React91.useState(false);
      React91.useEffect(() => {
        const intervalId = window.setInterval(() => {
          const editor = props.getEditor();
          if (!editor)
            return;
          setCanUndo(editor.canUndo());
          setCanRedo(editor.canRedo());
        }, 200);
        return () => window.clearInterval(intervalId);
      }, []);
      function undo() {
        const editor = props.getEditor();
        if (!editor)
          return;
        const embedId = props.embedId;
        const leafId = props.workspaceLeafId;
        const plugin = props.plugin;
        if (embedId && leafId && plugin) {
          setProgrammaticUndoInProgress(true, plugin);
          try {
            editor.undo();
            popEmbedUndoAndPushToRedo(leafId, embedId);
          } finally {
            const pluginRef = plugin;
            window.setTimeout(() => setProgrammaticUndoInProgress(false, pluginRef), 50);
          }
        } else {
          editor.undo();
        }
        props.onStoreChange();
      }
      function redo() {
        const editor = props.getEditor();
        if (!editor)
          return;
        const embedId = props.embedId;
        const leafId = props.workspaceLeafId;
        const plugin = props.plugin;
        if (embedId && leafId && plugin) {
          setProgrammaticRedoInProgress(true, plugin);
          try {
            editor.redo();
            popEmbedRedoAndPushToUndo(leafId, embedId);
          } finally {
            const pluginRef = plugin;
            window.setTimeout(() => setProgrammaticRedoInProgress(false, pluginRef), 50);
          }
        } else {
          editor.redo();
        }
        props.onStoreChange();
      }
      return /* @__PURE__ */ React91.createElement(React91.Fragment, null, /* @__PURE__ */ React91.createElement("div", {
        ref,
        className: (0, import_classnames34.default)([
          "ink_menu-bar",
          "ink_menu-bar_floating"
        ])
      }, /* @__PURE__ */ React91.createElement("div", {
        className: "ink_modify-menu"
      }, /* @__PURE__ */ React91.createElement(TooltipButton, {
        tooltip: "Redo",
        onClick: redo,
        disabled: !canRedo
      }, /* @__PURE__ */ React91.createElement(RedoIcon, null)), /* @__PURE__ */ React91.createElement(TooltipButton, {
        tooltip: "Undo",
        onClick: undo,
        disabled: !canUndo
      }, /* @__PURE__ */ React91.createElement(UndoIcon, null)))));
    });
  }
});

// src/components/jsx-components/expand-lines-button/expand-lines-button.scss
var init_13 = __esm({
  "src/components/jsx-components/expand-lines-button/expand-lines-button.scss"() {
  }
});

// src/graphics/icons/chevron-down-icon.tsx
var React92, ChevronDownIcon;
var init_chevron_down_icon = __esm({
  "src/graphics/icons/chevron-down-icon.tsx"() {
    React92 = __toESM(require_react());
    ChevronDownIcon = (props) => /* @__PURE__ */ React92.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "0 -960 960 960",
      width: 24,
      ...props
    }, /* @__PURE__ */ React92.createElement("path", {
      d: "M480-344 240-584l56-56 184 184 184-184 56 56-240 240Z"
    }));
  }
});

// src/components/jsx-components/expand-lines-button/expand-lines-button.tsx
var React93, ExpandLinesButton;
var init_expand_lines_button = __esm({
  "src/components/jsx-components/expand-lines-button/expand-lines-button.tsx"() {
    init_13();
    React93 = __toESM(require_react());
    init_chevron_down_icon();
    init_tooltip_button();
    ExpandLinesButton = (props) => {
      return /* @__PURE__ */ React93.createElement(React93.Fragment, null, /* @__PURE__ */ React93.createElement("div", {
        className: "ink_expand-lines-button"
      }, /* @__PURE__ */ React93.createElement(TooltipButton, {
        tooltip: "Add more lines",
        onClick: props.onExpandLines
      }, /* @__PURE__ */ React93.createElement(ChevronDownIcon, null))));
    };
  }
});

// src/logic/device-settings/use-finger-drawing-enabled.ts
function useFingerDrawingEnabled() {
  const [isEnabled, setIsEnabled] = (0, import_react124.useState)(() => getFingerDrawingEnabled());
  (0, import_react124.useEffect)(() => {
    setIsEnabled(getFingerDrawingEnabled());
    return subscribeDeviceSettingsChanged(() => {
      setIsEnabled(getFingerDrawingEnabled());
    });
  }, []);
  return isEnabled;
}
var import_react124;
var init_use_finger_drawing_enabled = __esm({
  "src/logic/device-settings/use-finger-drawing-enabled.ts"() {
    import_react124 = __toESM(require_react());
    init_device_settings();
  }
});

// src/logic/utils/restore-embed-cm-scroller-scroll.ts
function restoreEmbedCmScrollerScroll(wrapperEl) {
  if (!wrapperEl)
    return;
  const scroller = wrapperEl.closest(".cm-scroller") ?? wrapperEl.closest(".ddc_ink_writing-dedicated-scroller");
  if (!scroller)
    return;
  scroller.classList.remove("ink-cm-scroller--scroll-pinned");
  scroller.style.overflow = "auto";
  window.setTimeout(() => {
    scroller.style.scrollbarColor = "auto";
  }, 200);
}
var init_restore_embed_cm_scroller_scroll = __esm({
  "src/logic/utils/restore-embed-cm-scroller-scroll.ts"() {
  }
});

// src/components/formats/current/writing/writing-embed/writing-embed.scss
var init_14 = __esm({
  "src/components/formats/current/writing/writing-embed/writing-embed.scss"() {
  }
});

// src/components/dom-components/modals/migration-modal/migration-modal.scss
var init_15 = __esm({
  "src/components/dom-components/modals/migration-modal/migration-modal.scss"() {
  }
});

// src/ink-canvas/fit-strokes-for-mode-conversion.ts
function cloneStrokes(strokes) {
  return strokes.map((stroke) => ({
    ...stroke,
    points: stroke.points.map((point) => [...point]),
    style: { ...stroke.style },
    offset: { x: stroke.offset.x, y: stroke.offset.y }
  }));
}
function transformStroke(stroke, scale, translateX, translateY) {
  return {
    ...stroke,
    points: stroke.points.map(([x2, y2, pressure]) => [
      x2 * scale,
      y2 * scale,
      pressure
    ]),
    offset: {
      x: stroke.offset.x * scale + translateX,
      y: stroke.offset.y * scale + translateY
    },
    style: {
      ...stroke.style,
      size: stroke.style.size * scale
    }
  };
}
function computeDrawingToWritingScale(strokes, writingLineHeight, pageWidth) {
  const bounds = computeStrokesBounds(strokes);
  if (bounds.width <= 0 || bounds.height <= 0)
    return 1;
  const margin = pageWidth * 0.05;
  const contentWidth = pageWidth - 2 * margin;
  const topY = writingLineHeight * 0.5;
  let scale = Math.min(contentWidth / bounds.width, 1);
  const projectedMaxY = topY + bounds.height * scale;
  const invitingPageHeight = Math.max((Math.ceil(projectedMaxY / writingLineHeight) + 0.5) * writingLineHeight, WRITING_MIN_PAGE_HEIGHT);
  const maxContentHeight = invitingPageHeight - topY;
  if (bounds.height * scale > maxContentHeight) {
    scale = Math.min(scale, maxContentHeight / bounds.height);
  }
  return scale;
}
function previewDrawingToWritingScale(strokes, writingLineHeight = WRITING_LINE_HEIGHT, pageWidth = WRITING_PAGE_WIDTH) {
  if (strokes.length === 0)
    return 1;
  return computeDrawingToWritingScale(strokes, writingLineHeight, pageWidth);
}
function fitStrokesForDrawingToWriting(strokes, writingLineHeight = WRITING_LINE_HEIGHT, pageWidth = WRITING_PAGE_WIDTH) {
  if (strokes.length === 0)
    return [];
  const bounds = computeStrokesBounds(strokes);
  if (bounds.width <= 0 || bounds.height <= 0) {
    return cloneStrokes(strokes);
  }
  const margin = pageWidth * 0.05;
  const contentWidth = pageWidth - 2 * margin;
  const topY = writingLineHeight * 0.5;
  const scale = computeDrawingToWritingScale(strokes, writingLineHeight, pageWidth);
  const translateX = margin + (contentWidth - bounds.width * scale) / 2 - bounds.minX * scale;
  const translateY = topY - bounds.minY * scale;
  return cloneStrokes(strokes).map((stroke) => transformStroke(stroke, scale, translateX, translateY));
}
var init_fit_strokes_for_mode_conversion = __esm({
  "src/ink-canvas/fit-strokes-for-mode-conversion.ts"() {
    init_constants();
    init_svg_export();
  }
});

// src/components/formats/current/utils/convert-ink-canvas-between-modes.ts
function cloneInkCanvasSnapshot(snapshot) {
  return {
    ...snapshot,
    strokes: snapshot.strokes.map((stroke) => ({
      ...stroke,
      points: stroke.points.map((point) => [...point]),
      style: { ...stroke.style },
      offset: { ...stroke.offset }
    }))
  };
}
function convertWriteInkCanvasDataToDraw(data, gridEnabled = DEFAULT_SETTINGS.drawingGridEnabledByDefault) {
  if (!isInkCanvasFile(data) || !data.inkCanvas) {
    throw new Error("convertWriteInkCanvasDataToDraw requires an ink-canvas inkWriting file");
  }
  if (data.meta.fileType !== "inkWriting") {
    throw new Error("convertWriteInkCanvasDataToDraw requires fileType inkWriting");
  }
  const snapshotClone = cloneInkCanvasSnapshot(data.inkCanvas);
  delete snapshotClone.writingLineHeight;
  delete snapshotClone.camera;
  const inkCanvasSnapshot = {
    ...snapshotClone,
    gridEnabled
  };
  const svgString = renderStrokesToSvg(inkCanvasSnapshot.strokes, inkCanvasSnapshot);
  const fileData = buildInkCanvasDrawingFileData({ inkCanvasSnapshot, svgString });
  fileData.meta.pluginVersion = PLUGIN_VERSION;
  if (data.meta.transcript) {
    fileData.meta.transcript = data.meta.transcript;
  }
  return fileData;
}
function convertDrawInkCanvasDataToWrite(data, defaultWritingLineHeight) {
  if (!isInkCanvasFile(data) || !data.inkCanvas) {
    throw new Error("convertDrawInkCanvasDataToWrite requires an ink-canvas inkDrawing file");
  }
  if (data.meta.fileType !== "inkDrawing") {
    throw new Error("convertDrawInkCanvasDataToWrite requires fileType inkDrawing");
  }
  const writingLineHeight = data.inkCanvas.writingLineHeight ?? defaultWritingLineHeight;
  const snapshotRest = cloneInkCanvasSnapshot(data.inkCanvas);
  delete snapshotRest.camera;
  const fittedStrokes = fitStrokesForDrawingToWriting(snapshotRest.strokes, writingLineHeight, WRITING_PAGE_WIDTH);
  const inkCanvasSnapshot = {
    ...snapshotRest,
    strokes: fittedStrokes,
    gridEnabled: false,
    writingLineHeight
  };
  const svgString = renderWritingStrokesToSvg(inkCanvasSnapshot.strokes, inkCanvasSnapshot, WRITING_PAGE_WIDTH);
  const fileData = buildInkCanvasWritingFileData({ inkCanvasSnapshot, svgString });
  fileData.meta.pluginVersion = PLUGIN_VERSION;
  if (data.meta.transcript) {
    fileData.meta.transcript = data.meta.transcript;
  }
  if (inkCanvasSnapshot.writingLineHeight != null) {
    fileData.meta.writingLineHeight = inkCanvasSnapshot.writingLineHeight;
  }
  return fileData;
}
var init_convert_ink_canvas_between_modes = __esm({
  "src/components/formats/current/utils/convert-ink-canvas-between-modes.ts"() {
    init_plugin_settings();
    init_constants();
    init_fit_strokes_for_mode_conversion();
    init_svg_export();
    init_build_file_data();
    init_ink_file_storage_engine();
  }
});

// src/components/formats/current/utils/convertWriteFileToDraw.ts
function convertWriteDataToDraw(data, gridEnabled = DEFAULT_SETTINGS.drawingGridEnabledByDefault) {
  const store = data.tldraw.document.store;
  const updatedStore = { ...store };
  delete updatedStore["shape:writing-container"];
  delete updatedStore["shape:writing-lines"];
  const existingSession = data.tldraw.session ?? {};
  const sessionWithGrid = { ...existingSession, isGridMode: gridEnabled };
  return {
    ...data,
    meta: {
      ...data.meta,
      fileType: "inkDrawing"
    },
    tldraw: {
      ...data.tldraw,
      document: {
        ...data.tldraw.document,
        store: updatedStore
      },
      session: sessionWithGrid
    }
  };
}
var convertWriteFileToDraw;
var init_convertWriteFileToDraw = __esm({
  "src/components/formats/current/utils/convertWriteFileToDraw.ts"() {
    init_extractInkJsonFromSvg();
    init_plugin_settings();
    init_convert_ink_canvas_between_modes();
    init_buildFileStr();
    init_ink_file_storage_engine();
    convertWriteFileToDraw = async (plugin, file) => {
      if (file.extension !== "svg")
        return;
      const v2 = plugin.app.vault;
      const svgStr = await v2.read(file);
      const data = extractInkJsonFromSvg(svgStr);
      if (!data)
        return;
      if (data.meta.fileType !== "inkWriting")
        return;
      const gridEnabled = plugin.settings.drawingGridEnabledByDefault ?? DEFAULT_SETTINGS.drawingGridEnabledByDefault;
      const converted = isInkCanvasFile(data) ? convertWriteInkCanvasDataToDraw(data, gridEnabled) : convertWriteDataToDraw(data, gridEnabled);
      const newSvgStr = isInkCanvasFile(data) ? buildFileStr(converted) : buildFileStr({ ...converted, svgString: svgStr });
      await v2.modify(file, newSvgStr);
    };
  }
});

// src/components/formats/current/utils/convertDrawFileToWrite.ts
function inferTldrawPageId(store) {
  for (const value of Object.values(store)) {
    if (typeof value !== "object" || value === null)
      continue;
    const record = value;
    if (record.typeName === "page" && typeof record.id === "string") {
      return record.id;
    }
  }
  return "page:page";
}
function convertDrawDataToWrite(data) {
  const store = data.tldraw.document.store;
  const pageId = inferTldrawPageId(store);
  const writingContainerShape = {
    x: 0,
    y: 0,
    rotation: 0,
    isLocked: true,
    opacity: 1,
    meta: {},
    type: "writing-container",
    parentId: pageId,
    index: "a0",
    props: {
      x: 0,
      y: 0,
      w: WRITING_PAGE_WIDTH,
      h: WRITING_MIN_PAGE_HEIGHT
    },
    id: "shape:writing-container",
    typeName: "shape"
  };
  const writingLinesShape = {
    x: 0,
    y: 0,
    rotation: 0,
    isLocked: true,
    opacity: 1,
    meta: {},
    type: "writing-lines",
    parentId: pageId,
    index: "a0",
    props: {
      x: 0,
      y: 0,
      w: WRITING_PAGE_WIDTH,
      h: WRITING_MIN_PAGE_HEIGHT
    },
    id: "shape:writing-lines",
    typeName: "shape"
  };
  const updatedStore = {
    ...store,
    ["shape:writing-container"]: writingContainerShape,
    ["shape:writing-lines"]: writingLinesShape
  };
  const existingSession = data.tldraw.session ?? {};
  const sessionWithGridOff = { ...existingSession, isGridMode: false };
  return {
    ...data,
    meta: {
      ...data.meta,
      fileType: "inkWriting"
    },
    tldraw: {
      ...data.tldraw,
      document: {
        ...data.tldraw.document,
        store: updatedStore
      },
      session: sessionWithGridOff
    }
  };
}
var convertDrawFileToWrite;
var init_convertDrawFileToWrite = __esm({
  "src/components/formats/current/utils/convertDrawFileToWrite.ts"() {
    init_extractInkJsonFromSvg();
    init_convert_ink_canvas_between_modes();
    init_buildFileStr();
    init_ink_file_storage_engine();
    init_constants();
    convertDrawFileToWrite = async (plugin, file) => {
      if (file.extension !== "svg")
        return;
      const v2 = plugin.app.vault;
      const svgStr = await v2.read(file);
      const data = extractInkJsonFromSvg(svgStr);
      if (!data)
        return;
      if (data.meta.fileType !== "inkDrawing")
        return;
      const defaultWritingLineHeight = plugin.settings.writingLineHeight ?? WRITING_LINE_HEIGHT;
      const converted = isInkCanvasFile(data) ? convertDrawInkCanvasDataToWrite(data, defaultWritingLineHeight) : convertDrawDataToWrite(data);
      const newSvgStr = isInkCanvasFile(data) ? buildFileStr(converted) : buildFileStr({ ...converted, svgString: svgStr });
      await v2.modify(file, newSvgStr);
    };
  }
});

// src/logic/utils/createFoldersForFilepath.ts
var createFoldersForFilepath;
var init_createFoldersForFilepath = __esm({
  "src/logic/utils/createFoldersForFilepath.ts"() {
    init_universal_dev_logging();
    createFoldersForFilepath = async (plugin, filePath) => {
      const splitPath = filePath.split("/");
      splitPath.pop();
      let prevPath = [];
      for (let i2 = 0; i2 < splitPath.length; i2++) {
        const folderName = splitPath[i2];
        const cascadePath = prevPath.length > 0 ? `${prevPath.join("/")}/${folderName}` : folderName;
        try {
          if (!plugin.app.vault.getAbstractFileByPath(cascadePath)) {
            await plugin.app.vault.createFolder(cascadePath);
            debug(`Created path: ${cascadePath}`);
          }
        } catch (e2) {
          error(`Couldn't create attachment folder for ${cascadePath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
        }
        prevPath.push(folderName);
      }
      ;
    };
  }
});

// src/logic/utils/getDateFilename.ts
function getDateFilename() {
  const date = new Date();
  let monthStr = (date.getMonth() + 1).toString();
  let dateStr = date.getDate().toString();
  let hours = date.getHours();
  let minutesStr = date.getMinutes().toString();
  let suffix = hours < 12 ? "am" : "pm";
  if (minutesStr.length < 2)
    minutesStr = "0" + minutesStr;
  let filename = date.getFullYear() + "." + monthStr + "." + dateStr + " - " + hours + "." + minutesStr + suffix;
  return filename;
}
var init_getDateFilename = __esm({
  "src/logic/utils/getDateFilename.ts"() {
  }
});

// src/logic/utils/parseFilepath.ts
function parseFilepath(filepath) {
  const segments = filepath.split("/");
  let folderpath = segments[0] === "" ? "/" : "";
  const filename = segments.pop() || "";
  const extIndex = filename.lastIndexOf(".");
  const ext = extIndex >= 0 ? filename.slice(extIndex) : "";
  const basename = extIndex >= 0 ? filename.slice(0, extIndex) : filename;
  folderpath = segments.join("/");
  return { folderpath, basename, ext: ext.startsWith(".") ? ext.slice(1) : ext };
}
var init_parseFilepath = __esm({
  "src/logic/utils/parseFilepath.ts"() {
  }
});

// src/logic/utils/getVersionedFilepath.ts
var import_obsidian13, getVersionedFilepath;
var init_getVersionedFilepath = __esm({
  "src/logic/utils/getVersionedFilepath.ts"() {
    import_obsidian13 = require("obsidian");
    init_parseFilepath();
    getVersionedFilepath = async (plugin, seedFilepath) => {
      try {
        const {
          folderpath,
          basename,
          ext
        } = parseFilepath(seedFilepath);
        let pathAndBasename = folderpath + "/" + basename;
        let pathAndVersionedBasename = pathAndBasename;
        let version2 = 1;
        while (await plugin.app.vault.adapter.exists(`${pathAndVersionedBasename}.${ext}`)) {
          version2++;
          pathAndVersionedBasename = pathAndBasename + " (" + version2 + ")";
        }
        return `${pathAndVersionedBasename}.${ext}`;
      } catch (err) {
        console.warn(err);
        new import_obsidian13.Notice(`There was an error finding a non-conflicting filename.`, 0);
        return "";
      }
    };
  }
});

// src/logic/utils/getBaseAttachmentPath.ts
var getBaseAttachmentPath;
var init_getBaseAttachmentPath = __esm({
  "src/logic/utils/getBaseAttachmentPath.ts"() {
    init_plugin_settings();
    init_universal_dev_logging();
    getBaseAttachmentPath = async (plugin, options) => {
      let baseAttachmentPath = "";
      let attachmentFolderLocation;
      if (options.instigatingFileFolderPath) {
        if (plugin.settings.customAttachmentFolders) {
          attachmentFolderLocation = plugin.settings.noteAttachmentFolderLocation;
        } else {
          attachmentFolderLocation = DEFAULT_SETTINGS.noteAttachmentFolderLocation;
        }
      } else {
        if (plugin.settings.customAttachmentFolders) {
          attachmentFolderLocation = plugin.settings.notelessAttachmentFolderLocation;
        } else {
          attachmentFolderLocation = DEFAULT_SETTINGS.notelessAttachmentFolderLocation;
        }
      }
      if (attachmentFolderLocation === "obsidian") {
        if (options.obsAttachmentFolderPath) {
          baseAttachmentPath = options.obsAttachmentFolderPath;
        } else {
          baseAttachmentPath = "";
        }
      } else if (attachmentFolderLocation === "note") {
        if (options.instigatingFileFolderPath) {
          baseAttachmentPath = options.instigatingFileFolderPath;
        } else {
          warn(`There was an error accessing the note's folder. Placing the new file in the vault's root instead.`);
          baseAttachmentPath = "";
        }
      } else {
        baseAttachmentPath = "";
      }
      return baseAttachmentPath;
    };
  }
});

// src/logic/utils/getSubfolderPaths.ts
var getWritingSubfolderPath, getDrawingSubfolderPath;
var init_getSubfolderPaths = __esm({
  "src/logic/utils/getSubfolderPaths.ts"() {
    init_plugin_settings();
    getWritingSubfolderPath = (plugin) => {
      let subFolderPath = DEFAULT_SETTINGS.writingSubfolder;
      if (plugin.settings.customAttachmentFolders) {
        subFolderPath = plugin.settings.writingSubfolder || "";
      }
      return subFolderPath.trim();
    };
    getDrawingSubfolderPath = (plugin) => {
      let subFolderPath = DEFAULT_SETTINGS.drawingSubfolder;
      if (plugin.settings.customAttachmentFolders) {
        subFolderPath = plugin.settings.drawingSubfolder || "";
      }
      return subFolderPath.trim();
    };
  }
});

// src/logic/utils/obsidian-interfaces.ts
async function getObsidianAttachmentFolderPath(plugin) {
  let attachmentPath = null;
  try {
    const returnedObsPath = await plugin.app.fileManager.getAvailablePathForAttachment("dummy");
    if (returnedObsPath.contains("/")) {
      const { folderpath } = parseFilepath(returnedObsPath);
      attachmentPath = folderpath;
    }
  } catch {
    return null;
  }
  return attachmentPath;
}
var init_obsidian_interfaces = __esm({
  "src/logic/utils/obsidian-interfaces.ts"() {
    init_parseFilepath();
  }
});

// src/logic/utils/file-manipulation.ts
var import_obsidian14, getNewTimestampedDrawingSvgFilepath, getNewTimestampedWritingSvgFilepath, getNewTimestampedFilepath;
var init_file_manipulation = __esm({
  "src/logic/utils/file-manipulation.ts"() {
    import_obsidian14 = require("obsidian");
    init_constants();
    init_getDateFilename();
    init_getVersionedFilepath();
    init_getBaseAttachmentPath();
    init_getSubfolderPaths();
    init_parseFilepath();
    init_obsidian_interfaces();
    getNewTimestampedDrawingSvgFilepath = async (plugin, instigatingFile) => {
      const obsAttachmentFolderPath = await getObsidianAttachmentFolderPath(plugin);
      const instigatingFileFolderPath = instigatingFile ? parseFilepath(instigatingFile?.path).folderpath : null;
      let basePath = await getBaseAttachmentPath(plugin, {
        obsAttachmentFolderPath,
        instigatingFileFolderPath
      });
      let subFolderPath = getDrawingSubfolderPath(plugin);
      const fullPath = await getNewTimestampedFilepath(plugin, "svg", `${basePath}/${subFolderPath}`);
      return fullPath;
    };
    getNewTimestampedWritingSvgFilepath = async (plugin, instigatingFile) => {
      const obsAttachmentFolderPath = await getObsidianAttachmentFolderPath(plugin);
      const instigatingFileFolderPath = instigatingFile ? parseFilepath(instigatingFile?.path).folderpath : null;
      let basePath = await getBaseAttachmentPath(plugin, {
        obsAttachmentFolderPath,
        instigatingFileFolderPath
      });
      let subFolderPath = getWritingSubfolderPath(plugin);
      const fullPath = await getNewTimestampedFilepath(plugin, "svg", `${basePath}/${subFolderPath}`);
      return fullPath;
    };
    getNewTimestampedFilepath = async (plugin, ext, folderPath) => {
      const filename = getDateFilename() + "." + ext;
      const versionedFilepath = await getVersionedFilepath(plugin, `${folderPath}/${filename}`);
      return (0, import_obsidian14.normalizePath)(versionedFilepath);
    };
  }
});

// src/components/formats/current/utils/duplicate-files.ts
var duplicateDrawingFile, duplicateWritingFile;
var init_duplicate_files = __esm({
  "src/components/formats/current/utils/duplicate-files.ts"() {
    init_createFoldersForFilepath();
    init_file_manipulation();
    duplicateDrawingFile = async (plugin, existingFileRef, instigatingFile) => {
      const v2 = plugin.app.vault;
      const newFilePath = await getNewTimestampedDrawingSvgFilepath(plugin, instigatingFile);
      await createFoldersForFilepath(plugin, newFilePath);
      const newFile = await v2.copy(existingFileRef, newFilePath);
      return newFile;
    };
    duplicateWritingFile = async (plugin, existingFileRef, instigatingFile) => {
      const v2 = plugin.app.vault;
      const newFilePath = await getNewTimestampedWritingSvgFilepath(plugin, instigatingFile);
      const newFile = await v2.copy(existingFileRef, newFilePath);
      return newFile;
    };
  }
});

// src/logic/utils/convert-file-embeds.ts
function closeLeavesWithFileOpen(plugin, filePath) {
  const workspace = plugin.app.workspace;
  const viewTypes = [INK_WRITING_VIEW_TYPE, INK_DRAWING_VIEW_TYPE];
  for (const viewType of viewTypes) {
    const leaves = workspace.getLeavesOfType(viewType);
    for (const leaf of leaves) {
      const view = leaf.view;
      if (view?.file?.path === filePath) {
        leaf.detach();
      }
    }
  }
}
function buildFileEmbedPattern(svgFilePath, embedType, global2 = false) {
  const escapedPath = svgFilePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const altText = embedType === "inkWriting" ? "InkWriting" : "InkDrawing";
  return new RegExp(` !\\[${altText}\\]\\(<${escapedPath}>\\)`, global2 ? "g" : void 0);
}
function countFileEmbedOccurrencesInMarkdown(markdownContent, svgFilePath, embedType) {
  const pattern = buildFileEmbedPattern(svgFilePath, embedType, true);
  return markdownContent.match(pattern)?.length ?? 0;
}
async function countFileEmbedOccurrencesInVault(vault, svgFilePath, embedType, onProgress) {
  const mdFiles = vault.getMarkdownFiles();
  const total = mdFiles.length;
  let embedCount = 0;
  for (let i2 = 0; i2 < mdFiles.length; i2++) {
    const file = mdFiles[i2];
    try {
      const content = await vault.cachedRead(file);
      embedCount += countFileEmbedOccurrencesInMarkdown(content, svgFilePath, embedType);
    } catch {
    }
    onProgress?.(i2 + 1, total);
  }
  return embedCount;
}
async function findNotesContainingFileEmbed(vault, svgFilePath, fromType, onProgress) {
  const mdFiles = vault.getMarkdownFiles();
  const total = mdFiles.length;
  const results = [];
  const pattern = buildFileEmbedPattern(svgFilePath, fromType);
  for (let i2 = 0; i2 < mdFiles.length; i2++) {
    const file = mdFiles[i2];
    try {
      const content = await vault.cachedRead(file);
      if (pattern.test(content)) {
        results.push(file);
      }
    } catch {
    }
    onProgress?.(i2 + 1, total, results.length);
  }
  return results;
}
async function removeAllEmbedsOfFileFromNote(vault, note, svgFilePath, embedType) {
  let content = await vault.read(note);
  const escapedPath = svgFilePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const altText = embedType === "inkWriting" ? "InkWriting" : "InkDrawing";
  const lineRegex = new RegExp(` !\\[${altText}\\]\\(<${escapedPath}>\\)[^\\n]*\\r?\\n?`, "g");
  const updated = content.replace(lineRegex, "");
  if (updated === content)
    return false;
  await vault.modify(note, updated);
  return true;
}
async function buildDrawingEmbedLineForConvertedFile(vault, newSvgPath) {
  let embedSettings;
  try {
    const svgFile = vault.getAbstractFileByPath(newSvgPath);
    if (!(svgFile instanceof import_obsidian15.TFile)) {
      return buildDrawingEmbed(newSvgPath).trim();
    }
    const svgString = await vault.read(svgFile);
    const inkFileData = extractInkJsonFromSvg(svgString);
    if (inkFileData && isInkCanvasFile(inkFileData) && inkFileData.inkCanvas) {
      embedSettings = buildDrawingEmbedSettingsFromStrokes(inkFileData.inkCanvas.strokes) ?? void 0;
    }
  } catch {
  }
  return buildDrawingEmbed(newSvgPath, embedSettings ? { embedSettings } : void 0).trim();
}
async function buildWritingEmbedLineForConvertedFile(vault, newSvgPath) {
  try {
    const svgFile = vault.getAbstractFileByPath(newSvgPath);
    if (!(svgFile instanceof import_obsidian15.TFile)) {
      return buildWritingEmbed(newSvgPath).trim();
    }
    const svgString = await vault.read(svgFile);
    const aspectRatio = parseSvgViewBoxAspectRatio(svgString);
    return buildWritingEmbed(newSvgPath, aspectRatio != null ? { aspectRatio } : void 0).trim();
  } catch {
    return buildWritingEmbed(newSvgPath).trim();
  }
}
async function updateEmbedInNote(vault, note, oldSvgPath, newSvgPath, toType) {
  let content = await vault.read(note);
  const escapedOldPath = oldSvgPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const fromAlt = toType === "inkWriting" ? "InkDrawing" : "InkWriting";
  const lineRegex = new RegExp(` !\\[${fromAlt}\\]\\(<${escapedOldPath}>\\)[^
]*`, "g");
  const newEmbedLine = toType === "inkWriting" ? await buildWritingEmbedLineForConvertedFile(vault, newSvgPath) : await buildDrawingEmbedLineForConvertedFile(vault, newSvgPath);
  const updated = content.replace(lineRegex, ` ${newEmbedLine}`);
  if (updated === content)
    return false;
  await vault.modify(note, updated);
  return true;
}
function resolveNotesToUpdate(scope, affectedNotes) {
  if (scope.mode === "in-place") {
    return affectedNotes;
  }
  if (scope.embedUpdate === "none") {
    return [];
  }
  if (scope.embedUpdate === "all-affected") {
    return affectedNotes;
  }
  if (scope.embedUpdate === "instigating-only" && scope.instigatingNote) {
    return [scope.instigatingNote];
  }
  return [];
}
async function duplicateFileForConversion(plugin, file, toType, instigatingNote) {
  const fromType = toType === "inkDrawing" ? "inkWriting" : "inkDrawing";
  if (fromType === "inkDrawing") {
    return duplicateDrawingFile(plugin, file, instigatingNote);
  }
  return duplicateWritingFile(plugin, file, instigatingNote);
}
async function executeFileConversion(plugin, file, toType, affectedNotes, moveToPath, scope, onProgress) {
  const vault = plugin.app.vault;
  const notesToUpdate = resolveNotesToUpdate(scope, affectedNotes);
  const wasDuplicated = scope.mode === "duplicate";
  const duplicateStep = wasDuplicated ? 1 : 0;
  const moveStep = moveToPath ? 1 : 0;
  const total = duplicateStep + moveStep + 1 + notesToUpdate.length;
  let done = 0;
  const result = {
    updatedNotePaths: [],
    failed: [],
    finalFile: null,
    originalFilePath: file.path,
    wasDuplicated
  };
  const reportProgress = () => {
    onProgress(done, total, {
      updatedNotes: result.updatedNotePaths.length,
      failedCount: result.failed.length
    });
  };
  const oldPath = file.path;
  let currentFile = file;
  if (wasDuplicated) {
    try {
      const copy = await duplicateFileForConversion(plugin, file, toType, scope.instigatingNote);
      if (!copy) {
        result.failed.push("Duplicate failed: could not create copy");
        return result;
      }
      currentFile = copy;
    } catch (err) {
      result.failed.push(`Duplicate failed: ${String(err)}`);
      return result;
    }
    done++;
    reportProgress();
  } else {
    closeLeavesWithFileOpen(plugin, oldPath);
  }
  if (moveToPath) {
    try {
      await vault.rename(currentFile, moveToPath);
      currentFile = vault.getFileByPath(moveToPath) ?? currentFile;
    } catch (err) {
      result.failed.push(`Move failed: ${String(err)}`);
    }
    done++;
    reportProgress();
  }
  const newPath = currentFile.path;
  if (wasDuplicated) {
    closeLeavesWithFileOpen(plugin, newPath);
  }
  let svgConversionSucceeded = true;
  try {
    if (toType === "inkDrawing") {
      await convertWriteFileToDraw(plugin, currentFile);
    } else {
      await convertDrawFileToWrite(plugin, currentFile);
    }
  } catch (err) {
    svgConversionSucceeded = false;
    result.failed.push(`SVG conversion failed: ${String(err)}`);
  }
  done++;
  reportProgress();
  if (!svgConversionSucceeded) {
    result.finalFile = currentFile;
    return result;
  }
  for (const note of notesToUpdate) {
    try {
      await updateEmbedInNote(vault, note, oldPath, newPath, toType);
      result.updatedNotePaths.push(note.path);
    } catch (err) {
      result.failed.push(`${note.path}: ${String(err)}`);
    }
    done++;
    reportProgress();
  }
  result.finalFile = currentFile;
  return result;
}
var import_obsidian15, INK_WRITING_VIEW_TYPE, INK_DRAWING_VIEW_TYPE, FILE_CONVERSION_IN_PLACE;
var init_convert_file_embeds = __esm({
  "src/logic/utils/convert-file-embeds.ts"() {
    import_obsidian15 = require("obsidian");
    init_build_embeds();
    init_convertWriteFileToDraw();
    init_convertDrawFileToWrite();
    init_duplicate_files();
    init_ink_file_storage_engine();
    init_extractInkJsonFromSvg();
    init_build_drawing_embed_settings_from_file();
    init_writing_embed_aspect_ratio();
    INK_WRITING_VIEW_TYPE = "ink_writing-view";
    INK_DRAWING_VIEW_TYPE = "ink_drawing-view";
    FILE_CONVERSION_IN_PLACE = { mode: "in-place" };
  }
});

// src/components/dom-components/modals/file-conversion-modal/file-conversion-modal.ts
var import_obsidian16, EMBED_LIST_CAP, FileConversionModal;
var init_file_conversion_modal = __esm({
  "src/components/dom-components/modals/file-conversion-modal/file-conversion-modal.ts"() {
    init_15();
    import_obsidian16 = require("obsidian");
    init_convert_file_embeds();
    init_ink_file_storage_engine();
    init_extractInkJsonFromSvg();
    init_fit_strokes_for_mode_conversion();
    init_constants();
    EMBED_LIST_CAP = 10;
    FileConversionModal = class extends import_obsidian16.Modal {
      constructor(plugin, file, toType, opts) {
        super(plugin.app);
        this.phase = 0 /* Scanning */;
        this.affectedNotes = [];
        this.conversionResult = null;
        this.conversionScope = FILE_CONVERSION_IN_PLACE;
        this.isInkCanvas = false;
        this.fitScalePreview = null;
        this.suggestedMovePath = null;
        this.moveCheckboxEl = null;
        this.progressBarInnerEl = null;
        this.statusTextEl = null;
        this.convertedCountEl = null;
        this.remainingCountEl = null;
        this.failedCountEl = null;
        this.plugin = plugin;
        this.file = file;
        this.toType = toType;
        this.sourceMdFile = opts?.sourceMdFile;
        this.onConversionComplete = opts?.onConversionComplete;
      }
      onOpen() {
        const label = this.toType === "inkDrawing" ? "Drawing" : "Writing";
        this.titleEl.setText(`Convert to ${label}`);
        this.contentEl.addClass("ddc_ink_migration-modal");
        this.computeSuggestedMovePath();
        this.renderScanPhase();
      }
      onClose() {
        this.contentEl.empty();
      }
      computeSuggestedMovePath() {
        const { writingSubfolder, drawingSubfolder } = this.plugin.settings;
        const parentPath = this.file.parent?.path ?? "";
        if (this.toType === "inkDrawing" && parentPath === writingSubfolder) {
          this.suggestedMovePath = `${drawingSubfolder}/${this.file.name}`;
        } else if (this.toType === "inkWriting" && parentPath === drawingSubfolder) {
          this.suggestedMovePath = `${writingSubfolder}/${this.file.name}`;
        } else {
          this.suggestedMovePath = null;
        }
      }
      renderScanPhase() {
        this.phase = 0 /* Scanning */;
        const { contentEl } = this;
        contentEl.empty();
        this.statusTextEl = contentEl.createDiv({
          cls: "ddc_ink_migration-status-text",
          text: "Scanning vault for notes that embed this file\u2026"
        });
        const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
        this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
        const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
        this.remainingCountEl = this.createStat(statsEl, "0", "remaining").countEl;
        this.convertedCountEl = this.createStat(statsEl, "0", "found").countEl;
        void this.runScan();
      }
      async runScan() {
        const fromType = this.toType === "inkDrawing" ? "inkWriting" : "inkDrawing";
        try {
          this.affectedNotes = await findNotesContainingFileEmbed(this.plugin.app.vault, this.file.path, fromType, (scanned, total, foundCount) => {
            const remaining = total - scanned;
            const pct = total > 0 ? scanned / total * 100 : 100;
            if (this.progressBarInnerEl)
              this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
            if (this.remainingCountEl)
              this.remainingCountEl.setText(String(remaining));
            if (this.convertedCountEl)
              this.convertedCountEl.setText(String(foundCount));
          });
          await this.detectInkCanvasAndFitPreview();
        } catch (err) {
          if (this.statusTextEl)
            this.statusTextEl.setText("Scan failed: " + String(err));
          return;
        }
        this.renderConfirmPhase();
      }
      async detectInkCanvasAndFitPreview() {
        try {
          const svgStr = await this.plugin.app.vault.read(this.file);
          const data = extractInkJsonFromSvg(svgStr);
          this.isInkCanvas = !!data && isInkCanvasFile(data);
          if (this.isInkCanvas && this.toType === "inkWriting" && data?.inkCanvas?.strokes) {
            const lineHeight = data.inkCanvas.writingLineHeight ?? data.meta.writingLineHeight ?? this.plugin.settings.writingLineHeight ?? WRITING_LINE_HEIGHT;
            this.fitScalePreview = previewDrawingToWritingScale(data.inkCanvas.strokes, lineHeight);
          }
        } catch {
          this.isInkCanvas = false;
          this.fitScalePreview = null;
        }
      }
      renderConfirmPhase() {
        this.phase = 1 /* Confirm */;
        const { contentEl } = this;
        contentEl.empty();
        this.renderLayoutWarning(contentEl);
        this.renderEmbedSummary(contentEl);
        if (this.suggestedMovePath) {
          const destFolder = this.toType === "inkDrawing" ? this.plugin.settings.drawingSubfolder : this.plugin.settings.writingSubfolder;
          const moveOptionEl = contentEl.createDiv({ cls: "ddc_ink_migration-move-option" });
          this.moveCheckboxEl = moveOptionEl.createEl("input", { type: "checkbox" });
          this.moveCheckboxEl.checked = true;
          this.moveCheckboxEl.id = "ddc_ink_move-checkbox";
          const labelEl = moveOptionEl.createEl("label");
          labelEl.setAttribute("for", "ddc_ink_move-checkbox");
          labelEl.setText(`Also move file to ${destFolder}`);
        }
        const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
        const cancelBtn = buttonsEl.createEl("button", { text: "Cancel" });
        cancelBtn.addEventListener("click", () => this.close());
        const duplicateBtn = buttonsEl.createEl("button", {
          text: "Duplicate and convert copy"
        });
        duplicateBtn.addEventListener("click", () => {
          this.conversionScope = {
            mode: "duplicate",
            instigatingNote: this.sourceMdFile,
            embedUpdate: this.sourceMdFile ? "instigating-only" : "none"
          };
          this.renderConvertingPhase();
        });
        const convertBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Convert" });
        convertBtn.addEventListener("click", () => {
          this.conversionScope = FILE_CONVERSION_IN_PLACE;
          this.renderConvertingPhase();
        });
      }
      renderLayoutWarning(parent) {
        const sectionEl = parent.createDiv({ cls: "ddc_ink_migration-section ddc_ink_migration-warning" });
        sectionEl.createDiv({
          cls: "ddc_ink_migration-section-title",
          text: "Layout changes"
        });
        if (this.isInkCanvas) {
          if (this.toType === "inkWriting") {
            let text = "Strokes will be scaled (smaller only) and repositioned to fit the writing page. This cannot be undone.";
            if (this.fitScalePreview != null && this.fitScalePreview < 1) {
              const pct = Math.round(this.fitScalePreview * 100);
              text += ` Strokes will be scaled to approximately ${pct}% of their current size.`;
            }
            sectionEl.createEl("p", { text });
          } else {
            sectionEl.createEl("p", {
              text: "The drawing embed viewbox in affected notes will be recalculated to fit the ink. Stroke positions are unchanged."
            });
          }
          return;
        }
        sectionEl.createEl("p", {
          text: "Legacy tldraw format: layout adjustment does not apply. Only metadata and embed type will change."
        });
      }
      renderEmbedSummary(parent) {
        const totalCount = this.affectedNotes.length;
        const sectionEl = parent.createDiv({ cls: "ddc_ink_migration-section" });
        sectionEl.createDiv({
          cls: "ddc_ink_migration-section-title",
          text: "Embeds"
        });
        if (totalCount === 0) {
          sectionEl.createEl("p", { text: "This file is not embedded in any notes." });
          return;
        }
        const typeLabel = this.toType === "inkDrawing" ? "drawing" : "writing";
        const otherCount = this.sourceMdFile ? this.affectedNotes.filter((n2) => n2.path !== this.sourceMdFile.path).length : totalCount;
        if (this.sourceMdFile) {
          const includesThis = this.affectedNotes.some((n2) => n2.path === this.sourceMdFile.path);
          if (includesThis && otherCount > 0) {
            sectionEl.createEl("p", {
              text: `Embedded in ${totalCount} note${totalCount !== 1 ? "s" : ""} (including this note and ${otherCount} other${otherCount !== 1 ? "s" : ""}). Converting will update all ${totalCount} embeds.`
            });
          } else if (includesThis) {
            sectionEl.createEl("p", {
              text: `Embedded in this note only. Converting will update this embed to ${typeLabel}.`
            });
          } else {
            sectionEl.createEl("p", {
              text: `Embedded in ${totalCount} other note${totalCount !== 1 ? "s" : ""}. Converting will update all of them.`
            });
          }
        } else {
          sectionEl.createEl("p", {
            text: `Embedded in ${totalCount} note${totalCount !== 1 ? "s" : ""}. Converting will update all embeds to ${typeLabel}.`
          });
        }
        const listPaths = this.affectedNotes.map((n2) => n2.path);
        const visiblePaths = listPaths.slice(0, EMBED_LIST_CAP);
        this.renderList(sectionEl, "Notes:", visiblePaths);
        if (listPaths.length > EMBED_LIST_CAP) {
          sectionEl.createEl("p", {
            text: `\u2026and ${listPaths.length - EMBED_LIST_CAP} more.`
          });
        }
        if (totalCount > 0 && this.sourceMdFile) {
          sectionEl.createEl("p", {
            cls: "ddc_ink_migration-hint",
            text: `Use "Duplicate and convert copy" to convert a copy and update only this note's embed. Other notes keep the original file.`
          });
        }
      }
      renderList(parent, title, items) {
        const sectionEl = parent.createDiv({ cls: "ddc_ink_migration-section" });
        sectionEl.createDiv({ cls: "ddc_ink_migration-section-title", text: title });
        const listEl = sectionEl.createDiv({ cls: "ddc_ink_migration-list" });
        if (items.length === 0) {
          listEl.createDiv({ cls: "ddc_ink_migration-list-empty", text: "None" });
        } else {
          for (const item of items) {
            listEl.createDiv({ cls: "ddc_ink_migration-list-item", text: item });
          }
        }
      }
      renderConvertingPhase() {
        this.phase = 2 /* Converting */;
        const { contentEl } = this;
        contentEl.empty();
        this.statusTextEl = contentEl.createDiv({
          cls: "ddc_ink_migration-status-text",
          text: "Converting\u2026"
        });
        const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
        this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
        const notesToUpdate = this.conversionScope.mode === "in-place" ? this.affectedNotes.length : this.conversionScope.embedUpdate === "instigating-only" && this.sourceMdFile ? 1 : this.conversionScope.embedUpdate === "all-affected" ? this.affectedNotes.length : 0;
        const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
        this.convertedCountEl = this.createStat(statsEl, "0", "updated").countEl;
        this.remainingCountEl = this.createStat(statsEl, String(notesToUpdate), "remaining").countEl;
        this.failedCountEl = this.createStat(statsEl, "0", "failed").countEl;
        void this.runConversion();
      }
      async runConversion() {
        const moveToPath = this.moveCheckboxEl?.checked && this.suggestedMovePath ? this.suggestedMovePath : null;
        try {
          this.conversionResult = await executeFileConversion(this.plugin, this.file, this.toType, this.affectedNotes, moveToPath, this.conversionScope, (done, total, liveStats) => {
            const pct = total > 0 ? done / total * 100 : 100;
            if (this.progressBarInnerEl)
              this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
            if (this.remainingCountEl) {
              this.remainingCountEl.setText(String(total - done));
            }
            if (this.convertedCountEl) {
              this.convertedCountEl.setText(String(liveStats.updatedNotes));
            }
            if (this.failedCountEl) {
              this.failedCountEl.setText(String(liveStats.failedCount));
            }
          });
        } catch (err) {
          if (this.statusTextEl)
            this.statusTextEl.setText("Conversion failed: " + String(err));
          return;
        }
        const svgConversionFailed = this.conversionResult?.failed.some((message) => message.startsWith("SVG conversion failed"));
        if (!svgConversionFailed) {
          this.onConversionComplete?.(this.conversionResult?.finalFile ?? null, this.toType);
        }
        this.renderDonePhase();
      }
      renderDonePhase() {
        this.phase = 3 /* Done */;
        const { contentEl } = this;
        const result = this.conversionResult;
        contentEl.empty();
        const typeLabel = this.toType === "inkDrawing" ? "drawing" : "writing";
        const noteCount = result.updatedNotePaths.length;
        if (result.wasDuplicated && result.finalFile) {
          contentEl.createEl("p", {
            text: `Created and converted a copy to ${typeLabel} at ${result.finalFile.path}. ${noteCount} note${noteCount !== 1 ? "s" : ""} updated. The original file was not changed.`
          });
        } else {
          contentEl.createEl("p", {
            text: `Converted to ${typeLabel}. ${noteCount} note${noteCount !== 1 ? "s" : ""} updated.`
          });
        }
        if (result.failed.length > 0) {
          this.renderList(contentEl, `Failed (${result.failed.length})`, result.failed);
        }
        const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
        if (result.updatedNotePaths.length > 10) {
          const randomBtn = buttonsEl.createEl("button", { text: "Open 10 random notes" });
          randomBtn.addEventListener("click", () => {
            const shuffled = [...result.updatedNotePaths].sort(() => Math.random() - 0.5);
            for (const path of shuffled.slice(0, 10)) {
              void this.plugin.app.workspace.openLinkText(path, "", true);
            }
          });
        }
        if (result.updatedNotePaths.length > 0) {
          const openAllBtn = buttonsEl.createEl("button", {
            text: `Open all ${result.updatedNotePaths.length} note${result.updatedNotePaths.length !== 1 ? "s" : ""}`
          });
          openAllBtn.addEventListener("click", () => {
            for (const path of result.updatedNotePaths) {
              void this.plugin.app.workspace.openLinkText(path, "", true);
            }
          });
        }
        const doneBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Done" });
        doneBtn.addEventListener("click", () => this.close());
      }
      createStat(parent, count3, label) {
        const statEl = parent.createDiv({ cls: "ddc_ink_migration-stat" });
        const countEl = statEl.createDiv({ cls: "ddc_ink_migration-stat-count", text: count3 });
        statEl.createDiv({ cls: "ddc_ink_migration-stat-name", text: label });
        return { countEl };
      }
    };
  }
});

// src/components/dom-components/modals/remove-embed-modal/remove-embed-modal.ts
var import_obsidian17, RemoveEmbedModal;
var init_remove_embed_modal = __esm({
  "src/components/dom-components/modals/remove-embed-modal/remove-embed-modal.ts"() {
    init_15();
    import_obsidian17 = require("obsidian");
    init_convert_file_embeds();
    RemoveEmbedModal = class extends import_obsidian17.Modal {
      constructor(plugin, embeddedFile, embedType, opts) {
        super(plugin.app);
        this.phase = 0 /* Scanning */;
        this.affectedNotes = [];
        this.totalEmbedCount = 0;
        this.progressBarInnerEl = null;
        this.statusTextEl = null;
        this.remainingCountEl = null;
        this.foundCountEl = null;
        this.plugin = plugin;
        this.embeddedFile = embeddedFile;
        this.embedType = embedType;
        this.opts = opts;
      }
      onOpen() {
        this.titleEl.setText("Remove embed");
        this.contentEl.addClass("ddc_ink_migration-modal");
        this.renderScanPhase();
      }
      onClose() {
        this.contentEl.empty();
      }
      renderScanPhase() {
        this.phase = 0 /* Scanning */;
        const { contentEl } = this;
        contentEl.empty();
        this.statusTextEl = contentEl.createDiv({
          cls: "ddc_ink_migration-status-text",
          text: "Scanning vault for notes that embed this file\u2026"
        });
        const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
        this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
        const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
        this.remainingCountEl = this.createStat(statsEl, "0", "remaining").countEl;
        this.foundCountEl = this.createStat(statsEl, "0", "found").countEl;
        void this.runScan();
      }
      async runScan() {
        try {
          const vault = this.plugin.app.vault;
          this.affectedNotes = await findNotesContainingFileEmbed(vault, this.embeddedFile.path, this.embedType, (scanned, total, foundCount) => {
            const remaining = total - scanned;
            const pct = total > 0 ? scanned / total * 100 : 50;
            if (this.progressBarInnerEl)
              this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
            if (this.remainingCountEl)
              this.remainingCountEl.setText(String(remaining));
            if (this.foundCountEl)
              this.foundCountEl.setText(String(foundCount));
          });
          this.totalEmbedCount = await countFileEmbedOccurrencesInVault(vault, this.embeddedFile.path, this.embedType, (scanned, total) => {
            const remaining = total - scanned;
            const pct = total > 0 ? 50 + scanned / total * 50 : 100;
            if (this.progressBarInnerEl)
              this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
            if (this.remainingCountEl)
              this.remainingCountEl.setText(String(remaining));
          });
        } catch (err) {
          if (this.statusTextEl)
            this.statusTextEl.setText("Scan failed: " + String(err));
          return;
        }
        const isOnlyEmbedInVault = this.totalEmbedCount === 1;
        const isOnlyInCurrentNote = this.affectedNotes.length === 1;
        if (isOnlyEmbedInVault && isOnlyInCurrentNote) {
          this.renderConfirmPhase();
        } else {
          this.opts.onRemoveEmbedOnly();
          this.close();
        }
      }
      renderConfirmPhase() {
        this.phase = 1 /* Confirm */;
        const { contentEl } = this;
        contentEl.empty();
        const typeLabel = this.embedType === "inkDrawing" ? "drawing" : "writing";
        contentEl.createEl("p", {
          text: `This ${typeLabel} file is only embedded in this note. Do you want to remove the embed only, or also delete the file from your vault?`
        });
        const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
        const cancelBtn = buttonsEl.createEl("button", { text: "Cancel" });
        cancelBtn.addEventListener("click", () => this.close());
        const removeAndDeleteBtn = buttonsEl.createEl("button", { cls: "mod-warning", text: "Remove and delete file" });
        removeAndDeleteBtn.setAttr("aria-label", "Remove and permanently delete file");
        removeAndDeleteBtn.addEventListener("click", () => {
          this.opts.onRemoveEmbedAndFile();
          this.close();
        });
        const removeOnlyBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Remove embed" });
        removeOnlyBtn.addEventListener("click", () => {
          this.opts.onRemoveEmbedOnly();
          this.close();
        });
      }
      createStat(parent, count3, label) {
        const statEl = parent.createDiv({ cls: "ddc_ink_migration-stat" });
        const countEl = statEl.createDiv({ cls: "ddc_ink_migration-stat-count", text: count3 });
        statEl.createDiv({ cls: "ddc_ink_migration-stat-name", text: label });
        return { countEl };
      }
    };
  }
});

// src/logic/utils/remove-embed-flow.ts
function openRemoveEmbedFlow(plugin, embeddedFile, sourceMdFile, embedType, removeEmbedOnlyFn) {
  const modal = new RemoveEmbedModal(plugin, embeddedFile, embedType, {
    sourceMdFile,
    onRemoveEmbedOnly: removeEmbedOnlyFn,
    onRemoveEmbedAndFile: () => {
      void (async () => {
        try {
          await removeAllEmbedsOfFileFromNote(plugin.app.vault, sourceMdFile, embeddedFile.path, embedType);
          await plugin.app.fileManager.trashFile(embeddedFile);
        } catch (err) {
          new import_obsidian18.Notice("Failed to remove and delete file: " + String(err));
        }
      })();
    }
  });
  modal.open();
}
var import_obsidian18;
var init_remove_embed_flow = __esm({
  "src/logic/utils/remove-embed-flow.ts"() {
    import_obsidian18 = require("obsidian");
    init_convert_file_embeds();
    init_remove_embed_modal();
  }
});

// src/components/formats/current/writing/writing-embed-preview/writing-embed-preview.scss
var init_16 = __esm({
  "src/components/formats/current/writing/writing-embed-preview/writing-embed-preview.scss"() {
  }
});

// node_modules/react-from-dom/dist/index.mjs
function randomString(length = 6) {
  const characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  let result = "";
  for (let index3 = length; index3 > 0; --index3) {
    result += characters[Math.round(Math.random() * (characters.length - 1))];
  }
  return result;
}
function getReactNode(node, options) {
  const { key, level: level2, ...rest } = options;
  switch (node.nodeType) {
    case 1: {
      return React94.createElement(parseName(node.nodeName), parseAttributes(node, key), parseChildren(node.childNodes, level2, rest));
    }
    case 3: {
      const nodeText = node.nodeValue?.toString() ?? "";
      if (!rest.allowWhiteSpaces && /^\s+$/.test(nodeText) && !/[\u00A0\u202F]/.test(nodeText)) {
        return null;
      }
      if (!node.parentNode) {
        return nodeText;
      }
      const parentNodeName = node.parentNode.nodeName.toLowerCase();
      if (noTextChildNodes.includes(parentNodeName)) {
        if (/\S/.test(nodeText)) {
          console.warn(`A textNode is not allowed inside '${parentNodeName}'. Your text "${nodeText}" will be ignored`);
        }
        return null;
      }
      return nodeText;
    }
    case 8: {
      return null;
    }
    case 11: {
      return parseChildren(node.childNodes, level2, options);
    }
    default: {
      return null;
    }
  }
}
function parseAttributes(node, reactKey) {
  const attributes = {
    key: reactKey
  };
  if (node instanceof Element) {
    const nodeClassNames = node.getAttribute("class");
    if (nodeClassNames) {
      attributes.className = nodeClassNames;
    }
    [...node.attributes].forEach((d2) => {
      switch (d2.name) {
        case "class":
          break;
        case "style":
          attributes[d2.name] = styleToObject(d2.value);
          break;
        case "allowfullscreen":
        case "allowpaymentrequest":
        case "async":
        case "autofocus":
        case "autoplay":
        case "checked":
        case "controls":
        case "default":
        case "defer":
        case "disabled":
        case "formnovalidate":
        case "hidden":
        case "ismap":
        case "itemscope":
        case "loop":
        case "multiple":
        case "muted":
        case "nomodule":
        case "novalidate":
        case "open":
        case "readonly":
        case "required":
        case "reversed":
        case "selected":
        case "typemustmatch":
          attributes[possibleStandardNames[d2.name] || d2.name] = true;
          break;
        default:
          attributes[possibleStandardNames[d2.name] || d2.name] = d2.value;
      }
    });
  }
  return attributes;
}
function parseChildren(childNodeList, level2, options) {
  const children = [...childNodeList].map((node, index3) => convertFromNode(node, {
    ...options,
    index: index3,
    level: level2 + 1
  })).filter(Boolean);
  if (!children.length) {
    return null;
  }
  return children;
}
function parseName(nodeName) {
  if (/[a-z]+[A-Z]+[a-z]+/.test(nodeName)) {
    return nodeName;
  }
  return nodeName.toLowerCase();
}
function convertFromNode(input, options = {}) {
  if (!input || !(input instanceof Node)) {
    return null;
  }
  const { actions = [], index: index3 = 0, level: level2 = 0, randomKey } = options;
  let node = input;
  let key = `${level2}-${index3}`;
  const result = [];
  if (randomKey && level2 === 0) {
    key = `${randomString()}-${key}`;
  }
  if (Array.isArray(actions)) {
    actions.forEach((action) => {
      if (action.condition(node, key, level2)) {
        if (typeof action.pre === "function") {
          node = action.pre(node, key, level2);
          if (!(node instanceof Node)) {
            node = input;
            if (false) {
              console.warn("The `pre` method always must return a valid DomNode (instanceof Node) - your modification will be ignored (Hint: if you want to render a React-component, use the `post` method instead)");
            }
          }
        }
        if (typeof action.post === "function") {
          result.push(action.post(node, key, level2));
        }
      }
    });
  }
  if (result.length) {
    return result;
  }
  return getReactNode(node, { key, level: level2, ...options });
}
function convertFromString(input, options = {}) {
  if (!input || typeof input !== "string") {
    return null;
  }
  const {
    includeAllNodes = false,
    nodeOnly = false,
    selector = "body > *",
    type = "text/html"
  } = options;
  try {
    const parser = new DOMParser();
    const document2 = parser.parseFromString(input, type);
    if (includeAllNodes) {
      const { childNodes } = document2.body;
      if (nodeOnly) {
        return childNodes;
      }
      return [...childNodes].map((node2) => convertFromNode(node2, options));
    }
    const node = document2.querySelector(selector) || document2.body.childNodes[0];
    if (!(node instanceof Node)) {
      throw new TypeError("Error parsing input");
    }
    if (nodeOnly) {
      return node;
    }
    return convertFromNode(node, options);
  } catch (error2) {
    if (false) {
      console.error(error2);
    }
  }
  return null;
}
function convert(input, options = {}) {
  if (typeof input === "string") {
    return convertFromString(input, options);
  }
  if (input instanceof Node) {
    return convertFromNode(input, options);
  }
  return null;
}
var React94, styleToObject, noTextChildNodes, possibleStandardNames;
var init_dist32 = __esm({
  "node_modules/react-from-dom/dist/index.mjs"() {
    React94 = __toESM(require_react(), 1);
    styleToObject = (input) => {
      if (typeof input !== "string") {
        return {};
      }
      return input.split(/ ?; ?/).reduce((acc, item) => {
        const [key, value] = item.split(/ ?: ?/).map((d2, index3) => index3 === 0 ? d2.replace(/\s+/g, "") : d2.trim());
        if (key && value) {
          const nextKey = key.replace(/(\w)-(\w)/g, (_$0, $1, $2) => `${$1}${$2.toUpperCase()}`);
          let nextValue = value.trim();
          if (!Number.isNaN(Number(value))) {
            nextValue = Number(value);
          }
          acc[key.startsWith("-") ? key : nextKey] = nextValue;
        }
        return acc;
      }, {});
    };
    noTextChildNodes = [
      "br",
      "col",
      "colgroup",
      "dl",
      "hr",
      "iframe",
      "img",
      "input",
      "link",
      "menuitem",
      "meta",
      "ol",
      "param",
      "select",
      "table",
      "tbody",
      "tfoot",
      "thead",
      "tr",
      "ul",
      "wbr"
    ];
    possibleStandardNames = {
      "accept-charset": "acceptCharset",
      acceptcharset: "acceptCharset",
      accesskey: "accessKey",
      allowfullscreen: "allowFullScreen",
      autocapitalize: "autoCapitalize",
      autocomplete: "autoComplete",
      autocorrect: "autoCorrect",
      autofocus: "autoFocus",
      autoplay: "autoPlay",
      autosave: "autoSave",
      cellpadding: "cellPadding",
      cellspacing: "cellSpacing",
      charset: "charSet",
      class: "className",
      classid: "classID",
      classname: "className",
      colspan: "colSpan",
      contenteditable: "contentEditable",
      contextmenu: "contextMenu",
      controlslist: "controlsList",
      crossorigin: "crossOrigin",
      dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
      datetime: "dateTime",
      defaultchecked: "defaultChecked",
      defaultvalue: "defaultValue",
      enctype: "encType",
      for: "htmlFor",
      formmethod: "formMethod",
      formaction: "formAction",
      formenctype: "formEncType",
      formnovalidate: "formNoValidate",
      formtarget: "formTarget",
      frameborder: "frameBorder",
      hreflang: "hrefLang",
      htmlfor: "htmlFor",
      httpequiv: "httpEquiv",
      "http-equiv": "httpEquiv",
      icon: "icon",
      innerhtml: "innerHTML",
      inputmode: "inputMode",
      itemid: "itemID",
      itemprop: "itemProp",
      itemref: "itemRef",
      itemscope: "itemScope",
      itemtype: "itemType",
      keyparams: "keyParams",
      keytype: "keyType",
      marginwidth: "marginWidth",
      marginheight: "marginHeight",
      maxlength: "maxLength",
      mediagroup: "mediaGroup",
      minlength: "minLength",
      nomodule: "noModule",
      novalidate: "noValidate",
      playsinline: "playsInline",
      radiogroup: "radioGroup",
      readonly: "readOnly",
      referrerpolicy: "referrerPolicy",
      rowspan: "rowSpan",
      spellcheck: "spellCheck",
      srcdoc: "srcDoc",
      srclang: "srcLang",
      srcset: "srcSet",
      tabindex: "tabIndex",
      typemustmatch: "typeMustMatch",
      usemap: "useMap",
      accentheight: "accentHeight",
      "accent-height": "accentHeight",
      alignmentbaseline: "alignmentBaseline",
      "alignment-baseline": "alignmentBaseline",
      allowreorder: "allowReorder",
      arabicform: "arabicForm",
      "arabic-form": "arabicForm",
      attributename: "attributeName",
      attributetype: "attributeType",
      autoreverse: "autoReverse",
      basefrequency: "baseFrequency",
      baselineshift: "baselineShift",
      "baseline-shift": "baselineShift",
      baseprofile: "baseProfile",
      calcmode: "calcMode",
      capheight: "capHeight",
      "cap-height": "capHeight",
      clippath: "clipPath",
      "clip-path": "clipPath",
      clippathunits: "clipPathUnits",
      cliprule: "clipRule",
      "clip-rule": "clipRule",
      colorinterpolation: "colorInterpolation",
      "color-interpolation": "colorInterpolation",
      colorinterpolationfilters: "colorInterpolationFilters",
      "color-interpolation-filters": "colorInterpolationFilters",
      colorprofile: "colorProfile",
      "color-profile": "colorProfile",
      colorrendering: "colorRendering",
      "color-rendering": "colorRendering",
      contentscripttype: "contentScriptType",
      contentstyletype: "contentStyleType",
      diffuseconstant: "diffuseConstant",
      dominantbaseline: "dominantBaseline",
      "dominant-baseline": "dominantBaseline",
      edgemode: "edgeMode",
      enablebackground: "enableBackground",
      "enable-background": "enableBackground",
      externalresourcesrequired: "externalResourcesRequired",
      fillopacity: "fillOpacity",
      "fill-opacity": "fillOpacity",
      fillrule: "fillRule",
      "fill-rule": "fillRule",
      filterres: "filterRes",
      filterunits: "filterUnits",
      floodopacity: "floodOpacity",
      "flood-opacity": "floodOpacity",
      floodcolor: "floodColor",
      "flood-color": "floodColor",
      fontfamily: "fontFamily",
      "font-family": "fontFamily",
      fontsize: "fontSize",
      "font-size": "fontSize",
      fontsizeadjust: "fontSizeAdjust",
      "font-size-adjust": "fontSizeAdjust",
      fontstretch: "fontStretch",
      "font-stretch": "fontStretch",
      fontstyle: "fontStyle",
      "font-style": "fontStyle",
      fontvariant: "fontVariant",
      "font-variant": "fontVariant",
      fontweight: "fontWeight",
      "font-weight": "fontWeight",
      glyphname: "glyphName",
      "glyph-name": "glyphName",
      glyphorientationhorizontal: "glyphOrientationHorizontal",
      "glyph-orientation-horizontal": "glyphOrientationHorizontal",
      glyphorientationvertical: "glyphOrientationVertical",
      "glyph-orientation-vertical": "glyphOrientationVertical",
      glyphref: "glyphRef",
      gradienttransform: "gradientTransform",
      gradientunits: "gradientUnits",
      horizadvx: "horizAdvX",
      "horiz-adv-x": "horizAdvX",
      horizoriginx: "horizOriginX",
      "horiz-origin-x": "horizOriginX",
      imagerendering: "imageRendering",
      "image-rendering": "imageRendering",
      kernelmatrix: "kernelMatrix",
      kernelunitlength: "kernelUnitLength",
      keypoints: "keyPoints",
      keysplines: "keySplines",
      keytimes: "keyTimes",
      lengthadjust: "lengthAdjust",
      letterspacing: "letterSpacing",
      "letter-spacing": "letterSpacing",
      lightingcolor: "lightingColor",
      "lighting-color": "lightingColor",
      limitingconeangle: "limitingConeAngle",
      markerend: "markerEnd",
      "marker-end": "markerEnd",
      markerheight: "markerHeight",
      markermid: "markerMid",
      "marker-mid": "markerMid",
      markerstart: "markerStart",
      "marker-start": "markerStart",
      markerunits: "markerUnits",
      markerwidth: "markerWidth",
      maskcontentunits: "maskContentUnits",
      maskunits: "maskUnits",
      numoctaves: "numOctaves",
      overlineposition: "overlinePosition",
      "overline-position": "overlinePosition",
      overlinethickness: "overlineThickness",
      "overline-thickness": "overlineThickness",
      paintorder: "paintOrder",
      "paint-order": "paintOrder",
      "panose-1": "panose1",
      pathlength: "pathLength",
      patterncontentunits: "patternContentUnits",
      patterntransform: "patternTransform",
      patternunits: "patternUnits",
      pointerevents: "pointerEvents",
      "pointer-events": "pointerEvents",
      pointsatx: "pointsAtX",
      pointsaty: "pointsAtY",
      pointsatz: "pointsAtZ",
      preservealpha: "preserveAlpha",
      preserveaspectratio: "preserveAspectRatio",
      primitiveunits: "primitiveUnits",
      refx: "refX",
      refy: "refY",
      renderingintent: "renderingIntent",
      "rendering-intent": "renderingIntent",
      repeatcount: "repeatCount",
      repeatdur: "repeatDur",
      requiredextensions: "requiredExtensions",
      requiredfeatures: "requiredFeatures",
      shaperendering: "shapeRendering",
      "shape-rendering": "shapeRendering",
      specularconstant: "specularConstant",
      specularexponent: "specularExponent",
      spreadmethod: "spreadMethod",
      startoffset: "startOffset",
      stddeviation: "stdDeviation",
      stitchtiles: "stitchTiles",
      stopcolor: "stopColor",
      "stop-color": "stopColor",
      stopopacity: "stopOpacity",
      "stop-opacity": "stopOpacity",
      strikethroughposition: "strikethroughPosition",
      "strikethrough-position": "strikethroughPosition",
      strikethroughthickness: "strikethroughThickness",
      "strikethrough-thickness": "strikethroughThickness",
      strokedasharray: "strokeDasharray",
      "stroke-dasharray": "strokeDasharray",
      strokedashoffset: "strokeDashoffset",
      "stroke-dashoffset": "strokeDashoffset",
      strokelinecap: "strokeLinecap",
      "stroke-linecap": "strokeLinecap",
      strokelinejoin: "strokeLinejoin",
      "stroke-linejoin": "strokeLinejoin",
      strokemiterlimit: "strokeMiterlimit",
      "stroke-miterlimit": "strokeMiterlimit",
      strokewidth: "strokeWidth",
      "stroke-width": "strokeWidth",
      strokeopacity: "strokeOpacity",
      "stroke-opacity": "strokeOpacity",
      suppresscontenteditablewarning: "suppressContentEditableWarning",
      suppresshydrationwarning: "suppressHydrationWarning",
      surfacescale: "surfaceScale",
      systemlanguage: "systemLanguage",
      tablevalues: "tableValues",
      targetx: "targetX",
      targety: "targetY",
      textanchor: "textAnchor",
      "text-anchor": "textAnchor",
      textdecoration: "textDecoration",
      "text-decoration": "textDecoration",
      textlength: "textLength",
      textrendering: "textRendering",
      "text-rendering": "textRendering",
      underlineposition: "underlinePosition",
      "underline-position": "underlinePosition",
      underlinethickness: "underlineThickness",
      "underline-thickness": "underlineThickness",
      unicodebidi: "unicodeBidi",
      "unicode-bidi": "unicodeBidi",
      unicoderange: "unicodeRange",
      "unicode-range": "unicodeRange",
      unitsperem: "unitsPerEm",
      "units-per-em": "unitsPerEm",
      unselectable: "unselectable",
      valphabetic: "vAlphabetic",
      "v-alphabetic": "vAlphabetic",
      vectoreffect: "vectorEffect",
      "vector-effect": "vectorEffect",
      vertadvy: "vertAdvY",
      "vert-adv-y": "vertAdvY",
      vertoriginx: "vertOriginX",
      "vert-origin-x": "vertOriginX",
      vertoriginy: "vertOriginY",
      "vert-origin-y": "vertOriginY",
      vhanging: "vHanging",
      "v-hanging": "vHanging",
      videographic: "vIdeographic",
      "v-ideographic": "vIdeographic",
      viewbox: "viewBox",
      viewtarget: "viewTarget",
      vmathematical: "vMathematical",
      "v-mathematical": "vMathematical",
      wordspacing: "wordSpacing",
      "word-spacing": "wordSpacing",
      writingmode: "writingMode",
      "writing-mode": "writingMode",
      xchannelselector: "xChannelSelector",
      xheight: "xHeight",
      "x-height": "xHeight",
      xlinkactuate: "xlinkActuate",
      "xlink:actuate": "xlinkActuate",
      xlinkarcrole: "xlinkArcrole",
      "xlink:arcrole": "xlinkArcrole",
      xlinkhref: "xlinkHref",
      "xlink:href": "xlinkHref",
      xlinkrole: "xlinkRole",
      "xlink:role": "xlinkRole",
      xlinkshow: "xlinkShow",
      "xlink:show": "xlinkShow",
      xlinktitle: "xlinkTitle",
      "xlink:title": "xlinkTitle",
      xlinktype: "xlinkType",
      "xlink:type": "xlinkType",
      xmlbase: "xmlBase",
      "xml:base": "xmlBase",
      xmllang: "xmlLang",
      "xml:lang": "xmlLang",
      "xml:space": "xmlSpace",
      xmlnsxlink: "xmlnsXlink",
      "xmlns:xlink": "xmlnsXlink",
      xmlspace: "xmlSpace",
      ychannelselector: "yChannelSelector",
      zoomandpan: "zoomAndPan",
      onblur: "onBlur",
      onchange: "onChange",
      onclick: "onClick",
      oncontextmenu: "onContextMenu",
      ondoubleclick: "onDoubleClick",
      ondrag: "onDrag",
      ondragend: "onDragEnd",
      ondragenter: "onDragEnter",
      ondragexit: "onDragExit",
      ondragleave: "onDragLeave",
      ondragover: "onDragOver",
      ondragstart: "onDragStart",
      ondrop: "onDrop",
      onerror: "onError",
      onfocus: "onFocus",
      oninput: "onInput",
      oninvalid: "onInvalid",
      onkeydown: "onKeyDown",
      onkeypress: "onKeyPress",
      onkeyup: "onKeyUp",
      onload: "onLoad",
      onmousedown: "onMouseDown",
      onmouseenter: "onMouseEnter",
      onmouseleave: "onMouseLeave",
      onmousemove: "onMouseMove",
      onmouseout: "onMouseOut",
      onmouseover: "onMouseOver",
      onmouseup: "onMouseUp",
      onscroll: "onScroll",
      onsubmit: "onSubmit",
      ontouchcancel: "onTouchCancel",
      ontouchend: "onTouchEnd",
      ontouchmove: "onTouchMove",
      ontouchstart: "onTouchStart",
      onwheel: "onWheel"
    };
  }
});

// node_modules/react-inlinesvg/dist/index.mjs
function canUseDOM() {
  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
}
function isSupportedEnvironment() {
  return supportsInlineSVG() && typeof window !== "undefined" && window !== null;
}
async function request(url, options) {
  const response = await fetch(url, options);
  const contentType = response.headers.get("content-type");
  const [fileType] = (contentType ?? "").split(/ ?; ?/);
  if (response.status > 299) {
    throw new Error("Not found");
  }
  if (!["image/svg+xml", "text/plain"].some((d2) => fileType.includes(d2))) {
    throw new Error(`Content type isn't valid: ${fileType}`);
  }
  return response.text();
}
function sleep(seconds = 1) {
  return new Promise((resolve) => {
    setTimeout(resolve, seconds * 1e3);
  });
}
function supportsInlineSVG() {
  if (!document) {
    return false;
  }
  const div2 = document.createElement("div");
  div2.innerHTML = "<svg />";
  const svg = div2.firstChild;
  return !!svg && svg.namespaceURI === "http://www.w3.org/2000/svg";
}
function randomCharacter(character) {
  return character[Math.floor(Math.random() * character.length)];
}
function randomString2(length) {
  const letters = "abcdefghijklmnopqrstuvwxyz";
  const numbers = "1234567890";
  const charset = `${letters}${letters.toUpperCase()}${numbers}`;
  let R2 = "";
  for (let index3 = 0; index3 < length; index3++) {
    R2 += randomCharacter(charset);
  }
  return R2;
}
function omit(input, ...filter2) {
  const output = {};
  for (const key in input) {
    if ({}.hasOwnProperty.call(input, key)) {
      if (!filter2.includes(key)) {
        output[key] = input[key];
      }
    }
  }
  return output;
}
function usePrevious2(state) {
  const ref = (0, import_react126.useRef)();
  (0, import_react126.useEffect)(() => {
    ref.current = state;
  });
  return ref.current;
}
function getNode(options) {
  const {
    baseURL,
    content,
    description,
    handleError,
    hash: hash3,
    preProcessor,
    title,
    uniquifyIDs = false
  } = options;
  try {
    const svgText = processSVG(content, preProcessor);
    const node = convert(svgText, { nodeOnly: true });
    if (!node || !(node instanceof SVGSVGElement)) {
      throw new Error("Could not convert the src to a DOM Node");
    }
    const svg = updateSVGAttributes(node, { baseURL, hash: hash3, uniquifyIDs });
    if (description) {
      const originalDesc = svg.querySelector("desc");
      if (originalDesc?.parentNode) {
        originalDesc.parentNode.removeChild(originalDesc);
      }
      const descElement = document.createElementNS("http://www.w3.org/2000/svg", "desc");
      descElement.innerHTML = description;
      svg.prepend(descElement);
    }
    if (typeof title !== "undefined") {
      const originalTitle = svg.querySelector("title");
      if (originalTitle?.parentNode) {
        originalTitle.parentNode.removeChild(originalTitle);
      }
      if (title) {
        const titleElement = document.createElementNS("http://www.w3.org/2000/svg", "title");
        titleElement.innerHTML = title;
        svg.prepend(titleElement);
      }
    }
    return svg;
  } catch (error2) {
    return handleError(error2);
  }
}
function processSVG(content, preProcessor) {
  if (preProcessor) {
    return preProcessor(content);
  }
  return content;
}
function updateSVGAttributes(node, options) {
  const { baseURL = "", hash: hash3, uniquifyIDs } = options;
  const replaceableAttributes = ["id", "href", "xlink:href", "xlink:role", "xlink:arcrole"];
  const linkAttributes = ["href", "xlink:href"];
  const isDataValue = (name, value) => linkAttributes.includes(name) && (value ? !value.includes("#") : false);
  if (!uniquifyIDs) {
    return node;
  }
  [...node.children].forEach((d2) => {
    if (d2.attributes?.length) {
      const attributes = Object.values(d2.attributes).map((a2) => {
        const attribute = a2;
        const match = /url\((.*?)\)/.exec(a2.value);
        if (match?.[1]) {
          attribute.value = a2.value.replace(match[0], `url(${baseURL}${match[1]}__${hash3})`);
        }
        return attribute;
      });
      replaceableAttributes.forEach((r2) => {
        const attribute = attributes.find((a2) => a2.name === r2);
        if (attribute && !isDataValue(r2, attribute.value)) {
          attribute.value = `${attribute.value}__${hash3}`;
        }
      });
    }
    if (d2.children.length) {
      return updateSVGAttributes(d2, options);
    }
    return d2;
  });
  return node;
}
function ReactInlineSVG(props) {
  const {
    cacheRequests = true,
    children = null,
    description,
    fetchOptions,
    innerRef,
    loader = null,
    onError,
    onLoad,
    src,
    title,
    uniqueHash
  } = props;
  const [state, setState] = (0, import_react125.useReducer)((previousState2, nextState) => ({
    ...previousState2,
    ...nextState
  }), {
    content: "",
    element: null,
    isCached: cacheRequests && cacheStore.isCached(props.src),
    status: STATUS.IDLE
  });
  const { content, element, isCached, status } = state;
  const previousProps = usePrevious2(props);
  const previousState = usePrevious2(state);
  const hash3 = (0, import_react125.useRef)(uniqueHash ?? randomString2(8));
  const isActive = (0, import_react125.useRef)(false);
  const isInitialized = (0, import_react125.useRef)(false);
  const handleError = (0, import_react125.useCallback)((error2) => {
    if (isActive.current) {
      setState({
        status: error2.message === "Browser does not support SVG" ? STATUS.UNSUPPORTED : STATUS.FAILED
      });
      onError?.(error2);
    }
  }, [onError]);
  const handleLoad = (0, import_react125.useCallback)((loadedContent, hasCache = false) => {
    if (isActive.current) {
      setState({
        content: loadedContent,
        isCached: hasCache,
        status: STATUS.LOADED
      });
    }
  }, []);
  const fetchContent = (0, import_react125.useCallback)(async () => {
    const responseContent = await request(src, fetchOptions);
    handleLoad(responseContent);
  }, [fetchOptions, handleLoad, src]);
  const getElement = (0, import_react125.useCallback)(() => {
    try {
      const node = getNode({ ...props, handleError, hash: hash3.current, content });
      const convertedElement = convert(node);
      if (!convertedElement || !(0, import_react125.isValidElement)(convertedElement)) {
        throw new Error("Could not convert the src to a React element");
      }
      setState({
        element: convertedElement,
        status: STATUS.READY
      });
    } catch (error2) {
      handleError(new Error(error2.message));
    }
  }, [content, handleError, props]);
  const getContent = (0, import_react125.useCallback)(async () => {
    const dataURI = /^data:image\/svg[^,]*?(;base64)?,(.*)/u.exec(src);
    let inlineSrc;
    if (dataURI) {
      inlineSrc = dataURI[1] ? window.atob(dataURI[2]) : decodeURIComponent(dataURI[2]);
    } else if (src.includes("<svg")) {
      inlineSrc = src;
    }
    if (inlineSrc) {
      handleLoad(inlineSrc);
      return;
    }
    try {
      if (cacheRequests) {
        const cachedContent = await cacheStore.get(src, fetchOptions);
        handleLoad(cachedContent, true);
      } else {
        await fetchContent();
      }
    } catch (error2) {
      handleError(error2);
    }
  }, [cacheRequests, fetchContent, fetchOptions, handleError, handleLoad, src]);
  const load = (0, import_react125.useCallback)(async () => {
    if (isActive.current) {
      setState({
        content: "",
        element: null,
        isCached: false,
        status: STATUS.LOADING
      });
    }
  }, []);
  (0, import_react125.useEffect)(() => {
    isActive.current = true;
    if (!canUseDOM() || isInitialized.current) {
      return () => void 0;
    }
    try {
      if (status === STATUS.IDLE) {
        if (!isSupportedEnvironment()) {
          throw new Error("Browser does not support SVG");
        }
        if (!src) {
          throw new Error("Missing src");
        }
        load();
      }
    } catch (error2) {
      handleError(error2);
    }
    isInitialized.current = true;
    return () => {
      isActive.current = false;
    };
  }, []);
  (0, import_react125.useEffect)(() => {
    if (!canUseDOM()) {
      return;
    }
    if (!previousProps) {
      return;
    }
    if (previousProps.src !== src) {
      if (!src) {
        handleError(new Error("Missing src"));
        return;
      }
      load();
    } else if (previousProps.title !== title || previousProps.description !== description) {
      getElement();
    }
  }, [description, getElement, handleError, load, previousProps, src, title]);
  (0, import_react125.useEffect)(() => {
    if (!previousState) {
      return;
    }
    if (previousState.status !== STATUS.LOADING && status === STATUS.LOADING) {
      getContent();
    }
    if (previousState.status !== STATUS.LOADED && status === STATUS.LOADED) {
      getElement();
    }
    if (previousState.status !== STATUS.READY && status === STATUS.READY) {
      onLoad?.(src, isCached);
    }
  }, [getContent, getElement, isCached, onLoad, previousState, src, status]);
  const elementProps = omit(props, "baseURL", "cacheRequests", "children", "description", "fetchOptions", "innerRef", "loader", "onError", "onLoad", "preProcessor", "src", "title", "uniqueHash", "uniquifyIDs");
  if (!canUseDOM()) {
    return loader;
  }
  if (element) {
    return (0, import_react125.cloneElement)(element, { ref: innerRef, ...elementProps });
  }
  if ([STATUS.UNSUPPORTED, STATUS.FAILED].includes(status)) {
    return children;
  }
  return loader;
}
function InlineSVG(props) {
  if (!cacheStore) {
    cacheStore = new CacheStore();
  }
  const { loader } = props;
  const hasCallback = (0, import_react125.useRef)(false);
  const [isReady, setReady] = (0, import_react125.useState)(cacheStore.isReady);
  (0, import_react125.useEffect)(() => {
    if (!hasCallback.current) {
      cacheStore.onReady(() => {
        setReady(true);
      });
      hasCallback.current = true;
    }
  }, []);
  if (!isReady) {
    return loader;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime170.jsx)(ReactInlineSVG, { ...props });
}
var import_react125, import_react126, import_jsx_runtime170, __defProp8, __defNormalProp2, __publicField2, CACHE_NAME, CACHE_MAX_RETRIES, STATUS, CacheStore, cacheStore;
var init_dist33 = __esm({
  "node_modules/react-inlinesvg/dist/index.mjs"() {
    import_react125 = __toESM(require_react(), 1);
    init_dist32();
    import_react126 = __toESM(require_react(), 1);
    init_dist32();
    import_jsx_runtime170 = __toESM(require_jsx_runtime(), 1);
    "use client";
    __defProp8 = Object.defineProperty;
    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
    __publicField2 = (obj, key, value) => {
      __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
      return value;
    };
    CACHE_NAME = "react-inlinesvg";
    CACHE_MAX_RETRIES = 10;
    STATUS = {
      IDLE: "idle",
      LOADING: "loading",
      LOADED: "loaded",
      FAILED: "failed",
      READY: "ready",
      UNSUPPORTED: "unsupported"
    };
    CacheStore = class {
      constructor() {
        __publicField2(this, "cacheApi");
        __publicField2(this, "cacheStore");
        __publicField2(this, "subscribers", []);
        __publicField2(this, "isReady", false);
        this.cacheStore = /* @__PURE__ */ new Map();
        let cacheName = CACHE_NAME;
        let usePersistentCache = false;
        if (canUseDOM()) {
          cacheName = window.REACT_INLINESVG_CACHE_NAME ?? CACHE_NAME;
          usePersistentCache = !!window.REACT_INLINESVG_PERSISTENT_CACHE && "caches" in window;
        }
        if (usePersistentCache) {
          caches.open(cacheName).then((cache) => {
            this.cacheApi = cache;
            this.isReady = true;
            this.subscribers.forEach((callback) => callback());
          }).catch((error2) => {
            this.isReady = true;
            console.error(`Failed to open cache: ${error2.message}`);
          });
        } else {
          this.isReady = true;
        }
      }
      onReady(callback) {
        if (this.isReady) {
          callback();
        } else {
          this.subscribers.push(callback);
        }
      }
      async get(url, fetchOptions) {
        await (this.cacheApi ? this.fetchAndAddToPersistentCache(url, fetchOptions) : this.fetchAndAddToInternalCache(url, fetchOptions));
        return this.cacheStore.get(url)?.content ?? "";
      }
      set(url, data) {
        this.cacheStore.set(url, data);
      }
      isCached(url) {
        return this.cacheStore.get(url)?.status === STATUS.LOADED;
      }
      async fetchAndAddToInternalCache(url, fetchOptions) {
        const cache = this.cacheStore.get(url);
        if (cache?.status === STATUS.LOADING) {
          await this.handleLoading(url, async () => {
            this.cacheStore.set(url, { content: "", status: STATUS.IDLE });
            await this.fetchAndAddToInternalCache(url, fetchOptions);
          });
          return;
        }
        if (!cache?.content) {
          this.cacheStore.set(url, { content: "", status: STATUS.LOADING });
          try {
            const content = await request(url, fetchOptions);
            this.cacheStore.set(url, { content, status: STATUS.LOADED });
          } catch (error2) {
            this.cacheStore.set(url, { content: "", status: STATUS.FAILED });
            throw error2;
          }
        }
      }
      async fetchAndAddToPersistentCache(url, fetchOptions) {
        const cache = this.cacheStore.get(url);
        if (cache?.status === STATUS.LOADED) {
          return;
        }
        if (cache?.status === STATUS.LOADING) {
          await this.handleLoading(url, async () => {
            this.cacheStore.set(url, { content: "", status: STATUS.IDLE });
            await this.fetchAndAddToPersistentCache(url, fetchOptions);
          });
          return;
        }
        this.cacheStore.set(url, { content: "", status: STATUS.LOADING });
        const data = await this.cacheApi?.match(url);
        if (data) {
          const content = await data.text();
          this.cacheStore.set(url, { content, status: STATUS.LOADED });
          return;
        }
        try {
          await this.cacheApi?.add(new Request(url, fetchOptions));
          const response = await this.cacheApi?.match(url);
          const content = await response?.text() ?? "";
          this.cacheStore.set(url, { content, status: STATUS.LOADED });
        } catch (error2) {
          this.cacheStore.set(url, { content: "", status: STATUS.FAILED });
          throw error2;
        }
      }
      async handleLoading(url, callback) {
        let retryCount = 0;
        while (this.cacheStore.get(url)?.status === STATUS.LOADING && retryCount < CACHE_MAX_RETRIES) {
          await sleep(0.1);
          retryCount += 1;
        }
        if (retryCount >= CACHE_MAX_RETRIES) {
          await callback();
        }
      }
      keys() {
        return [...this.cacheStore.keys()];
      }
      data() {
        return [...this.cacheStore.entries()].map(([key, value]) => ({ [key]: value }));
      }
      async delete(url) {
        if (this.cacheApi) {
          await this.cacheApi.delete(url);
        }
        this.cacheStore.delete(url);
      }
      async clear() {
        if (this.cacheApi) {
          const keys = await this.cacheApi.keys();
          for (const key of keys) {
            await this.cacheApi.delete(key);
          }
        }
        this.cacheStore.clear();
      }
    };
  }
});

// src/logic/utils/use-ink-file-has-strokes.ts
function useInkFileHasStrokes(file, vault) {
  const [hasStrokes, setHasStrokes] = (0, import_react127.useState)(null);
  (0, import_react127.useEffect)(() => {
    if (!file) {
      setHasStrokes(null);
      return;
    }
    const inkFile = file;
    let cancelled = false;
    async function refresh() {
      try {
        const svgString = await vault.read(inkFile);
        if (!cancelled) {
          setHasStrokes(inkFileHasStrokes(svgString));
        }
      } catch {
        if (!cancelled) {
          setHasStrokes(null);
        }
      }
    }
    void refresh();
    const onModify = (modifiedFile) => {
      if (modifiedFile.path !== inkFile.path)
        return;
      void refresh();
    };
    const eventRef = vault.on("modify", onModify);
    return () => {
      cancelled = true;
      vault.offref(eventRef);
    };
  }, [file, vault]);
  return hasStrokes;
}
var import_react127;
var init_use_ink_file_has_strokes = __esm({
  "src/logic/utils/use-ink-file-has-strokes.ts"() {
    import_react127 = __toESM(require_react());
    init_ink_file_has_strokes();
  }
});

// src/defaults/empty-writing-embed.svg
var empty_writing_embed_default;
var init_empty_writing_embed = __esm({
  "src/defaults/empty-writing-embed.svg"() {
    empty_writing_embed_default = '<svg xmlns="http://www.w3.org/2000/svg" direction="ltr" width="2064" height="289" viewBox="-32 -32 2064 289" stroke-linecap="round" stroke-linejoin="round" style="background-color: transparent;">\n    <defs/>\n    <g transform="matrix(1, 0, 0, 1, 0, 0)" opacity="1">\n        <line x1="100" y1="150" x2="1900" y2="150"/>\n    </g>\n    <g transform="matrix(1, 0, 0, 1, 0, 0)" opacity="1">\n        <rect width="2000" height="225" opacity="0"/>\n    </g>\n</svg>';
  }
});

// src/components/formats/current/writing/writing-embed-preview/writing-embed-preview.tsx
var import_classnames35, React95, WritingEmbedPreviewWrapper, WritingEmbedPreview;
var init_writing_embed_preview = __esm({
  "src/components/formats/current/writing/writing-embed-preview/writing-embed-preview.tsx"() {
    import_classnames35 = __toESM(require_classnames());
    init_16();
    React95 = __toESM(require_react());
    init_dist33();
    init_esm();
    init_writing_embed();
    init_ink_file_has_strokes();
    init_use_ink_file_has_strokes();
    init_empty_writing_embed();
    WritingEmbedPreviewWrapper = (props) => {
      const embedsInEditMode = useAtomValue(embedsInEditModeAtom);
      const previewActive = !props.embedId || !embedsInEditMode.has(props.embedId);
      if (previewActive) {
        return /* @__PURE__ */ React95.createElement(WritingEmbedPreview, {
          ...props
        });
      } else {
        return /* @__PURE__ */ React95.createElement(React95.Fragment, null);
      }
    };
    WritingEmbedPreview = (props) => {
      const containerElRef = React95.useRef(null);
      const [fileSrc, setFileSrc] = React95.useState(empty_writing_embed_default);
      const hasStrokes = useInkFileHasStrokes(props.writingFile, props.plugin.app.vault);
      React95.useEffect(() => {
        refreshSrc();
        const onModify = (modifiedFile) => {
          if (!props.writingFile)
            return;
          if (modifiedFile.path !== props.writingFile.path)
            return;
          refreshSrc();
        };
        const eventRef = props.plugin.app.vault.on("modify", onModify);
        return () => {
          props.plugin.app.vault.offref(eventRef);
        };
      }, [props.writingFile]);
      const isImg = fileSrc.slice(0, 4) === "data";
      return /* @__PURE__ */ React95.createElement(React95.Fragment, null, /* @__PURE__ */ React95.createElement("div", {
        ref: containerElRef,
        className: (0, import_classnames35.default)([
          "ddc_ink_writing-embed-preview",
          showLockedChrome(props.plugin.settings.writingLinesWhenLocked, hasStrokes) && "ddc_ink_visible-lines",
          showLockedChrome(props.plugin.settings.writingBackgroundWhenLocked, hasStrokes) && "ddc_ink_visible-background"
        ]),
        style: {
          position: "absolute",
          width: "100%",
          height: "100%",
          pointerEvents: "all"
        },
        onClick: props.onClick
      }, isImg && /* @__PURE__ */ React95.createElement(React95.Fragment, null, /* @__PURE__ */ React95.createElement("img", {
        src: fileSrc,
        key: fileSrc,
        style: {
          width: "100%",
          height: "100%",
          cursor: "pointer",
          pointerEvents: "all"
        },
        onLoad
      })), !isImg && /* @__PURE__ */ React95.createElement(React95.Fragment, null, /* @__PURE__ */ React95.createElement(InlineSVG, {
        src: fileSrc,
        cacheRequests: false,
        key: fileSrc,
        style: {
          width: "100%",
          height: "100%",
          maxWidth: "100%",
          maxHeight: "100%",
          cursor: "pointer"
        },
        pointerEvents: "visible",
        onLoad
      }))));
      function onLoad() {
        window.setTimeout(() => {
        }, 100);
      }
      function refreshSrc() {
        const basePath = props.plugin.app.vault.getResourcePath(props.writingFile);
        if (!basePath)
          return;
        const mtime = props.writingFile.stat.mtime;
        const separator = basePath.includes("?") ? "&" : "?";
        setFileSrc(`${basePath}${separator}t=${mtime}`);
      }
    };
  }
});

// src/stores/active-ink-embed-store.ts
async function replaceActiveInkEmbed(embedId, saveAndHalt) {
  const store = getDefaultStore();
  const previous = store.get(activeInkEmbedAtom);
  if (previous && previous.embedId !== embedId) {
    verbose(["Closing previous active ink embed before opening new one", {
      previousEmbedId: previous.embedId,
      newEmbedId: embedId
    }]);
    logToVault("Closing previous active ink embed " + previous.embedId + " for new embed " + embedId);
    await previous.saveAndHalt();
  }
  store.set(activeInkEmbedAtom, { embedId, saveAndHalt });
}
function clearActiveInkEmbed(embedId) {
  const store = getDefaultStore();
  const current = store.get(activeInkEmbedAtom);
  if (current && current.embedId === embedId) {
    store.set(activeInkEmbedAtom, null);
  }
}
var activeInkEmbedAtom;
var init_active_ink_embed_store = __esm({
  "src/stores/active-ink-embed-store.ts"() {
    init_esm();
    init_esm();
    init_universal_dev_logging();
    init_log_to_vault();
    activeInkEmbedAtom = atom(null);
  }
});

// src/logic/utils/copy-embed-to-clipboard.ts
async function copyEmbedMarkdownToClipboard(embedStr) {
  if (!embedStr) {
    new import_obsidian19.Notice("Nothing to copy");
    return false;
  }
  try {
    await navigator.clipboard.writeText(embedStr);
    new import_obsidian19.Notice("Embed copied to clipboard");
    return true;
  } catch {
    new import_obsidian19.Notice("Failed to copy embed to clipboard");
    return false;
  }
}
var import_obsidian19;
var init_copy_embed_to_clipboard = __esm({
  "src/logic/utils/copy-embed-to-clipboard.ts"() {
    import_obsidian19 = require("obsidian");
  }
});

// src/components/jsx-components/embed-preview-context-menu/embed-preview-context-menu.tsx
var React96, LONG_PRESS_MS, LONG_PRESS_MOVE_THRESHOLD_PX, EmbedPreviewContextMenu;
var init_embed_preview_context_menu = __esm({
  "src/components/jsx-components/embed-preview-context-menu/embed-preview-context-menu.tsx"() {
    React96 = __toESM(require_react());
    init_show_menu_options();
    LONG_PRESS_MS = 500;
    LONG_PRESS_MOVE_THRESHOLD_PX = 10;
    EmbedPreviewContextMenu = (props) => {
      const wrapperRef = React96.useRef(null);
      const longPressTimerRef = React96.useRef(null);
      const longPressStartRef = React96.useRef(null);
      const longPressHandledRef = React96.useRef(false);
      React96.useEffect(() => {
        return () => {
          if (longPressTimerRef.current) {
            window.clearTimeout(longPressTimerRef.current);
          }
        };
      }, []);
      function clearLongPressTimer() {
        if (longPressTimerRef.current) {
          window.clearTimeout(longPressTimerRef.current);
          longPressTimerRef.current = null;
        }
        longPressStartRef.current = null;
      }
      function showMenuAtClientPoint(clientX, clientY) {
        showMenuOptionsAtPosition(props.menuOptions, { x: clientX, y: clientY });
      }
      function handleContextMenu(e2) {
        e2.preventDefault();
        e2.stopPropagation();
        showMenuAtClientPoint(e2.clientX, e2.clientY);
      }
      function handlePointerDown(e2) {
        if (e2.pointerType !== "touch")
          return;
        longPressHandledRef.current = false;
        longPressStartRef.current = { x: e2.clientX, y: e2.clientY };
        clearLongPressTimer();
        longPressTimerRef.current = window.setTimeout(() => {
          longPressTimerRef.current = null;
          longPressHandledRef.current = true;
          longPressStartRef.current = null;
          showMenuAtClientPoint(e2.clientX, e2.clientY);
        }, LONG_PRESS_MS);
      }
      function handlePointerMove(e2) {
        if (!longPressStartRef.current || !longPressTimerRef.current)
          return;
        const dx = e2.clientX - longPressStartRef.current.x;
        const dy = e2.clientY - longPressStartRef.current.y;
        if (Math.hypot(dx, dy) > LONG_PRESS_MOVE_THRESHOLD_PX) {
          clearLongPressTimer();
        }
      }
      function handlePointerUp(e2) {
        clearLongPressTimer();
        if (longPressHandledRef.current) {
          e2.preventDefault();
          e2.stopPropagation();
          longPressHandledRef.current = false;
        }
      }
      function handleClickCapture(e2) {
        if (longPressHandledRef.current) {
          e2.preventDefault();
          e2.stopPropagation();
          longPressHandledRef.current = false;
        }
      }
      return /* @__PURE__ */ React96.createElement("div", {
        ref: wrapperRef,
        className: "ddc_ink_embed-preview-context-menu",
        style: { position: "absolute", width: "100%", height: "100%" },
        onContextMenu: handleContextMenu,
        onPointerDown: handlePointerDown,
        onPointerMove: handlePointerMove,
        onPointerUp: handlePointerUp,
        onPointerCancel: handlePointerUp,
        onClickCapture: handleClickCapture
      }, props.children);
    };
  }
});

// src/components/formats/current/writing/writing-embed/writing-embed.tsx
function WritingEmbed(props) {
  const isBooxConnectionEnabled = useBooxConnectionEnabled();
  const embedContainerElRef = (0, import_react128.useRef)(null);
  const resizeContainerElRef = (0, import_react128.useRef)(null);
  const editorControlsRef = (0, import_react128.useRef)();
  const embedAspectRatioRef = (0, import_react128.useRef)(props.embedSettings?.embedDisplay?.aspectRatio || DEFAULT_EMBED_SETTINGS.embedDisplay.aspectRatio);
  const previousHeightRef = (0, import_react128.useRef)(null);
  const defaultInitialWidth = 700;
  const setEmbedsInEditMode = useSetAtom(embedsInEditModeAtom);
  const embedsInEditMode = useAtomValue(embedsInEditModeAtom);
  const isThisEmbedEditing = !!(props.embedId && embedsInEditMode.has(props.embedId));
  const [writingFormat, setWritingFormat] = React97.useState("unknown");
  React97.useLayoutEffect(() => {
    const resizeContainer = resizeContainerElRef.current;
    if (!resizeContainer)
      return;
    const aspectRatio = props.embedSettings?.embedDisplay?.aspectRatio || DEFAULT_EMBED_SETTINGS.embedDisplay.aspectRatio;
    embedAspectRatioRef.current = aspectRatio;
    previousHeightRef.current = null;
    resizeContainer.classList.remove("ddc_ink_smooth-transition");
    const containerWidth = resizeContainer.getBoundingClientRect().width || defaultInitialWidth;
    resizeContainer.style.height = containerWidth / aspectRatio + "px";
  }, [props.writingFileRef?.path, props.embedSettings?.embedDisplay?.aspectRatio]);
  React97.useEffect(() => {
    if (!props.writingFileRef || isThisEmbedEditing)
      return;
    let cancelled = false;
    const syncAspectRatioFromFile = async () => {
      const fileRef = props.writingFileRef;
      if (!fileRef)
        return;
      try {
        const derivedAspectRatio = await readWritingFileAspectRatio(props.plugin, fileRef);
        if (cancelled || derivedAspectRatio == null)
          return;
        embedAspectRatioRef.current = derivedAspectRatio;
        const resizeContainer = resizeContainerElRef.current;
        if (resizeContainer) {
          const containerWidth = resizeContainer.getBoundingClientRect().width || defaultInitialWidth;
          applyEmbedHeight(containerWidth / derivedAspectRatio);
        }
      } catch {
      }
    };
    void syncAspectRatioFromFile();
    const onModify = (modifiedFile) => {
      if (modifiedFile.path !== props.writingFileRef?.path)
        return;
      void syncAspectRatioFromFile();
    };
    const eventRef = props.plugin.app.vault.on("modify", onModify);
    return () => {
      cancelled = true;
      props.plugin.app.vault.offref(eventRef);
    };
  }, [props.writingFileRef?.path, props.embedSettings?.embedDisplay?.aspectRatio, isThisEmbedEditing]);
  React97.useEffect(() => {
    if (!props.writingFileRef)
      return;
    setWritingFormat("unknown");
    props.plugin.app.vault.read(props.writingFileRef).then((svg) => {
      const data = extractInkJsonFromSvg(svg);
      if (!data) {
        setWritingFormat("unknown");
        return;
      }
      const engine = isInkCanvasFile(data) ? "ink-canvas" : "tldraw";
      setWritingFormat(engine);
    }).catch(() => setWritingFormat("unknown"));
  }, [props.writingFileRef]);
  React97.useEffect(() => {
    if (embedShouldActivateImmediately() && props.embedId) {
      window.setTimeout(() => {
        void switchToEditMode();
      }, 200);
    }
  }, []);
  React97.useEffect(() => {
    if (!props.workspaceLeafId)
      return;
    const plugin = getGlobals().plugin;
    const handler = (leaf) => {
      const isThisLeafActive = leaf?.id === props.workspaceLeafId;
      editorControlsRef.current?.setBooxOverlayActive?.(isThisLeafActive);
    };
    plugin.app.workspace.on("active-leaf-change", handler);
    return () => {
      plugin.app.workspace.off("active-leaf-change", handler);
    };
  }, [props.workspaceLeafId]);
  function handleCopyEmbed(_source) {
    const embedStr = props.getEmbedMarkdown?.() ?? null;
    if (!embedStr) {
      new import_obsidian20.Notice("Could not read embed markdown to copy");
      return;
    }
    void copyEmbedMarkdownToClipboard(embedStr);
  }
  function handleDeleteEmbed() {
    const removeFn = props.deleteEmbed ?? props.remove;
    if (!props.writingFileRef || !props.sourceMdFile) {
      removeFn();
      return;
    }
    openRemoveEmbedFlow(props.plugin, props.writingFileRef, props.sourceMdFile, "inkWriting", () => removeFn());
  }
  const embedClipboardMenuOptions = [
    {
      text: "Copy embed",
      action: () => {
        handleCopyEmbed("context-menu");
      }
    },
    {
      text: "Delete embed",
      warning: true,
      action: () => {
        handleDeleteEmbed();
      }
    }
  ];
  const commonExtendedOptions = [
    {
      text: "Open writing",
      action: () => {
        void openInDedicatedView();
      }
    },
    { separator: true },
    {
      text: "Copy embed",
      action: () => {
        handleCopyEmbed("overflow-menu");
      }
    },
    {
      text: "Convert to Drawing",
      action: () => {
        if (!props.writingFileRef)
          return;
        new FileConversionModal(props.plugin, props.writingFileRef, "inkDrawing", {
          sourceMdFile: props.sourceMdFile,
          onConversionComplete: (finalFile, toType) => {
            if (finalFile)
              void props.replaceEmbedAfterConversion?.(finalFile, toType);
            ignoreChangesAndSwitchToPreviewMode();
          }
        }).open();
      }
    },
    { separator: true },
    {
      text: "Erase all",
      warning: true,
      action: () => {
        new ConfirmationModal({
          plugin: props.plugin,
          title: "Erase all strokes?",
          message: "This will remove all strokes from the canvas.",
          confirmLabel: "Erase all",
          confirmAction: () => void editorControlsRef.current?.eraseAll?.()
        }).open();
      }
    },
    {
      text: "Delete embed",
      destructive: true,
      action: () => {
        handleDeleteEmbed();
      }
    }
  ];
  if (!props.writingFileRef) {
    return /* @__PURE__ */ React97.createElement(React97.Fragment, null, /* @__PURE__ */ React97.createElement("div", {
      className: "ddc_ink_embed ddc_ink_writing-embed"
    }, /* @__PURE__ */ React97.createElement("div", {
      className: "ddc_ink_pending-banner ddc_ink_pending-banner--not-found"
    }, /* @__PURE__ */ React97.createElement("span", {
      className: "ddc_ink_pending-banner__title"
    }, "Writing file not found: ", props.partialEmbedFilepath), /* @__PURE__ */ React97.createElement("div", {
      className: "ddc_ink_pending-banner__actions"
    }, /* @__PURE__ */ React97.createElement("button", {
      className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
      onClick: () => props.locateFile?.()
    }, "Locate file")))));
  }
  return /* @__PURE__ */ React97.createElement(React97.Fragment, null, /* @__PURE__ */ React97.createElement("div", {
    ref: embedContainerElRef,
    className: (0, import_classnames36.default)([
      "ddc_ink_embed",
      "ddc_ink_writing-embed",
      props.isPendingPaste && "ddc_ink_embed--pending"
    ]),
    style: {
      paddingTop: "1em",
      paddingBottom: "0.5em"
    }
  }, props.isPendingPaste && props.writingFileRef && /* @__PURE__ */ React97.createElement("div", {
    className: "ddc_ink_pending-banner"
  }, /* @__PURE__ */ React97.createElement("span", {
    className: "ddc_ink_pending-banner__title"
  }, "Copied embed \u2014 reference source or duplicate?"), /* @__PURE__ */ React97.createElement("div", {
    className: "ddc_ink_pending-banner__actions"
  }, /* @__PURE__ */ React97.createElement("button", {
    className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
    onClick: () => props.resolveAsReference?.()
  }, "Reference existing file"), /* @__PURE__ */ React97.createElement("button", {
    className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
    onClick: () => void props.resolveAsDuplicate?.()
  }, "Make duplicate"))), props.writingFileRef && /* @__PURE__ */ React97.createElement("div", {
    className: (0, import_classnames36.default)([
      "ddc_ink_resize-container",
      isBooxConnectionEnabled && "ddc_ink_resize-container--boox"
    ]),
    ref: resizeContainerElRef
  }, /* @__PURE__ */ React97.createElement(EmbedPreviewContextMenu, {
    menuOptions: embedClipboardMenuOptions
  }, /* @__PURE__ */ React97.createElement(WritingEmbedPreviewWrapper, {
    embedId: props.embedId,
    plugin: props.plugin,
    onResize: (height) => applySizingWhilePreviewing(height),
    writingFile: props.writingFileRef,
    onClick: props.isPendingPaste ? () => {
    } : () => void switchToEditMode()
  })), (writingFormat === "ink-canvas" || writingFormat === "tldraw") && props.writingFileRef && /* @__PURE__ */ React97.createElement(WritingEditorWrapper, {
    plugin: props.plugin,
    workspaceLeafId: props.workspaceLeafId,
    embedId: props.embedId,
    onResize: (invitingBounds, tightBounds) => applySizingWhileEditing(invitingBounds, tightBounds),
    writingFile: props.writingFileRef,
    save: props.save,
    embedded: true,
    saveControlsReference: registerEditorControls,
    closeEditor: () => void saveAndSwitchToPreviewMode(),
    extendedMenu: commonExtendedOptions,
    onOpenInDedicatedView: () => void openInDedicatedView()
  }))));
  function registerEditorControls(handlers) {
    editorControlsRef.current = handlers;
  }
  async function openInDedicatedView() {
    if (!props.writingFileRef)
      return;
    dismissLegacyInkNoticesForFile(props.writingFileRef.path);
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
    editorControlsRef.current = void 0;
    await openInkFileInView(props.writingFileRef, "inkWriting");
  }
  function applySizingWhilePreviewing(height) {
    if (!height)
      return;
    if (!resizeContainerElRef.current)
      return;
    applyEmbedHeight(height);
  }
  function applySizingWhileEditing(invitingBounds, tightBounds) {
    if (!resizeContainerElRef.current)
      return;
    const containerWidth = resizeContainerElRef.current.getBoundingClientRect().width;
    if (!containerWidth)
      return;
    const editorRatio = invitingBounds?.w && invitingBounds?.h ? invitingBounds.w / invitingBounds.h : null;
    if (editorRatio && isFinite(editorRatio) && editorRatio > 0) {
      const editorHeight = containerWidth / editorRatio;
      applyEmbedHeight(editorHeight);
    }
    const previewRatio = tightBounds?.w && tightBounds?.h ? tightBounds.w / tightBounds.h : null;
    if (previewRatio && isFinite(previewRatio) && previewRatio > 0) {
      embedAspectRatioRef.current = previewRatio;
    }
  }
  function applyEmbedHeight(height) {
    if (!resizeContainerElRef.current)
      return;
    resizeContainerElRef.current.style.height = height + "px";
    const heightChanged = previousHeightRef.current === null || Math.abs(height - previousHeightRef.current) > 1;
    if (heightChanged)
      props.onRequestMeasure?.();
    previousHeightRef.current = height;
    window.setTimeout(() => {
      if (!resizeContainerElRef.current)
        return;
      resizeContainerElRef.current.classList.add("ddc_ink_smooth-transition");
    }, 100);
  }
  async function switchToEditMode() {
    if (!props.embedId)
      return;
    verbose(["Add writing embed to edit mode", props.embedId]);
    logToVault("Writing embed \u2192 edit: " + (props.writingFileRef?.path ?? props.partialEmbedFilepath));
    if (getBooxConnectionEnabled()) {
      await replaceActiveInkEmbed(props.embedId, saveAndSwitchToPreviewMode);
    }
    setEmbedsInEditMode((prev) => new Set(prev).add(props.embedId));
  }
  function ignoreChangesAndSwitchToPreviewMode() {
    logToVault("Writing embed \u2192 preview (discarded): " + (props.writingFileRef?.path ?? props.partialEmbedFilepath));
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
  }
  async function saveAndSwitchToPreviewMode() {
    verbose(["Remove writing embed from edit mode", props.embedId]);
    logToVault("Writing embed \u2192 preview (saved): " + (props.writingFileRef?.path ?? props.partialEmbedFilepath));
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    if (resizeContainerElRef.current && embedAspectRatioRef.current) {
      const containerWidth = resizeContainerElRef.current.getBoundingClientRect().width;
      if (containerWidth) {
        const previewHeight = containerWidth / embedAspectRatioRef.current;
        applyEmbedHeight(previewHeight);
      }
    }
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
    if (props.setEmbedProps) {
      props.setEmbedProps(embedAspectRatioRef.current);
    }
  }
}
var React97, import_react128, import_obsidian20, import_classnames36, embedsInEditModeAtom, anyWritingEmbedInEditModeAtom;
var init_writing_embed = __esm({
  "src/components/formats/current/writing/writing-embed/writing-embed.tsx"() {
    init_14();
    React97 = __toESM(require_react());
    import_react128 = __toESM(require_react());
    init_writing_editor();
    init_extractInkJsonFromSvg();
    init_ink_file_storage_engine();
    init_file_conversion_modal();
    init_confirmation_modal();
    init_remove_embed_flow();
    init_open_file();
    init_storage();
    init_device_settings();
    init_use_boox_connection_enabled();
    init_universal_dev_logging();
    init_log_to_vault();
    import_obsidian20 = require("obsidian");
    init_writing_embed_preview();
    import_classnames36 = __toESM(require_classnames());
    init_esm();
    init_embed_settings();
    init_active_ink_embed_store();
    init_global_store();
    init_copy_embed_to_clipboard();
    init_embed_preview_context_menu();
    init_legacy_ink_notice();
    init_writing_embed_aspect_ratio();
    embedsInEditModeAtom = atom(/* @__PURE__ */ new Set());
    anyWritingEmbedInEditModeAtom = atom((get) => {
      return get(embedsInEditModeAtom).size > 0;
    });
  }
});

// src/logic/undo-redo/dedicated-ink-editor-registry.ts
function registerDedicatedInkEditor(leafId, editor) {
  dedicatedInkEditorByLeafId.set(leafId, editor);
}
function unregisterDedicatedInkEditor(leafId, editor) {
  if (dedicatedInkEditorByLeafId.get(leafId) === editor) {
    dedicatedInkEditorByLeafId.delete(leafId);
  }
}
function getDedicatedInkEditor(leafId) {
  return dedicatedInkEditorByLeafId.get(leafId) ?? null;
}
var dedicatedInkEditorByLeafId;
var init_dedicated_ink_editor_registry = __esm({
  "src/logic/undo-redo/dedicated-ink-editor-registry.ts"() {
    dedicatedInkEditorByLeafId = /* @__PURE__ */ new Map();
  }
});

// src/logic/undo-redo/embedded-unified-undo.ts
function initializeEmbeddedUnifiedUndo(plugin, leafId, embedId, editor) {
  const obsidianDepth = getObsidianUndoDepthForLeaf(plugin, leafId);
  const canvasUndos = getTldrawNumUndos(editor);
  const registeredCount = getRegisteredEmbedCountForLeaf(leafId);
  const shouldMerge = registeredCount > 0 || !isUndoStackEmpty(leafId);
  if (shouldMerge) {
    initialize(leafId, obsidianDepth, canvasUndos, void 0, { mergeWithExisting: true, embedId });
  } else {
    initialize(leafId, obsidianDepth, canvasUndos);
  }
}
function recordEmbedCanvasActionOnUnifiedStack(leafId, embedId) {
  pushEmbedCanvasActionToUnifiedStack(leafId, embedId);
}
function syncObsidianOnlyBeforeKeyboard(leafId) {
  const embedIds = getRegisteredEmbedIdsForLeaf(leafId);
  if (embedIds.length === 0)
    return;
  syncUnifiedUndoHistory(leafId, embedIds[0], { skipEmbed: true });
}
var init_embedded_unified_undo = __esm({
  "src/logic/undo-redo/embedded-unified-undo.ts"() {
    init_ink_editor_registry();
    init_obsidian_undo_depth();
    init_tldraw_undo_depth();
    init_unified_undo_stack();
  }
});

// src/ink-canvas/ink-svg-canvas.scss
var init_17 = __esm({
  "src/ink-canvas/ink-svg-canvas.scss"() {
  }
});

// src/ink-canvas/stroke-store.ts
var StrokeStore;
var init_stroke_store = __esm({
  "src/ink-canvas/stroke-store.ts"() {
    StrokeStore = class {
      constructor() {
        this.strokes = /* @__PURE__ */ new Map();
        this.insertionOrder = [];
        this.listeners = /* @__PURE__ */ new Set();
      }
      subscribe(listener) {
        this.listeners.add(listener);
        return () => {
          this.listeners.delete(listener);
        };
      }
      notify() {
        for (const listener of this.listeners) {
          listener();
        }
      }
      add(stroke) {
        this.strokes.set(stroke.id, stroke);
        this.insertionOrder.push(stroke.id);
        this.notify();
      }
      addMany(strokesArr) {
        for (const stroke of strokesArr) {
          this.strokes.set(stroke.id, stroke);
          this.insertionOrder.push(stroke.id);
        }
        this.notify();
      }
      remove(ids) {
        const idSet = new Set(ids);
        for (const id of ids) {
          this.strokes.delete(id);
        }
        this.insertionOrder = this.insertionOrder.filter((id) => !idSet.has(id));
        this.notify();
      }
      updateOffsets(offsets) {
        for (const [id, offset5] of offsets) {
          const stroke = this.strokes.get(id);
          if (stroke) {
            this.strokes.set(id, { ...stroke, offset: offset5 });
          }
        }
        this.notify();
      }
      getById(id) {
        return this.strokes.get(id);
      }
      getAll() {
        return this.insertionOrder.map((id) => this.strokes.get(id)).filter((s2) => s2 !== void 0);
      }
      getAllIds() {
        return [...this.insertionOrder];
      }
      count() {
        return this.strokes.size;
      }
      clear() {
        this.strokes.clear();
        this.insertionOrder = [];
        this.notify();
      }
      replaceAll(strokesArr) {
        this.strokes.clear();
        this.insertionOrder = [];
        for (const stroke of strokesArr) {
          this.strokes.set(stroke.id, stroke);
          this.insertionOrder.push(stroke.id);
        }
        this.notify();
      }
    };
  }
});

// src/ink-canvas/undo-manager.ts
var UndoManager;
var init_undo_manager = __esm({
  "src/ink-canvas/undo-manager.ts"() {
    UndoManager = class {
      constructor() {
        this.undoStack = [];
        this.redoStack = [];
        this.listeners = /* @__PURE__ */ new Set();
      }
      subscribe(listener) {
        this.listeners.add(listener);
        return () => {
          this.listeners.delete(listener);
        };
      }
      notify(event) {
        for (const listener of this.listeners) {
          listener(event);
        }
      }
      execute(command) {
        command.apply();
        this.undoStack.push(command);
        this.redoStack = [];
        this.notify("execute");
      }
      undo() {
        const command = this.undoStack.pop();
        if (!command)
          return;
        command.unapply();
        this.redoStack.push(command);
        this.notify("undo");
      }
      redo() {
        const command = this.redoStack.pop();
        if (!command)
          return;
        command.apply();
        this.undoStack.push(command);
        this.notify("redo");
      }
      canUndo() {
        return this.undoStack.length > 0;
      }
      canRedo() {
        return this.redoStack.length > 0;
      }
      getUndoCount() {
        return this.undoStack.length;
      }
      getRedoCount() {
        return this.redoStack.length;
      }
      clear() {
        this.undoStack = [];
        this.redoStack = [];
        this.notify("clear");
      }
    };
  }
});

// src/ink-canvas/pan-momentum.ts
function isTrackpadWheel(event) {
  if (event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL)
    return false;
  return Math.abs(event.deltaY) < 100 && Math.abs(event.deltaX) < 100;
}
function isPinchWheelZoomEvent(event) {
  return event.ctrlKey && !event.metaKey;
}
function getModifierWheelZoomDirection(event) {
  const direction = event.deltaY < 0 ? -1 : 1;
  return isPinchWheelZoomEvent(event) ? direction > 0 ? -1 : 1 : direction;
}
function createModifierWheelZoomDirectionResolver() {
  return {
    getDirection(event) {
      return getModifierWheelZoomDirection(event);
    },
    cancel() {
    }
  };
}
function createPanMomentumController(options) {
  const axis = options.axis;
  const minReleaseVelocity = options.minReleaseVelocityPxPerSec ?? DEFAULT_MIN_RELEASE_VELOCITY;
  const frictionPerFrame = options.frictionPerFrame ?? DEFAULT_FRICTION_PER_FRAME;
  const maxVelocity = options.maxVelocityPxPerSec ?? DEFAULT_MAX_VELOCITY;
  const stopVelocity = options.stopVelocityPxPerSec ?? DEFAULT_STOP_VELOCITY;
  const velocityWindowMs = options.velocityWindowMs ?? DEFAULT_VELOCITY_WINDOW_MS;
  let samples = [];
  let rafId = null;
  let velocityX = 0;
  let velocityY = 0;
  let lastFrameTimeMs = 0;
  const pruneSamples = (now) => {
    while (samples.length > 0 && now - samples[0].t > SAMPLE_RETENTION_MS) {
      samples.shift();
    }
  };
  const capVelocity = (vx, vy) => {
    if (axis === "y")
      vx = 0;
    if (axis === "x")
      vy = 0;
    const speed = Math.hypot(vx, vy);
    if (speed <= maxVelocity || speed === 0)
      return { vx, vy };
    const scale = maxVelocity / speed;
    return { vx: vx * scale, vy: vy * scale };
  };
  const computeReleaseVelocity = (now) => {
    const recent = samples.filter((s2) => now - s2.t <= velocityWindowMs);
    if (recent.length < 2)
      return null;
    let totalDx = 0;
    let totalDy = 0;
    const tStart = recent[0].t;
    const tEnd = recent[recent.length - 1].t;
    const dtMs = Math.max(tEnd - tStart, 1);
    for (const sample of recent) {
      totalDx += sample.dx;
      totalDy += sample.dy;
    }
    let vx = totalDx / dtMs * 1e3;
    let vy = totalDy / dtMs * 1e3;
    ({ vx, vy } = capVelocity(vx, vy));
    const speed = Math.hypot(vx, vy);
    if (speed < minReleaseVelocity)
      return null;
    return { vx, vy };
  };
  const stopAnimation = () => {
    if (rafId !== null) {
      cancelAnimationFrame(rafId);
      rafId = null;
    }
    velocityX = 0;
    velocityY = 0;
  };
  return {
    recordScreenDelta(deltaScreenX, deltaScreenY, timestampMs = performance.now()) {
      if (deltaScreenX === 0 && deltaScreenY === 0)
        return;
      pruneSamples(timestampMs);
      samples.push({ t: timestampMs, dx: deltaScreenX, dy: deltaScreenY });
    },
    cancel() {
      stopAnimation();
      samples = [];
    },
    isActive() {
      return rafId !== null;
    },
    release(applyFrame) {
      stopAnimation();
      const now = performance.now();
      const releaseVelocity = computeReleaseVelocity(now);
      samples = [];
      if (!releaseVelocity)
        return;
      velocityX = releaseVelocity.vx;
      velocityY = releaseVelocity.vy;
      lastFrameTimeMs = now;
      const tick3 = (frameTimeMs) => {
        const dtMs = Math.max(frameTimeMs - lastFrameTimeMs, 1);
        lastFrameTimeMs = frameTimeMs;
        const friction = Math.pow(frictionPerFrame, dtMs / (1e3 / 60));
        velocityX *= friction;
        velocityY *= friction;
        const speed = Math.hypot(velocityX, velocityY);
        if (speed < stopVelocity) {
          stopAnimation();
          return;
        }
        const deltaScreenX = velocityX * (dtMs / 1e3);
        const deltaScreenY = velocityY * (dtMs / 1e3);
        const shouldContinue = applyFrame(deltaScreenX, deltaScreenY);
        if (!shouldContinue) {
          stopAnimation();
          return;
        }
        rafId = window.requestAnimationFrame(tick3);
      };
      rafId = window.requestAnimationFrame(tick3);
    }
  };
}
var DEFAULT_MIN_RELEASE_VELOCITY, DEFAULT_FRICTION_PER_FRAME, DEFAULT_MAX_VELOCITY, DEFAULT_STOP_VELOCITY, DEFAULT_VELOCITY_WINDOW_MS, SAMPLE_RETENTION_MS;
var init_pan_momentum = __esm({
  "src/ink-canvas/pan-momentum.ts"() {
    DEFAULT_MIN_RELEASE_VELOCITY = 100;
    DEFAULT_FRICTION_PER_FRAME = 0.92;
    DEFAULT_MAX_VELOCITY = 4e3;
    DEFAULT_STOP_VELOCITY = 15;
    DEFAULT_VELOCITY_WINDOW_MS = 120;
    SAMPLE_RETENTION_MS = 150;
  }
});

// src/ink-canvas/stroke-viewport-culling.ts
function computeApproxStrokePageBounds(stroke) {
  let minX = Infinity;
  let minY = Infinity;
  let maxX = -Infinity;
  let maxY = -Infinity;
  for (const [px, py] of stroke.points) {
    if (px < minX)
      minX = px;
    if (py < minY)
      minY = py;
    if (px > maxX)
      maxX = px;
    if (py > maxY)
      maxY = py;
  }
  if (!Number.isFinite(minX)) {
    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
  }
  const pad = Math.max(stroke.style.size, 1);
  return {
    minX: minX + stroke.offset.x - pad,
    minY: minY + stroke.offset.y - pad,
    maxX: maxX + stroke.offset.x + pad,
    maxY: maxY + stroke.offset.y + pad
  };
}
function pageRectsIntersect(a2, b2) {
  return a2.minX <= b2.maxX && a2.maxX >= b2.minX && a2.minY <= b2.maxY && a2.maxY >= b2.minY;
}
function computeApproxContentMaxY(strokes) {
  let maxY = 0;
  for (const stroke of strokes) {
    const bounds = computeApproxStrokePageBounds(stroke);
    if (bounds.maxY > maxY)
      maxY = bounds.maxY;
  }
  return maxY;
}
function visiblePageRectFromContainer(camera, containerRect, marginScreenPx = 80) {
  const visibleLeft = Math.max(containerRect.left, 0) - marginScreenPx;
  const visibleTop = Math.max(containerRect.top, 0) - marginScreenPx;
  const visibleRight = Math.min(containerRect.right, window.innerWidth) + marginScreenPx;
  const visibleBottom = Math.min(containerRect.bottom, window.innerHeight) + marginScreenPx;
  if (visibleRight <= visibleLeft || visibleBottom <= visibleTop) {
    return null;
  }
  const topLeft = screenToPage(camera, containerRect, visibleLeft, visibleTop);
  const bottomRight = screenToPage(camera, containerRect, visibleRight, visibleBottom);
  return {
    minX: Math.min(topLeft.x, bottomRight.x),
    minY: Math.min(topLeft.y, bottomRight.y),
    maxX: Math.max(topLeft.x, bottomRight.x),
    maxY: Math.max(topLeft.y, bottomRight.y)
  };
}
var init_stroke_viewport_culling = __esm({
  "src/ink-canvas/stroke-viewport-culling.ts"() {
    init_camera();
  }
});

// src/components/formats/current/utils/tldraw-helpers.ts
function cropWritingStrokeHeightTightly2(height, lineHeight = WRITING_LINE_HEIGHT) {
  const minPageHeight = lineHeight * 2.5;
  const numFilledLines = Math.ceil(height / lineHeight);
  const newLineHeight = (numFilledLines + 0.5) * lineHeight;
  return Math.max(newLineHeight, minPageHeight);
}
function cropWritingStrokeHeightInvitingly2(height, bufferLines = 2, lineHeight = WRITING_LINE_HEIGHT) {
  const minPageHeight = lineHeight * 2.5;
  const numOfLines = Math.ceil(height / lineHeight);
  const newLineHeight = (numOfLines + bufferLines + 0.5) * lineHeight;
  return Math.max(newLineHeight, minPageHeight);
}
function shouldResizeForNewHeight(newHeight, curHeight, bufferLines, lineHeight = WRITING_LINE_HEIGHT) {
  if (curHeight === null)
    return true;
  if (newHeight < curHeight)
    return true;
  if (newHeight > curHeight + (bufferLines - 1) * lineHeight)
    return true;
  return false;
}
function computeDedicatedWritingPageHeight(scrollTopPx, viewportHeightPx, zoom, invitingContentHeight, lineHeight = WRITING_LINE_HEIGHT) {
  const pageBottomVisible = (scrollTopPx + viewportHeightPx) / zoom;
  const minFromViewport = pageBottomVisible + 10 * lineHeight;
  return Math.max(minFromViewport, invitingContentHeight);
}
var init_tldraw_helpers = __esm({
  "src/components/formats/current/utils/tldraw-helpers.ts"() {
    init_dist_esm12();
    init_constants();
    init_universal_dev_logging();
    init_global_store();
  }
});

// src/ink-canvas/commands.ts
var AddStrokeCommand, RemoveStrokesCommand, MoveStrokesCommand, EraseAllCommand;
var init_commands = __esm({
  "src/ink-canvas/commands.ts"() {
    AddStrokeCommand = class {
      constructor(store, stroke) {
        this.store = store;
        this.stroke = stroke;
      }
      apply() {
        this.store.add(this.stroke);
      }
      unapply() {
        this.store.remove([this.stroke.id]);
      }
    };
    RemoveStrokesCommand = class {
      constructor(store, strokeIds) {
        this.store = store;
        this.removedStrokes = strokeIds.map((id) => store.getById(id)).filter((s2) => s2 !== void 0);
      }
      apply() {
        const ids = this.removedStrokes.map((s2) => s2.id);
        this.store.remove(ids);
      }
      unapply() {
        this.store.addMany(this.removedStrokes);
      }
    };
    MoveStrokesCommand = class {
      constructor(store, strokeIds, deltaX, deltaY) {
        this.store = store;
        this.strokeIds = strokeIds;
        this.previousOffsets = /* @__PURE__ */ new Map();
        this.newOffsets = /* @__PURE__ */ new Map();
        for (const id of strokeIds) {
          const stroke = store.getById(id);
          if (!stroke)
            continue;
          this.previousOffsets.set(id, { ...stroke.offset });
          this.newOffsets.set(id, {
            x: stroke.offset.x + deltaX,
            y: stroke.offset.y + deltaY
          });
        }
      }
      apply() {
        this.store.updateOffsets(this.newOffsets);
      }
      unapply() {
        this.store.updateOffsets(this.previousOffsets);
      }
    };
    EraseAllCommand = class {
      constructor(store) {
        this.store = store;
        this.previousStrokes = store.getAll();
      }
      apply() {
        this.store.clear();
      }
      unapply() {
        this.store.replaceAll(this.previousStrokes);
      }
    };
  }
});

// src/ink-canvas/utils/pointer-samples.ts
function getPointerSamples(e2) {
  if (!USE_COALESCED_POINTER_SAMPLES)
    return [e2];
  if (typeof e2.getCoalescedEvents !== "function")
    return [e2];
  const coalesced = e2.getCoalescedEvents();
  if (!coalesced?.length)
    return [e2];
  let samples = coalesced.length > 1 ? [...coalesced].sort((a2, b2) => a2.timeStamp - b2.timeStamp) : [...coalesced];
  const tail = samples[samples.length - 1];
  const dx = e2.clientX - tail.clientX;
  const dy = e2.clientY - tail.clientY;
  const screenDistSq = dx * dx + dy * dy;
  if (screenDistSq > 0.01) {
    samples = [...samples, e2];
  }
  return samples;
}
var USE_COALESCED_POINTER_SAMPLES;
var init_pointer_samples = __esm({
  "src/ink-canvas/utils/pointer-samples.ts"() {
    USE_COALESCED_POINTER_SAMPLES = false;
  }
});

// src/logic/device-settings/detect-stroke-input-from-pressures.ts
function detectStrokeInputFromRawPressures(pressures) {
  if (pressures.length === 0)
    return "mouse";
  const first = pressures[0];
  return pressures.every((p2) => p2 === first) ? "mouse" : "pen";
}
var init_detect_stroke_input_from_pressures = __esm({
  "src/logic/device-settings/detect-stroke-input-from-pressures.ts"() {
  }
});

// src/ink-canvas/stroke-presets.ts
function buildInkStrokeStyleForTreatAs(base, treatAs, captureZoom = INK_STROKE_ZOOM_REFERENCE) {
  const numeric = treatAs === "pen" ? PEN_NUMERIC_STROKE_PARTIAL : MOUSE_NUMERIC_STROKE_PARTIAL;
  const size4 = treatAs === "mouse" ? base.size * OPTICAL_MOUSE_TO_PEN_RATIO : base.size;
  const zoom = clampCaptureZoom(captureZoom);
  return {
    ...base,
    ...numeric,
    size: size4,
    streamline: numericForCaptureZoom(numeric.streamline, zoom, treatAs),
    smoothing: numericForCaptureZoom(numeric.smoothing, zoom, treatAs),
    inputKind: treatAs,
    captureZoom: zoom
  };
}
var PEN_NUMERIC_STROKE_PARTIAL, MOUSE_NUMERIC_STROKE_PARTIAL, OPTICAL_MOUSE_TO_PEN_RATIO;
var init_stroke_presets = __esm({
  "src/ink-canvas/stroke-presets.ts"() {
    init_stroke_zoom_scale();
    PEN_NUMERIC_STROKE_PARTIAL = {
      thinning: 0.6,
      smoothing: 0.1,
      streamline: 0,
      simulatePressure: false
    };
    MOUSE_NUMERIC_STROKE_PARTIAL = {
      thinning: 0.6,
      smoothing: 0.4,
      streamline: 0.4,
      simulatePressure: true
    };
    OPTICAL_MOUSE_TO_PEN_RATIO = 1;
  }
});

// src/ink-canvas/constants/pen-input.ts
function scaleAndClampPenPressure(raw, gain = PEN_PRESSURE_GAIN) {
  if (!Number.isFinite(raw))
    return 0;
  return Math.min(1, Math.max(0, raw * gain));
}
function applyPenEarlyStrokePressureFloor(scaledPressure, strokePathLength, strokeSize, lengthMultiplier = PEN_EARLY_STROKE_FLOOR_LENGTH_MULTIPLIER) {
  if (strokeSize <= 0)
    return Math.max(PEN_MIN_START_PRESSURE, scaledPressure);
  if (strokePathLength < strokeSize * lengthMultiplier) {
    return Math.max(PEN_MIN_START_PRESSURE, scaledPressure);
  }
  return scaledPressure;
}
function normalizePointerPenPressureForCapture(rawPressure, strokePathLength, strokeSize) {
  const scaled = scaleAndClampPenPressure(rawPressure);
  return applyPenEarlyStrokePressureFloor(scaled, strokePathLength, strokeSize);
}
function normalizeBooxPenPressureForCapture(rawPressure) {
  return scaleAndClampPenPressure(rawPressure, BOOX_PEN_PRESSURE_GAIN);
}
var PEN_PRESSURE_GAIN, PEN_MIN_START_PRESSURE, PEN_PRESSURE_SMOOTHING_ALPHA, PEN_PRESSURE_SLEW_PER_SIZE, PEN_HOVER_PRESSURE_EPSILON, PEN_EARLY_STROKE_FLOOR_LENGTH_MULTIPLIER, BOOX_PEN_PRESSURE_GAIN;
var init_pen_input = __esm({
  "src/ink-canvas/constants/pen-input.ts"() {
    PEN_PRESSURE_GAIN = 1.25;
    PEN_MIN_START_PRESSURE = 0.15;
    PEN_PRESSURE_SMOOTHING_ALPHA = 0.4;
    PEN_PRESSURE_SLEW_PER_SIZE = 0.3;
    PEN_HOVER_PRESSURE_EPSILON = 0.01;
    PEN_EARLY_STROKE_FLOOR_LENGTH_MULTIPLIER = 1;
    BOOX_PEN_PRESSURE_GAIN = 1;
  }
});

// src/ink-canvas/tools/draw-tool.ts
function generateStrokeId() {
  return `s_${Date.now()}_${idCounter3++}`;
}
function isHardwarePen(e2) {
  return e2.pointerType === "pen";
}
function isFingerPointer(e2) {
  return e2.pointerType === "touch";
}
function getEffectiveStrokeInputTreatAs(e2, ctx) {
  if (isFingerPointer(e2))
    return "mouse";
  return ctx.getResolvedStrokeInputTreatAs();
}
function drawToolPointerDown(e2, ctx) {
  const treatAs = getEffectiveStrokeInputTreatAs(e2, ctx);
  const treatAsPen = treatAs === "pen";
  const camera = ctx.getCamera();
  const containerRect = ctx.getContainerRect();
  const pagePoint = screenToPage(camera, containerRect, e2.clientX, e2.clientY);
  let pressure = e2.pressure;
  if (!treatAsPen && pressure === 0)
    pressure = 0.5;
  if (isHardwarePen(e2)) {
    pressure = normalizePointerPenPressureForCapture(e2.pressure, 0, ctx.getStrokeStyle().size);
  }
  const baseStyle = ctx.getStrokeStyle();
  const style = buildInkStrokeStyleForTreatAs(baseStyle, treatAs, camera.zoom);
  const firstPoint = [pagePoint.x, pagePoint.y, pressure];
  activeStroke = {
    id: generateStrokeId(),
    points: [copyInkPoint(firstPoint)],
    style: { ...style },
    startedAt: Date.now(),
    strokePathLength: 0,
    lastSmoothedPenPressure: pressure,
    lastCommittedPointAtMs: e2.timeStamp,
    rawSamples: [
      {
        clientX: e2.clientX,
        clientY: e2.clientY,
        pressure: e2.pressure,
        isPointerUpLiftSample: false
      }
    ]
  };
  updateLiveStrokePath(ctx);
}
function drawToolPointerMove(e2, ctx) {
  if (!activeStroke)
    return;
  appendDrawSamplesFromPointerEvent(e2, ctx, { forceCommitFinalPoint: false });
}
function drawToolPointerUp(e2, ctx) {
  if (!activeStroke)
    return;
  appendDrawSamplesFromPointerEvent(e2, ctx, { forceCommitFinalPoint: true });
  const isFingerStroke = isFingerPointer(e2);
  if (!isFingerStroke) {
    const detected = detectStrokeInputFromRawPressures(activeStroke.rawSamples.filter((s2) => !s2.isPointerUpLiftSample).map((s2) => s2.pressure));
    ctx.onStrokeInputDetected?.(detected);
    const preference = ctx.getStrokeInputTreatAsPreference();
    if (preference === "auto") {
      const recomputed = recomputeStrokeFromRawSamples({
        rawSamples: activeStroke.rawSamples,
        detected,
        camera: ctx.getCamera(),
        containerRect: ctx.getContainerRect(),
        baseStyle: ctx.getStrokeStyle()
      });
      activeStroke.points = recomputed.points;
      activeStroke.strokePathLength = recomputed.strokePathLength;
      activeStroke.lastSmoothedPenPressure = recomputed.lastSmoothedPenPressure;
      activeStroke.style = recomputed.style;
    } else {
      activeStroke.style = buildInkStrokeStyleForTreatAs(ctx.getStrokeStyle(), ctx.getResolvedStrokeInputTreatAs(), ctx.getCamera().zoom);
    }
  } else {
    activeStroke.style = buildInkStrokeStyleForTreatAs(ctx.getStrokeStyle(), "mouse", ctx.getCamera().zoom);
  }
  const stroke = {
    id: activeStroke.id,
    authoringSource: "local",
    points: activeStroke.points,
    style: activeStroke.style,
    offset: { x: 0, y: 0 },
    startedAt: activeStroke.startedAt,
    finishedAt: Date.now()
  };
  const command = new AddStrokeCommand(ctx.store, stroke);
  ctx.undoManager.execute(command);
  const livePath = ctx.getLiveStrokePath();
  if (livePath)
    livePath.setAttribute("d", "");
  activeStroke = null;
  ctx.onStrokeComplete?.();
}
function drawToolPointerCancel(_e, ctx) {
  const livePath = ctx.getLiveStrokePath();
  if (livePath)
    livePath.setAttribute("d", "");
  activeStroke = null;
}
function appendDrawSamplesFromPointerEvent(e2, ctx, options) {
  if (!activeStroke)
    return;
  const camera = ctx.getCamera();
  const containerRect = ctx.getContainerRect();
  const samples = getPointerSamples(e2);
  const treatAsPen = getEffectiveStrokeInputTreatAs(e2, ctx) === "pen";
  const mergeThresholdPage = 1 / camera.zoom;
  const hardwarePen = isHardwarePen(e2);
  const alpha = PEN_PRESSURE_SMOOTHING_ALPHA;
  const lastSampleIdx = samples.length - 1;
  for (let i2 = 0; i2 < samples.length; i2++) {
    const sample = samples[i2];
    const sampleIsPen = sample.pointerType === "pen" || hardwarePen;
    if (sampleIsPen && !options.forceCommitFinalPoint && sample.pressure <= PEN_HOVER_PRESSURE_EPSILON) {
      continue;
    }
    const pagePoint = screenToPage(camera, containerRect, sample.clientX, sample.clientY);
    const isLastSample = i2 === lastSampleIdx;
    const isPointerUpLiftSample = options.forceCommitFinalPoint && isLastSample;
    activeStroke.rawSamples.push({
      clientX: sample.clientX,
      clientY: sample.clientY,
      pressure: sample.pressure,
      isPointerUpLiftSample
    });
    let pressure = sample.pressure;
    if (!treatAsPen && pressure === 0)
      pressure = 0.5;
    if (sampleIsPen) {
      pressure = normalizePointerPenPressureForCapture(sample.pressure, activeStroke.strokePathLength, activeStroke.style.size);
      const last7 = activeStroke.points[activeStroke.points.length - 1];
      const dx = pagePoint.x - last7[0];
      const dy = pagePoint.y - last7[1];
      const segmentPageDistance = Math.hypot(dx, dy);
      const sampleTimeMs = e2.timeStamp + i2;
      const willMerge = shouldReplaceTipWithPoint(activeStroke.points, [pagePoint.x, pagePoint.y, pressure], mergeThresholdPage, sampleTimeMs, activeStroke.lastCommittedPointAtMs) && !(options.forceCommitFinalPoint && i2 === lastSampleIdx);
      if (willMerge) {
        pressure = Math.max(last7[2], pressure);
        activeStroke.lastSmoothedPenPressure = pressure;
      } else {
        const prevSmoothed = activeStroke.lastSmoothedPenPressure;
        const eased = alpha > 0 ? prevSmoothed + (pressure - prevSmoothed) * alpha : pressure;
        const maxPressureDelta = penPressureSlewLimit(segmentPageDistance, activeStroke.style.size);
        pressure = clampNumber(eased, prevSmoothed - maxPressureDelta, prevSmoothed + maxPressureDelta);
        activeStroke.lastSmoothedPenPressure = pressure;
      }
    }
    const nextPoint = [pagePoint.x, pagePoint.y, pressure];
    if (options.forceCommitFinalPoint && isLastSample) {
      setOrAppendLastPoint(activeStroke, nextPoint);
    } else {
      appendOrMergePoint(activeStroke, nextPoint, mergeThresholdPage, e2.timeStamp + i2);
    }
  }
  updateLiveStrokePath(ctx);
}
function copyInkPoint(p2) {
  return [p2[0], p2[1], p2[2]];
}
function recomputeStrokeFromRawSamples(args) {
  const { rawSamples, detected, camera, containerRect, baseStyle } = args;
  const treatAsPen = detected === "pen";
  const mergeThresholdPage = 1 / camera.zoom;
  const alpha = PEN_PRESSURE_SMOOTHING_ALPHA;
  const style = buildInkStrokeStyleForTreatAs(baseStyle, detected, camera.zoom);
  const points = [];
  let strokePathLength = 0;
  let lastSmoothedPenPressure = 0.5;
  const mergeState = { points, lastCommittedPointAtMs: 0 };
  const recomputeSampleIntervalMs = 16;
  const lastSampleIdx = rawSamples.length - 1;
  for (let i2 = 0; i2 < rawSamples.length; i2++) {
    const sampleTimeMs = i2 * recomputeSampleIntervalMs;
    const sample = rawSamples[i2];
    const isLastSample = i2 === lastSampleIdx;
    const pagePoint = screenToPage(camera, containerRect, sample.clientX, sample.clientY);
    let pressure = sample.pressure;
    if (!treatAsPen && pressure === 0)
      pressure = 0.5;
    if (treatAsPen) {
      pressure = normalizePointerPenPressureForCapture(sample.pressure, strokePathLength, style.size);
      if (points.length > 0) {
        const last7 = points[points.length - 1];
        const dx = pagePoint.x - last7[0];
        const dy = pagePoint.y - last7[1];
        const segmentPageDistance = Math.hypot(dx, dy);
        const willMerge = shouldReplaceTipWithPoint(points, [pagePoint.x, pagePoint.y, pressure], mergeThresholdPage, sampleTimeMs, mergeState.lastCommittedPointAtMs) && !isLastSample;
        if (willMerge) {
          pressure = Math.max(last7[2], pressure);
          lastSmoothedPenPressure = pressure;
        } else {
          const prevSmoothed = lastSmoothedPenPressure;
          const eased = alpha > 0 ? prevSmoothed + (pressure - prevSmoothed) * alpha : pressure;
          const maxPressureDelta = penPressureSlewLimit(segmentPageDistance, style.size);
          pressure = clampNumber(eased, prevSmoothed - maxPressureDelta, prevSmoothed + maxPressureDelta);
          lastSmoothedPenPressure = pressure;
        }
      } else {
        lastSmoothedPenPressure = pressure;
      }
    }
    const nextPoint = [pagePoint.x, pagePoint.y, pressure];
    if (isLastSample) {
      if (points.length === 0) {
        points.push(nextPoint);
      } else {
        const last7 = points[points.length - 1];
        const dx = nextPoint[0] - last7[0];
        const dy = nextPoint[1] - last7[1];
        const dist = Math.hypot(dx, dy);
        points[points.length - 1] = [nextPoint[0], nextPoint[1], Math.max(last7[2], nextPoint[2])];
        strokePathLength += dist;
      }
    } else {
      strokePathLength += applyAppendOrMergePoint(mergeState, nextPoint, mergeThresholdPage, sampleTimeMs);
    }
  }
  return { points, strokePathLength, lastSmoothedPenPressure, style };
}
function clampNumber(value, min4, max3) {
  return Math.min(max3, Math.max(min4, value));
}
function penPressureSlewLimit(segmentPageDistance, strokeSizePage) {
  if (strokeSizePage <= 0)
    return 1;
  return PEN_PRESSURE_SLEW_PER_SIZE * (segmentPageDistance / strokeSizePage);
}
function isWithinMergeRadiusPage(x2, y2, reference2, mergeThresholdPage) {
  const dx = x2 - reference2[0];
  const dy = y2 - reference2[1];
  const thresholdSq = mergeThresholdPage * mergeThresholdPage;
  return dx * dx + dy * dy < thresholdSq;
}
function resolvePointMergeAction(points, next, mergeThresholdPage, sampleTimeMs, lastCommittedPointAtMs) {
  if (points.length === 0)
    return "append";
  const last7 = points[points.length - 1];
  const withinTipRadius = isWithinMergeRadiusPage(next[0], next[1], last7, mergeThresholdPage);
  if (!withinTipRadius)
    return "append";
  if (points.length >= 2) {
    const anchor = points[points.length - 2];
    const withinAnchorRadius = isWithinMergeRadiusPage(next[0], next[1], anchor, mergeThresholdPage);
    if (!withinAnchorRadius) {
      const msSinceLastCommit = sampleTimeMs - lastCommittedPointAtMs;
      if (msSinceLastCommit >= SLOW_DRAW_TIP_REPLACE_APPEND_MS) {
        return "append";
      }
    }
  }
  return "replace-tip";
}
function shouldReplaceTipWithPoint(points, next, mergeThresholdPage, sampleTimeMs, lastCommittedPointAtMs) {
  return resolvePointMergeAction(points, next, mergeThresholdPage, sampleTimeMs, lastCommittedPointAtMs) === "replace-tip";
}
function applyAppendOrMergePoint(mergeState, next, mergeThresholdPage, sampleTimeMs) {
  const { points } = mergeState;
  if (points.length === 0) {
    points.push(next);
    mergeState.lastCommittedPointAtMs = sampleTimeMs;
    return 0;
  }
  const last7 = points[points.length - 1];
  const distToLast = Math.hypot(next[0] - last7[0], next[1] - last7[1]);
  const mergeAction = resolvePointMergeAction(points, next, mergeThresholdPage, sampleTimeMs, mergeState.lastCommittedPointAtMs);
  if (mergeAction === "replace-tip") {
    points[points.length - 1] = [next[0], next[1], Math.max(last7[2], next[2])];
  } else {
    points.push(next);
    mergeState.lastCommittedPointAtMs = sampleTimeMs;
  }
  return distToLast;
}
function appendOrMergePoint(stroke, next, mergeThresholdPage, sampleTimeMs) {
  const mergeState = {
    points: stroke.points,
    lastCommittedPointAtMs: stroke.lastCommittedPointAtMs
  };
  stroke.strokePathLength += applyAppendOrMergePoint(mergeState, next, mergeThresholdPage, sampleTimeMs);
  stroke.lastCommittedPointAtMs = mergeState.lastCommittedPointAtMs;
}
function setOrAppendLastPoint(stroke, next) {
  const points = stroke.points;
  if (points.length === 0) {
    points.push(next);
    return;
  }
  const last7 = points[points.length - 1];
  const dx = next[0] - last7[0];
  const dy = next[1] - last7[1];
  const dist = Math.hypot(dx, dy);
  points[points.length - 1] = [next[0], next[1], Math.max(last7[2], next[2])];
  stroke.strokePathLength += dist;
}
function updateLiveStrokePath(ctx) {
  if (!activeStroke)
    return;
  const livePath = ctx.getLiveStrokePath();
  if (!livePath)
    return;
  const outlinePoints = R(activeStroke.points, toStrokeOptions(activeStroke.style));
  const pathData = getSvgPathFromStroke(outlinePoints);
  livePath.setAttribute("d", pathData);
  livePath.setAttribute("fill", activeStroke.style.color);
}
var idCounter3, SLOW_DRAW_TIP_REPLACE_APPEND_MS, activeStroke;
var init_draw_tool = __esm({
  "src/ink-canvas/tools/draw-tool.ts"() {
    init_esm2();
    init_svg_path_from_stroke();
    init_pointer_samples();
    init_camera();
    init_commands();
    init_detect_stroke_input_from_pressures();
    init_types();
    init_stroke_presets();
    init_pen_input();
    idCounter3 = 0;
    SLOW_DRAW_TIP_REPLACE_APPEND_MS = 40;
    activeStroke = null;
  }
});

// src/ink-canvas/utils/eraser-hit-samples.ts
function getEraserClientSamplePoints(clientX, clientY, lastClientPoint, cameraZoom) {
  const hitRadius = eraserHitRadiusScreenPx(cameraZoom);
  const sweepSpacing = eraserSweepSpacingScreenPx(cameraZoom);
  const seen = /* @__PURE__ */ new Set();
  const samples = [];
  const add = (x2, y2) => {
    const key = `${x2.toFixed(1)},${y2.toFixed(1)}`;
    if (seen.has(key))
      return;
    seen.add(key);
    samples.push({ x: x2, y: y2 });
  };
  if (lastClientPoint) {
    const dx = clientX - lastClientPoint.x;
    const dy = clientY - lastClientPoint.y;
    const distance = Math.hypot(dx, dy);
    const stepCount = Math.max(1, Math.ceil(distance / sweepSpacing));
    for (let stepIndex = 0; stepIndex <= stepCount; stepIndex++) {
      const t3 = stepIndex / stepCount;
      appendRadiusPatternSamples(add, lastClientPoint.x + dx * t3, lastClientPoint.y + dy * t3, hitRadius);
    }
  } else {
    appendRadiusPatternSamples(add, clientX, clientY, hitRadius);
  }
  return samples;
}
function appendRadiusPatternSamples(add, centerX, centerY, radius) {
  add(centerX, centerY);
  for (let ringIndex = 0; ringIndex < ERASER_RING_SAMPLE_COUNT; ringIndex++) {
    const angle = 2 * Math.PI * ringIndex / ERASER_RING_SAMPLE_COUNT;
    add(centerX + radius * Math.cos(angle), centerY + radius * Math.sin(angle));
  }
}
var init_eraser_hit_samples = __esm({
  "src/ink-canvas/utils/eraser-hit-samples.ts"() {
    init_erase_tool();
    init_stroke_zoom_scale();
  }
});

// src/ink-canvas/utils/stroke-hit-test.ts
function getStrokeIdAtClientPoint(svg, clientX, clientY) {
  const document2 = svg.ownerDocument;
  if (!document2)
    return null;
  const elementsAtPoint = document2.elementsFromPoint?.(clientX, clientY) ?? [];
  for (const element of elementsAtPoint) {
    if (!element.instanceOf(Element))
      continue;
    const strokeElement2 = element.closest("[data-stroke-id]");
    if (!strokeElement2 || !svg.contains(strokeElement2))
      continue;
    const strokeId = strokeElement2.getAttribute("data-stroke-id");
    if (strokeId)
      return strokeId;
  }
  const fallback = document2.elementFromPoint(clientX, clientY);
  if (!fallback)
    return null;
  const strokeElement = fallback.closest("[data-stroke-id]");
  if (!strokeElement || !svg.contains(strokeElement))
    return null;
  return strokeElement.getAttribute("data-stroke-id");
}
var init_stroke_hit_test = __esm({
  "src/ink-canvas/utils/stroke-hit-test.ts"() {
  }
});

// src/ink-canvas/tools/erase-tool.ts
function eraseToolPointerDown(e2, ctx) {
  flushPendingEraseRemoval(ctx);
  erasing = true;
  touchedStrokeIds = /* @__PURE__ */ new Set();
  strokeMarkedAtMs = /* @__PURE__ */ new Map();
  lastEraseClientPoint = null;
  hitTestEraserAtClientPoint(e2.clientX, e2.clientY, null, ctx);
  lastEraseClientPoint = { x: e2.clientX, y: e2.clientY };
}
function eraseToolPointerMove(e2, ctx) {
  if (!erasing)
    return;
  hitTestEraserAtClientPoint(e2.clientX, e2.clientY, lastEraseClientPoint, ctx);
  lastEraseClientPoint = { x: e2.clientX, y: e2.clientY };
}
function eraseToolPointerUp(_e, ctx) {
  if (!erasing)
    return;
  erasing = false;
  lastEraseClientPoint = null;
  const ids = Array.from(touchedStrokeIds);
  touchedStrokeIds = /* @__PURE__ */ new Set();
  if (ids.length > 0) {
    scheduleEraseRemoval(ctx, ids);
  }
  strokeMarkedAtMs = /* @__PURE__ */ new Map();
}
function eraseToolPointerCancel(_e, ctx) {
  clearPendingEraseRemovalTimeout();
  const svg = ctx.getSvgElement();
  if (svg && touchedStrokeIds.size > 0) {
    clearPendingErasePreview(svg, touchedStrokeIds);
  }
  erasing = false;
  lastEraseClientPoint = null;
  touchedStrokeIds = /* @__PURE__ */ new Set();
  strokeMarkedAtMs = /* @__PURE__ */ new Map();
}
function hitTestEraserAtClientPoint(clientX, clientY, lastClientPoint, ctx) {
  const svg = ctx.getSvgElement();
  if (!svg)
    return;
  const cameraZoom = ctx.getCamera().zoom;
  const samplePoints = getEraserClientSamplePoints(clientX, clientY, lastClientPoint, cameraZoom);
  for (const sample of samplePoints) {
    const strokeId = getStrokeIdAtClientPoint(svg, sample.x, sample.y);
    if (!strokeId)
      continue;
    markStrokeForErase(svg, strokeId);
  }
}
function getStrokeGroupElement(svg, strokeId) {
  return svg.querySelector(`[data-stroke-group][data-stroke-id="${CSS.escape(strokeId)}"]`);
}
function markStrokeForErase(svg, strokeId) {
  if (touchedStrokeIds.has(strokeId))
    return;
  const strokeGroup = getStrokeGroupElement(svg, strokeId);
  if (!strokeGroup)
    return;
  touchedStrokeIds.add(strokeId);
  strokeMarkedAtMs.set(strokeId, Date.now());
  strokeGroup.classList.add(INK_STROKE_PENDING_ERASE_CLASS);
}
function clearPendingErasePreview(svg, strokeIds) {
  for (const strokeId of strokeIds) {
    const strokeGroup = getStrokeGroupElement(svg, strokeId);
    strokeGroup?.classList.remove(INK_STROKE_PENDING_ERASE_CLASS);
  }
}
function clearPendingEraseRemovalTimeout() {
  if (pendingEraseRemovalTimeout === null)
    return;
  window.clearTimeout(pendingEraseRemovalTimeout);
  pendingEraseRemovalTimeout = null;
}
function flushPendingEraseRemoval(ctx) {
  clearPendingEraseRemovalTimeout();
  const strokeIds = pendingRemovalStrokeIds;
  pendingRemovalStrokeIds = null;
  if (!strokeIds?.length)
    return;
  const command = new RemoveStrokesCommand(ctx.store, strokeIds);
  ctx.undoManager.execute(command);
  ctx.onErase?.();
}
function scheduleEraseRemoval(ctx, strokeIds) {
  clearPendingEraseRemovalTimeout();
  pendingRemovalStrokeIds = strokeIds;
  const now = Date.now();
  let maxElapsedMs = 0;
  for (const strokeId of strokeIds) {
    const markedAt = strokeMarkedAtMs.get(strokeId) ?? now;
    maxElapsedMs = Math.max(maxElapsedMs, now - markedAt);
  }
  const remainingMs = Math.max(0, INK_STROKE_PENDING_ERASE_ANIMATION_MS - maxElapsedMs);
  pendingEraseRemovalTimeout = window.setTimeout(() => {
    pendingEraseRemovalTimeout = null;
    pendingRemovalStrokeIds = null;
    const command = new RemoveStrokesCommand(ctx.store, strokeIds);
    ctx.undoManager.execute(command);
    ctx.onErase?.();
  }, remainingMs);
}
var erasing, touchedStrokeIds, strokeMarkedAtMs, lastEraseClientPoint, pendingEraseRemovalTimeout, pendingRemovalStrokeIds;
var init_erase_tool2 = __esm({
  "src/ink-canvas/tools/erase-tool.ts"() {
    init_commands();
    init_erase_tool();
    init_eraser_hit_samples();
    init_stroke_hit_test();
    erasing = false;
    touchedStrokeIds = /* @__PURE__ */ new Set();
    strokeMarkedAtMs = /* @__PURE__ */ new Map();
    lastEraseClientPoint = null;
    pendingEraseRemovalTimeout = null;
    pendingRemovalStrokeIds = null;
  }
});

// src/ink-canvas/tools/select-tool.ts
function selectToolPointerDown(e2, ctx) {
  const camera = ctx.getCamera();
  const containerRect = ctx.getContainerRect();
  const pagePoint = screenToPage(camera, containerRect, e2.clientX, e2.clientY);
  const selected = ctx.getSelectedStrokeIds();
  if (selected.size > 0) {
    const hitId = hitTestSingleStroke(e2, ctx);
    if (hitId && selected.has(hitId)) {
      phase = "dragging";
      dragStartPage = pagePoint;
      dragAccumulatedDelta = { x: 0, y: 0 };
      return;
    }
  }
  phase = "lasso";
  lassoPoints = [pagePoint];
  if (!e2.shiftKey) {
    ctx.setSelectedStrokeIds(/* @__PURE__ */ new Set());
    ctx.onSelectionChange?.();
  }
}
function selectToolPointerMove(e2, ctx) {
  if (phase === "lasso") {
    const camera = ctx.getCamera();
    const containerRect = ctx.getContainerRect();
    const pagePoint = screenToPage(camera, containerRect, e2.clientX, e2.clientY);
    lassoPoints.push(pagePoint);
    updateLassoVisual(ctx);
    return;
  }
  if (phase === "dragging") {
    const camera = ctx.getCamera();
    const containerRect = ctx.getContainerRect();
    const pagePoint = screenToPage(camera, containerRect, e2.clientX, e2.clientY);
    if (!dragStartPage)
      return;
    const dx = pagePoint.x - dragStartPage.x;
    const dy = pagePoint.y - dragStartPage.y;
    const delta = {
      x: dx - dragAccumulatedDelta.x,
      y: dy - dragAccumulatedDelta.y
    };
    moveSelectionVisuals(ctx, delta.x, delta.y);
    dragAccumulatedDelta = { x: dx, y: dy };
    return;
  }
}
function selectToolPointerUp(_e, ctx) {
  if (phase === "lasso") {
    finishLasso(_e, ctx);
    phase = "idle";
    return;
  }
  if (phase === "dragging") {
    finishDrag(ctx);
    phase = "idle";
    return;
  }
}
function selectToolPointerCancel(_e, ctx) {
  phase = "idle";
  lassoPoints = [];
  dragStartPage = null;
  clearLassoVisual(ctx);
}
function finishLasso(e2, ctx) {
  if (lassoPoints.length < 3) {
    handleTapSelect(e2, ctx);
    clearLassoVisual(ctx);
    lassoPoints = [];
    return;
  }
  const allStrokes = ctx.store.getAll();
  const selected = new Set(ctx.getSelectedStrokeIds());
  for (const stroke of allStrokes) {
    const isInside = isStrokeInsideLasso(stroke, lassoPoints);
    if (isInside)
      selected.add(stroke.id);
  }
  ctx.setSelectedStrokeIds(selected);
  ctx.onSelectionChange?.();
  clearLassoVisual(ctx);
  lassoPoints = [];
}
function handleTapSelect(e2, ctx) {
  const hitId = hitTestSingleStroke(e2, ctx);
  const next = new Set(ctx.getSelectedStrokeIds());
  if (hitId) {
    if (e2.shiftKey) {
      if (next.has(hitId))
        next.delete(hitId);
      else
        next.add(hitId);
    } else {
      next.clear();
      next.add(hitId);
    }
    ctx.setSelectedStrokeIds(next);
    ctx.onSelectionChange?.();
    return;
  }
  if (!e2.shiftKey) {
    ctx.setSelectedStrokeIds(/* @__PURE__ */ new Set());
    ctx.onSelectionChange?.();
  }
}
function isStrokeInsideLasso(stroke, lasso) {
  if (stroke.points.length === 0)
    return false;
  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
  for (const pt of stroke.points) {
    const px = pt[0] + stroke.offset.x;
    const py = pt[1] + stroke.offset.y;
    if (px < minX)
      minX = px;
    if (py < minY)
      minY = py;
    if (px > maxX)
      maxX = px;
    if (py > maxY)
      maxY = py;
  }
  const cx = (minX + maxX) / 2;
  const cy = (minY + maxY) / 2;
  return isPointInPolygon2(cx, cy, lasso);
}
function isPointInPolygon2(x2, y2, polygon) {
  let inside = false;
  const n2 = polygon.length;
  for (let i2 = 0, j2 = n2 - 1; i2 < n2; j2 = i2++) {
    const xi = polygon[i2].x, yi = polygon[i2].y;
    const xj = polygon[j2].x, yj = polygon[j2].y;
    const intersect = yi > y2 !== yj > y2 && x2 < (xj - xi) * (y2 - yi) / (yj - yi) + xi;
    if (intersect)
      inside = !inside;
  }
  return inside;
}
function updateLassoVisual(ctx) {
  const svg = ctx.getSvgElement();
  if (!svg)
    return;
  let lassoEl = svg.querySelector(".ink-canvas-lasso");
  if (!lassoEl) {
    lassoEl = activeDocument.createElementNS("http://www.w3.org/2000/svg", "polygon");
    lassoEl.classList.add("ink-canvas-lasso");
    lassoEl.setAttribute("fill", "rgba(0, 123, 255, 0.08)");
    lassoEl.setAttribute("stroke", "rgba(0, 123, 255, 0.5)");
    lassoEl.setAttribute("stroke-width", "1");
    lassoEl.setAttribute("stroke-dasharray", "4 2");
    svg.appendChild(lassoEl);
  }
  const camera = ctx.getCamera();
  const pointsStr = lassoPoints.map((p2) => `${(p2.x + camera.x) * camera.zoom},${(p2.y + camera.y) * camera.zoom}`).join(" ");
  lassoEl.setAttribute("points", pointsStr);
}
function clearLassoVisual(ctx) {
  const svg = ctx.getSvgElement();
  if (!svg)
    return;
  const lassoEl = svg.querySelector(".ink-canvas-lasso");
  if (lassoEl)
    lassoEl.remove();
}
function finishDrag(ctx) {
  if (dragAccumulatedDelta.x === 0 && dragAccumulatedDelta.y === 0) {
    dragStartPage = null;
    return;
  }
  const selected = ctx.getSelectedStrokeIds();
  if (selected.size === 0) {
    dragStartPage = null;
    return;
  }
  const ids = Array.from(selected);
  const command = new MoveStrokesCommand(ctx.store, ids, dragAccumulatedDelta.x, dragAccumulatedDelta.y);
  ctx.undoManager.execute(command);
  dragStartPage = null;
  dragAccumulatedDelta = { x: 0, y: 0 };
}
function moveSelectionVisuals(ctx, dx, dy) {
  const svg = ctx.getSvgElement();
  if (!svg)
    return;
  const selected = ctx.getSelectedStrokeIds();
  for (const id of selected) {
    const group = svg.querySelector(`[data-stroke-group][data-stroke-id="${id}"]`);
    if (!group)
      continue;
    const currentX = parseFloat(group.getAttribute("data-offset-x") || "0");
    const currentY = parseFloat(group.getAttribute("data-offset-y") || "0");
    const newX = currentX + dx;
    const newY = currentY + dy;
    group.setAttribute("transform", `translate(${newX}, ${newY})`);
    group.setAttribute("data-offset-x", String(newX));
    group.setAttribute("data-offset-y", String(newY));
  }
}
function hitTestSingleStroke(e2, ctx) {
  const svg = ctx.getSvgElement();
  if (!svg)
    return null;
  return getStrokeIdAtClientPoint(svg, e2.clientX, e2.clientY);
}
var phase, lassoPoints, dragStartPage, dragAccumulatedDelta;
var init_select_tool = __esm({
  "src/ink-canvas/tools/select-tool.ts"() {
    init_camera();
    init_commands();
    init_stroke_hit_test();
    phase = "idle";
    lassoPoints = [];
    dragStartPage = null;
    dragAccumulatedDelta = { x: 0, y: 0 };
  }
});

// src/logic/touch-gesture-policy.ts
function isVerticalDominant(deltaX, deltaY) {
  return Math.abs(deltaY) >= Math.abs(deltaX);
}
function shouldBlockObsidianTouch(params) {
  const {
    mode,
    fingerCount,
    deltaX,
    deltaY,
    axisLocked,
    twoFingerVerticalPanActive = false,
    twoFingerCanvasGestureActive = false
  } = params;
  if (mode === "embedNoteScroll" || mode === "legacy") {
    return false;
  }
  if (mode === "inkCanvasTwoFinger") {
    return fingerCount === 2 && twoFingerCanvasGestureActive;
  }
  if (mode === "dedicatedWritingVertical") {
    if (fingerCount === 2) {
      return twoFingerVerticalPanActive;
    }
    if (axisLocked === "horizontal")
      return false;
    if (axisLocked === "vertical")
      return true;
    const distance = Math.hypot(deltaX, deltaY);
    if (distance < TOUCH_AXIS_LOCK_THRESHOLD_PX)
      return false;
    return isVerticalDominant(deltaX, deltaY);
  }
  return false;
}
function blockObsidianTouchEvent(e2) {
  e2.preventDefault();
  e2.stopPropagation();
  e2.stopImmediatePropagation();
}
function resolveInkTouchGestureMode(options) {
  const { writingMode, isEmbedded, hasDedicatedVerticalTouchPan } = options;
  if (writingMode && isEmbedded)
    return "embedNoteScroll";
  if (writingMode && !isEmbedded && hasDedicatedVerticalTouchPan) {
    return "dedicatedWritingVertical";
  }
  if (!writingMode)
    return "inkCanvasTwoFinger";
  return "embedNoteScroll";
}
var TOUCH_AXIS_LOCK_THRESHOLD_PX;
var init_touch_gesture_policy = __esm({
  "src/logic/touch-gesture-policy.ts"() {
    TOUCH_AXIS_LOCK_THRESHOLD_PX = 4;
  }
});

// src/components/jsx-components/finger-blocker/finger-blocker.scss
var init_18 = __esm({
  "src/components/jsx-components/finger-blocker/finger-blocker.scss"() {
  }
});

// src/components/jsx-components/finger-blocker/finger-blocker.tsx
function setFingerBlockerTouchMode(blockerElement, mode) {
  blockerElement.classList.remove(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS, INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS);
  if (mode === "none")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS);
  else if (mode === "pan-xy")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS);
}
function isDrawingPointer(e2) {
  if (e2.pointerType === "pen")
    return true;
  return e2.pointerType === "mouse" && e2.button === 0;
}
function isInkSvgPenTarget(target) {
  return target instanceof SVGSVGElement && target.classList.contains("ink-svg-canvas");
}
function forwardPointerEvent(target, type, sample, coalescingParent) {
  const meta = coalescingParent ?? sample;
  const isCoalescedSample = coalescingParent !== void 0;
  const pressure = isCoalescedSample ? sample.pressure > 0 ? sample.pressure : coalescingParent.pressure > 0 ? coalescingParent.pressure : 0.5 : sample.pressure;
  const width = isCoalescedSample && sample.width <= 0 ? coalescingParent.width : sample.width;
  const height = isCoalescedSample && sample.height <= 0 ? coalescingParent.height : sample.height;
  target.dispatchEvent(new PointerEvent(type, {
    pointerId: meta.pointerId,
    pointerType: meta.pointerType,
    clientX: sample.clientX,
    clientY: sample.clientY,
    bubbles: true,
    cancelable: true,
    view: window,
    detail: meta.detail,
    screenX: sample.screenX,
    screenY: sample.screenY,
    ctrlKey: meta.ctrlKey,
    shiftKey: meta.shiftKey,
    altKey: meta.altKey,
    metaKey: meta.metaKey,
    button: meta.button,
    buttons: meta.buttons,
    pressure,
    width,
    height
  }));
}
function FingerBlocker({
  getTlEditor,
  wrapperRef,
  enableTwoFingerGestures,
  onVerticalTouchPan,
  forwardPenToCanvas = true,
  forwardFingerToCanvas = false,
  onDrawingEmbedTwoFingerGesture,
  onEmbedTwoFingerGestureEnd,
  onPanGestureEnd,
  touchGestureMode = "legacy",
  onTouchGestureSessionStart
}) {
  const blockerRef = React98.useRef(null);
  const pointerDownRef = React98.useRef(false);
  const recentPenInputRef = React98.useRef(false);
  const isPenDownRef = React98.useRef(false);
  const lockedScrollPosRef = React98.useRef(null);
  const activeScrollerRef = React98.useRef(null);
  const currentTldrawToolIdRef = React98.useRef(null);
  const tldrawToolCleanupMap = React98.useRef(/* @__PURE__ */ new Map());
  const activeTouchPointerDataRef = React98.useRef(/* @__PURE__ */ new Map());
  const twoFingerModeActiveRef = React98.useRef(false);
  const prevTwoFingerMidpointRef = React98.useRef({ x: 0, y: 0 });
  const prevTwoFingerDistanceRef = React98.useRef(0);
  const prevCameraLockedRef = React98.useRef(false);
  const twoFingerVerticalPanActiveRef = React98.useRef(false);
  const prevVerticalPanMidpointRef = React98.useRef({ x: 0, y: 0 });
  const prevSingleFingerVerticalPanClientYByPointerRef = React98.useRef(/* @__PURE__ */ new Map());
  const onVerticalTouchPanRef = React98.useRef(onVerticalTouchPan);
  const onDrawingEmbedTwoFingerGestureRef = React98.useRef(onDrawingEmbedTwoFingerGesture);
  const onEmbedTwoFingerGestureEndRef = React98.useRef(onEmbedTwoFingerGestureEnd);
  const onPanGestureEndRef = React98.useRef(onPanGestureEnd);
  const onTouchGestureSessionStartRef = React98.useRef(onTouchGestureSessionStart);
  React98.useEffect(() => {
    onTouchGestureSessionStartRef.current = onTouchGestureSessionStart;
  }, [onTouchGestureSessionStart]);
  const touchGestureModeRef = React98.useRef(touchGestureMode);
  touchGestureModeRef.current = touchGestureMode;
  const touchGestureSessionActiveRef = React98.useRef(false);
  const dedicatedWritingAxisLockedRef = React98.useRef("none");
  const dedicatedWritingGestureStartClientRef = React98.useRef(/* @__PURE__ */ new Map());
  const verticalPanConsumedRef = React98.useRef(false);
  const embedPanZoomPointerIdsRef = React98.useRef(/* @__PURE__ */ new Set());
  const middleButtonPanPointerIdsRef = React98.useRef(/* @__PURE__ */ new Set());
  const fingerDrawingPointerIdsRef = React98.useRef(/* @__PURE__ */ new Set());
  const forwardFingerToCanvasRef = React98.useRef(forwardFingerToCanvas);
  forwardFingerToCanvasRef.current = forwardFingerToCanvas;
  React98.useEffect(() => {
    onVerticalTouchPanRef.current = onVerticalTouchPan;
  }, [onVerticalTouchPan]);
  React98.useEffect(() => {
    onDrawingEmbedTwoFingerGestureRef.current = onDrawingEmbedTwoFingerGesture;
  }, [onDrawingEmbedTwoFingerGesture]);
  React98.useEffect(() => {
    onEmbedTwoFingerGestureEndRef.current = onEmbedTwoFingerGestureEnd;
  }, [onEmbedTwoFingerGestureEnd]);
  React98.useEffect(() => {
    onPanGestureEndRef.current = onPanGestureEnd;
  }, [onPanGestureEnd]);
  const getWrapper = () => {
    return wrapperRef?.current || blockerRef.current?.parentElement || null;
  };
  const getPenForwardTarget = () => {
    const wrapper = getWrapper();
    if (!wrapper)
      return null;
    return wrapper.querySelector(".ink-svg-canvas") ?? wrapper.querySelector(".tl-canvas");
  };
  const getScroller = () => {
    const wrapper = getWrapper();
    if (!wrapper)
      return null;
    return wrapper.closest(".cm-scroller") ?? wrapper.closest(".ddc_ink_writing-dedicated-scroller");
  };
  const lockScroll = () => {
    const scroller = getScroller();
    if (scroller) {
      activeScrollerRef.current = scroller;
      lockedScrollPosRef.current = { x: scroller.scrollLeft, y: scroller.scrollTop };
      scroller.classList.add(INK_CM_SCROLLER_SCROLL_PINNED_CLASS);
    }
  };
  const clearScrollerPin = (scroller) => {
    scroller.classList.remove(INK_CM_SCROLLER_SCROLL_PINNED_CLASS);
    scroller.style.overflow = "auto";
    window.setTimeout(() => {
      scroller.style.scrollbarColor = "auto";
    }, 200);
  };
  const unlockScroll = () => {
    if (isPenDownRef.current) {
      isPenDownRef.current = false;
      if (activeScrollerRef.current) {
        clearScrollerPin(activeScrollerRef.current);
        activeScrollerRef.current = null;
      }
      lockedScrollPosRef.current = null;
    } else {
      const scroller = getScroller();
      if (scroller) {
        clearScrollerPin(scroller);
      }
    }
  };
  const closeKeyboard = () => {
    const active = activeDocument.activeElement;
    if (active && !active.classList.contains("tl-canvas") && !active.classList.contains("ink-svg-canvas")) {
      active.blur();
    }
  };
  React98.useEffect(() => {
    const element = blockerRef.current;
    if (!element)
      return;
    const isEmbedDrawingInkCanvas = () => !!onDrawingEmbedTwoFingerGestureRef.current;
    const isDedicatedWritingVerticalMode = () => touchGestureModeRef.current === "dedicatedWritingVertical" && !!onVerticalTouchPanRef.current;
    const isInkCanvasTwoFingerMode = () => touchGestureModeRef.current === "inkCanvasTwoFinger" || !!enableTwoFingerGestures && touchGestureModeRef.current === "legacy";
    const resetDedicatedWritingGestureState = () => {
      dedicatedWritingAxisLockedRef.current = "none";
      dedicatedWritingGestureStartClientRef.current.clear();
      verticalPanConsumedRef.current = false;
    };
    const beginTouchGestureSession = () => {
      if (!touchGestureSessionActiveRef.current) {
        onTouchGestureSessionStartRef.current?.();
      }
      touchGestureSessionActiveRef.current = true;
    };
    const updateDedicatedWritingAxisLock = (pointerId, clientX, clientY) => {
      if (dedicatedWritingAxisLockedRef.current !== "none")
        return;
      const start2 = dedicatedWritingGestureStartClientRef.current.get(pointerId);
      if (!start2)
        return;
      const deltaX = clientX - start2.x;
      const deltaY = clientY - start2.y;
      if (Math.hypot(deltaX, deltaY) < TOUCH_AXIS_LOCK_THRESHOLD_PX)
        return;
      dedicatedWritingAxisLockedRef.current = Math.abs(deltaY) >= Math.abs(deltaX) ? "vertical" : "horizontal";
      if (dedicatedWritingAxisLockedRef.current === "vertical") {
        setFingerBlockerTouchMode(element, "none");
      }
    };
    const isRightButtonPanMouseButton = (e2) => e2.pointerType === "mouse" && e2.button === 2;
    const isMiddleButtonPanMouseButton = (e2) => e2.pointerType === "mouse" && e2.button === 1;
    const isFingerDrawingForwardActive = () => forwardFingerToCanvasRef.current && forwardPenToCanvas;
    const cancelActiveFingerDrawingPointers = (penTarget) => {
      if (!penTarget)
        return;
      for (const pointerId of [...fingerDrawingPointerIdsRef.current]) {
        const stored = activeTouchPointerDataRef.current.get(pointerId);
        if (stored) {
          forwardPointerEvent(penTarget, "pointercancel", new PointerEvent("pointercancel", {
            pointerId: stored.pointerId,
            pointerType: "touch",
            clientX: stored.clientX,
            clientY: stored.clientY,
            bubbles: true,
            cancelable: true
          }));
        }
        fingerDrawingPointerIdsRef.current.delete(pointerId);
      }
      if (fingerDrawingPointerIdsRef.current.size === 0) {
        setFingerBlockerTouchMode(element, "default");
        unlockScroll();
      }
    };
    const handlePointerDown = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        if (e2.pointerType === "mouse" && (e2.button === 3 || e2.button === 4))
          return;
        const isDrawingInput = e2.pointerType === "pen" || e2.button === 0;
        if (isDrawingInput) {
          lockScroll();
          isPenDownRef.current = true;
        }
        setFingerBlockerTouchMode(element, "none");
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        try {
          target.setPointerCapture(e2.pointerId);
        } catch {
        }
        const penTarget = getPenForwardTarget();
        if (penTarget && forwardPenToCanvas && isDrawingInput) {
          forwardPointerEvent(penTarget, "pointerdown", e2);
        }
        if (penTarget && isInkSvgPenTarget(penTarget) && isRightButtonPanMouseButton(e2)) {
          embedPanZoomPointerIdsRef.current.add(e2.pointerId);
          forwardPointerEvent(penTarget, "pointerdown", e2);
        }
        if (penTarget && isInkSvgPenTarget(penTarget) && isMiddleButtonPanMouseButton(e2)) {
          middleButtonPanPointerIdsRef.current.add(e2.pointerId);
          forwardPointerEvent(penTarget, "pointerdown", e2);
        }
        if (isDrawingInput) {
          recentPenInputRef.current = true;
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          pointerId: e2.pointerId,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY,
          width: e2.width,
          height: e2.height,
          pressure: e2.pressure
        });
        const touchCount = activeTouchPointerDataRef.current.size;
        const penTarget = getPenForwardTarget();
        if (isFingerDrawingForwardActive() && touchCount >= 2 && fingerDrawingPointerIdsRef.current.size > 0) {
          cancelActiveFingerDrawingPointers(penTarget);
        }
        if (isFingerDrawingForwardActive() && touchCount === 1 && !twoFingerModeActiveRef.current && !twoFingerVerticalPanActiveRef.current) {
          lockScroll();
          isPenDownRef.current = true;
          setFingerBlockerTouchMode(element, "none");
          e2.preventDefault();
          e2.stopPropagation();
          e2.stopImmediatePropagation();
          const target = e2.target;
          try {
            target.setPointerCapture(e2.pointerId);
          } catch {
          }
          fingerDrawingPointerIdsRef.current.add(e2.pointerId);
          if (penTarget) {
            forwardPointerEvent(penTarget, "pointerdown", e2);
          }
          return;
        }
        const verticalTouchPan = onVerticalTouchPanRef.current;
        const dedicatedWritingVertical = isDedicatedWritingVerticalMode();
        if (dedicatedWritingVertical) {
          beginTouchGestureSession();
          resetDedicatedWritingGestureState();
          if (touchCount >= 2 && !twoFingerVerticalPanActiveRef.current) {
            blockObsidianTouchEvent(e2);
            setFingerBlockerTouchMode(element, "none");
            twoFingerVerticalPanActiveRef.current = true;
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            prevVerticalPanMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2,
              y: (pa.clientY + pb.clientY) / 2
            };
          } else if (touchCount === 1) {
            setFingerBlockerTouchMode(element, "pan-xy");
            dedicatedWritingGestureStartClientRef.current.set(e2.pointerId, {
              x: e2.clientX,
              y: e2.clientY
            });
            prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
          }
        } else if (verticalTouchPan) {
          beginTouchGestureSession();
          blockObsidianTouchEvent(e2);
          setFingerBlockerTouchMode(element, "none");
          if (touchCount >= 2 && !twoFingerVerticalPanActiveRef.current) {
            twoFingerVerticalPanActiveRef.current = true;
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            prevVerticalPanMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2,
              y: (pa.clientY + pb.clientY) / 2
            };
          } else if (touchCount === 1) {
            prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
          }
        } else if (touchCount >= 2 && isInkCanvasTwoFingerMode() && !twoFingerModeActiveRef.current) {
          beginTouchGestureSession();
          blockObsidianTouchEvent(e2);
          setFingerBlockerTouchMode(element, "none");
          twoFingerModeActiveRef.current = true;
          const inkTwoFinger = onDrawingEmbedTwoFingerGestureRef.current;
          const editorForLock = getTlEditor?.();
          if (inkTwoFinger) {
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            prevTwoFingerMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2,
              y: (pa.clientY + pb.clientY) / 2
            };
            prevTwoFingerDistanceRef.current = Math.hypot(pb.clientX - pa.clientX, pb.clientY - pa.clientY);
          } else if (editorForLock) {
            prevCameraLockedRef.current = editorForLock.getCameraOptions().isLocked;
            editorForLock.setCameraOptions({ isLocked: false });
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            const containerRect = editorForLock.getContainer().getBoundingClientRect();
            prevTwoFingerMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2 - containerRect.left,
              y: (pa.clientY + pb.clientY) / 2 - containerRect.top
            };
            prevTwoFingerDistanceRef.current = Math.hypot(pb.clientX - pa.clientX, pb.clientY - pa.clientY);
          }
        } else if (!twoFingerModeActiveRef.current) {
          setFingerBlockerTouchMode(element, "pan-xy");
        }
      }
    };
    const endInkPenSession = (e2) => {
      if (fingerDrawingPointerIdsRef.current.has(e2.pointerId)) {
        fingerDrawingPointerIdsRef.current.delete(e2.pointerId);
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (fingerDrawingPointerIdsRef.current.size === 0) {
          setFingerBlockerTouchMode(element, "default");
          unlockScroll();
        }
        return;
      }
      if (!isDrawingPointer(e2))
        return;
      setFingerBlockerTouchMode(element, "default");
      unlockScroll();
    };
    const handlePointerMove = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (isPenDownRef.current && activeScrollerRef.current && lockedScrollPosRef.current) {
          const scroller = activeScrollerRef.current;
          if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
            scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
          }
        }
        const penTarget = getPenForwardTarget();
        if (penTarget && middleButtonPanPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointermove", e2);
        } else if (penTarget && embedPanZoomPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointermove", e2);
        } else if (penTarget && forwardPenToCanvas && isDrawingPointer(e2)) {
          const moveSamples = getPointerSamples(e2);
          for (const sample of moveSamples) {
            if (sample === e2) {
              forwardPointerEvent(penTarget, "pointermove", sample);
            } else {
              forwardPointerEvent(penTarget, "pointermove", sample, e2);
            }
          }
        }
      } else if (e2.pointerType === "touch" && fingerDrawingPointerIdsRef.current.has(e2.pointerId)) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (existing) {
          activeTouchPointerDataRef.current.set(e2.pointerId, {
            ...existing,
            clientX: e2.clientX,
            clientY: e2.clientY,
            screenX: e2.screenX,
            screenY: e2.screenY
          });
        }
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (isPenDownRef.current && activeScrollerRef.current && lockedScrollPosRef.current) {
          const scroller = activeScrollerRef.current;
          if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
            scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
          }
        }
        const penTarget = getPenForwardTarget();
        if (penTarget) {
          const moveSamples = getPointerSamples(e2);
          for (const sample of moveSamples) {
            if (sample === e2) {
              forwardPointerEvent(penTarget, "pointermove", sample);
            } else {
              forwardPointerEvent(penTarget, "pointermove", sample, e2);
            }
          }
        }
      } else if (e2.pointerType === "touch" && twoFingerVerticalPanActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const currentMidpoint = {
          x: (p0.clientX + p1.clientX) / 2,
          y: (p0.clientY + p1.clientY) / 2
        };
        const prevMidpoint = prevVerticalPanMidpointRef.current;
        const deltaX = currentMidpoint.x - prevMidpoint.x;
        const deltaY = currentMidpoint.y - prevMidpoint.y;
        blockObsidianTouchEvent(e2);
        if (Math.abs(deltaY) >= Math.abs(deltaX)) {
          verticalPanConsumedRef.current = true;
          onVerticalTouchPanRef.current?.(-deltaY);
        }
        prevVerticalPanMidpointRef.current = currentMidpoint;
      } else if (e2.pointerType === "touch" && onVerticalTouchPanRef.current && !twoFingerVerticalPanActiveRef.current) {
        recentPenInputRef.current = false;
        if (isDedicatedWritingVerticalMode()) {
          updateDedicatedWritingAxisLock(e2.pointerId, e2.clientX, e2.clientY);
          const axisLocked = dedicatedWritingAxisLockedRef.current;
          const start2 = dedicatedWritingGestureStartClientRef.current.get(e2.pointerId);
          const deltaX = start2 ? e2.clientX - start2.x : 0;
          const deltaY = start2 ? e2.clientY - start2.y : 0;
          const shouldBlock = shouldBlockObsidianTouch({
            mode: "dedicatedWritingVertical",
            fingerCount: 1,
            deltaX,
            deltaY,
            axisLocked
          });
          if (!shouldBlock)
            return;
          blockObsidianTouchEvent(e2);
          const prevClientY2 = prevSingleFingerVerticalPanClientYByPointerRef.current.get(e2.pointerId);
          if (prevClientY2 === void 0) {
            prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
          } else {
            const frameDeltaY = e2.clientY - prevClientY2;
            prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
            if (frameDeltaY !== 0) {
              verticalPanConsumedRef.current = true;
              onVerticalTouchPanRef.current(-frameDeltaY);
            }
          }
          return;
        }
        blockObsidianTouchEvent(e2);
        const prevClientY = prevSingleFingerVerticalPanClientYByPointerRef.current.get(e2.pointerId);
        if (prevClientY === void 0) {
          prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
        } else {
          const deltaY = e2.clientY - prevClientY;
          prevSingleFingerVerticalPanClientYByPointerRef.current.set(e2.pointerId, e2.clientY);
          if (deltaY !== 0) {
            onVerticalTouchPanRef.current(-deltaY);
          }
        }
      } else if (e2.pointerType === "touch" && recentPenInputRef.current) {
        const scroller = getScroller();
        if (scroller) {
          scroller.scrollTo({
            top: scroller.scrollTop - e2.movementY,
            left: scroller.scrollLeft - e2.movementX
          });
        }
      } else if (e2.pointerType === "touch" && twoFingerModeActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        blockObsidianTouchEvent(e2);
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const inkTwoFinger = onDrawingEmbedTwoFingerGestureRef.current;
        const curDist = Math.hypot(p1.clientX - p0.clientX, p1.clientY - p0.clientY);
        const pm = prevTwoFingerMidpointRef.current;
        const prevDist = prevTwoFingerDistanceRef.current;
        const ratio = prevDist > 0 ? curDist / prevDist : 1;
        if (inkTwoFinger) {
          const wrapper = getWrapper();
          const containerRect = wrapper?.getBoundingClientRect() ?? new DOMRect();
          const newMidClient = {
            x: (p0.clientX + p1.clientX) / 2,
            y: (p0.clientY + p1.clientY) / 2
          };
          inkTwoFinger({
            deltaX: newMidClient.x - pm.x,
            deltaY: newMidClient.y - pm.y,
            anchorX: newMidClient.x - containerRect.left,
            anchorY: newMidClient.y - containerRect.top,
            distanceRatio: ratio
          });
          prevTwoFingerMidpointRef.current = newMidClient;
          prevTwoFingerDistanceRef.current = curDist;
        } else {
          const editor = getTlEditor?.();
          if (!editor)
            return;
          const containerRect = editor.getContainer().getBoundingClientRect();
          const cm = {
            x: (p0.clientX + p1.clientX) / 2 - containerRect.left,
            y: (p0.clientY + p1.clientY) / 2 - containerRect.top
          };
          const factor = ratio;
          const { x: cx, y: cy, z: cz } = editor.getCamera();
          const { zoomSteps } = editor.getCameraOptions();
          const newZ = Math.max(zoomSteps[0], Math.min(zoomSteps[zoomSteps.length - 1], cz * factor));
          const newCx = cx + cm.x / newZ - pm.x / cz;
          const newCy = cy + cm.y / newZ - pm.y / cz;
          editor.setCamera({ x: newCx, y: newCy, z: newZ }, { animation: { duration: 0 } });
          prevTwoFingerMidpointRef.current = cm;
          prevTwoFingerDistanceRef.current = curDist;
        }
      }
    };
    const handlePointerUp = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        const penTarget = getPenForwardTarget();
        if (penTarget && forwardPenToCanvas && isDrawingPointer(e2)) {
          forwardPointerEvent(penTarget, "pointerup", e2);
        }
        if (penTarget && embedPanZoomPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointerup", e2);
          embedPanZoomPointerIdsRef.current.delete(e2.pointerId);
        }
        if (penTarget && middleButtonPanPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointerup", e2);
          middleButtonPanPointerIdsRef.current.delete(e2.pointerId);
        }
        setFingerBlockerTouchMode(element, "default");
        unlockScroll();
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch" && fingerDrawingPointerIdsRef.current.has(e2.pointerId)) {
        const penTarget = getPenForwardTarget();
        if (penTarget) {
          forwardPointerEvent(penTarget, "pointerup", e2);
        }
        fingerDrawingPointerIdsRef.current.delete(e2.pointerId);
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (activeTouchPointerDataRef.current.size === 0) {
          recentPenInputRef.current = false;
        }
        if (fingerDrawingPointerIdsRef.current.size === 0) {
          setFingerBlockerTouchMode(element, "default");
          unlockScroll();
        }
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (activeTouchPointerDataRef.current.size === 0) {
          recentPenInputRef.current = false;
        }
        if (onVerticalTouchPanRef.current) {
          prevSingleFingerVerticalPanClientYByPointerRef.current.delete(e2.pointerId);
          dedicatedWritingGestureStartClientRef.current.delete(e2.pointerId);
          if (twoFingerVerticalPanActiveRef.current && activeTouchPointerDataRef.current.size < 2) {
            twoFingerVerticalPanActiveRef.current = false;
            dedicatedWritingAxisLockedRef.current = "none";
            for (const touch of activeTouchPointerDataRef.current.values()) {
              prevSingleFingerVerticalPanClientYByPointerRef.current.set(touch.pointerId, touch.clientY);
              dedicatedWritingGestureStartClientRef.current.set(touch.pointerId, {
                x: touch.clientX,
                y: touch.clientY
              });
            }
          }
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode(element, "default");
          } else if (!isDedicatedWritingVerticalMode() || twoFingerVerticalPanActiveRef.current) {
            setFingerBlockerTouchMode(element, "none");
          }
        }
      }
    };
    const handlePointerCancel = (e2) => {
      if (e2.pointerType === "touch" && fingerDrawingPointerIdsRef.current.has(e2.pointerId)) {
        const penTarget = getPenForwardTarget();
        if (penTarget) {
          forwardPointerEvent(penTarget, "pointercancel", e2);
        }
        fingerDrawingPointerIdsRef.current.delete(e2.pointerId);
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (fingerDrawingPointerIdsRef.current.size === 0) {
          setFingerBlockerTouchMode(element, "default");
          unlockScroll();
        }
        return;
      }
      setFingerBlockerTouchMode(element, "default");
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        const penTarget = getPenForwardTarget();
        if (penTarget && forwardPenToCanvas && isDrawingPointer(e2)) {
          forwardPointerEvent(penTarget, "pointercancel", e2);
        }
        if (penTarget && embedPanZoomPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointercancel", e2);
          embedPanZoomPointerIdsRef.current.delete(e2.pointerId);
        }
        if (penTarget && middleButtonPanPointerIdsRef.current.has(e2.pointerId)) {
          forwardPointerEvent(penTarget, "pointercancel", e2);
          middleButtonPanPointerIdsRef.current.delete(e2.pointerId);
        }
        unlockScroll();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (onVerticalTouchPanRef.current) {
          prevSingleFingerVerticalPanClientYByPointerRef.current.delete(e2.pointerId);
          dedicatedWritingGestureStartClientRef.current.delete(e2.pointerId);
          twoFingerVerticalPanActiveRef.current = false;
          resetDedicatedWritingGestureState();
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode(element, "default");
            touchGestureSessionActiveRef.current = false;
          }
        }
      }
    };
    const handleWheel = (e2) => {
      if (isPenDownRef.current) {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        return;
      }
      if (isEmbedDrawingInkCanvas() && (e2.ctrlKey || e2.metaKey)) {
        const penTarget = getPenForwardTarget();
        if (penTarget) {
          penTarget.dispatchEvent(new WheelEvent("wheel", {
            deltaX: e2.deltaX,
            deltaY: e2.deltaY,
            deltaZ: e2.deltaZ,
            deltaMode: e2.deltaMode,
            clientX: e2.clientX,
            clientY: e2.clientY,
            screenX: e2.screenX,
            screenY: e2.screenY,
            ctrlKey: e2.ctrlKey,
            metaKey: e2.metaKey,
            shiftKey: e2.shiftKey,
            altKey: e2.altKey,
            bubbles: true,
            cancelable: true
          }));
          e2.preventDefault();
        }
      }
    };
    const suppressEmbedContextMenu = (e2) => {
      e2.preventDefault();
      e2.stopPropagation();
    };
    const handleTouchMove = (e2) => {
      if (isPenDownRef.current || twoFingerModeActiveRef.current || fingerDrawingPointerIdsRef.current.size > 0) {
        blockObsidianTouchEvent(e2);
        return;
      }
      if (!touchGestureSessionActiveRef.current)
        return;
      const mode = touchGestureModeRef.current;
      if (mode === "embedNoteScroll")
        return;
      if (mode === "inkCanvasTwoFinger" && twoFingerModeActiveRef.current) {
        blockObsidianTouchEvent(e2);
        return;
      }
      if (isDedicatedWritingVerticalMode() || mode === "legacy" && onVerticalTouchPanRef.current) {
        if (twoFingerVerticalPanActiveRef.current) {
          blockObsidianTouchEvent(e2);
          return;
        }
        if (mode === "legacy" && onVerticalTouchPanRef.current) {
          blockObsidianTouchEvent(e2);
          return;
        }
        if (isDedicatedWritingVerticalMode()) {
          const axisLocked = dedicatedWritingAxisLockedRef.current;
          if (axisLocked === "vertical") {
            blockObsidianTouchEvent(e2);
          }
        }
      }
    };
    const handleLostPointerCapture = () => {
      if (!isPenDownRef.current)
        return;
      unlockScroll();
    };
    const handleTouchEnd = (e2) => {
      Array.from(e2.changedTouches).forEach((touch) => {
        activeTouchPointerDataRef.current.delete(touch.identifier);
      });
      if (onVerticalTouchPanRef.current) {
        if (twoFingerVerticalPanActiveRef.current && e2.touches.length < 2) {
          twoFingerVerticalPanActiveRef.current = false;
          dedicatedWritingAxisLockedRef.current = "none";
        }
        if (e2.touches.length === 0) {
          setFingerBlockerTouchMode(element, "default");
          activeTouchPointerDataRef.current.clear();
          touchGestureSessionActiveRef.current = false;
          const shouldReleaseMomentum = isDedicatedWritingVerticalMode() ? verticalPanConsumedRef.current : true;
          if (shouldReleaseMomentum) {
            onPanGestureEndRef.current?.();
          }
          resetDedicatedWritingGestureState();
        }
        return;
      }
      if (!isInkCanvasTwoFingerMode())
        return;
      if (twoFingerModeActiveRef.current && e2.touches.length < 2) {
        if (!onDrawingEmbedTwoFingerGestureRef.current) {
          getTlEditor?.()?.setCameraOptions({ isLocked: prevCameraLockedRef.current });
        }
        twoFingerModeActiveRef.current = false;
        if (onDrawingEmbedTwoFingerGestureRef.current) {
          onEmbedTwoFingerGestureEndRef.current?.();
        }
      }
      if (e2.touches.length === 0) {
        setFingerBlockerTouchMode(element, "default");
        activeTouchPointerDataRef.current.clear();
        touchGestureSessionActiveRef.current = false;
        recentPenInputRef.current = false;
      }
    };
    element.addEventListener("pointerdown", handlePointerDown, { passive: false, capture: true });
    element.addEventListener("pointermove", handlePointerMove, { passive: false, capture: true });
    element.addEventListener("pointerup", handlePointerUp, { passive: false, capture: true });
    element.addEventListener("pointercancel", handlePointerCancel, { passive: false, capture: true });
    element.addEventListener("lostpointercapture", handleLostPointerCapture);
    element.addEventListener("wheel", handleWheel, { passive: false, capture: true });
    element.addEventListener("contextmenu", suppressEmbedContextMenu, { capture: true });
    element.addEventListener("touchmove", handleTouchMove, { passive: false, capture: true });
    element.addEventListener("touchend", handleTouchEnd, { passive: true, capture: true });
    element.addEventListener("touchcancel", handleTouchEnd, { passive: true, capture: true });
    const inkSvg = getPenForwardTarget();
    const inkPenEndOpts = { capture: true };
    if (isInkSvgPenTarget(inkSvg)) {
      inkSvg.addEventListener("pointerup", endInkPenSession, inkPenEndOpts);
      inkSvg.addEventListener("pointercancel", endInkPenSession, inkPenEndOpts);
    }
    return () => {
      isPenDownRef.current = false;
      embedPanZoomPointerIdsRef.current.clear();
      middleButtonPanPointerIdsRef.current.clear();
      fingerDrawingPointerIdsRef.current.clear();
      touchGestureSessionActiveRef.current = false;
      resetDedicatedWritingGestureState();
      unlockScroll();
      element.removeEventListener("pointerdown", handlePointerDown, { capture: true });
      element.removeEventListener("pointermove", handlePointerMove, { capture: true });
      element.removeEventListener("pointerup", handlePointerUp, { capture: true });
      element.removeEventListener("pointercancel", handlePointerCancel, { capture: true });
      element.removeEventListener("lostpointercapture", handleLostPointerCapture);
      element.removeEventListener("wheel", handleWheel, { capture: true });
      element.removeEventListener("contextmenu", suppressEmbedContextMenu, { capture: true });
      element.removeEventListener("touchmove", handleTouchMove, { capture: true });
      element.removeEventListener("touchend", handleTouchEnd, { capture: true });
      element.removeEventListener("touchcancel", handleTouchEnd, { capture: true });
      if (isInkSvgPenTarget(inkSvg)) {
        inkSvg.removeEventListener("pointerup", endInkPenSession, inkPenEndOpts);
        inkSvg.removeEventListener("pointercancel", endInkPenSession, inkPenEndOpts);
      }
    };
  }, [forwardPenToCanvas, forwardFingerToCanvas, enableTwoFingerGestures, onVerticalTouchPan, touchGestureMode]);
  React98.useEffect(() => {
    const scroller = getScroller();
    if (!scroller)
      return;
    const handleScroll2 = (e2) => {
      if (isPenDownRef.current && lockedScrollPosRef.current) {
        if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
          scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
        }
      }
    };
    scroller.addEventListener("scroll", handleScroll2, { passive: false, capture: true });
    return () => {
      scroller.removeEventListener("scroll", handleScroll2, { capture: true });
    };
  }, [getTlEditor]);
  const hasToolChanged = (entry) => {
    if (!entry.changes?.updated)
      return false;
    for (const [from, to] of Object.values(entry.changes.updated)) {
      if (typeof from === "object" && from !== null && typeof to === "object" && to !== null && "typeName" in from && "typeName" in to && from.typeName === "instance" && to.typeName === "instance") {
        return true;
      }
    }
    return false;
  };
  const wrapToolWithScrollHandlers = (tool) => {
    const prevDown = tool.onPointerDown;
    const prevUp = tool.onPointerUp;
    const prevMove = tool.onPointerMove;
    tool.onPointerDown = (e2) => {
      pointerDownRef.current = true;
      lockScroll();
      prevDown?.(e2);
    };
    tool.onPointerUp = (e2) => {
      pointerDownRef.current = false;
      unlockScroll();
      prevUp?.(e2);
    };
    tool.onPointerMove = (e2) => {
      prevMove?.(e2);
    };
    return () => {
      if (tool) {
        tool.onPointerDown = prevDown;
        tool.onPointerUp = prevUp;
        tool.onPointerMove = prevMove;
      }
    };
  };
  const listenForToolChangesAndUpdateHandlers = (resolveTlEditor) => {
    const editor = resolveTlEditor();
    if (!editor)
      return () => {
      };
    const handleToolChange = () => {
      const editor2 = resolveTlEditor();
      if (!editor2)
        return;
      const newToolId = editor2.getCurrentToolId();
      const previousToolId = currentTldrawToolIdRef.current;
      if (newToolId === previousToolId)
        return;
      if (previousToolId && tldrawToolCleanupMap.current.has(previousToolId)) {
        const cleanup = tldrawToolCleanupMap.current.get(previousToolId);
        if (cleanup) {
          cleanup();
          tldrawToolCleanupMap.current.delete(previousToolId);
        }
      }
      if (newToolId) {
        const tool = editor2.getCurrentTool();
        if (tool) {
          if (!tldrawToolCleanupMap.current.has(newToolId)) {
            const toolCleanupFn = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(newToolId, toolCleanupFn);
            currentTldrawToolIdRef.current = newToolId;
          }
        }
      }
    };
    return editor.store.listen((entry) => {
      if (hasToolChanged(entry)) {
        handleToolChange();
      }
    }, {
      source: "all",
      scope: "all"
    });
  };
  const listenForEditorToBecomeAvailable = (getTlEditor2, onEditorReady) => {
    let pollInterval = null;
    let setupComplete = false;
    let retryCount = 0;
    pollInterval = window.setInterval(() => {
      if (setupComplete)
        return;
      const editor = getTlEditor2();
      if (editor) {
        setupComplete = true;
        onEditorReady(editor);
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
      retryCount++;
      if (retryCount >= MAX_POLL_RETRIES) {
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
    }, POLL_INTERVAL_MS);
    return () => {
      if (pollInterval) {
        window.clearInterval(pollInterval);
      }
    };
  };
  React98.useEffect(() => {
    if (!getTlEditor)
      return;
    const resolveTlEditor = getTlEditor;
    let storeListenerCleanup = null;
    const stopPolling = listenForEditorToBecomeAvailable(resolveTlEditor, () => {
      const editor = resolveTlEditor();
      if (!editor)
        return;
      const initialToolId = editor.getCurrentToolId();
      if (initialToolId) {
        const tool = editor.getCurrentTool();
        if (tool) {
          const editorToolId = editor.getCurrentToolId();
          if (editorToolId === initialToolId && !tldrawToolCleanupMap.current.has(initialToolId)) {
            const cleanup = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(initialToolId, cleanup);
            currentTldrawToolIdRef.current = initialToolId;
          }
        }
      }
      storeListenerCleanup = listenForToolChangesAndUpdateHandlers(resolveTlEditor);
    });
    return () => {
      stopPolling();
      if (storeListenerCleanup) {
        storeListenerCleanup();
      }
      tldrawToolCleanupMap.current.forEach((cleanup) => {
        cleanup();
      });
      tldrawToolCleanupMap.current.clear();
    };
  }, [getTlEditor]);
  return /* @__PURE__ */ React98.createElement("div", {
    ref: blockerRef,
    style: {
      position: "absolute",
      inset: 0,
      zIndex: 1e3,
      userSelect: "none",
      WebkitUserSelect: "none",
      MozUserSelect: "none",
      msUserSelect: "none"
    },
    onPointerEnter: (e2) => {
      closeKeyboard();
    }
  });
}
var React98, INK_CM_SCROLLER_SCROLL_PINNED_CLASS, INK_FINGER_BLOCKER_TOUCH_NONE_CLASS, INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS, POLL_INTERVAL_MS, MAX_POLL_RETRIES;
var init_finger_blocker = __esm({
  "src/components/jsx-components/finger-blocker/finger-blocker.tsx"() {
    React98 = __toESM(require_react());
    init_pointer_samples();
    init_touch_gesture_policy();
    init_18();
    INK_CM_SCROLLER_SCROLL_PINNED_CLASS = "ink-cm-scroller--scroll-pinned";
    INK_FINGER_BLOCKER_TOUCH_NONE_CLASS = "ink-finger-blocker--touch-none";
    INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS = "ink-finger-blocker--touch-pan-xy";
    POLL_INTERVAL_MS = 100;
    MAX_POLL_RETRIES = 200;
  }
});

// src/logic/device-settings/use-stroke-input-treat-as.ts
function useStrokeInputTreatAs(editorKind) {
  const [value, setValue] = (0, import_react129.useState)(() => getStrokeInputTreatAs(editorKind));
  (0, import_react129.useEffect)(() => {
    setValue(getStrokeInputTreatAs(editorKind));
    return subscribeDeviceSettingsChanged(() => {
      setValue(getStrokeInputTreatAs(editorKind));
    });
  }, [editorKind]);
  return value;
}
var import_react129;
var init_use_stroke_input_treat_as = __esm({
  "src/logic/device-settings/use-stroke-input-treat-as.ts"() {
    import_react129 = __toESM(require_react());
    init_device_settings();
  }
});

// src/logic/device-settings/use-resolved-stroke-input-treat-as.ts
function useResolvedStrokeInputTreatAs(editorKind) {
  const [value, setValue] = (0, import_react130.useState)(() => resolveStrokeInputTreatAs(getStrokeInputTreatAs(editorKind), getLastDetectedStrokeInput()));
  (0, import_react130.useEffect)(() => {
    const refresh = () => {
      setValue(resolveStrokeInputTreatAs(getStrokeInputTreatAs(editorKind), getLastDetectedStrokeInput()));
    };
    refresh();
    return subscribeDeviceSettingsChanged(refresh);
  }, [editorKind]);
  return value;
}
var import_react130;
var init_use_resolved_stroke_input_treat_as = __esm({
  "src/logic/device-settings/use-resolved-stroke-input-treat-as.ts"() {
    import_react130 = __toESM(require_react());
    init_device_settings();
  }
});

// src/ink-canvas/ink-adaptive-grid.tsx
function modulate5(value, rangeA, rangeB) {
  const [fromLow, fromHigh] = rangeA;
  const [toLow, toHigh] = rangeB;
  return toLow + (value - fromLow) / (fromHigh - fromLow) * (toHigh - toLow);
}
function clamp01(value) {
  return Math.max(0, Math.min(1, value));
}
function computeLayerOpacity(tierIndex, z, min4, mid, zoomFadeScale = 1) {
  const peak = INK_GRID_TIER_PEAK_OPACITY[tierIndex] ?? 1;
  const fadeMin = min4 * zoomFadeScale;
  const fadeMid = mid * zoomFadeScale;
  if (tierIndex <= 1) {
    if (z < fadeMin) {
      return clamp01(modulate5(z, [Math.min(fadeMin, -1), fadeMin], [0, peak]));
    }
    return peak;
  }
  if (z < fadeMid) {
    return clamp01(modulate5(z, [fadeMin, fadeMid], [0, peak]));
  }
  return peak;
}
function InkAdaptiveGrid(props) {
  const { x: x2, y: y2, z, gridSize = INK_GRID_SIZE, className, zoomFadeScale = 1 } = props;
  const reactId = (0, import_react131.useId)();
  const patternIdPrefix = `ink_grid_${reactId.replace(/:/g, "")}`;
  return /* @__PURE__ */ import_react131.default.createElement("g", {
    className: className ?? "ink-adaptive-grid",
    pointerEvents: "none"
  }, /* @__PURE__ */ import_react131.default.createElement("defs", null, INK_GRID_STEPS.map(({ min: min4, mid, step }, tierIndex) => {
    const cellSize = step * gridSize * z;
    const xOffset = 0.5 + x2 * z;
    const yOffset = 0.5 + y2 * z;
    const gridXOrigin = xOffset > 0 ? xOffset % cellSize : cellSize + xOffset % cellSize;
    const gridYOrigin = yOffset > 0 ? yOffset % cellSize : cellSize + yOffset % cellSize;
    const opacity = computeLayerOpacity(tierIndex, z, min4, mid, zoomFadeScale);
    const dotRadius = INK_GRID_TIER_DOT_RADIUS[tierIndex] ?? 1;
    return /* @__PURE__ */ import_react131.default.createElement("pattern", {
      key: tierIndex,
      id: `${patternIdPrefix}_${step}`,
      width: cellSize,
      height: cellSize,
      patternUnits: "userSpaceOnUse"
    }, /* @__PURE__ */ import_react131.default.createElement("circle", {
      className: "ink-grid-dot",
      "data-ink-grid-tier": tierIndex,
      cx: gridXOrigin,
      cy: gridYOrigin,
      r: dotRadius,
      opacity
    }));
  })), INK_GRID_STEPS.map(({ step }, tierIndex) => /* @__PURE__ */ import_react131.default.createElement("rect", {
    key: tierIndex,
    x: "0",
    y: "0",
    width: "100%",
    height: "100%",
    fill: `url(#${patternIdPrefix}_${step})`
  })));
}
var import_react131, INK_GRID_SIZE, INK_GRID_STEPS, INK_GRID_TIER_PEAK_OPACITY, INK_GRID_TIER_DOT_RADIUS, INK_GRID_BOOX_ZOOM_FADE_SCALE;
var init_ink_adaptive_grid = __esm({
  "src/ink-canvas/ink-adaptive-grid.tsx"() {
    import_react131 = __toESM(require_react());
    INK_GRID_SIZE = 10;
    INK_GRID_STEPS = [
      { min: -1, mid: 0.15, step: 64 },
      { min: 0.05, mid: 0.375, step: 16 },
      { min: 0.15, mid: 1, step: 4 },
      { min: 0.7, mid: 2.5, step: 1 }
    ];
    INK_GRID_TIER_PEAK_OPACITY = [1, 0.6, 0.35, 0.25];
    INK_GRID_TIER_DOT_RADIUS = [1, 1, 1.25, 1.5];
    INK_GRID_BOOX_ZOOM_FADE_SCALE = 0.5;
  }
});

// src/ink-canvas/ink-svg-canvas.tsx
function isModKeyKeyboardEvent(e2) {
  return e2.key === "Control" || e2.key === "Meta";
}
function createPointerEventFromLastCanvasPointer(last7) {
  return new PointerEvent("pointerdown", {
    pointerId: last7.pointerId,
    pointerType: last7.pointerType,
    clientX: last7.clientX,
    clientY: last7.clientY,
    buttons: last7.buttons,
    bubbles: true,
    cancelable: true,
    view: window
  });
}
function InkSvgCanvas(props) {
  const writingMode = props.writingMode ?? false;
  const strokeInputEditorKind = writingMode ? "inkWriting" : "inkDrawing";
  const strokeInputTreatAsPreference = useStrokeInputTreatAs(strokeInputEditorKind);
  const strokeInputTreatAsPreferenceRef = (0, import_react132.useRef)(strokeInputTreatAsPreference);
  strokeInputTreatAsPreferenceRef.current = strokeInputTreatAsPreference;
  const resolvedStrokeInputTreatAs = useResolvedStrokeInputTreatAs(strokeInputEditorKind);
  const resolvedStrokeInputTreatAsRef = (0, import_react132.useRef)(resolvedStrokeInputTreatAs);
  resolvedStrokeInputTreatAsRef.current = resolvedStrokeInputTreatAs;
  const isBooxConnectionEnabled = useBooxConnectionEnabled();
  const pageWidth = props.pageWidth ?? WRITING_PAGE_WIDTH;
  const writingBufferLines = props.writingBufferLines ?? 3;
  const writingLineHeight = props.initialSnapshot?.writingLineHeight ?? WRITING_LINE_HEIGHT;
  const canvasWrapperRef = (0, import_react132.useRef)(null);
  const containerRef = (0, import_react132.useRef)(null);
  const svgRef = (0, import_react132.useRef)(null);
  const liveStrokeRef = (0, import_react132.useRef)(null);
  const cameraGroupRef = (0, import_react132.useRef)(null);
  function computeInitialPageHeight() {
    const strokes2 = props.initialSnapshot?.strokes ?? [];
    const contentHeight = strokes2.length > 0 ? computeApproxContentMaxY(strokes2) : 0;
    return cropWritingStrokeHeightInvitingly2(contentHeight, writingBufferLines, writingLineHeight);
  }
  const pageHeightRef = (0, import_react132.useRef)(computeInitialPageHeight());
  const [pageHeightState, setPageHeightState] = (0, import_react132.useState)(() => pageHeightRef.current);
  pageHeightRef.current = pageHeightState;
  const storeRef = (0, import_react132.useRef)(null);
  if (!storeRef.current) {
    storeRef.current = new StrokeStore();
    if (props.initialSnapshot)
      storeRef.current.replaceAll(props.initialSnapshot.strokes);
  }
  const undoManagerRef = (0, import_react132.useRef)(new UndoManager());
  const [tool, setTool] = (0, import_react132.useState)("draw");
  const [strokeStyle, setStrokeStyle] = (0, import_react132.useState)({ ...DEFAULT_STROKE_STYLE });
  const [camera, setCameraState] = (0, import_react132.useState)({ x: 0, y: 0, zoom: 1 });
  const [gridEnabled, setGridEnabledState] = (0, import_react132.useState)(props.initialSnapshot?.gridEnabled ?? (writingMode ? false : DEFAULT_SETTINGS.drawingGridEnabledByDefault));
  const [selectedIds, setSelectedIds] = (0, import_react132.useState)(/* @__PURE__ */ new Set());
  const [, forceRender] = (0, import_react132.useState)(0);
  const [viewportRevision, setViewportRevision] = (0, import_react132.useState)(0);
  const strokeBoundsCacheRef = (0, import_react132.useRef)(/* @__PURE__ */ new Map());
  const strokePathDCacheRef = (0, import_react132.useRef)(/* @__PURE__ */ new Map());
  const cameraRef = (0, import_react132.useRef)(camera);
  cameraRef.current = camera;
  const onCameraChangeRef = (0, import_react132.useRef)(props.onCameraChange);
  onCameraChangeRef.current = props.onCameraChange;
  const emitCameraChange = (0, import_react132.useCallback)((nextCamera, meta) => {
    const rect = containerRef.current?.getBoundingClientRect() ?? new DOMRect();
    onCameraChangeRef.current?.({ ...nextCamera }, rect, meta);
  }, []);
  const commitUserCameraState = (0, import_react132.useCallback)((computeNext) => {
    let nextCamera = null;
    setCameraState((prev) => {
      nextCamera = computeNext(prev);
      cameraRef.current = nextCamera;
      return nextCamera;
    });
    if (nextCamera) {
      emitCameraChange(nextCamera, { source: "user" });
    }
  }, [emitCameraChange]);
  const gridEnabledRef = (0, import_react132.useRef)(gridEnabled);
  gridEnabledRef.current = gridEnabled;
  const onChangeRef = (0, import_react132.useRef)(props.onChange);
  onChangeRef.current = props.onChange;
  const onEmbedUndoStackPushRef = (0, import_react132.useRef)(props.onEmbedUndoStackPush);
  onEmbedUndoStackPushRef.current = props.onEmbedUndoStackPush;
  const setGridEnabledHandlerRef = (0, import_react132.useRef)(() => {
  });
  setGridEnabledHandlerRef.current = (enabled) => {
    gridEnabledRef.current = enabled;
    setGridEnabledState(enabled);
    forceRender((n2) => n2 + 1);
    onChangeRef.current?.();
  };
  const toolRef = (0, import_react132.useRef)(tool);
  toolRef.current = tool;
  const toolChangeListenersRef = (0, import_react132.useRef)(/* @__PURE__ */ new Set());
  const applyToolChange = (0, import_react132.useCallback)((nextTool) => {
    setTool(nextTool);
    toolChangeListenersRef.current.forEach((listener) => listener(nextTool));
  }, []);
  const strokeStyleRef = (0, import_react132.useRef)(strokeStyle);
  strokeStyleRef.current = strokeStyle;
  const selectedIdsRef = (0, import_react132.useRef)(selectedIds);
  selectedIdsRef.current = selectedIds;
  const panMomentumRef = (0, import_react132.useRef)(null);
  (0, import_react132.useEffect)(() => {
    panMomentumRef.current = createPanMomentumController({
      axis: "xy"
    });
    return () => panMomentumRef.current?.cancel();
  }, []);
  const applyPanScreenDeltaImmediate = (0, import_react132.useCallback)((deltaScreenX, deltaScreenY) => {
    if (writingMode && !props.isEmbedded) {
      return false;
    }
    commitUserCameraState((prev) => panByScreenDelta(prev, deltaScreenX, deltaScreenY));
    return true;
  }, [writingMode, props.isEmbedded, commitUserCameraState]);
  const applyPanScreenDelta = (0, import_react132.useCallback)((deltaScreenX, deltaScreenY) => {
    panMomentumRef.current?.recordScreenDelta(deltaScreenX, deltaScreenY);
    applyPanScreenDeltaImmediate(deltaScreenX, deltaScreenY);
  }, [applyPanScreenDeltaImmediate]);
  const releasePanMomentum = (0, import_react132.useCallback)(() => {
    panMomentumRef.current?.release((deltaScreenX, deltaScreenY) => applyPanScreenDeltaImmediate(deltaScreenX, deltaScreenY));
  }, [applyPanScreenDeltaImmediate]);
  const cancelPanMomentum = (0, import_react132.useCallback)(() => {
    panMomentumRef.current?.cancel();
  }, []);
  const resetWritingCamera = (0, import_react132.useCallback)((preserveY = false) => {
    const container = containerRef.current;
    if (!container)
      return;
    const zoom = container.clientWidth / pageWidth;
    const prevY = preserveY ? cameraRef.current.y : 0;
    setCameraState({ x: 0, y: prevY, zoom });
  }, [pageWidth]);
  (0, import_react132.useLayoutEffect)(() => {
    if (writingMode) {
      resetWritingCamera(false);
      return;
    }
    if (props.initialViewBox) {
      const container2 = containerRef.current;
      if (!container2)
        return;
      const rect2 = container2.getBoundingClientRect();
      if (rect2.width === 0 || rect2.height === 0)
        return;
      const vb = props.initialViewBox;
      if (props.writingAlignedZoom && props.isEmbedded) {
        const zoom2 = clampZoom(vb.width > 0 ? rect2.width / vb.width : 1);
        const next2 = { x: -vb.x, y: -vb.y, zoom: zoom2 };
        setCameraState(next2);
        emitCameraChange(next2, { source: "init" });
        return;
      }
      const zoomX = vb.width > 0 ? rect2.width / vb.width : 1;
      const zoomY = vb.height > 0 ? rect2.height / vb.height : 1;
      const zoom = clampZoom(Math.min(zoomX, zoomY));
      const next = { x: -vb.x, y: -vb.y, zoom };
      setCameraState(next);
      emitCameraChange(next, { source: "init" });
      return;
    }
    const strokes2 = props.initialSnapshot?.strokes;
    const hasStrokes = (strokes2?.length ?? 0) > 0;
    if (!hasStrokes) {
      const container2 = containerRef.current;
      if (!container2)
        return;
      const zoom = container2.clientWidth / pageWidth;
      setCameraState((prev) => {
        const next = { ...prev, zoom };
        emitCameraChange(next, { source: "init" });
        return next;
      });
      return;
    }
    const container = containerRef.current;
    if (!container)
      return;
    const rect = container.getBoundingClientRect();
    if (rect.width === 0 || rect.height === 0)
      return;
    const bounds = computeStrokesBounds(strokes2);
    if (bounds.width <= 0 || bounds.height <= 0)
      return;
    const fittedCamera = fitBoundsToViewport(rect.width, rect.height, {
      x: bounds.minX,
      y: bounds.minY,
      width: bounds.width,
      height: bounds.height
    });
    setCameraState(fittedCamera);
    emitCameraChange(fittedCamera, { source: "init" });
  }, []);
  (0, import_react132.useEffect)(() => {
    const unsubStore = storeRef.current.subscribe(() => {
      strokeBoundsCacheRef.current.clear();
      strokePathDCacheRef.current.clear();
      forceRender((n2) => n2 + 1);
      props.onChange?.();
      if (writingMode) {
        const allStrokes = storeRef.current.getAll();
        const lh = props.initialSnapshot?.writingLineHeight ?? WRITING_LINE_HEIGHT;
        const contentHeight = allStrokes.length > 0 ? computeApproxContentMaxY(allStrokes) : 0;
        const candidateHeight = cropWritingStrokeHeightInvitingly2(contentHeight, writingBufferLines, lh);
        props.onPageHeightChange?.(candidateHeight);
      }
    });
    const unsubUndo = undoManagerRef.current.subscribe((event) => {
      forceRender((n2) => n2 + 1);
      if (event === "execute") {
        onEmbedUndoStackPushRef.current?.();
      }
    });
    return () => {
      unsubStore();
      unsubUndo();
    };
  }, []);
  (0, import_react132.useEffect)(() => {
    const container = containerRef.current;
    if (!container)
      return;
    let rafId = 0;
    const bumpViewportRevision = () => {
      if (rafId)
        return;
      rafId = window.requestAnimationFrame(() => {
        rafId = 0;
        setViewportRevision((n2) => n2 + 1);
      });
    };
    const noteScroller = container.closest(".cm-scroller");
    const dedicatedScroller = container.closest(".ddc_ink_writing-dedicated-scroller");
    noteScroller?.addEventListener("scroll", bumpViewportRevision, { passive: true });
    dedicatedScroller?.addEventListener("scroll", bumpViewportRevision, { passive: true });
    window.addEventListener("scroll", bumpViewportRevision, { passive: true, capture: true });
    window.addEventListener("resize", bumpViewportRevision);
    const visualViewport = window.visualViewport;
    visualViewport?.addEventListener("scroll", bumpViewportRevision);
    visualViewport?.addEventListener("resize", bumpViewportRevision);
    return () => {
      if (rafId)
        window.cancelAnimationFrame(rafId);
      noteScroller?.removeEventListener("scroll", bumpViewportRevision);
      dedicatedScroller?.removeEventListener("scroll", bumpViewportRevision);
      window.removeEventListener("scroll", bumpViewportRevision, true);
      window.removeEventListener("resize", bumpViewportRevision);
      visualViewport?.removeEventListener("scroll", bumpViewportRevision);
      visualViewport?.removeEventListener("resize", bumpViewportRevision);
    };
  }, [props.isEmbedded, writingMode]);
  (0, import_react132.useEffect)(() => {
    if (!writingMode)
      return;
    const container = containerRef.current;
    if (!container)
      return;
    let lastWidth = container.clientWidth;
    const resizeObserver = new ResizeObserver(() => {
      const width = container.clientWidth;
      if (props.isEmbedded && width === lastWidth)
        return;
      lastWidth = width;
      resetWritingCamera(!props.isEmbedded);
    });
    resizeObserver.observe(container);
    return () => resizeObserver.disconnect();
  }, [writingMode, props.isEmbedded, resetWritingCamera]);
  (0, import_react132.useEffect)(() => {
    if (writingMode)
      return;
    const container = containerRef.current;
    if (!container)
      return;
    let lastEmbedRect = null;
    let lastContainerRect = null;
    const resizeObserver = new ResizeObserver(() => {
      const containerRect2 = container.getBoundingClientRect();
      if (containerRect2.width <= 0 || containerRect2.height <= 0)
        return;
      if (props.isEmbedded) {
        const embedEl = container.closest(".ddc_ink_resize-container") ?? container;
        const embedRect = embedEl.getBoundingClientRect();
        if (lastEmbedRect && lastContainerRect) {
          const anchorScreenX = lastEmbedRect.left + lastEmbedRect.width / 2;
          const anchorScreenY = lastEmbedRect.top + lastEmbedRect.height / 2;
          const targetScreenX = embedRect.left + embedRect.width / 2;
          const targetScreenY = embedRect.top + embedRect.height / 2;
          const sizeChanged = embedRect.width !== lastEmbedRect.width || embedRect.height !== lastEmbedRect.height;
          if (sizeChanged) {
            const prevContainerRect = lastContainerRect;
            setCameraState((prev) => {
              const next = adjustCameraToPreservePagePointAtScreenTargets(prev, prevContainerRect, anchorScreenX, anchorScreenY, containerRect2, targetScreenX, targetScreenY);
              if (next.x === prev.x && next.y === prev.y)
                return prev;
              emitCameraChange(next, { source: "api" });
              return next;
            });
          }
        }
        lastEmbedRect = embedRect;
      } else if (lastContainerRect) {
        const sizeChanged = containerRect2.width !== lastContainerRect.width || containerRect2.height !== lastContainerRect.height;
        if (sizeChanged) {
          const prevContainerRect = lastContainerRect;
          setCameraState((prev) => {
            const next = adjustCameraToPreserveViewportCenter(prev, prevContainerRect, containerRect2);
            if (next.x === prev.x && next.y === prev.y)
              return prev;
            emitCameraChange(next, { source: "api" });
            return next;
          });
        }
      }
      lastContainerRect = containerRect2;
    });
    resizeObserver.observe(container);
    return () => resizeObserver.disconnect();
  }, [writingMode, props.isEmbedded, emitCameraChange]);
  (0, import_react132.useEffect)(() => {
    if (!props.onEditorReady)
      return;
    const editor = {
      undo: () => undoManagerRef.current.undo(),
      redo: () => undoManagerRef.current.redo(),
      canUndo: () => undoManagerRef.current.canUndo(),
      canRedo: () => undoManagerRef.current.canRedo(),
      getUndoCount: () => undoManagerRef.current.getUndoCount(),
      setTool: (t3) => applyToolChange(t3),
      getCurrentTool: () => toolRef.current,
      subscribeToolChange: (listener) => {
        toolChangeListenersRef.current.add(listener);
        listener(toolRef.current);
        return () => {
          toolChangeListenersRef.current.delete(listener);
        };
      },
      getStrokeStyle: () => ({ ...strokeStyleRef.current }),
      setStrokeStyle: (partial) => {
        setStrokeStyle((prev) => ({ ...prev, ...partial }));
      },
      getCamera: () => ({ ...cameraRef.current }),
      setCamera: (partial) => {
        setCameraState((prev) => {
          const next = { ...prev, ...partial };
          emitCameraChange(next, { source: "api" });
          return next;
        });
      },
      isGridEnabled: () => gridEnabledRef.current,
      setGridEnabled: (enabled) => setGridEnabledHandlerRef.current(enabled),
      getSelectedStrokeIds: () => new Set(selectedIdsRef.current),
      deleteSelectedStrokes: () => {
        const ids = Array.from(selectedIdsRef.current);
        if (ids.length === 0)
          return;
        const cmd = new RemoveStrokesCommand(storeRef.current, ids);
        undoManagerRef.current.execute(cmd);
        setSelectedIds(/* @__PURE__ */ new Set());
      },
      getSnapshot: () => ({
        version: 1,
        strokes: storeRef.current.getAll(),
        gridEnabled: gridEnabledRef.current,
        ...writingMode ? { writingLineHeight } : {}
      }),
      eraseAll: () => {
        const cmd = new EraseAllCommand(storeRef.current);
        undoManagerRef.current.execute(cmd);
      },
      addStroke: (stroke) => {
        const cmd = new AddStrokeCommand(storeRef.current, stroke);
        undoManagerRef.current.execute(cmd);
        if (props.onChange)
          props.onChange();
      },
      screenToPage: (sx, sy) => {
        const rect = containerRef.current?.getBoundingClientRect() ?? new DOMRect();
        return screenToPage(cameraRef.current, rect, sx, sy);
      },
      getContainerElement: () => containerRef.current,
      getSvgElement: () => svgRef.current,
      getPageHeight: () => writingMode ? pageHeightRef.current : 0,
      setWritingPageHeight: (height) => {
        if (!writingMode)
          return;
        if (height === pageHeightRef.current)
          return;
        pageHeightRef.current = height;
        setPageHeightState(height);
      }
    };
    props.onEditorReady(editor);
  }, []);
  const getContainerRect = (0, import_react132.useCallback)(() => {
    return containerRef.current?.getBoundingClientRect() ?? new DOMRect();
  }, []);
  const drawCtx = {
    store: storeRef.current,
    undoManager: undoManagerRef.current,
    getCamera: () => cameraRef.current,
    getContainerRect,
    getStrokeStyle: () => ({ ...strokeStyleRef.current }),
    getStrokeInputTreatAsPreference: () => strokeInputTreatAsPreferenceRef.current,
    getResolvedStrokeInputTreatAs: () => resolvedStrokeInputTreatAsRef.current,
    getLiveStrokePath: () => liveStrokeRef.current,
    onStrokeInputDetected: (detected) => {
      setLastDetectedStrokeInput(detected);
    }
  };
  const eraseCtx = {
    store: storeRef.current,
    undoManager: undoManagerRef.current,
    getCamera: () => cameraRef.current,
    getContainerRect,
    getSvgElement: () => svgRef.current
  };
  const selectCtx = {
    store: storeRef.current,
    undoManager: undoManagerRef.current,
    getCamera: () => cameraRef.current,
    getContainerRect,
    getSvgElement: () => svgRef.current,
    getSelectedStrokeIds: () => selectedIdsRef.current,
    setSelectedStrokeIds: (ids) => setSelectedIds(ids)
  };
  const isPanning = (0, import_react132.useRef)(false);
  const lastPanPoint = (0, import_react132.useRef)(null);
  const isRightDraggingRef = (0, import_react132.useRef)(false);
  const rightDragStartPointRef = (0, import_react132.useRef)({ x: 0, y: 0 });
  const rightDragInitialCameraRef = (0, import_react132.useRef)({ x: 0, y: 0, zoom: 1 });
  const rightDragFocalScreenRef = (0, import_react132.useRef)({ x: 0, y: 0 });
  const rightDragMovedRef = (0, import_react132.useRef)(false);
  const isSpaceHeldRef = (0, import_react132.useRef)(false);
  const isPointerOverCanvasRef = (0, import_react132.useRef)(false);
  const isModKeyHeldRef = (0, import_react132.useRef)(false);
  const isModTemporaryEraseModeRef = (0, import_react132.useRef)(false);
  const toolBeforeModTemporaryEraseRef = (0, import_react132.useRef)(null);
  const lastCanvasPointerRef = (0, import_react132.useRef)(null);
  const suppressPrimaryPointerUntilUpRef = (0, import_react132.useRef)(false);
  const [cursorStyle, setCursorStyle] = (0, import_react132.useState)(void 0);
  const isBooxInputLockedRef = (0, import_react132.useRef)(props.isBooxInputLocked ?? false);
  isBooxInputLockedRef.current = props.isBooxInputLocked ?? false;
  const isFingerDrawingActiveRef = (0, import_react132.useRef)(props.isFingerDrawingActive ?? false);
  isFingerDrawingActiveRef.current = props.isFingerDrawingActive ?? false;
  (0, import_react132.useEffect)(() => {
    if (!props.isBooxInputLocked)
      return;
    if (isModTemporaryEraseModeRef.current) {
      isModTemporaryEraseModeRef.current = false;
      isModKeyHeldRef.current = false;
      suppressPrimaryPointerUntilUpRef.current = false;
      const previousTool = toolBeforeModTemporaryEraseRef.current;
      toolBeforeModTemporaryEraseRef.current = null;
      if (previousTool)
        applyToolChange(previousTool);
    }
    drawToolPointerCancel({}, drawCtx);
    eraseToolPointerCancel({}, eraseCtx);
    selectToolPointerCancel({}, selectCtx);
  }, [props.isBooxInputLocked]);
  (0, import_react132.useEffect)(() => {
    if (props.isFingerDrawingActive)
      return;
    drawToolPointerCancel({}, drawCtx);
    eraseToolPointerCancel({}, eraseCtx);
    selectToolPointerCancel({}, selectCtx);
  }, [props.isFingerDrawingActive]);
  const shouldModTemporaryEraseActivate = (0, import_react132.useCallback)(() => {
    const last7 = lastCanvasPointerRef.current;
    const hasActiveCanvasPointer = last7 !== null && last7.buttons !== 0;
    return isPointerOverCanvasRef.current || hasActiveCanvasPointer;
  }, []);
  const beginModTemporaryEraseMode = (0, import_react132.useCallback)((opts) => {
    if (isModTemporaryEraseModeRef.current) {
      if (opts?.pointerDownEvent) {
        eraseToolPointerDown(opts.pointerDownEvent, eraseCtx);
      }
      return;
    }
    if (isBooxInputLockedRef.current)
      return;
    if (!opts?.forceActivate && !shouldModTemporaryEraseActivate()) {
      return;
    }
    isModTemporaryEraseModeRef.current = true;
    toolBeforeModTemporaryEraseRef.current = toolRef.current;
    drawToolPointerCancel({}, drawCtx);
    eraseToolPointerCancel({}, eraseCtx);
    selectToolPointerCancel({}, selectCtx);
    applyToolChange("erase");
    if (opts?.pointerDownEvent) {
      eraseToolPointerDown(opts.pointerDownEvent, eraseCtx);
      return;
    }
    const last7 = lastCanvasPointerRef.current;
    const midStrokeErase = last7?.pointerType === "mouse" && last7.buttons & 1;
    if (midStrokeErase) {
      eraseToolPointerDown(createPointerEventFromLastCanvasPointer(last7), eraseCtx);
    }
  }, [shouldModTemporaryEraseActivate]);
  const endModTemporaryEraseMode = (0, import_react132.useCallback)(() => {
    if (!isModTemporaryEraseModeRef.current)
      return;
    isModTemporaryEraseModeRef.current = false;
    eraseToolPointerCancel({}, eraseCtx);
    const previousTool = toolBeforeModTemporaryEraseRef.current;
    toolBeforeModTemporaryEraseRef.current = null;
    if (previousTool)
      applyToolChange(previousTool);
    const last7 = lastCanvasPointerRef.current;
    if (last7?.pointerType === "mouse" && last7.buttons & 1) {
      suppressPrimaryPointerUntilUpRef.current = true;
    }
  }, []);
  const beginModTemporaryEraseModeRef = (0, import_react132.useRef)(beginModTemporaryEraseMode);
  beginModTemporaryEraseModeRef.current = beginModTemporaryEraseMode;
  const endModTemporaryEraseModeRef = (0, import_react132.useRef)(endModTemporaryEraseMode);
  endModTemporaryEraseModeRef.current = endModTemporaryEraseMode;
  const recordCanvasPointer = (e2) => {
    lastCanvasPointerRef.current = {
      clientX: e2.clientX,
      clientY: e2.clientY,
      pointerId: e2.pointerId,
      pointerType: e2.pointerType,
      buttons: e2.buttons
    };
  };
  const beginMousePan = (e2) => {
    cancelPanMomentum();
    isPanning.current = true;
    lastPanPoint.current = { x: e2.clientX, y: e2.clientY };
    e2.target.setPointerCapture(e2.pointerId);
    setCursorStyle("grabbing");
  };
  const handlePointerDown = (0, import_react132.useCallback)((e2) => {
    if (e2.pointerType === "touch" && !isFingerDrawingActiveRef.current)
      return;
    recordCanvasPointer(e2);
    isPointerOverCanvasRef.current = true;
    if (suppressPrimaryPointerUntilUpRef.current && e2.button === 0) {
      e2.target.setPointerCapture(e2.pointerId);
      return;
    }
    const isSpacePanGesture = isSpaceHeldRef.current && e2.button === 0;
    if (isSpacePanGesture) {
      if (writingMode && props.isEmbedded)
        return;
      beginMousePan(e2);
      return;
    }
    const isModHeldNow = isModKeyHeldRef.current || e2.ctrlKey || e2.metaKey;
    if (isModHeldNow && e2.pointerType === "mouse" && e2.button === 0 && !isBooxInputLockedRef.current) {
      beginModTemporaryEraseMode({ pointerDownEvent: e2.nativeEvent, forceActivate: true });
      e2.target.setPointerCapture(e2.pointerId);
      return;
    }
    if (e2.button === 2) {
      e2.nativeEvent.stopPropagation();
      const isModHeld = e2.ctrlKey || e2.metaKey;
      if (isModHeld) {
        if (writingMode)
          return;
        isRightDraggingRef.current = true;
        rightDragStartPointRef.current = { x: e2.clientX, y: e2.clientY };
        rightDragInitialCameraRef.current = { ...cameraRef.current };
        const containerRect2 = containerRef.current?.getBoundingClientRect() ?? new DOMRect();
        rightDragFocalScreenRef.current = { x: e2.clientX - containerRect2.left, y: e2.clientY - containerRect2.top };
        rightDragMovedRef.current = false;
        e2.target.setPointerCapture(e2.pointerId);
        return;
      }
      if (writingMode && props.isEmbedded)
        return;
      beginMousePan(e2);
      return;
    }
    if (e2.pointerType === "mouse" && e2.button === 1) {
      e2.preventDefault();
      e2.nativeEvent.stopPropagation();
      if (writingMode && props.isEmbedded)
        return;
      beginMousePan(e2);
      return;
    }
    if (!isBooxInputLockedRef.current) {
      if (toolRef.current === "draw")
        drawToolPointerDown(e2.nativeEvent, drawCtx);
      if (toolRef.current === "erase")
        eraseToolPointerDown(e2.nativeEvent, eraseCtx);
      if (toolRef.current === "select")
        selectToolPointerDown(e2.nativeEvent, selectCtx);
    }
    e2.target.setPointerCapture(e2.pointerId);
  }, [tool]);
  const handlePointerMove = (0, import_react132.useCallback)((e2) => {
    if (e2.pointerType === "touch" && !isFingerDrawingActiveRef.current)
      return;
    recordCanvasPointer(e2);
    if (suppressPrimaryPointerUntilUpRef.current)
      return;
    if (isPanning.current && lastPanPoint.current) {
      const dx = e2.clientX - lastPanPoint.current.x;
      const dy = e2.clientY - lastPanPoint.current.y;
      lastPanPoint.current = { x: e2.clientX, y: e2.clientY };
      if (dx !== 0 || dy !== 0) {
        applyPanScreenDelta(dx, dy);
      }
      return;
    }
    if (isRightDraggingRef.current) {
      if (writingMode)
        return;
      const startPoint = rightDragStartPointRef.current;
      const dragZoomDelta = getRightDragZoomDelta(startPoint.x, startPoint.y, e2.clientX, e2.clientY);
      const hasMoved = Math.abs(dragZoomDelta) > 2;
      if (hasMoved)
        rightDragMovedRef.current = true;
      const factor = Math.exp(dragZoomDelta * 5e-3);
      const initialCam = rightDragInitialCameraRef.current;
      const newZoom = clampZoom(initialCam.zoom * factor);
      const focal = rightDragFocalScreenRef.current;
      const zoomDelta = 1 / newZoom - 1 / initialCam.zoom;
      const next = {
        x: initialCam.x + focal.x * zoomDelta,
        y: initialCam.y + focal.y * zoomDelta,
        zoom: newZoom
      };
      setCameraState(next);
      emitCameraChange(next, { source: "user" });
      return;
    }
    if (!isBooxInputLockedRef.current) {
      if (toolRef.current === "draw")
        drawToolPointerMove(e2.nativeEvent, drawCtx);
      if (toolRef.current === "erase")
        eraseToolPointerMove(e2.nativeEvent, eraseCtx);
      if (toolRef.current === "select")
        selectToolPointerMove(e2.nativeEvent, selectCtx);
    }
  }, [tool]);
  const handlePointerUp = (0, import_react132.useCallback)((e2) => {
    if (e2.pointerType === "touch" && !isFingerDrawingActiveRef.current)
      return;
    recordCanvasPointer(e2);
    if (suppressPrimaryPointerUntilUpRef.current && e2.button === 0) {
      suppressPrimaryPointerUntilUpRef.current = false;
      return;
    }
    if (isPanning.current) {
      isPanning.current = false;
      lastPanPoint.current = null;
      const nextCursor = isSpaceHeldRef.current ? "grab" : void 0;
      setCursorStyle(nextCursor);
      releasePanMomentum();
      return;
    }
    if (isRightDraggingRef.current) {
      isRightDraggingRef.current = false;
      return;
    }
    if (!isBooxInputLockedRef.current) {
      if (toolRef.current === "draw")
        drawToolPointerUp(e2.nativeEvent, drawCtx);
      if (toolRef.current === "erase")
        eraseToolPointerUp(e2.nativeEvent, eraseCtx);
      if (toolRef.current === "select")
        selectToolPointerUp(e2.nativeEvent, selectCtx);
    }
  }, [tool, releasePanMomentum]);
  const handlePointerCancel = (0, import_react132.useCallback)((e2) => {
    if (e2.pointerType === "touch" && !isFingerDrawingActiveRef.current)
      return;
    recordCanvasPointer(e2);
    if (suppressPrimaryPointerUntilUpRef.current) {
      suppressPrimaryPointerUntilUpRef.current = false;
    }
    if (isPanning.current) {
      isPanning.current = false;
      lastPanPoint.current = null;
      const nextCursor = isSpaceHeldRef.current ? "grab" : void 0;
      setCursorStyle(nextCursor);
      releasePanMomentum();
      return;
    }
    if (isRightDraggingRef.current) {
      isRightDraggingRef.current = false;
      return;
    }
    if (!isBooxInputLockedRef.current) {
      if (toolRef.current === "draw")
        drawToolPointerCancel(e2.nativeEvent, drawCtx);
      if (toolRef.current === "erase")
        eraseToolPointerCancel(e2.nativeEvent, eraseCtx);
      if (toolRef.current === "select")
        selectToolPointerCancel(e2.nativeEvent, selectCtx);
    }
  }, [tool]);
  const handleDrawingEmbedTwoFingerGesture = (0, import_react132.useCallback)((params) => {
    const { deltaX, deltaY, anchorX, anchorY, distanceRatio } = params;
    if (deltaX !== 0 || deltaY !== 0) {
      panMomentumRef.current?.recordScreenDelta(deltaX, deltaY);
    }
    commitUserCameraState((prev) => {
      const afterPan = panByScreenDelta(prev, deltaX, deltaY);
      const newZoom = clampZoom(afterPan.zoom * distanceRatio);
      const zoomDelta = 1 / newZoom - 1 / afterPan.zoom;
      return {
        x: afterPan.x + anchorX * zoomDelta,
        y: afterPan.y + anchorY * zoomDelta,
        zoom: newZoom
      };
    });
  }, [commitUserCameraState]);
  const handleEmbedTwoFingerGestureEnd = (0, import_react132.useCallback)(() => {
    releasePanMomentum();
    props.onBooxEmbedGeometryChange?.();
  }, [releasePanMomentum, props.onBooxEmbedGeometryChange]);
  (0, import_react132.useEffect)(() => {
    const container = containerRef.current;
    if (!container)
      return;
    const suppressContextMenu = (e2) => {
      e2.preventDefault();
      e2.stopPropagation();
    };
    container.addEventListener("contextmenu", suppressContextMenu, { capture: true });
    return () => container.removeEventListener("contextmenu", suppressContextMenu, { capture: true });
  }, []);
  const wheelIdleTimerRef = (0, import_react132.useRef)(null);
  const modifierWheelZoomDirectionResolverRef = (0, import_react132.useRef)(createModifierWheelZoomDirectionResolver());
  const commitUserCameraStateRef = (0, import_react132.useRef)(commitUserCameraState);
  commitUserCameraStateRef.current = commitUserCameraState;
  const applyPanScreenDeltaRef = (0, import_react132.useRef)(applyPanScreenDelta);
  applyPanScreenDeltaRef.current = applyPanScreenDelta;
  const releasePanMomentumRef = (0, import_react132.useRef)(releasePanMomentum);
  releasePanMomentumRef.current = releasePanMomentum;
  const cancelPanMomentumRef = (0, import_react132.useRef)(cancelPanMomentum);
  cancelPanMomentumRef.current = cancelPanMomentum;
  (0, import_react132.useEffect)(() => {
    const svg = svgRef.current;
    if (!svg)
      return;
    const TRACKPAD_WHEEL_IDLE_MS = 80;
    const clearTrackpadWheelIdleTimer = () => {
      if (wheelIdleTimerRef.current !== null) {
        window.clearTimeout(wheelIdleTimerRef.current);
        wheelIdleTimerRef.current = null;
      }
    };
    const scheduleTrackpadWheelRelease = () => {
      clearTrackpadWheelIdleTimer();
      wheelIdleTimerRef.current = window.setTimeout(() => {
        wheelIdleTimerRef.current = null;
        releasePanMomentumRef.current();
      }, TRACKPAD_WHEEL_IDLE_MS);
    };
    const handleWheelNative = (e2) => {
      if (writingMode) {
        return;
      }
      const isZoomModifier = e2.ctrlKey || e2.metaKey;
      if (isZoomModifier) {
        clearTrackpadWheelIdleTimer();
        cancelPanMomentumRef.current();
        e2.preventDefault();
        const svgRect = svg.getBoundingClientRect();
        const anchorX = e2.clientX - svgRect.left;
        const anchorY = e2.clientY - svgRect.top;
        const direction = modifierWheelZoomDirectionResolverRef.current.getDirection(e2);
        commitUserCameraStateRef.current((prev) => zoomAtPoint(prev, anchorX, anchorY, direction));
        return;
      }
      if (!props.isEmbedded) {
        e2.preventDefault();
        modifierWheelZoomDirectionResolverRef.current.cancel();
        if (isTrackpadWheel(e2)) {
          applyPanScreenDeltaRef.current(e2.deltaX, e2.deltaY);
          scheduleTrackpadWheelRelease();
        } else {
          clearTrackpadWheelIdleTimer();
          cancelPanMomentumRef.current();
          commitUserCameraStateRef.current((prev) => panByScreenDelta(prev, e2.deltaX, e2.deltaY));
        }
      }
    };
    svg.addEventListener("wheel", handleWheelNative, { passive: false });
    return () => {
      clearTrackpadWheelIdleTimer();
      modifierWheelZoomDirectionResolverRef.current.cancel();
      svg.removeEventListener("wheel", handleWheelNative);
    };
  }, [writingMode, props.isEmbedded]);
  (0, import_react132.useEffect)(() => {
    const handleKeyDown = (e2) => {
      const shouldActivate = e2.key === " " && !e2.repeat && !e2.metaKey && !e2.ctrlKey && isPointerOverCanvasRef.current && !props.isEmbedded && !writingMode;
      if (!shouldActivate)
        return;
      isSpaceHeldRef.current = true;
      setCursorStyle("grab");
      e2.preventDefault();
    };
    const handleKeyUp = (e2) => {
      if (e2.key !== " ")
        return;
      isSpaceHeldRef.current = false;
      if (!isPanning.current)
        setCursorStyle(void 0);
    };
    window.addEventListener("keydown", handleKeyDown, true);
    window.addEventListener("keyup", handleKeyUp, true);
    return () => {
      window.removeEventListener("keydown", handleKeyDown, true);
      window.removeEventListener("keyup", handleKeyUp, true);
    };
  }, []);
  (0, import_react132.useEffect)(() => {
    const handleKeyDown = (e2) => {
      if (!isModKeyKeyboardEvent(e2) || e2.repeat)
        return;
      isModKeyHeldRef.current = true;
      beginModTemporaryEraseModeRef.current({ forceActivate: true });
    };
    const handleKeyUp = (e2) => {
      if (!isModKeyKeyboardEvent(e2))
        return;
      const modStillHeld = e2.metaKey || e2.ctrlKey;
      if (!modStillHeld) {
        isModKeyHeldRef.current = false;
      }
      if (modStillHeld)
        return;
      endModTemporaryEraseModeRef.current();
    };
    const handleWindowBlur = () => {
      endModTemporaryEraseModeRef.current();
    };
    window.addEventListener("keydown", handleKeyDown, true);
    window.addEventListener("keyup", handleKeyUp, true);
    window.addEventListener("blur", handleWindowBlur);
    return () => {
      window.removeEventListener("keydown", handleKeyDown, true);
      window.removeEventListener("keyup", handleKeyUp, true);
      window.removeEventListener("blur", handleWindowBlur);
    };
  }, []);
  const strokes = storeRef.current.getAll();
  const cameraTransform = `scale(${camera.zoom}) translate(${camera.x}, ${camera.y})`;
  const containerRect = containerRef.current?.getBoundingClientRect() ?? null;
  const visiblePageRect = containerRect ? visiblePageRectFromContainer(camera, containerRect) : void 0;
  const getCachedApproxStrokeBounds = (stroke) => {
    const cached = strokeBoundsCacheRef.current.get(stroke.id);
    if (cached)
      return cached;
    const bounds = computeApproxStrokePageBounds(stroke);
    strokeBoundsCacheRef.current.set(stroke.id, bounds);
    return bounds;
  };
  const isStrokeVisibleInViewport = (stroke) => {
    if (selectedIds.has(stroke.id))
      return true;
    if (visiblePageRect === void 0)
      return true;
    if (visiblePageRect === null)
      return false;
    return pageRectsIntersect(getCachedApproxStrokeBounds(stroke), visiblePageRect);
  };
  const inkTouchGestureMode = resolveInkTouchGestureMode({
    writingMode,
    isEmbedded: !!props.isEmbedded,
    hasDedicatedVerticalTouchPan: false
  });
  return /* @__PURE__ */ import_react132.default.createElement("div", {
    ref: canvasWrapperRef,
    className: "ink-svg-canvas-wrapper",
    style: {
      width: "100%",
      height: "100%",
      position: "relative"
    }
  }, /* @__PURE__ */ import_react132.default.createElement(FingerBlocker, {
    wrapperRef: canvasWrapperRef,
    touchGestureMode: inkTouchGestureMode,
    forwardPenToCanvas: !props.isBooxInputLocked,
    forwardFingerToCanvas: !!props.isFingerDrawingActive && !props.isBooxInputLocked,
    onDrawingEmbedTwoFingerGesture: !writingMode ? handleDrawingEmbedTwoFingerGesture : void 0,
    onPanGestureEnd: props.onPanGestureEnd,
    onEmbedTwoFingerGestureEnd: !writingMode ? handleEmbedTwoFingerGestureEnd : void 0,
    onTouchGestureSessionStart: cancelPanMomentum
  }), /* @__PURE__ */ import_react132.default.createElement("div", {
    ref: containerRef,
    className: "ink-svg-canvas-container",
    style: {
      width: "100%",
      height: "100%",
      overflow: "hidden",
      touchAction: "auto",
      position: "relative",
      cursor: cursorStyle
    },
    onMouseEnter: (e2) => {
      isPointerOverCanvasRef.current = true;
      if ((e2.metaKey || e2.ctrlKey || isModKeyHeldRef.current) && !isModTemporaryEraseModeRef.current) {
        beginModTemporaryEraseModeRef.current({ forceActivate: true });
      }
    },
    onMouseMove: () => {
      isPointerOverCanvasRef.current = true;
    },
    onMouseLeave: () => {
      isPointerOverCanvasRef.current = false;
    }
  }, /* @__PURE__ */ import_react132.default.createElement("svg", {
    ref: svgRef,
    className: "ink-svg-canvas",
    style: { width: "100%", height: "100%", display: "block" },
    onPointerDown: handlePointerDown,
    onPointerMove: handlePointerMove,
    onPointerUp: handlePointerUp,
    onPointerCancel: handlePointerCancel
  }, !writingMode && gridEnabled && /* @__PURE__ */ import_react132.default.createElement(InkAdaptiveGrid, {
    x: camera.x,
    y: camera.y,
    z: camera.zoom,
    zoomFadeScale: isBooxConnectionEnabled ? INK_GRID_BOOX_ZOOM_FADE_SCALE : 1
  }), /* @__PURE__ */ import_react132.default.createElement("g", {
    ref: cameraGroupRef,
    transform: cameraTransform
  }, writingMode && (() => {
    const lh = writingLineHeight;
    const pw = pageWidth;
    const margin = pw * 0.05;
    const lineCount = Math.floor(pageHeightState / lh);
    const guideLineStrokeWidth = (isBooxConnectionEnabled ? 2 : 1) / camera.zoom;
    if (visiblePageRect === null)
      return null;
    let startIndex = 1;
    let endIndex = lineCount;
    if (visiblePageRect !== void 0) {
      startIndex = Math.max(1, Math.floor(visiblePageRect.minY / lh));
      endIndex = Math.min(lineCount, Math.ceil(visiblePageRect.maxY / lh));
    }
    if (endIndex < startIndex)
      return null;
    const lines = [];
    for (let i2 = startIndex; i2 <= endIndex; i2++) {
      const lineY = i2 * lh;
      lines.push(/* @__PURE__ */ import_react132.default.createElement("line", {
        key: i2,
        className: "ink-writing-guide-line",
        x1: margin,
        y1: lineY,
        x2: pw - margin,
        y2: lineY,
        stroke: isBooxConnectionEnabled ? "var(--text-normal)" : "currentColor",
        strokeOpacity: isBooxConnectionEnabled ? 1 : 0.5,
        strokeWidth: guideLineStrokeWidth
      }));
    }
    return lines;
  })(), strokes.map((stroke) => isStrokeVisibleInViewport(stroke) ? /* @__PURE__ */ import_react132.default.createElement(StrokePath, {
    key: stroke.id,
    stroke,
    isSelected: selectedIds.has(stroke.id),
    pathDCache: strokePathDCacheRef.current
  }) : null), /* @__PURE__ */ import_react132.default.createElement("path", {
    ref: liveStrokeRef,
    fill: strokeStyle.color,
    pointerEvents: "none"
  })))));
}
function strokePathPropsAreEqual(prev, next) {
  if (prev.isSelected !== next.isSelected)
    return false;
  if (prev.pathDCache !== next.pathDCache)
    return false;
  const a2 = prev.stroke;
  const b2 = next.stroke;
  if (a2 === b2)
    return true;
  if (a2.id !== b2.id)
    return false;
  if (a2.points !== b2.points)
    return false;
  if (a2.style !== b2.style)
    return false;
  if (a2.offset.x !== b2.offset.x || a2.offset.y !== b2.offset.y)
    return false;
  return true;
}
var import_react132, StrokePath;
var init_ink_svg_canvas = __esm({
  "src/ink-canvas/ink-svg-canvas.tsx"() {
    init_17();
    import_react132 = __toESM(require_react());
    init_esm2();
    init_svg_path_from_stroke();
    init_stroke_store();
    init_undo_manager();
    init_camera();
    init_pan_momentum();
    init_svg_export();
    init_stroke_viewport_culling();
    init_tldraw_helpers();
    init_constants();
    init_commands();
    init_draw_tool();
    init_erase_tool2();
    init_select_tool();
    init_finger_blocker();
    init_touch_gesture_policy();
    init_device_settings();
    init_use_stroke_input_treat_as();
    init_use_resolved_stroke_input_treat_as();
    init_use_boox_connection_enabled();
    init_plugin_settings();
    init_types();
    init_ink_adaptive_grid();
    StrokePath = (0, import_react132.memo)(function StrokePath2(props) {
      const { stroke, isSelected, pathDCache } = props;
      let d2 = pathDCache.get(stroke.id);
      if (d2 === void 0) {
        const outlinePoints = R(stroke.points, toStrokeOptions(stroke.style));
        d2 = getSvgPathFromStroke(outlinePoints);
        pathDCache.set(stroke.id, d2);
      }
      const hasOffset = stroke.offset.x !== 0 || stroke.offset.y !== 0;
      return /* @__PURE__ */ import_react132.default.createElement("g", {
        "data-stroke-group": "",
        "data-stroke-id": stroke.id,
        "data-offset-x": stroke.offset.x,
        "data-offset-y": stroke.offset.y,
        transform: hasOffset ? `translate(${stroke.offset.x}, ${stroke.offset.y})` : void 0
      }, /* @__PURE__ */ import_react132.default.createElement("path", {
        "data-stroke-id": stroke.id,
        d: d2,
        fill: stroke.style.color
      }), isSelected && /* @__PURE__ */ import_react132.default.createElement("path", {
        d: d2,
        fill: "none",
        stroke: "rgba(0, 123, 255, 0.6)",
        strokeWidth: 2,
        pointerEvents: "none"
      }));
    }, strokePathPropsAreEqual);
  }
});

// src/ink-canvas/utils/stroke-timestamps.ts
function inkStrokeTimestampsFromBooxPoints(points) {
  if (points.length === 0)
    return void 0;
  return {
    startedAt: points[0].timestamp,
    finishedAt: points[points.length - 1].timestamp
  };
}
var init_stroke_timestamps = __esm({
  "src/ink-canvas/utils/stroke-timestamps.ts"() {
  }
});

// src/components/formats/current/writing/writing-editor/writing-editor.tsx
function WritingEditor(props) {
  const dominantHand = useDominantHand();
  const isBooxConnectionEnabled = useBooxConnectionEnabled();
  const isFingerDrawingGloballyEnabled = useFingerDrawingEnabled();
  const [isFingerDrawingActive, setIsFingerDrawingActive] = React101.useState(false);
  const [initialSnapshot, setInitialSnapshot] = React101.useState();
  const [booxConnected, setBooxConnected] = React101.useState(false);
  const resizePostProcessTimeoutRef = (0, import_react133.useRef)();
  const shortDelayTimerRef = (0, import_react133.useRef)();
  const longDelayTimerRef = (0, import_react133.useRef)();
  const editorRef = (0, import_react133.useRef)();
  const editorWrapperRefEl = (0, import_react133.useRef)(null);
  const websocketConnectedRef = (0, import_react133.useRef)(false);
  const [isBooxInputLocked, setIsBooxInputLocked] = React101.useState(false);
  const activateWritingSessionRef = (0, import_react133.useRef)(null);
  const adjustThrottleRef = (0, import_react133.useRef)(null);
  const setBooxOverlayActiveTimerRef = (0, import_react133.useRef)(null);
  const isViewActiveRef = (0, import_react133.useRef)(true);
  const pendingNewOverlayRef = (0, import_react133.useRef)(false);
  const isAndroidDrawingAreaResizingRef = (0, import_react133.useRef)(false);
  const queuedBooxStrokePayloadsRef = (0, import_react133.useRef)([]);
  const writingLineHeightRef = (0, import_react133.useRef)(WRITING_LINE_HEIGHT);
  const curHeightRef = (0, import_react133.useRef)(null);
  const forceNextPageHeightChangeRef = (0, import_react133.useRef)(false);
  const isLegacyInkFileRef = (0, import_react133.useRef)(false);
  const dedicatedScrollerRef = (0, import_react133.useRef)(null);
  const dedicatedPageRef = (0, import_react133.useRef)(null);
  const [dedicatedPageCssHeightPx, setDedicatedPageCssHeightPx] = React101.useState(null);
  const dedicatedLastZoomRef = (0, import_react133.useRef)(null);
  React101.useEffect(() => {
    if (!isFingerDrawingGloballyEnabled)
      setIsFingerDrawingActive(false);
  }, [isFingerDrawingGloballyEnabled]);
  React101.useEffect(() => {
    verbose("INK CANVAS WRITING EDITOR mounted");
    logToVault("Ink canvas writing editor mounted: " + props.writingFile.path + (props.embedded ? " [embed]" : " [dedicated]"));
    void fetchFileData();
    return () => {
      verbose("INK CANVAS WRITING EDITOR unmounting");
      logToVault("Ink canvas writing editor unmounted: " + props.writingFile.path);
    };
  }, []);
  React101.useEffect(() => {
    if (!initialSnapshot || !isLegacyInkFileRef.current)
      return;
    showLegacyInkUnlockNotice({
      plugin: props.plugin,
      legacyFile: props.writingFile,
      isEmbedded: props.embedded
    });
  }, [initialSnapshot]);
  React101.useEffect(() => {
    return () => resetTimers();
  }, []);
  React101.useEffect(() => {
    if (!initialSnapshot)
      return;
    if (!getBooxConnectionEnabled())
      return;
    const { unregister: unregister2, activate } = props.plugin.booxConnection.registerDrawingSession({
      onStrokeStart: () => {
        cancelDelayedBooxResizePostProcess();
      },
      onStroke: (strokeData) => {
        const payload = strokeData;
        const strokePayload = {
          strokeId: payload.strokeId,
          points: payload.points ?? strokeData,
          canvasWidth: payload.canvasWidth,
          canvasHeight: payload.canvasHeight
        };
        if (isAndroidDrawingAreaResizingRef.current) {
          queuedBooxStrokePayloadsRef.current.push(strokePayload);
          return;
        }
        const created = createStrokeFromBoox(strokePayload);
        if (created && strokePayload.strokeId !== void 0) {
          props.plugin.booxConnection.sendStrokeRendered(strokePayload.strokeId);
        }
      },
      onDrawingAreaReady: () => {
        if (!isAndroidDrawingAreaResizingRef.current && queuedBooxStrokePayloadsRef.current.length === 0)
          return;
        isAndroidDrawingAreaResizingRef.current = false;
        flushQueuedBooxStrokesAfterResize();
      },
      onSocketOpen: () => {
        websocketConnectedRef.current = true;
        setBooxConnected(true);
        setIsBooxInputLocked(true);
        debug("Ink canvas writing: Connected to Boox companion app WebSocket");
        new import_obsidian21.Notice("Connected to Boox companion app");
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const editor = editorRef.current;
          if (editor) {
            props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
        } else {
          pendingNewOverlayRef.current = true;
        }
      },
      onReactivate: () => {
        if (!websocketConnectedRef.current)
          return;
        if (setBooxOverlayActiveTimerRef.current)
          window.clearTimeout(setBooxOverlayActiveTimerRef.current);
        setBooxOverlayActiveTimerRef.current = window.setTimeout(() => {
          setBooxOverlayActiveTimerRef.current = null;
          if (!websocketConnectedRef.current)
            return;
          activateWritingSessionRef.current?.();
          const sent = newAndroidDrawingArea();
          if (sent) {
            pendingNewOverlayRef.current = false;
            const editor = editorRef.current;
            if (editor)
              props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          } else {
            pendingNewOverlayRef.current = true;
          }
        }, 0);
      }
    });
    activateWritingSessionRef.current = activate;
    return () => {
      websocketConnectedRef.current = false;
      setBooxConnected(false);
      setIsBooxInputLocked(false);
      pendingNewOverlayRef.current = false;
      isAndroidDrawingAreaResizingRef.current = false;
      queuedBooxStrokePayloadsRef.current = [];
      if (adjustThrottleRef.current)
        window.clearTimeout(adjustThrottleRef.current);
      if (setBooxOverlayActiveTimerRef.current)
        window.clearTimeout(setBooxOverlayActiveTimerRef.current);
      activateWritingSessionRef.current = null;
      unregister2();
    };
  }, [initialSnapshot]);
  React101.useEffect(() => {
    if (!initialSnapshot)
      return;
    if (!getBooxConnectionEnabled())
      return;
    if (!editorWrapperRefEl.current)
      return;
    const scrollEl = props.embedded ? editorWrapperRefEl.current.closest(".cm-scroller") : dedicatedScrollerRef.current;
    if (!scrollEl)
      return;
    const onScroll = () => {
      if (!isViewActiveRef.current)
        return;
      restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
      adjustAndroidDrawingAreaThrottled();
    };
    scrollEl.addEventListener("scroll", onScroll, { passive: true });
    const visualViewport = typeof window !== "undefined" ? window.visualViewport : null;
    const onVisualViewportChange = () => {
      if (!isViewActiveRef.current)
        return;
      restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
      adjustAndroidDrawingAreaThrottled();
    };
    visualViewport?.addEventListener("scroll", onVisualViewportChange);
    visualViewport?.addEventListener("resize", onVisualViewportChange);
    return () => {
      scrollEl.removeEventListener("scroll", onScroll);
      visualViewport?.removeEventListener("scroll", onVisualViewportChange);
      visualViewport?.removeEventListener("resize", onVisualViewportChange);
    };
  }, [initialSnapshot, props.embedded]);
  React101.useEffect(() => {
    if (!initialSnapshot)
      return;
    if (!editorWrapperRefEl.current)
      return;
    const resizeObserver = new ResizeObserver(() => {
      if (!props.embedded) {
        syncDedicatedPageCssHeight({ preservePageScroll: true });
      }
      if (pendingNewOverlayRef.current && isViewActiveRef.current && websocketConnectedRef.current) {
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const editor = editorRef.current;
          if (editor) {
            props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
          return;
        }
        return;
      }
      if (websocketConnectedRef.current && isViewActiveRef.current) {
        sendAdjustmentImmediate();
      }
    });
    const observeTarget = props.embedded ? editorWrapperRefEl.current : dedicatedScrollerRef.current ?? editorWrapperRefEl.current;
    resizeObserver.observe(observeTarget);
    return () => resizeObserver.disconnect();
  }, [initialSnapshot, props.embedded]);
  function syncDedicatedPageCssHeight(options) {
    if (props.embedded)
      return;
    const scroller = dedicatedScrollerRef.current;
    const editor = editorRef.current;
    if (!scroller)
      return;
    const zoom = Math.max(scroller.clientWidth, 1) / WRITING_PAGE_WIDTH;
    const pageHeight = options?.pageHeight ?? editor?.getPageHeight() ?? WRITING_MIN_PAGE_HEIGHT;
    const nextCssHeight = pageHeight * zoom;
    const prevScrollTop = scroller.scrollTop;
    const prevZoom = dedicatedLastZoomRef.current;
    setDedicatedPageCssHeightPx(nextCssHeight);
    dedicatedLastZoomRef.current = zoom;
    if (options?.preservePageScroll && prevZoom != null && Math.abs(prevZoom - zoom) > 1e-6) {
      window.requestAnimationFrame(() => {
        const el = dedicatedScrollerRef.current;
        if (!el)
          return;
        const pad = MENUBAR_HEIGHT_PX;
        const contentScrollTop = Math.max(0, prevScrollTop - pad);
        el.scrollTop = pad + contentScrollTop * (zoom / prevZoom);
      });
    }
  }
  function handleEditorReady(editor) {
    editorRef.current = editor;
    const leafId = props.workspaceLeafId;
    if (props.embedded && props.embedId && leafId) {
      initializeEmbeddedUnifiedUndo(props.plugin, leafId, props.embedId, editor);
      register(props.embedId, editor, editor.getContainerElement(), leafId);
    }
    if (!props.embedded && leafId) {
      registerDedicatedInkEditor(leafId, editor);
    }
    if (editorWrapperRefEl.current) {
      editorWrapperRefEl.current.classList.remove("ddc_ink_editor-wrapper--loading");
    }
    if (props.saveControlsReference) {
      props.saveControlsReference({
        save: () => void completeSave(),
        saveAndHalt: async () => {
          await completeSave();
          unmountActions();
        },
        eraseAll: async () => {
          editor.eraseAll();
          await completeSave();
        },
        setBooxOverlayActive: (isActive) => {
          isViewActiveRef.current = isActive;
          if (!isActive) {
            pendingNewOverlayRef.current = false;
            props.plugin.booxConnection.sendCloseDrawingArea();
          } else {
            activateWritingSessionRef.current?.();
            const sent = newAndroidDrawingArea();
            if (!sent)
              pendingNewOverlayRef.current = true;
          }
        }
      });
    }
    if (getBooxConnectionEnabled() && props.plugin.booxConnection.isConnected()) {
      websocketConnectedRef.current = true;
      setBooxConnected(true);
      setIsBooxInputLocked(true);
      activateWritingSessionRef.current?.();
      newAndroidDrawingArea();
      const editor2 = editorRef.current;
      if (editor2) {
        props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor2));
      }
    }
    if (props.embedded) {
      applyInitialEmbedSizing();
    } else {
      applyPageHeightChange(0, false);
    }
  }
  function getInvitingHeightFromEditor(editor) {
    const lineHeight = writingLineHeightRef.current;
    const bufferLines = props.plugin.settings.writingBufferLines;
    const strokes = editor.getSnapshot().strokes;
    const contentHeight = strokes.length > 0 ? computeApproxContentMaxY(strokes) : 0;
    return cropWritingStrokeHeightInvitingly2(contentHeight, bufferLines, lineHeight);
  }
  function applyInitialEmbedSizing() {
    if (!props.embedded)
      return;
    const tryApply = () => {
      const editor = editorRef.current;
      const resizeContainer = editorWrapperRefEl.current?.closest(".ddc_ink_resize-container");
      if (!editor || !resizeContainer)
        return false;
      if (!resizeContainer.getBoundingClientRect().width)
        return false;
      applyPageHeightChange(0, true);
      return true;
    };
    window.requestAnimationFrame(() => {
      if (tryApply())
        return;
      const resizeContainer = editorWrapperRefEl.current?.closest(".ddc_ink_resize-container");
      if (!resizeContainer)
        return;
      const observer = new ResizeObserver(() => {
        if (tryApply())
          observer.disconnect();
      });
      observer.observe(resizeContainer);
    });
  }
  function unmountActions() {
    resetTimers();
    const leafId = props.workspaceLeafId;
    if (props.embedded && props.embedId) {
      unregister(props.embedId);
    }
    if (!props.embedded && leafId) {
      unregisterDedicatedInkEditor(leafId, editorRef.current);
    }
  }
  function handleStoreChange() {
    queueSaves();
    if (props.embedded) {
      debouncedEmbedResizePostProcess();
    }
  }
  function handleEmbedUndoStackPush() {
    if (props.embedded && props.embedId && props.workspaceLeafId) {
      recordEmbedCanvasActionOnUnifiedStack(props.workspaceLeafId, props.embedId);
    }
  }
  function cancelDelayedBooxResizePostProcess() {
    if (resizePostProcessTimeoutRef.current !== void 0) {
      window.clearTimeout(resizePostProcessTimeoutRef.current);
      resizePostProcessTimeoutRef.current = void 0;
    }
  }
  function debouncedEmbedResizePostProcess() {
    cancelDelayedBooxResizePostProcess();
    resizePostProcessTimeoutRef.current = window.setTimeout(() => {
      resizePostProcessTimeoutRef.current = void 0;
      const editor = editorRef.current;
      if (!editor || !props.embedded)
        return;
      if (websocketConnectedRef.current && getBooxConnectionEnabled())
        return;
      const invitingHeight = getInvitingHeightFromEditor(editor);
      if (!shouldResizeForNewHeight(invitingHeight, curHeightRef.current, props.plugin.settings.writingBufferLines, writingLineHeightRef.current))
        return;
      curHeightRef.current = invitingHeight;
      editor.setWritingPageHeight(invitingHeight);
      notifyEmbedResize(invitingHeight);
    }, WRITE_SHORT_DELAY_MS);
  }
  function handlePageHeightChange(candidateHeightPx) {
    applyPageHeightChange(candidateHeightPx, false);
  }
  function applyPageHeightChange(candidateHeightPx, isInitialMount) {
    const editor = editorRef.current;
    if (!editor)
      return;
    const lineHeight = writingLineHeightRef.current;
    const bufferLines = props.plugin.settings.writingBufferLines;
    const invitingFromContent = getInvitingHeightFromEditor(editor);
    if (props.embedded) {
      const skipAutoResize = !forceNextPageHeightChangeRef.current && websocketConnectedRef.current && getBooxConnectionEnabled();
      forceNextPageHeightChangeRef.current = false;
      if (skipAutoResize)
        return;
      if (isInitialMount) {
        const heightToApply = invitingFromContent;
        curHeightRef.current = heightToApply;
        editor.setWritingPageHeight(heightToApply);
        notifyEmbedResize(heightToApply);
        return;
      }
      const shouldResize = shouldResizeForNewHeight(candidateHeightPx, curHeightRef.current, bufferLines, lineHeight);
      if (!shouldResize)
        return;
      curHeightRef.current = candidateHeightPx;
      editor.setWritingPageHeight(candidateHeightPx);
      notifyEmbedResize(candidateHeightPx);
      return;
    }
    const scroller = dedicatedScrollerRef.current;
    const viewportHeightPx = scroller?.clientHeight ?? 0;
    const scrollTopPx = Math.max(0, (scroller?.scrollTop ?? 0) - MENUBAR_HEIGHT_PX);
    const zoom = Math.max(scroller?.clientWidth ?? 1, 1) / WRITING_PAGE_WIDTH;
    const targetHeight = computeDedicatedWritingPageHeight(scrollTopPx, viewportHeightPx, zoom, invitingFromContent, lineHeight);
    if (targetHeight > editor.getPageHeight()) {
      editor.setWritingPageHeight(targetHeight);
      curHeightRef.current = targetHeight;
      syncDedicatedPageCssHeight({
        pageHeight: targetHeight,
        preservePageScroll: true
      });
    } else if (isInitialMount || dedicatedPageCssHeightPx === null) {
      curHeightRef.current = editor.getPageHeight();
      syncDedicatedPageCssHeight({
        pageHeight: editor.getPageHeight(),
        preservePageScroll: false
      });
    }
  }
  function notifyEmbedResize(pageHeight) {
    if (!props.embedded || !props.onResize)
      return;
    const pw = WRITING_PAGE_WIDTH;
    const invitingBounds = { x: 0, y: 0, w: pw, h: pageHeight };
    const strokes = editorRef.current?.getSnapshot().strokes ?? [];
    const lineHeight = writingLineHeightRef.current;
    const tightHeight = strokes.length > 0 ? cropWritingStrokeHeightTightly2(computeApproxContentMaxY(strokes), lineHeight) : WRITING_MIN_PAGE_HEIGHT;
    const tightBounds = { x: 0, y: 0, w: pw, h: tightHeight };
    if (getBooxConnectionEnabled() && websocketConnectedRef.current) {
      isAndroidDrawingAreaResizingRef.current = true;
    }
    props.onResize(invitingBounds, tightBounds);
    sendAdjustmentImmediate();
  }
  function queueSaves() {
    resetTimers();
    shortDelayTimerRef.current = window.setTimeout(() => {
      void incrementalSave();
    }, WRITE_SHORT_DELAY_MS);
    longDelayTimerRef.current = window.setTimeout(() => {
      void completeSave();
    }, WRITE_LONG_DELAY_MS);
  }
  async function incrementalSave() {
    const editor = editorRef.current;
    if (!editor)
      return;
    verbose("incrementalSave (ink-canvas writing)");
    const snapshot = editor.getSnapshot();
    const svgString = renderWritingStrokesToSvg(snapshot.strokes, snapshot, WRITING_PAGE_WIDTH);
    props.save(buildInkCanvasWritingFileData({ inkCanvasSnapshot: snapshot, svgString }));
  }
  async function completeSave() {
    const editor = editorRef.current;
    if (!editor)
      return;
    verbose("completeSave (ink-canvas writing)");
    const snapshot = editor.getSnapshot();
    const svgString = renderWritingStrokesToSvg(snapshot.strokes, snapshot, WRITING_PAGE_WIDTH);
    props.save(buildInkCanvasWritingFileData({ inkCanvasSnapshot: snapshot, svgString }));
  }
  function resetTimers() {
    cancelDelayedBooxResizePostProcess();
    window.clearTimeout(shortDelayTimerRef.current);
    window.clearTimeout(longDelayTimerRef.current);
  }
  async function fetchFileData() {
    const svg = await props.writingFile.vault.read(props.writingFile);
    const data = extractInkJsonFromSvg(svg);
    if (!data)
      return;
    isLegacyInkFileRef.current = !isInkCanvasFile(data);
    let snapshot;
    if (isInkCanvasFile(data) && data.inkCanvas) {
      snapshot = data.inkCanvas;
    } else {
      const fallbackLineHeight = data.meta.writingLineHeight ?? WRITING_LINE_HEIGHT;
      snapshot = migrateWritingFromTldraw(data.tldraw, fallbackLineHeight);
    }
    writingLineHeightRef.current = snapshot.writingLineHeight ?? WRITING_LINE_HEIGHT;
    setInitialSnapshot(snapshot);
  }
  function getEditor2() {
    return editorRef.current;
  }
  function clampToVisibleViewport(embedRect) {
    const visibleTop = Math.max(0, embedRect.y);
    const visibleBottom = Math.min(window.innerHeight, embedRect.y + embedRect.height);
    const visibleLeft = Math.max(0, embedRect.x);
    const visibleRight = Math.min(window.innerWidth, embedRect.x + embedRect.width);
    return {
      x: Math.round(visibleLeft),
      y: Math.round(visibleTop),
      width: Math.round(Math.max(0, visibleRight - visibleLeft)),
      height: Math.round(Math.max(0, visibleBottom - visibleTop))
    };
  }
  function getBooxWritingSurfaceRects() {
    const wrapper = editorWrapperRefEl.current;
    if (!wrapper)
      return null;
    let raw;
    if (props.embedded) {
      raw = wrapper.getBoundingClientRect();
    } else {
      const editor = editorRef.current;
      const container = editor?.getContainerElement();
      if (container) {
        const containerRect = container.getBoundingClientRect();
        raw = containerRect.width > 1 && containerRect.height > 1 ? containerRect : wrapper.getBoundingClientRect();
      } else {
        raw = wrapper.getBoundingClientRect();
      }
    }
    const visible = clampToVisibleViewport(raw);
    if (visible.width <= 0 || visible.height <= 0) {
      return { raw, clamped: null };
    }
    return {
      raw,
      clamped: new DOMRect(visible.x, visible.y, visible.width, visible.height)
    };
  }
  function getMenuExcludeRects(wrapperEl) {
    const rects = [];
    const menuBarEl = wrapperEl.querySelector(".ink_primary-menu-bar");
    if (menuBarEl) {
      const rect = menuBarEl.getBoundingClientRect();
      if (rect.width > 0 && rect.height > 0) {
        rects.push({ x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) });
      }
    }
    const secondaryBarEl = wrapperEl.querySelector(".ink_secondary-menu-bar");
    if (secondaryBarEl) {
      const rect = secondaryBarEl.getBoundingClientRect();
      if (rect.width > 0 && rect.height > 0) {
        rects.push({ x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) });
      }
    }
    return rects;
  }
  function flushQueuedBooxStrokesAfterResize() {
    const queuedStrokePayloads = queuedBooxStrokePayloadsRef.current;
    queuedBooxStrokePayloadsRef.current = [];
    for (const queuedStrokePayload of queuedStrokePayloads) {
      if (createStrokeFromBoox(queuedStrokePayload) && queuedStrokePayload.strokeId !== void 0) {
        props.plugin.booxConnection.sendStrokeRendered(queuedStrokePayload.strokeId);
      }
    }
  }
  function newAndroidDrawingArea() {
    if (!editorWrapperRefEl.current)
      return false;
    if (!getBooxConnectionEnabled())
      return false;
    const surfaceRects = getBooxWritingSurfaceRects();
    if (!surfaceRects?.clamped) {
      pendingNewOverlayRef.current = true;
      return false;
    }
    const visible = {
      x: Math.round(surfaceRects.clamped.x),
      y: Math.round(surfaceRects.clamped.y),
      width: Math.round(surfaceRects.clamped.width),
      height: Math.round(surfaceRects.clamped.height)
    };
    pendingNewOverlayRef.current = false;
    props.plugin.booxConnection.sendNewDrawingArea({
      x: visible.x,
      y: visible.y,
      canvasWidth: visible.width,
      canvasHeight: visible.height,
      appWidth: window.innerWidth,
      appHeight: window.innerHeight,
      excludeRects: getMenuExcludeRects(editorWrapperRefEl.current)
    });
    return true;
  }
  function repositionBooxOverlayAfterEmbedGeometryChange() {
    restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
    if (!websocketConnectedRef.current || !isViewActiveRef.current)
      return;
    if (!getBooxConnectionEnabled())
      return;
    if (props.embedded) {
      activateWritingSessionRef.current?.();
      const sent = newAndroidDrawingArea();
      if (sent) {
        pendingNewOverlayRef.current = false;
        const editor = editorRef.current;
        if (editor) {
          props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
        }
      } else {
        pendingNewOverlayRef.current = true;
      }
      return;
    }
    sendAdjustment(false);
  }
  function adjustAndroidDrawingAreaThrottled() {
    if (!isViewActiveRef.current)
      return;
    if (adjustThrottleRef.current)
      window.clearTimeout(adjustThrottleRef.current);
    adjustThrottleRef.current = window.setTimeout(() => {
      adjustThrottleRef.current = null;
      repositionBooxOverlayAfterEmbedGeometryChange();
    }, 200);
  }
  function sendAdjustmentImmediate() {
    if (adjustThrottleRef.current)
      window.clearTimeout(adjustThrottleRef.current);
    adjustThrottleRef.current = window.setTimeout(() => {
      adjustThrottleRef.current = null;
      sendAdjustment(true);
    }, 50);
  }
  function sendAdjustment(immediate) {
    if (!editorWrapperRefEl.current)
      return;
    if (!websocketConnectedRef.current)
      return;
    if (!isViewActiveRef.current)
      return;
    if (!getBooxConnectionEnabled())
      return;
    const surfaceRects = getBooxWritingSurfaceRects();
    if (!surfaceRects?.clamped) {
      pendingNewOverlayRef.current = true;
      return;
    }
    const visible = {
      x: Math.round(surfaceRects.clamped.x),
      y: Math.round(surfaceRects.clamped.y),
      width: Math.round(surfaceRects.clamped.width),
      height: Math.round(surfaceRects.clamped.height)
    };
    pendingNewOverlayRef.current = false;
    props.plugin.booxConnection.sendUpdateDrawingArea({
      x: visible.x,
      y: visible.y,
      canvasWidth: visible.width,
      canvasHeight: visible.height,
      appWidth: window.innerWidth,
      appHeight: window.innerHeight,
      immediate,
      excludeRects: getMenuExcludeRects(editorWrapperRefEl.current)
    });
  }
  function getBooxStrokeSizeCssPx(editor) {
    const BOOX_STROKE_SIZE_SCALE = 2;
    const style = editor.getStrokeStyle();
    const zoom = editor.getCamera().zoom;
    return style.size * zoom * BOOX_STROKE_SIZE_SCALE;
  }
  function handleBooxActivateTool(activatedTool) {
    if (!getBooxConnectionEnabled())
      return;
    const isNonDrawTool = activatedTool === "erase" || activatedTool === "select";
    const isBooxConnected = props.plugin.booxConnection.isConnected();
    if (isNonDrawTool && websocketConnectedRef.current) {
      websocketConnectedRef.current = false;
      setBooxConnected(false);
      setIsBooxInputLocked(false);
      pendingNewOverlayRef.current = false;
      if (adjustThrottleRef.current)
        window.clearTimeout(adjustThrottleRef.current);
      props.plugin.booxConnection.sendCloseDrawingArea();
    } else if (activatedTool === "draw" && !websocketConnectedRef.current) {
      if (isBooxConnected) {
        websocketConnectedRef.current = true;
        setBooxConnected(true);
        setIsBooxInputLocked(true);
        activateWritingSessionRef.current?.();
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const editor = editorRef.current;
          if (editor) {
            props.plugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
        } else {
          pendingNewOverlayRef.current = true;
        }
      } else {
        void props.plugin.booxConnection.ensureConnected().catch((error2) => {
          verbose(["BooxConnection: reconnect from writing draw tool failed", error2]);
        });
      }
    }
  }
  function createStrokeFromBoox(strokePayload) {
    const payload = Array.isArray(strokePayload) ? { points: strokePayload } : strokePayload;
    const canvasRelativePoints = payload.points ?? [];
    if (!editorWrapperRefEl.current)
      return false;
    const editor = editorRef.current;
    if (!editor)
      return false;
    const surfaceRects = getBooxWritingSurfaceRects();
    if (!surfaceRects?.clamped)
      return false;
    const surfaceRect = surfaceRects.clamped;
    const sourceCanvasWidth = payload.canvasWidth && payload.canvasWidth > 0 ? payload.canvasWidth : surfaceRect.width;
    const sourceCanvasHeight = payload.canvasHeight && payload.canvasHeight > 0 ? payload.canvasHeight : surfaceRect.height;
    if (sourceCanvasWidth <= 0 || sourceCanvasHeight <= 0)
      return false;
    const inkPoints = canvasRelativePoints.map((pt) => {
      const sx = surfaceRect.left + pt.x / sourceCanvasWidth * surfaceRect.width;
      const sy = surfaceRect.top + pt.y / sourceCanvasHeight * surfaceRect.height;
      const page = editor.screenToPage(sx, sy);
      return [
        page.x,
        page.y,
        normalizeBooxPenPressureForCapture(pt.pressure)
      ];
    });
    const stroke = {
      id: crypto.randomUUID(),
      authoringSource: "boox",
      points: inkPoints,
      style: {
        ...buildInkStrokeStyleForTreatAs(editor.getStrokeStyle(), "pen", editor.getCamera().zoom),
        simulatePressure: false
      },
      offset: { x: 0, y: 0 },
      ...inkStrokeTimestampsFromBooxPoints(canvasRelativePoints)
    };
    editor.addStroke(stroke);
    return true;
  }
  function expandWritingLinesByOne() {
    const editor = editorRef.current;
    if (!editor)
      return;
    const lineHeight = writingLineHeightRef.current;
    const bufferLines = props.plugin.settings.writingBufferLines;
    const newHeight = editor.getPageHeight() + bufferLines * lineHeight;
    forceNextPageHeightChangeRef.current = true;
    curHeightRef.current = newHeight;
    editor.setWritingPageHeight(newHeight);
    notifyEmbedResize(newHeight);
  }
  if (!initialSnapshot)
    return /* @__PURE__ */ React101.createElement(React101.Fragment, null);
  const canvas = /* @__PURE__ */ React101.createElement(InkSvgCanvas, {
    initialSnapshot,
    writingMode: true,
    pageWidth: WRITING_PAGE_WIDTH,
    writingBufferLines: props.plugin.settings.writingBufferLines,
    onEditorReady: handleEditorReady,
    onChange: handleStoreChange,
    onEmbedUndoStackPush: handleEmbedUndoStackPush,
    onPageHeightChange: handlePageHeightChange,
    isEmbedded: props.embedded,
    isBooxInputLocked,
    isFingerDrawingActive,
    blockObsidianPenGestures: true,
    onBooxEmbedGeometryChange: isBooxInputLocked ? repositionBooxOverlayAfterEmbedGeometryChange : void 0
  });
  return /* @__PURE__ */ React101.createElement(React101.Fragment, null, /* @__PURE__ */ React101.createElement("div", {
    ref: editorWrapperRefEl,
    className: (0, import_classnames37.default)([
      "ddc_ink_writing-editor",
      "ddc_ink_editor-wrapper--loading",
      !props.embedded && "ddc_ink_dedicated-editor",
      dominantHand === "left" && "ink_dominant-hand_left",
      isBooxConnectionEnabled && "ddc_ink_boox-eink"
    ]),
    style: { height: "100%", position: "relative" },
    tabIndex: props.embedded ? void 0 : 0,
    onKeyDownCapture: (e2) => {
      if (props.embedded)
        return;
      const editor = editorRef.current;
      if (!editor)
        return;
      const modKey = e2.metaKey || e2.ctrlKey;
      const key = (e2.key ?? "").toLowerCase();
      if (modKey && !e2.shiftKey && key === "z") {
        e2.preventDefault();
        editor.undo();
        return;
      }
      if (modKey && (e2.shiftKey && key === "z" || key === "y")) {
        e2.preventDefault();
        editor.redo();
      }
    }
  }, props.embedded ? canvas : /* @__PURE__ */ React101.createElement("div", {
    ref: dedicatedScrollerRef,
    className: "ddc_ink_writing-dedicated-scroller"
  }, /* @__PURE__ */ React101.createElement("div", {
    ref: dedicatedPageRef,
    className: "ddc_ink_writing-dedicated-page",
    style: {
      height: dedicatedPageCssHeightPx ?? "100%",
      paddingTop: MENUBAR_HEIGHT_PX,
      boxSizing: "content-box"
    }
  }, canvas)), /* @__PURE__ */ React101.createElement(PrimaryMenuBar, null, /* @__PURE__ */ React101.createElement(InkCanvasDrawingMenu, {
    getEditor: getEditor2,
    onStoreChange: handleStoreChange,
    onActivateTool: handleBooxActivateTool,
    onExpandClick: props.embedded ? props.onOpenInDedicatedView : void 0,
    showFingerDrawingToggle: isFingerDrawingGloballyEnabled,
    isFingerDrawingActive,
    onFingerDrawingToggle: () => setIsFingerDrawingActive((active) => !active),
    embedId: props.embedded && props.embedId ? props.embedId : void 0,
    workspaceLeafId: props.embedded && props.workspaceLeafId ? props.workspaceLeafId : void 0,
    plugin: props.embedded ? props.plugin : void 0
  }), props.embedded && props.extendedMenu && /* @__PURE__ */ React101.createElement(extended_writing_menu_default, {
    onLockClick: () => props.closeEditor?.(),
    menuOptions: props.extendedMenu
  }), !props.embedded && props.extendedMenu && /* @__PURE__ */ React101.createElement(extended_writing_menu_default, {
    menuOptions: props.extendedMenu
  })), /* @__PURE__ */ React101.createElement(SecondaryMenuBar, null, /* @__PURE__ */ React101.createElement(InkCanvasModifyMenu, {
    getEditor: getEditor2,
    onStoreChange: handleStoreChange,
    embedId: props.embedded && props.embedId ? props.embedId : void 0,
    workspaceLeafId: props.embedded && props.workspaceLeafId ? props.workspaceLeafId : void 0,
    plugin: props.embedded ? props.plugin : void 0
  }), props.embedded && booxConnected && /* @__PURE__ */ React101.createElement(ExpandLinesButton, {
    onExpandLines: expandWritingLinesByOne
  }))));
}
var React101, import_react133, import_classnames37, import_obsidian21, WritingEditorWrapper;
var init_writing_editor = __esm({
  "src/components/formats/current/writing/writing-editor/writing-editor.tsx"() {
    init_9();
    React101 = __toESM(require_react());
    import_react133 = __toESM(require_react());
    init_esm();
    import_classnames37 = __toESM(require_classnames());
    init_build_file_data();
    init_ink_file_storage_engine();
    init_constants();
    init_primary_menu_bar();
    init_ink_canvas_drawing_menu();
    init_extended_writing_menu();
    init_secondary_menu_bar();
    init_ink_canvas_modify_menu();
    init_expand_lines_button();
    init_universal_dev_logging();
    init_log_to_vault();
    init_device_settings();
    init_use_boox_connection_enabled();
    init_use_finger_drawing_enabled();
    init_restore_embed_cm_scroller_scroll();
    init_extractInkJsonFromSvg();
    init_writing_embed();
    init_dedicated_ink_editor_registry();
    init_ink_editor_registry();
    init_embedded_unified_undo();
    init_ink_svg_canvas();
    init_svg_export();
    init_stroke_viewport_culling();
    init_migrate_from_tldraw();
    init_tldraw_helpers();
    init_legacy_ink_notice();
    init_dominant_hand_store();
    import_obsidian21 = require("obsidian");
    init_universal_dev_logging();
    init_pen_input();
    init_stroke_presets();
    init_stroke_timestamps();
    WritingEditorWrapper = (props) => {
      const embedsInEditMode = useAtomValue(embedsInEditModeAtom);
      const editorActive = !!props.embedId && embedsInEditMode.has(props.embedId);
      if (editorActive)
        return /* @__PURE__ */ React101.createElement(WritingEditor, {
          ...props
        });
      return /* @__PURE__ */ React101.createElement(React101.Fragment, null);
    };
  }
});

// src/logic/utils/inline-svg-preview.ts
function embedPreviewClassForFileType(fileType) {
  return fileType === "inkWriting" ? WRITING_EMBED_PREVIEW_CLASS : DRAWING_EMBED_PREVIEW_CLASS;
}
function mountInlineSvgPreview(host, svgString) {
  host.replaceChildren();
  const trimmed = svgString.trim();
  if (!trimmed.startsWith("<"))
    return false;
  const doc = new DOMParser().parseFromString(trimmed, "image/svg+xml");
  const parseError = doc.querySelector("parsererror");
  if (parseError)
    return false;
  const svg = doc.documentElement;
  if (svg.tagName.toLowerCase() !== "svg")
    return false;
  svg.setAttribute("width", "100%");
  svg.setAttribute("height", "100%");
  host.appendChild(host.ownerDocument.importNode(svg, true));
  return true;
}
var WRITING_EMBED_PREVIEW_CLASS, DRAWING_EMBED_PREVIEW_CLASS;
var init_inline_svg_preview = __esm({
  "src/logic/utils/inline-svg-preview.ts"() {
    WRITING_EMBED_PREVIEW_CLASS = "ddc_ink_writing-embed-preview";
    DRAWING_EMBED_PREVIEW_CLASS = "ddc_ink_drawing-embed-preview";
  }
});

// src/logic/utils/svg-edit-button.scss
var init_19 = __esm({
  "src/logic/utils/svg-edit-button.scss"() {
  }
});

// src/logic/utils/addEditButtonToSvgView.ts
function suppressNativeSvgFlash(leaf) {
  leaf.view?.containerEl?.classList.add(AWAITING_THEME_CLASS);
}
function releaseNativeSvgFlashSuppression(leaf) {
  leaf.view?.containerEl?.classList.remove(AWAITING_THEME_CLASS);
}
async function ensureThemedNativeInkSvgView(plugin, leaf, file) {
  if (!file || file.extension !== "svg" || !leaf)
    return;
  const currentViewType = leaf.view?.getViewType?.();
  if (currentViewType === INK_WRITING_VIEW_TYPE2 || currentViewType === INK_DRAWING_VIEW_TYPE2) {
    return;
  }
  const leafId = leaf.id ?? "";
  const inFlightKey = `${leafId}:${file.path}`;
  if (themingInFlightByLeafFileKey.has(inFlightKey))
    return;
  themingInFlightByLeafFileKey.add(inFlightKey);
  const finishEnsure = () => {
    themingInFlightByLeafFileKey.delete(inFlightKey);
  };
  suppressNativeSvgFlash(leaf);
  try {
    const svgString = await plugin.app.vault.read(file);
    if (!svgString || !svgString.trim().startsWith("<svg")) {
      releaseNativeSvgFlashSuppression(leaf);
      finishEnsure();
      return;
    }
    const viewTypeAfterRead = leaf.view?.getViewType?.();
    if (viewTypeAfterRead === INK_WRITING_VIEW_TYPE2 || viewTypeAfterRead === INK_DRAWING_VIEW_TYPE2) {
      releaseNativeSvgFlashSuppression(leaf);
      finishEnsure();
      return;
    }
    const inkFileData = extractInkJsonFromSvg(svgString);
    if (!inkFileData) {
      releaseNativeSvgFlashSuppression(leaf);
      finishEnsure();
      return;
    }
    if (inkFileData.meta.fileType === "inkWriting") {
      addEditButtonToSvgView(plugin, leaf, file, INK_WRITING_VIEW_TYPE2, svgString, "inkWriting", finishEnsure);
      return;
    }
    if (inkFileData.meta.fileType === "inkDrawing") {
      addEditButtonToSvgView(plugin, leaf, file, INK_DRAWING_VIEW_TYPE2, svgString, "inkDrawing", finishEnsure);
      return;
    }
    releaseNativeSvgFlashSuppression(leaf);
    finishEnsure();
  } catch {
    releaseNativeSvgFlashSuppression(leaf);
    finishEnsure();
  }
}
function addEditButtonToSvgView(plugin, leaf, file, viewType, svgString, fileType, onSettled) {
  scheduleNativeSvgChrome(leaf, (viewContent, containerEl) => {
    if (containerEl.querySelector(".ddc_ink_svg-edit-button")) {
      releaseNativeSvgFlashSuppression(leaf);
      onSettled();
      return;
    }
    const computedStyle = window.getComputedStyle(viewContent);
    if (computedStyle.position === "static") {
      viewContent.classList.add("ddc_ink_svg-view-content--anchor");
    }
    const didMountPreview = mountThemedNativeViewPreview(viewContent, svgString, fileType);
    if (!didMountPreview) {
      releaseNativeSvgFlashSuppression(leaf);
      onSettled();
      return;
    }
    const buttonContainer = activeDocument.createElement("div");
    buttonContainer.className = "ddc_ink_svg-edit-button-container";
    const isDrawing = viewType.includes("drawing");
    const buttonText = isDrawing ? "Edit drawing" : "Edit writing";
    const editButton = activeDocument.createElement("button");
    editButton.className = "ddc_ink_btn-slim ddc_ink_svg-edit-button";
    editButton.textContent = buttonText;
    editButton.title = `Edit ${isDrawing ? "drawing" : "writing"} in custom view`;
    editButton.addEventListener("click", (e2) => {
      e2.stopPropagation();
      e2.preventDefault();
      void leaf.setViewState({
        type: viewType,
        state: { file: file.path },
        active: true
      });
    });
    buttonContainer.appendChild(editButton);
    viewContent.appendChild(buttonContainer);
    releaseNativeSvgFlashSuppression(leaf);
    onSettled();
    const cleanup = () => {
      const existingButton = containerEl.querySelector(".ddc_ink_svg-edit-button-container");
      if (existingButton) {
        existingButton.remove();
      }
      const existingPreview = containerEl.querySelector(`.${THEMED_PREVIEW_HOST_CLASS}`);
      if (existingPreview) {
        existingPreview.remove();
      }
      containerEl.querySelectorAll(".ddc_ink_svg-native-media--hidden").forEach((el) => {
        el.classList.remove("ddc_ink_svg-native-media--hidden");
      });
      containerEl.classList.remove(AWAITING_THEME_CLASS);
    };
    plugin.registerEvent(plugin.app.workspace.on("file-open", () => {
      const currentView = leaf.view;
      if (currentView instanceof import_obsidian22.FileView && currentView.file !== file) {
        cleanup();
      }
    }));
  }, () => {
    releaseNativeSvgFlashSuppression(leaf);
    onSettled();
  });
}
function scheduleNativeSvgChrome(leaf, onReady, onGiveUp) {
  let attempts = 0;
  const tryMount = () => {
    const view = leaf.view;
    const containerEl = view?.containerEl;
    if (!containerEl)
      return false;
    const viewContent = containerEl.querySelector(".view-content") || containerEl.querySelector(".markdown-source-view") || containerEl;
    onReady(viewContent, containerEl);
    return true;
  };
  if (tryMount())
    return;
  const tick3 = () => {
    attempts += 1;
    if (tryMount())
      return;
    if (attempts >= MAX_MOUNT_ATTEMPTS) {
      onGiveUp();
      return;
    }
    window.requestAnimationFrame(tick3);
  };
  window.requestAnimationFrame(tick3);
}
function mountThemedNativeViewPreview(viewContent, svgString, fileType) {
  if (viewContent.querySelector(`.${THEMED_PREVIEW_HOST_CLASS}`))
    return true;
  const nativeMedia = viewContent.querySelectorAll("img, object, embed");
  nativeMedia.forEach((el) => {
    el.classList.add("ddc_ink_svg-native-media--hidden");
  });
  const previewHost = activeDocument.createElement("div");
  previewHost.className = `${THEMED_PREVIEW_HOST_CLASS} ${embedPreviewClassForFileType(fileType)}`;
  if (!mountInlineSvgPreview(previewHost, svgString)) {
    nativeMedia.forEach((el) => {
      el.classList.remove("ddc_ink_svg-native-media--hidden");
    });
    return false;
  }
  viewContent.appendChild(previewHost);
  return true;
}
var import_obsidian22, THEMED_PREVIEW_HOST_CLASS, AWAITING_THEME_CLASS, MAX_MOUNT_ATTEMPTS, INK_WRITING_VIEW_TYPE2, INK_DRAWING_VIEW_TYPE2, themingInFlightByLeafFileKey;
var init_addEditButtonToSvgView = __esm({
  "src/logic/utils/addEditButtonToSvgView.ts"() {
    import_obsidian22 = require("obsidian");
    init_extractInkJsonFromSvg();
    init_inline_svg_preview();
    init_19();
    THEMED_PREVIEW_HOST_CLASS = "ddc_ink_svg-native-view-preview";
    AWAITING_THEME_CLASS = "ddc_ink_svg-view--awaiting-theme";
    MAX_MOUNT_ATTEMPTS = 30;
    INK_WRITING_VIEW_TYPE2 = "ink_writing-view";
    INK_DRAWING_VIEW_TYPE2 = "ink_drawing-view";
    themingInFlightByLeafFileKey = /* @__PURE__ */ new Set();
  }
});

// src/components/formats/current/writing/writing-view/writing-view.tsx
function registerWritingView(plugin) {
  plugin.registerView(WRITING_VIEW_TYPE, (leaf) => new WritingView(leaf, plugin));
  plugin.registerEvent(plugin.app.workspace.on("file-open", async (file) => {
    if (!file)
      return;
    const targetLeaf = plugin.app.workspace.getMostRecentLeaf();
    if (targetLeaf) {
      await ensureThemedNativeInkSvgView(plugin, targetLeaf, file);
    }
  }));
  plugin.registerEvent(plugin.app.workspace.on("active-leaf-change", async (leaf) => {
    if (!leaf)
      return;
    const view = leaf.view;
    if (view instanceof import_obsidian23.FileView && view.file) {
      await ensureThemedNativeInkSvgView(plugin, leaf, view.file);
    }
  }));
}
var import_obsidian23, React102, import_client2, WRITING_VIEW_TYPE, WritingView;
var init_writing_view = __esm({
  "src/components/formats/current/writing/writing-view/writing-view.tsx"() {
    import_obsidian23 = require("obsidian");
    React102 = __toESM(require_react());
    import_client2 = __toESM(require_client());
    init_8();
    init_writing_editor();
    init_buildFileStr();
    init_extractInkJsonFromSvg();
    init_addEditButtonToSvgView();
    init_open_file();
    init_file_conversion_modal();
    init_confirmation_modal();
    init_build_embeds();
    init_copy_embed_to_clipboard();
    init_writing_embed_aspect_ratio();
    WRITING_VIEW_TYPE = "ink_writing-view";
    WritingView = class extends import_obsidian23.TextFileView {
      constructor(leaf, plugin) {
        super(leaf);
        this.editorControls = null;
        this.tldrawControls = {};
        this.leafChangeListenerRegistered = false;
        this.getDisplayText = () => {
          return this.file?.basename || "Handwritten note";
        };
        this.setViewData = (fileContents, clear) => {
          if (!this.file)
            return;
          const inkFileData = extractInkJsonFromSvg(fileContents);
          if (inkFileData) {
            this.inkFileData = inkFileData;
          }
          const viewContent = this.containerEl.children[1];
          viewContent.setAttr("style", "padding: 0;");
          if (this.root)
            this.clear();
          const host = viewContent.ownerDocument.createElement("div");
          host.className = "ink-writing-view-host";
          viewContent.appendChild(host);
          this.hostEl = host;
          this.root = (0, import_client2.createRoot)(host);
          this.root.render(/* @__PURE__ */ React102.createElement(WritingEditor, {
            plugin: this.plugin,
            workspaceLeafId: this.leaf.id,
            writingFile: this.file,
            save: this.saveFile,
            saveControlsReference: this.registerEditorControls,
            extendedMenu: this.buildExtendedMenu()
          }));
          if (!this.leafChangeListenerRegistered) {
            this.leafChangeListenerRegistered = true;
            this.registerEvent(this.plugin.app.workspace.on("active-leaf-change", (leaf) => {
              const isThisLeafActive = leaf === this.leaf;
              const isThisViewStillInLeaf = this.leaf?.view?.getViewType?.() === WRITING_VIEW_TYPE;
              this.editorControls?.setBooxOverlayActive?.(isThisLeafActive && isThisViewStillInLeaf);
            }));
          }
        };
        this.saveFile = (inkFileData) => {
          this.inkFileData = inkFileData;
          void this.save(false);
        };
        this.registerEditorControls = (controls) => {
          this.editorControls = controls;
          this.tldrawControls.resize = controls.resize;
        };
        this.getViewData = () => {
          return buildFileStr(this.inkFileData);
        };
        this.clear = () => {
          this.editorControls = null;
          try {
            if (this.root)
              this.root.unmount();
          } catch {
          }
          this.root = null;
          if (this.hostEl && this.hostEl.isConnected) {
            try {
              this.hostEl.remove();
            } catch {
            }
          }
          this.hostEl = null;
        };
        this.onResize = () => {
        };
        this.plugin = plugin;
        this.hostEl = null;
      }
      getViewType() {
        return WRITING_VIEW_TYPE;
      }
      buildExtendedMenu() {
        return [
          { separator: true },
          {
            text: "Copy embed",
            action: () => {
              if (!this.file)
                return;
              void (async () => {
                if (!this.file)
                  return;
                const aspectRatio = await readWritingFileAspectRatio(this.plugin, this.file);
                const embedStr = buildWritingEmbedLine(this.file.path, aspectRatio != null ? { aspectRatio } : void 0);
                void copyEmbedMarkdownToClipboard(embedStr);
              })();
            }
          },
          {
            text: "Convert to Drawing",
            action: () => {
              if (!this.file)
                return;
              new FileConversionModal(this.plugin, this.file, "inkDrawing", {
                onConversionComplete: (finalFile) => {
                  if (finalFile)
                    void openInkFileInView(finalFile, "inkDrawing");
                }
              }).open();
            }
          },
          { separator: true },
          {
            text: "Erase all",
            warning: true,
            action: () => {
              new ConfirmationModal({
                plugin: this.plugin,
                title: "Erase all strokes?",
                message: "This will remove all strokes from the canvas.",
                confirmLabel: "Erase all",
                confirmAction: () => {
                  void this.editorControls?.eraseAll?.();
                }
              }).open();
            }
          }
        ];
      }
      async onClose() {
        if (this.editorControls) {
          await this.editorControls.saveAndHalt();
        }
        this.clear();
        restoreSidebarsAfterInkView();
        return await super.onClose();
      }
    };
  }
});

// src/components/formats/current/drawing/drawing-view/drawing-view.scss
var init_20 = __esm({
  "src/components/formats/current/drawing/drawing-view/drawing-view.scss"() {
  }
});

// src/components/formats/current/drawing/drawing-editor/drawing-editor.scss
var init_21 = __esm({
  "src/components/formats/current/drawing/drawing-editor/drawing-editor.scss"() {
  }
});

// src/graphics/icons/lock-frame-icon.tsx
var React103, LockFrameIcon;
var init_lock_frame_icon = __esm({
  "src/graphics/icons/lock-frame-icon.tsx"() {
    React103 = __toESM(require_react());
    LockFrameIcon = (props) => /* @__PURE__ */ React103.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: 24,
      viewBox: "1.5 1.5 21 21",
      width: 24,
      fill: "currentColor",
      ...props
    }, /* @__PURE__ */ React103.createElement("path", {
      fillRule: "evenodd",
      clipRule: "evenodd",
      d: "M16.459314346313477,1.8955078125C16.459314346313477,1.40093994140625,16.860254287719727,1,17.354822158813477,1C20.472558975219727,1,23.000024795532227,3.5274658203125,23.000024795532227,6.64520263671875C23.000024795532227,7.13983154296875,22.599084854125977,7.540771484375,22.104455947875977,7.540771484375C21.609888076782227,7.540771484375,21.208948135375977,7.13983154296875,21.208948135375977,6.64520263671875C21.208948135375977,4.5166015625,19.483362197875977,2.79107666015625,17.354822158813477,2.79107666015625C16.860254287719727,2.79107666015625,16.459314346313477,2.39013671875,16.459314346313477,1.8955078125Z"
    }), /* @__PURE__ */ React103.createElement("path", {
      fillRule: "evenodd",
      clipRule: "evenodd",
      d: "M7.540795803070068,22.1044921875C7.540795803070068,22.59906005859375,7.139855861663818,23,6.645226955413818,23C3.5274291038513184,23,1.000024437904358,20.47259521484375,1.000024437904358,17.354736328125C1.000024437904358,16.86016845703125,1.400964379310608,16.459228515625,1.895532250404358,16.459228515625C2.3901000022888184,16.459228515625,2.7910399436950684,16.86016845703125,2.7910399436950684,17.354736328125C2.7910399436950684,19.4833984375,4.516625881195068,21.20892333984375,6.645226955413818,21.20892333984375C7.139855861663818,21.20892333984375,7.540795803070068,21.60986328125,7.540795803070068,22.1044921875Z"
    }), /* @__PURE__ */ React103.createElement("path", {
      fillRule: "evenodd",
      clipRule: "evenodd",
      d: "M22.104455947875977,16.459228515625C22.599084854125977,16.459228515625,23.000024795532227,16.86016845703125,23.000024795532227,17.354736328125C23.000024795532227,20.47259521484375,20.472558975219727,23,17.354822158813477,23C16.860254287719727,23,16.459314346313477,22.59906005859375,16.459314346313477,22.1044921875C16.459314346313477,21.60986328125,16.860254287719727,21.20892333984375,17.354822158813477,21.20892333984375C19.483362197875977,21.20892333984375,21.208948135375977,19.4833984375,21.208948135375977,17.354736328125C21.208948135375977,16.86016845703125,21.609888076782227,16.459228515625,22.104455947875977,16.459228515625Z"
    }), /* @__PURE__ */ React103.createElement("path", {
      fillRule: "evenodd",
      clipRule: "evenodd",
      d: "M1.895532250404358,7.540771484375C1.400903344154358,7.540771484375,0.9999634027481079,7.13983154296875,0.9999634027481079,6.64520263671875C0.9999634027481079,3.5274658203125,3.5274291038513184,1,6.645226955413818,1C7.139794826507568,1,7.540734767913818,1.40093994140625,7.540734767913818,1.8955078125C7.540734767913818,2.39013671875,7.139794826507568,2.79107666015625,6.645226955413818,2.79107666015625C4.516625881195068,2.79107666015625,2.7910399436950684,4.5166015625,2.7910399436950684,6.64520263671875C2.7910399436950684,7.13983154296875,2.3901000022888184,7.540771484375,1.895532250404358,7.540771484375Z"
    }), /* @__PURE__ */ React103.createElement("path", {
      d: "M7.750024318695068,18.6826171875C7.360436916351318,18.6826171875,7.026940822601318,18.54388427734375,6.749413967132568,18.26641845703125C6.472070217132568,17.989013671875,6.333337306976318,17.655517578125,6.333337306976318,17.265869140625L6.333337306976318,10.1826171875C6.333337306976318,9.79296875,6.472070217132568,9.45947265625,6.749413967132568,9.18206787109375C7.026940822601318,8.90460205078125,7.360436916351318,8.765869140625,7.750024318695068,8.765869140625L8.458337783813477,8.765869140625L8.458337783813477,7.3492431640625C8.458337783813477,6.36932373046875,8.803613662719727,5.5341796875,9.494287490844727,4.843505859375C10.184900283813477,4.15289306640625,11.020105361938477,3.8076171875,12.000024795532227,3.8076171875C12.979883193969727,3.8076171875,13.815088272094727,4.15289306640625,14.505701065063477,4.843505859375C15.196374893188477,5.5341796875,15.541650772094727,6.36932373046875,15.541650772094727,7.3492431640625L15.541650772094727,8.765869140625L16.250024795532227,8.765869140625C16.639551162719727,8.765869140625,16.973047256469727,8.90460205078125,17.250574111938477,9.18206787109375C17.527917861938477,9.45947265625,17.666650772094727,9.79296875,17.666650772094727,10.1826171875L17.666650772094727,17.265869140625C17.666650772094727,17.655517578125,17.527917861938477,17.989013671875,17.250574111938477,18.26641845703125C16.973047256469727,18.54388427734375,16.639551162719727,18.6826171875,16.250024795532227,18.6826171875L7.750024318695068,18.6826171875ZM7.750024318695068,17.265869140625L16.250024795532227,17.265869140625L16.250024795532227,10.1826171875L7.750024318695068,10.1826171875L7.750024318695068,17.265869140625ZM13.000574111938477,14.72479248046875C13.277917861938477,14.447265625,13.416650772094727,14.11383056640625,13.416650772094727,13.7242431640625C13.416650772094727,13.33465576171875,13.277917861938477,13.001220703125,13.000574111938477,12.72369384765625C12.723047256469727,12.44635009765625,12.389551162719727,12.3076171875,12.000024795532227,12.3076171875C11.610437393188477,12.3076171875,11.276941299438477,12.44635009765625,10.999414443969727,12.72369384765625C10.722070693969727,13.001220703125,10.583337783813477,13.33465576171875,10.583337783813477,13.7242431640625C10.583337783813477,14.11383056640625,10.722070693969727,14.447265625,10.999414443969727,14.72479248046875C11.276941299438477,15.00213623046875,11.610437393188477,15.140869140625,12.000024795532227,15.140869140625C12.389551162719727,15.140869140625,12.723047256469727,15.00213623046875,13.000574111938477,14.72479248046875ZM9.875024795532227,8.765869140625L14.125024795532227,8.765869140625L14.125024795532227,7.3492431640625C14.125024795532227,6.759033203125,13.918359756469727,6.2572021484375,13.505212783813477,5.843994140625C13.092004776000977,5.430908203125,12.590234756469727,5.2242431640625,12.000024795532227,5.2242431640625C11.409753799438477,5.2242431640625,10.907983779907227,5.430908203125,10.494775772094727,5.843994140625C10.081628799438477,6.2572021484375,9.875024795532227,6.759033203125,9.875024795532227,7.3492431640625L9.875024795532227,8.765869140625Z"
    }));
  }
});

// src/components/jsx-components/extended-drawing-menu/extended-drawing-menu.scss
var init_22 = __esm({
  "src/components/jsx-components/extended-drawing-menu/extended-drawing-menu.scss"() {
  }
});

// src/components/jsx-components/extended-drawing-menu/extended-drawing-menu.tsx
var React104, ExtendedDrawingMenu, extended_drawing_menu_default;
var init_extended_drawing_menu = __esm({
  "src/components/jsx-components/extended-drawing-menu/extended-drawing-menu.tsx"() {
    init_lock_icon();
    init_lock_frame_icon();
    init_22();
    React104 = __toESM(require_react());
    init_overflow_menu();
    init_tooltip_button();
    ExtendedDrawingMenu = (props) => {
      const showSaveCamera = props.isSaveCameraEnabled === true;
      return /* @__PURE__ */ React104.createElement(React104.Fragment, null, /* @__PURE__ */ React104.createElement("div", {
        className: "ink_extended-writing-menu"
      }, (showSaveCamera || props.onLockClick) && /* @__PURE__ */ React104.createElement("div", {
        className: "ddc_ink_btn-group ddc_ink_btn-group--lock"
      }, props.onLockClick && /* @__PURE__ */ React104.createElement(TooltipButton, {
        tooltip: showSaveCamera ? "Abandon framing" : "Lock",
        className: "ddc_ink_btn-group__btn",
        onClick: () => props.onLockClick?.()
      }, /* @__PURE__ */ React104.createElement(LockIcon, null)), showSaveCamera && props.onSaveCameraClick && /* @__PURE__ */ React104.createElement(TooltipButton, {
        tooltip: "Save framing",
        className: "ddc_ink_btn-group__btn ddc_ink_btn-group__btn--accent",
        onClick: () => props.onSaveCameraClick?.()
      }, /* @__PURE__ */ React104.createElement(LockFrameIcon, null))), /* @__PURE__ */ React104.createElement(overflow_menu_default, {
        menuOptions: props.menuOptions
      })));
    };
    extended_drawing_menu_default = ExtendedDrawingMenu;
  }
});

// src/components/jsx-components/resize-handle/resize-handle.scss
var init_23 = __esm({
  "src/components/jsx-components/resize-handle/resize-handle.scss"() {
  }
});

// src/graphics/icons/resize-diagonal-icon.tsx
var React105, ResizeDiagonalIcon;
var init_resize_diagonal_icon = __esm({
  "src/graphics/icons/resize-diagonal-icon.tsx"() {
    React105 = __toESM(require_react());
    ResizeDiagonalIcon = (props) => /* @__PURE__ */ React105.createElement("svg", {
      xmlns: "http://www.w3.org/2000/svg",
      height: "1em",
      viewBox: "0 0 24 24",
      width: "1em",
      ...props
    }, /* @__PURE__ */ React105.createElement("path", {
      d: "M19.071 12.414a1 1 0 0 1 1 1v5.657a1 1 0 0 1-1 1h-5.657a1 1 0 0 1 0-2h4.657v-4.657a1 1 0 0 1 1-1ZM3.929 4.929a1 1 0 0 1 1-1h5.657a1 1 0 0 1 0 2H5.929v4.657a1 1 0 0 1-2 0V4.929Z"
    }), /* @__PURE__ */ React105.createElement("path", {
      d: "M4.222 4.222a.999.999 0 0 1 1.414 0l14.142 14.142a.999.999 0 1 1-1.414 1.414L4.222 5.636a.999.999 0 0 1 0-1.414Z"
    }));
  }
});

// src/components/jsx-components/resize-handle/resize-handle.tsx
function getHorzResizeDiff(movementX, dominantHand) {
  const sign = dominantHand === "left" ? -1 : 1;
  return movementX * 2 * sign;
}
var import_classnames38, React106, ResizeHandle;
var init_resize_handle = __esm({
  "src/components/jsx-components/resize-handle/resize-handle.tsx"() {
    init_23();
    import_classnames38 = __toESM(require_classnames());
    React106 = __toESM(require_react());
    init_resize_diagonal_icon();
    init_dominant_hand_store();
    ResizeHandle = (props) => {
      const dominantHand = useDominantHand();
      const lastPointerXPosition = React106.useRef();
      const lastPointerYPosition = React106.useRef();
      return /* @__PURE__ */ React106.createElement("button", {
        className: (0, import_classnames38.default)([
          "ddc_ink_resize-handle",
          dominantHand === "left" && "ddc_ink_resize-handle--left"
        ]),
        onPointerDown: startResizing
      }, /* @__PURE__ */ React106.createElement(ResizeDiagonalIcon, null));
      function startResizing(e2) {
        props.onResizeStart?.();
        activeDocument.addEventListener("mousemove", handleMouseResizing);
        activeDocument.addEventListener("mouseup", stopResizing);
        activeDocument.addEventListener("touchmove", handleTouchResizing, { passive: false });
        activeDocument.addEventListener("touchend", stopResizing);
      }
      function stopResizing(e2) {
        activeDocument.removeEventListener("mousemove", handleMouseResizing);
        activeDocument.removeEventListener("mouseup", stopResizing);
        activeDocument.removeEventListener("touchmove", handleTouchResizing);
        activeDocument.removeEventListener("touchend", stopResizing);
        delete lastPointerXPosition.current;
        delete lastPointerYPosition.current;
        props.onResizeEnd?.();
      }
      function handleMouseResizing(e2) {
        const horzDiff = getHorzResizeDiff(e2.movementX, dominantHand);
        const vertDiff = e2.movementY;
        props.resizeEmbed(horzDiff, vertDiff);
      }
      function handleTouchResizing(e2) {
        e2.preventDefault();
        e2.stopPropagation();
        const touchPointer = e2.changedTouches.item(0);
        if (!touchPointer || e2.changedTouches.length !== 1)
          return;
        if (lastPointerXPosition.current != null && lastPointerYPosition.current != null) {
          const horzDiff = getHorzResizeDiff(touchPointer.pageX - lastPointerXPosition.current, dominantHand);
          const vertDiff = touchPointer.pageY - lastPointerYPosition.current;
          props.resizeEmbed(horzDiff, vertDiff);
        }
        lastPointerXPosition.current = touchPointer.pageX;
        lastPointerYPosition.current = touchPointer.pageY;
      }
    };
  }
});

// src/components/formats/current/drawing/drawing-editor/drawing-editor.tsx
function DrawingEditor(props) {
  const dominantHand = useDominantHand();
  const isBooxConnectionEnabled = useBooxConnectionEnabled();
  const isFingerDrawingGloballyEnabled = useFingerDrawingEnabled();
  const [isFingerDrawingActive, setIsFingerDrawingActive] = React107.useState(false);
  const [initialSnapshot, setInitialSnapshot] = React107.useState();
  const shortDelayTimerRef = (0, import_react134.useRef)();
  const longDelayTimerRef = (0, import_react134.useRef)();
  const editorRef = (0, import_react134.useRef)();
  const editorWrapperRefEl = (0, import_react134.useRef)(null);
  const websocketConnectedRef = (0, import_react134.useRef)(false);
  const [isBooxInputLocked, setIsBooxInputLocked] = React107.useState(false);
  const activateDrawingSessionRef = (0, import_react134.useRef)(null);
  const adjustThrottleRef = (0, import_react134.useRef)(null);
  const setBooxOverlayActiveTimerRef = (0, import_react134.useRef)(null);
  const isViewActiveRef = (0, import_react134.useRef)(true);
  const pendingNewOverlayRef = (0, import_react134.useRef)(false);
  const [, setCameraTick] = React107.useState(0);
  const hasUserMovedCameraRef = (0, import_react134.useRef)(false);
  const isLegacyInkFileRef = (0, import_react134.useRef)(false);
  React107.useEffect(() => {
    verbose("INK CANVAS EDITOR mounted");
    logToVault("Ink canvas editor mounted: " + props.drawingFile.path + (props.embedded ? " [embed]" : " [dedicated]"));
    void fetchFileData();
    return () => {
      verbose("INK CANVAS EDITOR unmounting");
      logToVault("Ink canvas editor unmounted: " + props.drawingFile.path);
    };
  }, []);
  React107.useEffect(() => {
    if (!isFingerDrawingGloballyEnabled)
      setIsFingerDrawingActive(false);
  }, [isFingerDrawingGloballyEnabled]);
  React107.useEffect(() => {
    if (!initialSnapshot || !isLegacyInkFileRef.current)
      return;
    showLegacyInkUnlockNotice({
      plugin: getGlobals().plugin,
      legacyFile: props.drawingFile,
      isEmbedded: props.embedded
    });
  }, [initialSnapshot]);
  React107.useEffect(() => {
    return () => {
      resetTimers();
    };
  }, []);
  React107.useEffect(() => {
    if (!initialSnapshot)
      return;
    const inkPlugin = getGlobals().plugin;
    if (!getBooxConnectionEnabled())
      return;
    const { unregister: unregister2, activate } = inkPlugin.booxConnection.registerDrawingSession({
      onStroke: (strokeData) => {
        const payload = strokeData;
        const points = payload.points ?? strokeData;
        if (createStrokeFromBoox(points, payload) && payload.strokeId !== void 0) {
          inkPlugin.booxConnection.sendStrokeRendered(payload.strokeId);
        }
      },
      onSocketOpen: () => {
        websocketConnectedRef.current = true;
        setIsBooxInputLocked(true);
        debug("Ink canvas: Connected to Boox companion app WebSocket");
        new import_obsidian24.Notice("Connected to Boox companion app");
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const editor = editorRef.current;
          if (editor) {
            inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
        } else {
          pendingNewOverlayRef.current = true;
        }
      },
      onReactivate: () => {
        if (!websocketConnectedRef.current)
          return;
        if (setBooxOverlayActiveTimerRef.current)
          window.clearTimeout(setBooxOverlayActiveTimerRef.current);
        setBooxOverlayActiveTimerRef.current = window.setTimeout(() => {
          setBooxOverlayActiveTimerRef.current = null;
          if (!websocketConnectedRef.current)
            return;
          activateDrawingSessionRef.current?.();
          const sent = newAndroidDrawingArea();
          if (sent) {
            pendingNewOverlayRef.current = false;
            const editor = editorRef.current;
            if (editor)
              inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          } else {
            pendingNewOverlayRef.current = true;
          }
        }, 0);
      }
    });
    activateDrawingSessionRef.current = activate;
    return () => {
      websocketConnectedRef.current = false;
      setIsBooxInputLocked(false);
      pendingNewOverlayRef.current = false;
      if (adjustThrottleRef.current)
        window.clearTimeout(adjustThrottleRef.current);
      if (setBooxOverlayActiveTimerRef.current)
        window.clearTimeout(setBooxOverlayActiveTimerRef.current);
      activateDrawingSessionRef.current = null;
      unregister2();
    };
  }, [initialSnapshot]);
  React107.useEffect(() => {
    if (!initialSnapshot)
      return;
    if (!editorWrapperRefEl.current)
      return;
    if (!getBooxConnectionEnabled())
      return;
    const scrollEl = editorWrapperRefEl.current.closest(".cm-scroller");
    if (!scrollEl)
      return;
    const onScroll = () => {
      if (!isViewActiveRef.current)
        return;
      restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
      adjustAndroidDrawingAreaThrottled();
    };
    scrollEl.addEventListener("scroll", onScroll, { passive: true });
    const visualViewport = typeof window !== "undefined" ? window.visualViewport : null;
    const onVisualViewportChange = () => {
      if (!isViewActiveRef.current)
        return;
      restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
      adjustAndroidDrawingAreaThrottled();
    };
    visualViewport?.addEventListener("scroll", onVisualViewportChange);
    visualViewport?.addEventListener("resize", onVisualViewportChange);
    return () => {
      scrollEl.removeEventListener("scroll", onScroll);
      visualViewport?.removeEventListener("scroll", onVisualViewportChange);
      visualViewport?.removeEventListener("resize", onVisualViewportChange);
    };
  }, [initialSnapshot]);
  React107.useEffect(() => {
    if (!initialSnapshot)
      return;
    if (!editorWrapperRefEl.current)
      return;
    const resizeObserver = new ResizeObserver(() => {
      if (pendingNewOverlayRef.current && isViewActiveRef.current && websocketConnectedRef.current) {
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const inkPlugin = getGlobals().plugin;
          const editor = editorRef.current;
          if (editor) {
            inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
          return;
        }
        return;
      }
      if (websocketConnectedRef.current && isViewActiveRef.current) {
        adjustAndroidDrawingAreaThrottled();
      }
    });
    resizeObserver.observe(editorWrapperRefEl.current);
    return () => resizeObserver.disconnect();
  }, [initialSnapshot]);
  function handleEditorReady(editor) {
    editorRef.current = editor;
    const leafId = props.workspaceLeafId;
    if (props.embedded && props.embedId && leafId) {
      initializeEmbeddedUnifiedUndo(getGlobals().plugin, leafId, props.embedId, editor);
      register(props.embedId, editor, editor.getContainerElement(), leafId, props.applyEmbedDimensions);
    }
    if (!props.embedded && leafId) {
      registerDedicatedInkEditor(leafId, editor);
    }
    if (editorWrapperRefEl.current) {
      editorWrapperRefEl.current.classList.remove("ddc_ink_editor-wrapper--loading");
    }
    if (props.saveControlsReference) {
      props.saveControlsReference({
        save: () => completeSave(),
        saveAndHalt: async () => {
          await completeSave();
          unmountActions();
        },
        eraseAll: async () => {
          editor.eraseAll();
          await completeSave();
        },
        setBooxOverlayActive: (isActive) => {
          isViewActiveRef.current = isActive;
          if (isActive && websocketConnectedRef.current) {
            activateDrawingSessionRef.current?.();
            const sent = newAndroidDrawingArea();
            if (!sent)
              pendingNewOverlayRef.current = true;
          } else if (!isActive) {
            pendingNewOverlayRef.current = false;
            const inkPlugin2 = getGlobals().plugin;
            if (getBooxConnectionEnabled()) {
              inkPlugin2.booxConnection.sendCloseDrawingArea();
            }
          }
        }
      });
    }
    const inkPlugin = getGlobals().plugin;
    if (getBooxConnectionEnabled() && inkPlugin.booxConnection.isConnected()) {
      websocketConnectedRef.current = true;
      setIsBooxInputLocked(true);
      activateDrawingSessionRef.current?.();
      newAndroidDrawingArea();
      const editor2 = editorRef.current;
      if (editor2) {
        inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor2));
      }
    }
    if (props.onReady)
      props.onReady();
  }
  function unmountActions() {
    resetTimers();
    const leafId = props.workspaceLeafId;
    if (props.embedded && props.embedId) {
      unregister(props.embedId);
    }
    if (!props.embedded && leafId) {
      unregisterDedicatedInkEditor(leafId, editorRef.current);
    }
  }
  function handleStoreChange() {
    queueSaves();
  }
  function handleEmbedUndoStackPush() {
    if (props.embedded && props.embedId && props.workspaceLeafId) {
      recordEmbedCanvasActionOnUnifiedStack(props.workspaceLeafId, props.embedId);
    }
  }
  function queueSaves() {
    resetTimers();
    shortDelayTimerRef.current = window.setTimeout(() => {
      void incrementalSave();
    }, DRAW_SHORT_DELAY_MS);
    longDelayTimerRef.current = window.setTimeout(() => {
      void completeSave();
    }, DRAW_LONG_DELAY_MS);
  }
  async function incrementalSave() {
    const editor = editorRef.current;
    if (!editor)
      return;
    verbose("incrementalSave (ink-canvas)");
    logToVault("incrementalSave (ink-canvas drawing): " + props.drawingFile.path);
    const snapshot = editor.getSnapshot();
    const svgString = renderStrokesToSvg(snapshot.strokes, snapshot);
    const fileData = buildInkCanvasDrawingFileData({
      inkCanvasSnapshot: snapshot,
      svgString
    });
    props.save(fileData);
  }
  async function completeSave() {
    const editor = editorRef.current;
    if (!editor)
      return;
    verbose("completeSave (ink-canvas)");
    logToVault("completeSave (ink-canvas drawing): " + props.drawingFile.path);
    const snapshot = editor.getSnapshot();
    const svgString = renderStrokesToSvg(snapshot.strokes, snapshot);
    const fileData = buildInkCanvasDrawingFileData({
      inkCanvasSnapshot: snapshot,
      svgString
    });
    props.save(fileData);
  }
  function resetTimers() {
    window.clearTimeout(shortDelayTimerRef.current);
    window.clearTimeout(longDelayTimerRef.current);
  }
  async function fetchFileData() {
    const svg = await props.drawingFile.vault.read(props.drawingFile);
    if (!svg) {
      logToVault("Drawing file unreadable: " + props.drawingFile.path);
      return;
    }
    const inkFileData = extractInkJsonFromSvg(svg);
    if (!inkFileData) {
      logToVault("Drawing file has no ink JSON: " + props.drawingFile.path);
      return;
    }
    isLegacyInkFileRef.current = !isInkCanvasFile(inkFileData);
    if (isInkCanvasFile(inkFileData) && inkFileData.inkCanvas) {
      setInitialSnapshot(inkFileData.inkCanvas);
      return;
    }
    const migrated = migrateFromTldraw(inkFileData.tldraw);
    setInitialSnapshot(migrated);
  }
  function getEditor2() {
    return editorRef.current;
  }
  function computeCurrentViewBox() {
    const editor = editorRef.current;
    if (!editor)
      return null;
    const container = editor.getContainerElement();
    if (!container)
      return null;
    const rect = container.getBoundingClientRect();
    if (rect.width <= 0 || rect.height <= 0)
      return null;
    const camera = editor.getCamera();
    return {
      x: -camera.x,
      y: -camera.y,
      width: rect.width / camera.zoom,
      height: rect.height / camera.zoom
    };
  }
  function isViewBoxDirty() {
    if (!props.embedded)
      return false;
    if (!props.embedSettings)
      return false;
    const vb = computeCurrentViewBox();
    if (!vb)
      return false;
    const saved = props.embedSettings.viewBox;
    const EPS = 0.75;
    const dx = Math.abs(vb.x - saved.x);
    const dy = Math.abs(vb.y - saved.y);
    const dw = Math.abs(vb.width - saved.width);
    const dh = Math.abs(vb.height - saved.height);
    const dirty = dx > EPS || dy > EPS || dw > EPS || dh > EPS;
    return dirty;
  }
  function handleSaveCameraPosition() {
    const vb = computeCurrentViewBox();
    if (!vb)
      return;
    props.onSaveCameraPosition?.(vb);
  }
  const customExtendedMenu = [
    {
      text: "Grid on/off",
      action: () => {
        const editor = getEditor2();
        if (editor)
          editor.setGridEnabled(!editor.isGridEnabled());
      }
    },
    ...props.extendedMenu || []
  ];
  function resizeEmbed(pxWidthDiff, pxHeightDiff) {
    if (props.resizeEmbed)
      props.resizeEmbed(pxWidthDiff, pxHeightDiff);
  }
  function onResizeEnd() {
    props.onResizeEnd?.();
    if (props.embedded) {
      hasUserMovedCameraRef.current = true;
      setCameraTick((n2) => n2 + 1);
      props.onEmbedResizeEnd?.();
    }
  }
  function computeClampDrawingSurfaceOverlay(surfaceRect) {
    const innerW = window.innerWidth;
    const innerH = window.innerHeight;
    const visibleTop = Math.max(0, surfaceRect.y);
    const visibleBottom = Math.min(innerH, surfaceRect.y + surfaceRect.height);
    const visibleLeft = Math.max(0, surfaceRect.x);
    const visibleRight = Math.min(innerW, surfaceRect.x + surfaceRect.width);
    const width = Math.round(Math.max(0, visibleRight - visibleLeft));
    const height = Math.round(Math.max(0, visibleBottom - visibleTop));
    return new DOMRect(Math.round(visibleLeft), Math.round(visibleTop), width, height);
  }
  function getBooxDrawingSurfaceRects() {
    const wrapper = editorWrapperRefEl.current;
    if (!wrapper)
      return null;
    let raw;
    if (props.embedded) {
      raw = wrapper.getBoundingClientRect();
    } else {
      const editor = editorRef.current;
      const container = editor?.getContainerElement();
      if (container) {
        const cr = container.getBoundingClientRect();
        raw = cr.width > 1 && cr.height > 1 ? cr : wrapper.getBoundingClientRect();
      } else {
        raw = wrapper.getBoundingClientRect();
      }
    }
    const clamped = computeClampDrawingSurfaceOverlay(raw);
    if (clamped.width <= 0 || clamped.height <= 0) {
      return { raw, clamped: null };
    }
    return { raw, clamped };
  }
  function getBooxClientAreaRect() {
    return getBooxDrawingSurfaceRects()?.clamped ?? null;
  }
  function buildBooxDrawingAreaPayload() {
    const surfaceRect = getBooxClientAreaRect();
    if (!surfaceRect)
      return null;
    const canvasWidth = Math.round(surfaceRect.width);
    const canvasHeight = Math.round(surfaceRect.height);
    if (canvasWidth === 0 || canvasHeight === 0)
      return null;
    return {
      x: Math.round(surfaceRect.x),
      y: Math.round(surfaceRect.y),
      canvasWidth,
      canvasHeight,
      appWidth: window.innerWidth,
      appHeight: window.innerHeight
    };
  }
  function newAndroidDrawingArea() {
    if (!editorWrapperRefEl.current)
      return false;
    const inkPlugin = getGlobals().plugin;
    if (!getBooxConnectionEnabled())
      return false;
    const payload = buildBooxDrawingAreaPayload();
    if (!payload)
      return false;
    inkPlugin.booxConnection.sendNewDrawingArea(payload);
    return true;
  }
  function repositionBooxOverlayAfterEmbedGeometryChange() {
    restoreEmbedCmScrollerScroll(editorWrapperRefEl.current);
    if (!websocketConnectedRef.current || !isViewActiveRef.current)
      return;
    const inkPlugin = getGlobals().plugin;
    if (!getBooxConnectionEnabled())
      return;
    if (props.embedded) {
      activateDrawingSessionRef.current?.();
      const sent = newAndroidDrawingArea();
      if (sent) {
        pendingNewOverlayRef.current = false;
        const editor = editorRef.current;
        if (editor) {
          inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
        }
      } else {
        pendingNewOverlayRef.current = true;
      }
      return;
    }
    sendAdjustment(false);
  }
  function adjustAndroidDrawingAreaThrottled() {
    if (adjustThrottleRef.current)
      window.clearTimeout(adjustThrottleRef.current);
    adjustThrottleRef.current = window.setTimeout(() => {
      adjustThrottleRef.current = null;
      repositionBooxOverlayAfterEmbedGeometryChange();
    }, 200);
  }
  function sendAdjustment(immediate) {
    if (!editorWrapperRefEl.current)
      return;
    if (!websocketConnectedRef.current)
      return;
    if (!isViewActiveRef.current)
      return;
    const inkPlugin = getGlobals().plugin;
    if (!getBooxConnectionEnabled())
      return;
    const payload = buildBooxDrawingAreaPayload();
    if (!payload)
      return;
    inkPlugin.booxConnection.sendUpdateDrawingArea({
      ...payload,
      immediate
    });
  }
  function getBooxStrokeSizeCssPx(editor) {
    const BOOX_STROKE_SIZE_SCALE = 2;
    const style = editor.getStrokeStyle();
    const zoom = editor.getCamera().zoom;
    return style.size * zoom * BOOX_STROKE_SIZE_SCALE;
  }
  function handleBooxActivateTool(activatedTool) {
    const inkPlugin = getGlobals().plugin;
    if (!getBooxConnectionEnabled())
      return;
    const isNonDrawTool = activatedTool === "erase" || activatedTool === "select";
    const isBooxConnected = inkPlugin.booxConnection.isConnected();
    if (isNonDrawTool && websocketConnectedRef.current) {
      websocketConnectedRef.current = false;
      setIsBooxInputLocked(false);
      pendingNewOverlayRef.current = false;
      if (adjustThrottleRef.current)
        window.clearTimeout(adjustThrottleRef.current);
      inkPlugin.booxConnection.sendCloseDrawingArea();
    } else if (activatedTool === "draw" && !websocketConnectedRef.current) {
      if (isBooxConnected) {
        websocketConnectedRef.current = true;
        setIsBooxInputLocked(true);
        activateDrawingSessionRef.current?.();
        const sent = newAndroidDrawingArea();
        if (sent) {
          pendingNewOverlayRef.current = false;
          const editor = editorRef.current;
          if (editor) {
            inkPlugin.booxConnection.sendUpdateTool("draw", getBooxStrokeSizeCssPx(editor));
          }
        } else {
          pendingNewOverlayRef.current = true;
        }
      } else {
        void inkPlugin.booxConnection.ensureConnected().catch((error2) => {
          verbose(["BooxConnection: reconnect from drawing draw tool failed", error2]);
        });
      }
    }
  }
  function createStrokeFromBoox(canvasRelativePoints, booxMeta) {
    if (!editorWrapperRefEl.current)
      return false;
    const editor = editorRef.current;
    if (!editor)
      return false;
    const surfaceTriple = getBooxDrawingSurfaceRects();
    if (!surfaceTriple?.clamped)
      return false;
    const surfaceRect = surfaceTriple.clamped;
    const payloadCw = booxMeta?.canvasWidth;
    const payloadCh = booxMeta?.canvasHeight;
    const sourceCanvasWidth = payloadCw && payloadCw > 0 ? payloadCw : surfaceRect.width;
    const sourceCanvasHeight = payloadCh && payloadCh > 0 ? payloadCh : surfaceRect.height;
    if (sourceCanvasWidth <= 0 || sourceCanvasHeight <= 0)
      return false;
    const inkPoints = canvasRelativePoints.map((pt) => {
      const sx = surfaceRect.left + pt.x / sourceCanvasWidth * surfaceRect.width;
      const sy = surfaceRect.top + pt.y / sourceCanvasHeight * surfaceRect.height;
      const page = editor.screenToPage(sx, sy);
      return [page.x, page.y, normalizeBooxPenPressureForCapture(pt.pressure)];
    });
    const strokeId = `boox-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
    const stroke = {
      id: strokeId,
      authoringSource: "boox",
      points: inkPoints,
      style: {
        ...buildInkStrokeStyleForTreatAs(editor.getStrokeStyle(), "pen", editor.getCamera().zoom),
        simulatePressure: false
      },
      offset: { x: 0, y: 0 },
      ...inkStrokeTimestampsFromBooxPoints(canvasRelativePoints)
    };
    editor.addStroke(stroke);
    return true;
  }
  if (!initialSnapshot)
    return /* @__PURE__ */ React107.createElement(React107.Fragment, null);
  return /* @__PURE__ */ React107.createElement(React107.Fragment, null, /* @__PURE__ */ React107.createElement("div", {
    ref: editorWrapperRefEl,
    className: (0, import_classnames39.default)([
      "ddc_ink_drawing-editor",
      "ddc_ink_editor-wrapper--loading",
      !props.embedded && "ddc_ink_dedicated-editor",
      dominantHand === "left" && "ink_dominant-hand_left",
      isBooxConnectionEnabled && "ddc_ink_boox-eink"
    ]),
    style: { height: "100%", position: "relative" },
    tabIndex: props.embedded ? void 0 : 0
  }, /* @__PURE__ */ React107.createElement(InkSvgCanvas, {
    initialSnapshot,
    onEditorReady: handleEditorReady,
    onChange: handleStoreChange,
    onEmbedUndoStackPush: handleEmbedUndoStackPush,
    onCameraChange: (camera, containerRect, meta) => {
      if (meta.source === "user")
        hasUserMovedCameraRef.current = true;
      setCameraTick((n2) => n2 + 1);
    },
    initialViewBox: props.embedded ? props.embedSettings?.viewBox : void 0,
    writingAlignedZoom: !!props.embedded && !!props.embedSettings && isWritingAlignedDrawingEmbed(props.embedSettings),
    isEmbedded: props.embedded,
    isBooxInputLocked,
    isFingerDrawingActive,
    blockObsidianPenGestures: !!props.embedded || isBooxInputLocked,
    onBooxEmbedGeometryChange: props.embedded && isBooxInputLocked ? repositionBooxOverlayAfterEmbedGeometryChange : void 0
  }), /* @__PURE__ */ React107.createElement(PrimaryMenuBar, null, /* @__PURE__ */ React107.createElement(InkCanvasDrawingMenu, {
    getEditor: getEditor2,
    onStoreChange: handleStoreChange,
    onActivateTool: handleBooxActivateTool,
    onExpandClick: props.embedded ? () => props.onOpenInDedicatedView?.() : void 0,
    showFingerDrawingToggle: isFingerDrawingGloballyEnabled,
    isFingerDrawingActive,
    onFingerDrawingToggle: () => setIsFingerDrawingActive((active) => !active),
    embedId: props.embedId,
    workspaceLeafId: props.workspaceLeafId,
    plugin: getGlobals().plugin
  }), props.embedded && /* @__PURE__ */ React107.createElement(extended_drawing_menu_default, {
    onSaveCameraClick: handleSaveCameraPosition,
    isSaveCameraEnabled: hasUserMovedCameraRef.current && isViewBoxDirty(),
    onLockClick: () => props.closeEditor?.(),
    menuOptions: customExtendedMenu
  }), !props.embedded && /* @__PURE__ */ React107.createElement(extended_drawing_menu_default, {
    menuOptions: customExtendedMenu
  })), /* @__PURE__ */ React107.createElement(SecondaryMenuBar, null, /* @__PURE__ */ React107.createElement(InkCanvasModifyMenu, {
    getEditor: getEditor2,
    onStoreChange: handleStoreChange,
    embedId: props.embedded && props.embedId ? props.embedId : void 0,
    workspaceLeafId: props.embedded && props.workspaceLeafId ? props.workspaceLeafId : void 0,
    plugin: props.embedded ? getGlobals().plugin : void 0
  })), props.resizeEmbed && /* @__PURE__ */ React107.createElement(ResizeHandle, {
    resizeEmbed,
    onResizeStart: props.onResizeStart,
    onResizeEnd
  })));
}
var React107, import_react134, import_classnames39, import_obsidian24, DrawingEditorWrapper;
var init_drawing_editor = __esm({
  "src/components/formats/current/drawing/drawing-editor/drawing-editor.tsx"() {
    init_21();
    React107 = __toESM(require_react());
    import_react134 = __toESM(require_react());
    init_esm();
    import_classnames39 = __toESM(require_classnames());
    init_build_file_data();
    init_ink_file_storage_engine();
    init_constants();
    init_primary_menu_bar();
    init_ink_canvas_drawing_menu();
    init_extended_drawing_menu();
    init_secondary_menu_bar();
    init_ink_canvas_modify_menu();
    init_resize_handle();
    init_universal_dev_logging();
    init_log_to_vault();
    init_device_settings();
    init_use_boox_connection_enabled();
    init_use_finger_drawing_enabled();
    init_restore_embed_cm_scroller_scroll();
    init_global_store();
    init_extractInkJsonFromSvg();
    init_drawing_embed();
    init_dedicated_ink_editor_registry();
    init_ink_editor_registry();
    init_embedded_unified_undo();
    init_ink_svg_canvas();
    init_svg_export();
    init_migrate_from_tldraw();
    init_dominant_hand_store();
    import_obsidian24 = require("obsidian");
    init_universal_dev_logging();
    init_pen_input();
    init_stroke_presets();
    init_stroke_timestamps();
    init_embed_settings();
    init_legacy_ink_notice();
    DrawingEditorWrapper = (props) => {
      const embedsInEditMode = useAtomValue(embedsInEditModeAtom_v2);
      const editorActive = !!props.embedId && embedsInEditMode.has(props.embedId);
      if (editorActive)
        return /* @__PURE__ */ React107.createElement(DrawingEditor, {
          ...props
        });
      return /* @__PURE__ */ React107.createElement(React107.Fragment, null);
    };
  }
});

// src/components/formats/current/drawing/drawing-view/drawing-view.tsx
function getExtendedOptions(plugin, fileRef) {
  return [
    { separator: true },
    {
      text: "Copy embed",
      action: () => {
        if (!fileRef)
          return;
        void (async () => {
          const embedSettings = await buildDrawingEmbedSettingsFromFile(plugin, fileRef);
          const embedStr = buildDrawingEmbedLine(fileRef.path, { embedSettings });
          void copyEmbedMarkdownToClipboard(embedStr);
        })();
      }
    },
    {
      text: "Convert to Writing",
      action: () => {
        if (!fileRef)
          return;
        new FileConversionModal(plugin, fileRef, "inkWriting", {
          onConversionComplete: (finalFile) => {
            if (finalFile)
              void openInkFileInView(finalFile, "inkWriting");
          }
        }).open();
      }
    }
  ];
}
function registerDrawingView(plugin) {
  plugin.registerView(DRAWING_VIEW_TYPE, (leaf) => new DrawingView(leaf, plugin));
  plugin.registerEvent(plugin.app.workspace.on("file-open", async (file) => {
    if (!file)
      return;
    const targetLeaf = plugin.app.workspace.getMostRecentLeaf();
    if (targetLeaf) {
      await ensureThemedNativeInkSvgView(plugin, targetLeaf, file);
    }
  }));
  plugin.registerEvent(plugin.app.workspace.on("active-leaf-change", async (leaf) => {
    if (!leaf)
      return;
    const view = leaf.view;
    if (view instanceof import_obsidian25.FileView && view.file) {
      await ensureThemedNativeInkSvgView(plugin, leaf, view.file);
    }
  }));
}
var import_obsidian25, React108, import_client3, DRAWING_VIEW_TYPE, DrawingView;
var init_drawing_view = __esm({
  "src/components/formats/current/drawing/drawing-view/drawing-view.tsx"() {
    import_obsidian25 = require("obsidian");
    React108 = __toESM(require_react());
    import_client3 = __toESM(require_client());
    init_20();
    init_esm();
    init_buildFileStr();
    init_extractInkJsonFromSvg();
    init_addEditButtonToSvgView();
    init_open_file();
    init_file_conversion_modal();
    init_confirmation_modal();
    init_drawing_editor();
    init_build_embeds();
    init_build_drawing_embed_settings_from_file();
    init_copy_embed_to_clipboard();
    DRAWING_VIEW_TYPE = "ink_drawing-view";
    DrawingView = class extends import_obsidian25.TextFileView {
      constructor(leaf, plugin) {
        super(leaf);
        this.editorControls = null;
        this.leafChangeListenerRegistered = false;
        this.getDisplayText = () => {
          return this.file?.basename || "Drawing";
        };
        this.setViewData = (fileContents, clear) => {
          if (!this.file)
            return;
          const inkFileData = extractInkJsonFromSvg(fileContents);
          if (inkFileData) {
            this.inkFileData = inkFileData;
          }
          const viewContent = this.containerEl.children[1];
          viewContent.setAttr("style", "padding: 0;");
          if (this.root)
            this.clear();
          const host = viewContent.ownerDocument.createElement("div");
          host.className = "ink-drawing-view-host";
          viewContent.appendChild(host);
          this.hostEl = host;
          this.root = (0, import_client3.createRoot)(host);
          const editorElement = /* @__PURE__ */ React108.createElement(DrawingEditor, {
            onReady: () => {
            },
            workspaceLeafId: this.leaf.id,
            drawingFile: this.file,
            save: this.saveFile,
            extendedMenu: [
              ...getExtendedOptions(this.plugin, this.file),
              { separator: true },
              {
                text: "Erase all",
                warning: true,
                action: () => {
                  new ConfirmationModal({
                    plugin: this.plugin,
                    title: "Erase all strokes?",
                    message: "This will remove all strokes from the canvas.",
                    confirmLabel: "Erase all",
                    confirmAction: () => void this.editorControls?.eraseAll?.()
                  }).open();
                }
              }
            ],
            saveControlsReference: this.registerEditorControls
          });
          this.root.render(/* @__PURE__ */ React108.createElement(Provider, null, editorElement));
          if (!this.leafChangeListenerRegistered) {
            this.leafChangeListenerRegistered = true;
            this.registerEvent(this.plugin.app.workspace.on("active-leaf-change", (leaf) => {
              const isThisLeafActive = leaf === this.leaf;
              const isThisViewStillInLeaf = this.leaf?.view?.getViewType?.() === DRAWING_VIEW_TYPE;
              this.editorControls?.setBooxOverlayActive?.(isThisLeafActive && isThisViewStillInLeaf);
            }));
          }
        };
        this.saveFile = (inkFileData) => {
          this.inkFileData = inkFileData;
          void this.save(false);
        };
        this.getViewData = () => {
          return buildFileStr(this.inkFileData);
        };
        this.clear = () => {
          this.editorControls = null;
          try {
            if (this.root)
              this.root.unmount();
          } catch (_error) {
          }
          this.root = null;
          if (this.hostEl && this.hostEl.isConnected) {
            try {
              this.hostEl.remove();
            } catch (_error) {
            }
          }
          this.hostEl = null;
        };
        this.registerEditorControls = (controls) => {
          this.editorControls = controls;
        };
        this.plugin = plugin;
        this.hostEl = null;
      }
      getViewType() {
        return DRAWING_VIEW_TYPE;
      }
      async onClose() {
        if (this.root && this.editorControls) {
          await this.editorControls.saveAndHalt();
        }
        this.clear();
        restoreSidebarsAfterInkView();
        return await super.onClose();
      }
    };
  }
});

// src/logic/utils/open-file.ts
async function openInkFile(fileRef) {
  await openInActiveView(fileRef);
}
async function openInActiveView(fileRef) {
  const { workspace } = getGlobals().plugin.app;
  const leaf = workspace.getLeaf();
  await leaf.openFile(fileRef);
}
async function openInkFileInView(fileRef, viewType) {
  const plugin = getGlobals().plugin;
  const { workspace } = plugin.app;
  const leaf = workspace.getLeaf();
  const type = viewType === "inkDrawing" ? DRAWING_VIEW_TYPE : WRITING_VIEW_TYPE;
  const inkViewAlreadyOpen = [
    ...workspace.getLeavesOfType(DRAWING_VIEW_TYPE),
    ...workspace.getLeavesOfType(WRITING_VIEW_TYPE)
  ].length > 0;
  await leaf.setViewState({
    type,
    state: { file: fileRef.path },
    active: true
  });
  if (!inkViewAlreadyOpen) {
    plugin.inkViewSidebarState = {
      leftWasCollapsed: workspace.leftSplit.collapsed,
      rightWasCollapsed: workspace.rightSplit.collapsed
    };
    workspace.leftSplit.collapse();
    workspace.rightSplit.collapse();
  }
}
function restoreSidebarsAfterInkView() {
  const plugin = getGlobals().plugin;
  const { workspace } = plugin.app;
  window.setTimeout(() => {
    const remainingInkLeaves = [
      ...workspace.getLeavesOfType(DRAWING_VIEW_TYPE),
      ...workspace.getLeavesOfType(WRITING_VIEW_TYPE)
    ];
    if (remainingInkLeaves.length > 0)
      return;
    const state = plugin.inkViewSidebarState;
    if (!state)
      return;
    if (!state.leftWasCollapsed)
      workspace.leftSplit.expand();
    if (!state.rightWasCollapsed)
      workspace.rightSplit.expand();
    plugin.inkViewSidebarState = null;
  }, 0);
}
var init_open_file = __esm({
  "src/logic/utils/open-file.ts"() {
    init_global_store();
    init_writing_view();
    init_drawing_view();
  }
});

// src/components/formats/current/drawing/drawing-embed-preview/drawing-embed-preview.scss
var init_24 = __esm({
  "src/components/formats/current/drawing/drawing-embed-preview/drawing-embed-preview.scss"() {
  }
});

// src/components/formats/current/drawing/drawing-embed-preview/drawing-embed-preview.tsx
var import_classnames40, React109, DrawingEmbedPreviewWrapper, DrawingEmbedPreview;
var init_drawing_embed_preview = __esm({
  "src/components/formats/current/drawing/drawing-embed-preview/drawing-embed-preview.tsx"() {
    import_classnames40 = __toESM(require_classnames());
    init_24();
    React109 = __toESM(require_react());
    init_dist33();
    init_esm();
    init_drawing_embed();
    init_universal_dev_logging();
    init_ink_file_has_strokes();
    init_use_ink_file_has_strokes();
    init_global_store();
    DrawingEmbedPreviewWrapper = (props) => {
      const embedsInEditMode = useAtomValue(embedsInEditModeAtom_v2);
      const previewActive = !props.embedId || !embedsInEditMode.has(props.embedId);
      if (previewActive) {
        return /* @__PURE__ */ React109.createElement(DrawingEmbedPreview, {
          ...props
        });
      } else {
        return /* @__PURE__ */ React109.createElement(React109.Fragment, null);
      }
    };
    DrawingEmbedPreview = (props) => {
      const { plugin } = getGlobals();
      const containerElRef = React109.useRef(null);
      const [fileSrc, setFileSrc] = React109.useState(null);
      const hasStrokes = useInkFileHasStrokes(props.embeddedFile, plugin.app.vault);
      React109.useEffect(() => {
        verbose("PREVIEW mounted");
        refreshSrc();
        const onModify = (modifiedFile) => {
          if (!props.embeddedFile)
            return;
          if (modifiedFile.path !== props.embeddedFile.path)
            return;
          refreshSrc();
        };
        const eventRef = plugin.app.vault.on("modify", onModify);
        return () => {
          verbose("PREVIEW unmounting");
          plugin.app.vault.offref(eventRef);
        };
      }, [props.embeddedFile]);
      return /* @__PURE__ */ React109.createElement(React109.Fragment, null, /* @__PURE__ */ React109.createElement("div", {
        ref: containerElRef,
        className: (0, import_classnames40.default)([
          "ddc_ink_drawing-embed-preview",
          showLockedChrome(plugin.settings.drawingFrameWhenLocked, hasStrokes) && "ddc_ink_visible-frame",
          showLockedChrome(plugin.settings.drawingBackgroundWhenLocked, hasStrokes) && "ddc_ink_visible-background"
        ]),
        style: {
          position: "absolute",
          width: "100%",
          height: "100%",
          pointerEvents: "all"
        },
        onClick: props.onClick
      }, fileSrc && /* @__PURE__ */ React109.createElement(React109.Fragment, null, /* @__PURE__ */ React109.createElement(InlineSVG, {
        src: fileSrc,
        style: {
          width: "100%",
          height: "100%",
          maxWidth: "100%",
          maxHeight: "100%",
          cursor: "pointer"
        },
        pointerEvents: "visible",
        cacheRequests: false,
        key: fileSrc,
        onLoad,
        viewBox: props.embedSettings?.viewBox ? `${props.embedSettings.viewBox.x} ${props.embedSettings.viewBox.y} ${props.embedSettings.viewBox.width} ${props.embedSettings.viewBox.height}` : void 0
      }))));
      function onLoad() {
        window.setTimeout(() => {
          props.onReady();
        }, 100);
      }
      function refreshSrc() {
        if (!props.embeddedFile) {
          setFileSrc(null);
          return;
        }
        const basePath = plugin.app.vault.getResourcePath(props.embeddedFile);
        if (!basePath) {
          setFileSrc(null);
          return;
        }
        const mtime = props.embeddedFile.stat.mtime;
        const separator = basePath.includes("?") ? "&" : "?";
        setFileSrc(`${basePath}${separator}t=${mtime}`);
      }
    };
  }
});

// src/components/formats/current/drawing/drawing-embed/drawing-embed.tsx
function DrawingEmbed(props) {
  const isBooxConnectionEnabled = useBooxConnectionEnabled();
  const embedContainerElRef = (0, import_react135.useRef)(null);
  const resizeContainerElRef = (0, import_react135.useRef)(null);
  const editorControlsRef = (0, import_react135.useRef)();
  const embedWidthRef = (0, import_react135.useRef)(props.embedSettings.embedDisplay.width || DRAWING_INITIAL_WIDTH);
  const embedAspectRatioRef = (0, import_react135.useRef)(props.embedSettings.embedDisplay.aspectRatio || DRAWING_INITIAL_ASPECT_RATIO);
  const didExplicitSaveEmbedSettingsRef = (0, import_react135.useRef)(false);
  const resizeStartWidthRef = (0, import_react135.useRef)(0);
  const resizeStartAspectRatioRef = (0, import_react135.useRef)(0);
  const [drawingFormat, setDrawingFormat] = React110.useState("unknown");
  const setEmbedsInEditMode = useSetAtom(embedsInEditModeAtom_v2);
  React110.useEffect(() => {
    if (!props.embeddedFile)
      return;
    void detectFormat(props.embeddedFile);
  }, [props.embeddedFile?.path]);
  async function detectFormat(file) {
    try {
      const svgString = await file.vault.read(file);
      if (!svgString) {
        setDrawingFormat("legacyInk");
        return;
      }
      const inkFileData = extractInkJsonFromSvg(svgString);
      if (!inkFileData) {
        setDrawingFormat("legacyInk");
        return;
      }
      setDrawingFormat(isInkCanvasFile(inkFileData) ? "ink-canvas" : "legacyInk");
    } catch {
      setDrawingFormat("legacyInk");
    }
  }
  React110.useEffect(() => {
    if (embedShouldActivateImmediately() && props.embedId) {
      window.setTimeout(() => {
        void switchToEditMode();
      }, 200);
    }
    window.addEventListener("resize", handleResize);
    handleResize();
    return () => {
      window.removeEventListener("resize", handleResize);
    };
  }, []);
  React110.useEffect(() => {
    if (!props.workspaceLeafId)
      return;
    const plugin = getGlobals().plugin;
    const booxConnectionTyped = plugin.booxConnection;
    const handler = (leaf) => {
      const isThisLeafActive = leaf?.id === props.workspaceLeafId;
      const sessionCount = booxConnectionTyped?.getSessionCount?.() ?? "?";
      inkDebugLog({
        hypothesisId: "MULTI-CLOSE",
        location: "drawing-embed.tsx:active-leaf-change-handler",
        message: "active-leaf-change fired on embed",
        runId: "view-connect-debug",
        data: {
          isThisLeafActive,
          thisLeafId: props.workspaceLeafId,
          incomingLeafId: leaf?.id ?? null,
          editorControlsPresent: !!editorControlsRef.current,
          sessionCount
        }
      });
      editorControlsRef.current?.setBooxOverlayActive?.(isThisLeafActive);
    };
    plugin.app.workspace.on("active-leaf-change", handler);
    return () => {
      plugin.app.workspace.off("active-leaf-change", handler);
    };
  }, [props.workspaceLeafId]);
  function handleCopyEmbed(_source) {
    const embedStr = props.getEmbedMarkdown?.() ?? null;
    if (!embedStr) {
      new import_obsidian26.Notice("Could not read embed Markdown to copy");
      return;
    }
    void copyEmbedMarkdownToClipboard(embedStr);
  }
  function handleDeleteEmbed() {
    const removeFn = props.deleteEmbed ?? props.remove;
    if (!props.embeddedFile || !props.sourceMdFile) {
      removeFn();
      return;
    }
    openRemoveEmbedFlow(getGlobals().plugin, props.embeddedFile, props.sourceMdFile, "inkDrawing", () => removeFn());
  }
  const embedClipboardMenuOptions = [
    {
      text: "Copy embed",
      action: () => {
        handleCopyEmbed("context-menu");
      }
    },
    {
      text: "Delete embed",
      warning: true,
      action: () => {
        handleDeleteEmbed();
      }
    }
  ];
  const commonExtendedOptions = [
    {
      text: "Open drawing",
      action: async () => {
        await openInDedicatedView();
      }
    },
    { separator: true },
    {
      text: "Copy embed",
      action: () => {
        handleCopyEmbed("overflow-menu");
      }
    },
    {
      text: "Convert to Writing",
      action: () => {
        if (!props.embeddedFile)
          return;
        new FileConversionModal(getGlobals().plugin, props.embeddedFile, "inkWriting", {
          sourceMdFile: props.sourceMdFile,
          onConversionComplete: (finalFile, toType) => {
            if (finalFile)
              void props.replaceEmbedAfterConversion?.(finalFile, toType);
            ignoreChangesAndSwitchToPreviewMode();
          }
        }).open();
      }
    },
    { separator: true },
    {
      text: "Erase all",
      warning: true,
      action: () => {
        new ConfirmationModal({
          plugin: getGlobals().plugin,
          title: "Erase all strokes?",
          message: "This will remove all strokes from the canvas.",
          confirmLabel: "Erase all",
          confirmAction: () => void editorControlsRef.current?.eraseAll?.()
        }).open();
      }
    },
    {
      text: "Delete embed",
      destructive: true,
      action: () => {
        handleDeleteEmbed();
      }
    }
  ].filter(Boolean);
  if (!props.embeddedFile) {
    return /* @__PURE__ */ React110.createElement(React110.Fragment, null, /* @__PURE__ */ React110.createElement("div", {
      className: "ddc_ink_embed ddc_ink_drawing-embed"
    }, /* @__PURE__ */ React110.createElement("div", {
      className: "ddc_ink_pending-banner ddc_ink_pending-banner--not-found"
    }, /* @__PURE__ */ React110.createElement("span", {
      className: "ddc_ink_pending-banner__title"
    }, "Drawing file not found: ", props.partialEmbedFilepath), /* @__PURE__ */ React110.createElement("div", {
      className: "ddc_ink_pending-banner__actions"
    }, /* @__PURE__ */ React110.createElement("button", {
      className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
      onClick: () => props.locateFile?.()
    }, "Locate file")))));
  }
  return /* @__PURE__ */ React110.createElement(React110.Fragment, null, /* @__PURE__ */ React110.createElement("div", {
    ref: embedContainerElRef,
    className: (0, import_classnames41.default)([
      "ddc_ink_embed",
      "ddc_ink_drawing-embed",
      props.isPendingPaste && "ddc_ink_embed--pending"
    ]),
    style: {
      paddingTop: "1em",
      paddingBottom: "0.5em"
    }
  }, props.isPendingPaste && props.embeddedFile && /* @__PURE__ */ React110.createElement("div", {
    className: "ddc_ink_pending-banner"
  }, /* @__PURE__ */ React110.createElement("span", {
    className: "ddc_ink_pending-banner__title"
  }, "Copied embed \u2014 reference source or duplicate?"), /* @__PURE__ */ React110.createElement("div", {
    className: "ddc_ink_pending-banner__actions"
  }, /* @__PURE__ */ React110.createElement("button", {
    className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
    onClick: () => props.resolveAsReference?.()
  }, "Reference existing file"), /* @__PURE__ */ React110.createElement("button", {
    className: "ddc_ink_pending-banner__btn ddc_ink_pending-banner__btn--primary",
    onClick: () => void props.resolveAsDuplicate?.()
  }, "Make duplicate"))), props.embeddedFile && /* @__PURE__ */ React110.createElement("div", {
    className: (0, import_classnames41.default)([
      "ddc_ink_resize-container",
      isBooxConnectionEnabled && "ddc_ink_resize-container--boox"
    ]),
    ref: resizeContainerElRef,
    style: {
      width: embedWidthRef.current + "px",
      height: embedWidthRef.current / embedAspectRatioRef.current + "px",
      position: "relative",
      left: "50%",
      translate: "-50%"
    }
  }, /* @__PURE__ */ React110.createElement(EmbedPreviewContextMenu, {
    menuOptions: embedClipboardMenuOptions
  }, /* @__PURE__ */ React110.createElement(DrawingEmbedPreviewWrapper, {
    embedId: props.embedId,
    embeddedFile: props.embeddedFile,
    embedSettings: props.embedSettings,
    onReady: () => {
    },
    onClick: props.isPendingPaste ? () => {
    } : () => void switchToEditMode()
  })), (drawingFormat === "ink-canvas" || drawingFormat === "legacyInk") && /* @__PURE__ */ React110.createElement(DrawingEditorWrapper, {
    embedId: props.embedId,
    workspaceLeafId: props.workspaceLeafId,
    onReady: () => {
    },
    drawingFile: props.embeddedFile,
    save: props.saveSrcFile,
    extendedMenu: commonExtendedOptions,
    embedSettings: props.embedSettings,
    onSaveCameraPosition: (viewBox) => {
      didExplicitSaveEmbedSettingsRef.current = true;
      props.setEmbedPropsAndViewBox?.({
        width: embedWidthRef.current,
        aspectRatio: embedAspectRatioRef.current,
        viewBox
      });
    },
    embedded: true,
    saveControlsReference: registerEditorControls,
    closeEditor: () => void saveAndSwitchToPreviewMode(),
    resizeEmbed,
    onResizeStart,
    onResizeEnd,
    onEmbedResizeEnd: () => {
    },
    applyEmbedDimensions,
    onOpenInDedicatedView: () => void openInDedicatedView()
  }))));
  function registerEditorControls(handlers) {
    editorControlsRef.current = handlers;
  }
  function resizeEmbed(pxWidthDiff, pxHeightDiff) {
    if (!resizeContainerElRef.current)
      return;
    const maxWidth2 = getFullPageWidth(embedContainerElRef.current);
    if (!maxWidth2)
      return;
    let destWidth = embedWidthRef.current + pxWidthDiff;
    destWidth = Math.max(destWidth, 150);
    destWidth = Math.min(destWidth, maxWidth2);
    const curHeight = resizeContainerElRef.current.getBoundingClientRect().height;
    let destHeight = curHeight + pxHeightDiff;
    destHeight = Math.max(destHeight, 150);
    embedWidthRef.current = destWidth;
    embedAspectRatioRef.current = destWidth / destHeight;
    resizeContainerElRef.current.style.width = embedWidthRef.current + "px";
    resizeContainerElRef.current.style.height = destHeight + "px";
    props.onRequestMeasure?.();
  }
  function onResizeStart() {
    resizeStartWidthRef.current = embedWidthRef.current;
    resizeStartAspectRatioRef.current = embedAspectRatioRef.current;
  }
  function onResizeEnd() {
    const fromWidth = resizeStartWidthRef.current;
    const fromAspectRatio = resizeStartAspectRatioRef.current;
    const toWidth = embedWidthRef.current;
    const toAspectRatio = embedAspectRatioRef.current;
    const dimensionsChanged = fromWidth !== toWidth || fromAspectRatio !== toAspectRatio;
    if (dimensionsChanged && props.embedId && props.workspaceLeafId) {
      pushDrawingEmbedResize(props.workspaceLeafId, {
        type: "embed-resize",
        embedId: props.embedId,
        fromWidth,
        fromAspectRatio,
        toWidth,
        toAspectRatio
      });
    }
  }
  function applyEmbedDimensions(width, aspectRatio) {
    embedWidthRef.current = width;
    embedAspectRatioRef.current = aspectRatio;
    if (resizeContainerElRef.current) {
      resizeContainerElRef.current.style.width = width + "px";
      resizeContainerElRef.current.style.height = width / aspectRatio + "px";
      props.onRequestMeasure?.();
    }
  }
  function applyEmbedHeight() {
    if (!resizeContainerElRef.current)
      return;
    resizeContainerElRef.current.style.width = embedWidthRef.current + "px";
    const curWidth = resizeContainerElRef.current.getBoundingClientRect().width;
    resizeContainerElRef.current.style.height = curWidth / embedAspectRatioRef.current + "px";
    props.onRequestMeasure?.();
  }
  async function switchToEditMode() {
    if (!props.embedId)
      return;
    didExplicitSaveEmbedSettingsRef.current = false;
    verbose(["Add embed to edit mode", props.embedId]);
    logToVault("Drawing embed \u2192 edit: " + (props.embeddedFile?.path ?? props.partialEmbedFilepath));
    if (getBooxConnectionEnabled()) {
      await replaceActiveInkEmbed(props.embedId, saveAndSwitchToPreviewMode);
    }
    applyEmbedHeight();
    setEmbedsInEditMode((prev) => new Set(prev).add(props.embedId));
  }
  function ignoreChangesAndSwitchToPreviewMode() {
    logToVault("Drawing embed \u2192 preview (discarded): " + (props.embeddedFile?.path ?? props.partialEmbedFilepath));
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
  }
  async function openInDedicatedView() {
    if (!props.embeddedFile)
      return;
    dismissLegacyInkNoticesForFile(props.embeddedFile.path);
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
    editorControlsRef.current = void 0;
    await openInkFileInView(props.embeddedFile, "inkDrawing");
  }
  async function saveAndSwitchToPreviewMode() {
    verbose(["Remove embed from edit mode", props.embedId]);
    logToVault("Drawing embed \u2192 preview (saved): " + (props.embeddedFile?.path ?? props.partialEmbedFilepath));
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    if (props.embedId) {
      clearActiveInkEmbed(props.embedId);
      setEmbedsInEditMode((prev) => {
        const next = new Set(prev);
        next.delete(props.embedId);
        return next;
      });
    }
    if (!didExplicitSaveEmbedSettingsRef.current) {
      embedWidthRef.current = props.embedSettings.embedDisplay.width || DRAWING_INITIAL_WIDTH;
      embedAspectRatioRef.current = props.embedSettings.embedDisplay.aspectRatio || DRAWING_INITIAL_ASPECT_RATIO;
      applyEmbedDimensions(embedWidthRef.current, embedAspectRatioRef.current);
    }
  }
  function handleResize() {
    const maxWidth2 = getFullPageWidth(embedContainerElRef.current);
    if (resizeContainerElRef.current) {
      resizeContainerElRef.current.style.maxWidth = maxWidth2 + "px";
      const curWidth = resizeContainerElRef.current.getBoundingClientRect().width;
      resizeContainerElRef.current.style.height = curWidth / embedAspectRatioRef.current + "px";
      props.onRequestMeasure?.();
    }
  }
  ;
}
var React110, import_react135, import_obsidian26, import_classnames41, embedsInEditModeAtom_v2, embedStateAtom_v2, anyDrawingEmbedInEditModeAtom_v2;
var init_drawing_embed = __esm({
  "src/components/formats/current/drawing/drawing-embed/drawing-embed.tsx"() {
    init_7();
    React110 = __toESM(require_react());
    import_react135 = __toESM(require_react());
    init_ink_file_storage_engine();
    init_storage();
    init_device_settings();
    init_use_boox_connection_enabled();
    init_getFullPageWidth();
    init_universal_dev_logging();
    init_log_to_vault();
    init_global_store();
    init_open_file();
    init_file_conversion_modal();
    init_confirmation_modal();
    init_remove_embed_flow();
    import_obsidian26 = require("obsidian");
    import_classnames41 = __toESM(require_classnames());
    init_esm();
    init_constants();
    init_unified_undo_stack();
    init_drawing_embed_preview();
    init_drawing_editor();
    init_copy_embed_to_clipboard();
    init_embed_preview_context_menu();
    init_active_ink_embed_store();
    init_extractInkJsonFromSvg();
    init_legacy_ink_notice();
    embedsInEditModeAtom_v2 = atom(/* @__PURE__ */ new Set());
    embedStateAtom_v2 = atom("preview" /* preview */);
    anyDrawingEmbedInEditModeAtom_v2 = atom((get) => {
      return get(embedsInEditModeAtom_v2).size > 0;
    });
  }
});

// src/components/formats/current/drawing/drawing-embed-extension/drawing-embed-extension.scss
var init_25 = __esm({
  "src/components/formats/current/drawing/drawing-embed-extension/drawing-embed-extension.scss"() {
  }
});

// src/components/formats/current/utils/preventWidgetRootStealingFocus.ts
function preventWidgetRootStealingFocus(element) {
  element.tabIndex = -1;
}
var init_preventWidgetRootStealingFocus = __esm({
  "src/components/formats/current/utils/preventWidgetRootStealingFocus.ts"() {
  }
});

// src/components/formats/current/utils/createWidgetRootDomEventHandlers.ts
function eventTargetTouchesWidgetRoot(selector, rawTarget) {
  if (!(rawTarget instanceof Element))
    return false;
  return Boolean(rawTarget.closest(selector));
}
function preventCodeMirrorHandlingWidgetsEvents(selector = ".ddc_ink_widget-root") {
  return import_view.EditorView.domEventHandlers({
    mousedown: (event) => {
      return eventTargetTouchesWidgetRoot(selector, event.target);
    },
    touchstart: (event) => {
      return eventTargetTouchesWidgetRoot(selector, event.target);
    },
    click: (event) => {
      return eventTargetTouchesWidgetRoot(selector, event.target);
    }
  });
}
var import_view;
var init_createWidgetRootDomEventHandlers = __esm({
  "src/components/formats/current/utils/createWidgetRootDomEventHandlers.ts"() {
    import_view = require("@codemirror/view");
  }
});

// src/components/dom-components/modals/svg-picker-modal/svg-picker-modal.scss
var init_26 = __esm({
  "src/components/dom-components/modals/svg-picker-modal/svg-picker-modal.scss"() {
  }
});

// src/components/dom-components/modals/svg-picker-modal/svg-picker-modal.ts
function fileMatchesQuery(file, query) {
  const trimmed = query.trim();
  if (trimmed === "")
    return true;
  const searchFn = (0, import_obsidian27.prepareFuzzySearch)(trimmed);
  return searchFn(file.basename) !== null || searchFn(file.path) !== null;
}
function filterFiles(files, query) {
  return files.filter((file) => fileMatchesQuery(file, query));
}
var import_obsidian27, MAX_CONCURRENT_PREVIEW_LOADS, PREVIEW_ROOT_MARGIN, SvgFilePickerModal;
var init_svg_picker_modal = __esm({
  "src/components/dom-components/modals/svg-picker-modal/svg-picker-modal.ts"() {
    init_26();
    import_obsidian27 = require("obsidian");
    init_inline_svg_preview();
    MAX_CONCURRENT_PREVIEW_LOADS = 4;
    PREVIEW_ROOT_MARGIN = "120px 0px";
    SvgFilePickerModal = class extends import_obsidian27.Modal {
      constructor(app, options) {
        super(app);
        this.searchQuery = "";
        this.hasClosed = false;
        this.isScanning = false;
        this.svgContentCache = /* @__PURE__ */ new Map();
        this.previewObserver = null;
        this.cardPreviewStates = /* @__PURE__ */ new Map();
        this.activePreviewLoads = 0;
        this.pendingPreviewLoads = [];
        this.searchComponent = null;
        this.sectionsContainer = null;
        this.statusEl = null;
        this.titleText = options.title;
        this.sections = options.sections;
        this.fileType = options.fileType;
        this.onChoose = options.onChoose;
        this.isScanning = options.isScanning === true;
      }
      setSections(sections, isScanning) {
        if (this.hasClosed)
          return;
        this.sections = sections;
        this.isScanning = isScanning;
        this.updateStatusText();
        this.applyFilter();
      }
      updateStatusText() {
        if (!this.statusEl)
          return;
        if (this.isScanning) {
          this.statusEl.setText("Scanning vault for ink files\u2026");
          this.statusEl.show();
          return;
        }
        this.statusEl.hide();
      }
      disconnectPreviewObserver() {
        this.previewObserver?.disconnect();
        this.previewObserver = null;
        this.cardPreviewStates.clear();
        this.pendingPreviewLoads = [];
        this.activePreviewLoads = 0;
      }
      ensurePreviewObserver() {
        if (this.previewObserver || !this.sectionsContainer)
          return;
        this.previewObserver = new IntersectionObserver((entries) => {
          for (const entry of entries) {
            const state = this.cardPreviewStates.get(entry.target);
            if (!state)
              continue;
            if (entry.isIntersecting) {
              this.enqueuePreviewMount(state);
            } else if (state.isMounted) {
              this.unloadPreview(state);
            }
          }
        }, {
          root: this.sectionsContainer,
          rootMargin: PREVIEW_ROOT_MARGIN,
          threshold: 0.01
        });
      }
      enqueuePreviewMount(state) {
        if (state.isMounted)
          return;
        if (this.pendingPreviewLoads.includes(state))
          return;
        this.pendingPreviewLoads.push(state);
        this.pumpPreviewLoadQueue();
      }
      pumpPreviewLoadQueue() {
        while (this.activePreviewLoads < MAX_CONCURRENT_PREVIEW_LOADS && this.pendingPreviewLoads.length > 0) {
          const next = this.pendingPreviewLoads.shift();
          if (!next)
            break;
          if (next.isMounted)
            continue;
          this.activePreviewLoads++;
          void this.loadInlinePreview(next).finally(() => {
            this.activePreviewLoads = Math.max(0, this.activePreviewLoads - 1);
            this.pumpPreviewLoadQueue();
          });
        }
      }
      unloadPreview(state) {
        state.loadGeneration++;
        state.isMounted = false;
        state.previewHost.empty();
        state.previewHost.createDiv({
          cls: "ink-svg-picker-preview-placeholder",
          text: ""
        });
      }
      async loadInlinePreview(state) {
        const generation = ++state.loadGeneration;
        const { previewHost, file } = state;
        try {
          let svgString = this.svgContentCache.get(file.path);
          if (svgString === void 0) {
            svgString = await this.app.vault.cachedRead(file);
            this.svgContentCache.set(file.path, svgString);
          }
          if (generation !== state.loadGeneration)
            return;
          if (![...this.cardPreviewStates.values()].includes(state))
            return;
          if (mountInlineSvgPreview(previewHost, svgString)) {
            state.isMounted = true;
            return;
          }
        } catch {
        }
        if (generation !== state.loadGeneration)
          return;
        if (![...this.cardPreviewStates.values()].includes(state))
          return;
        previewHost.empty();
        previewHost.createDiv({
          cls: "ink-svg-picker-preview-placeholder",
          text: "Preview unavailable"
        });
        state.isMounted = true;
      }
      createFileCard(container, file, isHorizontalRow = false) {
        const card = container.createDiv({
          cls: isHorizontalRow ? "ink-svg-picker-item ink-svg-picker-item--row-fixed-width" : "ink-svg-picker-item"
        });
        const previewWrapper = card.createDiv({ cls: "ink-svg-picker-preview" });
        const previewHost = previewWrapper.createDiv({
          cls: embedPreviewClassForFileType(this.fileType)
        });
        previewHost.createDiv({
          cls: "ink-svg-picker-preview-placeholder",
          text: ""
        });
        const state = {
          file,
          previewHost,
          isMounted: false,
          loadGeneration: 0
        };
        this.cardPreviewStates.set(card, state);
        this.previewObserver?.observe(card);
        const label = card.createDiv({ cls: "ink-svg-picker-label" });
        label.setText(file.basename);
        card.addEventListener("click", () => {
          this.close();
          this.onChoose(file);
        });
      }
      renderHorizontalRow(container, files) {
        const wrapper = container.createDiv({ cls: "ink-svg-picker-row-wrapper" });
        const row = wrapper.createDiv({ cls: "ink-svg-picker-row" });
        for (const file of files) {
          this.createFileCard(row, file, true);
        }
        const createScrollBtn = (chevron, scrollDelta) => {
          const btn = wrapper.createDiv({ cls: "ink-svg-picker-scroll-btn" });
          btn.setText(chevron);
          btn.addEventListener("click", (event) => {
            event.stopPropagation();
            row.scrollBy({ left: scrollDelta, behavior: "smooth" });
          });
          return btn;
        };
        const leftOverlay = wrapper.createDiv({
          cls: "ink-svg-picker-scroll-indicator ink-svg-picker-scroll-indicator--left"
        });
        const leftBtn = createScrollBtn("\u2039", -140);
        leftOverlay.appendChild(leftBtn);
        const rightOverlay = wrapper.createDiv({
          cls: "ink-svg-picker-scroll-indicator ink-svg-picker-scroll-indicator--right"
        });
        const rightBtn = createScrollBtn("\u203A", 140);
        rightOverlay.appendChild(rightBtn);
        const updateOverlayVisibility = () => {
          const isScrollable = row.scrollWidth > row.clientWidth;
          const atStart = row.scrollLeft <= 1;
          const atEnd = row.scrollLeft + row.clientWidth >= row.scrollWidth - 1;
          leftOverlay.classList.toggle("ink-svg-picker-scroll-indicator--hidden", !(isScrollable && !atStart));
          rightOverlay.classList.toggle("ink-svg-picker-scroll-indicator--hidden", !(isScrollable && !atEnd));
        };
        window.requestAnimationFrame(() => {
          updateOverlayVisibility();
          window.requestAnimationFrame(updateOverlayVisibility);
        });
        row.addEventListener("scroll", updateOverlayVisibility);
      }
      renderSectionHeader(container, label) {
        const header = container.createEl("div", { cls: "ink-svg-picker-section-header" });
        header.setText(label);
      }
      renderSections(container, filteredRecent, filteredOnPage, filteredOther) {
        this.disconnectPreviewObserver();
        container.empty();
        this.ensurePreviewObserver();
        const otherLabel = this.fileType === "inkDrawing" ? "Other drawings" : "Other writing";
        const recentLabel = this.fileType === "inkDrawing" ? "Recent drawings" : "Recent writing";
        const hasAnyResults = filteredRecent.length > 0 || filteredOnPage.length > 0 || filteredOther.length > 0;
        if (!hasAnyResults) {
          const emptyEl = container.createDiv({ cls: "ink-svg-picker-empty" });
          emptyEl.setText(this.isScanning ? "Scanning vault\u2026" : "No files match your search");
          return;
        }
        if (filteredRecent.length > 0) {
          this.renderSectionHeader(container, recentLabel);
          this.renderHorizontalRow(container, filteredRecent);
        }
        if (filteredOnPage.length > 0) {
          this.renderSectionHeader(container, "On current page");
          this.renderHorizontalRow(container, filteredOnPage);
        }
        if (filteredOther.length > 0) {
          const isOnlySection = filteredRecent.length === 0 && filteredOnPage.length === 0;
          if (!isOnlySection)
            this.renderSectionHeader(container, otherLabel);
          const grid = container.createDiv({ cls: "ink-svg-picker-grid" });
          for (const file of filteredOther) {
            this.createFileCard(grid, file);
          }
        }
      }
      applyFilter() {
        if (!this.sectionsContainer || !this.searchComponent)
          return;
        this.searchQuery = this.searchComponent.getValue();
        const filteredRecent = filterFiles(this.sections.recent, this.searchQuery);
        const filteredOnPage = filterFiles(this.sections.onCurrentPage, this.searchQuery);
        const filteredOther = filterFiles(this.sections.other, this.searchQuery);
        this.renderSections(this.sectionsContainer, filteredRecent, filteredOnPage, filteredOther);
      }
      onOpen() {
        const { titleEl, contentEl } = this;
        titleEl.setText(this.titleText);
        this.statusEl = contentEl.createDiv({ cls: "ink-svg-picker-status" });
        this.updateStatusText();
        const searchContainer = contentEl.createDiv({ cls: "ink-svg-picker-search" });
        this.searchComponent = new import_obsidian27.SearchComponent(searchContainer);
        this.searchComponent.setPlaceholder("Search by filename...");
        this.searchComponent.setValue(this.searchQuery);
        this.sectionsContainer = contentEl.createDiv({ cls: "ink-svg-picker-sections" });
        this.searchComponent.onChange(() => this.applyFilter());
        this.applyFilter();
        window.requestAnimationFrame(() => {
          this.searchComponent?.inputEl.focus();
        });
      }
      onClose() {
        this.hasClosed = true;
        this.disconnectPreviewObserver();
        this.svgContentCache.clear();
        this.searchComponent = null;
        this.sectionsContainer = null;
        this.statusEl = null;
        this.contentEl.empty();
      }
    };
  }
});

// src/logic/utils/open-ink-file-picker.ts
function extractEmbedPathsFromNote(content, fileType) {
  const altText = fileType === "inkWriting" ? "InkWriting" : "InkDrawing";
  const paths = [];
  let match;
  EMBED_PATH_REGEX.lastIndex = 0;
  while ((match = EMBED_PATH_REGEX.exec(content)) !== null) {
    if (match[1] === altText)
      paths.push(match[2].trim());
  }
  return paths;
}
function resolvePathToCanonical(vault, metadataCache, linkpath, sourcePath) {
  const normalized = (0, import_obsidian28.normalizePath)(linkpath);
  const resolved = metadataCache.getFirstLinkpathDest(normalized, sourcePath);
  if (resolved instanceof import_obsidian28.TFile)
    return resolved.path;
  const byPath = vault.getAbstractFileByPath(normalized);
  if (byPath instanceof import_obsidian28.TFile)
    return byPath.path;
  return null;
}
async function getNoteForOnCurrentPage(plugin, fileType, sourceFile) {
  if (!sourceFile)
    return null;
  if (sourceFile.extension === "md")
    return sourceFile;
  if (sourceFile.extension === "svg") {
    const notes = await findNotesContainingFileEmbed(plugin.app.vault, sourceFile.path, fileType);
    return notes[0] ?? null;
  }
  return null;
}
async function buildSectionedFiles(plugin, validFiles, fileType, sourceFile, noteContent) {
  const validByPath = /* @__PURE__ */ new Map();
  for (const file of validFiles) {
    validByPath.set(file.path, file);
  }
  const recentPaths = fetchRecentFilePaths(fileType).slice(0, RECENT_MAX);
  const recent = [];
  const recentPathsSeen = /* @__PURE__ */ new Set();
  for (const path of recentPaths) {
    const file = validByPath.get(path);
    if (file && !recentPathsSeen.has(path)) {
      recent.push(file);
      recentPathsSeen.add(path);
    }
  }
  const onPagePathsSeen = /* @__PURE__ */ new Set();
  const onCurrentPage = [];
  const noteFile = await getNoteForOnCurrentPage(plugin, fileType, sourceFile);
  verbose(["[On Current Page] getNoteForOnCurrentPage", {
    noteFile: noteFile?.path ?? null,
    sourceWasSvg: sourceFile?.extension === "svg"
  }]);
  if (noteFile) {
    const content = noteContent ?? await plugin.app.vault.cachedRead(noteFile);
    verbose(["[On Current Page] content", {
      contentLength: content.length,
      containsInkDrawing: content.includes("InkDrawing"),
      containsInkWriting: content.includes("InkWriting")
    }]);
    const rawPaths = extractEmbedPathsFromNote(content, fileType);
    verbose(["[On Current Page] extractEmbedPathsFromNote", {
      rawPaths,
      count: rawPaths.length
    }]);
    for (const linkpath of rawPaths) {
      const canonical = resolvePathToCanonical(plugin.app.vault, plugin.app.metadataCache, linkpath, noteFile.path);
      const inValidByPath = canonical !== null && validByPath.has(canonical);
      const inRecentPathsSeen = canonical !== null && recentPathsSeen.has(canonical);
      verbose(["[On Current Page] resolvePath", {
        linkpath,
        canonical,
        inValidByPath,
        inRecentPathsSeen
      }]);
      if (canonical && inValidByPath && !onPagePathsSeen.has(canonical)) {
        const file = validByPath.get(canonical);
        onCurrentPage.push(file);
        onPagePathsSeen.add(canonical);
      }
    }
  }
  verbose(["[On Current Page] result", { onCurrentPageCount: onCurrentPage.length }]);
  const shownPaths = /* @__PURE__ */ new Set([...recentPathsSeen, ...onPagePathsSeen]);
  const other = validFiles.filter((file) => !shownPaths.has(file.path));
  return { recent, onCurrentPage, other };
}
async function collectMatchingInkSvgFiles(plugin, svgFiles, fileType) {
  const validFiles = [];
  let nextIndex = 0;
  const workerCount = Math.min(DISCOVERY_READ_CONCURRENCY, Math.max(1, svgFiles.length));
  const workers = Array.from({ length: workerCount }, async () => {
    while (nextIndex < svgFiles.length) {
      const fileIndex = nextIndex++;
      const file = svgFiles[fileIndex];
      try {
        const svgString = await plugin.app.vault.cachedRead(file);
        if (sniffInkSvgFileType(svgString) === fileType) {
          validFiles.push(file);
        }
      } catch {
      }
    }
  });
  await Promise.all(workers);
  validFiles.sort((a2, b2) => a2.path.localeCompare(b2.path));
  return validFiles;
}
async function openInkFilePicker(plugin, fileType, title, onChoose, options) {
  const allFiles = plugin.app.vault.getFiles();
  const svgFiles = allFiles.filter((file) => file.extension === "svg");
  const fileTypeLabel = fileType === "inkWriting" ? "writing" : "drawing";
  if (svgFiles.length === 0) {
    new import_obsidian28.Notice(`No ${fileTypeLabel} SVGs found`);
    return;
  }
  const effectiveSource = options?.sourceFile ?? plugin.app.workspace.getActiveViewOfType(import_obsidian28.MarkdownView)?.file ?? plugin.app.workspace.getActiveFile();
  const noteContent = options?.noteContent ?? null;
  verbose(["[On Current Page] effectiveSource", {
    effectiveSource: effectiveSource?.path ?? null,
    hasNoteContent: noteContent !== null
  }]);
  const wrappedOnChoose = (file) => {
    recordRecentFileSelection(fileType, file.path);
    void Promise.resolve(onChoose(file));
  };
  const modal = new SvgFilePickerModal(plugin.app, {
    title,
    sections: { recent: [], onCurrentPage: [], other: [] },
    fileType,
    onChoose: wrappedOnChoose,
    isScanning: true
  });
  modal.open();
  const validFiles = await collectMatchingInkSvgFiles(plugin, svgFiles, fileType);
  if (modal.hasClosed)
    return;
  if (validFiles.length === 0) {
    modal.close();
    new import_obsidian28.Notice(`No ${fileTypeLabel} SVGs found`);
    return;
  }
  const sections = await buildSectionedFiles(plugin, validFiles, fileType, effectiveSource ?? null, noteContent);
  if (modal.hasClosed)
    return;
  modal.setSections(sections, false);
}
var import_obsidian28, EMBED_PATH_REGEX, RECENT_MAX, DISCOVERY_READ_CONCURRENCY;
var init_open_ink_file_picker = __esm({
  "src/logic/utils/open-ink-file-picker.ts"() {
    import_obsidian28 = require("obsidian");
    init_extractInkJsonFromSvg();
    init_svg_picker_modal();
    init_storage();
    init_convert_file_embeds();
    init_universal_dev_logging();
    EMBED_PATH_REGEX = /!\[(InkWriting|InkDrawing)\]\(<([^>]+)>\)/g;
    RECENT_MAX = 10;
    DISCOVERY_READ_CONCURRENCY = 8;
  }
});

// src/logic/undo-redo/workspace-leaf-from-cm.ts
function getWorkspaceLeafForEditorView(plugin, editorView) {
  let found = null;
  plugin.app.workspace.iterateAllLeaves((leaf) => {
    if (found)
      return;
    const view = leaf.view;
    if (view instanceof import_obsidian29.MarkdownView) {
      const cm = view.editor.cm;
      if (cm === editorView) {
        found = leaf;
      }
    }
  });
  return found;
}
var import_obsidian29;
var init_workspace_leaf_from_cm = __esm({
  "src/logic/undo-redo/workspace-leaf-from-cm.ts"() {
    import_obsidian29 = require("obsidian");
  }
});

// src/logic/utils/embed-markdown-range.ts
function getEmbedDecorationRange(doc, markerFrom, urlEndTo) {
  let from = markerFrom;
  let to = urlEndTo;
  if (from >= 2 && doc.sliceString(from - 2, from) === "\n ") {
    from -= 2;
  } else if (from >= 1 && doc.sliceString(from - 1, from) === " ") {
    from -= 1;
  }
  if (to < doc.length && doc.sliceString(to, to + 1) === "\n") {
    to += 1;
  }
  return { from, to };
}
function getEmbedMarkdownRange(doc, decFrom, decTo, embedType) {
  const slice = doc.sliceString(decFrom, decTo);
  const pattern = EMBED_MARKDOWN_REGEX[embedType];
  const match = slice.match(pattern);
  if (match && match.index !== void 0) {
    const from = decFrom + match.index;
    const to = from + match[0].length;
    return { from, to };
  }
  return null;
}
var EMBED_MARKDOWN_REGEX;
var init_embed_markdown_range = __esm({
  "src/logic/utils/embed-markdown-range.ts"() {
    EMBED_MARKDOWN_REGEX = {
      inkWriting: / !\[InkWriting\]\(<[^>]+>\) \[Edit Writing\]\([^)]+\)/,
      inkDrawing: / !\[InkDrawing\]\(<[^>]+>\) \[Edit Drawing\]\([^)]+\)/
    };
  }
});

// src/components/formats/current/drawing/drawing-embed-extension/drawing-embed-extension.tsx
function drawingEmbedWidgetFromDecoration(deco) {
  const specUnknown = deco.spec;
  if (!specUnknown || typeof specUnknown !== "object" || !("widget" in specUnknown)) {
    return void 0;
  }
  const widgetCandidate = Reflect.get(specUnknown, "widget");
  return widgetCandidate instanceof DrawingEmbedWidget ? widgetCandidate : void 0;
}
function updateWidgetHighlights(transaction2, decorations) {
  const { plugin } = getGlobals();
  const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian30.MarkdownView);
  const activeEditor = activeView?.editor;
  if (!activeEditor)
    return;
  const view = activeEditor.cm;
  const widgetHighlightStates = /* @__PURE__ */ new Map();
  const it = decorations.iter();
  while (it.value) {
    const widget = drawingEmbedWidgetFromDecoration(it.value);
    if (widget) {
      const widgetStart = it.from;
      const widgetEnd = it.to;
      const isHighlighted = transaction2.newSelection.ranges.some((range) => {
        const hasSelection = range.from !== range.to;
        const spansWidget = range.from < widgetStart && range.to > widgetEnd || range.from < widgetStart && range.to > widgetStart && range.to <= widgetEnd || range.from >= widgetStart && range.from < widgetEnd && range.to > widgetEnd;
        return hasSelection && spansWidget;
      });
      widgetHighlightStates.set(widget.id, isHighlighted);
    }
    it.next();
  }
  const widgetElements = view.dom.querySelectorAll(".ddc_ink_widget-root");
  for (const element of widgetElements) {
    const htmlElement = element;
    const decorationsIter = decorations.iter();
    let matchedWidget;
    while (decorationsIter.value) {
      const widget = drawingEmbedWidgetFromDecoration(decorationsIter.value);
      if (widget) {
        const widgetId = htmlElement.getAttribute("data-widget-id");
        if (widgetId === widget.id || !widgetId && matchedWidget === void 0) {
          matchedWidget = widget;
          htmlElement.setAttribute("data-widget-id", widget.id);
          break;
        }
      }
      decorationsIter.next();
    }
    if (matchedWidget) {
      const isHighlighted = widgetHighlightStates.get(matchedWidget.id) || false;
      if (isHighlighted) {
        htmlElement.classList.add("ddc_ink_widget-highlighted");
      } else {
        htmlElement.classList.remove("ddc_ink_widget-highlighted");
      }
    }
  }
}
function drawingEmbedExtension() {
  return [embedStateField];
}
function refreshDrawingEmbedsNow(viewportFrom, options) {
  const { plugin } = getGlobals();
  const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian30.MarkdownView);
  const editor = activeView?.editor;
  if (!editor)
    return;
  const cmView = editor.cm;
  if (!cmView)
    return;
  const payload = options?.forceRebuild ? { viewportFrom, forceRebuild: true } : viewportFrom;
  cmView.dispatch({ effects: refreshEmbedsEffectDrawing.of(payload) });
}
function registerDrawingEmbed(plugin) {
  plugin.registerEditorExtension([
    drawingEmbedExtension()
  ]);
}
function detectMarkdownEmbedLink(mdFile, previewLinkStartNode, transaction2) {
  const { plugin } = getGlobals();
  let nextNode = null;
  if (!previewLinkStartNode || !previewLinkStartNode.name.includes("formatting_formatting-image_image_image-marker")) {
    return { alterFlow: "continue-traversal" };
  }
  const spaceBefore = transaction2.state.doc.sliceString(previewLinkStartNode.from - 1, previewLinkStartNode.from);
  if (spaceBefore !== " ") {
    return { alterFlow: "continue-traversal" };
  }
  const transcriptStartNode = previewLinkStartNode.node.nextSibling;
  if (!transcriptStartNode || !transcriptStartNode.name.includes("formatting_formatting-image_image_image-alt-text_link")) {
    return { alterFlow: "continue-traversal" };
  }
  nextNode = transcriptStartNode.node.nextSibling;
  if (!nextNode) {
    return { alterFlow: "continue-traversal" };
  }
  let transcriptTextNode = null;
  let transcriptEndNode = null;
  if (transcriptStartNode.to - transcriptStartNode.from === 1) {
    transcriptTextNode = nextNode;
    transcriptEndNode = transcriptTextNode.node.nextSibling;
    if (!transcriptEndNode || !transcriptEndNode.name.includes("formatting_formatting-image_image_image-alt-text_link")) {
      return { alterFlow: "continue-traversal" };
    }
    nextNode = transcriptEndNode.node.nextSibling;
  }
  const previewUrlStartNode = nextNode;
  if (!previewUrlStartNode || !previewUrlStartNode.name.includes("formatting_formatting-link-string") && !previewUrlStartNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const previewFilepathNode = previewUrlStartNode.node.nextSibling;
  if (!previewFilepathNode || !previewFilepathNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const previewUrlEndNode = previewFilepathNode.node.nextSibling;
  if (!previewUrlEndNode || !previewUrlEndNode.name.includes("formatting_formatting-link-string") && !previewUrlEndNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  let quoteNode = previewUrlEndNode.node.nextSibling;
  while (quoteNode && quoteNode.name === "quote_quote-1") {
    quoteNode = quoteNode.node.nextSibling;
  }
  nextNode = quoteNode;
  const editTextStartNode = nextNode;
  if (!editTextStartNode || !editTextStartNode.name.includes("formatting_formatting-link_link")) {
    if (editTextStartNode) {
    }
    return { alterFlow: "continue-traversal" };
  }
  nextNode = editTextStartNode.node.nextSibling;
  if (!nextNode) {
    return { alterFlow: "continue-traversal" };
  }
  let editTextNode = null;
  let editTextEndNode = null;
  if (editTextStartNode.to - editTextStartNode.from === 1) {
    editTextNode = nextNode;
    const editText = transaction2.state.doc.sliceString(editTextNode.from, editTextNode.to);
    if (editText.trim() !== "Edit Drawing") {
      return { alterFlow: "continue-traversal" };
    }
    editTextEndNode = editTextNode.node.nextSibling;
    if (!editTextEndNode || !editTextEndNode.name.includes("formatting_formatting-link_link")) {
      if (editTextEndNode) {
      }
      return { alterFlow: "continue-traversal" };
    }
    nextNode = editTextEndNode.node.nextSibling;
  }
  const settingsUrlStartNode = nextNode;
  if (!settingsUrlStartNode || !settingsUrlStartNode.name.includes("formatting_formatting-link-string") && !settingsUrlStartNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const settingsUrlPathNode = settingsUrlStartNode.node.nextSibling;
  if (!settingsUrlPathNode || !settingsUrlPathNode.name.includes("string_url")) {
    if (settingsUrlPathNode) {
    }
    return { alterFlow: "continue-traversal" };
  }
  const settingsUrlEndNode = settingsUrlPathNode.node.nextSibling;
  if (!settingsUrlEndNode || !settingsUrlEndNode.name.includes("formatting_formatting-link-string") && !settingsUrlEndNode.name.includes("string_url")) {
    if (settingsUrlEndNode) {
    }
    return { alterFlow: "continue-traversal" };
  }
  const previewPartialFilepath = transaction2.state.doc.sliceString(previewFilepathNode.from + 1, previewFilepathNode.to - 1);
  const urlAndSettings = transaction2.state.doc.sliceString(settingsUrlPathNode.from, settingsUrlPathNode.to);
  if (!urlAndSettings.includes("type=inkDrawing")) {
    return { alterFlow: "continue-traversal" };
  }
  const startOfReplacement = previewLinkStartNode.from;
  const endOfReplacement = settingsUrlEndNode.to;
  const { embedSettings, isPendingPaste } = parseSettingsFromUrl(urlAndSettings);
  const embeddedFile = plugin.app.metadataCache.getFirstLinkpathDest((0, import_obsidian30.normalizePath)(previewPartialFilepath), mdFile.path);
  return {
    embedLinkInfo: {
      startPosition: startOfReplacement,
      endPosition: endOfReplacement,
      embeddedFile,
      embedSettings,
      partialEmbedFilepath: previewPartialFilepath,
      isPendingPaste
    }
  };
}
var import_language, import_state31, import_view2, import_obsidian30, React111, import_client4, refreshEmbedsEffectDrawing, mountedDecorationIds, DrawingEmbedWidget, embedStateField;
var init_drawing_embed_extension = __esm({
  "src/components/formats/current/drawing/drawing-embed-extension/drawing-embed-extension.tsx"() {
    import_language = require("@codemirror/language");
    import_state31 = require("@codemirror/state");
    import_view2 = require("@codemirror/view");
    import_obsidian30 = require("obsidian");
    React111 = __toESM(require_react());
    import_client4 = __toESM(require_client());
    init_global_store();
    init_esm();
    init_drawing_embed();
    init_embed_settings();
    init_25();
    init_preventWidgetRootStealingFocus();
    init_createWidgetRootDomEventHandlers();
    init_parse_settings_from_url();
    init_buildFileStr();
    init_build_embeds();
    init_build_drawing_embed_settings_from_file();
    init_duplicate_files();
    init_open_ink_file_picker();
    init_workspace_leaf_from_cm();
    init_embed();
    init_ink_embed_refresh();
    init_writing_embed_aspect_ratio();
    init_embed_markdown_range();
    refreshEmbedsEffectDrawing = import_state31.StateEffect.define();
    mountedDecorationIds = [];
    DrawingEmbedWidget = class extends import_view2.WidgetType {
      constructor(mdFile, embeddedFile, embedSettings, partialEmbedFilepath, isPendingPaste) {
        super();
        this.isHighlighted = false;
        this.save = async (inkFileData) => {
          if (!this.embeddedFile)
            return;
          const plugin = getGlobals().plugin;
          const inkFileContents = buildFileStr(inkFileData);
          await plugin.app.vault.modify(this.embeddedFile, inkFileContents);
        };
        this.setEmbedProps = async (view, width, aspectRatio) => {
          const newEmbedSettings = {
            ...this.embedSettings,
            embedDisplay: {
              ...this.embedSettings?.embedDisplay,
              width,
              aspectRatio
            },
            viewBox: {
              ...this.embedSettings?.viewBox
            }
          };
          this.updateEmbed(view, newEmbedSettings);
        };
        this.setEmbedViewBox = async (view, viewBox) => {
          const newEmbedSettings = {
            ...this.embedSettings,
            embedDisplay: {
              ...this.embedSettings?.embedDisplay
            },
            viewBox: {
              x: viewBox.x,
              y: viewBox.y,
              width: viewBox.width,
              height: viewBox.height
            }
          };
          this.updateEmbed(view, newEmbedSettings);
        };
        this.setEmbedPropsAndViewBox = async (view, params) => {
          const newEmbedSettings = {
            ...this.embedSettings,
            embedDisplay: {
              ...this.embedSettings?.embedDisplay,
              width: params.width,
              aspectRatio: params.aspectRatio
            },
            viewBox: {
              x: params.viewBox.x,
              y: params.viewBox.y,
              width: params.viewBox.width,
              height: params.viewBox.height
            }
          };
          this.updateEmbed(view, newEmbedSettings);
        };
        this.mdFile = mdFile;
        this.id = crypto.randomUUID();
        this.embeddedFile = embeddedFile;
        this.embedSettings = embedSettings;
        this.partialEmbedFilepath = partialEmbedFilepath;
        this.isPendingPaste = isPendingPaste;
      }
      toDOM(view) {
        const rootEl = activeDocument.createElement("div");
        rootEl.className = "ddc_ink_widget-root";
        rootEl.setAttribute("data-widget-id", this.id);
        preventWidgetRootStealingFocus(rootEl);
        applyCommonAncestorStyling(rootEl);
        const root = (0, import_client4.createRoot)(rootEl);
        mountedDecorationIds.push(this.id);
        const { plugin } = getGlobals();
        const hostLeaf = getWorkspaceLeafForEditorView(plugin, view);
        const workspaceLeafId = hostLeaf?.id ?? "";
        this.updateHighlightState(view, rootEl);
        root.render(/* @__PURE__ */ React111.createElement(Provider, null, /* @__PURE__ */ React111.createElement(DrawingEmbed, {
          workspaceLeafId,
          embedId: this.id,
          embeddedFile: this.embeddedFile,
          embedSettings: this.embedSettings,
          saveSrcFile: (pageData) => void this.save(pageData),
          remove: () => {
            this.removeEmbed(view);
          },
          getEmbedMarkdown: () => this.getEmbedMarkdown(view),
          deleteEmbed: () => {
            this.removeEmbed(view);
          },
          setEmbedProps: (width, aspectRatio) => {
            void this.setEmbedProps(view, width, aspectRatio);
          },
          setEmbedViewBox: (viewBox) => {
            void this.setEmbedViewBox(view, viewBox);
          },
          setEmbedPropsAndViewBox: (params) => {
            void this.setEmbedPropsAndViewBox(view, params);
          },
          onRequestMeasure: () => this.requestMeasure(view),
          partialEmbedFilepath: this.partialEmbedFilepath,
          sourceMdFile: this.mdFile,
          isPendingPaste: this.isPendingPaste,
          resolveAsReference: () => this.resolveAsReference(view),
          resolveAsDuplicate: () => {
            void this.resolveAsDuplicate(view);
          },
          locateFile: () => {
            void this.locateFile(view);
          },
          replaceEmbedAfterConversion: (finalFile, toType) => {
            void this.replaceEmbedAfterConversion(view, finalFile, toType);
          }
        })));
        return rootEl;
      }
      get estimatedHeight() {
        let height;
        if (this.embedSettings?.embedDisplay) {
          const { width = 500, aspectRatio = 16 / 9 } = this.embedSettings.embedDisplay;
          const calculatedHeight = width / aspectRatio;
          height = calculatedHeight + 24;
        } else {
          height = 305;
        }
        return height;
      }
      updateHighlightState(view, rootEl) {
        const decorations = view.state.field(embedStateField, false);
        if (!decorations)
          return;
        const it = decorations.iter();
        while (it.value) {
          const widget = drawingEmbedWidgetFromDecoration(it.value);
          if (widget && widget.id === this.id) {
            const widgetStart = it.from;
            const widgetEnd = it.to;
            const isHighlighted = view.state.selection.ranges.some((range) => {
              const hasSelection = range.from !== range.to;
              const spansWidget = range.from < widgetStart && range.to > widgetEnd || range.from < widgetStart && range.to > widgetStart && range.to <= widgetEnd || range.from >= widgetStart && range.from < widgetEnd && range.to > widgetEnd;
              return hasSelection && spansWidget;
            });
            if (isHighlighted !== this.isHighlighted) {
              this.isHighlighted = isHighlighted;
              if (isHighlighted) {
                rootEl.classList.add("ddc_ink_widget-highlighted");
              } else {
                rootEl.classList.remove("ddc_ink_widget-highlighted");
              }
            }
            break;
          }
          it.next();
        }
      }
      resolveAsReference(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        const updated = currentText.replace(/&pendingPaste=true/, "");
        if (updated === currentText)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: updated } });
        view.dispatch(tr);
      }
      async resolveAsDuplicate(view) {
        if (!this.embeddedFile)
          return;
        const { plugin } = getGlobals();
        const duplicatedFile = await duplicateDrawingFile(plugin, this.embeddedFile, this.mdFile);
        if (!duplicatedFile)
          return;
        new import_obsidian30.Notice("Drawing file duplicated");
        await this.replaceEmbedAfterConversion(view, duplicatedFile, "inkDrawing");
      }
      async replaceEmbedAfterConversion(view, finalFile, toType) {
        const { plugin } = getGlobals();
        const writingAspectRatio = toType === "inkWriting" ? await readWritingFileAspectRatio(plugin, finalFile) : null;
        const insertEmbedMarkdown = toType === "inkWriting" ? buildWritingEmbedLine(finalFile.path, {
          ...writingAspectRatio != null ? { aspectRatio: writingAspectRatio } : {}
        }) : buildDrawingEmbedLine(finalFile.path, {
          embedSettings: await buildDrawingEmbedSettingsFromFile(plugin, finalFile)
        });
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const tr = view.state.update({
          changes: { from: range.from, to: range.to, insert: insertEmbedMarkdown }
        });
        view.dispatch(tr);
      }
      async locateFile(view) {
        const { plugin } = getGlobals();
        await openInkFilePicker(plugin, "inkDrawing", "Locate drawing file", (chosenFile) => {
          this.updateEmbedFilepath(view, chosenFile.path);
        });
      }
      updateEmbedFilepath(view, newFilepath) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        let updated = currentText.replace(/\(<([^>]+)>\)/, `(<${newFilepath}>)`);
        if (!this.isPendingPaste) {
          updated = updated.replace(/&pendingPaste=true/, "");
        }
        if (updated === currentText)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: updated } });
        view.dispatch(tr);
      }
      getDecorationBounds(view) {
        const decorations = view.state.field(embedStateField, false);
        if (!decorations)
          return null;
        const it = decorations.iter();
        while (it.value) {
          const widget = drawingEmbedWidgetFromDecoration(it.value);
          if (widget && widget.id === this.id) {
            return { decFrom: it.from, decTo: it.to };
          }
          it.next();
        }
        return null;
      }
      getEmbedMarkdownRangeInView(view) {
        const bounds = this.getDecorationBounds(view);
        if (!bounds)
          return null;
        return getEmbedMarkdownRange(view.state.doc, bounds.decFrom, bounds.decTo, "inkDrawing");
      }
      getEmbedMarkdown(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return null;
        return view.state.doc.sliceString(range.from, range.to);
      }
      removeEmbed(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: "" } });
        view.dispatch(tr);
      }
      requestMeasure(view) {
        view.requestMeasure();
      }
      updateEmbed(view, newEmbedSettings) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        this.embedSettings = newEmbedSettings;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        let updated = currentText;
        if (/width=[^&)]+/.test(updated)) {
          updated = updated.replace(/(width=)([^&)]+)/, `$1${newEmbedSettings.embedDisplay.width}`);
        }
        if (/aspectRatio=[^&)]+/.test(updated)) {
          updated = updated.replace(/(aspectRatio=)([^&)]+)/, `$1${formatEmbedAspectRatio(newEmbedSettings.embedDisplay.aspectRatio)}`);
        }
        const viewBoxParams = [
          ["viewBoxX", newEmbedSettings.viewBox.x],
          ["viewBoxY", newEmbedSettings.viewBox.y],
          ["viewBoxW", newEmbedSettings.viewBox.width],
          ["viewBoxH", newEmbedSettings.viewBox.height]
        ];
        for (const [key, value] of viewBoxParams) {
          const valStr = (Math.round(value * 1e3) / 1e3).toString();
          const re2 = new RegExp(`(${key}=)([^&)]+)`);
          if (re2.test(updated)) {
            updated = updated.replace(re2, `$1${valStr}`);
            continue;
          }
          updated = updated.replace(/(\[Edit Drawing\]\([^?]+)(\?[^)]*)?(\))/, (_match, p1, p2, p3) => {
            if (p2)
              return `${p1}${p2}&${key}=${valStr}${p3}`;
            return `${p1}?${key}=${valStr}${p3}`;
          });
        }
        if (updated === currentText)
          return;
        const tr = view.state.update({
          changes: { from: range.from, to: range.to, insert: updated },
          annotations: [import_state31.Transaction.addToHistory.of(false)]
        });
        view.dispatch(tr);
      }
    };
    embedStateField = import_state31.StateField.define({
      create() {
        return import_view2.Decoration.none;
      },
      update(prevEmbeds, transaction2) {
        const { plugin } = getGlobals();
        const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian30.MarkdownView);
        const activeEditor = activeView?.editor;
        if (!activeEditor)
          return prevEmbeds;
        const cmEditorView = activeEditor.cm;
        const isLivePreview = cmEditorView.state.field(import_obsidian30.editorLivePreviewField);
        if (!isLivePreview)
          return import_view2.Decoration.none;
        const firstRun = prevEmbeds.size === 0;
        if (!firstRun && transaction2.changes.empty && transaction2.selection) {
          updateWidgetHighlights(transaction2, prevEmbeds);
        }
        const refreshEffect = transaction2.effects.find((e2) => e2.is(refreshEmbedsEffectDrawing));
        const hasRefreshEffect = !!refreshEffect;
        const { viewportFrom, forceRebuild } = parseInkEmbedRefreshEffectValue(refreshEffect?.value);
        if (!firstRun && transaction2.changes.empty && !hasRefreshEffect) {
          return prevEmbeds;
        }
        const builder = new import_state31.RangeSetBuilder();
        if (viewportFrom !== void 0 && !forceRebuild) {
          const iter = prevEmbeds.iter();
          while (iter.value) {
            const mappedFrom = transaction2.changes.mapPos(iter.from);
            const mappedTo = transaction2.changes.mapPos(iter.to);
            if (mappedFrom < viewportFrom) {
              builder.add(mappedFrom, mappedTo, iter.value);
            }
            iter.next();
          }
        }
        const iterateOptions = viewportFrom !== void 0 ? { from: viewportFrom, enter: iterateCallback } : { enter: iterateCallback };
        function iterateCallback(syntaxNodeRef) {
          const mdFile = activeView?.file;
          if (!mdFile)
            return true;
          const { embedLinkInfo, alterFlow } = detectMarkdownEmbedLink(mdFile, syntaxNodeRef, transaction2);
          if (!embedLinkInfo)
            return true;
          if (alterFlow === "ignore-children")
            return false;
          if (alterFlow === "continue-traversal")
            return true;
          const decorationRange = getEmbedDecorationRange(transaction2.state.doc, embedLinkInfo.startPosition, embedLinkInfo.endPosition);
          embedLinkInfo.startPosition = decorationRange.from;
          embedLinkInfo.endPosition = decorationRange.to;
          let decorationAlreadyExists = false;
          const oldDecoration = prevEmbeds.iter();
          while (oldDecoration.value) {
            const oldDecFrom = transaction2.changes.mapPos(oldDecoration.from);
            const oldDecTo = transaction2.changes.mapPos(oldDecoration.to);
            const positionsMatch = oldDecFrom === embedLinkInfo.startPosition && oldDecTo === embedLinkInfo.endPosition;
            if (positionsMatch) {
              let rangeWasModified = false;
              if (!transaction2.changes.empty) {
                transaction2.changes.iterChangedRanges((fromA, toA) => {
                  if (fromA < oldDecoration.to && toA > oldDecoration.from) {
                    rangeWasModified = true;
                  }
                });
              }
              decorationAlreadyExists = !rangeWasModified;
              if (decorationAlreadyExists)
                break;
            }
            oldDecoration.next();
          }
          if (!forceRebuild && decorationAlreadyExists && oldDecoration.value) {
            builder.add(embedLinkInfo.startPosition, embedLinkInfo.endPosition, oldDecoration.value);
          } else {
            builder.add(embedLinkInfo.startPosition, embedLinkInfo.endPosition, import_view2.Decoration.replace({
              widget: new DrawingEmbedWidget(mdFile, embedLinkInfo.embeddedFile, embedLinkInfo.embedSettings, embedLinkInfo.partialEmbedFilepath, embedLinkInfo.isPendingPaste),
              isBlock: true
            }));
          }
          return true;
        }
        (0, import_language.syntaxTree)(transaction2.state).iterate(iterateOptions);
        return builder.finish();
      },
      provide(stateField) {
        return [
          import_view2.EditorView.decorations.from(stateField),
          import_view2.EditorView.atomicRanges.of((view) => {
            const decorations = view.state.field(embedStateField, false);
            return decorations || import_view2.Decoration.none;
          }),
          preventCodeMirrorHandlingWidgetsEvents()
        ];
      }
    });
  }
});

// src/components/formats/current/writing/writing-embed-extension/writing-embed-extension.scss
var init_27 = __esm({
  "src/components/formats/current/writing/writing-embed-extension/writing-embed-extension.scss"() {
  }
});

// src/components/formats/current/writing/writing-embed-extension/writing-embed-extension.tsx
function writingEmbedWidgetFromDecoration(deco) {
  const specUnknown = deco.spec;
  if (!specUnknown || typeof specUnknown !== "object" || !("widget" in specUnknown)) {
    return void 0;
  }
  const widgetCandidate = Reflect.get(specUnknown, "widget");
  return widgetCandidate instanceof WritingEmbedWidget ? widgetCandidate : void 0;
}
function updateWidgetHighlightsWriting(transaction2, decorations) {
  const { plugin } = getGlobals();
  const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian31.MarkdownView);
  const activeEditor = activeView?.editor;
  if (!activeEditor)
    return;
  const view = activeEditor.cm;
  const widgetHighlightStates = /* @__PURE__ */ new Map();
  const it = decorations.iter();
  while (it.value) {
    const widget = writingEmbedWidgetFromDecoration(it.value);
    if (widget) {
      const widgetStart = it.from;
      const widgetEnd = it.to;
      const isHighlighted = transaction2.newSelection.ranges.some((range) => {
        const hasSelection = range.from !== range.to;
        const spansWidget = range.from < widgetStart && range.to > widgetEnd || range.from < widgetStart && range.to > widgetStart && range.to <= widgetEnd || range.from >= widgetStart && range.from < widgetEnd && range.to > widgetEnd;
        return hasSelection && spansWidget;
      });
      widgetHighlightStates.set(widget.id, isHighlighted);
    }
    it.next();
  }
  const widgetElements = view.dom.querySelectorAll(".ddc_ink_widget-root");
  for (const element of widgetElements) {
    const htmlElement = element;
    const decorationsIter = decorations.iter();
    let matchedWidget;
    while (decorationsIter.value) {
      const widget = writingEmbedWidgetFromDecoration(decorationsIter.value);
      if (widget) {
        const widgetId = htmlElement.getAttribute("data-widget-id");
        if (widgetId === widget.id || !widgetId && matchedWidget === void 0) {
          matchedWidget = widget;
          htmlElement.setAttribute("data-widget-id", widget.id);
          break;
        }
      }
      decorationsIter.next();
    }
    if (matchedWidget) {
      const isHighlighted = widgetHighlightStates.get(matchedWidget.id) || false;
      if (isHighlighted) {
        htmlElement.classList.add("ddc_ink_widget-highlighted");
      } else {
        htmlElement.classList.remove("ddc_ink_widget-highlighted");
      }
    }
  }
}
function writingEmbedExtension() {
  return [embedStateFieldWriting];
}
function refreshWritingEmbedsNow(viewportFrom, options) {
  const { plugin } = getGlobals();
  const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian31.MarkdownView);
  const editor = activeView?.editor;
  if (!editor)
    return;
  const cmView = editor.cm;
  if (!cmView)
    return;
  const payload = options?.forceRebuild ? { viewportFrom, forceRebuild: true } : viewportFrom;
  cmView.dispatch({ effects: refreshEmbedsEffectWriting.of(payload) });
}
function registerWritingEmbed(plugin) {
  plugin.registerEditorExtension([
    writingEmbedExtension()
  ]);
}
function detectMarkdownEmbedLinkWriting(mdFile, previewLinkStartNode, transaction2) {
  const { plugin } = getGlobals();
  let nextNode = null;
  if (!previewLinkStartNode || !previewLinkStartNode.name.includes("formatting_formatting-image_image_image-marker")) {
    return { alterFlow: "continue-traversal" };
  }
  const spaceBefore = transaction2.state.doc.sliceString(previewLinkStartNode.from - 1, previewLinkStartNode.from);
  if (spaceBefore !== " ")
    return { alterFlow: "continue-traversal" };
  const transcriptStartNode = previewLinkStartNode.node.nextSibling;
  if (!transcriptStartNode || !transcriptStartNode.name.includes("formatting_formatting-image_image_image-alt-text_link")) {
    return { alterFlow: "continue-traversal" };
  }
  nextNode = transcriptStartNode.node.nextSibling;
  if (!nextNode)
    return { alterFlow: "continue-traversal" };
  if (transcriptStartNode.to - transcriptStartNode.from === 1) {
    const transcriptTextNode = nextNode;
    const transcriptEndNode = transcriptTextNode.node.nextSibling;
    if (!transcriptEndNode || !transcriptEndNode.name.includes("formatting_formatting-image_image_image-alt-text_link")) {
      return { alterFlow: "continue-traversal" };
    }
    nextNode = transcriptEndNode.node.nextSibling;
  }
  const previewUrlStartNode = nextNode;
  if (!previewUrlStartNode || !previewUrlStartNode.name.includes("formatting_formatting-link-string") && !previewUrlStartNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const previewFilepathNode = previewUrlStartNode.node.nextSibling;
  if (!previewFilepathNode || !previewFilepathNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const previewUrlEndNode = previewFilepathNode.node.nextSibling;
  if (!previewUrlEndNode || !previewUrlEndNode.name.includes("formatting_formatting-link-string") && !previewUrlEndNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  let quoteNode = previewUrlEndNode.node.nextSibling;
  while (quoteNode && quoteNode.name === "quote_quote-1") {
    quoteNode = quoteNode.node.nextSibling;
  }
  nextNode = quoteNode;
  const editTextStartNode = nextNode;
  if (!editTextStartNode || !editTextStartNode.name.includes("formatting_formatting-link_link")) {
    return { alterFlow: "continue-traversal" };
  }
  nextNode = editTextStartNode.node.nextSibling;
  if (!nextNode)
    return { alterFlow: "continue-traversal" };
  if (editTextStartNode.to - editTextStartNode.from === 1) {
    const editTextNode = nextNode;
    const editText = transaction2.state.doc.sliceString(editTextNode.from, editTextNode.to);
    if (editText.trim() !== "Edit Writing") {
      return { alterFlow: "continue-traversal" };
    }
    const editTextEndNode = editTextNode.node.nextSibling;
    if (!editTextEndNode || !editTextEndNode.name.includes("formatting_formatting-link_link")) {
      return { alterFlow: "continue-traversal" };
    }
    nextNode = editTextEndNode.node.nextSibling;
  }
  const settingsUrlStartNode = nextNode;
  if (!settingsUrlStartNode || !settingsUrlStartNode.name.includes("formatting_formatting-link-string") && !settingsUrlStartNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const settingsUrlPathNode = settingsUrlStartNode.node.nextSibling;
  if (!settingsUrlPathNode || !settingsUrlPathNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const urlAndSettings = transaction2.state.doc.sliceString(settingsUrlPathNode.from, settingsUrlPathNode.to);
  if (!urlAndSettings.includes("type=inkWriting")) {
    return { alterFlow: "continue-traversal" };
  }
  const settingsUrlEndNode = settingsUrlPathNode.node.nextSibling;
  if (!settingsUrlEndNode || !settingsUrlEndNode.name.includes("formatting_formatting-link-string") && !settingsUrlEndNode.name.includes("string_url")) {
    return { alterFlow: "continue-traversal" };
  }
  const previewPartialFilepath = transaction2.state.doc.sliceString(previewFilepathNode.from + 1, previewFilepathNode.to - 1);
  const startOfReplacement = previewLinkStartNode.from;
  const endOfReplacement = settingsUrlEndNode.to;
  const { embedSettings, isPendingPaste } = parseSettingsFromUrl(urlAndSettings);
  const embeddedFile = plugin.app.metadataCache.getFirstLinkpathDest((0, import_obsidian31.normalizePath)(previewPartialFilepath), mdFile.path);
  return {
    embedLinkInfo: {
      startPosition: startOfReplacement,
      endPosition: endOfReplacement,
      embeddedFile,
      embedSettings,
      partialEmbedFilepath: previewPartialFilepath,
      isPendingPaste
    }
  };
}
var import_language2, import_state32, import_view3, import_obsidian31, React112, import_client5, refreshEmbedsEffectWriting, WritingEmbedWidget, embedStateFieldWriting;
var init_writing_embed_extension = __esm({
  "src/components/formats/current/writing/writing-embed-extension/writing-embed-extension.tsx"() {
    import_language2 = require("@codemirror/language");
    import_state32 = require("@codemirror/state");
    import_view3 = require("@codemirror/view");
    import_obsidian31 = require("obsidian");
    React112 = __toESM(require_react());
    import_client5 = __toESM(require_client());
    init_global_store();
    init_esm();
    init_writing_embed();
    init_buildFileStr();
    init_build_embeds();
    init_build_drawing_embed_settings_from_file();
    init_duplicate_files();
    init_open_ink_file_picker();
    init_27();
    init_preventWidgetRootStealingFocus();
    init_createWidgetRootDomEventHandlers();
    init_workspace_leaf_from_cm();
    init_ink_embed_refresh();
    init_parse_settings_from_url();
    init_embed_markdown_range();
    init_writing_embed_aspect_ratio();
    refreshEmbedsEffectWriting = import_state32.StateEffect.define();
    WritingEmbedWidget = class extends import_view3.WidgetType {
      constructor(mdFile, embeddedFile, embedSettings, partialEmbedFilepath, isPendingPaste) {
        super();
        this.isHighlighted = false;
        this.save = async (pageData) => {
          if (!this.embeddedFile)
            return;
          const plugin = getGlobals().plugin;
          const pageDataStr = buildFileStr(pageData);
          await plugin.app.vault.modify(this.embeddedFile, pageDataStr);
        };
        this.mdFile = mdFile;
        this.id = crypto.randomUUID();
        this.embeddedFile = embeddedFile;
        this.embedSettings = embedSettings;
        this.partialEmbedFilepath = partialEmbedFilepath;
        this.isPendingPaste = isPendingPaste;
      }
      toDOM(view) {
        const rootEl = activeDocument.createElement("div");
        this.rootEl = rootEl;
        rootEl.className = "ddc_ink_widget-root";
        rootEl.setAttribute("data-widget-id", this.id);
        const root = (0, import_client5.createRoot)(rootEl);
        const { plugin } = getGlobals();
        const hostLeaf = getWorkspaceLeafForEditorView(plugin, view);
        const workspaceLeafId = hostLeaf?.id ?? "";
        preventWidgetRootStealingFocus(rootEl);
        this.updateHighlightState(view, rootEl);
        root.render(/* @__PURE__ */ React112.createElement(Provider, null, /* @__PURE__ */ React112.createElement(WritingEmbed, {
          plugin,
          workspaceLeafId,
          embedId: this.id,
          writingFileRef: this.embeddedFile,
          partialEmbedFilepath: this.partialEmbedFilepath,
          embedSettings: this.embedSettings,
          save: (pageData) => {
            void this.save(pageData);
          },
          remove: () => {
            this.removeEmbed(view);
          },
          getEmbedMarkdown: () => this.getEmbedMarkdown(view),
          deleteEmbed: () => {
            this.removeEmbed(view);
          },
          setEmbedProps: (aspectRatio) => this.setEmbedProps(view, aspectRatio),
          onRequestMeasure: () => this.onRequestMeasure(view),
          sourceMdFile: this.mdFile,
          isPendingPaste: this.isPendingPaste,
          resolveAsReference: () => this.resolveAsReference(view),
          resolveAsDuplicate: () => {
            void this.resolveAsDuplicate(view);
          },
          locateFile: () => {
            void this.locateFile(view);
          },
          replaceEmbedAfterConversion: (finalFile, toType) => {
            void this.replaceEmbedAfterConversion(view, finalFile, toType);
          }
        })));
        return rootEl;
      }
      get estimatedHeight() {
        let height;
        if (this.embedSettings?.embedDisplay?.aspectRatio) {
          const { plugin } = getGlobals();
          const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian31.MarkdownView);
          const activeEditor = activeView?.editor;
          if (activeEditor) {
            const cmEditorView = activeEditor.cm;
            const contentWidth = cmEditorView.contentDOM?.clientWidth || cmEditorView.scrollDOM.clientWidth;
            const aspectRatio = this.embedSettings.embedDisplay.aspectRatio;
            const calculatedHeight = contentWidth / aspectRatio;
            height = calculatedHeight + 24;
          } else {
            height = 250;
          }
        } else {
          height = 250;
        }
        return height;
      }
      updateHighlightState(view, rootEl) {
        const decorations = view.state.field(embedStateFieldWriting, false);
        if (!decorations)
          return;
        const it = decorations.iter();
        while (it.value) {
          const widget = writingEmbedWidgetFromDecoration(it.value);
          if (widget && widget.id === this.id) {
            const widgetStart = it.from;
            const widgetEnd = it.to;
            const isHighlighted = view.state.selection.ranges.some((range) => {
              const hasSelection = range.from !== range.to;
              const spansWidget = range.from < widgetStart && range.to > widgetEnd || range.from < widgetStart && range.to > widgetStart && range.to <= widgetEnd || range.from >= widgetStart && range.from < widgetEnd && range.to > widgetEnd;
              return hasSelection && spansWidget;
            });
            if (isHighlighted !== this.isHighlighted) {
              this.isHighlighted = isHighlighted;
              if (isHighlighted) {
                rootEl.classList.add("ddc_ink_widget-highlighted");
              } else {
                rootEl.classList.remove("ddc_ink_widget-highlighted");
              }
            }
            break;
          }
          it.next();
        }
      }
      onRequestMeasure(view) {
        view.requestMeasure();
      }
      getDecorationBounds(view) {
        const decorations = view.state.field(embedStateFieldWriting, false);
        if (!decorations)
          return null;
        const it = decorations.iter();
        while (it.value) {
          const widget = writingEmbedWidgetFromDecoration(it.value);
          if (widget && widget.id === this.id) {
            return { decFrom: it.from, decTo: it.to };
          }
          it.next();
        }
        return null;
      }
      getEmbedMarkdownRangeInView(view) {
        const bounds = this.getDecorationBounds(view);
        if (!bounds)
          return null;
        return getEmbedMarkdownRange(view.state.doc, bounds.decFrom, bounds.decTo, "inkWriting");
      }
      getEmbedMarkdown(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return null;
        return view.state.doc.sliceString(range.from, range.to);
      }
      removeEmbed(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: "" } });
        view.dispatch(tr);
      }
      resolveAsReference(view) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        const updated = currentText.replace(/&pendingPaste=true/, "");
        if (updated === currentText)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: updated } });
        view.dispatch(tr);
      }
      async resolveAsDuplicate(view) {
        if (!this.embeddedFile)
          return;
        const { plugin } = getGlobals();
        const duplicatedFile = await duplicateWritingFile(plugin, this.embeddedFile, this.mdFile);
        if (!duplicatedFile)
          return;
        new import_obsidian31.Notice("Writing file duplicated");
        await this.replaceEmbedAfterConversion(view, duplicatedFile, "inkWriting");
      }
      async replaceEmbedAfterConversion(view, finalFile, toType) {
        const { plugin } = getGlobals();
        const writingAspectRatio = toType === "inkWriting" ? await readWritingFileAspectRatio(plugin, finalFile) : null;
        const insertEmbedMarkdown = toType === "inkWriting" ? buildWritingEmbedLine(finalFile.path, {
          ...writingAspectRatio != null ? { aspectRatio: writingAspectRatio } : {}
        }) : buildDrawingEmbedLine(finalFile.path, {
          embedSettings: await buildDrawingEmbedSettingsFromFile(plugin, finalFile)
        });
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const tr = view.state.update({
          changes: { from: range.from, to: range.to, insert: insertEmbedMarkdown }
        });
        view.dispatch(tr);
      }
      async locateFile(view) {
        const { plugin } = getGlobals();
        await openInkFilePicker(plugin, "inkWriting", "Locate writing file", (chosenFile) => {
          this.updateEmbedFilepath(view, chosenFile.path);
        });
      }
      updateEmbedFilepath(view, newFilepath) {
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        let updated = currentText.replace(/\(<([^>]+)>\)/, `(<${newFilepath}>)`);
        if (!this.isPendingPaste) {
          updated = updated.replace(/&pendingPaste=true/, "");
        }
        if (updated === currentText)
          return;
        const tr = view.state.update({ changes: { from: range.from, to: range.to, insert: updated } });
        view.dispatch(tr);
      }
      setEmbedProps(view, aspectRatio) {
        this.embedSettings.embedDisplay.aspectRatio = aspectRatio;
        view.requestMeasure();
        const range = this.getEmbedMarkdownRangeInView(view);
        if (!range)
          return;
        const currentText = view.state.doc.sliceString(range.from, range.to);
        const updated = patchWritingEmbedAspectRatioInEmbedSnippet(currentText, aspectRatio);
        if (updated === currentText)
          return;
        const tr = view.state.update({
          changes: { from: range.from, to: range.to, insert: updated },
          annotations: [import_state32.Transaction.addToHistory.of(false)]
        });
        view.dispatch(tr);
      }
    };
    embedStateFieldWriting = import_state32.StateField.define({
      create() {
        return import_view3.Decoration.none;
      },
      update(prevEmbeds, transaction2) {
        const { plugin } = getGlobals();
        const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian31.MarkdownView);
        const activeEditor = activeView?.editor;
        if (!activeEditor)
          return prevEmbeds;
        const cmEditorView = activeEditor.cm;
        const isLivePreview = cmEditorView.state.field(import_obsidian31.editorLivePreviewField);
        if (!isLivePreview)
          return import_view3.Decoration.none;
        const firstRun = prevEmbeds.size === 0;
        if (!firstRun && transaction2.changes.empty && transaction2.selection) {
          updateWidgetHighlightsWriting(transaction2, prevEmbeds);
        }
        const refreshEffect = transaction2.effects.find((e2) => e2.is(refreshEmbedsEffectWriting));
        const hasRefreshEffect = !!refreshEffect;
        const { viewportFrom, forceRebuild } = parseInkEmbedRefreshEffectValue(refreshEffect?.value);
        if (!firstRun && transaction2.changes.empty && !hasRefreshEffect) {
          return prevEmbeds;
        }
        const builder = new import_state32.RangeSetBuilder();
        if (viewportFrom !== void 0 && !forceRebuild) {
          const iter = prevEmbeds.iter();
          while (iter.value) {
            const mappedFrom = transaction2.changes.mapPos(iter.from);
            const mappedTo = transaction2.changes.mapPos(iter.to);
            if (mappedFrom < viewportFrom) {
              builder.add(mappedFrom, mappedTo, iter.value);
            }
            iter.next();
          }
        }
        const iterateOptions = viewportFrom !== void 0 ? { from: viewportFrom, enter: iterateCallback } : { enter: iterateCallback };
        function iterateCallback(syntaxNodeRef) {
          const mdFile = activeView?.file;
          if (!mdFile)
            return true;
          const { embedLinkInfo, alterFlow } = detectMarkdownEmbedLinkWriting(mdFile, syntaxNodeRef, transaction2);
          if (!embedLinkInfo)
            return true;
          if (alterFlow === "ignore-children")
            return false;
          if (alterFlow === "continue-traversal")
            return true;
          const decorationRange = getEmbedDecorationRange(transaction2.state.doc, embedLinkInfo.startPosition, embedLinkInfo.endPosition);
          embedLinkInfo.startPosition = decorationRange.from;
          embedLinkInfo.endPosition = decorationRange.to;
          let decorationAlreadyExists = false;
          const oldDecoration = prevEmbeds.iter();
          while (oldDecoration.value) {
            const oldDecFrom = transaction2.changes.mapPos(oldDecoration.from);
            const oldDecTo = transaction2.changes.mapPos(oldDecoration.to);
            const positionsMatch = oldDecFrom === embedLinkInfo.startPosition && oldDecTo === embedLinkInfo.endPosition;
            if (positionsMatch) {
              let rangeWasModified = false;
              if (!transaction2.changes.empty) {
                transaction2.changes.iterChangedRanges((fromA, toA) => {
                  if (fromA < oldDecoration.to && toA > oldDecoration.from) {
                    rangeWasModified = true;
                  }
                });
              }
              decorationAlreadyExists = !rangeWasModified;
              if (decorationAlreadyExists)
                break;
            }
            oldDecoration.next();
          }
          if (!forceRebuild && decorationAlreadyExists && oldDecoration.value) {
            builder.add(embedLinkInfo.startPosition, embedLinkInfo.endPosition, oldDecoration.value);
          } else {
            builder.add(embedLinkInfo.startPosition, embedLinkInfo.endPosition, import_view3.Decoration.replace({
              widget: new WritingEmbedWidget(mdFile, embedLinkInfo.embeddedFile, embedLinkInfo.embedSettings, embedLinkInfo.partialEmbedFilepath, embedLinkInfo.isPendingPaste),
              isBlock: true
            }));
          }
          return true;
        }
        (0, import_language2.syntaxTree)(transaction2.state).iterate(iterateOptions);
        return builder.finish();
      },
      provide(stateField) {
        return [
          import_view3.EditorView.decorations.from(stateField),
          import_view3.EditorView.atomicRanges.of((view) => {
            const decorations = view.state.field(embedStateFieldWriting, false);
            return decorations || import_view3.Decoration.none;
          }),
          preventCodeMirrorHandlingWidgetsEvents()
        ];
      }
    });
  }
});

// src/components/formats/current/ink-embeds-extension/ink-embed-refresh.ts
function parseInkEmbedRefreshEffectValue(value) {
  if (typeof value === "number") {
    return { viewportFrom: value, forceRebuild: false };
  }
  if (value && typeof value === "object") {
    return {
      viewportFrom: value.viewportFrom,
      forceRebuild: value.forceRebuild ?? false
    };
  }
  return { forceRebuild: false };
}
function refreshLivePreviewEmbedsWhenReady(plugin) {
  let attempt = 0;
  const tryRefresh = () => {
    attempt += 1;
    const markdownView = plugin.app.workspace.getActiveViewOfType(import_obsidian32.MarkdownView);
    if (!markdownView || markdownView.getMode() !== "source")
      return;
    const editor = markdownView.editor;
    const cmView = editor?.cm;
    const isLivePreview = cmView?.state.field(import_obsidian32.editorLivePreviewField) ?? false;
    if (!cmView || !isLivePreview) {
      if (attempt < LIVE_PREVIEW_EMBED_REFRESH_MAX_ATTEMPTS) {
        window.requestAnimationFrame(tryRefresh);
      }
      return;
    }
    refreshDrawingEmbedsNow(void 0, { forceRebuild: true });
    refreshWritingEmbedsNow(void 0, { forceRebuild: true });
  };
  queueMicrotask(() => window.requestAnimationFrame(tryRefresh));
}
var import_obsidian32, LIVE_PREVIEW_EMBED_REFRESH_MAX_ATTEMPTS;
var init_ink_embed_refresh = __esm({
  "src/components/formats/current/ink-embeds-extension/ink-embed-refresh.ts"() {
    import_obsidian32 = require("obsidian");
    init_drawing_embed_extension();
    init_writing_embed_extension();
    LIVE_PREVIEW_EMBED_REFRESH_MAX_ATTEMPTS = 24;
  }
});

// src/logic/utils/migrate-legacy-ink-on-open.ts
function resolveVaultLinkPath(plugin, linkpath, sourceNotePath) {
  return plugin.app.metadataCache.getFirstLinkpathDest(linkpath, sourceNotePath)?.path ?? null;
}
async function migrateLegacyInkFileOnOpen(plugin, legacyFile) {
  const vault = plugin.app.vault;
  if (isLegacyInkFilePath(legacyFile.path)) {
    const scanResult = await buildSingleLegacyFileScanResult(vault, legacyFile);
    if (!scanResult) {
      throw new Error("Could not prepare migration for this legacy file.");
    }
    const migrationResult = await executeMigration(vault, plugin.app.fileManager, scanResult, void 0, {
      singleLegacyFilePath: legacyFile.path
    });
    if (migrationResult.convertedFiles === 0) {
      const detail = migrationResult.failed[0] ?? migrationResult.skipped[0] ?? "unknown error";
      throw new Error(detail);
    }
    const fileType = getLegacyInkFileType(legacyFile.path);
    if (!fileType) {
      throw new Error("Could not determine legacy file type.");
    }
    const newSvgPath = getLegacySvgPath(legacyFile.path);
    const openedFile = vault.getFileByPath(newSvgPath);
    if (!openedFile) {
      throw new Error("Migration completed but the new SVG file was not found.");
    }
    refreshLivePreviewEmbedsWhenReady(plugin);
    return {
      openedFile,
      viewType: fileType === "drawing" ? "inkDrawing" : "inkWriting"
    };
  }
  const tldrawScanResult = await buildSingleTldrawSvgScanResult(vault, legacyFile, (linkpath, sourceNotePath) => resolveVaultLinkPath(plugin, linkpath, sourceNotePath));
  if (!tldrawScanResult) {
    throw new Error("This file is not eligible for on-open migration.");
  }
  const tldrawMigrationResult = await executeTldrawSvgMigration(vault, tldrawScanResult);
  if (tldrawMigrationResult.convertedFiles === 0) {
    const detail = tldrawMigrationResult.failed[0] ?? tldrawMigrationResult.skipped[0] ?? "unknown error";
    throw new Error(detail);
  }
  const entry = tldrawScanResult.tldrawSvgFiles[0];
  refreshLivePreviewEmbedsWhenReady(plugin);
  return {
    openedFile: entry.svgFile,
    viewType: entry.fileKind === "drawing" ? "inkDrawing" : "inkWriting"
  };
}
async function runLegacyInkMigrationFromNotice(plugin, legacyFile, options) {
  const migrationResult = await migrateLegacyInkFileOnOpen(plugin, legacyFile);
  new import_obsidian33.Notice("Migrated to the new SVG format.");
  if (options?.isEmbedded)
    return;
  await openInkFileInView(migrationResult.openedFile, migrationResult.viewType);
}
var import_obsidian33;
var init_migrate_legacy_ink_on_open = __esm({
  "src/logic/utils/migrate-legacy-ink-on-open.ts"() {
    import_obsidian33 = require("obsidian");
    init_ink_embed_refresh();
    init_open_file();
    init_migration_logic();
    init_tldraw_svg_migration_logic();
  }
});

// src/logic/utils/legacy-ink-notice.ts
function dismissLegacyInkNoticesForFile(filePath) {
  for (let index3 = activeLegacyInkNotices.length - 1; index3 >= 0; index3--) {
    const entry = activeLegacyInkNotices[index3];
    if (entry.filePath !== filePath)
      continue;
    entry.notice.hide();
    activeLegacyInkNotices.splice(index3, 1);
  }
}
function trackLegacyInkNotice(filePath, notice) {
  dismissLegacyInkNoticesForFile(filePath);
  activeLegacyInkNotices.push({ filePath, notice });
}
function untrackLegacyInkNotice(notice) {
  const index3 = activeLegacyInkNotices.findIndex((entry) => entry.notice === notice);
  if (index3 >= 0)
    activeLegacyInkNotices.splice(index3, 1);
}
function showLegacyInkUnlockNotice(context) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText("Legacy Ink file");
  scrollAreaEl.createEl("p").setText("This is a legacy Ink file and won't support all the newest features. You can migrate it to the new SVG format now.");
  const { primaryBtnEl, tertiaryBtnEl } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Migrate to new format",
    tertiaryLabel: "Dismiss"
  });
  const notice = launchPersistentNotice(noticeBody);
  trackLegacyInkNotice(context.legacyFile.path, notice);
  primaryBtnEl?.addEventListener("click", () => {
    if (!primaryBtnEl || primaryBtnEl.disabled)
      return;
    primaryBtnEl.disabled = true;
    primaryBtnEl.setText("Migrating\u2026");
    void (async () => {
      try {
        await runLegacyInkMigrationFromNotice(context.plugin, context.legacyFile, {
          isEmbedded: context.isEmbedded
        });
        dismissLegacyInkNoticesForFile(context.legacyFile.path);
      } catch (err) {
        new import_obsidian34.Notice("Migration failed: " + String(err));
      } finally {
        primaryBtnEl.disabled = false;
        primaryBtnEl.setText("Migrate to new format");
      }
    })();
  });
  tertiaryBtnEl?.addEventListener("click", () => {
    notice.hide();
    untrackLegacyInkNotice(notice);
  });
}
var import_obsidian34, activeLegacyInkNotices;
var init_legacy_ink_notice = __esm({
  "src/logic/utils/legacy-ink-notice.ts"() {
    import_obsidian34 = require("obsidian");
    init_notice_components();
    init_migrate_legacy_ink_on_open();
    activeLegacyInkNotices = [];
  }
});

// src/components/formats/current/ink-embeds-extension/ink-embeds-extension.tsx
var ink_embeds_extension_exports = {};
__export(ink_embeds_extension_exports, {
  inkEmbedsExtension: () => inkEmbedsExtension
});
function inkEmbedsExtension() {
  const InkEmbedsView = import_view4.ViewPlugin.fromClass(class {
    constructor(view) {
      this.view = view;
      this.lastScrollTop = 0;
      this.handleScroll = () => {
        const currentScrollTop = this.view.scrollDOM.scrollTop;
        const scrollDelta = currentScrollTop - this.lastScrollTop;
        this.lastScrollTop = currentScrollTop;
        if (scrollDelta <= 0)
          return;
        const viewportFrom = this.view.viewport.from;
        refreshWritingEmbedsNow(viewportFrom);
        refreshDrawingEmbedsNow(viewportFrom);
      };
      this.lastScrollTop = view.scrollDOM.scrollTop;
      this.view.scrollDOM.addEventListener("scroll", this.handleScroll);
    }
    destroy() {
      this.view.scrollDOM.removeEventListener("scroll", this.handleScroll);
    }
    update(update) {
    }
  });
  return [InkEmbedsView];
}
var import_view4;
var init_ink_embeds_extension = __esm({
  "src/components/formats/current/ink-embeds-extension/ink-embeds-extension.tsx"() {
    import_view4 = require("@codemirror/view");
    init_writing_embed_extension();
    init_drawing_embed_extension();
  }
});

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => InkPlugin,
  inkPluginAtom: () => inkPluginAtom
});
module.exports = __toCommonJS(main_exports);
var import_obsidian47 = require("obsidian");
init_plugin_settings();

// src/components/dom-components/support-button-set.ts
var import_obsidian = require("obsidian");
function createSupportButtonSet(containerEl) {
  const supportBarEl = containerEl.createDiv("ddc_ink_support-btn-set");
  const settingEl = new import_obsidian.Setting(supportBarEl);
  settingEl.infoEl.createEl("p").setText("Like ink?");
  settingEl.addButton((btn) => {
    btn.setClass("ddc_ink_secondary-button");
    btn.setTooltip("Bluesky");
    btn.setIcon("bluesky");
    btn.onClick((e2) => {
      window.open("https://bsky.app/profile/daledesilva.bsky.social", "_blank");
    });
  });
  settingEl.addButton((btn) => {
    btn.setClass("ddc_ink_secondary-button");
    btn.setTooltip("Mastodon");
    btn.setIcon("mastodon");
    btn.onClick((e2) => {
      window.open("https://indieweb.social/@daledesilva", "_blank");
    });
  });
  settingEl.addButton((btn) => {
    btn.setClass("ddc_ink_secondary-button");
    btn.setTooltip("X (Twitter)");
    btn.setIcon("twitter");
    btn.onClick((e2) => {
      window.open("https://twitter.com/daledesilva", "_blank");
    });
  });
  settingEl.addButton((btn) => {
    btn.setClass("ddc_ink_primary-button");
    btn.setTooltip("Threads");
    btn.setIcon("threads");
    btn.onClick((e2) => {
      window.open("https://www.threads.net/@daledesilva", "_blank");
    });
  });
  settingEl.addButton((btn) => {
    btn.setClass("ddc_ink_primary-button");
    btn.setTooltip("Support developer");
    btn.setIcon("heart");
    btn.onClick((e2) => {
      window.open("https://ko-fi.com/N4N3JLUCW", "_blank");
    });
  });
}

// src/components/dom-components/tabs/settings-tab/settings-tab.ts
var import_obsidian10 = require("obsidian");
init_confirmation_modal();
init_plugin_settings();

// src/components/dom-components/welcome-notice.ts
init_notice_components();

// src/logic/utils/isIpad.ts
var import_obsidian4 = require("obsidian");
function isIpad() {
  return import_obsidian4.Platform.isIosApp && import_obsidian4.Platform.isTablet;
}

// src/components/dom-components/welcome-notice.ts
function showWelcomeTips_maybe(plugin) {
  if (plugin.settings.onboardingTips.welcomeTipRead)
    return false;
  void showWelcomeTips(plugin);
  return true;
}
var tipsShowingOrDismissed = false;
async function showWelcomeTips(plugin) {
  if (tipsShowingOrDismissed)
    return;
  tipsShowingOrDismissed = true;
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate(1, 3);
  scrollAreaEl.createEl("h1").setText(`Welcome to ink`);
  scrollAreaEl.createEl("p").setText(`Ink is all about enabling pen use directly in your Markdown notes.`);
  scrollAreaEl.createEl("p").setText(`Here's a quick rundown to help you get started...`);
  const {
    primaryBtnEl,
    tertiaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: `Read now`,
    tertiaryLabel: "Remind me later"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (tertiaryBtnEl) {
    tertiaryBtnEl.addEventListener("click", () => {
      notice.hide();
    });
  }
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showHandwritingWelcomeTip(plugin);
    });
  }
}
function showHandwritingWelcomeTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`Inserting handwriting sections...`);
  scrollAreaEl.createEl("p").setText(`In any Markdown note, run the following command to begin writing where your Cursor is.`);
  scrollAreaEl.createEl("blockquote").setText(`"Ink: New handwriting section"`);
  scrollAreaEl.createEl("p").setText(`( Cmd+P or swipe down )`);
  const {
    primaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Continue",
    tertiaryLabel: "Dismiss for now"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showDrawingWelcomeTip(plugin);
    });
  }
}
function showDrawingWelcomeTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`Drawing sections...`);
  scrollAreaEl.createEl("p").setText(`These can be added too and can be resized right in your Markdown file. Use the purple lock icon to save framing, or the standard lock icon to save the drawing but revert the framing.`);
  scrollAreaEl.createEl("blockquote").setText(`"Ink: New drawing"`);
  const {
    primaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Continue",
    tertiaryLabel: "Dismiss for now"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      if (isIpad()) {
        showiPadWelcomeTip(plugin);
      } else {
        showSyncingWelcomeTip(plugin);
      }
    });
  }
}
function showiPadWelcomeTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`If you're using an ipad...`);
  scrollAreaEl.createEl("p").setText(`The 'scribble' feature of the apple pencil can interfere with the ability to write in ink embeds.`);
  scrollAreaEl.createEl("p").setText(`To use ink you will need to turn off scribble in your device settings.`);
  const {
    primaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Continue",
    tertiaryLabel: "Dismiss for now"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showSyncingWelcomeTip(plugin);
    });
  }
}
function showSyncingWelcomeTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`Syncing with your vault...`);
  scrollAreaEl.createEl("p").setText(`Ink files live in your vault and can sync with it to other devices.`);
  scrollAreaEl.createEl("p").setText(`If using Obsidian Sync, turn on "sync all other types" in the Obsidian Sync settings.`);
  const {
    primaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Continue",
    tertiaryLabel: "Dismiss for now"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showDevelopmentWelcomeTip(plugin);
    });
  }
}
function showDevelopmentWelcomeTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`Get involved...`);
  scrollAreaEl.createEl("p").setText(`If you notice any bugs, please report them through the link in the settings.`);
  scrollAreaEl.createEl("p").setText(`You can also follow along with development and let me know which features are important to you at the links below.`);
  const {
    tertiaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    footerLinks: [
      {
        href: "https://youtu.be/plrnx7J_Avc",
        label: "View feature demos"
      },
      {
        href: "https://designdebt.club/socials",
        label: "Follow on socials"
      }
    ],
    tertiaryLabel: "Dismiss"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (tertiaryBtnEl) {
    tertiaryBtnEl.addEventListener("click", () => {
      notice.hide();
      tipsShowingOrDismissed = false;
      plugin.settings.onboardingTips.welcomeTipRead = true;
      plugin.settings.onboardingTips.lastVersionTipRead = plugin.manifest.version;
      void plugin.saveSettings();
    });
  }
}

// src/components/dom-components/version-notices.ts
var semVer = __toESM(require_semver2());
init_notice_components();
function showVersionNotice(plugin) {
  let curVersion = plugin.manifest.version;
  if (curVersion.endsWith("-beta")) {
    curVersion = curVersion.replace("-beta", "");
  }
  const lastVersionTipRead = plugin.settings.onboardingTips.lastVersionTipRead;
  const noLastVersionTipRead = !semVer.valid(lastVersionTipRead);
  const updatedToNewerVersion = noLastVersionTipRead || semVer.gt(curVersion, lastVersionTipRead);
  if (updatedToNewerVersion) {
    showChanges(plugin);
  }
}
function showRecentChanges(plugin) {
  showChanges(plugin);
}
function showChanges(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate(1, 2);
  scrollAreaEl.createEl("h1").setText(`Additions in Ink v0.5.6`);
  const addedListEl = scrollAreaEl.createEl("ul");
  addedListEl.createEl("li").setText(`Full screen writing and drawing is now fully supported.`);
  addedListEl.createEl("li").setText(`Frame the same drawing differently across multiple embeds.`);
  const undoLi = addedListEl.createEl("li");
  undoLi.appendText(`Unified undo allows `);
  createNoticeInlineQuote(undoLi, "Cmd+Z");
  undoLi.appendText(` across embeds and your Markdown note.`);
  addedListEl.createEl("li").setText(`Manual smoothing & pressure selection.`);
  const eraserHoldLi = addedListEl.createEl("li");
  eraserHoldLi.appendText(`Hold `);
  createNoticeInlineQuote(eraserHoldLi, "Cmd");
  eraserHoldLi.appendText(` to switch to eraser temporarily.`);
  addedListEl.createEl("li").setText(`Ability to draw with fingers (activate in settings).`);
  addedListEl.createEl("li").setText(`And more...`);
  const {
    primaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    footerLink: {
      href: "https://youtu.be/plrnx7J_Avc",
      label: "View feature demos"
    },
    primaryLabel: "Continue"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showChangesPageTwo(plugin);
    });
  }
}
function showChangesPageTwo(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate(2, 2);
  scrollAreaEl.createEl("h1").setText(`Changes in Ink v0.5.6`);
  scrollAreaEl.createEl("h2").setText(`Changed`);
  const changedListEl = scrollAreaEl.createEl("ul");
  changedListEl.createEl("li").setText(`Files now save in a new file format.`);
  changedListEl.createEl("li").setText(`Reduced minimum drawing embed size.`);
  const eraserShortcutLi = changedListEl.createEl("li");
  eraserShortcutLi.appendText(`Eraser shortcut is now `);
  createNoticeInlineQuote(eraserShortcutLi, "Cmd");
  eraserShortcutLi.appendText(` instead of middle mouse button.`);
  scrollAreaEl.createEl("h2").setText(`Fixed`);
  const fixedListEl = scrollAreaEl.createEl("ul");
  fixedListEl.createEl("li").setText(`Colour theming in reading mode layout.`);
  fixedListEl.createEl("li").setText(`Reading mode and PDF export sizing.`);
  fixedListEl.createEl("li").setText(`Ability to draw slowly at high zoom levels.`);
  const {
    tertiaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    footerLink: {
      href: "https://youtu.be/plrnx7J_Avc",
      label: "View feature demos"
    },
    tertiaryLabel: "Dismiss"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (tertiaryBtnEl) {
    tertiaryBtnEl.addEventListener("click", () => {
      notice.hide();
      plugin.settings.onboardingTips.lastVersionTipRead = plugin.manifest.version;
      void plugin.saveSettings();
    });
  }
}

// src/components/dom-components/toggle-accordion-setting.ts
var import_obsidian5 = require("obsidian");
var ToggleAccordionSetting = class {
  constructor(containerEl) {
    this.containerEl = containerEl;
    this.sectionEl = this.containerEl.createDiv("ddc_ink_toggle-accordion");
    this.sectionHeaderEl = this.sectionEl.createDiv("ddc_ink_toggle-accordion-header");
    this.sectionContentEl = this.sectionEl.createDiv("ddc_ink_toggle-accordion-content");
    this.sectionContentInnerEl = this.sectionContentEl.createDiv("ddc_ink_toggle-accordion-content-inner");
    this.toggleSetting = new import_obsidian5.Setting(this.sectionHeaderEl).setClass("ddc_ink_setting").addToggle((toggle) => this.toggle = toggle);
    return this;
  }
  setName(name) {
    this.toggleSetting.setName(name);
    return this;
  }
  setDesc(desc) {
    this.toggleSetting.setDesc(desc);
    return this;
  }
  setExpanded(expanded) {
    this.toggle.setValue(expanded);
    if (expanded) {
      this.sectionEl.classList.add("ddc_ink_expanded");
    } else {
      this.sectionEl.classList.remove("ddc_ink_expanded");
    }
    return this;
  }
  onToggle(toggleHandler) {
    this.toggle.onChange((value) => {
      this.setExpanded(value);
      toggleHandler(value);
    });
    return this;
  }
  setContent(contentHandler) {
    contentHandler(this.sectionContentInnerEl);
    return this;
  }
};

// src/components/dom-components/two-way-toggle-setting/two-way-toggle-setting.ts
var import_obsidian6 = require("obsidian");
var TwoWayToggleSetting = class {
  constructor(containerEl) {
    this.containerEl = containerEl;
    this.setting = new import_obsidian6.Setting(containerEl).setClass("ddc_ink_setting").setClass("ddc_ink_two-way-toggle-setting");
    this.setting.addButton((button) => {
      this.rightButton = button;
      button.buttonEl.classList.add("ddc_ink_two-way-toggle-option", "ddc_ink_two-way-toggle-option--start");
      button.buttonEl.setAttribute("aria-pressed", "false");
      button.onClick(() => this.selectStart());
    });
    this.setting.addButton((button) => {
      this.leftButton = button;
      button.buttonEl.classList.add("ddc_ink_two-way-toggle-option", "ddc_ink_two-way-toggle-option--end");
      button.buttonEl.setAttribute("aria-pressed", "false");
      button.onClick(() => this.selectEnd());
    });
    const trackEl = this.setting.controlEl.createDiv("ddc_ink_two-way-toggle-track");
    trackEl.appendChild(this.rightButton.buttonEl);
    trackEl.appendChild(this.leftButton.buttonEl);
  }
  setName(name) {
    this.setting.setName(name);
    return this;
  }
  setDesc(desc) {
    this.setting.setDesc(desc);
    return this;
  }
  setOptionPair(startValue, startLabel, endValue, endLabel) {
    this.startValue = startValue;
    this.endValue = endValue;
    this.rightButton.setButtonText(startLabel);
    this.leftButton.setButtonText(endLabel);
    return this;
  }
  setValue(value) {
    if (this.startValue === void 0 || this.endValue === void 0) {
      throw new Error("TwoWayToggleSetting: call setOptionPair before setValue");
    }
    this.updateActiveState(value);
    return this;
  }
  onChange(handler) {
    this.onChangeHandler = handler;
    return this;
  }
  selectStart() {
    const { startValue, endValue } = this;
    if (startValue === void 0 || endValue === void 0) {
      throw new Error("TwoWayToggleSetting: call setOptionPair before use");
    }
    this.updateActiveState(startValue);
    void this.onChangeHandler?.(startValue);
  }
  selectEnd() {
    const { startValue, endValue } = this;
    if (startValue === void 0 || endValue === void 0) {
      throw new Error("TwoWayToggleSetting: call setOptionPair before use");
    }
    this.updateActiveState(endValue);
    void this.onChangeHandler?.(endValue);
  }
  updateActiveState(value) {
    const isStart = value === this.startValue;
    this.rightButton.buttonEl.classList.toggle("ddc_ink_two-way-toggle-option--active", isStart);
    this.rightButton.buttonEl.setAttribute("aria-pressed", String(isStart));
    this.leftButton.buttonEl.classList.toggle("ddc_ink_two-way-toggle-option--active", !isStart);
    this.leftButton.buttonEl.setAttribute("aria-pressed", String(!isStart));
  }
};

// src/components/dom-components/three-way-toggle-setting/three-way-toggle-setting.ts
var import_obsidian7 = require("obsidian");
var THREE_WAY_POSITION_CLASSES = [
  "ddc_ink_three-way-toggle-option--start",
  "ddc_ink_three-way-toggle-option--middle",
  "ddc_ink_three-way-toggle-option--end"
];
var ThreeWayToggleSetting = class {
  constructor(containerEl) {
    this.buttons = [];
    this.options = [];
    this.containerEl = containerEl;
    this.setting = new import_obsidian7.Setting(containerEl).setClass("ddc_ink_setting").setClass("ddc_ink_three-way-toggle-setting");
    for (let i2 = 0; i2 < 3; i2++) {
      const buttonIndex = i2;
      this.setting.addButton((button) => {
        this.buttons.push(button);
        button.buttonEl.classList.add("ddc_ink_three-way-toggle-option", THREE_WAY_POSITION_CLASSES[buttonIndex]);
        button.buttonEl.setAttribute("aria-pressed", "false");
        button.onClick(() => {
          const option = this.options[buttonIndex];
          if (option)
            this.selectOption(option.value);
        });
      });
    }
    const trackEl = this.setting.controlEl.createDiv("ddc_ink_three-way-toggle-track");
    for (const button of this.buttons) {
      trackEl.appendChild(button.buttonEl);
    }
  }
  setName(name) {
    this.setting.setName(name);
    return this;
  }
  setDesc(desc) {
    this.setting.setDesc(desc);
    return this;
  }
  setOptions(options) {
    if (options.length !== 3) {
      throw new Error("ThreeWayToggleSetting: exactly three options are required");
    }
    this.options = options;
    for (let i2 = 0; i2 < options.length; i2++) {
      this.buttons[i2].setButtonText(options[i2].label);
    }
    return this;
  }
  setValue(value) {
    if (this.options.length !== 3) {
      throw new Error("ThreeWayToggleSetting: call setOptions before setValue");
    }
    this.updateActiveState(value);
    return this;
  }
  onChange(handler) {
    this.onChangeHandler = handler;
    return this;
  }
  selectOption(value) {
    if (this.options.length !== 3) {
      throw new Error("ThreeWayToggleSetting: call setOptions before use");
    }
    this.updateActiveState(value);
    void this.onChangeHandler?.(value);
  }
  updateActiveState(value) {
    for (let i2 = 0; i2 < this.options.length; i2++) {
      const isActive = this.options[i2].value === value;
      const button = this.buttons[i2];
      button.buttonEl.classList.toggle("ddc_ink_three-way-toggle-option--active", isActive);
      button.buttonEl.setAttribute("aria-pressed", String(isActive));
    }
  }
};

// src/components/dom-components/tabs/settings-tab/settings-tab.ts
init_dominant_hand_store();
init_tldraw_svg_migration_logic();
init_device_settings();
function registerSettingsTab(plugin) {
  plugin.addSettingTab(new MySettingsTab(plugin.app, plugin));
}
var MySettingsTab = class extends import_obsidian10.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.legacyMigrateScanGeneration = 0;
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    this.unsubscribeDeviceSettings?.();
    this.unsubscribeDeviceSettings = void 0;
    containerEl.empty();
    containerEl.createEl("p").setText("Hand write or draw directly between paragraphs in your notes.");
    containerEl.createEl("hr");
    insertGettingStartedSection(containerEl, this.plugin);
    const migrateWrapper = insertMigrateSection(containerEl, this.plugin, () => {
      void this.refreshLegacyMigrateSectionVisibility(migrateWrapper);
    });
    void this.refreshLegacyMigrateSectionVisibility(migrateWrapper);
    let writingSectionEl;
    let drawingSectionEl;
    let booxCompanionToggle;
    let fingerDrawingToggle;
    insertHighLevelSettings(containerEl, this.plugin, (show) => {
      if (show)
        writingSectionEl.classList.add("ddc_ink_expanded");
      else
        writingSectionEl.classList.remove("ddc_ink_expanded");
    }, (show) => {
      if (show)
        drawingSectionEl.classList.add("ddc_ink_expanded");
      else
        drawingSectionEl.classList.remove("ddc_ink_expanded");
    }, (toggle) => {
      booxCompanionToggle = toggle;
    }, (toggle) => {
      fingerDrawingToggle = toggle;
    });
    insertTldrawSvgMigrateSection(containerEl, this.plugin);
    containerEl.createEl("hr");
    const strokeInputToggles = [];
    writingSectionEl = insertWritingSettings(containerEl, this.plugin, strokeInputToggles);
    if (this.plugin.settings.writingEnabled)
      writingSectionEl.classList.add("ddc_ink_expanded");
    drawingSectionEl = insertDrawingSettings(containerEl, this.plugin, strokeInputToggles);
    if (this.plugin.settings.drawingEnabled)
      drawingSectionEl.classList.add("ddc_ink_expanded");
    this.unsubscribeDeviceSettings = subscribeDeviceSettingsChanged(() => {
      if (strokeInputToggles[0]) {
        strokeInputToggles[0].setDesc(strokeInputTreatAsSettingDesc("inkWriting"));
      }
      if (strokeInputToggles[1]) {
        strokeInputToggles[1].setDesc(strokeInputTreatAsSettingDesc("inkDrawing"));
      }
      booxCompanionToggle?.setValue(getBooxConnectionEnabled());
      fingerDrawingToggle?.setValue(getFingerDrawingEnabled());
    });
    insertFileOrganisationSection(containerEl, this.plugin);
    new import_obsidian10.Setting(containerEl).setClass("ddc_ink_bare-setting").addButton((button) => {
      button.setButtonText("Reset settings\u2026");
      button.onClick(() => {
        new ConfirmationModal({
          plugin: this.plugin,
          title: "Please confirm",
          message: "Revert to default settings for Ink plugin?",
          confirmLabel: "Reset settings",
          confirmAction: () => {
            void this.plugin.resetSettings().then(() => {
              this.display();
            });
          }
        }).open();
      });
    });
    containerEl.createEl("hr");
    insertPrereleaseWarning(containerEl, this.plugin);
    insertPluginDevelopmentSection(containerEl);
    createSupportButtonSet(containerEl);
  }
  hide() {
    this.legacyMigrateScanGeneration++;
    this.unsubscribeDeviceSettings?.();
    this.unsubscribeDeviceSettings = void 0;
  }
  async refreshLegacyMigrateSectionVisibility(wrapperEl) {
    const generation = ++this.legacyMigrateScanGeneration;
    await Promise.resolve();
    if (generation !== this.legacyMigrateScanGeneration)
      return;
    const needsMigration = await vaultNeedsInkFormatMigration(this.plugin.app.vault, (linkpath, sourceNotePath) => this.plugin.app.metadataCache.getFirstLinkpathDest(linkpath, sourceNotePath)?.path ?? null);
    if (generation !== this.legacyMigrateScanGeneration)
      return;
    wrapperEl.classList.toggle("ddc_ink_expanded", needsMigration);
  }
};
function insertGettingStartedSection(containerEl, plugin) {
  const isExpanded = plugin.settings.gettingStartedExpanded ?? true;
  const wrapperEl = containerEl.createDiv("ddc_ink_section-wrapper");
  if (isExpanded)
    wrapperEl.classList.add("ddc_ink_expanded");
  const sectionEl = wrapperEl.createDiv("ddc_ink_controls-section");
  const headerSetting = new import_obsidian10.Setting(sectionEl).setClass("ddc_ink_controls-header").setClass("ddc_ink_controls-header--clickable").setName("Getting started").setDesc("Tips for using Ink, compatibility with other processes, and migrating from older versions.");
  const arrowEl = headerSetting.settingEl.createSpan("ddc_ink_collapse-arrow");
  arrowEl.setText("\u203A");
  if (isExpanded)
    arrowEl.classList.add("ddc_ink_expanded");
  headerSetting.settingEl.addEventListener("click", () => {
    const expanded = wrapperEl.classList.toggle("ddc_ink_expanded");
    arrowEl.classList.toggle("ddc_ink_expanded", expanded);
    plugin.settings.gettingStartedExpanded = expanded;
    void plugin.saveSettings();
  });
  const contentEl = sectionEl.createDiv("ddc_ink_controls-content");
  const tipsSectionEl = contentEl.createDiv("ddc_ink_tips-section");
  const tipsGridEl = tipsSectionEl.createDiv("ddc_ink_tips-grid");
  const featureDemosLabelEl = tipsGridEl.createDiv("ddc_ink_tips-label");
  const featureDemosLinkEl = featureDemosLabelEl.createEl("a", {
    href: "https://youtu.be/plrnx7J_Avc",
    text: "View feature demos"
  });
  featureDemosLinkEl.setAttribute("target", "_blank");
  featureDemosLinkEl.setAttribute("rel", "noopener");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText("Short videos demonstrating Ink's features.");
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("Slash Commands");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`For a more intuitive experience, turn on "Slash commands" in "Obsidian settings" / "core plugins" or install and set up the community plugin "slash commander".`);
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("Drawing embed framing");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`Two fingers or right mouse button to reframe. Cmd + right mouse button to zoom, or Cmd + scroll wheel.`);
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("Locked embeds");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`Right click on a locked embed to copy or delete it.`);
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("Temporary eraser");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`Hold cmd/ctrl to switch to eraser temporarily.`);
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("iPadOS pencil scribble");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`If using an iPad, the Apple pencil "Scribble" setting can interfere with input in Ink sections. Disable it in iPadOS settings for a better experience.`);
  tipsGridEl.createDiv("ddc_ink_tips-label").setText("Obsidian Sync");
  tipsGridEl.createDiv("ddc_ink_tips-desc").setText(`If using "Obsidian Sync", turn on "sync all other types" in the Obsidian Sync settings.`);
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_bare-setting").setClass("ddc_ink_bare-setting--no-bottom-margin").addButton((btn) => {
    btn.setButtonText("View recent changes");
    btn.onClick(() => showRecentChanges(plugin));
  }).addButton((btn) => {
    btn.setButtonText("Rewatch welcome tips");
    btn.setCta();
    btn.onClick(() => showWelcomeTips(plugin));
  });
}
function insertMigrateSection(containerEl, plugin, onPermanentMigrationFinished) {
  const wrapperEl = containerEl.createDiv("ddc_ink_legacy-migrate-card-wrapper");
  const innerEl = wrapperEl.createDiv("ddc_ink_legacy-migrate-card-inner");
  const cardEl = innerEl.createDiv("ddc_ink_legacy-migrate-card");
  cardEl.createDiv({
    cls: "ddc_ink_legacy-migrate-card-title",
    text: "Migrate Legacy Ink Files"
  });
  cardEl.createDiv({
    cls: "ddc_ink_legacy-migrate-card-desc",
    text: "This version of Ink uses a new SVG format. Migrate legacy .writing/.drawing files and older Ink SVG files still on the previous format to unlock newer features."
  });
  new import_obsidian10.Setting(cardEl).setClass("ddc_ink_bare-setting").setClass("ddc_ink_bare-setting--left").setClass("ddc_ink_legacy-migrate-card-action").addButton((button) => {
    button.setCta();
    button.setButtonText("Show migration options\u2026");
    button.onClick(() => plugin.openMigrationModal(onPermanentMigrationFinished));
  });
  return wrapperEl;
}
function insertTldrawSvgMigrateSection(containerEl, plugin) {
  new import_obsidian10.Setting(containerEl).setClass("ddc_ink_setting").setName("Developer: Migrate tldraw SVG to ink-canvas").setDesc("Bulk-convert v2 SVG files still on <tldraw> metadata (referenced by embeds) to ink-canvas in place. Drawing embed viewBox is refit to stroke bounds.").addButton((button) => {
    button.setButtonText("Migrate tldraw SVGs\u2026");
    button.onClick(() => plugin.openTldrawSvgMigrationModal());
  });
}
function insertPluginDevelopmentSection(containerEl) {
  const wrapperEl = containerEl.createDiv("ddc_ink_section");
  const sectionEl = wrapperEl.createDiv("ddc_ink_controls-section");
  new import_obsidian10.Setting(sectionEl).setClass("ddc_ink_controls-header").setName("Plugin development").setDesc("For information on this plugin's development, visit the links below.");
  const contentEl = sectionEl.createDiv("ddc_ink_controls-content");
  const tipsGridEl = contentEl.createDiv("ddc_ink_tips-grid");
  const addLinkRow = (parent, href, label, description) => {
    const labelEl = parent.createDiv("ddc_ink_tips-label");
    const a2 = labelEl.createEl("a", { href, text: label });
    a2.setAttribute("target", "_blank");
    a2.setAttribute("rel", "noopener");
    parent.createDiv("ddc_ink_tips-desc").setText(description);
  };
  addLinkRow(tipsGridEl, "https://github.com/daledesilva/obsidian_ink/releases", "Latest Changes", "Version history, release notes, and download links for each Ink release.");
  addLinkRow(tipsGridEl, "https://github.com/daledesilva/obsidian_ink", "Roadmap", "Main repository with source code, roadmap, and project information.");
  addLinkRow(tipsGridEl, "https://youtu.be/plrnx7J_Avc", "View feature demos", "Short videos demonstrating Ink's features.");
  addLinkRow(tipsGridEl, "https://github.com/daledesilva/obsidian_ink/issues", "Request feature / Report bug", "Submit feature requests, report bugs, or join the discussion.");
}
function insertHighLevelSettings(containerEl, plugin, onToggleWriting, onToggleDrawing, onBooxToggleReady, onFingerDrawingToggleReady) {
  new import_obsidian10.Setting(containerEl).setClass("ddc_ink_setting").setName("Enable writing").setDesc("If disabled, you will not be able to add new writing embeds and those already embedded will appear as raw code. Existing writing files will be hidden in Obsidian but still exist on disk. Changing this setting will require a restart of Obsidian to take effect.").addToggle((toggle) => {
    toggle.setValue(plugin.settings.writingEnabled);
    toggle.onChange(async (value) => {
      plugin.settings.writingEnabled = value;
      await plugin.saveSettings();
      onToggleWriting(value);
    });
  });
  new import_obsidian10.Setting(containerEl).setClass("ddc_ink_setting").setName("Enable drawing").setDesc("If disabled, you will not be able to add new drawing embeds and those already embedded will appear as raw code. Existing drawing files will be hidden in Obsidian but still exist on disk. Changing this setting will require a restart of Obsidian to take effect.").addToggle((toggle) => {
    toggle.setValue(plugin.settings.drawingEnabled);
    toggle.onChange(async (value) => {
      plugin.settings.drawingEnabled = value;
      await plugin.saveSettings();
      onToggleDrawing(value);
    });
  });
  new import_obsidian10.Setting(containerEl).setClass("ddc_ink_setting").setName("Enable Boox companion app").setDesc("This enables connection to the Boox companion app for passing through smoother pen strokes. This is currently only available for a closed group of testers.").addToggle((toggle) => {
    toggle.setValue(getBooxConnectionEnabled());
    onBooxToggleReady?.(toggle);
    toggle.onChange((value) => {
      setBooxConnectionEnabled(value);
      plugin.booxConnection.onSettingsChanged();
    });
  });
  new import_obsidian10.Setting(containerEl).setClass("ddc_ink_setting").setName("Enable finger drawing").setDesc("Shows a toolbar toggle while editing so you can draw with your finger on touch devices. When off, fingers scroll the note as usual.").addToggle((toggle) => {
    toggle.setValue(getFingerDrawingEnabled());
    onFingerDrawingToggleReady?.(toggle);
    toggle.onChange((value) => {
      setFingerDrawingEnabled(value);
    });
  });
  new TwoWayToggleSetting(containerEl).setName("Dominant hand").setDesc("Which side undo/redo and extend controls appear on while editing.").setOptionPair("right", "Right", "left", "Left").setValue(plugin.settings.dominantHand).onChange(async (value) => {
    plugin.settings.dominantHand = value;
    setDominantHand(value);
    await plugin.saveSettings();
  });
}
function insertFileOrganisationSection(containerEl, plugin) {
  const saveWritingFolder = async (enteredValue) => {
    const value = enteredValue || DEFAULT_SETTINGS.writingSubfolder;
    plugin.settings.writingSubfolder = value.trim();
    await plugin.saveSettings();
  };
  const saveDrawingFolder = async (enteredValue) => {
    const value = enteredValue || DEFAULT_SETTINGS.drawingSubfolder;
    plugin.settings.drawingSubfolder = value.trim();
    await plugin.saveSettings();
  };
  new ToggleAccordionSetting(containerEl).setName("Customise file organisation").setExpanded(plugin.settings.customAttachmentFolders).onToggle(async (value) => {
    plugin.settings.customAttachmentFolders = value;
    await plugin.saveSettings();
  }).setContent((container) => {
    let obsidianBtn, rootBtn, noteBtn;
    const setActiveLocationButton = (active) => {
      obsidianBtn.removeCta();
      obsidianBtn.setDisabled(false);
      rootBtn.removeCta();
      rootBtn.setDisabled(false);
      noteBtn.removeCta();
      noteBtn.setDisabled(false);
      const activeBtn = active === "obsidian" ? obsidianBtn : active === "root" ? rootBtn : noteBtn;
      activeBtn.setCta();
      activeBtn.setDisabled(true);
    };
    new import_obsidian10.Setting(container).setClass("ddc_ink_button-set").setName(`Where should Ink files be saved when created in a note?`).addButton((button) => {
      obsidianBtn = button;
      button.setButtonText("Obsidian attachment folder");
      button.setClass("ddc_ink_left-most");
      if (plugin.settings.noteAttachmentFolderLocation === "obsidian") {
        button.setCta();
        button.setDisabled(true);
      }
      button.onClick(async (e2) => {
        plugin.settings.noteAttachmentFolderLocation = "obsidian";
        await plugin.saveSettings();
        setActiveLocationButton("obsidian");
      });
    }).addButton((button) => {
      rootBtn = button;
      button.setButtonText("Vault root");
      button.setClass("ddc_ink_middle");
      if (plugin.settings.noteAttachmentFolderLocation === "root") {
        button.setCta();
        button.setDisabled(true);
      }
      button.onClick(async (e2) => {
        plugin.settings.noteAttachmentFolderLocation = "root";
        await plugin.saveSettings();
        setActiveLocationButton("root");
      });
    }).addButton((button) => {
      noteBtn = button;
      button.setButtonText("Next to the note");
      button.setClass("ddc_ink_right-most");
      if (plugin.settings.noteAttachmentFolderLocation === "note") {
        button.setCta();
        button.setDisabled(true);
      }
      button.onClick(async (e2) => {
        plugin.settings.noteAttachmentFolderLocation = "note";
        await plugin.saveSettings();
        setActiveLocationButton("note");
      });
    });
    let inputSettingEl = new import_obsidian10.Setting(container).setClass("ddc_ink_setting").setName("Writing files subfolder").addText((textItem) => {
      textItem.setValue(plugin.settings.writingSubfolder.toString());
      textItem.setPlaceholder(DEFAULT_SETTINGS.writingSubfolder.toString());
      textItem.inputEl.addEventListener("blur", (_ev) => {
        void saveWritingFolder(textItem.getValue());
      });
      textItem.inputEl.addEventListener("keypress", (ev) => {
        if (ev.key === "Enter")
          void saveWritingFolder(textItem.getValue());
      });
    });
    inputSettingEl.settingEl.classList.add("ddc_ink_input-medium");
    inputSettingEl = new import_obsidian10.Setting(container).setClass("ddc_ink_setting").setName("Drawing files subfolder").addText((textItem) => {
      textItem.setValue(plugin.settings.drawingSubfolder.toString());
      textItem.setPlaceholder(DEFAULT_SETTINGS.drawingSubfolder.toString());
      textItem.inputEl.addEventListener("blur", (_ev) => {
        void saveDrawingFolder(textItem.getValue());
      });
      textItem.inputEl.addEventListener("keypress", (ev) => {
        if (ev.key === "Enter")
          void saveDrawingFolder(textItem.getValue());
      });
    });
    inputSettingEl.settingEl.classList.add("ddc_ink_input-medium");
  });
}
function strokeInputTreatAsSettingDesc(editorKind) {
  const last7 = getLastDetectedStrokeInput();
  const detectedLabel = last7 === "pen" ? "Pen" : last7 === "mouse" ? "Mouse" : "None";
  const frag = activeDocument.createDocumentFragment();
  const intro = activeDocument.createElement("p");
  intro.textContent = "Automatically detect pen or mouse from pressure (auto), use pen pressure and faithful smoothing (pen), or simulated pressure with higher smoothing (mouse).";
  frag.appendChild(intro);
  const detectedParagraph = activeDocument.createElement("p");
  detectedParagraph.classList.add("ddc_ink_stroke-input-detected-paragraph");
  const detectedLine = activeDocument.createElement("strong");
  detectedLine.append("Last detected input: ");
  const detectedValue = activeDocument.createElement("span");
  detectedValue.className = "ddc_ink_stroke-input-detected-value";
  detectedValue.textContent = detectedLabel;
  detectedLine.appendChild(detectedValue);
  detectedParagraph.appendChild(detectedLine);
  detectedParagraph.appendChild(activeDocument.createElement("br"));
  detectedParagraph.append("If detection is incorrect, choose Pen or Mouse manually.");
  frag.appendChild(detectedParagraph);
  return frag;
}
function insertStrokeInputTreatAsSetting(contentEl, editorKind) {
  return new ThreeWayToggleSetting(contentEl).setName("Smoothing and pressure").setDesc(strokeInputTreatAsSettingDesc(editorKind)).setOptions([
    { value: "auto", label: "Auto" },
    { value: "pen", label: "Pen" },
    { value: "mouse", label: "Mouse" }
  ]).setValue(getStrokeInputTreatAs(editorKind)).onChange((value) => {
    setStrokeInputTreatAs(editorKind, value);
  });
}
function insertDrawingSettings(containerEl, plugin, strokeInputToggles) {
  const wrapperEl = containerEl.createDiv("ddc_ink_section-wrapper");
  const sectionEl = wrapperEl.createDiv("ddc_ink_controls-section");
  new import_obsidian10.Setting(sectionEl).setClass("ddc_ink_controls-header").setName("Drawing").setDesc(`While editing a Markdown file, run the action 'insert new hand drawn section' to embed a drawing canvas.`);
  const contentEl = sectionEl.createDiv("ddc_ink_controls-content");
  strokeInputToggles.push(insertStrokeInputTreatAsSetting(contentEl, "inkDrawing"));
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Show grid in new drawings").addToggle((toggle) => {
    toggle.setValue(plugin.settings.drawingGridEnabledByDefault);
    toggle.onChange(async (value) => {
      plugin.settings.drawingGridEnabledByDefault = value;
      await plugin.saveSettings();
    });
  });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Show frame around drawing when not editing").addToggle((toggle) => {
    toggle.setValue(plugin.settings.drawingFrameWhenLocked);
    toggle.onChange(async (value) => {
      plugin.settings.drawingFrameWhenLocked = value;
      await plugin.saveSettings();
    });
  });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Show background when not editing").addToggle((toggle) => {
    toggle.setValue(plugin.settings.drawingBackgroundWhenLocked);
    toggle.onChange(async (value) => {
      plugin.settings.drawingBackgroundWhenLocked = value;
      await plugin.saveSettings();
    });
  });
  return wrapperEl;
}
function insertWritingSettings(containerEl, plugin, strokeInputToggles) {
  const saveWritingBufferLines = async (enteredValue) => {
    const parsed = parseInt(enteredValue);
    const value = !isNaN(parsed) && parsed >= 0 ? parsed : DEFAULT_SETTINGS.writingBufferLines;
    plugin.settings.writingBufferLines = value;
    await plugin.saveSettings();
  };
  let lineHeightSliderComponent;
  let lineHeightTextComponent;
  const applyWritingLineHeight = async (value) => {
    const clampedValue = Math.max(50, Math.min(400, value));
    plugin.settings.writingLineHeight = clampedValue;
    await plugin.saveSettings();
    lineHeightSliderComponent.setValue(clampedValue);
    lineHeightTextComponent.setValue(clampedValue.toString());
  };
  const wrapperEl = containerEl.createDiv("ddc_ink_section-wrapper");
  const sectionEl = wrapperEl.createDiv("ddc_ink_controls-section");
  new import_obsidian10.Setting(sectionEl).setClass("ddc_ink_controls-header").setName("Writing").setDesc(`While editing a Markdown file, run the action 'New handwriting section' to embed a section for writing with a pen.`);
  const contentEl = sectionEl.createDiv("ddc_ink_controls-content");
  strokeInputToggles.push(insertStrokeInputTreatAsSetting(contentEl, "inkWriting"));
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Show ruled lines when not editing").addToggle((toggle) => {
    toggle.setValue(plugin.settings.writingLinesWhenLocked);
    toggle.onChange(async (value) => {
      plugin.settings.writingLinesWhenLocked = value;
      await plugin.saveSettings();
    });
  });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Show background when not editing").addToggle((toggle) => {
    toggle.setValue(plugin.settings.writingBackgroundWhenLocked);
    toggle.onChange(async (value) => {
      plugin.settings.writingBackgroundWhenLocked = value;
      await plugin.saveSettings();
    });
  });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Line height").setDesc(`Height in pixels of each ruled line. Only affects new writing embeds.`).addSlider((slider) => {
    lineHeightSliderComponent = slider;
    const currentValue = plugin.settings.writingLineHeight ?? DEFAULT_SETTINGS.writingLineHeight;
    slider.setLimits(50, 400, 10).setValue(currentValue);
    slider.sliderEl.addEventListener("input", () => {
      lineHeightTextComponent.setValue(slider.getValue().toString());
    });
    slider.onChange(async (value) => {
      await applyWritingLineHeight(value);
    });
  }).addText((textItem) => {
    lineHeightTextComponent = textItem;
    const currentValue = plugin.settings.writingLineHeight ?? DEFAULT_SETTINGS.writingLineHeight;
    textItem.setValue(currentValue.toString());
    textItem.inputEl.classList.add("ddc_ink_line-height-input");
    textItem.inputEl.addEventListener("blur", () => {
      const parsed = parseInt(textItem.getValue());
      const valueToApply = !isNaN(parsed) ? parsed : DEFAULT_SETTINGS.writingLineHeight;
      void applyWritingLineHeight(valueToApply);
    });
    textItem.inputEl.addEventListener("keypress", (ev) => {
      if (ev.key === "Enter") {
        const parsed = parseInt(textItem.getValue());
        const valueToApply = !isNaN(parsed) ? parsed : DEFAULT_SETTINGS.writingLineHeight;
        void applyWritingLineHeight(valueToApply);
      }
    });
  });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Buffer lines when editing").setDesc(`Number of empty lines shown below your writing while editing. Writing reaches the last line before the embed extends in height.`).addText((textItem) => {
    textItem.setValue(plugin.settings.writingBufferLines.toString());
    textItem.setPlaceholder(DEFAULT_SETTINGS.writingBufferLines.toString());
    textItem.inputEl.addEventListener("blur", () => {
      void saveWritingBufferLines(textItem.getValue());
    });
    textItem.inputEl.addEventListener("keypress", (ev) => {
      if (ev.key === "Enter")
        void saveWritingBufferLines(textItem.getValue());
    });
  });
  insertWritingLimitations(contentEl);
  return wrapperEl;
}
function insertWritingLimitations(containerEl) {
}
function insertPrereleaseWarning(containerEl, plugin) {
  const wrapperEl = containerEl.createDiv("ddc_ink_section-wrapper");
  const controlsEl = wrapperEl.createDiv("ddc_ink_controls-section");
  const headerSetting = new import_obsidian10.Setting(controlsEl).setClass("ddc_ink_controls-header").setClass("ddc_ink_controls-header--clickable").setName("This plugin is in beta").setDesc("Always back up your files. Expand for details.");
  const arrowEl = headerSetting.settingEl.createSpan("ddc_ink_collapse-arrow");
  arrowEl.setText("\u203A");
  headerSetting.settingEl.addEventListener("click", () => {
    const expanded = wrapperEl.classList.toggle("ddc_ink_expanded");
    arrowEl.classList.toggle("ddc_ink_expanded", expanded);
  });
  const contentEl = controlsEl.createDiv("ddc_ink_controls-content");
  contentEl.createEl("p", { text: `Beta means the plugin is still evolving. Changes to embed formats and file-handling features, even when thoroughly tested, may occasionally introduce issues that affect your vault. Always keep backups of your data.` });
  new import_obsidian10.Setting(contentEl).setClass("ddc_ink_setting").setName("Enable debug logging").setDesc("When enabled, debug information is written to an ink-debug.md file in your vault root. This includes writing and drawing activity, so do not enable this unless you are actively troubleshooting a bug to provide logs for a bug report. Disable it again once you're done.").addToggle((toggle) => {
    toggle.setValue(plugin.settings.debugLoggingEnabled);
    toggle.onChange(async (value) => {
      plugin.settings.debugLoggingEnabled = value;
      await plugin.saveSettings();
    });
  });
}

// src/components/formats/v1-code-blocks/drawing/widgets/writing-embed-widget.tsx
var import_obsidian35 = require("obsidian");
var React117 = __toESM(require_react());
var import_client6 = __toESM(require_client());
init_extractInkJsonFromSvg();
init_embed();

// src/components/formats/v1-code-blocks/utils/buildFileStr.ts
var buildFileStr_v1 = (pageData) => {
  return JSON.stringify(pageData, null, "	");
};

// src/components/formats/v1-code-blocks/writing/writing-embed-editor/writing-embed.tsx
var React116 = __toESM(require_react());
var import_react137 = __toESM(require_react());

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
init_dist_esm12();
var import_react136 = __toESM(require_react());

// src/components/formats/v1-code-blocks/utils/tldraw-helpers.ts
init_dist_esm12();
init_constants();
var import_react120 = __toESM(require_react());

// src/components/dom-components/stroke-limit-notice.ts
init_notice_components();
function showStrokeLimitTips_maybe(plugin) {
  if (plugin.settings.onboardingTips.strokeLimitTipRead)
    return;
  showStrokeLimitTips_debounced(plugin);
}
var tips_timeouts = [];
var tipsShowingOrDismissed2 = false;
function showStrokeLimitTips_debounced(plugin) {
  while (tips_timeouts.length > 0) {
    window.clearTimeout(tips_timeouts.pop());
  }
  const newTimeout = window.setTimeout(() => {
    showStrokeLimitTips(plugin);
  }, 5e3);
  tips_timeouts.push(newTimeout);
}
function showStrokeLimitTips(plugin) {
  if (tipsShowingOrDismissed2)
    return;
  tipsShowingOrDismissed2 = true;
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`Lines disappearing?`);
  scrollAreaEl.createEl("p").setText(`You may have noticed that your handwriting lines have started disapearing...`);
  const {
    primaryBtnEl,
    tertiaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    primaryLabel: "Learn why",
    tertiaryLabel: "Dismiss for now"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (tertiaryBtnEl) {
    tertiaryBtnEl.addEventListener("click", () => {
      notice.hide();
    });
  }
  if (primaryBtnEl) {
    primaryBtnEl.addEventListener("click", () => {
      notice.hide();
      showFullStrokeLimitTip(plugin);
    });
  }
}
function showFullStrokeLimitTip(plugin) {
  const { noticeBody, scrollAreaEl, footerEl } = createNoticeTemplate();
  scrollAreaEl.createEl("h1").setText(`To help keep writing smooth...`);
  scrollAreaEl.createEl("p").setText(`Hiding old strokes helps keep pen latency down and the writing experience smooth.`);
  scrollAreaEl.createEl("p").setText(`Never fear though, all your strokes still exist and will become visible again later.`);
  scrollAreaEl.createEl("p").setText(`When you lock or save the embed, those strokes become visible again.`);
  const {
    tertiaryBtnEl
  } = createNoticeCtaBar(footerEl, {
    tertiaryLabel: "Dismiss"
  });
  const notice = launchPersistentNotice(noticeBody);
  if (tertiaryBtnEl) {
    tertiaryBtnEl.addEventListener("click", () => {
      notice.hide();
      tipsShowingOrDismissed2 = false;
      plugin.settings.onboardingTips.strokeLimitTipRead = true;
      void plugin.saveSettings();
    });
  }
}

// src/components/formats/v1-code-blocks/utils/tldraw-helpers.ts
init_universal_dev_logging();
function getActivityType(entry) {
  const activitySummary = getActivitySummary(entry);
  if (activitySummary.drawShapesCompleted)
    return 5 /* DrawingCompleted */;
  if (activitySummary.drawShapesStarted)
    return 3 /* DrawingStarted */;
  if (activitySummary.drawShapesContinued)
    return 4 /* DrawingContinued */;
  if (activitySummary.drawShapesRemoved)
    return 6 /* DrawingErased */;
  if (activitySummary.cameraMoved && activitySummary.pointerMoved)
    return 1 /* CameraMovedManually */;
  if (activitySummary.cameraMoved && !activitySummary.pointerMoved)
    return 2 /* CameraMovedAutomatically */;
  if (activitySummary.pointerMoved)
    return 0 /* PointerMoved */;
  return 8 /* Unclassified */;
}
function getActivitySummary(entry) {
  const summary = {
    pointerMoved: false,
    pointerScribbled: false,
    cameraMoved: false,
    drawShapesStarted: 0,
    drawShapesContinued: 0,
    drawShapesCompleted: 0,
    drawShapesRemoved: 0
  };
  const addedRecords = Object.values(entry.changes.added);
  if (addedRecords) {
    for (let i2 = 0; i2 < addedRecords.length; i2++) {
      const record = addedRecords[i2];
      if (record.typeName == "shape" && record.type == "draw") {
        summary.drawShapesStarted += 1;
        if ("isComplete" in record.props && record.props.isComplete === true) {
          summary.drawShapesCompleted += 1;
        }
        ;
      }
    }
  }
  const updatedRecords = Object.values(entry.changes.updated);
  if (updatedRecords) {
    for (let i2 = 0; i2 < updatedRecords.length; i2++) {
      const recordFinalState = updatedRecords[i2][1];
      if (recordFinalState.typeName == "shape" && recordFinalState.type == "draw") {
        if ("isComplete" in recordFinalState.props && recordFinalState.props.isComplete === true) {
          summary.drawShapesCompleted += 1;
        } else {
          summary.drawShapesContinued += 1;
        }
      } else if (recordFinalState.typeName == "pointer") {
        summary.pointerMoved = true;
      } else if (recordFinalState.typeName == "camera") {
        summary.cameraMoved = true;
      } else if (recordFinalState.typeName == "instance") {
        if (recordFinalState.scribbles)
          summary.pointerScribbled = true;
      }
    }
  }
  const removedRecords = Object.values(entry.changes.removed);
  if (removedRecords) {
    for (let i2 = 0; i2 < removedRecords.length; i2++) {
      const record = removedRecords[i2];
      if (record.typeName == "shape" && record.type == "draw") {
        summary.drawShapesRemoved += 1;
      }
    }
  }
  return summary;
}
function preventTldrawCanvasesCausingObsidianGestures(tlEditor) {
  const tlContainer = tlEditor.getContainer();
  const tlCanvas = tlContainer.getElementsByClassName("tl-canvas")[0];
  if (!tlCanvas)
    return;
  tlCanvas.addEventListener("touchmove", (e2) => {
    e2.stopPropagation();
  });
}
function initWritingCamera(editor, topMarginPx = 0) {
  let canvasWidth = editor.getContainer().clientWidth;
  let containerMargin = 0;
  let containerWidth = 2e3;
  let visibleWidth = containerWidth + 2 * containerMargin;
  const zoom = canvasWidth / visibleWidth;
  let x2 = containerMargin;
  let y2 = topMarginPx;
  silentlyChangeStore(editor, () => {
    editor.setCamera({
      x: x2,
      y: y2,
      z: zoom
    });
  });
}
function initDrawingCamera(editor) {
  const allShapesBounds = editor.getCurrentPageBounds();
  if (!allShapesBounds) {
    const curCameraProps = editor.getCamera();
    editor.setCamera({ ...curCameraProps, z: 0.3 });
    return;
  }
  ;
  const targetZoom = 1;
  editor.zoomToBounds(allShapesBounds, { targetZoom });
}
function initWritingCameraLimits(editor) {
  return {
    x: {
      min: editor.getCamera().x,
      max: editor.getCamera().x
    },
    zoom: {
      min: editor.getCamera().z,
      max: editor.getCamera().z
    }
  };
}
function restrictWritingCamera(editor, cameraLimits) {
  const bounds = editor.getCurrentPageBounds();
  if (!bounds)
    return;
  const yMin = bounds.minY - 500;
  const yMax = bounds.maxY + 1e3;
  let x2 = editor.getCamera().x;
  let y2 = editor.getCamera().y;
  let zoom = editor.getZoomLevel();
  x2 = Math.max(x2, cameraLimits.x.min);
  x2 = Math.min(x2, cameraLimits.x.max);
  y2 = Math.max(y2, yMin);
  y2 = Math.min(y2, yMax);
  zoom = Math.max(zoom, cameraLimits.zoom.min);
  zoom = Math.min(zoom, cameraLimits.zoom.max);
  silentlyChangeStore(editor, () => {
    editor.setCamera({
      x: x2,
      y: y2,
      z: zoom
    });
  });
}
function adaptTldrawToObsidianThemeMode(editor) {
  const isDarkMode = activeDocument.body.classList.contains("theme-dark");
  if (isDarkMode) {
    setUserPreferences({
      id: "dummy-id",
      colorScheme: "dark"
    });
  } else {
    setUserPreferences({
      id: "dummy-id",
      colorScheme: "light"
    });
  }
}
function getCompleteShapes(editor) {
  const allShapes = editor.getCurrentPageShapes();
  let completeShapes = [];
  for (let i2 = 0; i2 < allShapes.length; i2++) {
    const shape = allShapes[i2];
    if ("isComplete" in shape.props && shape.props.isComplete === true) {
      completeShapes.push(shape);
    }
  }
  completeShapes.sort((a2, b2) => {
    return a2.y - b2.y;
  });
  return completeShapes;
}
var useStash = (plugin) => {
  const stash = (0, import_react120.useRef)([]);
  const stashStaleContent = (editor) => {
    const completeShapes = getCompleteShapes(editor);
    const staleShapeIds = [];
    const staleShapes = [];
    for (let i2 = 0; i2 <= completeShapes.length - plugin.settings.writingStrokeLimit; i2++) {
      const record = completeShapes[i2];
      if (record.type !== "draw")
        return;
      staleShapeIds.push(record.id);
      staleShapes.push(record);
    }
    stash.current.push(...staleShapes);
    silentlyChangeStore(editor, () => {
      editor.store.remove(staleShapeIds);
    });
    try {
      if (staleShapeIds.length >= 5)
        showStrokeLimitTips_maybe(plugin);
    } catch (caught) {
      verbose(["Error from stashing stale content (when calling showStrokeLimitTips_maybe)", caught]);
    }
  };
  const unstashStaleContent = (editor) => {
    silentlyChangeStore(editor, () => {
      editor.store.put(stash.current);
    });
    stash.current.length = 0;
  };
  return { stashStaleContent, unstashStaleContent };
};
var hideWritingTemplate = (editor) => {
  hideWritingContainer(editor);
  hideWritingLines(editor);
};
var unhideWritingTemplate = (editor) => {
  unhideWritingContainer(editor);
  unhideWritingLines(editor);
};
var hideWritingContainer = (editor) => {
  const writingContainerShape = editor.getShape("shape:writing-container");
  if (!writingContainerShape)
    return;
  const savedH = writingContainerShape.props.h;
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingContainerShape);
    editor.updateShape({
      id: writingContainerShape.id,
      type: writingContainerShape.type,
      props: {
        h: 0
      },
      meta: {
        savedH
      }
    });
    lockShape(editor, writingContainerShape);
  });
};
var hideWritingLines = (editor) => {
  const writingLinesShape = editor.getShape("shape:writing-lines");
  if (!writingLinesShape)
    return;
  const savedH = writingLinesShape.props.h;
  editor.store.update(writingLinesShape.id, (record) => {
    record.isLocked = false;
    return record;
  });
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingLinesShape);
    editor.updateShape({
      id: writingLinesShape.id,
      type: writingLinesShape.type,
      props: {
        h: 0
      },
      meta: {
        savedH
      }
    });
    lockShape(editor, writingLinesShape);
  });
};
var unhideWritingContainer = (editor) => {
  const writingContainerShape = editor.getShape("shape:writing-container");
  if (!writingContainerShape)
    return;
  const h2 = writingContainerShape.meta.savedH;
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingContainerShape);
    editor.updateShape({
      id: writingContainerShape.id,
      type: writingContainerShape.type,
      props: {
        h: h2
      },
      meta: {
        savedH: void 0
      }
    });
    lockShape(editor, writingContainerShape);
  });
};
var unhideWritingLines = (editor) => {
  const writingLinesShape = editor.getShape("shape:writing-lines");
  if (!writingLinesShape)
    return;
  const h2 = writingLinesShape.meta.savedH;
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingLinesShape);
    editor.updateShape({
      id: writingLinesShape.id,
      type: writingLinesShape.type,
      props: {
        h: h2
      },
      meta: {
        savedH: void 0
      }
    });
    lockShape(editor, writingLinesShape);
  });
};
var silentlyChangeStore = (editor, func) => {
  editor.run(() => {
    editor.store.mergeRemoteChanges(func);
  }, {
    history: "ignore"
  });
};
function prepareWritingSnapshot(TLEditorSnapshot5) {
  return deleteObsoleteWritingTemplateShapes(TLEditorSnapshot5);
}
function prepareDrawingSnapshot(tlEditorSnapshot) {
  return tlEditorSnapshot;
}
function deleteObsoleteWritingTemplateShapes(TLEditorSnapshot5) {
  const updatedSnapshot = JSON.parse(JSON.stringify(TLEditorSnapshot5));
  const obsoleteShapeIds = [
    "shape:primary_container",
    "shape:handwriting_lines"
  ];
  let updatedStore = updatedSnapshot.document?.store;
  if (!updatedStore) {
    updatedStore = TLEditorSnapshot5.store;
  }
  if (!updatedStore) {
    return updatedSnapshot;
  }
  const filteredStore = Object.entries(updatedStore).filter(([_key, tlRecord]) => {
    const isObsoleteObj = obsoleteShapeIds.some((obsId) => tlRecord.id === obsId);
    if (isObsoleteObj) {
      info(["Removing old ink elements to update file:", tlRecord]);
      return false;
    }
    return true;
  });
  const newStore = Object.fromEntries(filteredStore);
  updatedSnapshot.document = {
    ...updatedSnapshot.document,
    store: newStore
  };
  return updatedSnapshot;
}
var updateWritingStoreIfNeeded = (editor) => {
  addNewTemplateShapes(editor);
};
function addNewTemplateShapes(editor) {
  const hasLines = editor.store.has("shape:writing-lines");
  if (!hasLines) {
    editor.createShape({
      id: "shape:writing-lines",
      type: "writing-lines"
    });
  }
  const hasContainer = editor.store.has("shape:writing-container");
  if (!hasContainer) {
    editor.createShape({
      id: "shape:writing-container",
      type: "writing-container"
    });
  }
}
function unlockShape(editor, shape) {
  editor.store.update(shape.id, (record) => {
    const newRecord = JSON.parse(JSON.stringify(record));
    newRecord.isLocked = false;
    return newRecord;
  });
}
function lockShape(editor, shape) {
  editor.store.update(shape.id, (record) => {
    const newRecord = JSON.parse(JSON.stringify(record));
    newRecord.isLocked = true;
    return newRecord;
  });
}
function getWritingContainerBounds(editor) {
  const bounds = editor.getShapePageBounds("shape:writing-container");
  if (bounds) {
    return bounds;
  } else {
    return new Box();
  }
}
async function getWritingSvg(editor) {
  let svgObj;
  resizeWritingTemplateTightly(editor);
  const allShapeIds = Array.from(editor.getCurrentPageShapeIds().values());
  svgObj = await editor.getSvgString(allShapeIds);
  resizeWritingTemplateInvitingly(editor);
  return svgObj;
}
function getAllStrokeBounds(editor) {
  const allStrokeBounds = getDrawShapeBounds(editor);
  allStrokeBounds.x = 0;
  allStrokeBounds.w = WRITING_PAGE_WIDTH;
  allStrokeBounds.h += allStrokeBounds.y;
  allStrokeBounds.y = 0;
  return allStrokeBounds;
}
function getDrawShapeBounds(editor) {
  hideWritingTemplate(editor);
  let bounds = editor.getCurrentPageBounds() || new Box(0, 0);
  unhideWritingTemplate(editor);
  return bounds;
}
function cropWritingStrokeHeightTightly(height) {
  const numOfLines = Math.ceil(height / WRITING_LINE_HEIGHT);
  const newLineHeight = (numOfLines + 0.5) * WRITING_LINE_HEIGHT;
  return Math.max(newLineHeight, WRITING_MIN_PAGE_HEIGHT);
}
function cropWritingStrokeHeightInvitingly(height) {
  const numOfLines = Math.ceil(height / WRITING_LINE_HEIGHT);
  const newLineHeight = (numOfLines + 1.5) * WRITING_LINE_HEIGHT;
  return Math.max(newLineHeight, WRITING_MIN_PAGE_HEIGHT);
}
var resizeWritingTemplateInvitingly = (editor) => {
  verbose("resizeWritingTemplateInvitingly");
  let contentBounds = getAllStrokeBounds(editor);
  if (!contentBounds)
    return;
  contentBounds.h = cropWritingStrokeHeightInvitingly(contentBounds.h);
  const writingLinesShape = editor.getShape("shape:writing-lines");
  const writingContainerShape = editor.getShape("shape:writing-container");
  if (!writingLinesShape)
    return;
  if (!writingContainerShape)
    return;
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingContainerShape);
    unlockShape(editor, writingLinesShape);
    editor.updateShape({
      id: writingContainerShape.id,
      type: writingContainerShape.type,
      props: {
        h: contentBounds.h
      }
    });
    editor.updateShape({
      id: writingLinesShape.id,
      type: writingLinesShape.type,
      props: {
        h: contentBounds.h
      }
    });
    lockShape(editor, writingContainerShape);
    lockShape(editor, writingLinesShape);
  });
};
var resizeWritingTemplateTightly = (editor) => {
  verbose("resizeWritingTemplateTightly");
  let contentBounds = getAllStrokeBounds(editor);
  if (!contentBounds)
    return;
  contentBounds.h = cropWritingStrokeHeightTightly(contentBounds.h);
  const writingLinesShape = editor.getShape("shape:writing-lines");
  const writingContainerShape = editor.getShape("shape:writing-container");
  silentlyChangeStore(editor, () => {
    unlockShape(editor, writingContainerShape);
    unlockShape(editor, writingLinesShape);
    editor.updateShape({
      id: writingContainerShape.id,
      type: writingContainerShape.type,
      props: {
        h: contentBounds.h
      }
    });
    editor.updateShape({
      id: writingLinesShape.id,
      type: writingLinesShape.type,
      props: {
        h: contentBounds.h
      }
    });
    lockShape(editor, writingContainerShape);
    lockShape(editor, writingLinesShape);
  });
};
async function getDrawingSvg(editor) {
  const allShapeIds = Array.from(editor.getCurrentPageShapeIds().values());
  const svgObj = await editor.getSvgString(allShapeIds);
  return svgObj;
}
function focusChildTldrawEditor(containerEl) {
  if (containerEl) {
    containerEl.find(".tl-container").focus({ preventScroll: true });
  }
}

// src/components/formats/v1-code-blocks/writing/writing-shapes/writing-container.tsx
init_dist_esm12();
init_dist_esm12();
var React71 = __toESM(require_react());
init_constants();
var WritingContainerUtil_v1 = class extends ShapeUtil {
  constructor() {
    super(...arguments);
    this.canBind = (opts) => false;
    this.hideRotateHandle = (shape) => true;
    this.onTranslate = (initShape, newShape) => {
      return initShape;
    };
    this.onResize = (shape, info2) => {
      return resizeBox(shape, info2, {
        minWidth: WRITING_PAGE_WIDTH,
        maxWidth: WRITING_PAGE_WIDTH,
        minHeight: WRITING_MIN_PAGE_HEIGHT,
        maxHeight: 5e4
      });
    };
  }
  getDefaultProps() {
    return {
      w: WRITING_PAGE_WIDTH,
      h: WRITING_MIN_PAGE_HEIGHT
    };
  }
  getGeometry(shape) {
    return new Rectangle2d({
      width: shape.props.w,
      height: shape.props.h,
      isFilled: false
    });
  }
  component(shape) {
    return /* @__PURE__ */ React71.createElement(SVGContainer, null, this.createSvg(shape));
  }
  indicator(shape) {
    return /* @__PURE__ */ React71.createElement(React71.Fragment, null, /* @__PURE__ */ React71.createElement("rect", {
      width: shape.props.w,
      height: shape.props.h,
      rx: 20,
      ry: 20
    }));
  }
  toSvg(shape, ctx) {
    return this.createSvg(shape);
  }
  createSvg(shape) {
    this.isAspectRatioLocked(shape);
    return /* @__PURE__ */ React71.createElement(React71.Fragment, null, /* @__PURE__ */ React71.createElement("rect", {
      width: shape.props.w,
      height: shape.props.h,
      opacity: 0
    }));
  }
};
WritingContainerUtil_v1.type = "writing-container";

// src/components/jsx-components/writing-menu/writing-menu.tsx
init_2();
var React78 = __toESM(require_react());

// src/graphics/icons/write-icon.tsx
var React72 = __toESM(require_react());
var WriteIcon = (props) => /* @__PURE__ */ React72.createElement("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  height: 24,
  viewBox: "0 -960 960 960",
  width: 24,
  ...props
}, /* @__PURE__ */ React72.createElement("path", {
  d: "m499-287 335-335-52-52-335 335 52 52Zm-379-62q0 29 20 45t66 21q16 2 25.5 14.5T240-240q-1 17-12 28t-27 9q-81-10-121-46.5T40-349q0-65 53.5-105.5T242-503q39-3 58.5-12.5T320-542q0-22-21-34.5T230-596q-16-2-25.5-15t-7.5-29q2-17 14-27.5t28-8.5q83 12 122 44.5t39 89.5q0 53-38.5 83T248-423q-64 5-96 23.5T120-349Zm398 156L353-358l382-382q20-20 47.5-20t47.5 20l70 70q20 20 20 47.5T900-575L518-193Zm-159 33q-17 4-30-9t-9-30l33-159 165 165-159 33Z"
}));

// src/components/jsx-components/writing-menu/writing-menu.tsx
init_erase_icon();
init_select_icon();
init_expand_icon();
var import_classnames30 = __toESM(require_classnames());
init_tooltip_button();
var WritingMenu = (props) => {
  const [curTool, setCurTool] = React78.useState("draw" /* draw */);
  function activateSelectTool() {
    const tlEditor = props.getTlEditor();
    if (!tlEditor)
      return;
    tlEditor.setCurrentTool("select");
    setCurTool("select" /* select */);
    props.onActivateTool?.("select" /* select */);
  }
  function activateDrawTool() {
    const tlEditor = props.getTlEditor();
    if (!tlEditor)
      return;
    tlEditor.setCurrentTool("draw");
    setCurTool("draw" /* draw */);
    props.onActivateTool?.("draw" /* draw */);
  }
  function activateEraseTool() {
    const tlEditor = props.getTlEditor();
    if (!tlEditor)
      return;
    tlEditor.setCurrentTool("eraser");
    setCurTool("eraser" /* eraser */);
    props.onActivateTool?.("eraser" /* eraser */);
  }
  return /* @__PURE__ */ React78.createElement(React78.Fragment, null, /* @__PURE__ */ React78.createElement("div", {
    className: (0, import_classnames30.default)([
      "ink_menu-bar",
      "ink_menu-bar_full"
    ])
  }, props.onExpandClick && /* @__PURE__ */ React78.createElement("div", {
    className: "ink_quick-menu"
  }, /* @__PURE__ */ React78.createElement(TooltipButton, {
    tooltip: "Open in full view",
    onClick: () => props.onExpandClick?.()
  }, /* @__PURE__ */ React78.createElement(ExpandIcon, null))), /* @__PURE__ */ React78.createElement("div", {
    className: "ink_tool-menu"
  }, /* @__PURE__ */ React78.createElement(TooltipButton, {
    tooltip: "Select",
    onClick: activateSelectTool,
    disabled: curTool === "select" /* select */
  }, /* @__PURE__ */ React78.createElement(SelectIcon, null)), /* @__PURE__ */ React78.createElement(TooltipButton, {
    tooltip: "Write",
    onClick: activateDrawTool,
    disabled: curTool === "draw" /* draw */
  }, /* @__PURE__ */ React78.createElement(WriteIcon, null)), /* @__PURE__ */ React78.createElement(TooltipButton, {
    tooltip: "Erase",
    onClick: activateEraseTool,
    disabled: curTool === "eraser" /* eraser */
  }, /* @__PURE__ */ React78.createElement(EraseIcon, null))), /* @__PURE__ */ React78.createElement("div", {
    className: "ink_other-menu"
  })));
};

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
var React114 = __toESM(require_react());
init_constants();

// src/components/formats/v1-code-blocks/utils/build-file-data.ts
init_constants();
var buildWritingFileData_v1 = (props) => {
  return buildFileData_v1(props);
};
var buildDrawingFileData_v1 = (props) => {
  return buildFileData_v1(props);
};
var buildFileData_v1 = (props) => {
  const { tlEditorSnapshot, previewUri, previewIsOutdated = false } = props;
  let pageData = {
    meta: {
      pluginVersion: PLUGIN_VERSION,
      tldrawVersion: TLDRAW_VERSION
    },
    tldraw: tlEditorSnapshot
  };
  if (previewIsOutdated)
    pageData.meta.previewIsOutdated = previewIsOutdated;
  if (previewUri)
    pageData.previewUri = previewUri;
  return pageData;
};

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
init_primary_menu_bar();
init_extended_writing_menu();
var import_classnames42 = __toESM(require_classnames());

// src/components/formats/v1-code-blocks/writing/writing-shapes/writing-lines.tsx
init_dist_esm12();
init_dist_esm12();
var React84 = __toESM(require_react());
init_constants();
var WritingLinesUtil_v1 = class extends ShapeUtil {
  constructor() {
    super(...arguments);
    this.canBind = (opts) => false;
    this.hideRotateHandle = (shape) => true;
    this.onTranslate = (initShape, newShape) => {
      return initShape;
    };
    this.onResize = (shape, info2) => {
      return resizeBox(shape, info2, {
        minWidth: WRITING_PAGE_WIDTH,
        maxWidth: WRITING_PAGE_WIDTH,
        minHeight: WRITING_MIN_PAGE_HEIGHT,
        maxHeight: 5e4
      });
    };
  }
  getDefaultProps() {
    return {
      x: 0,
      y: 0,
      w: WRITING_PAGE_WIDTH,
      h: WRITING_MIN_PAGE_HEIGHT
    };
  }
  getGeometry(shape) {
    return new Rectangle2d({
      width: shape.props.w,
      height: shape.props.h,
      isFilled: false
    });
  }
  indicator(shape) {
    return /* @__PURE__ */ React84.createElement(React84.Fragment, null, /* @__PURE__ */ React84.createElement("rect", {
      width: shape.props.w,
      height: shape.props.h,
      rx: 20,
      ry: 20
    }));
  }
  component(shape) {
    return /* @__PURE__ */ React84.createElement(SVGContainer, null, this.createSvg(shape));
  }
  toSvg(shape, ctx) {
    return this.createSvg(shape);
  }
  createSvg(shape) {
    const numberOfLines = Math.floor(shape.props.h / WRITING_LINE_HEIGHT);
    const margin = 0.05 * shape.props.w;
    this.isAspectRatioLocked(shape);
    const lines = Array.from({ length: numberOfLines }, (_2, index3) => /* @__PURE__ */ React84.createElement("line", {
      key: index3,
      x1: margin,
      y1: (index3 + 1) * WRITING_LINE_HEIGHT,
      x2: shape.props.w - margin,
      y2: (index3 + 1) * WRITING_LINE_HEIGHT
    }));
    return /* @__PURE__ */ React84.createElement(React84.Fragment, null, lines);
  }
};
WritingLinesUtil_v1.type = "writing-lines";

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
init_esm();

// src/components/formats/v1-code-blocks/utils/getInkFileData.ts
init_global_store();
async function getInkFileData(file) {
  const v2 = getGlobals().plugin.app.vault;
  const inkFileDataStr = await v2.read(file);
  const inkFileData = JSON.parse(inkFileDataStr);
  return inkFileData;
}

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
init_universal_dev_logging();
init_legacy_ink_notice();

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/finger-blocker/finger-blocker.tsx
var React113 = __toESM(require_react());
var INK_CM_SCROLLER_SCROLL_PINNED_CLASS2 = "ink-cm-scroller--scroll-pinned";
var INK_FINGER_BLOCKER_TOUCH_NONE_CLASS2 = "ink-finger-blocker--touch-none";
var INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS2 = "ink-finger-blocker--touch-pan-xy";
function setFingerBlockerTouchMode2(blockerElement, mode) {
  blockerElement.classList.remove(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS2, INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS2);
  if (mode === "none")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS2);
  else if (mode === "pan-xy")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS2);
}
var POLL_INTERVAL_MS2 = 100;
var MAX_POLL_RETRIES2 = 200;
function FingerBlocker2({ getTlEditor, wrapperRef, enableTwoFingerGestures, onVerticalTouchPan }) {
  const blockerRef = React113.useRef(null);
  const pointerDownRef = React113.useRef(false);
  const recentPenInputRef = React113.useRef(false);
  const isPenDownRef = React113.useRef(false);
  const lockedScrollPosRef = React113.useRef(null);
  const activeScrollerRef = React113.useRef(null);
  const currentTldrawToolIdRef = React113.useRef(null);
  const tldrawToolCleanupMap = React113.useRef(/* @__PURE__ */ new Map());
  const activeTouchPointerDataRef = React113.useRef(/* @__PURE__ */ new Map());
  const twoFingerModeActiveRef = React113.useRef(false);
  const prevTwoFingerMidpointRef = React113.useRef({ x: 0, y: 0 });
  const prevTwoFingerDistanceRef = React113.useRef(0);
  const prevCameraLockedRef = React113.useRef(false);
  const twoFingerVerticalPanActiveRef = React113.useRef(false);
  const prevVerticalPanMidpointRef = React113.useRef({ x: 0, y: 0 });
  const onVerticalTouchPanRef = React113.useRef(onVerticalTouchPan);
  React113.useEffect(() => {
    onVerticalTouchPanRef.current = onVerticalTouchPan;
  }, [onVerticalTouchPan]);
  const getWrapper = () => {
    return wrapperRef?.current || blockerRef.current?.parentElement || null;
  };
  const getCanvas = () => {
    const wrapper = getWrapper();
    return wrapper ? wrapper.querySelector(".tl-canvas") : null;
  };
  const getScroller = () => {
    const wrapper = getWrapper();
    return wrapper ? wrapper.closest(".cm-scroller") : null;
  };
  const lockScroll = () => {
    const scroller = getScroller();
    if (scroller) {
      activeScrollerRef.current = scroller;
      lockedScrollPosRef.current = { x: scroller.scrollLeft, y: scroller.scrollTop };
      scroller.classList.add(INK_CM_SCROLLER_SCROLL_PINNED_CLASS2);
    }
  };
  const unlockScroll = () => {
    if (isPenDownRef.current) {
      isPenDownRef.current = false;
      if (activeScrollerRef.current) {
        activeScrollerRef.current.style.overflow = "auto";
        window.setTimeout(() => {
          if (activeScrollerRef.current) {
            activeScrollerRef.current.style.scrollbarColor = "auto";
          }
        }, 200);
        activeScrollerRef.current = null;
      }
      lockedScrollPosRef.current = null;
    } else {
      const scroller = getScroller();
      if (scroller) {
        scroller.style.overflow = "auto";
        window.setTimeout(() => {
          scroller.style.scrollbarColor = "auto";
        }, 200);
      }
    }
  };
  const closeKeyboard = () => {
    const active = activeDocument.activeElement;
    if (active && !active.classList.contains("tl-canvas")) {
      active.blur();
    }
  };
  React113.useEffect(() => {
    const element = blockerRef.current;
    if (!element)
      return;
    const handlePointerDown = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        if (e2.pointerType === "mouse" && (e2.button === 3 || e2.button === 4))
          return;
        const isDrawingInput = e2.pointerType === "pen" || e2.button === 0;
        if (isDrawingInput) {
          lockScroll();
          isPenDownRef.current = true;
        }
        setFingerBlockerTouchMode2(element, "none");
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        try {
          target.setPointerCapture(e2.pointerId);
        } catch {
        }
        const canvas = getCanvas();
        if (canvas) {
          const forwarded = new PointerEvent("pointerdown", {
            pointerId: e2.pointerId,
            pointerType: e2.pointerType,
            clientX: e2.clientX,
            clientY: e2.clientY,
            bubbles: true,
            cancelable: true,
            view: window,
            detail: e2.detail,
            screenX: e2.screenX,
            screenY: e2.screenY,
            ctrlKey: e2.ctrlKey,
            shiftKey: e2.shiftKey,
            altKey: e2.altKey,
            metaKey: e2.metaKey,
            button: e2.button,
            buttons: e2.buttons
          });
          canvas.dispatchEvent(forwarded);
          recentPenInputRef.current = true;
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          pointerId: e2.pointerId,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY,
          width: e2.width,
          height: e2.height,
          pressure: e2.pressure
        });
        const touchCount = activeTouchPointerDataRef.current.size;
        const verticalTouchPan = onVerticalTouchPanRef.current;
        if (verticalTouchPan) {
          e2.preventDefault();
          e2.stopPropagation();
          e2.stopImmediatePropagation();
          setFingerBlockerTouchMode2(element, "none");
          if (touchCount >= 2 && !twoFingerVerticalPanActiveRef.current) {
            twoFingerVerticalPanActiveRef.current = true;
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            prevVerticalPanMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2,
              y: (pa.clientY + pb.clientY) / 2
            };
          }
        } else if (touchCount >= 2 && enableTwoFingerGestures && !twoFingerModeActiveRef.current) {
          e2.preventDefault();
          e2.stopPropagation();
          setFingerBlockerTouchMode2(element, "none");
          twoFingerModeActiveRef.current = true;
          const editorForLock = getTlEditor();
          prevCameraLockedRef.current = editorForLock ? editorForLock.getCameraOptions().isLocked : false;
          editorForLock?.setCameraOptions({ isLocked: false });
          const editor = getTlEditor();
          if (editor) {
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            const containerRect = editor.getContainer().getBoundingClientRect();
            prevTwoFingerMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2 - containerRect.left,
              y: (pa.clientY + pb.clientY) / 2 - containerRect.top
            };
            prevTwoFingerDistanceRef.current = Math.hypot(pb.clientX - pa.clientX, pb.clientY - pa.clientY);
          }
        } else if (!twoFingerModeActiveRef.current) {
          setFingerBlockerTouchMode2(element, "pan-xy");
        }
      }
    };
    const handlePointerMove = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (isPenDownRef.current && activeScrollerRef.current && lockedScrollPosRef.current) {
          const scroller = activeScrollerRef.current;
          if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
            scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
          }
        }
      } else if (e2.pointerType === "touch" && twoFingerVerticalPanActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const currentMidpoint = {
          x: (p0.clientX + p1.clientX) / 2,
          y: (p0.clientY + p1.clientY) / 2
        };
        const prevMidpoint = prevVerticalPanMidpointRef.current;
        const deltaX = currentMidpoint.x - prevMidpoint.x;
        const deltaY = currentMidpoint.y - prevMidpoint.y;
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (Math.abs(deltaY) >= Math.abs(deltaX)) {
          onVerticalTouchPanRef.current?.(-deltaY);
        }
        prevVerticalPanMidpointRef.current = currentMidpoint;
      } else if (e2.pointerType === "touch" && onVerticalTouchPanRef.current && !twoFingerVerticalPanActiveRef.current) {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        recentPenInputRef.current = false;
        if (e2.movementY !== 0) {
          onVerticalTouchPanRef.current(-e2.movementY);
        }
      } else if (e2.pointerType === "touch" && recentPenInputRef.current) {
        const scroller = getScroller();
        if (scroller) {
          scroller.scrollTo({
            top: scroller.scrollTop - e2.movementY,
            left: scroller.scrollLeft - e2.movementX
          });
        }
      } else if (e2.pointerType === "touch" && twoFingerModeActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        const editor = getTlEditor();
        if (!editor)
          return;
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const containerRect = editor.getContainer().getBoundingClientRect();
        const cm = {
          x: (p0.clientX + p1.clientX) / 2 - containerRect.left,
          y: (p0.clientY + p1.clientY) / 2 - containerRect.top
        };
        const curDist = Math.hypot(p1.clientX - p0.clientX, p1.clientY - p0.clientY);
        const pm = prevTwoFingerMidpointRef.current;
        const prevDist = prevTwoFingerDistanceRef.current;
        const { x: cx, y: cy, z: cz } = editor.getCamera();
        const { zoomSteps } = editor.getCameraOptions();
        const factor = prevDist > 0 ? curDist / prevDist : 1;
        const newZ = Math.max(zoomSteps[0], Math.min(zoomSteps[zoomSteps.length - 1], cz * factor));
        const newCx = cx + cm.x / newZ - pm.x / cz;
        const newCy = cy + cm.y / newZ - pm.y / cz;
        editor.setCamera({ x: newCx, y: newCy, z: newZ }, { animation: { duration: 0 } });
        prevTwoFingerMidpointRef.current = cm;
        prevTwoFingerDistanceRef.current = curDist;
      }
    };
    const handlePointerUp = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        setFingerBlockerTouchMode2(element, "default");
        unlockScroll();
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        recentPenInputRef.current = false;
        if (onVerticalTouchPanRef.current) {
          if (twoFingerVerticalPanActiveRef.current && activeTouchPointerDataRef.current.size < 2) {
            twoFingerVerticalPanActiveRef.current = false;
          }
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode2(element, "default");
          } else {
            setFingerBlockerTouchMode2(element, "none");
          }
        }
      }
    };
    const handlePointerCancel = (e2) => {
      setFingerBlockerTouchMode2(element, "default");
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        unlockScroll();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (onVerticalTouchPanRef.current) {
          twoFingerVerticalPanActiveRef.current = false;
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode2(element, "default");
          }
        }
      }
    };
    const handleWheel = (e2) => {
      if (isPenDownRef.current) {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
      }
    };
    const handleTouchMove = (e2) => {
      const isDedicatedVerticalPan = twoFingerVerticalPanActiveRef.current || onVerticalTouchPanRef.current && activeTouchPointerDataRef.current.size > 0;
      if (isPenDownRef.current || twoFingerModeActiveRef.current || isDedicatedVerticalPan) {
        e2.preventDefault();
        if (isPenDownRef.current || twoFingerModeActiveRef.current || isDedicatedVerticalPan) {
          e2.stopPropagation();
          e2.stopImmediatePropagation();
        }
      }
    };
    const handleLostPointerCapture = () => {
      if (isPenDownRef.current) {
        console.debug("[FingerBlocker] lostpointercapture \u2014 unlocking scroll");
        unlockScroll();
      }
    };
    const handleTouchEnd = (e2) => {
      Array.from(e2.changedTouches).forEach((touch) => {
        activeTouchPointerDataRef.current.delete(touch.identifier);
      });
      if (onVerticalTouchPanRef.current) {
        if (twoFingerVerticalPanActiveRef.current && e2.touches.length < 2) {
          twoFingerVerticalPanActiveRef.current = false;
        }
        if (e2.touches.length === 0) {
          setFingerBlockerTouchMode2(element, "default");
          activeTouchPointerDataRef.current.clear();
        }
        return;
      }
      if (!enableTwoFingerGestures)
        return;
      if (twoFingerModeActiveRef.current && e2.touches.length < 2) {
        getTlEditor()?.setCameraOptions({ isLocked: prevCameraLockedRef.current });
        twoFingerModeActiveRef.current = false;
      }
      if (e2.touches.length === 0) {
        setFingerBlockerTouchMode2(element, "default");
        activeTouchPointerDataRef.current.clear();
      }
    };
    element.addEventListener("pointerdown", handlePointerDown, { passive: false, capture: true });
    element.addEventListener("pointermove", handlePointerMove, { passive: false, capture: true });
    element.addEventListener("pointerup", handlePointerUp, { passive: false, capture: true });
    element.addEventListener("pointercancel", handlePointerCancel, { passive: false, capture: true });
    element.addEventListener("lostpointercapture", handleLostPointerCapture);
    element.addEventListener("wheel", handleWheel, { passive: false, capture: true });
    element.addEventListener("touchmove", handleTouchMove, { passive: false, capture: true });
    element.addEventListener("touchend", handleTouchEnd, { passive: true, capture: true });
    element.addEventListener("touchcancel", handleTouchEnd, { passive: true, capture: true });
    return () => {
      element.removeEventListener("pointerdown", handlePointerDown, { capture: true });
      element.removeEventListener("pointermove", handlePointerMove, { capture: true });
      element.removeEventListener("pointerup", handlePointerUp, { capture: true });
      element.removeEventListener("pointercancel", handlePointerCancel, { capture: true });
      element.removeEventListener("lostpointercapture", handleLostPointerCapture);
      element.removeEventListener("wheel", handleWheel, { capture: true });
      element.removeEventListener("touchmove", handleTouchMove, { capture: true });
      element.removeEventListener("touchend", handleTouchEnd, { capture: true });
      element.removeEventListener("touchcancel", handleTouchEnd, { capture: true });
    };
  }, [enableTwoFingerGestures, onVerticalTouchPan]);
  React113.useEffect(() => {
    const scroller = getScroller();
    if (!scroller)
      return;
    const handleScroll2 = (e2) => {
      if (isPenDownRef.current && lockedScrollPosRef.current) {
        if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
          scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
        }
      }
    };
    scroller.addEventListener("scroll", handleScroll2, { passive: false, capture: true });
    return () => {
      scroller.removeEventListener("scroll", handleScroll2, { capture: true });
    };
  }, [getTlEditor]);
  const hasToolChanged = (entry) => {
    if (!entry.changes?.updated)
      return false;
    for (const [from, to] of Object.values(entry.changes.updated)) {
      if (typeof from === "object" && from !== null && typeof to === "object" && to !== null && "typeName" in from && "typeName" in to && from.typeName === "instance" && to.typeName === "instance") {
        return true;
      }
    }
    return false;
  };
  const wrapToolWithScrollHandlers = (tool) => {
    const prevDown = tool.onPointerDown;
    const prevUp = tool.onPointerUp;
    const prevMove = tool.onPointerMove;
    tool.onPointerDown = (e2) => {
      pointerDownRef.current = true;
      lockScroll();
      prevDown?.(e2);
    };
    tool.onPointerUp = (e2) => {
      pointerDownRef.current = false;
      unlockScroll();
      prevUp?.(e2);
    };
    tool.onPointerMove = (e2) => {
      prevMove?.(e2);
    };
    return () => {
      if (tool) {
        tool.onPointerDown = prevDown;
        tool.onPointerUp = prevUp;
        tool.onPointerMove = prevMove;
      }
    };
  };
  const listenForToolChangesAndUpdateHandlers = () => {
    const editor = getTlEditor();
    if (!editor)
      return () => {
      };
    const handleToolChange = () => {
      const editor2 = getTlEditor();
      if (!editor2)
        return;
      const newToolId = editor2.getCurrentToolId();
      const previousToolId = currentTldrawToolIdRef.current;
      if (newToolId === previousToolId)
        return;
      if (previousToolId && tldrawToolCleanupMap.current.has(previousToolId)) {
        const cleanup = tldrawToolCleanupMap.current.get(previousToolId);
        if (cleanup) {
          cleanup();
          tldrawToolCleanupMap.current.delete(previousToolId);
        }
      }
      if (newToolId) {
        const tool = editor2.getCurrentTool();
        if (tool) {
          if (!tldrawToolCleanupMap.current.has(newToolId)) {
            const toolCleanupFn = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(newToolId, toolCleanupFn);
            currentTldrawToolIdRef.current = newToolId;
          }
        }
      }
    };
    return editor.store.listen((entry) => {
      if (hasToolChanged(entry)) {
        handleToolChange();
      }
    }, {
      source: "all",
      scope: "all"
    });
  };
  const listenForEditorToBecomeAvailable = (getTlEditor2, onEditorReady) => {
    let pollInterval = null;
    let setupComplete = false;
    let retryCount = 0;
    pollInterval = window.setInterval(() => {
      if (setupComplete)
        return;
      const editor = getTlEditor2();
      if (editor) {
        setupComplete = true;
        onEditorReady(editor);
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
      retryCount++;
      if (retryCount >= MAX_POLL_RETRIES2) {
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
    }, POLL_INTERVAL_MS2);
    return () => {
      if (pollInterval) {
        window.clearInterval(pollInterval);
      }
    };
  };
  React113.useEffect(() => {
    let storeListenerCleanup = null;
    const stopPolling = listenForEditorToBecomeAvailable(getTlEditor, () => {
      const editor = getTlEditor();
      if (!editor)
        return;
      const initialToolId = editor.getCurrentToolId();
      if (initialToolId) {
        const tool = editor.getCurrentTool();
        if (tool) {
          const editorToolId = editor.getCurrentToolId();
          if (editorToolId === initialToolId && !tldrawToolCleanupMap.current.has(initialToolId)) {
            const cleanup = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(initialToolId, cleanup);
            currentTldrawToolIdRef.current = initialToolId;
          }
        }
      }
      storeListenerCleanup = listenForToolChangesAndUpdateHandlers();
    });
    return () => {
      stopPolling();
      if (storeListenerCleanup) {
        storeListenerCleanup();
      }
      tldrawToolCleanupMap.current.forEach((cleanup) => {
        cleanup();
      });
      tldrawToolCleanupMap.current.clear();
    };
  }, [getTlEditor]);
  return /* @__PURE__ */ React113.createElement("div", {
    ref: blockerRef,
    style: {
      position: "absolute",
      inset: 0,
      zIndex: 1e3,
      userSelect: "none",
      WebkitUserSelect: "none",
      MozUserSelect: "none",
      msUserSelect: "none"
    },
    onPointerEnter: (e2) => {
      closeKeyboard();
    }
  });
}

// src/components/formats/v1-code-blocks/writing/tldraw-writing-editor/tldraw-writing-editor.tsx
var TldrawWritingEditorWrapper_v1 = (props) => {
  const editorActive = useAtomValue(editorActiveAtom_v1);
  if (editorActive) {
    return /* @__PURE__ */ React114.createElement(TldrawWritingEditor_v1, {
      ...props
    });
  } else {
    return /* @__PURE__ */ React114.createElement(React114.Fragment, null);
  }
};
var MyCustomShapes_v1 = [WritingContainerUtil_v1, WritingLinesUtil_v1];
var tlOptions_v1 = {
  defaultSvgPadding: 0
};
function TldrawWritingEditor_v1(props) {
  const [tlEditorSnapshot, setTlEditorSnapshot] = React114.useState();
  const setEmbedState = useSetAtom(embedStateAtom_v1);
  const shortDelayPostProcessTimeoutRef = (0, import_react136.useRef)();
  const longDelayPostProcessTimeoutRef = (0, import_react136.useRef)();
  const tlEditorRef = (0, import_react136.useRef)();
  const tlEditorWrapperElRef = (0, import_react136.useRef)(null);
  const { stashStaleContent, unstashStaleContent } = useStash(props.plugin);
  const cameraLimitsRef = (0, import_react136.useRef)();
  React114.useEffect(() => {
    verbose("EDITOR mounted");
    void fetchFileData();
    return () => {
      verbose("EDITOR unmounting");
    };
  }, []);
  React114.useEffect(() => {
    if (!tlEditorSnapshot)
      return;
    showLegacyInkUnlockNotice({
      plugin: props.plugin,
      legacyFile: props.writingFile,
      isEmbedded: props.embedded
    });
  }, [tlEditorSnapshot]);
  if (!tlEditorSnapshot)
    return /* @__PURE__ */ React114.createElement(React114.Fragment, null);
  verbose("EDITOR snapshot loaded");
  const defaultComponents = {
    Scribble: TldrawScribble,
    ShapeIndicators: TldrawShapeIndicators,
    CollaboratorScribble: TldrawScribble,
    SelectionForeground: TldrawSelectionForeground,
    SelectionBackground: TldrawSelectionBackground,
    Handles: TldrawHandles
  };
  const handleMount = (_tlEditor) => {
    const tlEditor = tlEditorRef.current = _tlEditor;
    setEmbedState("editor" /* editor */);
    focusChildTldrawEditor(tlEditorWrapperElRef.current);
    preventTldrawCanvasesCausingObsidianGestures(tlEditor);
    if (tlEditorWrapperElRef.current) {
      tlEditorWrapperElRef.current.classList.remove("ddc_ink_editor-wrapper--loading");
    }
    updateWritingStoreIfNeeded(tlEditor);
    adaptTldrawToObsidianThemeMode(tlEditor);
    resizeWritingTemplateInvitingly(tlEditor);
    resizeContainerIfEmbed(tlEditor);
    if (props.embedded) {
      initWritingCamera(tlEditor);
      tlEditor.setCameraOptions({
        isLocked: true
      });
    } else {
      initWritingCamera(tlEditor, MENUBAR_HEIGHT_PX);
      cameraLimitsRef.current = initWritingCameraLimits(tlEditor);
    }
    const removeUserActionListener = tlEditor.store.listen((entry) => {
      if (!tlEditorWrapperElRef.current)
        return;
      const activity = getActivityType(entry);
      switch (activity) {
        case 0 /* PointerMoved */:
          break;
        case 2 /* CameraMovedAutomatically */:
        case 1 /* CameraMovedManually */:
          if (cameraLimitsRef.current)
            restrictWritingCamera(tlEditor, cameraLimitsRef.current);
          unstashStaleContent(tlEditor);
          break;
        case 3 /* DrawingStarted */:
          resetInputPostProcessTimers();
          stashStaleContent(tlEditor);
          break;
        case 4 /* DrawingContinued */:
          resetInputPostProcessTimers();
          break;
        case 5 /* DrawingCompleted */:
          queueOrRunStorePostProcesses(tlEditor);
          break;
        case 6 /* DrawingErased */:
          queueOrRunStorePostProcesses(tlEditor);
          break;
        default:
      }
    }, {
      source: "user",
      scope: "all"
    });
    const unmountActions = () => {
      resetInputPostProcessTimers();
      removeUserActionListener();
    };
    if (props.saveControlsReference) {
      props.saveControlsReference({
        saveAndHalt: async () => {
          await completeSave(tlEditor);
          unmountActions();
        },
        resize: () => {
          const camera = tlEditor.getCamera();
          const cameraY = camera.y;
          initWritingCamera(tlEditor);
          tlEditor.setCamera({ x: camera.x, y: cameraY });
        }
      });
    }
    return () => {
      unmountActions();
    };
  };
  function resizeContainerIfEmbed(editor) {
    if (!props.embedded || !props.onResize)
      return;
    const embedBounds = editor.getViewportScreenBounds();
    const contentBounds = getWritingContainerBounds(editor);
    if (contentBounds) {
      const contentRatio = contentBounds.w / contentBounds.h;
      const newEmbedHeight = embedBounds.w / contentRatio;
      props.onResize(newEmbedHeight);
    }
  }
  const queueOrRunStorePostProcesses = (editor) => {
    instantInputPostProcess(editor);
    smallDelayInputPostProcess(editor);
    longDelayInputPostProcess(editor);
  };
  const instantInputPostProcess = (editor) => {
    resizeWritingTemplateInvitingly(editor);
    resizeContainerIfEmbed(editor);
  };
  const smallDelayInputPostProcess = (editor) => {
    resetShortPostProcessTimer();
    shortDelayPostProcessTimeoutRef.current = window.setTimeout(() => {
      void incrementalSave(editor);
    }, WRITE_SHORT_DELAY_MS);
  };
  const longDelayInputPostProcess = (editor) => {
    resetLongPostProcessTimer();
    longDelayPostProcessTimeoutRef.current = window.setTimeout(() => {
      void completeSave(editor);
    }, WRITE_LONG_DELAY_MS);
  };
  const resetShortPostProcessTimer = () => {
    window.clearTimeout(shortDelayPostProcessTimeoutRef.current);
  };
  const resetLongPostProcessTimer = () => {
    window.clearTimeout(longDelayPostProcessTimeoutRef.current);
  };
  const resetInputPostProcessTimers = () => {
    resetShortPostProcessTimer();
    resetLongPostProcessTimer();
  };
  const incrementalSave = async (editor) => {
    unstashStaleContent(editor);
    const tlEditorSnapshot2 = getSnapshot(editor.store);
    stashStaleContent(editor);
    const pageData = buildWritingFileData_v1({
      tlEditorSnapshot: tlEditorSnapshot2,
      previewIsOutdated: true
    });
    props.save(pageData);
  };
  const completeSave = async (editor) => {
    let previewUri;
    unstashStaleContent(editor);
    const tlEditorSnapshot2 = getSnapshot(editor.store);
    const svgObj = await getWritingSvg(editor);
    stashStaleContent(editor);
    if (svgObj) {
      previewUri = svgObj.svg;
    }
    if (previewUri) {
      const pageData = buildWritingFileData_v1({
        tlEditorSnapshot: tlEditorSnapshot2,
        previewUri
      });
      props.save(pageData);
    } else {
      const pageData = buildWritingFileData_v1({
        tlEditorSnapshot: tlEditorSnapshot2
      });
      props.save(pageData);
    }
    return;
  };
  const getTlEditor = () => {
    return tlEditorRef.current;
  };
  return /* @__PURE__ */ React114.createElement(React114.Fragment, null, /* @__PURE__ */ React114.createElement("div", {
    ref: tlEditorWrapperElRef,
    className: (0, import_classnames42.default)([
      "ddc_ink_writing-editor",
      "ddc_ink_editor-wrapper--loading"
    ]),
    style: {
      height: "100%",
      position: "relative"
    }
  }, /* @__PURE__ */ React114.createElement(TldrawEditor, {
    options: tlOptions_v1,
    shapeUtils: [...defaultShapeUtils, ...MyCustomShapes_v1],
    tools: [...defaultTools, ...defaultShapeTools],
    initialState: "draw",
    snapshot: tlEditorSnapshot,
    components: defaultComponents,
    onMount: handleMount,
    autoFocus: false
  }), /* @__PURE__ */ React114.createElement(FingerBlocker2, {
    getTlEditor,
    wrapperRef: tlEditorWrapperElRef
  }), /* @__PURE__ */ React114.createElement(PrimaryMenuBar, null, /* @__PURE__ */ React114.createElement(WritingMenu, {
    getTlEditor,
    onStoreChange: (tlEditor) => queueOrRunStorePostProcesses(tlEditor)
  }), props.embedded && props.extendedMenu && /* @__PURE__ */ React114.createElement(extended_writing_menu_default, {
    onLockClick: () => void props.closeEditor?.(),
    menuOptions: props.extendedMenu
  }))));
  async function fetchFileData() {
    const inkFileData = await getInkFileData(props.writingFile);
    if (inkFileData.tldraw) {
      const snapshot = prepareWritingSnapshot(inkFileData.tldraw);
      setTlEditorSnapshot(snapshot);
    }
  }
}

// src/components/formats/v1-code-blocks/writing/writing-embed-editor/writing-embed.tsx
init_storage();
init_universal_dev_logging();

// src/components/formats/v1-code-blocks/writing/writing-embed-preview/writing-embed-preview.tsx
var import_classnames43 = __toESM(require_classnames());
var React115 = __toESM(require_react());
init_dist33();
init_esm();
init_empty_writing_embed();
var WritingEmbedPreviewWrapper_v1 = (props) => {
  const previewActive = useAtomValue(previewActiveAtom);
  if (previewActive) {
    return /* @__PURE__ */ React115.createElement(WritingEmbedPreview_v1, {
      ...props
    });
  } else {
    return /* @__PURE__ */ React115.createElement(React115.Fragment, null);
  }
};
var WritingEmbedPreview_v1 = (props) => {
  const containerElRef = React115.useRef(null);
  const setEmbedState = useSetAtom(embedStateAtom_v1);
  const [fileSrc, setFileSrc] = React115.useState(empty_writing_embed_default);
  React115.useEffect(() => {
    void fetchFileData();
    return () => {
    };
  });
  const isImg = fileSrc.slice(0, 4) === "data";
  return /* @__PURE__ */ React115.createElement(React115.Fragment, null, /* @__PURE__ */ React115.createElement("div", {
    ref: containerElRef,
    className: (0, import_classnames43.default)([
      "ddc_ink_writing-embed-preview",
      props.plugin.settings.writingLinesWhenLocked && "ddc_ink_visible-lines",
      props.plugin.settings.writingBackgroundWhenLocked && "ddc_ink_visible-background"
    ]),
    style: {
      position: "absolute",
      width: "100%"
    },
    onClick: props.onClick
  }, isImg && /* @__PURE__ */ React115.createElement(React115.Fragment, null, /* @__PURE__ */ React115.createElement("img", {
    src: fileSrc,
    style: {
      width: "100%",
      cursor: "pointer",
      pointerEvents: "all"
    },
    onLoad
  })), !isImg && /* @__PURE__ */ React115.createElement(React115.Fragment, null, /* @__PURE__ */ React115.createElement(InlineSVG, {
    src: fileSrc,
    style: {
      width: "100%",
      height: "unset",
      cursor: "pointer"
    },
    pointerEvents: "visible",
    onLoad
  }))));
  function onLoad() {
    recalcHeight();
    window.setTimeout(() => {
      setEmbedState("preview" /* preview */);
    }, 100);
  }
  async function fetchFileData() {
    const inkFileData = await getInkFileData(props.writingFile);
    if (inkFileData.previewUri)
      setFileSrc(inkFileData.previewUri);
  }
  function recalcHeight() {
    if (!containerElRef.current)
      return;
    const observer = new IntersectionObserver((entries) => {
      entries.forEach((entry) => {
        if (entry.target !== containerElRef.current)
          return;
        if (!entry.isIntersecting)
          return;
        const rect = containerElRef.current.getBoundingClientRect();
        props.onResize(rect.height);
        observer.unobserve(containerElRef.current);
      });
    });
    observer.observe(containerElRef.current);
  }
};

// src/components/formats/v1-code-blocks/writing/writing-embed-editor/writing-embed.tsx
var import_classnames44 = __toESM(require_classnames());
init_esm();
var embedStateAtom_v1 = atom("preview" /* preview */);
var previewActiveAtom = atom((get) => {
  const embedState = get(embedStateAtom_v1);
  return embedState !== "editor" /* editor */;
});
var editorActiveAtom_v1 = atom((get) => {
  const embedState = get(embedStateAtom_v1);
  return embedState !== "preview" /* preview */;
});
function WritingEmbed_v1(props) {
  const embedContainerElRef = (0, import_react137.useRef)(null);
  const resizeContainerElRef = (0, import_react137.useRef)(null);
  const editorControlsRef = (0, import_react137.useRef)();
  const setEmbedState = useSetAtom(embedStateAtom_v1);
  React116.useEffect(() => {
    if (embedShouldActivateImmediately()) {
      window.setTimeout(() => {
        switchToEditMode();
      }, 200);
    }
  }, []);
  const commonExtendedOptions = [
    {
      text: "Remove embed",
      action: () => {
        props.remove();
      }
    }
  ];
  return /* @__PURE__ */ React116.createElement(React116.Fragment, null, /* @__PURE__ */ React116.createElement("div", {
    ref: embedContainerElRef,
    className: (0, import_classnames44.default)([
      "ddc_ink_embed",
      "ddc_ink_writing-embed"
    ]),
    style: {
      paddingTop: "1em",
      paddingBottom: "0.5em"
    }
  }, /* @__PURE__ */ React116.createElement("div", {
    className: "ddc_ink_resize-container",
    ref: resizeContainerElRef
  }, /* @__PURE__ */ React116.createElement(WritingEmbedPreviewWrapper_v1, {
    plugin: props.plugin,
    onResize: (height) => resizeContainer(height),
    writingFile: props.writingFileRef,
    onClick: () => switchToEditMode()
  }), /* @__PURE__ */ React116.createElement(TldrawWritingEditorWrapper_v1, {
    plugin: props.plugin,
    onResize: (height) => resizeContainer(height),
    writingFile: props.writingFileRef,
    save: props.save,
    embedded: true,
    saveControlsReference: registerEditorControls,
    closeEditor: () => void saveAndSwitchToPreviewMode(),
    extendedMenu: commonExtendedOptions
  }))));
  function registerEditorControls(handlers) {
    editorControlsRef.current = handlers;
  }
  function resizeContainer(height) {
    if (!resizeContainerElRef.current)
      return;
    resizeContainerElRef.current.style.height = height + "px";
    window.setTimeout(() => {
      if (!resizeContainerElRef.current)
        return;
      resizeContainerElRef.current.classList.add("ddc_ink_smooth-transition");
    }, 100);
  }
  function switchToEditMode() {
    verbose("Set WritingEmbedState: loadingEditor");
    setEmbedState("loadingEditor" /* loadingEditor */);
  }
  async function saveAndSwitchToPreviewMode() {
    verbose("Set WritingEmbedState: loadingPreview");
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    setEmbedState("unloadingEditor" /* loadingPreview */);
  }
}

// src/components/formats/v1-code-blocks/drawing/widgets/writing-embed-widget.tsx
init_constants();
init_esm();
function registerWritingEmbed_v1(plugin) {
  plugin.registerMarkdownCodeBlockProcessor(WRITE_EMBED_KEY, (source, el, ctx) => {
    const embedData = JSON.parse(source);
    const embedCtrls = {
      removeEmbed: () => removeEmbed(plugin, ctx, el)
    };
    if (embedData.filepath) {
      ctx.addChild(new WritingEmbedWidget_v1(el, plugin, embedData, embedCtrls));
    }
  });
}
var WritingEmbedWidget_v1 = class extends import_obsidian35.MarkdownRenderChild {
  constructor(el, plugin, embedData, embedCtrls) {
    super(el);
    this.save = async (pageData) => {
      if (!this.fileRef)
        return;
      const pageDataStr = buildFileStr_v1(pageData);
      await this.plugin.app.vault.modify(this.fileRef, pageDataStr);
    };
    this.el = el;
    this.plugin = plugin;
    this.embedData = embedData;
    this.embedCtrls = embedCtrls;
  }
  onload() {
    void this.mountWritingEmbed();
  }
  async mountWritingEmbed() {
    const v2 = this.plugin.app.vault;
    const abstractFile = v2.getAbstractFileByPath(this.embedData.filepath);
    this.fileRef = abstractFile instanceof import_obsidian35.TFile ? abstractFile : null;
    if (!this.fileRef) {
      this.el.createEl("p").textContent = "Ink writing file not found: " + this.embedData.filepath;
      return;
    }
    const pageDataStr = await v2.read(this.fileRef);
    let pageData = null;
    try {
      pageData = JSON.parse(pageDataStr);
    } catch {
      pageData = extractInkJsonFromSvg(pageDataStr);
    }
    if (!pageData) {
      this.el.createEl("p").textContent = "Ink writing file invalid.";
      return;
    }
    if (!this.root)
      this.root = (0, import_client6.createRoot)(this.el);
    this.root.render(/* @__PURE__ */ React117.createElement(Provider, null, /* @__PURE__ */ React117.createElement(WritingEmbed_v1, {
      plugin: this.plugin,
      writingFileRef: this.fileRef,
      pageData,
      save: (embeddedPageData) => void this.save(embeddedPageData),
      remove: this.embedCtrls.removeEmbed
    })));
    applyCommonAncestorStyling(this.el);
  }
  onunload() {
    this.root?.unmount();
  }
};

// src/commands/insert-existing-writing-file.ts
init_build_embeds();
init_open_ink_file_picker();
init_writing_embed_aspect_ratio();
var insertExistingWritingFile = async (plugin, editor) => {
  const sourceFile = plugin.app.workspace.getActiveFile();
  const noteContent = editor.getValue();
  await openInkFilePicker(plugin, "inkWriting", "Select writing", async (file) => {
    const aspectRatio = await readWritingFileAspectRatio(plugin, file);
    const embedStr = buildWritingEmbed(file.path, {
      pendingPaste: true,
      ...aspectRatio != null ? { aspectRatio } : {}
    });
    editor.replaceRange(embedStr, editor.getCursor());
  }, { sourceFile, noteContent });
};

// src/commands/insert-new-writing-file.ts
init_storage();
init_build_embeds();

// src/commands/create-new-writing-file.ts
init_build_file_data();
init_file_manipulation();
init_createFoldersForFilepath();
init_buildFileStr();
init_constants();
init_svg_export();
var createNewWritingFile = async (plugin, instigatingFile) => {
  const filepath = await getNewTimestampedWritingSvgFilepath(plugin, instigatingFile);
  const lineHeight = plugin.settings.writingLineHeight ?? WRITING_LINE_HEIGHT;
  const inkCanvasSnapshot = {
    version: 1,
    strokes: [],
    gridEnabled: false,
    writingLineHeight: lineHeight
  };
  const svgString = renderWritingStrokesToSvg([], inkCanvasSnapshot, WRITING_PAGE_WIDTH);
  const pageData = buildInkCanvasWritingFileData({ inkCanvasSnapshot, svgString });
  await createFoldersForFilepath(plugin, filepath);
  const fileRef = await plugin.app.vault.create(filepath, buildFileStr(pageData));
  return fileRef;
};

// src/commands/insert-new-writing-file.ts
init_writing_embed_aspect_ratio();
var insertNewWritingFile = async (plugin, editor) => {
  const activeFile = plugin.app.workspace.getActiveFile();
  const fileRef = await createNewWritingFile(plugin, activeFile);
  recordRecentFileSelection("inkWriting", fileRef.path);
  const aspectRatio = await readWritingFileAspectRatio(plugin, fileRef);
  const embedStr = buildWritingEmbed(fileRef.path, aspectRatio != null ? { aspectRatio } : void 0);
  activateNextEmbed();
  const positionForEmbed = editor.getCursor();
  editor.replaceRange(embedStr, positionForEmbed);
  const positionForCursor = { ...positionForEmbed };
  const embedLines = embedStr.split(/\r\n|\r|\n/);
  positionForCursor.line += embedLines.length;
  editor.setCursor(positionForCursor);
};

// src/components/formats/v1-code-blocks/writing/writing-view/writing-view.tsx
var import_obsidian36 = require("obsidian");
var React118 = __toESM(require_react());
var import_client7 = __toESM(require_client());
init_constants();
var WRITING_VIEW_V1_TYPE = "ink_writing-v1-view";
function registerWritingView_v1(plugin) {
  plugin.registerView(WRITING_VIEW_V1_TYPE, (leaf) => new WritingView_v1(leaf, plugin));
  plugin.registerExtensions([WRITE_FILE_V1_EXT], WRITING_VIEW_V1_TYPE);
}
var WritingView_v1 = class extends import_obsidian36.TextFileView {
  constructor(leaf, plugin) {
    super(leaf);
    this.tldrawControls = {};
    this.getDisplayText = () => {
      return this.file?.basename || "Handwritten note";
    };
    this.setViewData = (fileContents, clear) => {
      if (!this.file)
        return;
      const pageData = JSON.parse(fileContents);
      this.pageData = pageData;
      const viewContent = this.containerEl.children[1];
      viewContent.setAttr("style", "padding: 0;");
      if (this.root)
        this.clear();
      this.root = (0, import_client7.createRoot)(viewContent);
      this.root.render(/* @__PURE__ */ React118.createElement(TldrawWritingEditor_v1, {
        plugin: this.plugin,
        writingFile: this.file,
        save: this.saveFile,
        saveControlsReference: (controls) => {
          this.tldrawControls.resize = controls.resize;
        }
      }));
    };
    this.saveFile = (pageData) => {
      this.pageData = pageData;
      void this.save(false);
    };
    this.getViewData = () => {
      buildWritingFileData_v1({
        tlEditorSnapshot: this.pageData.tldraw,
        previewIsOutdated: this.pageData.meta.previewIsOutdated,
        transcript: this.pageData.meta.transcript
      });
      return buildFileStr_v1(this.pageData);
    };
    this.clear = () => {
      this.root?.unmount();
    };
    this.onResize = () => {
    };
    this.plugin = plugin;
  }
  getViewType() {
    return WRITING_VIEW_V1_TYPE;
  }
};

// src/commands/insert-existing-drawing-file.ts
init_build_embeds();
init_build_drawing_embed_settings_from_file();
init_open_ink_file_picker();
var insertExistingDrawingFile = async (plugin, editor) => {
  const sourceFile = plugin.app.workspace.getActiveFile();
  const noteContent = editor.getValue();
  await openInkFilePicker(plugin, "inkDrawing", "Select drawing", async (file) => {
    const embedSettings = await buildDrawingEmbedSettingsFromFile(plugin, file);
    const embedStr = buildDrawingEmbed(file.path, {
      pendingPaste: true,
      embedSettings
    });
    editor.replaceRange(embedStr, editor.getCursor());
  }, { sourceFile, noteContent });
};

// src/components/formats/v1-code-blocks/drawing/drawing-view/drawing-view.tsx
var import_obsidian37 = require("obsidian");
var React124 = __toESM(require_react());
var import_client8 = __toESM(require_client());
init_constants();

// src/components/formats/v1-code-blocks/drawing/tldraw-drawing-editor/tldraw-drawing-editor.tsx
init_dist_esm12();
var import_react139 = __toESM(require_react());
var React123 = __toESM(require_react());
init_constants();
init_primary_menu_bar();

// src/components/jsx-components/drawing-menu/drawing-menu.tsx
init_10();
var React119 = __toESM(require_react());
init_select_icon();
init_erase_icon();
init_draw_icon();
var import_classnames45 = __toESM(require_classnames());
init_tooltip_button();
var DrawingMenu = React119.forwardRef((props, ref) => {
  const [curTool, setCurTool] = React119.useState("draw" /* draw */);
  function activateSelectTool() {
    const editor = props.getTlEditor();
    if (!editor)
      return;
    editor.setCurrentTool("select");
    setCurTool("select" /* select */);
    props.onActivateTool?.("select");
  }
  function activateDrawTool() {
    const editor = props.getTlEditor();
    if (!editor)
      return;
    editor.setCurrentTool("draw");
    setCurTool("draw" /* draw */);
    props.onActivateTool?.("draw");
  }
  function activateEraseTool() {
    const editor = props.getTlEditor();
    if (!editor)
      return;
    editor.setCurrentTool("eraser");
    setCurTool("eraser" /* eraser */);
    props.onActivateTool?.("eraser");
  }
  return /* @__PURE__ */ React119.createElement(React119.Fragment, null, /* @__PURE__ */ React119.createElement("div", {
    ref,
    className: (0, import_classnames45.default)([
      "ink_menu-bar",
      "ink_menu-bar_full"
    ])
  }, /* @__PURE__ */ React119.createElement("div", {
    className: "ink_tool-menu"
  }, /* @__PURE__ */ React119.createElement(TooltipButton, {
    tooltip: "Select",
    onClick: activateSelectTool,
    disabled: curTool === "select" /* select */
  }, /* @__PURE__ */ React119.createElement(SelectIcon, null)), /* @__PURE__ */ React119.createElement(TooltipButton, {
    tooltip: "Draw",
    onClick: activateDrawTool,
    disabled: curTool === "draw" /* draw */
  }, /* @__PURE__ */ React119.createElement(DrawIcon, null)), /* @__PURE__ */ React119.createElement(TooltipButton, {
    tooltip: "Erase",
    onClick: activateEraseTool,
    disabled: curTool === "eraser" /* eraser */
  }, /* @__PURE__ */ React119.createElement(EraseIcon, null))), /* @__PURE__ */ React119.createElement("div", {
    className: "ink_other-menu"
  })));
});
var drawing_menu_default = DrawingMenu;

// src/components/formats/v1-code-blocks/drawing/tldraw-drawing-editor/tldraw-drawing-editor.tsx
init_extended_drawing_menu();
var import_classnames48 = __toESM(require_classnames());
init_esm();

// src/components/formats/v1-code-blocks/drawing/drawing-embed-editor/drawing-embed.tsx
var React121 = __toESM(require_react());
var import_react138 = __toESM(require_react());
init_open_file();
init_storage();
init_getFullPageWidth();
init_universal_dev_logging();

// src/components/formats/v1-code-blocks/drawing/drawing-embed-preview/drawing-embed-preview.tsx
var import_classnames46 = __toESM(require_classnames());
var React120 = __toESM(require_react());
init_dist33();
init_esm();
init_empty_drawing_embed();
var DrawingEmbedPreviewWrapper_v1 = (props) => {
  const previewActive = useAtomValue(previewActiveAtom2);
  if (previewActive) {
    return /* @__PURE__ */ React120.createElement(DrawingEmbedPreview_v1, {
      ...props
    });
  } else {
    return /* @__PURE__ */ React120.createElement(React120.Fragment, null);
  }
};
var DrawingEmbedPreview_v1 = (props) => {
  const containerElRef = React120.useRef(null);
  const setEmbedState = useSetAtom(embedStateAtom);
  const [fileSrc, setFileSrc] = React120.useState(empty_drawing_embed_default);
  React120.useEffect(() => {
    void fetchFileData();
    return () => {
    };
  });
  const isImg = fileSrc.slice(0, 4) === "data";
  return /* @__PURE__ */ React120.createElement(React120.Fragment, null, /* @__PURE__ */ React120.createElement("div", {
    ref: containerElRef,
    className: (0, import_classnames46.default)([
      "ddc_ink_drawing-embed-preview",
      props.plugin.settings.drawingFrameWhenLocked && "ddc_ink_visible-frame",
      props.plugin.settings.drawingBackgroundWhenLocked && "ddc_ink_visible-background"
    ]),
    style: {
      position: "absolute",
      width: "100%",
      height: "100%",
      pointerEvents: "all"
    },
    onClick: props.onClick
  }, isImg && /* @__PURE__ */ React120.createElement("img", {
    src: fileSrc,
    style: {
      height: "100%",
      cursor: "pointer",
      pointerEvents: "all"
    },
    onLoad
  }), !isImg && /* @__PURE__ */ React120.createElement(InlineSVG, {
    src: fileSrc,
    style: {
      maxWidth: "100%",
      maxHeight: "100%",
      cursor: "pointer"
    },
    pointerEvents: "visible",
    onLoad
  })));
  function onLoad() {
    window.setTimeout(() => {
      setEmbedState("preview" /* preview */);
      props.onReady();
    }, 100);
  }
  async function fetchFileData() {
    const inkFileData = await getInkFileData(props.drawingFile);
    if (inkFileData.previewUri)
      setFileSrc(inkFileData.previewUri);
  }
};

// src/components/formats/v1-code-blocks/drawing/drawing-embed-editor/drawing-embed.tsx
var import_classnames47 = __toESM(require_classnames());
init_esm();
init_constants();
var embedStateAtom = atom("preview" /* preview */);
var previewActiveAtom2 = atom((get) => {
  const embedState = get(embedStateAtom);
  return embedState !== "editor" /* editor */;
});
var editorActiveAtom = atom((get) => {
  const embedState = get(embedStateAtom);
  return embedState !== "preview" /* preview */;
});
function DrawingEmbed_v1(props) {
  const embedContainerElRef = (0, import_react138.useRef)(null);
  const resizeContainerElRef = (0, import_react138.useRef)(null);
  const editorControlsRef = (0, import_react138.useRef)();
  const embedWidthRef = (0, import_react138.useRef)(props.width || DRAWING_INITIAL_WIDTH);
  const embedAspectRatioRef = (0, import_react138.useRef)(props.aspectRatio || DRAWING_INITIAL_ASPECT_RATIO);
  const setEmbedState = useSetAtom(embedStateAtom);
  React121.useEffect(() => {
    if (embedShouldActivateImmediately()) {
      window.setTimeout(() => {
        switchToEditMode();
      }, 200);
    }
    window.addEventListener("resize", handleResize);
    handleResize();
    return () => {
      window.removeEventListener("resize", handleResize);
    };
  }, []);
  const commonExtendedOptions = [
    {
      text: "Open drawing",
      action: async () => {
        await openInkFile(props.drawingFileRef);
      }
    },
    {
      text: "Remove embed",
      action: () => {
        props.remove();
      }
    }
  ];
  return /* @__PURE__ */ React121.createElement(React121.Fragment, null, /* @__PURE__ */ React121.createElement("div", {
    ref: embedContainerElRef,
    className: (0, import_classnames47.default)([
      "ddc_ink_embed",
      "ddc_ink_drawing-embed"
    ]),
    style: {
      paddingTop: "1em",
      paddingBottom: "0.5em"
    }
  }, /* @__PURE__ */ React121.createElement("div", {
    className: "ddc_ink_resize-container",
    ref: resizeContainerElRef,
    style: {
      width: embedWidthRef.current + "px",
      height: embedWidthRef.current / embedAspectRatioRef.current + "px",
      position: "relative",
      left: "50%",
      translate: "-50%"
    }
  }, /* @__PURE__ */ React121.createElement(DrawingEmbedPreviewWrapper_v1, {
    plugin: props.plugin,
    onReady: () => {
    },
    drawingFile: props.drawingFileRef,
    onClick: () => switchToEditMode()
  }), /* @__PURE__ */ React121.createElement(TldrawDrawingEditorWrapper_v1, {
    onReady: () => {
    },
    plugin: props.plugin,
    drawingFile: props.drawingFileRef,
    save: props.saveSrcFile,
    extendedMenu: commonExtendedOptions,
    embedded: true,
    saveControlsReference: registerEditorControls,
    closeEditor: () => void saveAndSwitchToPreviewMode(),
    resizeEmbed
  }))));
  function registerEditorControls(handlers) {
    editorControlsRef.current = handlers;
  }
  function resizeEmbed(pxWidthDiff, pxHeightDiff) {
    if (!resizeContainerElRef.current)
      return;
    const maxWidth2 = getFullPageWidth(embedContainerElRef.current);
    if (!maxWidth2)
      return;
    let destWidth = embedWidthRef.current + pxWidthDiff;
    if (destWidth < 350)
      destWidth = 350;
    if (destWidth > maxWidth2)
      destWidth = maxWidth2;
    const curHeight = resizeContainerElRef.current.getBoundingClientRect().height;
    let destHeight = curHeight + pxHeightDiff;
    if (destHeight < 150)
      destHeight = 150;
    embedWidthRef.current = destWidth;
    embedAspectRatioRef.current = destWidth / destHeight;
    resizeContainerElRef.current.style.width = embedWidthRef.current + "px";
    resizeContainerElRef.current.style.height = destHeight + "px";
  }
  function applyEmbedHeight() {
    if (!resizeContainerElRef.current)
      return;
    resizeContainerElRef.current.style.width = embedWidthRef.current + "px";
    const curWidth = resizeContainerElRef.current.getBoundingClientRect().width;
    resizeContainerElRef.current.style.height = curWidth / embedAspectRatioRef.current + "px";
  }
  function switchToEditMode() {
    verbose("Set DrawingEmbedState: loadingEditor");
    applyEmbedHeight();
    setEmbedState("loadingEditor" /* loadingEditor */);
  }
  async function saveAndSwitchToPreviewMode() {
    verbose("Set DrawingEmbedState: loadingPreview");
    if (editorControlsRef.current) {
      await editorControlsRef.current.saveAndHalt();
    }
    setEmbedState("unloadingEditor" /* loadingPreview */);
    props.setEmbedProps(embedWidthRef.current, embedAspectRatioRef.current);
  }
  function handleResize() {
    const maxWidth2 = getFullPageWidth(embedContainerElRef.current);
    if (resizeContainerElRef.current) {
      resizeContainerElRef.current.style.maxWidth = maxWidth2 + "px";
      const curWidth = resizeContainerElRef.current.getBoundingClientRect().width;
      resizeContainerElRef.current.style.height = curWidth / embedAspectRatioRef.current + "px";
    }
  }
  ;
}
var drawing_embed_default = DrawingEmbed_v1;

// src/components/formats/v1-code-blocks/drawing/tldraw-drawing-editor/tldraw-drawing-editor.tsx
init_resize_handle();
init_universal_dev_logging();
init_legacy_ink_notice();

// src/components/formats/v1-code-blocks/drawing/tldraw-drawing-editor/finger-blocker/finger-blocker.tsx
var React122 = __toESM(require_react());
var INK_CM_SCROLLER_SCROLL_PINNED_CLASS3 = "ink-cm-scroller--scroll-pinned";
var INK_FINGER_BLOCKER_TOUCH_NONE_CLASS3 = "ink-finger-blocker--touch-none";
var INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS3 = "ink-finger-blocker--touch-pan-xy";
function setFingerBlockerTouchMode3(blockerElement, mode) {
  blockerElement.classList.remove(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS3, INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS3);
  if (mode === "none")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_NONE_CLASS3);
  else if (mode === "pan-xy")
    blockerElement.classList.add(INK_FINGER_BLOCKER_TOUCH_PAN_XY_CLASS3);
}
var POLL_INTERVAL_MS3 = 100;
var MAX_POLL_RETRIES3 = 200;
function FingerBlocker3({ getTlEditor, wrapperRef, enableTwoFingerGestures, onVerticalTouchPan }) {
  const blockerRef = React122.useRef(null);
  const pointerDownRef = React122.useRef(false);
  const recentPenInputRef = React122.useRef(false);
  const isPenDownRef = React122.useRef(false);
  const lockedScrollPosRef = React122.useRef(null);
  const activeScrollerRef = React122.useRef(null);
  const currentTldrawToolIdRef = React122.useRef(null);
  const tldrawToolCleanupMap = React122.useRef(/* @__PURE__ */ new Map());
  const activeTouchPointerDataRef = React122.useRef(/* @__PURE__ */ new Map());
  const twoFingerModeActiveRef = React122.useRef(false);
  const prevTwoFingerMidpointRef = React122.useRef({ x: 0, y: 0 });
  const prevTwoFingerDistanceRef = React122.useRef(0);
  const prevCameraLockedRef = React122.useRef(false);
  const twoFingerVerticalPanActiveRef = React122.useRef(false);
  const prevVerticalPanMidpointRef = React122.useRef({ x: 0, y: 0 });
  const onVerticalTouchPanRef = React122.useRef(onVerticalTouchPan);
  React122.useEffect(() => {
    onVerticalTouchPanRef.current = onVerticalTouchPan;
  }, [onVerticalTouchPan]);
  const getWrapper = () => {
    return wrapperRef?.current || blockerRef.current?.parentElement || null;
  };
  const getCanvas = () => {
    const wrapper = getWrapper();
    return wrapper ? wrapper.querySelector(".tl-canvas") : null;
  };
  const getScroller = () => {
    const wrapper = getWrapper();
    return wrapper ? wrapper.closest(".cm-scroller") : null;
  };
  const lockScroll = () => {
    const scroller = getScroller();
    if (scroller) {
      activeScrollerRef.current = scroller;
      lockedScrollPosRef.current = { x: scroller.scrollLeft, y: scroller.scrollTop };
      scroller.classList.add(INK_CM_SCROLLER_SCROLL_PINNED_CLASS3);
    }
  };
  const unlockScroll = () => {
    if (isPenDownRef.current) {
      isPenDownRef.current = false;
      if (activeScrollerRef.current) {
        activeScrollerRef.current.style.overflow = "auto";
        window.setTimeout(() => {
          if (activeScrollerRef.current) {
            activeScrollerRef.current.style.scrollbarColor = "auto";
          }
        }, 200);
        activeScrollerRef.current = null;
      }
      lockedScrollPosRef.current = null;
    } else {
      const scroller = getScroller();
      if (scroller) {
        scroller.style.overflow = "auto";
        window.setTimeout(() => {
          scroller.style.scrollbarColor = "auto";
        }, 200);
      }
    }
  };
  const closeKeyboard = () => {
    const active = activeDocument.activeElement;
    if (active && !active.classList.contains("tl-canvas")) {
      active.blur();
    }
  };
  React122.useEffect(() => {
    const element = blockerRef.current;
    if (!element)
      return;
    const handlePointerDown = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        if (e2.pointerType === "mouse" && (e2.button === 3 || e2.button === 4))
          return;
        const isDrawingInput = e2.pointerType === "pen" || e2.button === 0;
        if (isDrawingInput) {
          lockScroll();
          isPenDownRef.current = true;
        }
        setFingerBlockerTouchMode3(element, "none");
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        try {
          target.setPointerCapture(e2.pointerId);
        } catch {
        }
        const canvas = getCanvas();
        if (canvas) {
          const forwarded = new PointerEvent("pointerdown", {
            pointerId: e2.pointerId,
            pointerType: e2.pointerType,
            clientX: e2.clientX,
            clientY: e2.clientY,
            bubbles: true,
            cancelable: true,
            view: window,
            detail: e2.detail,
            screenX: e2.screenX,
            screenY: e2.screenY,
            ctrlKey: e2.ctrlKey,
            shiftKey: e2.shiftKey,
            altKey: e2.altKey,
            metaKey: e2.metaKey,
            button: e2.button,
            buttons: e2.buttons
          });
          canvas.dispatchEvent(forwarded);
          recentPenInputRef.current = true;
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          pointerId: e2.pointerId,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY,
          width: e2.width,
          height: e2.height,
          pressure: e2.pressure
        });
        const touchCount = activeTouchPointerDataRef.current.size;
        const verticalTouchPan = onVerticalTouchPanRef.current;
        if (verticalTouchPan) {
          e2.preventDefault();
          e2.stopPropagation();
          e2.stopImmediatePropagation();
          setFingerBlockerTouchMode3(element, "none");
          if (touchCount >= 2 && !twoFingerVerticalPanActiveRef.current) {
            twoFingerVerticalPanActiveRef.current = true;
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            prevVerticalPanMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2,
              y: (pa.clientY + pb.clientY) / 2
            };
          }
        } else if (touchCount >= 2 && enableTwoFingerGestures && !twoFingerModeActiveRef.current) {
          e2.preventDefault();
          e2.stopPropagation();
          setFingerBlockerTouchMode3(element, "none");
          twoFingerModeActiveRef.current = true;
          const editorForLock = getTlEditor();
          prevCameraLockedRef.current = editorForLock ? editorForLock.getCameraOptions().isLocked : false;
          editorForLock?.setCameraOptions({ isLocked: false });
          const editor = getTlEditor();
          if (editor) {
            const [pa, pb] = [...activeTouchPointerDataRef.current.values()];
            const containerRect = editor.getContainer().getBoundingClientRect();
            prevTwoFingerMidpointRef.current = {
              x: (pa.clientX + pb.clientX) / 2 - containerRect.left,
              y: (pa.clientY + pb.clientY) / 2 - containerRect.top
            };
            prevTwoFingerDistanceRef.current = Math.hypot(pb.clientX - pa.clientX, pb.clientY - pa.clientY);
          }
        } else if (!twoFingerModeActiveRef.current) {
          setFingerBlockerTouchMode3(element, "pan-xy");
        }
      }
    };
    const handlePointerMove = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (isPenDownRef.current && activeScrollerRef.current && lockedScrollPosRef.current) {
          const scroller = activeScrollerRef.current;
          if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
            scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
          }
        }
      } else if (e2.pointerType === "touch" && twoFingerVerticalPanActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const currentMidpoint = {
          x: (p0.clientX + p1.clientX) / 2,
          y: (p0.clientY + p1.clientY) / 2
        };
        const prevMidpoint = prevVerticalPanMidpointRef.current;
        const deltaX = currentMidpoint.x - prevMidpoint.x;
        const deltaY = currentMidpoint.y - prevMidpoint.y;
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        if (Math.abs(deltaY) >= Math.abs(deltaX)) {
          onVerticalTouchPanRef.current?.(-deltaY);
        }
        prevVerticalPanMidpointRef.current = currentMidpoint;
      } else if (e2.pointerType === "touch" && onVerticalTouchPanRef.current && !twoFingerVerticalPanActiveRef.current) {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        recentPenInputRef.current = false;
        if (e2.movementY !== 0) {
          onVerticalTouchPanRef.current(-e2.movementY);
        }
      } else if (e2.pointerType === "touch" && recentPenInputRef.current) {
        const scroller = getScroller();
        if (scroller) {
          scroller.scrollTo({
            top: scroller.scrollTop - e2.movementY,
            left: scroller.scrollLeft - e2.movementX
          });
        }
      } else if (e2.pointerType === "touch" && twoFingerModeActiveRef.current) {
        const existing = activeTouchPointerDataRef.current.get(e2.pointerId);
        if (!existing)
          return;
        activeTouchPointerDataRef.current.set(e2.pointerId, {
          ...existing,
          clientX: e2.clientX,
          clientY: e2.clientY,
          screenX: e2.screenX,
          screenY: e2.screenY
        });
        if (activeTouchPointerDataRef.current.size < 2)
          return;
        const editor = getTlEditor();
        if (!editor)
          return;
        const [p0, p1] = [...activeTouchPointerDataRef.current.values()];
        const containerRect = editor.getContainer().getBoundingClientRect();
        const cm = {
          x: (p0.clientX + p1.clientX) / 2 - containerRect.left,
          y: (p0.clientY + p1.clientY) / 2 - containerRect.top
        };
        const curDist = Math.hypot(p1.clientX - p0.clientX, p1.clientY - p0.clientY);
        const pm = prevTwoFingerMidpointRef.current;
        const prevDist = prevTwoFingerDistanceRef.current;
        const { x: cx, y: cy, z: cz } = editor.getCamera();
        const { zoomSteps } = editor.getCameraOptions();
        const factor = prevDist > 0 ? curDist / prevDist : 1;
        const newZ = Math.max(zoomSteps[0], Math.min(zoomSteps[zoomSteps.length - 1], cz * factor));
        const newCx = cx + cm.x / newZ - pm.x / cz;
        const newCy = cy + cm.y / newZ - pm.y / cz;
        editor.setCamera({ x: newCx, y: newCy, z: newZ }, { animation: { duration: 0 } });
        prevTwoFingerMidpointRef.current = cm;
        prevTwoFingerDistanceRef.current = curDist;
      }
    };
    const handlePointerUp = (e2) => {
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        setFingerBlockerTouchMode3(element, "default");
        unlockScroll();
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        recentPenInputRef.current = false;
        if (onVerticalTouchPanRef.current) {
          if (twoFingerVerticalPanActiveRef.current && activeTouchPointerDataRef.current.size < 2) {
            twoFingerVerticalPanActiveRef.current = false;
          }
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode3(element, "default");
          } else {
            setFingerBlockerTouchMode3(element, "none");
          }
        }
      }
    };
    const handlePointerCancel = (e2) => {
      setFingerBlockerTouchMode3(element, "default");
      if (e2.pointerType === "pen" || e2.pointerType === "mouse") {
        unlockScroll();
        const target = e2.target;
        if (target.hasPointerCapture(e2.pointerId)) {
          try {
            target.releasePointerCapture(e2.pointerId);
          } catch {
          }
        }
      } else if (e2.pointerType === "touch") {
        activeTouchPointerDataRef.current.delete(e2.pointerId);
        if (onVerticalTouchPanRef.current) {
          twoFingerVerticalPanActiveRef.current = false;
          if (activeTouchPointerDataRef.current.size === 0) {
            setFingerBlockerTouchMode3(element, "default");
          }
        }
      }
    };
    const handleWheel = (e2) => {
      if (isPenDownRef.current) {
        e2.preventDefault();
        e2.stopPropagation();
        e2.stopImmediatePropagation();
      }
    };
    const handleTouchMove = (e2) => {
      const isDedicatedVerticalPan = twoFingerVerticalPanActiveRef.current || onVerticalTouchPanRef.current && activeTouchPointerDataRef.current.size > 0;
      if (isPenDownRef.current || twoFingerModeActiveRef.current || isDedicatedVerticalPan) {
        e2.preventDefault();
        if (isPenDownRef.current || twoFingerModeActiveRef.current || isDedicatedVerticalPan) {
          e2.stopPropagation();
          e2.stopImmediatePropagation();
        }
      }
    };
    const handleLostPointerCapture = () => {
      if (isPenDownRef.current) {
        console.debug("[FingerBlocker] lostpointercapture \u2014 unlocking scroll");
        unlockScroll();
      }
    };
    const handleTouchEnd = (e2) => {
      Array.from(e2.changedTouches).forEach((touch) => {
        activeTouchPointerDataRef.current.delete(touch.identifier);
      });
      if (onVerticalTouchPanRef.current) {
        if (twoFingerVerticalPanActiveRef.current && e2.touches.length < 2) {
          twoFingerVerticalPanActiveRef.current = false;
        }
        if (e2.touches.length === 0) {
          setFingerBlockerTouchMode3(element, "default");
          activeTouchPointerDataRef.current.clear();
        }
        return;
      }
      if (!enableTwoFingerGestures)
        return;
      if (twoFingerModeActiveRef.current && e2.touches.length < 2) {
        getTlEditor()?.setCameraOptions({ isLocked: prevCameraLockedRef.current });
        twoFingerModeActiveRef.current = false;
      }
      if (e2.touches.length === 0) {
        setFingerBlockerTouchMode3(element, "default");
        activeTouchPointerDataRef.current.clear();
      }
    };
    element.addEventListener("pointerdown", handlePointerDown, { passive: false, capture: true });
    element.addEventListener("pointermove", handlePointerMove, { passive: false, capture: true });
    element.addEventListener("pointerup", handlePointerUp, { passive: false, capture: true });
    element.addEventListener("pointercancel", handlePointerCancel, { passive: false, capture: true });
    element.addEventListener("lostpointercapture", handleLostPointerCapture);
    element.addEventListener("wheel", handleWheel, { passive: false, capture: true });
    element.addEventListener("touchmove", handleTouchMove, { passive: false, capture: true });
    element.addEventListener("touchend", handleTouchEnd, { passive: true, capture: true });
    element.addEventListener("touchcancel", handleTouchEnd, { passive: true, capture: true });
    return () => {
      element.removeEventListener("pointerdown", handlePointerDown, { capture: true });
      element.removeEventListener("pointermove", handlePointerMove, { capture: true });
      element.removeEventListener("pointerup", handlePointerUp, { capture: true });
      element.removeEventListener("pointercancel", handlePointerCancel, { capture: true });
      element.removeEventListener("lostpointercapture", handleLostPointerCapture);
      element.removeEventListener("wheel", handleWheel, { capture: true });
      element.removeEventListener("touchmove", handleTouchMove, { capture: true });
      element.removeEventListener("touchend", handleTouchEnd, { capture: true });
      element.removeEventListener("touchcancel", handleTouchEnd, { capture: true });
    };
  }, [enableTwoFingerGestures, onVerticalTouchPan]);
  React122.useEffect(() => {
    const scroller = getScroller();
    if (!scroller)
      return;
    const handleScroll2 = (e2) => {
      if (isPenDownRef.current && lockedScrollPosRef.current) {
        if (Math.abs(scroller.scrollTop - lockedScrollPosRef.current.y) > 1 || Math.abs(scroller.scrollLeft - lockedScrollPosRef.current.x) > 1) {
          scroller.scrollTo(lockedScrollPosRef.current.x, lockedScrollPosRef.current.y);
        }
      }
    };
    scroller.addEventListener("scroll", handleScroll2, { passive: false, capture: true });
    return () => {
      scroller.removeEventListener("scroll", handleScroll2, { capture: true });
    };
  }, [getTlEditor]);
  const hasToolChanged = (entry) => {
    if (!entry.changes?.updated)
      return false;
    for (const [from, to] of Object.values(entry.changes.updated)) {
      if (typeof from === "object" && from !== null && typeof to === "object" && to !== null && "typeName" in from && "typeName" in to && from.typeName === "instance" && to.typeName === "instance") {
        return true;
      }
    }
    return false;
  };
  const wrapToolWithScrollHandlers = (tool) => {
    const prevDown = tool.onPointerDown;
    const prevUp = tool.onPointerUp;
    const prevMove = tool.onPointerMove;
    tool.onPointerDown = (e2) => {
      pointerDownRef.current = true;
      lockScroll();
      prevDown?.(e2);
    };
    tool.onPointerUp = (e2) => {
      pointerDownRef.current = false;
      unlockScroll();
      prevUp?.(e2);
    };
    tool.onPointerMove = (e2) => {
      prevMove?.(e2);
    };
    return () => {
      if (tool) {
        tool.onPointerDown = prevDown;
        tool.onPointerUp = prevUp;
        tool.onPointerMove = prevMove;
      }
    };
  };
  const listenForToolChangesAndUpdateHandlers = () => {
    const editor = getTlEditor();
    if (!editor)
      return () => {
      };
    const handleToolChange = () => {
      const editor2 = getTlEditor();
      if (!editor2)
        return;
      const newToolId = editor2.getCurrentToolId();
      const previousToolId = currentTldrawToolIdRef.current;
      if (newToolId === previousToolId)
        return;
      if (previousToolId && tldrawToolCleanupMap.current.has(previousToolId)) {
        const cleanup = tldrawToolCleanupMap.current.get(previousToolId);
        if (cleanup) {
          cleanup();
          tldrawToolCleanupMap.current.delete(previousToolId);
        }
      }
      if (newToolId) {
        const tool = editor2.getCurrentTool();
        if (tool) {
          if (!tldrawToolCleanupMap.current.has(newToolId)) {
            const toolCleanupFn = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(newToolId, toolCleanupFn);
            currentTldrawToolIdRef.current = newToolId;
          }
        }
      }
    };
    return editor.store.listen((entry) => {
      if (hasToolChanged(entry)) {
        handleToolChange();
      }
    }, {
      source: "all",
      scope: "all"
    });
  };
  const listenForEditorToBecomeAvailable = (getTlEditor2, onEditorReady) => {
    let pollInterval = null;
    let setupComplete = false;
    let retryCount = 0;
    pollInterval = window.setInterval(() => {
      if (setupComplete)
        return;
      const editor = getTlEditor2();
      if (editor) {
        setupComplete = true;
        onEditorReady(editor);
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
      retryCount++;
      if (retryCount >= MAX_POLL_RETRIES3) {
        if (pollInterval) {
          window.clearInterval(pollInterval);
          pollInterval = null;
        }
      }
    }, POLL_INTERVAL_MS3);
    return () => {
      if (pollInterval) {
        window.clearInterval(pollInterval);
      }
    };
  };
  React122.useEffect(() => {
    let storeListenerCleanup = null;
    const stopPolling = listenForEditorToBecomeAvailable(getTlEditor, () => {
      const editor = getTlEditor();
      if (!editor)
        return;
      const initialToolId = editor.getCurrentToolId();
      if (initialToolId) {
        const tool = editor.getCurrentTool();
        if (tool) {
          const editorToolId = editor.getCurrentToolId();
          if (editorToolId === initialToolId && !tldrawToolCleanupMap.current.has(initialToolId)) {
            const cleanup = wrapToolWithScrollHandlers(tool);
            tldrawToolCleanupMap.current.set(initialToolId, cleanup);
            currentTldrawToolIdRef.current = initialToolId;
          }
        }
      }
      storeListenerCleanup = listenForToolChangesAndUpdateHandlers();
    });
    return () => {
      stopPolling();
      if (storeListenerCleanup) {
        storeListenerCleanup();
      }
      tldrawToolCleanupMap.current.forEach((cleanup) => {
        cleanup();
      });
      tldrawToolCleanupMap.current.clear();
    };
  }, [getTlEditor]);
  return /* @__PURE__ */ React122.createElement("div", {
    ref: blockerRef,
    style: {
      position: "absolute",
      inset: 0,
      zIndex: 1e3,
      userSelect: "none",
      WebkitUserSelect: "none",
      MozUserSelect: "none",
      msUserSelect: "none"
    },
    onPointerEnter: (e2) => {
      closeKeyboard();
    }
  });
}

// src/components/formats/v1-code-blocks/drawing/tldraw-drawing-editor/tldraw-drawing-editor.tsx
var TldrawDrawingEditorWrapper_v1 = (props) => {
  const editorActive = useAtomValue(editorActiveAtom);
  if (editorActive) {
    return /* @__PURE__ */ React123.createElement(TldrawDrawingEditor_v1, {
      ...props
    });
  } else {
    return /* @__PURE__ */ React123.createElement(React123.Fragment, null);
  }
};
var tlOptions_v12 = {
  defaultSvgPadding: 10
};
function TldrawDrawingEditor_v1(props) {
  const [tlEditorSnapshot, setTlEditorSnapshot] = React123.useState();
  const setEmbedState = useSetAtom(embedStateAtom);
  const shortDelayPostProcessTimeoutRef = (0, import_react139.useRef)();
  const longDelayPostProcessTimeoutRef = (0, import_react139.useRef)();
  const tlEditorRef = (0, import_react139.useRef)();
  const editorWrapperRefEl = (0, import_react139.useRef)(null);
  React123.useEffect(() => {
    verbose("EDITOR mounted");
    void fetchFileData();
    return () => {
      verbose("EDITOR unmounting");
    };
  }, []);
  React123.useEffect(() => {
    if (!tlEditorSnapshot)
      return;
    showLegacyInkUnlockNotice({
      plugin: props.plugin,
      legacyFile: props.drawingFile,
      isEmbedded: props.embedded
    });
  }, [tlEditorSnapshot]);
  if (!tlEditorSnapshot)
    return /* @__PURE__ */ React123.createElement(React123.Fragment, null);
  verbose("EDITOR snapshot loaded");
  const defaultComponents = {
    Scribble: TldrawScribble,
    ShapeIndicators: TldrawShapeIndicators,
    CollaboratorScribble: TldrawScribble,
    SelectionForeground: TldrawSelectionForeground,
    SelectionBackground: TldrawSelectionBackground,
    Handles: TldrawHandles
  };
  const handleMount = (_editor) => {
    const editor = tlEditorRef.current = _editor;
    setEmbedState("editor" /* editor */);
    focusChildTldrawEditor(editorWrapperRefEl.current);
    preventTldrawCanvasesCausingObsidianGestures(editor);
    adaptTldrawToObsidianThemeMode(editor);
    editor.updateInstanceState({
      isGridMode: true
    });
    initDrawingCamera(editor);
    if (props.embedded) {
      editor.setCameraOptions({
        isLocked: true
      });
    }
    if (editorWrapperRefEl.current) {
      editorWrapperRefEl.current.classList.remove("ddc_ink_editor-wrapper--loading");
    }
    const removeUserActionListener = editor.store.listen((entry) => {
      const activity = getActivityType(entry);
      switch (activity) {
        case 0 /* PointerMoved */:
          break;
        case 2 /* CameraMovedAutomatically */:
        case 1 /* CameraMovedManually */:
          break;
        case 3 /* DrawingStarted */:
          resetInputPostProcessTimers();
          break;
        case 4 /* DrawingContinued */:
          resetInputPostProcessTimers();
          break;
        case 5 /* DrawingCompleted */:
          queueOrRunStorePostProcesses(editor);
          embedPostProcess(editor);
          break;
        case 6 /* DrawingErased */:
          queueOrRunStorePostProcesses(editor);
          embedPostProcess(editor);
          break;
        default:
          queueOrRunStorePostProcesses(editor);
          verbose("Activity not recognised.");
          verbose(["entry", entry], { freeze: true });
      }
    }, {
      source: "user",
      scope: "all"
    });
    const unmountActions = () => {
      resetInputPostProcessTimers();
      removeUserActionListener();
    };
    if (props.saveControlsReference) {
      props.saveControlsReference({
        save: () => completeSave(editor),
        saveAndHalt: async () => {
          await completeSave(editor);
          unmountActions();
        }
      });
    }
    if (props.onReady)
      props.onReady();
    return () => {
      unmountActions();
    };
  };
  async function fetchFileData() {
    const inkFileData = await getInkFileData(props.drawingFile);
    if (inkFileData.tldraw) {
      const snapshot = prepareDrawingSnapshot(inkFileData.tldraw);
      setTlEditorSnapshot(snapshot);
    }
  }
  const embedPostProcess = (editor) => {
  };
  const queueOrRunStorePostProcesses = (editor) => {
    instantInputPostProcess(editor);
    smallDelayInputPostProcess(editor);
    longDelayInputPostProcess(editor);
  };
  const instantInputPostProcess = (editor) => {
  };
  const smallDelayInputPostProcess = (editor) => {
    resetShortPostProcessTimer();
    shortDelayPostProcessTimeoutRef.current = window.setTimeout(() => {
      void incrementalSave(editor);
    }, DRAW_SHORT_DELAY_MS);
  };
  const longDelayInputPostProcess = (editor) => {
    resetLongPostProcessTimer();
    longDelayPostProcessTimeoutRef.current = window.setTimeout(() => {
      void completeSave(editor);
    }, DRAW_LONG_DELAY_MS);
  };
  const resetShortPostProcessTimer = () => {
    window.clearTimeout(shortDelayPostProcessTimeoutRef.current);
  };
  const resetLongPostProcessTimer = () => {
    window.clearTimeout(longDelayPostProcessTimeoutRef.current);
  };
  const resetInputPostProcessTimers = () => {
    resetShortPostProcessTimer();
    resetLongPostProcessTimer();
  };
  const incrementalSave = async (editor) => {
    verbose("incrementalSave");
    const tlEditorSnapshot2 = getSnapshot(editor.store);
    const pageData = buildDrawingFileData_v1({
      tlEditorSnapshot: tlEditorSnapshot2,
      previewIsOutdated: true
    });
    props.save(pageData);
  };
  const completeSave = async (editor) => {
    verbose("completeSave");
    let previewUri;
    const tlEditorSnapshot2 = getSnapshot(editor.store);
    const svgObj = await getDrawingSvg(editor);
    if (svgObj) {
      previewUri = svgObj.svg;
    }
    if (previewUri) {
      const pageData = buildDrawingFileData_v1({
        tlEditorSnapshot: tlEditorSnapshot2,
        previewUri
      });
      props.save(pageData);
    } else {
      const pageData = buildDrawingFileData_v1({
        tlEditorSnapshot: tlEditorSnapshot2
      });
      props.save(pageData);
    }
    return;
  };
  const getTlEditor = () => {
    return tlEditorRef.current;
  };
  const customExtendedMenu = [
    {
      text: "Grid on/off",
      action: () => {
        const editor = getTlEditor();
        if (editor) {
          editor.updateInstanceState({ isGridMode: !editor.getInstanceState().isGridMode });
        }
      }
    },
    ...props.extendedMenu || []
  ];
  return /* @__PURE__ */ React123.createElement(React123.Fragment, null, /* @__PURE__ */ React123.createElement("div", {
    ref: editorWrapperRefEl,
    className: (0, import_classnames48.default)([
      "ddc_ink_drawing-editor",
      "ddc_ink_editor-wrapper--loading"
    ]),
    style: {
      height: "100%",
      position: "relative"
    }
  }, /* @__PURE__ */ React123.createElement(TldrawEditor, {
    options: tlOptions_v12,
    shapeUtils: [...defaultShapeUtils],
    tools: [...defaultTools, ...defaultShapeTools],
    initialState: "draw",
    snapshot: tlEditorSnapshot,
    components: defaultComponents,
    onMount: handleMount,
    autoFocus: false
  }), /* @__PURE__ */ React123.createElement(FingerBlocker3, {
    getTlEditor,
    wrapperRef: editorWrapperRefEl
  }), /* @__PURE__ */ React123.createElement(PrimaryMenuBar, null, /* @__PURE__ */ React123.createElement(drawing_menu_default, {
    getTlEditor,
    onStoreChange: (tlEditor) => queueOrRunStorePostProcesses(tlEditor)
  }), props.embedded && props.extendedMenu && /* @__PURE__ */ React123.createElement(extended_drawing_menu_default, {
    onLockClick: () => void props.closeEditor?.(),
    menuOptions: customExtendedMenu
  }), !props.embedded && props.extendedMenu && /* @__PURE__ */ React123.createElement(extended_drawing_menu_default, {
    menuOptions: customExtendedMenu
  }))), props.resizeEmbed && /* @__PURE__ */ React123.createElement(ResizeHandle, {
    resizeEmbed
  }));
  function resizeEmbed(pxWidthDiff, pxHeightDiff) {
    if (!props.resizeEmbed)
      return;
    props.resizeEmbed(pxWidthDiff, pxHeightDiff);
  }
}

// src/components/formats/v1-code-blocks/drawing/drawing-view/drawing-view.tsx
init_esm();
var DRAWING_VIEW_V1_TYPE = "ink_drawing-v1-view";
function getExtendedOptions2(_plugin) {
  return [];
}
function registerDrawingView_v1(plugin) {
  plugin.registerView(DRAWING_VIEW_V1_TYPE, (leaf) => new DrawingView_v1(leaf, plugin));
  plugin.registerExtensions([DRAW_FILE_V1_EXT], DRAWING_VIEW_V1_TYPE);
}
var DrawingView_v1 = class extends import_obsidian37.TextFileView {
  constructor(leaf, plugin) {
    super(leaf);
    this.getDisplayText = () => {
      return this.file?.basename || "Drawing";
    };
    this.setViewData = (fileContents, clear) => {
      if (!this.file)
        return;
      const pageData = JSON.parse(fileContents);
      this.pageData = pageData;
      const viewContent = this.containerEl.children[1];
      viewContent.setAttr("style", "padding: 0;");
      if (this.root)
        this.clear();
      this.root = (0, import_client8.createRoot)(viewContent);
      this.root.render(/* @__PURE__ */ React124.createElement(Provider, null, /* @__PURE__ */ React124.createElement(TldrawDrawingEditor_v1, {
        plugin: this.plugin,
        onReady: () => {
        },
        drawingFile: this.file,
        save: this.saveFile,
        extendedMenu: getExtendedOptions2(this.plugin)
      })));
    };
    this.saveFile = (pageData) => {
      this.pageData = pageData;
      void this.save(false);
    };
    this.getViewData = () => {
      return buildFileStr_v1(this.pageData);
    };
    this.clear = () => {
      this.root?.unmount();
    };
    this.plugin = plugin;
  }
  getViewType() {
    return DRAWING_VIEW_V1_TYPE;
  }
};

// src/components/formats/v1-code-blocks/drawing/widgets/drawing-embed-widget.tsx
var import_obsidian38 = require("obsidian");
var React125 = __toESM(require_react());
var import_client9 = __toESM(require_client());
init_embed();
init_constants();
init_esm();
function registerDrawingEmbed_v1(plugin) {
  plugin.registerMarkdownCodeBlockProcessor(DRAW_EMBED_KEY, (source, el, ctx) => {
    const embedData = JSON.parse(source);
    const embedCtrls = {
      removeEmbed: () => removeEmbed(plugin, ctx, el)
    };
    if (embedData.filepath) {
      ctx.addChild(new DrawingEmbedWidget_v1(el, plugin, embedData, embedCtrls, (newEmbedData) => updateEmbed_v1(plugin, ctx, el, newEmbedData)));
    }
  });
}
function updateEmbed_v1(plugin, ctx, el, embedData) {
  const cmEditor = plugin.app.workspace.activeEditor?.editor;
  if (!cmEditor)
    return;
  const sectionInfo = ctx.getSectionInfo(el);
  if (sectionInfo?.lineStart === void 0 || sectionInfo.lineEnd === void 0)
    return;
  const embedStart = {
    line: sectionInfo.lineStart + 1,
    ch: 0
  };
  const lastContentLine = sectionInfo.lineEnd - 1;
  const embedEnd = {
    line: lastContentLine,
    ch: cmEditor.getLine(lastContentLine).length
  };
  cmEditor.replaceRange(stringifyEmbedData(embedData), embedStart, embedEnd);
  cmEditor.setCursor(embedStart);
}
var DrawingEmbedWidget_v1 = class extends import_obsidian38.MarkdownRenderChild {
  constructor(el, plugin, embedData, embedCtrls, updateEmbed) {
    super(el);
    this.save = async (pageData) => {
      if (!this.fileRef)
        return;
      const pageDataStr = buildFileStr_v1(pageData);
      await this.plugin.app.vault.modify(this.fileRef, pageDataStr);
    };
    this.setEmbedProps = async (width, aspectRatio) => {
      const newEmbedData = {
        ...this.embedData,
        width,
        aspectRatio
      };
      this.updateEmbed(newEmbedData);
    };
    this.el = el;
    this.plugin = plugin;
    this.embedData = embedData;
    this.embedCtrls = embedCtrls;
    this.updateEmbed = updateEmbed;
  }
  onload() {
    void this.mountDrawingEmbed();
  }
  async mountDrawingEmbed() {
    const v2 = this.plugin.app.vault;
    const abstractFile = v2.getAbstractFileByPath(this.embedData.filepath);
    this.fileRef = abstractFile instanceof import_obsidian38.TFile ? abstractFile : null;
    if (!this.fileRef) {
      this.el.createEl("p").textContent = "Ink drawing file not found.";
      return;
    }
    const pageDataStr = await v2.read(this.fileRef);
    const pageData = JSON.parse(pageDataStr);
    this.root = (0, import_client9.createRoot)(this.el);
    this.root.render(/* @__PURE__ */ React125.createElement(Provider, null, /* @__PURE__ */ React125.createElement(drawing_embed_default, {
      plugin: this.plugin,
      drawingFileRef: this.fileRef,
      pageData,
      saveSrcFile: (embeddedPageData) => void this.save(embeddedPageData),
      setEmbedProps: (width, aspectRatio) => void this.setEmbedProps(width, aspectRatio),
      remove: this.embedCtrls.removeEmbed,
      width: this.embedData.width,
      aspectRatio: this.embedData.aspectRatio
    })));
    applyCommonAncestorStyling(this.el);
  }
  onunload() {
    this.root?.unmount();
  }
};

// src/commands/insert-new-drawing-file.ts
init_storage();
init_build_embeds();

// src/commands/create-new-drawing-file.ts
init_build_file_data();
init_file_manipulation();
init_createFoldersForFilepath();
init_buildFileStr();
init_plugin_settings();
init_empty_drawing_embed();
var createNewDrawingFile = async (plugin, instigatingFile) => {
  const filepath = await getNewTimestampedDrawingSvgFilepath(plugin, instigatingFile);
  const inkCanvasSnapshot = {
    version: 1,
    strokes: [],
    gridEnabled: plugin.settings.drawingGridEnabledByDefault ?? DEFAULT_SETTINGS.drawingGridEnabledByDefault
  };
  const pageData = buildInkCanvasDrawingFileData({
    inkCanvasSnapshot,
    svgString: empty_drawing_embed_default
  });
  await createFoldersForFilepath(plugin, filepath);
  const fileRef = await plugin.app.vault.create(filepath, buildFileStr(pageData));
  return fileRef;
};

// src/commands/insert-new-drawing-file.ts
var insertNewDrawingFile = async (plugin, editor) => {
  const activeFile = plugin.app.workspace.getActiveFile();
  const fileRef = await createNewDrawingFile(plugin, activeFile);
  recordRecentFileSelection("inkDrawing", fileRef.path);
  const embedStr = buildDrawingEmbed(fileRef.path, { writingAlignedViewBox: true });
  activateNextEmbed();
  const positionForEmbed = editor.getCursor();
  editor.replaceRange(embedStr, positionForEmbed);
  const positionForCursor = { ...positionForEmbed };
  const embedLines = embedStr.split(/\r\n|\r|\n/);
  positionForCursor.line += embedLines.length;
  editor.setCursor(positionForCursor);
};

// src/graphics/social-icons/bluesky.svg
var bluesky_default = '<svg width="100" height="100" viewBox="0 0 15 13" fill="none" xmlns="http://www.w3.org/2000/svg">\n<path d="M7.173 5.80097C6.54015 4.57089 4.81761 2.27767 3.21592 1.14748C1.68129 0.0647798 1.09663 0.251283 0.713148 0.425911C0.268894 0.624988 0.187866 1.30743 0.187866 1.70768C0.187866 2.10933 0.407898 4.99698 0.551093 5.47965C1.02608 7.07227 2.71229 7.61012 4.26718 7.43759C1.99003 7.77497 -0.0335624 8.6041 2.61869 11.5574C5.53708 14.5785 6.61838 10.9099 7.173 9.04976C7.72762 10.9099 8.36606 14.4465 11.6742 11.5574C14.1581 9.04976 12.3567 7.77497 10.0795 7.43759C11.6337 7.61012 13.3206 7.07227 13.7949 5.47965C13.9381 4.99768 14.1581 2.10933 14.1581 1.70838C14.1581 1.30674 14.0771 0.625686 13.6328 0.424514C13.2494 0.251283 12.6647 0.0633829 11.1301 1.14608C9.52839 2.27837 7.80515 4.57159 7.173 5.80097Z" fill="white"/>\n</svg>\n';

// src/graphics/social-icons/mastodon.svg
var mastodon_default = '<svg width="100" height="100" viewBox="0 0 13 13" fill="none" xmlns="http://www.w3.org/2000/svg">\n<path d="M12.0997 7.77207C11.9245 8.67344 10.5296 9.66111 8.92761 9.85226C8.09272 9.95198 7.26998 10.044 6.39291 10.0031C4.95903 9.93728 3.82688 9.66111 3.82688 9.66111C3.82688 9.80048 3.83583 9.93344 3.85245 10.0575C4.03912 11.4734 5.25629 11.5578 6.40953 11.5981C7.573 11.6377 8.60861 11.3104 8.60861 11.3104L8.6572 12.3627C8.6572 12.3627 7.84277 12.7999 6.39291 12.8805C5.59382 12.9239 4.60104 12.86 3.4446 12.5544C0.936746 11.8902 0.505239 9.21746 0.439395 6.5044C0.419577 5.69893 0.431723 4.94011 0.431723 4.30532C0.431723 1.53089 2.24917 0.71838 2.24917 0.71838C3.16524 0.297741 4.7372 0.120663 6.37245 0.107239H6.41209C8.0467 0.120024 9.61994 0.297741 10.536 0.71838C10.536 0.71838 12.3535 1.53153 12.3535 4.30468C12.3535 4.30468 12.3765 6.35098 12.0997 7.77207ZM10.21 4.52011C10.21 3.83354 10.0355 3.28824 9.6845 2.88486C9.32204 2.48148 8.84834 2.27436 8.25957 2.27436C7.57875 2.27436 7.0635 2.53646 6.72213 3.05938L6.39099 3.61555L6.05921 3.05938C5.71848 2.53646 5.20323 2.27436 4.52241 2.27436C3.93364 2.27436 3.4593 2.48148 3.09748 2.88486C2.74652 3.28824 2.572 3.83354 2.572 4.52011V7.87819H3.90232V4.61856C3.90232 3.93135 4.19126 3.58294 4.7698 3.58294C5.40907 3.58294 5.72935 3.99655 5.72935 4.81482V6.59838H7.05263V4.81482C7.05263 3.99655 7.37227 3.58294 8.01154 3.58294C8.59007 3.58294 8.87966 3.93135 8.87966 4.61856V7.87883H10.2093V4.51947L10.21 4.52011Z" fill="white"/>\n</svg>\n';

// src/graphics/social-icons/threads.svg
var threads_default = '<svg width="100" height="100" viewBox="0 0 13 15" fill="none" xmlns="http://www.w3.org/2000/svg">\n<path fill-rule="evenodd" clip-rule="evenodd" d="M6.53736 3.69841C5.31389 3.69841 4.42969 4.07195 3.75944 5.02945C3.75944 5.02945 4.55499 5.58148 4.79377 5.74106L4.82214 5.70915C5.16495 5.31197 5.45929 4.97152 6.53618 4.97152C7.74427 4.97152 8.22184 5.93847 8.22184 6.50351C7.8944 6.43732 7.26789 6.40185 6.74777 6.40185C5.35881 6.40185 3.59986 7.07328 3.59986 8.9268C3.59986 10.2247 4.83751 11.2153 6.27139 11.2153C8.7325 11.2153 9.29281 9.37481 9.50204 8.28138C9.5576 8.28138 10.6286 8.89134 10.6286 10.1668C10.6286 12.0404 8.79279 13.3194 6.33049 13.3194C3.33744 13.3194 1.3397 11.369 1.3397 7.69624C1.3397 3.6003 3.12703 1.67585 6.28912 1.67585C8.20056 1.67585 10.2869 2.15815 11.2823 5.1843L12.488 4.87223C11.2019 0.622612 7.77974 0.407471 6.32104 0.407471C3.16249 0.407471 0.0760498 2.21134 0.0760498 7.49529C0.0760498 12.8076 3.26297 14.5926 6.33049 14.5926C9.90277 14.5926 11.8769 12.5014 11.8769 10.0935C11.8769 8.96108 11.3355 7.97285 10.352 7.31206C10.1077 7.14736 9.84051 7.00433 9.55051 6.88296C9.48195 5.877 9.18288 5.08973 8.65921 4.53888C8.13436 3.98921 7.40028 3.69841 6.53736 3.69841ZM4.87534 8.92325C4.87534 8.43859 5.10821 7.66787 6.91681 7.66787C7.47121 7.66787 7.81283 7.70806 8.27148 7.8109C8.12491 9.70934 7.19578 9.95995 6.29266 9.95995C5.79855 9.95995 4.87534 9.70225 4.87534 8.92325Z" fill="white"/>\n</svg>\n';

// src/graphics/social-icons/twitter.svg
var twitter_default = '<svg width="100" height="100" viewBox="0 0 15 13" fill="none" xmlns="http://www.w3.org/2000/svg">\n<path d="M14.6288 2.14845C14.094 2.38083 13.5281 2.53393 12.9491 2.60291C13.5576 2.24658 14.0153 1.68049 14.2362 1.01081C13.6608 1.34722 13.0324 1.58327 12.3779 1.70883C12.1023 1.41998 11.7708 1.19019 11.4036 1.03342C11.0364 0.876661 10.6412 0.796203 10.2419 0.796941C8.62549 0.796941 7.31735 2.08607 7.31735 3.6752C7.31621 3.89624 7.34154 4.11663 7.3928 4.33164C6.23368 4.2773 5.09867 3.98161 4.06037 3.46349C3.02208 2.94537 2.10336 2.21622 1.36301 1.32269C1.10328 1.76055 0.965917 2.26014 0.965284 2.76925C0.965284 3.76728 1.48598 4.64947 2.27223 5.16631C1.8064 5.15525 1.35012 5.03196 0.942115 4.8069V4.84254C0.942115 6.2386 1.95203 7.4 3.28868 7.66436C3.03733 7.73137 2.77831 7.76532 2.51818 7.76536C2.33359 7.76568 2.14943 7.74777 1.96837 7.71189C2.33996 8.85547 3.42146 9.68717 4.70256 9.71093C3.66157 10.5132 2.38351 10.9468 1.06925 10.9436C0.83596 10.9433 0.602892 10.9294 0.371216 10.902C1.70822 11.7558 3.26238 12.2074 4.8487 12.203C10.2357 12.203 13.1787 7.81585 13.1787 4.01085C13.1787 3.88609 13.1755 3.76134 13.1695 3.63955C13.7407 3.23323 14.2349 2.72829 14.6288 2.14845Z" fill="white"/>\n</svg>\n';

// src/main.ts
init_esm();
init_drawing_embed_extension();
init_writing_embed_extension();

// src/components/formats/current/reading-mode/register-reading-mode-ink-embeds.ts
var import_obsidian41 = require("obsidian");

// src/logic/utils/detect-reading-mode-ink-embed.ts
var import_obsidian39 = require("obsidian");
init_parse_settings_from_url();
var INK_READING_PROCESSED_ATTR = "data-ink-reading-processed";
var INK_READING_ACTIVE_ATTR = "data-ink-reading-active";
var INK_READING_MOUNTING_ATTR = "data-ink-reading-mounting";
var INK_EMBED_ALT_BY_KIND = {
  drawing: "InkDrawing",
  writing: "InkWriting"
};
var INK_EDIT_LINK_FRAGMENT_BY_KIND = {
  drawing: "type=inkDrawing",
  writing: "type=inkWriting"
};
function findReadingModeInkEmbedCandidates(app, rootEl, sourcePath) {
  const candidates = [];
  for (const embedKind of ["drawing", "writing"]) {
    const altText = INK_EMBED_ALT_BY_KIND[embedKind];
    const editLinkFragment = INK_EDIT_LINK_FRAGMENT_BY_KIND[embedKind];
    const markerSelector = `.internal-embed[alt="${altText}"], img[alt="${altText}"]`;
    const markerEls = rootEl.querySelectorAll(markerSelector);
    markerEls.forEach((embedMarkerEl) => {
      if (embedMarkerEl.closest(`[${INK_READING_PROCESSED_ATTR}]`))
        return;
      if (isNestedObsidianEmbedImg(embedMarkerEl))
        return;
      const editLinkEl = findInkEditLinkForMarker(embedMarkerEl, editLinkFragment);
      if (!editLinkEl)
        return;
      const partialEmbedFilepath = extractPartialEmbedFilepath(embedMarkerEl);
      if (!partialEmbedFilepath)
        return;
      const settingsHref = editLinkEl.getAttribute("href") ?? "";
      const { embedSettings, isPendingPaste } = parseSettingsFromUrl(settingsHref);
      const embeddedFile = app.metadataCache.getFirstLinkpathDest((0, import_obsidian39.normalizePath)(partialEmbedFilepath), sourcePath);
      candidates.push({
        embedKind,
        embedMarkerEl,
        editLinkEl,
        partialEmbedFilepath,
        embeddedFile,
        embedSettings,
        isPendingPaste
      });
    });
  }
  return dedupeReadingModeCandidatesByEditLink(candidates);
}
function isNestedObsidianEmbedImg(embedMarkerEl) {
  if (!embedMarkerEl.instanceOf(HTMLImageElement))
    return false;
  const parentEmbedEl = embedMarkerEl.parentElement?.closest(".internal-embed[alt]");
  return !!parentEmbedEl && parentEmbedEl !== embedMarkerEl;
}
function dedupeReadingModeCandidatesByEditLink(candidates) {
  const bestByEditLink = /* @__PURE__ */ new Map();
  for (const candidate of candidates) {
    const existing = bestByEditLink.get(candidate.editLinkEl);
    if (!existing || preferReadingModeEmbedMarker(candidate, existing)) {
      bestByEditLink.set(candidate.editLinkEl, candidate);
    }
  }
  return [...bestByEditLink.values()];
}
function preferReadingModeEmbedMarker(candidate, incumbent) {
  const candidateScore = readingModeEmbedMarkerScore(candidate.embedMarkerEl);
  const incumbentScore = readingModeEmbedMarkerScore(incumbent.embedMarkerEl);
  return candidateScore > incumbentScore;
}
function readingModeEmbedMarkerScore(embedMarkerEl) {
  let score = 0;
  if (embedMarkerEl.classList.contains("internal-embed") && embedMarkerEl.tagName !== "IMG") {
    score += 2;
  }
  const srcAttr = embedMarkerEl.getAttribute("src");
  if (srcAttr && !isObsidianResourceUrl(srcAttr))
    score += 1;
  return score;
}
function findInkEditLinkForMarker(embedMarkerEl, editLinkFragment) {
  const blockScopeEl = findInkEmbedSearchScope(embedMarkerEl);
  if (!blockScopeEl)
    return null;
  const editLinks = blockScopeEl.querySelectorAll(`a[href*="${editLinkFragment}"]`);
  for (const editLinkEl of editLinks) {
    const position = embedMarkerEl.compareDocumentPosition(editLinkEl);
    const editLinkFollowsMarker = (position & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
    if (editLinkFollowsMarker)
      return editLinkEl;
  }
  return null;
}
function findInkEmbedSearchScope(embedMarkerEl) {
  return embedMarkerEl.closest("p, .el-p, blockquote, .callout, .markdown-embed") ?? embedMarkerEl.parentElement;
}
function extractPartialEmbedFilepath(embedMarkerEl) {
  const srcAttr = embedMarkerEl.getAttribute("src");
  if (srcAttr) {
    const vaultPath = vaultRelativePathFromObsidianResource(srcAttr);
    if (vaultPath)
      return vaultPath;
    if (!isObsidianResourceUrl(srcAttr))
      return srcAttr;
  }
  const parentEmbedEl = embedMarkerEl.closest(".internal-embed[alt][src]");
  if (parentEmbedEl) {
    const parentSrc = parentEmbedEl.getAttribute("src");
    if (parentSrc) {
      const vaultPath = vaultRelativePathFromObsidianResource(parentSrc);
      if (vaultPath)
        return vaultPath;
      if (!isObsidianResourceUrl(parentSrc))
        return parentSrc;
    }
  }
  if (embedMarkerEl.instanceOf(HTMLImageElement) && embedMarkerEl.src) {
    return vaultRelativePathFromObsidianResource(embedMarkerEl.src);
  }
  return null;
}
function isObsidianResourceUrl(url) {
  return url.startsWith("app://") || url.startsWith("capacitor://") || url.startsWith("obsidian://");
}
function vaultRelativePathFromObsidianResource(url) {
  if (!isObsidianResourceUrl(url))
    return null;
  const pathStart = url.indexOf("/", url.indexOf("://") + 3);
  if (pathStart === -1)
    return null;
  const pathWithQuery = url.slice(pathStart + 1);
  const pathOnly = pathWithQuery.split("?")[0];
  if (!pathOnly)
    return null;
  let decodedPath = pathOnly;
  try {
    decodedPath = decodeURIComponent(pathOnly);
  } catch {
    decodedPath = pathOnly;
  }
  const inkPathMatch = decodedPath.match(/(?:^|\/)Ink\/(?:Writing|Drawing)\/.+\.svg$/i);
  if (inkPathMatch) {
    const inkIndex = decodedPath.search(/Ink\/(?:Writing|Drawing)\//i);
    if (inkIndex !== -1)
      return decodedPath.slice(inkIndex);
  }
  return decodedPath;
}

// src/components/formats/current/reading-mode/ink-reading-embed-host.tsx
var import_obsidian40 = require("obsidian");
var React126 = __toESM(require_react());
var import_client10 = __toESM(require_client());
var import_classnames49 = __toESM(require_classnames());
init_drawing_embed_preview();
init_writing_embed_preview();
init_embed();
init_getFullPageWidth();
init_constants();
init_embed_settings();
init_writing_embed_aspect_ratio();
var InkReadingEmbedHost = class extends import_obsidian40.MarkdownRenderChild {
  constructor(containerEl, params) {
    super(containerEl);
    this.params = params;
    this.reactRoot = null;
    this.resizeObserver = null;
    this.pageResizeObserver = null;
    this.resizeContainerEl = null;
    this.writingFileModifyRef = null;
    this.handleWindowResize = () => {
      this.applyDimensions();
    };
  }
  onload() {
    this.containerEl.removeAttribute(INK_READING_MOUNTING_ATTR);
    this.containerEl.setAttribute(INK_READING_ACTIVE_ATTR, "true");
    applyReadingModeAncestorStyling(this.containerEl, this.params.embedKind);
    this.reactRoot = (0, import_client10.createRoot)(this.containerEl);
    this.reactRoot.render(/* @__PURE__ */ React126.createElement(InkReadingEmbedContent, {
      plugin: this.params.plugin,
      embedKind: this.params.embedKind,
      embeddedFile: this.params.embeddedFile,
      partialEmbedFilepath: this.params.partialEmbedFilepath,
      embedSettings: this.params.embedSettings,
      sourcePath: this.params.sourcePath,
      onMount: (_embedEl, resizeContainerEl) => {
        this.resizeContainerEl = resizeContainerEl;
        this.attachResizeObserver(resizeContainerEl);
        this.attachPageResizeObserver(resizeContainerEl);
        this.applyDimensions();
        void this.syncWritingAspectRatioFromFile();
      }
    }));
    window.addEventListener("resize", this.handleWindowResize);
    if (this.params.embedKind === "writing" && this.params.embeddedFile) {
      const writingFilePath = this.params.embeddedFile.path;
      const onModify = (modifiedFile) => {
        if (modifiedFile.path !== writingFilePath)
          return;
        void this.syncWritingAspectRatioFromFile();
      };
      this.writingFileModifyRef = this.params.plugin.app.vault.on("modify", onModify);
    }
  }
  onunload() {
    window.removeEventListener("resize", this.handleWindowResize);
    if (this.writingFileModifyRef) {
      this.params.plugin.app.vault.offref(this.writingFileModifyRef);
      this.writingFileModifyRef = null;
    }
    this.pageResizeObserver?.disconnect();
    this.pageResizeObserver = null;
    this.resizeContainerEl = null;
    this.containerEl.removeAttribute(INK_READING_ACTIVE_ATTR);
    this.containerEl.removeAttribute(INK_READING_MOUNTING_ATTR);
    this.resizeObserver?.disconnect();
    this.resizeObserver = null;
    this.reactRoot?.unmount();
    this.reactRoot = null;
  }
  applyDimensions() {
    applyReadingModeEmbedDimensions(this.params.embedKind, this.resizeContainerEl, this.params.embedSettings);
  }
  async syncWritingAspectRatioFromFile() {
    if (this.params.embedKind !== "writing" || !this.params.embeddedFile)
      return;
    const derivedAspectRatio = await readWritingFileAspectRatio(this.params.plugin, this.params.embeddedFile);
    if (derivedAspectRatio == null)
      return;
    this.params.embedSettings.embedDisplay.aspectRatio = derivedAspectRatio;
    this.containerEl.dataset.inkEmbedSettings = JSON.stringify(this.params.embedSettings);
    this.applyDimensions();
  }
  attachResizeObserver(resizeContainerEl) {
    if (!resizeContainerEl)
      return;
    this.resizeObserver?.disconnect();
    this.resizeObserver = new ResizeObserver(() => {
      this.applyDimensions();
    });
    this.resizeObserver.observe(resizeContainerEl);
  }
  attachPageResizeObserver(resizeContainerEl) {
    if (!resizeContainerEl)
      return;
    const pageEl = resizeContainerEl.closest(".markdown-preview-view") ?? resizeContainerEl.closest(".markdown-reading-view");
    if (!(pageEl instanceof HTMLElement))
      return;
    this.pageResizeObserver?.disconnect();
    this.pageResizeObserver = new ResizeObserver(() => {
      this.applyDimensions();
    });
    this.pageResizeObserver.observe(pageEl);
  }
};
var InkReadingEmbedContent = (props) => {
  const embedContainerElRef = React126.useRef(null);
  const resizeContainerElRef = React126.useRef(null);
  const embedWidth = props.embedSettings.embedDisplay.width || DRAWING_INITIAL_WIDTH;
  const embedAspectRatio = props.embedSettings.embedDisplay.aspectRatio || DEFAULT_EMBED_SETTINGS.embedDisplay.aspectRatio;
  React126.useLayoutEffect(() => {
    const embedEl = embedContainerElRef.current;
    const resizeContainerEl = resizeContainerElRef.current;
    if (!embedEl)
      return;
    applyReadingModeEmbedDimensions(props.embedKind, resizeContainerEl, props.embedSettings);
    props.onMount(embedEl, resizeContainerEl);
  }, [
    props.embedKind,
    props.embedSettings.embedDisplay.width,
    props.embedSettings.embedDisplay.aspectRatio,
    props.embeddedFile?.path
  ]);
  if (!props.embeddedFile) {
    const notFoundLabel = props.embedKind === "drawing" ? "Drawing" : "Writing";
    return /* @__PURE__ */ React126.createElement("div", {
      className: (0, import_classnames49.default)("ddc_ink_embed", embedOuterClass(props.embedKind))
    }, /* @__PURE__ */ React126.createElement("div", {
      className: "ddc_ink_pending-banner ddc_ink_pending-banner--not-found"
    }, /* @__PURE__ */ React126.createElement("span", {
      className: "ddc_ink_pending-banner__title"
    }, notFoundLabel, " file not found: ", props.partialEmbedFilepath)));
  }
  return /* @__PURE__ */ React126.createElement("div", {
    ref: embedContainerElRef,
    className: (0, import_classnames49.default)("ddc_ink_embed", embedOuterClass(props.embedKind)),
    style: {
      paddingTop: "1em",
      paddingBottom: "0.5em"
    }
  }, /* @__PURE__ */ React126.createElement("div", {
    ref: resizeContainerElRef,
    className: "ddc_ink_resize-container",
    style: props.embedKind === "drawing" ? {
      width: `${embedWidth}px`,
      height: `${embedWidth / embedAspectRatio}px`
    } : {
      position: "relative"
    }
  }, props.embedKind === "drawing" ? /* @__PURE__ */ React126.createElement(DrawingEmbedPreview, {
    key: props.embeddedFile.path,
    embeddedFile: props.embeddedFile,
    embedSettings: props.embedSettings,
    onReady: () => {
    },
    onClick: () => {
    }
  }) : /* @__PURE__ */ React126.createElement(WritingEmbedPreview, {
    plugin: props.plugin,
    writingFile: props.embeddedFile,
    onResize: () => {
    },
    onClick: () => {
    }
  })));
};
function embedOuterClass(embedKind) {
  return embedKind === "drawing" ? "ddc_ink_drawing-embed" : "ddc_ink_writing-embed";
}
function applyReadingModeEmbedDimensions(embedKind, resizeContainerEl, embedSettings) {
  if (!resizeContainerEl)
    return;
  const aspectRatio = embedSettings.embedDisplay.aspectRatio || DEFAULT_EMBED_SETTINGS.embedDisplay.aspectRatio;
  const configuredWidth = embedSettings.embedDisplay.width || DRAWING_INITIAL_WIDTH;
  const pageWidth = getFullPageWidth(resizeContainerEl);
  const containerWidth = resizeContainerEl.getBoundingClientRect().width;
  if (embedKind === "drawing") {
    resizeContainerEl.style.width = `${configuredWidth}px`;
    if (pageWidth > 0) {
      resizeContainerEl.style.maxWidth = `${pageWidth}px`;
    }
    const renderedWidth = containerWidth > 0 ? containerWidth : pageWidth > 0 ? Math.min(configuredWidth, pageWidth) : configuredWidth;
    resizeContainerEl.style.height = `${renderedWidth / aspectRatio}px`;
    return;
  }
  const writingWidth = containerWidth || pageWidth || maxFallbackWidth(resizeContainerEl);
  resizeContainerEl.style.height = `${writingWidth / aspectRatio}px`;
}
function refreshReadingModeEmbedDimensionsInRoot(rootEl) {
  for (const hostEl of rootEl.querySelectorAll(".ddc_ink_reading-embed-host")) {
    const embedKind = hostEl.dataset.inkEmbedKind;
    const embedSettingsJson = hostEl.dataset.inkEmbedSettings;
    if (!embedKind || !embedSettingsJson)
      continue;
    let embedSettings;
    try {
      embedSettings = JSON.parse(embedSettingsJson);
    } catch {
      continue;
    }
    const resizeContainerEl = hostEl.querySelector(".ddc_ink_resize-container");
    applyReadingModeEmbedDimensions(embedKind, resizeContainerEl, embedSettings);
  }
}
function maxFallbackWidth(resizeContainerEl) {
  return getFullPageWidth(resizeContainerEl);
}

// src/components/formats/current/reading-mode/register-reading-mode-ink-embeds.ts
init_ink_embed_refresh();
init_7();
init_24();
init_14();
init_16();
var READING_MODE_EMBED_SCAN_ROOT_SELECTOR = "p, .el-p, .markdown-preview-section, blockquote, .callout, .markdown-embed";
var FULL_PAGE_PREVIEW_ROOT_SELECTOR = ".markdown-preview-view";
var INK_READING_EMBED_KIND_DATA = "inkEmbedKind";
var INK_READING_FILE_PATH_DATA = "inkFilePath";
var INK_READING_EMBED_SETTINGS_DATA = "inkEmbedSettings";
var INK_READING_SOURCE_PATH_DATA = "inkSourcePath";
function registerReadingModeInkEmbeds(plugin) {
  plugin.registerMarkdownPostProcessor((element, context) => {
    const matchesScanRoot = element.matches(READING_MODE_EMBED_SCAN_ROOT_SELECTOR);
    const isFullPagePreviewRoot = element.matches(FULL_PAGE_PREVIEW_ROOT_SELECTOR);
    if (!matchesScanRoot && !isFullPagePreviewRoot)
      return;
    queueMicrotask(() => {
      if (!element.isConnected)
        return;
      processReadingModeInkEmbedsInRoot(plugin, element, context);
    });
  }, 100);
  const scheduleReadingModeOrLivePreviewEmbedRefresh = () => {
    queueMicrotask(() => {
      const markdownView = plugin.app.workspace.getActiveViewOfType(import_obsidian41.MarkdownView);
      if (!markdownView)
        return;
      if (markdownView.getMode() === "preview") {
        remountStaleReadingEmbedHostsInActivePreview(plugin);
      } else {
        refreshLivePreviewEmbedsWhenReady(plugin);
      }
    });
  };
  plugin.registerEvent(plugin.app.workspace.on("layout-change", scheduleReadingModeOrLivePreviewEmbedRefresh));
  plugin.registerEvent(plugin.app.workspace.on("active-leaf-change", scheduleReadingModeOrLivePreviewEmbedRefresh));
}
function processReadingModeInkEmbedsInRoot(plugin, rootEl, context) {
  const isFullPageRoot = rootEl.matches(FULL_PAGE_PREVIEW_ROOT_SELECTOR);
  const candidates = findReadingModeInkEmbedCandidates(plugin.app, rootEl, context.sourcePath);
  const sortedCandidates = [...candidates].sort((a2, b2) => {
    const position = b2.embedMarkerEl.compareDocumentPosition(a2.embedMarkerEl);
    return (position & Node.DOCUMENT_POSITION_FOLLOWING) !== 0 ? 1 : -1;
  });
  for (const candidate of sortedCandidates) {
    if (!candidate.embedMarkerEl.isConnected || !candidate.editLinkEl.isConnected) {
      continue;
    }
    const hostEl = activeDocument.createElement("div");
    hostEl.setAttribute(INK_READING_PROCESSED_ATTR, "true");
    hostEl.classList.add("ddc_ink_reading-embed-host");
    stampReadingEmbedHostMetadata(hostEl, candidate, context.sourcePath);
    replaceInkEmbedRangeWithHost(candidate.embedMarkerEl, candidate.editLinkEl, hostEl);
    mountReadingEmbedHost(plugin, hostEl, {
      plugin,
      embedKind: candidate.embedKind,
      embeddedFile: candidate.embeddedFile,
      partialEmbedFilepath: candidate.partialEmbedFilepath,
      embedSettings: candidate.embedSettings,
      sourcePath: context.sourcePath
    }, context);
  }
  window.requestAnimationFrame(() => {
    if (!isFullPageRoot) {
      remountStaleReadingEmbedHostsInRoot(plugin, rootEl, context.sourcePath);
    }
    refreshReadingModeEmbedDimensionsInRoot(rootEl);
  });
}
function remountStaleReadingEmbedHostsInActivePreview(plugin) {
  const markdownView = plugin.app.workspace.getActiveViewOfType(import_obsidian41.MarkdownView);
  if (!markdownView || markdownView.getMode() !== "preview")
    return;
  const sourcePath = markdownView.file?.path;
  if (!sourcePath)
    return;
  const previewEl = markdownView.containerEl.querySelector(".markdown-reading-view");
  if (!(previewEl instanceof HTMLElement))
    return;
  remountStaleReadingEmbedHostsInRoot(plugin, previewEl, sourcePath);
  window.requestAnimationFrame(() => {
    refreshReadingModeEmbedDimensionsInRoot(previewEl);
  });
}
function remountStaleReadingEmbedHostsInRoot(plugin, rootEl, sourcePath) {
  const staleHostEls = [...rootEl.querySelectorAll(`.ddc_ink_reading-embed-host[${INK_READING_PROCESSED_ATTR}]`)].filter((hostEl) => {
    if (hostEl.hasAttribute(INK_READING_MOUNTING_ATTR))
      return false;
    if (!hostEl.hasAttribute(INK_READING_ACTIVE_ATTR))
      return true;
    return !hostEl.querySelector(".ddc_ink_embed");
  });
  if (staleHostEls.length === 0)
    return;
  for (const hostEl of staleHostEls) {
    hostEl.removeAttribute(INK_READING_ACTIVE_ATTR);
    hostEl.replaceChildren();
    const params = readReadingEmbedHostParams(plugin, hostEl, sourcePath);
    if (!params)
      continue;
    mountReadingEmbedHost(plugin, hostEl, params);
  }
}
function stampReadingEmbedHostMetadata(hostEl, candidate, sourcePath) {
  hostEl.dataset[INK_READING_EMBED_KIND_DATA] = candidate.embedKind;
  hostEl.dataset[INK_READING_FILE_PATH_DATA] = candidate.partialEmbedFilepath;
  hostEl.dataset[INK_READING_EMBED_SETTINGS_DATA] = JSON.stringify(candidate.embedSettings);
  hostEl.dataset[INK_READING_SOURCE_PATH_DATA] = sourcePath;
}
function readReadingEmbedHostParams(plugin, hostEl, fallbackSourcePath) {
  const embedKind = hostEl.dataset[INK_READING_EMBED_KIND_DATA];
  const partialEmbedFilepath = hostEl.dataset[INK_READING_FILE_PATH_DATA];
  const embedSettingsJson = hostEl.dataset[INK_READING_EMBED_SETTINGS_DATA];
  if (!embedKind || !partialEmbedFilepath || !embedSettingsJson)
    return null;
  let embedSettings;
  try {
    embedSettings = JSON.parse(embedSettingsJson);
  } catch {
    return null;
  }
  const sourcePath = hostEl.dataset[INK_READING_SOURCE_PATH_DATA] || fallbackSourcePath;
  const embeddedFile = plugin.app.metadataCache.getFirstLinkpathDest((0, import_obsidian41.normalizePath)(partialEmbedFilepath), sourcePath);
  return {
    plugin,
    embedKind,
    embeddedFile,
    partialEmbedFilepath,
    embedSettings,
    sourcePath
  };
}
function mountReadingEmbedHost(plugin, hostEl, params, context) {
  if (hostEl.hasAttribute(INK_READING_ACTIVE_ATTR) || hostEl.hasAttribute(INK_READING_MOUNTING_ATTR)) {
    return;
  }
  hostEl.setAttribute(INK_READING_MOUNTING_ATTR, "true");
  const host = new InkReadingEmbedHost(hostEl, params);
  if (context) {
    context.addChild(host);
  } else {
    plugin.addChild(host);
  }
}
function replaceInkEmbedRangeWithHost(embedMarkerEl, editLinkEl, hostEl) {
  const range = activeDocument.createRange();
  range.setStartBefore(embedMarkerEl);
  range.setEndAfter(editLinkEl);
  range.deleteContents();
  const parentEl = range.startContainer.parentElement;
  if (!parentEl)
    return;
  range.insertNode(hostEl);
  const emptyParagraphEl = hostEl.parentElement;
  if (emptyParagraphEl && (emptyParagraphEl.tagName === "P" || emptyParagraphEl.classList.contains("el-p")) && emptyParagraphEl.childNodes.length === 1 && emptyParagraphEl.textContent?.trim() === "") {
    emptyParagraphEl.replaceWith(hostEl);
  }
}

// src/components/formats/current/utils/paste-embed-handler.ts
var INK_EMBED_REGEX = / !\[Ink(?:Writing|Drawing)\]\(<([^>]+)>\) \[Edit (?:Writing|Drawing)\]\(([^)]+)\)/g;
function injectPendingPasteIntoEmbeds(text) {
  let foundEmbeds = false;
  const modified = text.replace(INK_EMBED_REGEX, (fullMatch, _filepath, settingsUrl) => {
    foundEmbeds = true;
    return fullMatch.replace(`(${settingsUrl})`, `(${settingsUrl}&pendingPaste=true)`);
  });
  if (!foundEmbeds)
    return null;
  return modified;
}
function registerPasteEmbedHandler(plugin) {
  plugin.registerEvent(plugin.app.workspace.on("editor-paste", (evt, editor) => {
    if (evt.defaultPrevented)
      return;
    const clipboardText = evt.clipboardData?.getData("text/plain");
    if (!clipboardText)
      return;
    const modifiedText = injectPendingPasteIntoEmbeds(clipboardText);
    if (!modifiedText)
      return;
    evt.preventDefault();
    editor.replaceSelection(modifiedText);
  }));
}

// src/main.ts
init_global_store();
init_writing_view();
init_drawing_view();

// src/components/dom-components/modals/migration-modal/migration-modal.ts
init_15();
var import_obsidian42 = require("obsidian");
init_migration_logic();
init_tldraw_svg_migration_logic();
var MigrationModal = class extends import_obsidian42.Modal {
  constructor(plugin, onPermanentMigrationFinished) {
    super(plugin.app);
    this.phase = 0 /* Scanning */;
    this.scanResult = null;
    this.tldrawScanResult = null;
    this.migrationResult = null;
    this.migrationOptions = { testRun: false };
    this.progressBarInnerEl = null;
    this.statusTextEl = null;
    this.convertedCountEl = null;
    this.remainingCountEl = null;
    this.skippedCountEl = null;
    this.failedCountEl = null;
    this.logEl = null;
    this.resolveLinkPath = (linkpath, sourceNotePath) => {
      return this.plugin.app.metadataCache.getFirstLinkpathDest(linkpath, sourceNotePath)?.path ?? null;
    };
    this.plugin = plugin;
    this.onPermanentMigrationFinished = onPermanentMigrationFinished;
  }
  onOpen() {
    this.titleEl.setText("Migrate legacy ink embeds to ink-canvas");
    this.contentEl.addClass("ddc_ink_migration-modal");
    this.renderScanPhase();
  }
  onClose() {
    this.contentEl.empty();
  }
  get legacyFileCount() {
    return this.scanResult?.legacyFiles.length ?? 0;
  }
  get tldrawFileCount() {
    return this.tldrawScanResult?.tldrawSvgFiles.length ?? 0;
  }
  renderScanPhase() {
    this.phase = 0 /* Scanning */;
    const { contentEl } = this;
    contentEl.empty();
    this.statusTextEl = contentEl.createDiv({ cls: "ddc_ink_migration-status-text", text: "Scanning vault for legacy embeds\u2026" });
    const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
    this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
    const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
    this.remainingCountEl = this.createStat(statsEl, "0", "remaining").countEl;
    this.convertedCountEl = this.createStat(statsEl, "0", "found").countEl;
    void this.runScan();
  }
  async runScan() {
    try {
      if (this.statusTextEl)
        this.statusTextEl.setText("Scanning for .writing / .drawing files\u2026");
      this.scanResult = await scanVaultForLegacyEmbeds(this.plugin.app.vault, (scanned, tot, foundCount) => {
        const remaining = tot - scanned;
        const pct = tot > 0 ? scanned / tot * 100 : 100;
        if (this.progressBarInnerEl) {
          this.progressBarInnerEl.style.width = (pct * 0.5).toFixed(1) + "%";
        }
        if (this.remainingCountEl)
          this.remainingCountEl.setText(String(remaining));
        if (this.convertedCountEl)
          this.convertedCountEl.setText(String(foundCount));
      });
      if (this.statusTextEl)
        this.statusTextEl.setText("Scanning for older tldraw SVG files\u2026");
      this.tldrawScanResult = await scanVaultForTldrawInkSvgFiles(this.plugin.app.vault, this.resolveLinkPath, (scanned, tot, foundCount) => {
        const remaining = tot - scanned;
        const pct = tot > 0 ? scanned / tot * 100 : 100;
        if (this.progressBarInnerEl) {
          this.progressBarInnerEl.style.width = (50 + pct * 0.5).toFixed(1) + "%";
        }
        if (this.remainingCountEl)
          this.remainingCountEl.setText(String(remaining));
        const legacyFound = this.scanResult?.legacyFiles.length ?? 0;
        if (this.convertedCountEl)
          this.convertedCountEl.setText(String(legacyFound + foundCount));
      });
    } catch (err) {
      if (this.statusTextEl)
        this.statusTextEl.setText("Scan failed: " + String(err));
      return;
    }
    if (this.legacyFileCount === 0 && this.tldrawFileCount === 0) {
      this.renderNothingToMigrate();
    } else {
      this.renderConfirmPhase();
    }
  }
  renderNothingToMigrate() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("p", { text: "No legacy Ink files were found in your vault. Nothing to migrate." });
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    const doneBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Done" });
    doneBtn.addEventListener("click", () => this.close());
  }
  renderConfirmPhase() {
    this.phase = 1 /* Confirm */;
    const { contentEl } = this;
    contentEl.empty();
    this.titleEl.setText("Migrate legacy ink files to new format");
    const parts = [];
    if (this.legacyFileCount > 0) {
      parts.push(`${this.legacyFileCount} legacy .writing/.drawing file${this.legacyFileCount !== 1 ? "s" : ""}`);
    }
    if (this.tldrawFileCount > 0) {
      parts.push(`${this.tldrawFileCount} older SVG file${this.tldrawFileCount !== 1 ? "s" : ""} still on the previous format`);
    }
    contentEl.createEl("p", {
      text: `Found ${parts.join(" and ")}. This modal migrates them to the newest SVG format.`
    });
    this.renderMigrationChoiceCards(contentEl);
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    const cancelBtn = buttonsEl.createEl("button", { text: "Cancel" });
    cancelBtn.addEventListener("click", () => this.close());
  }
  renderMigrationChoiceCards(parent) {
    const gridEl = parent.createDiv({ cls: "ddc_ink_migration-choice-grid" });
    const hasLegacyV1 = this.legacyFileCount > 0;
    if (hasLegacyV1) {
      const testCard = gridEl.createDiv({ cls: "ddc_ink_migration-choice-card" });
      testCard.setAttribute("role", "button");
      testCard.setAttribute("tabindex", "0");
      testCard.createDiv({ cls: "ddc_ink_migration-choice-card-title", text: "Test Migration" });
      testCard.createDiv({
        cls: "ddc_ink_migration-choice-card-desc",
        text: this.tldrawFileCount > 0 ? `Convert .writing/.drawing files into the new format without deleting the old files. Older SVG files (${this.tldrawFileCount}) are only converted on permanent migrate.` : "Convert legacy files into the new format without deleting the old files. Validate the conversion works before migrating permanently."
      });
      testCard.addEventListener("click", () => this.startMigration({ testRun: true }));
      testCard.addEventListener("keydown", (ev) => {
        if (ev.key === "Enter" || ev.key === " ") {
          ev.preventDefault();
          this.startMigration({ testRun: true });
        }
      });
    }
    const permanentCard = gridEl.createDiv({ cls: "ddc_ink_migration-choice-card" });
    permanentCard.setAttribute("role", "button");
    permanentCard.setAttribute("tabindex", "0");
    permanentCard.createDiv({ cls: "ddc_ink_migration-choice-card-title", text: "Migrate Permanently" });
    permanentCard.createDiv({
      cls: "ddc_ink_migration-choice-card-desc",
      text: hasLegacyV1 ? "Convert legacy .writing/.drawing files (and delete them), convert older SVG files in place, and update links in notes." : "Convert older SVG files in place to the newest format and update drawing embed framing in notes where needed."
    });
    permanentCard.addEventListener("click", () => this.startMigration({ testRun: false }));
    permanentCard.addEventListener("keydown", (ev) => {
      if (ev.key === "Enter" || ev.key === " ") {
        ev.preventDefault();
        this.startMigration({ testRun: false });
      }
    });
  }
  startMigration(options) {
    this.migrationOptions = options;
    this.renderMigratingPhase();
  }
  renderList(parent, title, items) {
    const sectionEl = parent.createDiv({ cls: "ddc_ink_migration-section" });
    sectionEl.createDiv({ cls: "ddc_ink_migration-section-title", text: title });
    const listEl = sectionEl.createDiv({ cls: "ddc_ink_migration-list" });
    if (items.length === 0) {
      listEl.createDiv({ cls: "ddc_ink_migration-list-empty", text: "None" });
    } else {
      for (const item of items) {
        listEl.createDiv({ cls: "ddc_ink_migration-list-item", text: item });
      }
    }
  }
  renderMigratingPhase() {
    this.phase = 2 /* Migrating */;
    const { contentEl } = this;
    contentEl.empty();
    const isTestRun = this.migrationOptions.testRun === true;
    this.statusTextEl = contentEl.createDiv({
      cls: "ddc_ink_migration-status-text",
      text: isTestRun ? "Running test migration\u2026" : "Migrating\u2026"
    });
    const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
    this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
    const legacySteps = this.legacyFileCount + (isTestRun ? 0 : this.scanResult?.affectedNotes.length ?? 0);
    const tldrawSteps = isTestRun ? 0 : this.tldrawFileCount + (this.tldrawScanResult?.affectedNotes.length ?? 0);
    const totalSteps = legacySteps + tldrawSteps;
    const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
    this.convertedCountEl = this.createStat(statsEl, "0", "converted").countEl;
    this.remainingCountEl = this.createStat(statsEl, String(totalSteps), "remaining").countEl;
    this.skippedCountEl = this.createStat(statsEl, "0", "skipped").countEl;
    this.failedCountEl = this.createStat(statsEl, "0", "failed").countEl;
    this.logEl = contentEl.createDiv({ cls: "ddc_ink_migration-log" });
    this.logEl.hide();
    void this.runMigration(totalSteps, legacySteps);
  }
  async runMigration(totalSteps, legacySteps) {
    const isTestRun = this.migrationOptions.testRun === true;
    let legacyResult = null;
    let tldrawResult = null;
    const updateLive = (doneInPhase, phaseOffset, liveStats, convertedOffset, skippedOffset, failedOffset) => {
      const done = phaseOffset + doneInPhase;
      const pct = totalSteps > 0 ? done / totalSteps * 100 : 100;
      if (this.progressBarInnerEl)
        this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
      if (this.remainingCountEl)
        this.remainingCountEl.setText(String(Math.max(0, totalSteps - done)));
      if (this.convertedCountEl) {
        this.convertedCountEl.setText(String(convertedOffset + liveStats.convertedFiles));
      }
      if (this.skippedCountEl)
        this.skippedCountEl.setText(String(skippedOffset + liveStats.skippedCount));
      if (this.failedCountEl)
        this.failedCountEl.setText(String(failedOffset + liveStats.failedCount));
    };
    try {
      if (this.scanResult && this.legacyFileCount > 0) {
        if (this.statusTextEl) {
          this.statusTextEl.setText(isTestRun ? "Converting .writing / .drawing (test)\u2026" : "Converting .writing / .drawing\u2026");
        }
        legacyResult = await executeMigration(this.plugin.app.vault, this.plugin.app.fileManager, this.scanResult, (d2, _tot, liveStats) => {
          updateLive(d2, 0, liveStats, 0, 0, 0);
        }, this.migrationOptions);
      }
      if (!isTestRun && this.tldrawScanResult && this.tldrawFileCount > 0) {
        if (this.statusTextEl)
          this.statusTextEl.setText("Converting older SVG files\u2026");
        const convertedOffset = legacyResult?.convertedFiles ?? 0;
        const skippedOffset = legacyResult?.skipped.length ?? 0;
        const failedOffset = legacyResult?.failed.length ?? 0;
        tldrawResult = await executeTldrawSvgMigration(this.plugin.app.vault, this.tldrawScanResult, (d2, _tot, liveStats) => {
          updateLive(d2, legacySteps, liveStats, convertedOffset, skippedOffset, failedOffset);
        });
      }
    } catch (err) {
      if (this.statusTextEl)
        this.statusTextEl.setText("Migration failed: " + String(err));
      return;
    }
    this.migrationResult = { legacy: legacyResult, tldraw: tldrawResult };
    this.renderDonePhase();
  }
  renderDonePhase() {
    this.phase = 3 /* Done */;
    const { contentEl } = this;
    const combined = this.migrationResult;
    const isTestRun = this.migrationOptions.testRun === true;
    contentEl.empty();
    const legacy = combined.legacy;
    const tldraw = combined.tldraw;
    const convertedFiles = (legacy?.convertedFiles ?? 0) + (tldraw?.convertedFiles ?? 0);
    const updatedNotePaths = [
      ...legacy?.updatedNotePaths ?? [],
      ...tldraw?.updatedNotePaths ?? []
    ];
    const uniqueNotePaths = [...new Set(updatedNotePaths)];
    const skipped = [...legacy?.skipped ?? [], ...tldraw?.skipped ?? []];
    const failed = [...legacy?.failed ?? [], ...tldraw?.failed ?? []];
    if (isTestRun) {
      this.titleEl.setText("Test Migration Complete");
      const hasFailures = failed.length > 0;
      const summary = hasFailures ? `Test migration finished with errors. ${legacy?.convertedFiles ?? 0} file${(legacy?.convertedFiles ?? 0) !== 1 ? "s" : ""} written to ${INK_TEST_CONVERSIONS_FOLDER}/.` : `Test migration complete. ${legacy?.convertedFiles ?? 0} file${(legacy?.convertedFiles ?? 0) !== 1 ? "s" : ""} written to ${INK_TEST_CONVERSIONS_FOLDER}/.`;
      contentEl.createEl("p", { text: summary });
      if (this.tldrawFileCount > 0) {
        contentEl.createEl("p", {
          text: `${this.tldrawFileCount} older SVG file${this.tldrawFileCount !== 1 ? "s" : ""} were left unchanged \u2014 run Migrate Permanently to convert them.`
        });
      }
      const whatsNextEl = contentEl.createDiv({ cls: "ddc_ink_migration-whats-next" });
      whatsNextEl.createEl("p", { text: "What's next:" });
      const stepsEl = whatsNextEl.createEl("ul");
      stepsEl.createEl("li", {
        text: `Check conversion tests in ${INK_TEST_CONVERSIONS_FOLDER}/.`
      });
      stepsEl.createEl("li", { text: "If satisfied, delete test conversions folder." });
      stepsEl.createEl("li", { text: "Run migration again permanently." });
    } else {
      contentEl.createEl("p", {
        text: `Migration complete. ${convertedFiles} file${convertedFiles !== 1 ? "s" : ""} converted, ${uniqueNotePaths.length} note${uniqueNotePaths.length !== 1 ? "s" : ""} updated.`
      });
      this.onPermanentMigrationFinished?.();
    }
    if (skipped.length > 0) {
      this.renderList(contentEl, `Skipped (${skipped.length})`, skipped);
    }
    if (failed.length > 0) {
      this.renderList(contentEl, `Failed (${failed.length})`, failed);
    }
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    if (!isTestRun && uniqueNotePaths.length > 0) {
      if (uniqueNotePaths.length > 10) {
        const randomBtn = buttonsEl.createEl("button", { text: "Open 10 random notes" });
        randomBtn.addEventListener("click", () => {
          const shuffled = [...uniqueNotePaths].sort(() => Math.random() - 0.5);
          for (const path of shuffled.slice(0, 10)) {
            void this.plugin.app.workspace.openLinkText(path, "", true);
          }
        });
      }
      const openAllBtn = buttonsEl.createEl("button", { text: `Open all ${uniqueNotePaths.length} notes` });
      openAllBtn.addEventListener("click", () => {
        for (const path of uniqueNotePaths) {
          void this.plugin.app.workspace.openLinkText(path, "", true);
        }
      });
    }
    const doneBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Done" });
    doneBtn.addEventListener("click", () => this.close());
  }
  createStat(parent, count3, label) {
    const statEl = parent.createDiv({ cls: "ddc_ink_migration-stat" });
    const countEl = statEl.createDiv({ cls: "ddc_ink_migration-stat-count", text: count3 });
    statEl.createDiv({ cls: "ddc_ink_migration-stat-name", text: label });
    return { countEl };
  }
};

// src/components/dom-components/modals/tldraw-svg-migration-modal/tldraw-svg-migration-modal.ts
init_15();
var import_obsidian43 = require("obsidian");
init_tldraw_svg_migration_logic();
var TldrawSvgMigrationModal = class extends import_obsidian43.Modal {
  constructor(plugin) {
    super(plugin.app);
    this.scanResult = null;
    this.migrationResult = null;
    this.progressBarInnerEl = null;
    this.statusTextEl = null;
    this.convertedCountEl = null;
    this.remainingCountEl = null;
    this.skippedCountEl = null;
    this.failedCountEl = null;
    this.plugin = plugin;
  }
  onOpen() {
    this.titleEl.setText("Migrate tldraw SVG files to ink-canvas");
    this.contentEl.addClass("ddc_ink_migration-modal");
    this.renderScanPhase();
  }
  onClose() {
    this.contentEl.empty();
  }
  renderScanPhase() {
    const { contentEl } = this;
    contentEl.empty();
    this.statusTextEl = contentEl.createDiv({
      cls: "ddc_ink_migration-status-text",
      text: "Scanning vault for tldraw SVG files\u2026"
    });
    const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
    this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
    const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
    this.remainingCountEl = this.createStat(statsEl, "0", "remaining").countEl;
    this.convertedCountEl = this.createStat(statsEl, "0", "found").countEl;
    void this.runScan();
  }
  async runScan() {
    const resolveLinkPath = (linkpath, sourceNotePath) => {
      const resolved = this.plugin.app.metadataCache.getFirstLinkpathDest(linkpath, sourceNotePath);
      return resolved?.path ?? null;
    };
    try {
      this.scanResult = await scanVaultForTldrawInkSvgFiles(this.plugin.app.vault, resolveLinkPath, (scanned, tot, foundCount) => {
        const remaining = tot - scanned;
        const pct = tot > 0 ? scanned / tot * 100 : 100;
        if (this.progressBarInnerEl) {
          this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
        }
        if (this.remainingCountEl)
          this.remainingCountEl.setText(String(remaining));
        if (this.convertedCountEl) {
          this.convertedCountEl.setText(String(foundCount));
        }
      });
    } catch (err) {
      if (this.statusTextEl)
        this.statusTextEl.setText("Scan failed: " + String(err));
      return;
    }
    if (this.scanResult.tldrawSvgFiles.length === 0) {
      this.renderNothingToMigrate();
    } else {
      this.renderConfirmPhase();
    }
  }
  renderNothingToMigrate() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("p", {
      text: "No v2 tldraw SVG files referenced by embeds were found. Nothing to migrate."
    });
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    const doneBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Done" });
    doneBtn.addEventListener("click", () => this.close());
  }
  renderConfirmPhase() {
    const { contentEl } = this;
    const scan = this.scanResult;
    contentEl.empty();
    contentEl.createEl("p", {
      text: `Developer tool: found ${scan.tldrawSvgFiles.length} tldraw SVG file${scan.tldrawSvgFiles.length !== 1 ? "s" : ""} and ${scan.affectedNotes.length} note${scan.affectedNotes.length !== 1 ? "s" : ""} referencing them. Each file will be upgraded in place to ink-canvas metadata. Drawing embeds will get a viewBox fitted to stroke bounds. Writing embed lines are unchanged.`
    });
    this.renderList(contentEl, `SVG files to convert (${scan.tldrawSvgFiles.length})`, scan.tldrawSvgFiles.map((e2) => e2.svgFile.path));
    this.renderList(contentEl, `Notes that may be updated (${scan.affectedNotes.length})`, scan.affectedNotes.map((n2) => n2.path));
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    const cancelBtn = buttonsEl.createEl("button", { text: "Cancel" });
    cancelBtn.addEventListener("click", () => this.close());
    const migrateBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Migrate" });
    migrateBtn.addEventListener("click", () => this.renderMigratingPhase());
  }
  renderList(parent, title, items) {
    const sectionEl = parent.createDiv({ cls: "ddc_ink_migration-section" });
    sectionEl.createDiv({ cls: "ddc_ink_migration-section-title", text: title });
    const listEl = sectionEl.createDiv({ cls: "ddc_ink_migration-list" });
    if (items.length === 0) {
      listEl.createDiv({ cls: "ddc_ink_migration-list-empty", text: "None" });
    } else {
      for (const item of items) {
        listEl.createDiv({ cls: "ddc_ink_migration-list-item", text: item });
      }
    }
  }
  renderMigratingPhase() {
    const { contentEl } = this;
    contentEl.empty();
    this.statusTextEl = contentEl.createDiv({ cls: "ddc_ink_migration-status-text", text: "Migrating\u2026" });
    const progressBarEl = contentEl.createDiv({ cls: "ddc_ink_migration-progress-bar" });
    this.progressBarInnerEl = progressBarEl.createDiv({ cls: "ddc_ink_migration-progress-bar-inner" });
    const statsEl = contentEl.createDiv({ cls: "ddc_ink_migration-stats" });
    this.convertedCountEl = this.createStat(statsEl, "0", "converted").countEl;
    this.remainingCountEl = this.createStat(statsEl, String(this.scanResult.tldrawSvgFiles.length + this.scanResult.affectedNotes.length), "remaining").countEl;
    this.skippedCountEl = this.createStat(statsEl, "0", "skipped").countEl;
    this.failedCountEl = this.createStat(statsEl, "0", "failed").countEl;
    void this.runMigration();
  }
  async runMigration() {
    const scan = this.scanResult;
    try {
      this.migrationResult = await executeTldrawSvgMigration(this.plugin.app.vault, scan, (d2, tot, liveStats) => {
        const pct = tot > 0 ? d2 / tot * 100 : 100;
        if (this.progressBarInnerEl)
          this.progressBarInnerEl.style.width = pct.toFixed(1) + "%";
        if (this.remainingCountEl)
          this.remainingCountEl.setText(String(tot - d2));
        if (this.convertedCountEl) {
          this.convertedCountEl.setText(String(liveStats.convertedFiles));
        }
        if (this.skippedCountEl) {
          this.skippedCountEl.setText(String(liveStats.skippedCount));
        }
        if (this.failedCountEl) {
          this.failedCountEl.setText(String(liveStats.failedCount));
        }
      });
    } catch (err) {
      if (this.statusTextEl)
        this.statusTextEl.setText("Migration failed: " + String(err));
      return;
    }
    this.renderDonePhase();
  }
  renderDonePhase() {
    const { contentEl } = this;
    const result = this.migrationResult;
    contentEl.empty();
    contentEl.createEl("p", {
      text: `Migration complete. ${result.convertedFiles} file${result.convertedFiles !== 1 ? "s" : ""} converted, ${result.updatedNotes} drawing note${result.updatedNotes !== 1 ? "s" : ""} updated with fitted viewBox.`
    });
    if (result.skipped.length > 0) {
      this.renderList(contentEl, `Skipped (${result.skipped.length})`, result.skipped);
    }
    if (result.failed.length > 0) {
      this.renderList(contentEl, `Failed (${result.failed.length})`, result.failed);
    }
    const buttonsEl = contentEl.createDiv({ cls: "ddc_ink_migration-buttons" });
    if (result.updatedNotePaths.length > 0) {
      const openAllBtn = buttonsEl.createEl("button", {
        text: `Open all ${result.updatedNotePaths.length} updated notes`
      });
      openAllBtn.addEventListener("click", () => {
        for (const path of result.updatedNotePaths) {
          void this.plugin.app.workspace.openLinkText(path, "", true);
        }
      });
    }
    const doneBtn = buttonsEl.createEl("button", { cls: "mod-cta", text: "Done" });
    doneBtn.addEventListener("click", () => this.close());
  }
  createStat(parent, count3, label) {
    const statEl = parent.createDiv({ cls: "ddc_ink_migration-stat" });
    const countEl = statEl.createDiv({ cls: "ddc_ink_migration-stat-count", text: count3 });
    statEl.createDiv({ cls: "ddc_ink_migration-stat-name", text: label });
    return { countEl };
  }
};

// src/main.ts
init_file_conversion_modal();
init_convert_file_embeds();
init_remove_embed_flow();
init_remove_embed_modal();

// src/logic/undo-redo/keyboard-handler.ts
var import_obsidian44 = require("obsidian");
init_log_to_vault();
init_ink_editor_registry();
init_dedicated_ink_editor_registry();
init_writing_view();
init_drawing_view();
init_unified_undo_stack();
init_embedded_unified_undo();
init_obsidian_undo_depth();
init_universal_dev_logging();
function formatStackForLog2(snapshot) {
  return "[" + snapshot.map((e2) => {
    if (e2.type === "obsidian")
      return "Obsidian";
    if (e2.type === "embed-resize")
      return `EmbedResize:${e2.embedId}`;
    return `Embed:${e2.embedId}`;
  }).join(", ") + "]";
}
var EMPTY_UNDO_MESSAGE = "To undo further in Obsidian you must lock the Ink embed (which will discard any redo ability in the embed).";
function getUnifiedUndoRedoIntent(event) {
  const isUnifiedModPressed = event.metaKey || event.ctrlKey;
  if (!isUnifiedModPressed)
    return null;
  const key = (event.key ?? "").toLowerCase();
  if (key === "z" && !event.shiftKey)
    return "undo";
  if (key === "z" && event.shiftKey)
    return "redo";
  return null;
}
function getDedicatedUndoRedoIntent(event) {
  const isUnifiedModPressed = event.metaKey || event.ctrlKey;
  if (!isUnifiedModPressed)
    return null;
  const key = (event.key ?? "").toLowerCase();
  if (key === "z" && !event.shiftKey)
    return "undo";
  if (key === "z" && event.shiftKey)
    return "redo";
  if (key === "y")
    return "redo";
  return null;
}
function isActiveLeafDedicatedInk(plugin) {
  const leaf = plugin.app.workspace.getMostRecentLeaf();
  const viewType = leaf?.view?.getViewType?.();
  return viewType === WRITING_VIEW_TYPE || viewType === DRAWING_VIEW_TYPE;
}
function handleKeydown(plugin, event) {
  const leafId = plugin.app.workspace.getMostRecentLeaf()?.id;
  if (!leafId)
    return;
  const isDedicatedLeaf = isActiveLeafDedicatedInk(plugin);
  const dedicatedEditor = getDedicatedInkEditor(leafId);
  if (isDedicatedLeaf && dedicatedEditor !== null) {
    const dedicatedIntent = getDedicatedUndoRedoIntent(event);
    if (dedicatedIntent !== null) {
      event.preventDefault();
      event.stopPropagation();
      if (dedicatedIntent === "undo") {
        dedicatedEditor.undo();
      } else {
        dedicatedEditor.redo();
      }
      return;
    }
  }
  const intent = getUnifiedUndoRedoIntent(event);
  if (intent === null)
    return;
  const activeEmbedId = getActiveEmbedIdForLeaf(leafId);
  if (activeEmbedId === null || isDedicatedLeaf) {
    return;
  }
  event.preventDefault();
  event.stopPropagation();
  if (intent === "undo") {
    executeUnifiedUndo(plugin, leafId, activeEmbedId);
  } else {
    executeUnifiedRedo(plugin, leafId, activeEmbedId);
  }
}
function executeUnifiedUndo(plugin, leafId, activeEmbedId) {
  syncObsidianOnlyBeforeKeyboard(leafId);
  if (isUndoStackEmpty(leafId)) {
    new import_obsidian44.Notice(EMPTY_UNDO_MESSAGE);
    return;
  }
  const entry = popUndo(leafId);
  if (!entry)
    return;
  notifyUndoExecuted(leafId, entry);
  setProgrammaticUndoInProgress(true, plugin);
  try {
    executeUndo(plugin, leafId, entry, activeEmbedId);
  } finally {
    const pluginRef = plugin;
    window.setTimeout(() => setProgrammaticUndoInProgress(false, pluginRef), 50);
  }
  pushRedo(leafId, entry);
  logToVault("Unified undo executed. Entry: " + entry.type);
  verbose(`[undo-redo] Undo executed. Undo stack after: ${formatStackForLog2(getUndoStackSnapshot(leafId))}`);
}
function executeUnifiedRedo(plugin, leafId, activeEmbedId) {
  syncObsidianOnlyBeforeKeyboard(leafId);
  if (isRedoStackEmpty(leafId))
    return;
  const entry = popRedo(leafId);
  if (!entry)
    return;
  notifyRedoExecuted(leafId, entry);
  setProgrammaticRedoInProgress(true, plugin);
  try {
    executeRedo(plugin, leafId, entry, activeEmbedId);
  } finally {
    const pluginRef = plugin;
    window.setTimeout(() => setProgrammaticRedoInProgress(false, pluginRef), 50);
  }
  pushUndo(leafId, entry);
  logToVault("Unified redo executed. Entry: " + entry.type);
  verbose(`[undo-redo] Redo executed. Undo stack after: ${formatStackForLog2(getUndoStackSnapshot(leafId))}`);
}
function executeUndo(plugin, leafId, entry, activeEmbedId) {
  if (entry.type === "obsidian") {
    const md = getMarkdownViewForLeaf(plugin, leafId);
    const editor = md?.editor;
    if (editor)
      editor.undo();
  } else if (entry.type === "embed-resize") {
    const applier = getResizeApplier(entry.embedId);
    if (applier)
      applier(entry.fromWidth, entry.fromAspectRatio);
  } else {
    const tldrawEditor = getEditor(entry.embedId ?? activeEmbedId);
    if (tldrawEditor)
      tldrawEditor.undo();
  }
}
function executeRedo(plugin, leafId, entry, activeEmbedId) {
  if (entry.type === "obsidian") {
    const md = getMarkdownViewForLeaf(plugin, leafId);
    const editor = md?.editor;
    if (editor)
      editor.redo();
  } else if (entry.type === "embed-resize") {
    const applier = getResizeApplier(entry.embedId);
    if (applier)
      applier(entry.toWidth, entry.toAspectRatio);
  } else {
    const tldrawEditor = getEditor(entry.embedId ?? activeEmbedId);
    if (tldrawEditor)
      tldrawEditor.redo();
  }
}
function registerUnifiedUndoRedo(plugin) {
  plugin.registerDomEvent(activeDocument, "keydown", (event) => {
    handleKeydown(plugin, event);
  }, { capture: true });
}

// src/logic/undo-redo/unified-commands.ts
var import_obsidian45 = require("obsidian");
var COMMAND_UNIFIED_UNDO_ID = "unified-undo";
var COMMAND_UNIFIED_REDO_ID = "unified-redo";
function createSyntheticUndoRedoKeyboardEvent(shiftKey) {
  const isMacLikePlatform = import_obsidian45.Platform.isMacOS || import_obsidian45.Platform.isIosApp;
  return new KeyboardEvent("keydown", {
    key: "z",
    code: "KeyZ",
    metaKey: isMacLikePlatform,
    ctrlKey: !isMacLikePlatform,
    shiftKey,
    bubbles: true,
    cancelable: true
  });
}
function dispatchSyntheticUndoRedoKeydown(shiftKey) {
  return activeDocument.dispatchEvent(createSyntheticUndoRedoKeyboardEvent(shiftKey));
}
function executeOrDispatchUnifiedUndoRedo(plugin, shiftKey) {
  const wasHandledByUnifiedKeydownHandler = dispatchSyntheticUndoRedoKeydown(shiftKey) === false;
  if (wasHandledByUnifiedKeydownHandler)
    return;
  const editor = plugin.app.workspace.getActiveViewOfType(import_obsidian45.MarkdownView)?.editor;
  if (!editor)
    return;
  if (shiftKey)
    editor.redo();
  else
    editor.undo();
}
function dispatchSyntheticUndoKeydown(plugin) {
  executeOrDispatchUnifiedUndoRedo(plugin, false);
}
function dispatchSyntheticRedoKeydown(plugin) {
  executeOrDispatchUnifiedUndoRedo(plugin, true);
}
function registerUnifiedUndoRedoCommands(plugin) {
  plugin.addCommand({
    id: COMMAND_UNIFIED_UNDO_ID,
    name: "Unified undo",
    callback: () => dispatchSyntheticUndoKeydown(plugin)
  });
  plugin.addCommand({
    id: COMMAND_UNIFIED_REDO_ID,
    name: "Unified redo",
    callback: () => dispatchSyntheticRedoKeydown(plugin)
  });
}

// src/graphics/icons/write_default.svg
var write_default_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n    >\n    <g class="frame-children">\n        <path d="M3.337,7.285C3.292,4.586,4.792,2.536,6.791,2.536C7.644,2.536,8.562,2.835,9.244,3.671C9.904,4.480,10.246,5.674,10.246,7.270C10.246,8.787,9.619,10.449,8.510,12.222C8.137,12.819,7.704,13.438,7.211,14.077C7.551,13.992,7.924,14.111,8.147,14.408C8.613,15.030,9.004,15.484,9.343,15.800C9.685,16.120,9.926,16.252,10.087,16.299C10.265,16.352,10.567,16.372,11.245,15.624C11.908,14.893,12.190,14.351,12.413,13.805C12.472,13.661,12.532,13.500,12.597,13.326C12.772,12.856,12.984,12.286,13.316,11.665C13.500,11.320,13.886,11.135,14.269,11.206C14.653,11.277,14.946,11.588,14.995,11.976C15.208,13.685,15.534,14.917,15.948,15.527C16.138,15.806,16.262,15.834,16.302,15.838C16.361,15.846,16.577,15.840,17.005,15.513C17.660,15.014,18.317,14.799,18.988,14.918C19.564,15.020,20.015,15.359,20.287,15.563C20.296,15.570,20.305,15.577,20.314,15.584C20.653,15.838,20.786,15.925,20.908,15.953C20.909,15.953,20.910,15.954,20.911,15.954C20.946,15.962,21.081,15.995,21.416,15.751C21.816,15.460,22.376,15.548,22.667,15.948C22.958,16.348,22.870,16.908,22.470,17.199C21.817,17.674,21.161,17.850,20.505,17.698C19.980,17.577,19.553,17.254,19.294,17.058C19.275,17.043,19.257,17.029,19.239,17.016C18.918,16.775,18.786,16.701,18.675,16.681C18.637,16.674,18.474,16.645,18.092,16.937C17.480,17.404,16.799,17.703,16.085,17.616C15.351,17.527,14.825,17.061,14.466,16.533C14.197,16.136,13.978,15.641,13.800,15.082C13.532,15.612,13.165,16.173,12.572,16.826C11.768,17.713,10.791,18.374,9.581,18.017C9.046,17.860,8.566,17.525,8.121,17.110C7.671,16.690,7.208,16.141,6.715,15.483C6.589,15.315,6.531,15.118,6.536,14.924C5.692,15.945,4.708,17.016,3.587,18.138C3.237,18.487,2.670,18.487,2.320,18.138C1.970,17.788,1.970,17.221,2.320,16.871C4.425,14.766,5.974,12.900,6.991,11.273C8.015,9.635,8.454,8.311,8.454,7.270C8.454,5.896,8.156,5.170,7.856,4.803C7.579,4.463,7.218,4.327,6.791,4.327C6.232,4.327,5.091,5.054,5.128,7.255C5.136,7.749,4.742,8.157,4.248,8.165C3.753,8.173,3.345,7.779,3.337,7.285ZZ"/>\n        <path d="M4.218,6.374C4.712,6.366,5.120,6.760,5.128,7.255C5.147,8.373,5.612,9.795,6.256,11.172C6.890,12.532,7.648,13.742,8.147,14.408C8.444,14.804,8.364,15.366,7.968,15.662C7.572,15.959,7.011,15.879,6.714,15.483C6.137,14.713,5.317,13.395,4.633,11.930C3.957,10.484,3.362,8.786,3.337,7.285C3.329,6.790,3.723,6.383,4.218,6.374ZZ"/>\n        <path d="M3.837,20.400C3.837,19.906,4.238,19.505,4.732,19.505L21.299,19.505C21.794,19.505,22.194,19.906,22.194,20.400C22.194,20.895,21.794,21.296,21.299,21.296L4.732,21.296C4.238,21.296,3.837,20.895,3.837,20.400ZZ"/>\n        <ellipse cx="14.496" cy="8.705" rx="1.107" ry="1.107" transform="matrix(0.897379, -0.441262, 0.441262, 0.897379, -2.353381, 7.289870)" />\n    </g>\n</svg>';

// src/graphics/icons/write_existing.svg
var write_existing_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n>\n    <g class="frame-children">\n        <path d="M7.522,11.373C7.941,11.111,8.494,11.239,8.756,11.658C8.952,11.972,9.202,12.364,9.312,12.511C9.609,12.906,9.528,13.468,9.133,13.764C8.737,14.061,8.176,13.981,7.879,13.585C7.713,13.363,7.417,12.896,7.237,12.607C6.975,12.188,7.103,11.635,7.522,11.373ZZ"/>\n        <path d="M13.686,10.258C14.122,10.491,14.287,11.034,14.054,11.470C13.872,11.811,13.779,12.062,13.671,12.353C13.618,12.496,13.561,12.648,13.489,12.825C13.275,13.349,12.988,13.885,12.391,14.544C11.810,15.185,11.024,15.749,10.023,15.454C9.593,15.328,9.221,15.063,8.894,14.758C8.563,14.449,8.228,14.051,7.879,13.585C7.582,13.189,7.663,12.628,8.058,12.331C8.454,12.035,9.015,12.115,9.312,12.511C9.634,12.939,9.896,13.243,10.116,13.449C10.340,13.658,10.473,13.720,10.529,13.736C10.530,13.737,10.531,13.737,10.532,13.737C10.553,13.743,10.564,13.747,10.614,13.724C10.696,13.686,10.842,13.586,11.064,13.341C11.503,12.856,11.685,12.505,11.831,12.148C11.867,12.059,11.906,11.954,11.950,11.838C12.073,11.507,12.232,11.079,12.474,10.626C12.707,10.190,13.250,10.025,13.686,10.258ZZ"/>\n        <path d="M13.153,10.160C13.644,10.098,14.091,10.446,14.153,10.937C14.302,12.134,14.526,12.936,14.775,13.303C14.807,13.350,14.832,13.379,14.849,13.396C14.893,13.381,14.984,13.341,15.129,13.231C15.673,12.815,16.258,12.673,16.840,12.838C17.285,12.965,17.641,13.260,17.831,13.418C17.845,13.429,17.858,13.440,17.870,13.450C17.938,13.506,17.990,13.547,18.029,13.576C18.040,13.564,18.052,13.550,18.066,13.535C18.387,13.159,18.953,13.116,19.328,13.437C19.704,13.759,19.747,14.325,19.425,14.700C19.021,15.173,18.484,15.519,17.819,15.412C17.335,15.335,16.950,15.015,16.768,14.863C16.755,14.852,16.743,14.842,16.733,14.834C16.495,14.638,16.412,14.583,16.363,14.565C16.343,14.572,16.294,14.594,16.215,14.655C15.760,15.002,15.214,15.256,14.616,15.183C13.998,15.108,13.569,14.716,13.294,14.309C12.777,13.549,12.524,12.349,12.375,11.159C12.314,10.668,12.662,10.221,13.153,10.160ZZM17.933,13.665C17.933,13.665,17.935,13.663,17.933,13.665ZC17.935,13.664,17.933,13.665,17.933,13.665ZZM14.876,13.419C14.876,13.419,14.874,13.418,14.876,13.419ZC14.874,13.417,14.876,13.418,14.876,13.419ZZ"/>\n        <path d="M5.463,7.694C5.430,5.731,6.534,4.099,8.148,4.099C8.809,4.099,9.534,4.332,10.072,4.992C10.588,5.624,10.833,6.530,10.833,7.679C10.833,8.812,10.366,10.025,9.578,11.286C8.784,12.557,7.615,13.953,6.097,15.471C5.747,15.820,5.180,15.820,4.830,15.471C4.481,15.121,4.481,14.554,4.830,14.204C5.624,13.411,6.300,12.670,6.865,11.979C6.203,10.773,5.487,9.116,5.463,7.694ZZM8.047,10.357C8.051,10.350,8.055,10.343,8.047,10.357ZC8.763,9.211,9.042,8.336,9.042,7.679C9.042,6.751,8.840,6.315,8.684,6.124C8.551,5.961,8.382,5.890,8.148,5.890C7.973,5.890,7.229,6.200,7.254,7.664C7.267,8.428,7.601,9.416,8.047,10.357ZZ"/>\n        <path d="M15.105,16.737C15.444,17.098,15.426,17.664,15.066,18.003C13.407,19.565,10.819,19.565,9.159,18.003C8.799,17.664,8.782,17.098,9.121,16.737C9.460,16.377,10.027,16.360,10.387,16.699C11.356,17.612,12.869,17.612,13.839,16.699C14.199,16.360,14.766,16.377,15.105,16.737ZZ"/>\n        <ellipse cx="13.695" cy="8.395" rx=".965" ry=".965" transform="matrix(0.897379, -0.441262, 0.441262, 0.897379, -2.298862, 6.904515)" />\n    </g>\n</svg>';

// src/graphics/icons/write_paste.svg
var write_paste_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n>\n    <g class="frame-children">\n        <path d="M15.954,3.315C15.954,2.821,16.355,2.420,16.850,2.420C19.968,2.420,22.495,4.947,22.495,8.065C22.495,8.559,22.094,8.960,21.599,8.960C21.105,8.960,20.704,8.559,20.704,8.065C20.704,5.936,18.978,4.211,16.850,4.211C16.355,4.211,15.954,3.810,15.954,3.315ZZ"/>\n        <path d="M8.246,19.763C8.246,20.257,7.845,20.658,7.350,20.658C4.232,20.658,1.705,18.131,1.705,15.013C1.705,14.518,2.106,14.117,2.600,14.117C3.095,14.117,3.496,14.518,3.496,15.013C3.496,17.142,5.221,18.867,7.350,18.867C7.845,18.867,8.246,19.268,8.246,19.763ZZ"/>\n        <path d="M21.599,14.117C22.094,14.117,22.495,14.518,22.495,15.013C22.495,18.131,19.968,20.658,16.850,20.658C16.355,20.658,15.954,20.257,15.954,19.763C15.954,19.268,16.355,18.867,16.850,18.867C18.978,18.867,20.704,17.142,20.704,15.013C20.704,14.518,21.105,14.117,21.599,14.117ZZ"/>\n        <path d="M2.610,8.960C2.115,8.960,1.714,8.559,1.714,8.065C1.714,4.947,4.242,2.420,7.359,2.420C7.854,2.420,8.255,2.821,8.255,3.315C8.255,3.810,7.854,4.211,7.359,4.211C5.231,4.211,3.505,5.936,3.505,8.065C3.505,8.559,3.104,8.960,2.610,8.960ZZ"/>\n        <ellipse cx="13.625" cy="9.567" rx=".965" ry=".965" transform="matrix(0.897379, -0.441262, 0.441262, 0.897379, -2.823144, 6.993809)"/>\n        <path d="M7.522,12.684C7.941,12.421,8.494,12.549,8.756,12.969C8.952,13.282,9.202,13.674,9.312,13.821C9.609,14.216,9.528,14.778,9.133,15.074C8.737,15.371,8.176,15.291,7.879,14.895C7.713,14.674,7.417,14.206,7.237,13.917C6.975,13.498,7.103,12.946,7.522,12.684ZZ"/>\n        <path d="M13.686,11.568C14.122,11.801,14.287,12.344,14.054,12.780C13.872,13.121,13.779,13.373,13.671,13.663C13.618,13.806,13.561,13.958,13.489,14.135C13.275,14.660,12.988,15.195,12.391,15.854C11.810,16.495,11.024,17.059,10.023,16.764C9.593,16.638,9.221,16.373,8.894,16.068C8.563,15.759,8.228,15.361,7.879,14.895C7.582,14.500,7.663,13.938,8.058,13.641C8.454,13.345,9.015,13.425,9.312,13.821C9.634,14.250,9.896,14.553,10.116,14.759C10.340,14.968,10.473,15.030,10.529,15.046C10.530,15.047,10.531,15.047,10.532,15.047C10.553,15.053,10.564,15.057,10.614,15.034C10.696,14.996,10.842,14.896,11.064,14.651C11.503,14.166,11.685,13.815,11.831,13.458C11.867,13.369,11.906,13.264,11.950,13.148C12.073,12.817,12.232,12.389,12.474,11.936C12.707,11.500,13.250,11.335,13.686,11.568ZZ"/>\n        <path d="M13.153,11.470C13.644,11.408,14.091,11.757,14.153,12.247C14.302,13.444,14.526,14.246,14.775,14.613C14.807,14.660,14.832,14.689,14.849,14.706C14.893,14.691,14.984,14.651,15.129,14.541C15.673,14.126,16.258,13.983,16.840,14.149C17.285,14.275,17.641,14.570,17.831,14.728C17.845,14.740,17.858,14.750,17.870,14.760C17.938,14.816,17.990,14.857,18.029,14.886C18.040,14.874,18.052,14.860,18.066,14.845C18.387,14.469,18.953,14.426,19.328,14.748C19.704,15.069,19.747,15.635,19.425,16.010C19.021,16.483,18.484,16.829,17.819,16.722C17.335,16.645,16.950,16.325,16.768,16.173C16.755,16.162,16.743,16.152,16.733,16.144C16.495,15.949,16.412,15.893,16.363,15.875C16.343,15.883,16.294,15.904,16.215,15.965C15.760,16.312,15.214,16.566,14.616,16.493C13.998,16.418,13.569,16.026,13.294,15.619C12.777,14.859,12.524,13.659,12.375,12.469C12.314,11.978,12.662,11.531,13.153,11.470ZZM17.933,14.975C17.933,14.975,17.935,14.973,17.933,14.975ZC17.935,14.974,17.933,14.975,17.933,14.975ZZM14.876,14.729C14.876,14.729,14.874,14.728,14.876,14.729ZC14.874,14.727,14.876,14.728,14.876,14.729ZZ"/>\n        <path d="M5.463,9.004C5.430,7.041,6.534,5.409,8.148,5.409C8.809,5.409,9.534,5.643,10.072,6.302C10.588,6.934,10.833,7.840,10.833,8.989C10.833,10.122,10.366,11.335,9.578,12.596C8.784,13.867,7.615,15.263,6.097,16.781C5.747,17.130,5.180,17.130,4.830,16.781C4.481,16.431,4.481,15.864,4.830,15.514C5.624,14.721,6.300,13.980,6.865,13.290C6.203,12.083,5.487,10.426,5.463,9.004ZZM8.047,11.667C8.051,11.660,8.055,11.653,8.047,11.667ZC8.763,10.521,9.042,9.646,9.042,8.989C9.042,8.062,8.840,7.625,8.684,7.434C8.551,7.271,8.382,7.200,8.148,7.200C7.973,7.200,7.229,7.510,7.254,8.974C7.267,9.738,7.601,10.726,8.047,11.667ZZ"/>\n    </g>\n</svg>';

// src/graphics/icons/draw_default.svg
var draw_default_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n>\n    <g>\n        <path d="M19.771,17.456C20.266,17.456,20.667,17.857,20.667,18.351C20.667,20.003,19.328,21.341,17.677,21.341L11.960,21.341C11.465,21.341,11.064,20.940,11.064,20.446C11.064,19.951,11.465,19.550,11.960,19.550L17.677,19.550C18.339,19.550,18.876,19.013,18.876,18.351C18.876,17.857,19.277,17.456,19.771,17.456ZZ"/>\n        <path d="M11.145,6.293C11.440,6.244,12.157,6.340,13.538,6.975C14.954,7.626,16.545,8.849,17.366,9.799C17.689,10.173,18.255,10.214,18.629,9.890C19.003,9.567,19.044,9.001,18.721,8.627C17.727,7.479,15.927,6.103,14.286,5.348C12.875,4.699,11.724,4.382,10.855,4.525C10.375,4.604,9.939,4.831,9.646,5.246C9.370,5.640,9.299,6.094,9.310,6.491C9.331,7.262,9.668,8.142,10.080,8.940C10.506,9.765,11.071,10.613,11.661,11.351C12.233,12.066,12.671,12.772,12.932,13.365C13.062,13.661,13.139,13.908,13.173,14.100C13.187,14.175,13.192,14.236,13.194,14.283C13.146,14.283,13.079,14.279,12.989,14.265C12.486,14.188,11.622,13.857,10.298,13.062C8.860,12.199,7.789,11.724,7.005,11.643C6.593,11.600,6.115,11.652,5.729,11.977C5.341,12.303,5.232,12.749,5.212,13.082C5.174,13.699,5.412,14.417,5.597,14.924C5.675,15.136,5.757,15.346,5.830,15.532C5.852,15.587,5.873,15.640,5.892,15.691C5.984,15.927,6.042,16.086,6.070,16.187C6.082,16.231,6.091,16.271,6.097,16.306C6.017,16.286,5.912,16.252,5.776,16.194C5.408,16.038,4.901,15.742,4.238,15.238C3.844,14.939,3.282,15.015,2.983,15.409C2.684,15.803,2.760,16.365,3.154,16.664C3.886,17.220,4.524,17.609,5.077,17.843C5.612,18.070,6.167,18.196,6.681,18.081C7.271,17.950,7.659,17.538,7.816,17.035C7.956,16.588,7.906,16.113,7.798,15.715C7.741,15.509,7.648,15.263,7.561,15.041C7.538,14.982,7.515,14.924,7.492,14.865C7.421,14.683,7.349,14.499,7.279,14.309C7.150,13.956,7.066,13.671,7.026,13.463C7.439,13.566,8.174,13.876,9.376,14.597C10.753,15.424,11.860,15.904,12.716,16.036C13.149,16.102,13.602,16.094,14.009,15.916C14.452,15.722,14.748,15.369,14.887,14.947C15.015,14.558,15.001,14.149,14.937,13.786C14.871,13.415,14.740,13.028,14.571,12.643C14.233,11.875,13.703,11.036,13.060,10.232C12.534,9.574,12.036,8.824,11.672,8.118C11.293,7.385,11.110,6.800,11.101,6.442C11.099,6.372,11.104,6.327,11.145,6.293ZC11.118,6.298,11.131,6.295,11.145,6.293ZZM11.077,6.310C11.077,6.310,11.078,6.310,11.077,6.310ZC11.077,6.310,11.076,6.310,11.077,6.310ZZM6.738,13.422C6.738,13.422,6.739,13.422,6.738,13.422ZZM7.001,13.171C7.002,13.170,7.002,13.170,7.001,13.171ZZ"/>\n    </g>\n</svg>';

// src/graphics/icons/draw_existing.svg
var draw_existing_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n>\n    <g class="frame-children">\n        <path d="M14.808,16.098C15.147,16.458,15.129,17.024,14.769,17.363C13.110,18.925,10.521,18.925,8.862,17.363C8.502,17.024,8.485,16.458,8.824,16.098C9.163,15.737,9.730,15.720,10.090,16.059C11.059,16.972,12.572,16.972,13.542,16.059C13.902,15.720,14.469,15.737,14.808,16.098ZZ"/>\n        <path d="M12.576,6.218C12.819,6.242,13.279,6.354,14.047,6.707C15.069,7.177,16.224,8.066,16.811,8.745C17.135,9.119,17.700,9.160,18.074,8.837C18.448,8.513,18.489,7.948,18.166,7.573C17.406,6.695,16.043,5.654,14.795,5.080C13.744,4.596,12.833,4.333,12.114,4.451C11.709,4.517,11.324,4.713,11.065,5.081C10.821,5.428,10.765,5.820,10.773,6.144C10.791,6.770,11.060,7.461,11.371,8.062C11.695,8.690,12.123,9.333,12.570,9.891C12.985,10.410,13.299,10.917,13.482,11.335C13.534,11.453,13.573,11.557,13.600,11.647C13.248,11.555,12.684,11.316,11.856,10.820C10.788,10.178,9.954,9.800,9.316,9.734C8.977,9.699,8.549,9.738,8.196,10.035C7.842,10.334,7.748,10.737,7.731,11.018C7.699,11.531,7.895,12.108,8.030,12.479C8.089,12.639,8.152,12.799,8.206,12.937C8.217,12.966,8.228,12.993,8.238,13.019C8.012,12.898,7.727,12.716,7.377,12.450C6.983,12.150,6.421,12.227,6.122,12.621C5.823,13.014,5.899,13.576,6.293,13.876C6.846,14.295,7.336,14.596,7.770,14.780C8.187,14.956,8.652,15.070,9.102,14.970C9.627,14.853,9.975,14.482,10.115,14.036C10.237,13.647,10.190,13.246,10.103,12.927C10.058,12.760,9.984,12.567,9.920,12.403C9.903,12.358,9.885,12.314,9.868,12.270C9.815,12.135,9.763,12.002,9.713,11.864C9.689,11.799,9.667,11.737,9.647,11.677C9.667,11.685,9.689,11.694,9.711,11.704C10.020,11.838,10.421,12.047,10.934,12.355C11.964,12.973,12.817,13.349,13.498,13.453C13.843,13.506,14.228,13.504,14.586,13.348C14.978,13.176,15.241,12.861,15.364,12.489C15.476,12.151,15.461,11.805,15.409,11.515C15.356,11.216,15.252,10.910,15.122,10.614C14.861,10.020,14.455,9.380,13.968,8.772C13.586,8.293,13.225,7.750,12.962,7.240C12.732,6.795,12.613,6.446,12.576,6.218ZZM9.107,11.514C9.107,11.514,9.108,11.514,9.107,11.514ZC9.108,11.514,9.107,11.514,9.107,11.514ZZ"/>\n    </g>\n</svg>';

// src/graphics/icons/draw_paste.svg
var draw_paste_default = '<svg\n    viewBox="2 2 21 21"\n    xmlns="http://www.w3.org/2000/svg"\n    fill="currentcolor" \n>\n    <g class="frame-children">\n        <path d="M16.298,3.315C16.298,2.821,16.699,2.420,17.194,2.420C20.312,2.420,22.839,4.947,22.839,8.065C22.839,8.559,22.438,8.960,21.943,8.960C21.449,8.960,21.048,8.559,21.048,8.065C21.048,5.936,19.322,4.211,17.194,4.211C16.699,4.211,16.298,3.810,16.298,3.315ZZ" />\n        <path d="M8.590,19.763C8.590,20.257,8.189,20.658,7.694,20.658C4.576,20.658,2.049,18.131,2.049,15.013C2.049,14.518,2.450,14.117,2.944,14.117C3.439,14.117,3.840,14.518,3.840,15.013C3.840,17.142,5.565,18.867,7.694,18.867C8.189,18.867,8.590,19.268,8.590,19.763ZZ" />\n        <path d="M21.943,14.117C22.438,14.117,22.839,14.518,22.839,15.013C22.839,18.131,20.312,20.658,17.194,20.658C16.699,20.658,16.298,20.257,16.298,19.763C16.298,19.268,16.699,18.867,17.194,18.867C19.322,18.867,21.048,17.142,21.048,15.013C21.048,14.518,21.449,14.117,21.943,14.117ZZ" />\n        <path d="M2.954,8.960C2.459,8.960,2.058,8.559,2.058,8.065C2.058,4.947,4.586,2.420,7.703,2.420C8.198,2.420,8.599,2.821,8.599,3.315C8.599,3.810,8.198,4.211,7.703,4.211C5.575,4.211,3.849,5.936,3.849,8.065C3.849,8.559,3.448,8.960,2.954,8.960ZZ" />\n        <path d="M13.216,8.168C13.459,8.192,13.919,8.304,14.686,8.657C15.709,9.127,16.863,10.016,17.451,10.695C17.774,11.069,18.340,11.110,18.714,10.787C19.088,10.463,19.129,9.898,18.806,9.523C18.046,8.645,16.683,7.604,15.435,7.030C14.383,6.546,13.472,6.283,12.753,6.401C12.349,6.468,11.964,6.663,11.705,7.031C11.461,7.378,11.404,7.770,11.413,8.095C11.430,8.720,11.700,9.411,12.011,10.013C12.335,10.640,12.763,11.283,13.209,11.841C13.625,12.360,13.938,12.868,14.122,13.285C14.174,13.403,14.212,13.507,14.240,13.597C13.887,13.505,13.323,13.266,12.496,12.770C11.428,12.128,10.593,11.750,9.956,11.684C9.617,11.649,9.189,11.688,8.836,11.985C8.481,12.284,8.388,12.688,8.370,12.968C8.339,13.481,8.534,14.058,8.670,14.429C8.728,14.589,8.791,14.749,8.846,14.888C8.857,14.916,8.867,14.943,8.877,14.969C8.652,14.848,8.367,14.666,8.017,14.400C7.623,14.100,7.061,14.177,6.762,14.571C6.462,14.965,6.539,15.526,6.933,15.826C7.485,16.245,7.976,16.546,8.410,16.730C8.826,16.906,9.292,17.020,9.742,16.920C10.267,16.803,10.615,16.432,10.754,15.986C10.876,15.597,10.830,15.196,10.743,14.877C10.697,14.710,10.623,14.517,10.560,14.353C10.542,14.309,10.525,14.264,10.508,14.220C10.455,14.085,10.403,13.953,10.352,13.814C10.328,13.749,10.306,13.687,10.286,13.627C10.307,13.635,10.328,13.644,10.350,13.654C10.660,13.788,11.061,13.997,11.574,14.305C12.603,14.923,13.457,15.299,14.138,15.403C14.483,15.456,14.868,15.454,15.225,15.298C15.618,15.126,15.881,14.811,16.004,14.440C16.115,14.101,16.100,13.755,16.049,13.465C15.995,13.166,15.892,12.860,15.761,12.564C15.500,11.970,15.095,11.331,14.608,10.722C14.225,10.243,13.865,9.700,13.602,9.191C13.372,8.745,13.253,8.396,13.216,8.168ZZM9.747,13.464C9.747,13.464,9.747,13.464,9.747,13.464ZC9.747,13.464,9.747,13.464,9.747,13.464ZZ" />\n    </g>\n</svg>';

// src/connections/boox/boox-connection.ts
var import_obsidian46 = require("obsidian");
init_universal_dev_logging();
init_log_to_vault();
var INK_LOG_PREFIX = "[Ink]";
var INK_BRIDGE_WEBSOCKET_PORT = 8080;
var INK_BRIDGE_PROTOCOL_VERSION = 1;
var BOOX_BRIDGE_WEBSOCKET_URL = `ws://127.0.0.1:${INK_BRIDGE_WEBSOCKET_PORT}/ws`;
var MSG_BOOX_COMPANION_NOT_FOUND = "Attempted Boox Companion app connection but didn't find one.";
var PROBE_TIMEOUT_MS = 2e3;
function agentBridgeLog(hypothesisId, location, message, data) {
  console.debug("[InkBridgeDebug]", message, data);
  inkDebugLog({ hypothesisId, location, message, data });
}
function webSocketReadyStateName(ws) {
  if (!ws)
    return "none";
  if (ws.readyState === WebSocket.CONNECTING)
    return "CONNECTING";
  if (ws.readyState === WebSocket.OPEN)
    return "OPEN";
  if (ws.readyState === WebSocket.CLOSING)
    return "CLOSING";
  if (ws.readyState === WebSocket.CLOSED)
    return "CLOSED";
  return `unknown:${ws.readyState}`;
}
function isValidInkBridgePongData(data) {
  if (typeof data !== "object" || data === null)
    return false;
  const record = data;
  return record.bridgeId === "eink-bridge" && record.protocolVersion === INK_BRIDGE_PROTOCOL_VERSION;
}
var BooxConnection = class {
  constructor(getSettings) {
    this.getSettings = getSettings;
    this.ws = null;
    this.disposed = false;
    this.intentionalClose = false;
    this.currentUrl = null;
    this.inFlightConnect = null;
    this.drawingSessions = [];
    this.lastCloseDrawingAreaAt = 0;
  }
  onSettingsChanged() {
    this.intentionalClose = true;
    this.teardownWebSocket();
    this.intentionalClose = false;
    this.currentUrl = null;
    this.inFlightConnect = null;
  }
  registerDrawingSession(entry) {
    this.drawingSessions.push(entry);
    logToVault("Boox drawing session registered. Active: " + this.drawingSessions.length);
    agentBridgeLog("CONN", "boox-connection.ts:registerDrawingSession", "Drawing session registered", {
      activeSessions: this.drawingSessions.length,
      disposed: this.disposed,
      booxConnectionEnabled: this.getSettings().booxConnectionEnabled,
      wsState: webSocketReadyStateName(this.ws),
      currentUrl: this.currentUrl,
      hasInFlightConnect: !!this.inFlightConnect
    });
    void this.ensureConnected().then(() => {
      if (this.ws?.readyState === WebSocket.OPEN && this.drawingSessions.includes(entry)) {
        try {
          entry.onSocketOpen();
        } catch (error2) {
          verbose(["BooxConnection: late onSocketOpen error", error2]);
        }
      }
    }).catch((err) => {
      agentBridgeLog("CONN", "boox-connection.ts:registerDrawingSession", "ensureConnected rejected after register", {
        error: String(err),
        activeSessions: this.drawingSessions.length
      });
    });
    const unregister2 = () => {
      const index3 = this.drawingSessions.indexOf(entry);
      if (index3 >= 0)
        this.drawingSessions.splice(index3, 1);
      logToVault("Boox drawing session unregistered. Active: " + this.drawingSessions.length);
      agentBridgeLog("CONN", "boox-connection.ts:unregisterDrawingSession", "Drawing session unregistered", {
        activeSessions: this.drawingSessions.length,
        wsState: webSocketReadyStateName(this.ws),
        currentUrl: this.currentUrl
      });
      if (this.drawingSessions.length === 0) {
        this.sendCloseDrawingArea();
      } else {
        const remaining = this.drawingSessions[this.drawingSessions.length - 1];
        remaining.onReactivate?.();
      }
    };
    const activate = () => {
      const idx = this.drawingSessions.indexOf(entry);
      if (idx >= 0 && idx < this.drawingSessions.length - 1) {
        this.drawingSessions.splice(idx, 1);
        this.drawingSessions.push(entry);
      }
    };
    return { unregister: unregister2, activate };
  }
  async ensureConnected() {
    const { booxConnectionEnabled } = this.getSettings();
    agentBridgeLog("CONN", "boox-connection.ts:ensureConnected", "ensureConnected called", {
      disposed: this.disposed,
      booxConnectionEnabled,
      wsState: webSocketReadyStateName(this.ws),
      hasInFlightConnect: !!this.inFlightConnect,
      activeSessions: this.drawingSessions.length
    });
    if (this.disposed) {
      throw new Error("BooxConnection disposed");
    }
    if (!booxConnectionEnabled) {
      throw new Error("Boox companion app disabled");
    }
    if (this.ws?.readyState === WebSocket.OPEN) {
      agentBridgeLog("CONN", "boox-connection.ts:ensureConnected", "Already open, returning", {});
      return;
    }
    if (this.inFlightConnect) {
      agentBridgeLog("CONN", "boox-connection.ts:ensureConnected", "In-flight connect exists, returning existing promise", {});
      return this.inFlightConnect;
    }
    if (this.ws) {
      this.intentionalClose = true;
      this.teardownWebSocket();
      this.intentionalClose = false;
    }
    this.inFlightConnect = this.connectOnce().finally(() => {
      this.inFlightConnect = null;
    });
    return this.inFlightConnect;
  }
  connectOnce() {
    return new Promise((resolve, reject) => {
      void this.probePort().then(() => resolve()).catch((err) => reject(err ?? new Error("WebSocket connection failed")));
    });
  }
  async probePort() {
    const url = BOOX_BRIDGE_WEBSOCKET_URL;
    agentBridgeLog("CONN", "boox-connection.ts:probePort", "Starting probe", {
      url,
      activeSessions: this.drawingSessions.length,
      disposed: this.disposed
    });
    const result = await this.probeSinglePort(url);
    if (result.kind === "success") {
      agentBridgeLog("CONN", "boox-connection.ts:probePort", "Probe SUCCESS", {
        url: result.url,
        activeSessions: this.drawingSessions.length
      });
      if (this.drawingSessions.length === 0) {
        verbose("BooxConnection: handshake ok but no active drawing; closing");
        this.intentionalClose = true;
        try {
          result.socket.close();
        } catch {
        }
        this.intentionalClose = false;
        if (this.ws === result.socket) {
          this.ws = null;
        }
        this.currentUrl = null;
        return;
      }
      verbose("BooxConnection: WebSocket open (handshake ok)");
      logToVault("Boox WebSocket open (handshake ok): " + result.url);
      this.attachProductionHandlers(result.socket, result.url);
      this.sendInitMessage();
      for (const session of this.drawingSessions) {
        try {
          session.onSocketOpen();
        } catch (error2) {
          verbose(["BooxConnection: onSocketOpen error", error2]);
        }
      }
      return;
    }
    agentBridgeLog("CONN", "boox-connection.ts:probePort", "Probe failed", {
      activeSessions: this.drawingSessions.length
    });
    console.debug(INK_LOG_PREFIX, MSG_BOOX_COMPANION_NOT_FOUND);
    logToVault("Boox companion not found on port " + INK_BRIDGE_WEBSOCKET_PORT);
    if (import_obsidian46.Platform.isMobileApp || import_obsidian46.Platform.isMobile) {
      console.debug(INK_LOG_PREFIX, "Boox tip: Start or restore eInk Bridge on this tablet so its foreground service and loopback WebSocket are up; Obsidian Ink only connects over ws://127.0.0.1.");
    }
    throw new Error("WebSocket connection failed");
  }
  attachProductionHandlers(socket, url) {
    this.currentUrl = url;
    this.ws = socket;
    socket.onmessage = (event) => {
      this.dispatchStrokeMessage(event);
    };
    socket.onerror = () => {
    };
    socket.onclose = () => {
      const wasThisSocket = this.ws === socket;
      if (wasThisSocket) {
        this.ws = null;
      }
    };
  }
  dispatchStrokeMessage(event) {
    let parsed;
    try {
      parsed = JSON.parse(String(event.data));
    } catch {
      verbose("BooxConnection: invalid JSON message");
      return;
    }
    if (typeof parsed !== "object" || parsed === null || !("data" in parsed)) {
      return;
    }
    const action = parsed.action;
    const rawTool = parsed.data?.tool ?? "(none)";
    logToVault(`dispatchStroke action:${action} tool:${rawTool}`);
    if (action === "stroke-start") {
      const last7 = this.drawingSessions[this.drawingSessions.length - 1];
      if (last7) {
        try {
          last7.onStrokeStart?.(parsed.data);
        } catch (error2) {
          verbose(["BooxConnection: onStrokeStart error", error2]);
        }
      }
      return;
    }
    if (action === "drawing-area-ready") {
      const last7 = this.drawingSessions[this.drawingSessions.length - 1];
      if (last7) {
        try {
          last7.onDrawingAreaReady?.(parsed.data);
        } catch (error2) {
          verbose(["BooxConnection: onDrawingAreaReady error", error2]);
        }
      }
      return;
    }
    if (action !== "new-stroke") {
      return;
    }
    const strokePayload = parsed.data;
    if (strokePayload && typeof strokePayload === "object" && strokePayload !== null) {
      const sp = strokePayload;
      const pts = Array.isArray(sp.points) ? sp.points : [];
      const firstPt = pts[0];
      const lastPt = pts.length > 0 ? pts[pts.length - 1] : void 0;
      agentBridgeLog("H-plugin-ws-new-stroke", "boox-connection.ts:dispatchStrokeMessage", "Received new-stroke before routing to session", {
        strokeId: sp.strokeId,
        tool: sp.tool,
        canvasWidth: sp.canvasWidth,
        canvasHeight: sp.canvasHeight,
        pointCount: pts.length,
        firstX: firstPt?.x,
        firstY: firstPt?.y,
        lastX: lastPt?.x,
        lastY: lastPt?.y,
        sessionCount: this.drawingSessions.length
      });
    }
    const lastSession = this.drawingSessions[this.drawingSessions.length - 1];
    if (lastSession) {
      try {
        lastSession.onStroke(parsed.data);
      } catch (error2) {
        verbose(["BooxConnection: onStroke error", error2]);
      }
    }
  }
  probeSinglePort(url) {
    const probeStart = Date.now();
    return new Promise((resolve) => {
      let settled = false;
      const settle = (result) => {
        if (settled)
          return;
        settled = true;
        window.clearTimeout(timeoutId);
        if (result.kind === "failed") {
          try {
            socket.close();
          } catch {
          }
        }
        resolve(result);
      };
      const timeoutId = window.setTimeout(() => {
        agentBridgeLog("PROBE", "boox-connection.ts:probeSinglePort", "Probe timeout", {
          url,
          elapsedMs: Date.now() - probeStart,
          readyState: webSocketReadyStateName(socket)
        });
        settle({ kind: "failed" });
      }, PROBE_TIMEOUT_MS);
      const socket = new WebSocket(url);
      socket.onopen = () => {
        agentBridgeLog("PROBE", "boox-connection.ts:probeSinglePort", "Socket opened", {
          url,
          elapsedMs: Date.now() - probeStart
        });
        if (settled || this.disposed || this.drawingSessions.length === 0) {
          settle({ kind: "failed" });
          return;
        }
        try {
          socket.send(JSON.stringify({
            action: "ink-bridge-ping",
            data: {
              protocolVersion: INK_BRIDGE_PROTOCOL_VERSION
            }
          }));
        } catch {
          settle({ kind: "failed" });
        }
      };
      socket.onmessage = (event) => {
        if (settled)
          return;
        let parsed;
        try {
          parsed = JSON.parse(String(event.data));
        } catch {
          return;
        }
        if (typeof parsed !== "object" || parsed === null)
          return;
        const action = parsed.action;
        const data = parsed.data;
        if (action !== "ink-bridge-pong" || !isValidInkBridgePongData(data)) {
          return;
        }
        agentBridgeLog("PROBE", "boox-connection.ts:probeSinglePort", "Handshake success", {
          url,
          elapsedMs: Date.now() - probeStart
        });
        if (this.disposed || this.drawingSessions.length === 0) {
          settle({ kind: "failed" });
          return;
        }
        settle({ kind: "success", socket, url });
      };
      socket.onerror = () => {
        agentBridgeLog("PROBE", "boox-connection.ts:probeSinglePort", "Socket error", {
          url,
          elapsedMs: Date.now() - probeStart,
          readyState: webSocketReadyStateName(socket)
        });
      };
      socket.onclose = () => {
        agentBridgeLog("PROBE", "boox-connection.ts:probeSinglePort", "Socket closed", {
          url,
          elapsedMs: Date.now() - probeStart
        });
        settle({ kind: "failed" });
      };
    });
  }
  sendInitMessage() {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      agentBridgeLog("A", "boox-connection.ts:sendInitMessage", "Dropped init send because socket is not open", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        currentUrl: this.currentUrl
      });
      return;
    }
    agentBridgeLog("A", "boox-connection.ts:sendInitMessage", "Sending init message", {
      readyState: webSocketReadyStateName(this.ws),
      sessionCount: this.drawingSessions.length,
      currentUrl: this.currentUrl
    });
    this.ws.send(JSON.stringify({
      action: "init",
      data: "Obsidian connected!"
    }));
  }
  sendNewDrawingArea(dimensions) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      agentBridgeLog("A", "boox-connection.ts:sendNewDrawingArea", "Dropped new-drawing-area because socket is not open", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        currentUrl: this.currentUrl,
        dimensions
      });
      return;
    }
    agentBridgeLog("A,B,C", "boox-connection.ts:sendNewDrawingArea", "Sending new-drawing-area", {
      readyState: webSocketReadyStateName(this.ws),
      sessionCount: this.drawingSessions.length,
      currentUrl: this.currentUrl,
      dimensions
    });
    this.ws.send(JSON.stringify({
      action: "new-drawing-area",
      data: {
        x: dimensions.x,
        y: dimensions.y,
        canvasWidth: dimensions.canvasWidth,
        canvasHeight: dimensions.canvasHeight,
        appWidth: dimensions.appWidth,
        appHeight: dimensions.appHeight,
        excludeRects: dimensions.excludeRects ?? []
      }
    }));
  }
  sendUpdateDrawingArea(dimensions) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      agentBridgeLog("A", "boox-connection.ts:sendUpdateDrawingArea", "Dropped update-drawing-area because socket is not open", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        currentUrl: this.currentUrl,
        dimensions
      });
      return;
    }
    agentBridgeLog("B,C", "boox-connection.ts:sendUpdateDrawingArea", "Sending update-drawing-area", {
      readyState: webSocketReadyStateName(this.ws),
      sessionCount: this.drawingSessions.length,
      currentUrl: this.currentUrl,
      dimensions
    });
    this.ws.send(JSON.stringify({
      action: "update-drawing-area",
      data: {
        x: dimensions.x,
        y: dimensions.y,
        canvasWidth: dimensions.canvasWidth,
        canvasHeight: dimensions.canvasHeight,
        appWidth: dimensions.appWidth,
        appHeight: dimensions.appHeight,
        immediate: dimensions.immediate ?? false,
        excludeRects: dimensions.excludeRects ?? []
      }
    }));
  }
  sendCloseDrawingArea() {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      agentBridgeLog("A,C", "boox-connection.ts:sendCloseDrawingArea", "Dropped close-drawing-area because socket is not open", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        currentUrl: this.currentUrl
      });
      return;
    }
    const now = Date.now();
    if (now - this.lastCloseDrawingAreaAt < 100) {
      agentBridgeLog("A,C", "boox-connection.ts:sendCloseDrawingArea", "Deduplicated close-drawing-area (sent within 100ms)", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        msAgo: now - this.lastCloseDrawingAreaAt
      });
      return;
    }
    this.lastCloseDrawingAreaAt = now;
    agentBridgeLog("A,C", "boox-connection.ts:sendCloseDrawingArea", "Sending close-drawing-area", {
      readyState: webSocketReadyStateName(this.ws),
      sessionCount: this.drawingSessions.length,
      currentUrl: this.currentUrl
    });
    this.ws.send(JSON.stringify({
      action: "close-drawing-area"
    }));
  }
  isConnected() {
    return this.ws?.readyState === WebSocket.OPEN;
  }
  getSessionCount() {
    return this.drawingSessions.length;
  }
  sendUpdateTool(tool, strokeSizeDevicePx) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      agentBridgeLog("A,E", "boox-connection.ts:sendUpdateTool", "Dropped update-tool because socket is not open", {
        readyState: webSocketReadyStateName(this.ws),
        sessionCount: this.drawingSessions.length,
        currentUrl: this.currentUrl,
        tool,
        strokeSizeDevicePx
      });
      return;
    }
    const data = { tool };
    if (strokeSizeDevicePx !== void 0)
      data.strokeSize = strokeSizeDevicePx;
    agentBridgeLog("A,E", "boox-connection.ts:sendUpdateTool", "Sending update-tool", {
      readyState: webSocketReadyStateName(this.ws),
      sessionCount: this.drawingSessions.length,
      currentUrl: this.currentUrl,
      tool,
      strokeSizeDevicePx
    });
    this.ws.send(JSON.stringify({
      action: "update-tool",
      data
    }));
  }
  sendStrokeRendered(strokeId) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
      return;
    this.ws.send(JSON.stringify({
      action: "stroke-rendered",
      data: { strokeId }
    }));
  }
  teardownWebSocket() {
    if (this.ws) {
      try {
        this.ws.close();
      } catch {
      }
      this.ws = null;
    }
  }
  dispose() {
    this.disposed = true;
    this.drawingSessions.length = 0;
    this.intentionalClose = true;
    this.teardownWebSocket();
    this.intentionalClose = false;
    this.currentUrl = null;
    this.inFlightConnect = null;
  }
};

// src/types/plugin-settings-migrations.ts
init_plugin_settings_0_5_0();
function migrateOutdatedSettings(raw) {
  let updatedSettings = raw;
  if (!raw.settingsVersion) {
    updatedSettings = migrate_0_4_0_to_0_5_0(raw);
  }
  const settings = updatedSettings;
  if (settings.dominantHand === void 0) {
    settings.dominantHand = DEFAULT_PLUGIN_SETTINGS_0_5_0.dominantHand;
  }
  if (settings.drawingGridEnabledByDefault === void 0) {
    settings.drawingGridEnabledByDefault = DEFAULT_PLUGIN_SETTINGS_0_5_0.drawingGridEnabledByDefault;
  }
  if (settings.settingsVersion === "0.6.0") {
    settings.settingsVersion = DEFAULT_PLUGIN_SETTINGS_0_5_0.settingsVersion;
  }
  const settingsWereMigrated = JSON.stringify(updatedSettings) !== JSON.stringify(raw);
  if (settingsWereMigrated) {
    console.debug("Ink: Migrated outdated plugin settings");
    console.debug("Old settings:", JSON.parse(JSON.stringify(raw)));
    console.debug("New settings:", JSON.parse(JSON.stringify(updatedSettings)));
  }
  return settings;
}
function migrate_0_4_0_to_0_5_0(oldSettings) {
  const newSettings = {
    ...DEFAULT_PLUGIN_SETTINGS_0_5_0,
    ...oldSettings,
    gettingStartedExpanded: DEFAULT_PLUGIN_SETTINGS_0_5_0.gettingStartedExpanded,
    writingBufferLines: DEFAULT_PLUGIN_SETTINGS_0_5_0.writingBufferLines,
    debugLoggingEnabled: DEFAULT_PLUGIN_SETTINGS_0_5_0.debugLoggingEnabled,
    dominantHand: DEFAULT_PLUGIN_SETTINGS_0_5_0.dominantHand,
    settingsVersion: DEFAULT_PLUGIN_SETTINGS_0_5_0.settingsVersion
  };
  return JSON.parse(JSON.stringify(newSettings));
}

// src/main.ts
init_log_to_vault();
init_dominant_hand_store();
init_device_settings();
var InkPlugin = class extends import_obsidian47.Plugin {
  constructor() {
    super(...arguments);
    this.inkViewSidebarState = null;
    this.FileConversionModal = FileConversionModal;
    this.findNotesContainingFileEmbed = findNotesContainingFileEmbed;
    this.executeFileConversion = executeFileConversion;
    this.RemoveEmbedModal = RemoveEmbedModal;
    this.removeAllEmbedsOfFileFromNote = removeAllEmbedsOfFileFromNote;
    this.openRemoveEmbedFlow = openRemoveEmbedFlow;
  }
  openMigrationModal(onPermanentMigrationFinished) {
    new MigrationModal(this, onPermanentMigrationFinished).open();
  }
  openTldrawSvgMigrationModal() {
    new TldrawSvgMigrationModal(this).open();
  }
  async onload() {
    await this.loadSettings();
    this.booxConnection = new BooxConnection(() => ({
      booxConnectionEnabled: getBooxConnectionEnabled()
    }));
    setGlobals({
      plugin: this
    });
    logToVault(`Plugin loaded. writing=${this.settings.writingEnabled}, drawing=${this.settings.drawingEnabled}, boox=${getBooxConnectionEnabled()}`);
    (0, import_obsidian47.addIcon)("write_default", write_default_default);
    (0, import_obsidian47.addIcon)("write_existing", write_existing_default);
    (0, import_obsidian47.addIcon)("write_paste", write_paste_default);
    (0, import_obsidian47.addIcon)("draw_default", draw_default_default);
    (0, import_obsidian47.addIcon)("draw_existing", draw_existing_default);
    (0, import_obsidian47.addIcon)("draw_paste", draw_paste_default);
    (0, import_obsidian47.addIcon)("bluesky", bluesky_default);
    (0, import_obsidian47.addIcon)("mastodon", mastodon_default);
    (0, import_obsidian47.addIcon)("threads", threads_default);
    (0, import_obsidian47.addIcon)("twitter", twitter_default);
    const inkProcessEnv = window.process?.env;
    const emulateMobileRequested = inkProcessEnv?.INK_EMULATE_MOBILE === "true";
    const mobileEmulationReloadGuardKey = "__inkMobileEmulationReloadInProgress";
    const appWithMobileEmulation = this.app;
    const canEmulateMobile = typeof appWithMobileEmulation.emulateMobile === "function";
    const alreadyInMobileMode = !!(import_obsidian47.Platform.isMobile || import_obsidian47.Platform.isMobileApp || appWithMobileEmulation.isMobile);
    const mobileEmulationReloadInProgress = window.localStorage.getItem(mobileEmulationReloadGuardKey) === "true";
    if (emulateMobileRequested && canEmulateMobile && !alreadyInMobileMode && !mobileEmulationReloadInProgress) {
      window.localStorage.setItem(mobileEmulationReloadGuardKey, "true");
      const runEmulateMobile = appWithMobileEmulation.emulateMobile;
      if (typeof runEmulateMobile === "function") {
        runEmulateMobile(true);
      }
      return;
    }
    if (!emulateMobileRequested || alreadyInMobileMode) {
      window.localStorage.removeItem(mobileEmulationReloadGuardKey);
    }
    if (this.settings.writingEnabled) {
      registerWritingView(this);
      registerWritingEmbed(this);
      registerUnifiedUndoRedo(this);
      registerUnifiedUndoRedoCommands(this);
      implementWritingEmbedCommands(this);
      registerWritingView_v1(this);
      registerWritingEmbed_v1(this);
    }
    if (this.settings.drawingEnabled) {
      registerDrawingView(this);
      registerDrawingEmbed(this);
      if (!this.settings.writingEnabled)
        registerUnifiedUndoRedo(this);
      if (!this.settings.writingEnabled)
        registerUnifiedUndoRedoCommands(this);
      implementDrawingEmbedCommands(this);
      registerDrawingView_v1(this);
      registerDrawingEmbed_v1(this);
    }
    if (this.settings.writingEnabled || this.settings.drawingEnabled) {
      const { inkEmbedsExtension: inkEmbedsExtension2 } = await Promise.resolve().then(() => (init_ink_embeds_extension(), ink_embeds_extension_exports));
      this.registerEditorExtension([inkEmbedsExtension2()]);
      registerPasteEmbedHandler(this);
      registerReadingModeInkEmbeds(this);
    }
    registerSettingsTab(this);
    showOnboardingTips_maybe(this);
  }
  onunload() {
    logToVault("Plugin unloaded");
    this.booxConnection?.dispose();
  }
  async loadSettings() {
    const loaded = await this.loadData();
    migrateBooxConnectionFromVaultToDevice(loaded);
    const isNewInstall = !loaded || Object.keys(loaded).length === 0;
    if (isNewInstall) {
      this.settings = Object.assign({}, DEFAULT_SETTINGS);
    } else {
      this.settings = migrateOutdatedSettings(loaded);
      this.stripLegacyBooxFromPluginSettings();
      await this.saveSettings();
    }
    setDominantHand(this.settings.dominantHand);
  }
  stripLegacyBooxFromPluginSettings() {
    const settingsRecord = this.settings;
    let changed = false;
    if ("booxConnectionEnabled" in settingsRecord) {
      delete settingsRecord.booxConnectionEnabled;
      changed = true;
    }
    if ("einkBridgeEnabled" in settingsRecord) {
      delete settingsRecord.einkBridgeEnabled;
      changed = true;
    }
    return changed;
  }
  async saveSettings() {
    await this.saveData(this.settings);
  }
  async resetSettings() {
    this.settings = structuredClone(DEFAULT_SETTINGS);
    setDominantHand(this.settings.dominantHand);
    resetBooxConnectionToDefault();
    resetFingerDrawingToDefault();
    this.booxConnection.onSettingsChanged();
    await this.saveSettings();
    new import_obsidian47.Notice("Ink plugin settings reset");
  }
  setBooxConnectionEnabledForTests(enabled) {
    setBooxConnectionEnabled(enabled);
    this.booxConnection.onSettingsChanged();
  }
};
var inkPluginAtom = atom();
function implementWritingEmbedCommands(plugin) {
  plugin.addCommand({
    id: "create-handwritten-section",
    name: "New handwriting section",
    icon: "write_default",
    editorCallback: (editor) => insertNewWritingFile(plugin, editor)
  });
  plugin.addCommand({
    id: "embed-writing-file",
    name: "Existing handwriting section",
    icon: "write_existing",
    editorCallback: (editor) => insertExistingWritingFile(plugin, editor)
  });
}
function implementDrawingEmbedCommands(plugin) {
  plugin.addCommand({
    id: "create-drawing-section",
    name: "New drawing",
    icon: "draw_default",
    editorCallback: (editor) => insertNewDrawingFile(plugin, editor)
  });
  plugin.addCommand({
    id: "embed-drawing-file",
    name: "Existing drawing",
    icon: "folder-dot",
    editorCallback: (editor) => insertExistingDrawingFile(plugin, editor)
  });
}
function showOnboardingTips_maybe(plugin) {
  const newInstall = showWelcomeTips_maybe(plugin);
  if (!newInstall) {
    showVersionNotice(plugin);
  }
}
/*!
	Copyright (c) 2018 Jed Watson.
	Licensed under the MIT License (MIT), see
	http://jedwatson.github.io/classnames
*/
/*!
 * Author: excalidraw
 * MIT License: https://github.com/excalidraw/excalidraw/blob/master/LICENSE
 * https://github.com/excalidraw/excalidraw/blob/48c3465b19f10ec755b3eb84e21a01a468e96e43/packages/excalidraw/utils.ts#L600
 */
/*!
 * MIT License
 * Adapted (mostly copied) the work of https://github.com/fregante/text-field-edit
 * Copyright (c) Federico Brigante <opensource@bfred.it> (bfred.it)
 */
/*!
 * MIT License
 * Modified code originally from <https://github.com/qzb/is-animated>
 * Copyright (c) 2016 Józef Sokołowski <j.k.sokolowski@gmail.com>
 */
/*!
 * MIT License: https://github.com/alexgorbatchev/crc/blob/master/LICENSE
 * Copyright: 2014 Alex Gorbatchev
 * Code: crc32, https://github.com/alexgorbatchev/crc/blob/master/src/calculators/crc32.ts
 */
/*!
 * MIT License: https://github.com/sindresorhus/is-webp/blob/main/license
 * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 */
/*!
 * MIT License: https://github.com/vHeemstra/is-apng/blob/main/license
 * Copyright (c) Philip van Heemstra
 */
/*!
 * canvas-size
 * v1.2.6
 * https://github.com/jhildenbiddle/canvas-size
 * (c) 2015-2023 John Hildenbiddle <http://hildenbiddle.com>
 * MIT license
 */
/**
 * @license React
 * react-dom.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
/**
 * @license React
 * react-jsx-runtime.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
/**
 * @license React
 * react.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
/**
 * @license React
 * scheduler.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/* nosourcemap */