@ai-ecoverse/slicc-spectrum 1.104.2 → 1.105.0

package/dist/chunk-KIDTSHLT.js

@@ -0,0 +1,3239 @@
+import {
+  unwrapDefault
+} from "./chunk-NEW2Q7FF.js";
+import {
+  __export
+} from "./chunk-AXQFWXYZ.js";
+
+// node_modules/@pierre/diffs/dist/utils/isWorkerContext.js
+function isWorkerContext() {
+  return typeof WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof WorkerGlobalScope;
+}
+
+// node_modules/@pierre/diffs/dist/highlighter/themes/createCachedLoader.js
+function createCachedLoader(loader) {
+  let cached;
+  return () => cached ??= loader().then((loaded) => {
+    cached = loaded;
+    return loaded;
+  }, (error) => {
+    cached = void 0;
+    throw error;
+  });
+}
+
+// node_modules/@pierre/theming/dist/modules/createThemeResolver.js
+var DuplicateThemeError = class extends Error {
+  constructor(name) {
+    super(`Theme "${name}" is already registered`);
+    this.name = "DuplicateThemeError";
+  }
+};
+var UnregisteredThemeError = class extends Error {
+  constructor(name) {
+    super(`No loader registered for theme "${name}"`);
+    this.name = "UnregisteredThemeError";
+  }
+};
+var UnresolvedThemeError = class extends Error {
+  constructor(name) {
+    super(`Theme "${name}" has not been resolved`);
+    this.name = "UnresolvedThemeError";
+  }
+};
+function createThemeResolver(options = {}) {
+  const loaders = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  let cacheGeneration = 0;
+  function registerTheme(name, loader) {
+    if (loaders.has(name)) throw new DuplicateThemeError(name);
+    loaders.set(name, loader);
+  }
+  function registerThemeIfAbsent(name, loader) {
+    if (loaders.has(name)) return false;
+    loaders.set(name, loader);
+    return true;
+  }
+  function hasRegisteredTheme(name) {
+    return loaders.has(name);
+  }
+  function resolveTheme(name) {
+    const cached = resolved.get(name);
+    if (cached !== void 0) return Promise.resolve(cached);
+    const existing = inflight.get(name);
+    if (existing !== void 0) return existing;
+    const loader = loaders.get(name);
+    if (loader === void 0 && options.fallbackLoader === void 0) return Promise.reject(new UnregisteredThemeError(name));
+    const generation = cacheGeneration;
+    const promise = Promise.resolve().then(() => loader !== void 0 ? loader() : options.fallbackLoader?.(name)).then(async (result) => {
+      if (result === void 0) throw new UnregisteredThemeError(name);
+      const loaded = unwrapDefault(result);
+      const theme = options.normalizeTheme === void 0 ? loaded : await options.normalizeTheme(loaded, name);
+      if (generation === cacheGeneration) resolved.set(name, theme);
+      if (inflight.get(name) === promise) inflight.delete(name);
+      return theme;
+    }).catch((err) => {
+      if (inflight.get(name) === promise) inflight.delete(name);
+      throw err;
+    });
+    inflight.set(name, promise);
+    return promise;
+  }
+  function resolveThemes(names) {
+    return Promise.all(names.map((name) => resolveTheme(name)));
+  }
+  function seedResolvedTheme(name, theme) {
+    resolved.set(name, theme);
+  }
+  function seedResolvedThemes(entries) {
+    for (const [name, theme] of entries) seedResolvedTheme(name, theme);
+  }
+  function getResolvedTheme(name) {
+    return resolved.get(name);
+  }
+  function getResolvedThemes(names) {
+    const themes = [];
+    for (const name of names) {
+      const theme = resolved.get(name);
+      if (theme === void 0) throw new UnresolvedThemeError(name);
+      themes.push(theme);
+    }
+    return themes;
+  }
+  function hasResolvedTheme(name) {
+    return resolved.has(name);
+  }
+  function hasResolvedThemes(names) {
+    for (const name of names) if (!resolved.has(name)) return false;
+    return true;
+  }
+  function getResolvedOrResolveTheme(name) {
+    const cached = resolved.get(name);
+    if (cached !== void 0) return cached;
+    return resolveTheme(name);
+  }
+  function clearResolvedThemes() {
+    cacheGeneration++;
+    resolved.clear();
+    inflight.clear();
+  }
+  return {
+    clearResolvedThemes,
+    getResolvedOrResolveTheme,
+    getResolvedTheme,
+    getResolvedThemes,
+    hasRegisteredTheme,
+    hasResolvedTheme,
+    hasResolvedThemes,
+    registerTheme,
+    registerThemeIfAbsent,
+    resolveTheme,
+    resolveThemes,
+    seedResolvedTheme,
+    seedResolvedThemes
+  };
+}
+
+// node_modules/@pierre/diffs/dist/highlighter/themes/themeResolver.js
+var customThemes = /* @__PURE__ */ new Map();
+var resolvers = /* @__PURE__ */ new Map();
+var loadHighlightsThemeCatalog = createCachedLoader(() => import("./chunk-4LNENAB3.js"));
+var loadPierreThemeCatalog = createCachedLoader(() => import("./chunk-K7CQ2PRH.js"));
+var loadShikiCore = createCachedLoader(() => import("./chunk-E6FGQYBA.js"));
+var ZED_COLOR_ALIASES = [
+  ["editor.lineHighlightBackground", "editor.active_line.background"],
+  ["editor.selectionBackground", "element.selected"],
+  ["editor.findMatchBackground", "search.match_background"],
+  ["editor.findMatchHighlightBackground", "search.match_background"],
+  ["editorBracketMatch.background", "editor.document_highlight.bracket_background"],
+  ["editorError.foreground", "error"],
+  ["editorWarning.foreground", "warning"],
+  ["editorInfo.foreground", "info"],
+  ["editorHint.foreground", "hint"],
+  [
+    "gitDecoration.addedResourceForeground",
+    "created",
+    "terminal.ansi.green"
+  ],
+  [
+    "gitDecoration.deletedResourceForeground",
+    "deleted",
+    "terminal.ansi.red"
+  ],
+  [
+    "gitDecoration.modifiedResourceForeground",
+    "modified",
+    "terminal.ansi.blue"
+  ]
+];
+function createHighlightsTheme(name, raw2) {
+  const theme = "themes" in raw2 ? raw2.themes[0] : raw2;
+  if (theme == null) throw new Error(`Theme "${name}" is an empty Zed theme family.`);
+  const zed = {
+    ...theme,
+    name
+  };
+  const colors = {};
+  for (const [key2, value] of Object.entries(zed.style)) if (typeof value === "string") colors[key2] = value;
+  const player = zed.style.players?.[0];
+  if (player?.cursor != null) colors["editorCursor.foreground"] ??= player.cursor;
+  if (player?.selection != null) colors["editor.selectionBackground"] ??= player.selection;
+  for (const [target, ...sources] of ZED_COLOR_ALIASES) {
+    if (colors[target] != null) continue;
+    const source = sources.find((key2) => colors[key2] != null);
+    if (source != null) colors[target] = colors[source];
+  }
+  if (zed.cssVariables === true) {
+    colors["editor.foreground"] = "var(--hls-foreground)";
+    colors["editor.background"] = "var(--hls-background)";
+  } else if (typeof zed.cssVariables === "object") {
+    colors["editor.foreground"] ??= colors.text ?? colors.foreground ?? "foreground";
+    colors["editor.background"] ??= colors.background ?? "background";
+    const { prefix = "--hls-", defaults } = zed.cssVariables;
+    for (const [key2, value] of Object.entries(colors)) {
+      const fallback = defaults?.[value];
+      colors[key2] = `var(${prefix}${value}${fallback ? `, ${fallback}` : ""})`;
+    }
+  }
+  const type = zed.appearance === "light" ? "light" : "dark";
+  return {
+    name,
+    type,
+    colors,
+    zed,
+    fg: colors["editor.foreground"] ?? colors.text ?? colors.foreground ?? (type === "light" ? "#333333" : "#bbbbbb"),
+    bg: colors["editor.background"] ?? colors.background ?? (type === "light" ? "#ffffff" : "#1e1e1e")
+  };
+}
+function createDiffsThemeResolver(backend) {
+  let resolver = resolvers.get(backend);
+  if (resolver != null) return resolver;
+  resolver = createThemeResolver({
+    fallbackLoader: async (name) => {
+      if (typeof __DIFFS_WORKER__ !== "undefined" ? __DIFFS_WORKER__ : isWorkerContext()) throw new Error(`Theme "${name}" cannot be resolved from a worker context. Themes must be pre-resolved on the main thread and passed to the worker via the resolvedThemes parameter.`);
+      const custom = customThemes.get(name);
+      if (backend === "highlights") {
+        const loader = custom?.zed ?? custom?.diffs;
+        if (loader != null) {
+          const loaded = await loader();
+          const theme = "default" in loaded ? loaded.default : loaded;
+          if ("zed" in theme && theme.zed != null) return theme;
+          if ("style" in theme || "themes" in theme) return createHighlightsTheme(name, theme);
+          throw new Error(`Theme "${name}" is a TextMate theme; register a Zed theme with registerCustomTheme(name, loader, 'zed') for Highlights.`);
+        }
+        const catalog = loadHighlightsThemeCatalog();
+        const { themes } = catalog instanceof Promise ? await catalog : catalog;
+        const bundledLoader = themes[name];
+        if (bundledLoader != null) return createHighlightsTheme(name, (await bundledLoader()).default);
+        if (custom?.textmate != null) throw new Error(`Theme "${name}" is only registered for TextMate; use registerCustomTheme(name, loader, 'zed') for Highlights.`);
+      } else {
+        const loader = custom?.textmate ?? custom?.diffs;
+        let loaded;
+        if (loader != null) {
+          const result = await loader();
+          loaded = "default" in result ? result.default : result;
+        } else {
+          const catalog = loadPierreThemeCatalog();
+          const { themes } = catalog instanceof Promise ? await catalog : catalog;
+          const descriptor = themes.getTheme(name);
+          if (descriptor == null && custom?.zed != null) throw new Error(`Theme "${name}" is only registered for Zed; use registerCustomTheme(name, loader, 'textmate') for Shiki.`);
+          if (descriptor == null) throw new Error(`No valid theme loader registered for "${name}"`);
+          const result = await descriptor.load();
+          loaded = "default" in result ? result.default : result;
+        }
+        if ("style" in loaded || "themes" in loaded) throw new Error(`Theme "${name}" is a Zed theme; use preferredHighlighter: 'highlights' or register a TextMate theme for Shiki.`);
+        const core2 = loadShikiCore();
+        const { normalizeTheme, createCssVariablesTheme } = core2 instanceof Promise ? await core2 : core2;
+        if ("cssVariables" in loaded && loaded.cssVariables != null) return {
+          ...loaded,
+          textmate: normalizeTheme(createCssVariablesTheme(loaded.cssVariables))
+        };
+        if ("textmate" in loaded && loaded.textmate != null) return {
+          ...loaded,
+          textmate: normalizeTheme(loaded.textmate)
+        };
+        const textmate = normalizeTheme(loaded);
+        return {
+          name: textmate.name,
+          type: textmate.type,
+          fg: textmate.fg,
+          bg: textmate.bg,
+          colors: textmate.colors,
+          textmate
+        };
+      }
+      throw new Error(`No valid theme loader registered for "${name}"`);
+    },
+    normalizeTheme: (theme, name) => {
+      if (theme.name !== name) throw new Error(`resolvedTheme: themeName: ${name} does not match theme.name: ${theme.name}`);
+      return theme;
+    }
+  });
+  resolvers.set(backend, resolver);
+  return resolver;
+}
+
+// node_modules/@pierre/diffs/dist/constants.js
+var DIFFS_TAG_NAME = "diffs-container";
+var DIFFS_DEVELOPMENT_BUILD = (() => {
+  try {
+    return true;
+  } catch {
+    return false;
+  }
+})();
+var GIT_DIFF_FILE_BREAK_REGEX = /(?=^diff --git)/gm;
+var SPLIT_WITH_NEWLINES = /(?<=\n)/;
+var FILENAME_HEADER_REGEX = /^(---|\+\+\+)\s+([^\t\r\n]+)/;
+var INDEX_LINE_METADATA = /^index ([0-9a-f]+)\.\.([0-9a-f]+)(?: (\d+))?$/i;
+var HEADER_PREFIX_SLOT_ID = "header-prefix";
+var HEADER_FILENAME_SUFFIX_SLOT_ID = "header-filename-suffix";
+var HEADER_METADATA_SLOT_ID = "header-metadata";
+var CUSTOM_HEADER_SLOT_ID = "header-custom";
+var DEFAULT_THEMES = {
+  dark: "pierre-dark",
+  light: "pierre-light"
+};
+var THEME_CSS_ATTRIBUTE = "data-theme-css";
+var UNSAFE_CSS_ATTRIBUTE = "data-unsafe-css";
+var DIFFS_SCROLLBAR_MEASURE_ATTRIBUTE = "data-diffs-scrollbar-measure";
+var DIFFS_SCROLLBAR_GUTTER_MEASURED_PROPERTY = "--diffs-scrollbar-gutter-measured";
+var DEFAULT_TOKENIZE_MAX_LENGTH = 1e5;
+var DEFAULT_VIRTUAL_FILE_METRICS = {
+  hunkLineCount: 50,
+  lineHeight: 20,
+  diffHeaderHeight: 44,
+  spacing: 8
+};
+var DEFAULT_CODE_VIEW_FILE_METRICS = {
+  ...DEFAULT_VIRTUAL_FILE_METRICS,
+  hunkLineCount: 1
+};
+var DEFAULT_EXPANDED_REGION = Object.freeze({
+  fromStart: 0,
+  fromEnd: 0
+});
+var DEFAULT_RENDER_RANGE = {
+  startingLine: 0,
+  totalLines: Infinity,
+  bufferBefore: 0,
+  bufferAfter: 0
+};
+var EMPTY_LINE_ANNOTATIONS = Object.freeze([]);
+var EMPTY_RENDER_RANGE = {
+  startingLine: 0,
+  totalLines: 0,
+  bufferBefore: 0,
+  bufferAfter: 0
+};
+
+// node_modules/@pierre/diffs/dist/highlighter/highlighterType.js
+var activeType;
+var holds = 0;
+var HighlighterDisposedError = class extends Error {
+  constructor() {
+    super("Highlighter is disposed");
+    this.name = "HighlighterDisposedError";
+  }
+};
+function getHighlighterType() {
+  return activeType;
+}
+function resolveHighlighterType(type) {
+  return type ?? activeType ?? "shiki-js";
+}
+function assertHighlighterType(type) {
+  if (activeType != null && activeType !== type) throw new Error(`Cannot load the "${type}" highlighter while "${activeType}" is in use. Only one highlighter type can be active at a time; dispose every "${activeType}" instance (disposeHighlighter() disposes the shared one) before switching.`);
+}
+function acquireHighlighterType(type) {
+  assertHighlighterType(type);
+  activeType = type;
+  holds++;
+}
+function releaseHighlighterType() {
+  holds--;
+  if (holds === 0) activeType = void 0;
+}
+
+// node_modules/html-void-elements/index.js
+var htmlVoidElements = [
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+
+// node_modules/property-information/lib/util/schema.js
+var Schema = class {
+  /**
+   * @param {SchemaType['property']} property
+   *   Property.
+   * @param {SchemaType['normal']} normal
+   *   Normal.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Schema.
+   */
+  constructor(property, normal, space) {
+    this.normal = normal;
+    this.property = property;
+    if (space) {
+      this.space = space;
+    }
+  }
+};
+Schema.prototype.normal = {};
+Schema.prototype.property = {};
+Schema.prototype.space = void 0;
+
+// node_modules/property-information/lib/util/merge.js
+function merge(definitions, space) {
+  const property = {};
+  const normal = {};
+  for (const definition of definitions) {
+    Object.assign(property, definition.property);
+    Object.assign(normal, definition.normal);
+  }
+  return new Schema(property, normal, space);
+}
+
+// node_modules/property-information/lib/normalize.js
+function normalize(value) {
+  return value.toLowerCase();
+}
+
+// node_modules/property-information/lib/util/info.js
+var Info = class {
+  /**
+   * @param {string} property
+   *   Property.
+   * @param {string} attribute
+   *   Attribute.
+   * @returns
+   *   Info.
+   */
+  constructor(property, attribute) {
+    this.attribute = attribute;
+    this.property = property;
+  }
+};
+Info.prototype.attribute = "";
+Info.prototype.booleanish = false;
+Info.prototype.boolean = false;
+Info.prototype.commaOrSpaceSeparated = false;
+Info.prototype.commaSeparated = false;
+Info.prototype.defined = false;
+Info.prototype.mustUseProperty = false;
+Info.prototype.number = false;
+Info.prototype.overloadedBoolean = false;
+Info.prototype.property = "";
+Info.prototype.spaceSeparated = false;
+Info.prototype.space = void 0;
+
+// node_modules/property-information/lib/util/types.js
+var types_exports = {};
+__export(types_exports, {
+  boolean: () => boolean,
+  booleanish: () => booleanish,
+  commaOrSpaceSeparated: () => commaOrSpaceSeparated,
+  commaSeparated: () => commaSeparated,
+  number: () => number,
+  overloadedBoolean: () => overloadedBoolean,
+  spaceSeparated: () => spaceSeparated
+});
+var powers = 0;
+var boolean = increment();
+var booleanish = increment();
+var overloadedBoolean = increment();
+var number = increment();
+var spaceSeparated = increment();
+var commaSeparated = increment();
+var commaOrSpaceSeparated = increment();
+function increment() {
+  return 2 ** ++powers;
+}
+
+// node_modules/property-information/lib/util/defined-info.js
+var checks = (
+  /** @type {ReadonlyArray<keyof typeof types>} */
+  Object.keys(types_exports)
+);
+var DefinedInfo = class extends Info {
+  /**
+   * @constructor
+   * @param {string} property
+   *   Property.
+   * @param {string} attribute
+   *   Attribute.
+   * @param {number | null | undefined} [mask]
+   *   Mask.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Info.
+   */
+  constructor(property, attribute, mask, space) {
+    let index = -1;
+    super(property, attribute);
+    mark(this, "space", space);
+    if (typeof mask === "number") {
+      while (++index < checks.length) {
+        const check = checks[index];
+        mark(this, checks[index], (mask & types_exports[check]) === types_exports[check]);
+      }
+    }
+  }
+};
+DefinedInfo.prototype.defined = true;
+function mark(values, key2, value) {
+  if (value) {
+    values[key2] = value;
+  }
+}
+
+// node_modules/property-information/lib/util/create.js
+function create(definition) {
+  const properties = {};
+  const normals = {};
+  for (const [property, value] of Object.entries(definition.properties)) {
+    const info = new DefinedInfo(
+      property,
+      definition.transform(definition.attributes || {}, property),
+      value,
+      definition.space
+    );
+    if (definition.mustUseProperty && definition.mustUseProperty.includes(property)) {
+      info.mustUseProperty = true;
+    }
+    properties[property] = info;
+    normals[normalize(property)] = property;
+    normals[normalize(info.attribute)] = property;
+  }
+  return new Schema(properties, normals, definition.space);
+}
+
+// node_modules/property-information/lib/aria.js
+var aria = create({
+  properties: {
+    ariaActiveDescendant: null,
+    ariaAtomic: booleanish,
+    ariaAutoComplete: null,
+    ariaBusy: booleanish,
+    ariaChecked: booleanish,
+    ariaColCount: number,
+    ariaColIndex: number,
+    ariaColSpan: number,
+    ariaControls: spaceSeparated,
+    ariaCurrent: null,
+    ariaDescribedBy: spaceSeparated,
+    ariaDetails: null,
+    ariaDisabled: booleanish,
+    ariaDropEffect: spaceSeparated,
+    ariaErrorMessage: null,
+    ariaExpanded: booleanish,
+    ariaFlowTo: spaceSeparated,
+    ariaGrabbed: booleanish,
+    ariaHasPopup: null,
+    ariaHidden: booleanish,
+    ariaInvalid: null,
+    ariaKeyShortcuts: null,
+    ariaLabel: null,
+    ariaLabelledBy: spaceSeparated,
+    ariaLevel: number,
+    ariaLive: null,
+    ariaModal: booleanish,
+    ariaMultiLine: booleanish,
+    ariaMultiSelectable: booleanish,
+    ariaOrientation: null,
+    ariaOwns: spaceSeparated,
+    ariaPlaceholder: null,
+    ariaPosInSet: number,
+    ariaPressed: booleanish,
+    ariaReadOnly: booleanish,
+    ariaRelevant: null,
+    ariaRequired: booleanish,
+    ariaRoleDescription: spaceSeparated,
+    ariaRowCount: number,
+    ariaRowIndex: number,
+    ariaRowSpan: number,
+    ariaSelected: booleanish,
+    ariaSetSize: number,
+    ariaSort: null,
+    ariaValueMax: number,
+    ariaValueMin: number,
+    ariaValueNow: number,
+    ariaValueText: null,
+    role: null
+  },
+  transform(_, property) {
+    return property === "role" ? property : "aria-" + property.slice(4).toLowerCase();
+  }
+});
+
+// node_modules/property-information/lib/util/case-sensitive-transform.js
+function caseSensitiveTransform(attributes, attribute) {
+  return attribute in attributes ? attributes[attribute] : attribute;
+}
+
+// node_modules/property-information/lib/util/case-insensitive-transform.js
+function caseInsensitiveTransform(attributes, property) {
+  return caseSensitiveTransform(attributes, property.toLowerCase());
+}
+
+// node_modules/property-information/lib/html.js
+var html = create({
+  attributes: {
+    acceptcharset: "accept-charset",
+    classname: "class",
+    htmlfor: "for",
+    httpequiv: "http-equiv"
+  },
+  mustUseProperty: ["checked", "multiple", "muted", "selected"],
+  properties: {
+    // Standard Properties.
+    abbr: null,
+    accept: commaSeparated,
+    acceptCharset: spaceSeparated,
+    accessKey: spaceSeparated,
+    action: null,
+    allow: null,
+    allowFullScreen: boolean,
+    allowPaymentRequest: boolean,
+    allowUserMedia: boolean,
+    alpha: boolean,
+    alt: null,
+    as: null,
+    async: boolean,
+    autoCapitalize: null,
+    autoComplete: spaceSeparated,
+    autoFocus: boolean,
+    autoPlay: boolean,
+    blocking: spaceSeparated,
+    capture: null,
+    charSet: null,
+    checked: boolean,
+    cite: null,
+    className: spaceSeparated,
+    closedBy: null,
+    colorSpace: null,
+    cols: number,
+    colSpan: number,
+    command: null,
+    commandFor: null,
+    content: null,
+    contentEditable: booleanish,
+    controls: boolean,
+    controlsList: spaceSeparated,
+    coords: number | commaSeparated,
+    crossOrigin: null,
+    data: null,
+    dateTime: null,
+    decoding: null,
+    default: boolean,
+    defer: boolean,
+    dir: null,
+    dirName: null,
+    disabled: boolean,
+    download: overloadedBoolean,
+    draggable: booleanish,
+    encType: null,
+    enterKeyHint: null,
+    fetchPriority: null,
+    form: null,
+    formAction: null,
+    formEncType: null,
+    formMethod: null,
+    formNoValidate: boolean,
+    formTarget: null,
+    headers: spaceSeparated,
+    height: number,
+    hidden: overloadedBoolean,
+    high: number,
+    href: null,
+    hrefLang: null,
+    htmlFor: spaceSeparated,
+    httpEquiv: spaceSeparated,
+    id: null,
+    imageSizes: null,
+    imageSrcSet: null,
+    inert: boolean,
+    inputMode: null,
+    integrity: null,
+    is: null,
+    isMap: boolean,
+    itemId: null,
+    itemProp: spaceSeparated,
+    itemRef: spaceSeparated,
+    itemScope: boolean,
+    itemType: spaceSeparated,
+    kind: null,
+    label: null,
+    lang: null,
+    language: null,
+    list: null,
+    loading: null,
+    loop: boolean,
+    low: number,
+    manifest: null,
+    max: null,
+    maxLength: number,
+    media: null,
+    method: null,
+    min: null,
+    minLength: number,
+    multiple: boolean,
+    muted: boolean,
+    name: null,
+    nonce: null,
+    noModule: boolean,
+    noValidate: boolean,
+    onAbort: null,
+    onAfterPrint: null,
+    onAuxClick: null,
+    onBeforeMatch: null,
+    onBeforePrint: null,
+    onBeforeToggle: null,
+    onBeforeUnload: null,
+    onBlur: null,
+    onCancel: null,
+    onCanPlay: null,
+    onCanPlayThrough: null,
+    onChange: null,
+    onClick: null,
+    onClose: null,
+    onContextLost: null,
+    onContextMenu: null,
+    onContextRestored: null,
+    onCopy: null,
+    onCueChange: null,
+    onCut: null,
+    onDblClick: null,
+    onDrag: null,
+    onDragEnd: null,
+    onDragEnter: null,
+    onDragExit: null,
+    onDragLeave: null,
+    onDragOver: null,
+    onDragStart: null,
+    onDrop: null,
+    onDurationChange: null,
+    onEmptied: null,
+    onEnded: null,
+    onError: null,
+    onFocus: null,
+    onFormData: null,
+    onHashChange: null,
+    onInput: null,
+    onInvalid: null,
+    onKeyDown: null,
+    onKeyPress: null,
+    onKeyUp: null,
+    onLanguageChange: null,
+    onLoad: null,
+    onLoadedData: null,
+    onLoadedMetadata: null,
+    onLoadEnd: null,
+    onLoadStart: null,
+    onMessage: null,
+    onMessageError: null,
+    onMouseDown: null,
+    onMouseEnter: null,
+    onMouseLeave: null,
+    onMouseMove: null,
+    onMouseOut: null,
+    onMouseOver: null,
+    onMouseUp: null,
+    onOffline: null,
+    onOnline: null,
+    onPageHide: null,
+    onPageShow: null,
+    onPaste: null,
+    onPause: null,
+    onPlay: null,
+    onPlaying: null,
+    onPopState: null,
+    onProgress: null,
+    onRateChange: null,
+    onRejectionHandled: null,
+    onReset: null,
+    onResize: null,
+    onScroll: null,
+    onScrollEnd: null,
+    onSecurityPolicyViolation: null,
+    onSeeked: null,
+    onSeeking: null,
+    onSelect: null,
+    onSlotChange: null,
+    onStalled: null,
+    onStorage: null,
+    onSubmit: null,
+    onSuspend: null,
+    onTimeUpdate: null,
+    onToggle: null,
+    onUnhandledRejection: null,
+    onUnload: null,
+    onVolumeChange: null,
+    onWaiting: null,
+    onWheel: null,
+    open: boolean,
+    optimum: number,
+    pattern: null,
+    ping: spaceSeparated,
+    placeholder: null,
+    playsInline: boolean,
+    popover: null,
+    popoverTarget: null,
+    popoverTargetAction: null,
+    poster: null,
+    preload: null,
+    readOnly: boolean,
+    referrerPolicy: null,
+    rel: spaceSeparated,
+    required: boolean,
+    reversed: boolean,
+    rows: number,
+    rowSpan: number,
+    sandbox: spaceSeparated,
+    scope: null,
+    scoped: boolean,
+    seamless: boolean,
+    selected: boolean,
+    shadowRootClonable: boolean,
+    shadowRootCustomElementRegistry: boolean,
+    shadowRootDelegatesFocus: boolean,
+    shadowRootMode: null,
+    shadowRootSerializable: boolean,
+    shape: null,
+    size: number,
+    sizes: null,
+    slot: null,
+    span: number,
+    spellCheck: booleanish,
+    src: null,
+    srcDoc: null,
+    srcLang: null,
+    srcSet: null,
+    start: number,
+    step: null,
+    style: null,
+    tabIndex: number,
+    target: null,
+    title: null,
+    translate: null,
+    type: null,
+    typeMustMatch: boolean,
+    useMap: null,
+    value: booleanish,
+    width: number,
+    wrap: null,
+    writingSuggestions: null,
+    // Legacy.
+    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
+    align: null,
+    // Several. Use CSS `text-align` instead,
+    aLink: null,
+    // `<body>`. Use CSS `a:active {color}` instead
+    archive: spaceSeparated,
+    // `<object>`. List of URIs to archives
+    axis: null,
+    // `<td>` and `<th>`. Use `scope` on `<th>`
+    background: null,
+    // `<body>`. Use CSS `background-image` instead
+    bgColor: null,
+    // `<body>` and table elements. Use CSS `background-color` instead
+    border: number,
+    // `<table>`. Use CSS `border-width` instead,
+    borderColor: null,
+    // `<table>`. Use CSS `border-color` instead,
+    bottomMargin: number,
+    // `<body>`
+    cellPadding: null,
+    // `<table>`
+    cellSpacing: null,
+    // `<table>`
+    char: null,
+    // Several table elements. When `align=char`, sets the character to align on
+    charOff: null,
+    // Several table elements. When `char`, offsets the alignment
+    classId: null,
+    // `<object>`
+    clear: null,
+    // `<br>`. Use CSS `clear` instead
+    code: null,
+    // `<object>`
+    codeBase: null,
+    // `<object>`
+    codeType: null,
+    // `<object>`
+    color: null,
+    // `<font>` and `<hr>`. Use CSS instead
+    compact: boolean,
+    // Lists. Use CSS to reduce space between items instead
+    declare: boolean,
+    // `<object>`
+    event: null,
+    // `<script>`
+    face: null,
+    // `<font>`. Use CSS instead
+    frame: null,
+    // `<table>`
+    frameBorder: null,
+    // `<iframe>`. Use CSS `border` instead
+    hSpace: number,
+    // `<img>` and `<object>`
+    leftMargin: number,
+    // `<body>`
+    link: null,
+    // `<body>`. Use CSS `a:link {color: *}` instead
+    longDesc: null,
+    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
+    lowSrc: null,
+    // `<img>`. Use a `<picture>`
+    marginHeight: number,
+    // `<body>`
+    marginWidth: number,
+    // `<body>`
+    noResize: boolean,
+    // `<frame>`
+    noHref: boolean,
+    // `<area>`. Use no href instead of an explicit `nohref`
+    noShade: boolean,
+    // `<hr>`. Use background-color and height instead of borders
+    noWrap: boolean,
+    // `<td>` and `<th>`
+    object: null,
+    // `<applet>`
+    profile: null,
+    // `<head>`
+    prompt: null,
+    // `<isindex>`
+    rev: null,
+    // `<link>`
+    rightMargin: number,
+    // `<body>`
+    rules: null,
+    // `<table>`
+    scheme: null,
+    // `<meta>`
+    scrolling: booleanish,
+    // `<frame>`. Use overflow in the child context
+    standby: null,
+    // `<object>`
+    summary: null,
+    // `<table>`
+    text: null,
+    // `<body>`. Use CSS `color` instead
+    topMargin: number,
+    // `<body>`
+    valueType: null,
+    // `<param>`
+    version: null,
+    // `<html>`. Use a doctype.
+    vAlign: null,
+    // Several. Use CSS `vertical-align` instead
+    vLink: null,
+    // `<body>`. Use CSS `a:visited {color}` instead
+    vSpace: number,
+    // `<img>` and `<object>`
+    // Non-standard Properties.
+    allowTransparency: null,
+    autoCorrect: null,
+    autoSave: null,
+    credentialless: boolean,
+    disablePictureInPicture: boolean,
+    disableRemotePlayback: boolean,
+    exportParts: commaSeparated,
+    part: spaceSeparated,
+    prefix: null,
+    property: null,
+    results: number,
+    security: null,
+    unselectable: null
+  },
+  space: "html",
+  transform: caseInsensitiveTransform
+});
+
+// node_modules/property-information/lib/svg.js
+var svg = create({
+  attributes: {
+    accentHeight: "accent-height",
+    alignmentBaseline: "alignment-baseline",
+    arabicForm: "arabic-form",
+    baselineShift: "baseline-shift",
+    capHeight: "cap-height",
+    className: "class",
+    clipPath: "clip-path",
+    clipRule: "clip-rule",
+    colorInterpolation: "color-interpolation",
+    colorInterpolationFilters: "color-interpolation-filters",
+    colorProfile: "color-profile",
+    colorRendering: "color-rendering",
+    crossOrigin: "crossorigin",
+    dataType: "datatype",
+    dominantBaseline: "dominant-baseline",
+    enableBackground: "enable-background",
+    fillOpacity: "fill-opacity",
+    fillRule: "fill-rule",
+    floodColor: "flood-color",
+    floodOpacity: "flood-opacity",
+    fontFamily: "font-family",
+    fontSize: "font-size",
+    fontSizeAdjust: "font-size-adjust",
+    fontStretch: "font-stretch",
+    fontStyle: "font-style",
+    fontVariant: "font-variant",
+    fontWeight: "font-weight",
+    glyphName: "glyph-name",
+    glyphOrientationHorizontal: "glyph-orientation-horizontal",
+    glyphOrientationVertical: "glyph-orientation-vertical",
+    hrefLang: "hreflang",
+    horizAdvX: "horiz-adv-x",
+    horizOriginX: "horiz-origin-x",
+    horizOriginY: "horiz-origin-y",
+    imageRendering: "image-rendering",
+    letterSpacing: "letter-spacing",
+    lightingColor: "lighting-color",
+    markerEnd: "marker-end",
+    markerMid: "marker-mid",
+    markerStart: "marker-start",
+    maskType: "mask-type",
+    navDown: "nav-down",
+    navDownLeft: "nav-down-left",
+    navDownRight: "nav-down-right",
+    navLeft: "nav-left",
+    navNext: "nav-next",
+    navPrev: "nav-prev",
+    navRight: "nav-right",
+    navUp: "nav-up",
+    navUpLeft: "nav-up-left",
+    navUpRight: "nav-up-right",
+    onAbort: "onabort",
+    onActivate: "onactivate",
+    onAfterPrint: "onafterprint",
+    onBeforePrint: "onbeforeprint",
+    onBegin: "onbegin",
+    onCancel: "oncancel",
+    onCanPlay: "oncanplay",
+    onCanPlayThrough: "oncanplaythrough",
+    onChange: "onchange",
+    onClick: "onclick",
+    onClose: "onclose",
+    onCopy: "oncopy",
+    onCueChange: "oncuechange",
+    onCut: "oncut",
+    onDblClick: "ondblclick",
+    onDrag: "ondrag",
+    onDragEnd: "ondragend",
+    onDragEnter: "ondragenter",
+    onDragExit: "ondragexit",
+    onDragLeave: "ondragleave",
+    onDragOver: "ondragover",
+    onDragStart: "ondragstart",
+    onDrop: "ondrop",
+    onDurationChange: "ondurationchange",
+    onEmptied: "onemptied",
+    onEnd: "onend",
+    onEnded: "onended",
+    onError: "onerror",
+    onFocus: "onfocus",
+    onFocusIn: "onfocusin",
+    onFocusOut: "onfocusout",
+    onHashChange: "onhashchange",
+    onInput: "oninput",
+    onInvalid: "oninvalid",
+    onKeyDown: "onkeydown",
+    onKeyPress: "onkeypress",
+    onKeyUp: "onkeyup",
+    onLoad: "onload",
+    onLoadedData: "onloadeddata",
+    onLoadedMetadata: "onloadedmetadata",
+    onLoadStart: "onloadstart",
+    onMessage: "onmessage",
+    onMouseDown: "onmousedown",
+    onMouseEnter: "onmouseenter",
+    onMouseLeave: "onmouseleave",
+    onMouseMove: "onmousemove",
+    onMouseOut: "onmouseout",
+    onMouseOver: "onmouseover",
+    onMouseUp: "onmouseup",
+    onMouseWheel: "onmousewheel",
+    onOffline: "onoffline",
+    onOnline: "ononline",
+    onPageHide: "onpagehide",
+    onPageShow: "onpageshow",
+    onPaste: "onpaste",
+    onPause: "onpause",
+    onPlay: "onplay",
+    onPlaying: "onplaying",
+    onPopState: "onpopstate",
+    onProgress: "onprogress",
+    onRateChange: "onratechange",
+    onRepeat: "onrepeat",
+    onReset: "onreset",
+    onResize: "onresize",
+    onScroll: "onscroll",
+    onSeeked: "onseeked",
+    onSeeking: "onseeking",
+    onSelect: "onselect",
+    onShow: "onshow",
+    onStalled: "onstalled",
+    onStorage: "onstorage",
+    onSubmit: "onsubmit",
+    onSuspend: "onsuspend",
+    onTimeUpdate: "ontimeupdate",
+    onToggle: "ontoggle",
+    onUnload: "onunload",
+    onVolumeChange: "onvolumechange",
+    onWaiting: "onwaiting",
+    onZoom: "onzoom",
+    overlinePosition: "overline-position",
+    overlineThickness: "overline-thickness",
+    paintOrder: "paint-order",
+    panose1: "panose-1",
+    pointerEvents: "pointer-events",
+    referrerPolicy: "referrerpolicy",
+    renderingIntent: "rendering-intent",
+    shapeRendering: "shape-rendering",
+    stopColor: "stop-color",
+    stopOpacity: "stop-opacity",
+    strikethroughPosition: "strikethrough-position",
+    strikethroughThickness: "strikethrough-thickness",
+    strokeDashArray: "stroke-dasharray",
+    strokeDashOffset: "stroke-dashoffset",
+    strokeLineCap: "stroke-linecap",
+    strokeLineJoin: "stroke-linejoin",
+    strokeMiterLimit: "stroke-miterlimit",
+    strokeOpacity: "stroke-opacity",
+    strokeWidth: "stroke-width",
+    tabIndex: "tabindex",
+    textAnchor: "text-anchor",
+    textDecoration: "text-decoration",
+    textRendering: "text-rendering",
+    transformOrigin: "transform-origin",
+    typeOf: "typeof",
+    underlinePosition: "underline-position",
+    underlineThickness: "underline-thickness",
+    unicodeBidi: "unicode-bidi",
+    unicodeRange: "unicode-range",
+    unitsPerEm: "units-per-em",
+    vAlphabetic: "v-alphabetic",
+    vHanging: "v-hanging",
+    vIdeographic: "v-ideographic",
+    vMathematical: "v-mathematical",
+    vectorEffect: "vector-effect",
+    vertAdvY: "vert-adv-y",
+    vertOriginX: "vert-origin-x",
+    vertOriginY: "vert-origin-y",
+    wordSpacing: "word-spacing",
+    writingMode: "writing-mode",
+    xHeight: "x-height",
+    // These were camelcased in Tiny. Now lowercased in SVG 2
+    playbackOrder: "playbackorder",
+    timelineBegin: "timelinebegin"
+  },
+  properties: {
+    about: commaOrSpaceSeparated,
+    accentHeight: number,
+    accumulate: null,
+    additive: null,
+    alignmentBaseline: null,
+    alphabetic: number,
+    amplitude: number,
+    arabicForm: null,
+    ascent: number,
+    attributeName: null,
+    attributeType: null,
+    azimuth: number,
+    bandwidth: null,
+    baselineShift: null,
+    baseFrequency: null,
+    baseProfile: null,
+    bbox: null,
+    begin: null,
+    bias: number,
+    by: null,
+    calcMode: null,
+    capHeight: number,
+    className: spaceSeparated,
+    clip: null,
+    clipPath: null,
+    clipPathUnits: null,
+    clipRule: null,
+    color: null,
+    colorInterpolation: null,
+    colorInterpolationFilters: null,
+    colorProfile: null,
+    colorRendering: null,
+    content: null,
+    contentScriptType: null,
+    contentStyleType: null,
+    crossOrigin: null,
+    cursor: null,
+    cx: null,
+    cy: null,
+    d: null,
+    dataType: null,
+    defaultAction: null,
+    descent: number,
+    diffuseConstant: number,
+    direction: null,
+    display: null,
+    dur: null,
+    divisor: number,
+    dominantBaseline: null,
+    download: boolean,
+    dx: null,
+    dy: null,
+    edgeMode: null,
+    editable: null,
+    elevation: number,
+    enableBackground: null,
+    end: null,
+    event: null,
+    exponent: number,
+    externalResourcesRequired: null,
+    fill: null,
+    fillOpacity: number,
+    fillRule: null,
+    filter: null,
+    filterRes: null,
+    filterUnits: null,
+    floodColor: null,
+    floodOpacity: null,
+    focusable: null,
+    focusHighlight: null,
+    fontFamily: null,
+    fontSize: null,
+    fontSizeAdjust: null,
+    fontStretch: null,
+    fontStyle: null,
+    fontVariant: null,
+    fontWeight: null,
+    format: null,
+    fr: null,
+    from: null,
+    fx: null,
+    fy: null,
+    g1: commaSeparated,
+    g2: commaSeparated,
+    glyphName: commaSeparated,
+    glyphOrientationHorizontal: null,
+    glyphOrientationVertical: null,
+    glyphRef: null,
+    gradientTransform: null,
+    gradientUnits: null,
+    handler: null,
+    hanging: number,
+    hatchContentUnits: null,
+    hatchUnits: null,
+    height: null,
+    href: null,
+    hrefLang: null,
+    horizAdvX: number,
+    horizOriginX: number,
+    horizOriginY: number,
+    id: null,
+    ideographic: number,
+    imageRendering: null,
+    initialVisibility: null,
+    in: null,
+    in2: null,
+    intercept: number,
+    k: number,
+    k1: number,
+    k2: number,
+    k3: number,
+    k4: number,
+    kernelMatrix: commaOrSpaceSeparated,
+    kernelUnitLength: null,
+    keyPoints: null,
+    // SEMI_COLON_SEPARATED
+    keySplines: null,
+    // SEMI_COLON_SEPARATED
+    keyTimes: null,
+    // SEMI_COLON_SEPARATED
+    kerning: null,
+    lang: null,
+    lengthAdjust: null,
+    letterSpacing: null,
+    lightingColor: null,
+    limitingConeAngle: number,
+    local: null,
+    markerEnd: null,
+    markerMid: null,
+    markerStart: null,
+    markerHeight: null,
+    markerUnits: null,
+    markerWidth: null,
+    mask: null,
+    maskContentUnits: null,
+    maskType: null,
+    maskUnits: null,
+    mathematical: null,
+    max: null,
+    media: null,
+    mediaCharacterEncoding: null,
+    mediaContentEncodings: null,
+    mediaSize: number,
+    mediaTime: null,
+    method: null,
+    min: null,
+    mode: null,
+    name: null,
+    navDown: null,
+    navDownLeft: null,
+    navDownRight: null,
+    navLeft: null,
+    navNext: null,
+    navPrev: null,
+    navRight: null,
+    navUp: null,
+    navUpLeft: null,
+    navUpRight: null,
+    numOctaves: null,
+    observer: null,
+    offset: null,
+    onAbort: null,
+    onActivate: null,
+    onAfterPrint: null,
+    onBeforePrint: null,
+    onBegin: null,
+    onCancel: null,
+    onCanPlay: null,
+    onCanPlayThrough: null,
+    onChange: null,
+    onClick: null,
+    onClose: null,
+    onCopy: null,
+    onCueChange: null,
+    onCut: null,
+    onDblClick: null,
+    onDrag: null,
+    onDragEnd: null,
+    onDragEnter: null,
+    onDragExit: null,
+    onDragLeave: null,
+    onDragOver: null,
+    onDragStart: null,
+    onDrop: null,
+    onDurationChange: null,
+    onEmptied: null,
+    onEnd: null,
+    onEnded: null,
+    onError: null,
+    onFocus: null,
+    onFocusIn: null,
+    onFocusOut: null,
+    onHashChange: null,
+    onInput: null,
+    onInvalid: null,
+    onKeyDown: null,
+    onKeyPress: null,
+    onKeyUp: null,
+    onLoad: null,
+    onLoadedData: null,
+    onLoadedMetadata: null,
+    onLoadStart: null,
+    onMessage: null,
+    onMouseDown: null,
+    onMouseEnter: null,
+    onMouseLeave: null,
+    onMouseMove: null,
+    onMouseOut: null,
+    onMouseOver: null,
+    onMouseUp: null,
+    onMouseWheel: null,
+    onOffline: null,
+    onOnline: null,
+    onPageHide: null,
+    onPageShow: null,
+    onPaste: null,
+    onPause: null,
+    onPlay: null,
+    onPlaying: null,
+    onPopState: null,
+    onProgress: null,
+    onRateChange: null,
+    onRepeat: null,
+    onReset: null,
+    onResize: null,
+    onScroll: null,
+    onSeeked: null,
+    onSeeking: null,
+    onSelect: null,
+    onShow: null,
+    onStalled: null,
+    onStorage: null,
+    onSubmit: null,
+    onSuspend: null,
+    onTimeUpdate: null,
+    onToggle: null,
+    onUnload: null,
+    onVolumeChange: null,
+    onWaiting: null,
+    onZoom: null,
+    opacity: null,
+    operator: null,
+    order: null,
+    orient: null,
+    orientation: null,
+    origin: null,
+    overflow: null,
+    overlay: null,
+    overlinePosition: number,
+    overlineThickness: number,
+    paintOrder: null,
+    panose1: null,
+    path: null,
+    pathLength: number,
+    patternContentUnits: null,
+    patternTransform: null,
+    patternUnits: null,
+    phase: null,
+    ping: spaceSeparated,
+    pitch: null,
+    playbackOrder: null,
+    pointerEvents: null,
+    points: null,
+    pointsAtX: number,
+    pointsAtY: number,
+    pointsAtZ: number,
+    preserveAlpha: null,
+    preserveAspectRatio: null,
+    primitiveUnits: null,
+    propagate: null,
+    property: commaOrSpaceSeparated,
+    r: null,
+    radius: null,
+    referrerPolicy: null,
+    refX: null,
+    refY: null,
+    rel: commaOrSpaceSeparated,
+    rev: commaOrSpaceSeparated,
+    renderingIntent: null,
+    repeatCount: null,
+    repeatDur: null,
+    requiredExtensions: commaOrSpaceSeparated,
+    requiredFeatures: commaOrSpaceSeparated,
+    requiredFonts: commaOrSpaceSeparated,
+    requiredFormats: commaOrSpaceSeparated,
+    resource: null,
+    restart: null,
+    result: null,
+    rotate: null,
+    rx: null,
+    ry: null,
+    scale: null,
+    seed: null,
+    shapeRendering: null,
+    side: null,
+    slope: null,
+    snapshotTime: null,
+    specularConstant: number,
+    specularExponent: number,
+    spreadMethod: null,
+    spacing: null,
+    startOffset: null,
+    stdDeviation: null,
+    stemh: null,
+    stemv: null,
+    stitchTiles: null,
+    stopColor: null,
+    stopOpacity: null,
+    strikethroughPosition: number,
+    strikethroughThickness: number,
+    string: null,
+    stroke: null,
+    strokeDashArray: commaOrSpaceSeparated,
+    strokeDashOffset: null,
+    strokeLineCap: null,
+    strokeLineJoin: null,
+    strokeMiterLimit: number,
+    strokeOpacity: number,
+    strokeWidth: null,
+    style: null,
+    surfaceScale: number,
+    syncBehavior: null,
+    syncBehaviorDefault: null,
+    syncMaster: null,
+    syncTolerance: null,
+    syncToleranceDefault: null,
+    systemLanguage: commaOrSpaceSeparated,
+    tabIndex: number,
+    tableValues: null,
+    target: null,
+    targetX: number,
+    targetY: number,
+    textAnchor: null,
+    textDecoration: null,
+    textRendering: null,
+    textLength: null,
+    timelineBegin: null,
+    title: null,
+    transformBehavior: null,
+    type: null,
+    typeOf: commaOrSpaceSeparated,
+    to: null,
+    transform: null,
+    transformOrigin: null,
+    u1: null,
+    u2: null,
+    underlinePosition: number,
+    underlineThickness: number,
+    unicode: null,
+    unicodeBidi: null,
+    unicodeRange: null,
+    unitsPerEm: number,
+    values: null,
+    vAlphabetic: number,
+    vMathematical: number,
+    vectorEffect: null,
+    vHanging: number,
+    vIdeographic: number,
+    version: null,
+    vertAdvY: number,
+    vertOriginX: number,
+    vertOriginY: number,
+    viewBox: null,
+    viewTarget: null,
+    visibility: null,
+    width: null,
+    widths: null,
+    wordSpacing: null,
+    writingMode: null,
+    x: null,
+    x1: null,
+    x2: null,
+    xChannelSelector: null,
+    xHeight: number,
+    y: null,
+    y1: null,
+    y2: null,
+    yChannelSelector: null,
+    z: null,
+    zoomAndPan: null
+  },
+  space: "svg",
+  transform: caseSensitiveTransform
+});
+
+// node_modules/property-information/lib/xlink.js
+var xlink = create({
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  },
+  space: "xlink",
+  transform(_, property) {
+    return "xlink:" + property.slice(5).toLowerCase();
+  }
+});
+
+// node_modules/property-information/lib/xmlns.js
+var xmlns = create({
+  attributes: { xmlnsxlink: "xmlns:xlink" },
+  properties: { xmlnsXLink: null, xmlns: null },
+  space: "xmlns",
+  transform: caseInsensitiveTransform
+});
+
+// node_modules/property-information/lib/xml.js
+var xml = create({
+  properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
+  space: "xml",
+  transform(_, property) {
+    return "xml:" + property.slice(3).toLowerCase();
+  }
+});
+
+// node_modules/property-information/lib/find.js
+var cap = /[A-Z]/g;
+var dash = /-[a-z]/g;
+var valid = /^data[-\w.:]+$/i;
+function find(schema, value) {
+  const normal = normalize(value);
+  let property = value;
+  let Type = Info;
+  if (normal in schema.normal) {
+    return schema.property[schema.normal[normal]];
+  }
+  if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value)) {
+    if (value.charAt(4) === "-") {
+      const rest = value.slice(5).replace(dash, camelcase);
+      property = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
+    } else {
+      const rest = value.slice(4);
+      if (!dash.test(rest)) {
+        let dashes = rest.replace(cap, kebab);
+        if (dashes.charAt(0) !== "-") {
+          dashes = "-" + dashes;
+        }
+        value = "data" + dashes;
+      }
+    }
+    Type = DefinedInfo;
+  }
+  return new Type(property, value);
+}
+function kebab($0) {
+  return "-" + $0.toLowerCase();
+}
+function camelcase($0) {
+  return $0.charAt(1).toUpperCase();
+}
+
+// node_modules/property-information/index.js
+var html2 = merge([aria, html, xlink, xmlns, xml], "html");
+var svg2 = merge([aria, svg, xlink, xmlns, xml], "svg");
+
+// node_modules/zwitch/index.js
+var own = {}.hasOwnProperty;
+function zwitch(key2, options) {
+  const settings = options || {};
+  function one2(value, ...parameters) {
+    let fn = one2.invalid;
+    const handlers = one2.handlers;
+    if (value && own.call(value, key2)) {
+      const id = String(value[key2]);
+      fn = own.call(handlers, id) ? handlers[id] : one2.unknown;
+    }
+    if (fn) {
+      return fn.call(this, value, ...parameters);
+    }
+  }
+  one2.handlers = settings.handlers || {};
+  one2.invalid = settings.invalid;
+  one2.unknown = settings.unknown;
+  return one2;
+}
+
+// node_modules/stringify-entities/lib/core.js
+var defaultSubsetRegex = /["&'<>`]/g;
+var surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+var controlCharactersRegex = (
+  // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
+  /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
+);
+var regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g;
+var subsetToRegexCache = /* @__PURE__ */ new WeakMap();
+function core(value, options) {
+  value = value.replace(
+    options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex,
+    basic
+  );
+  if (options.subset || options.escapeOnly) {
+    return value;
+  }
+  return value.replace(surrogatePairsRegex, surrogate).replace(controlCharactersRegex, basic);
+  function surrogate(pair, index, all2) {
+    return options.format(
+      (pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536,
+      all2.charCodeAt(index + 2),
+      options
+    );
+  }
+  function basic(character, index, all2) {
+    return options.format(
+      character.charCodeAt(0),
+      all2.charCodeAt(index + 1),
+      options
+    );
+  }
+}
+function charactersToExpressionCached(subset) {
+  let cached = subsetToRegexCache.get(subset);
+  if (!cached) {
+    cached = charactersToExpression(subset);
+    subsetToRegexCache.set(subset, cached);
+  }
+  return cached;
+}
+function charactersToExpression(subset) {
+  const groups = [];
+  let index = -1;
+  while (++index < subset.length) {
+    groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
+  }
+  return new RegExp("(?:" + groups.join("|") + ")", "g");
+}
+
+// node_modules/stringify-entities/lib/util/to-hexadecimal.js
+var hexadecimalRegex = /[\dA-Fa-f]/;
+function toHexadecimal(code, next, omit) {
+  const value = "&#x" + code.toString(16).toUpperCase();
+  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+}
+
+// node_modules/stringify-entities/lib/util/to-decimal.js
+var decimalRegex = /\d/;
+function toDecimal(code, next, omit) {
+  const value = "&#" + String(code);
+  return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+}
+
+// node_modules/character-entities-legacy/index.js
+var characterEntitiesLegacy = [
+  "AElig",
+  "AMP",
+  "Aacute",
+  "Acirc",
+  "Agrave",
+  "Aring",
+  "Atilde",
+  "Auml",
+  "COPY",
+  "Ccedil",
+  "ETH",
+  "Eacute",
+  "Ecirc",
+  "Egrave",
+  "Euml",
+  "GT",
+  "Iacute",
+  "Icirc",
+  "Igrave",
+  "Iuml",
+  "LT",
+  "Ntilde",
+  "Oacute",
+  "Ocirc",
+  "Ograve",
+  "Oslash",
+  "Otilde",
+  "Ouml",
+  "QUOT",
+  "REG",
+  "THORN",
+  "Uacute",
+  "Ucirc",
+  "Ugrave",
+  "Uuml",
+  "Yacute",
+  "aacute",
+  "acirc",
+  "acute",
+  "aelig",
+  "agrave",
+  "amp",
+  "aring",
+  "atilde",
+  "auml",
+  "brvbar",
+  "ccedil",
+  "cedil",
+  "cent",
+  "copy",
+  "curren",
+  "deg",
+  "divide",
+  "eacute",
+  "ecirc",
+  "egrave",
+  "eth",
+  "euml",
+  "frac12",
+  "frac14",
+  "frac34",
+  "gt",
+  "iacute",
+  "icirc",
+  "iexcl",
+  "igrave",
+  "iquest",
+  "iuml",
+  "laquo",
+  "lt",
+  "macr",
+  "micro",
+  "middot",
+  "nbsp",
+  "not",
+  "ntilde",
+  "oacute",
+  "ocirc",
+  "ograve",
+  "ordf",
+  "ordm",
+  "oslash",
+  "otilde",
+  "ouml",
+  "para",
+  "plusmn",
+  "pound",
+  "quot",
+  "raquo",
+  "reg",
+  "sect",
+  "shy",
+  "sup1",
+  "sup2",
+  "sup3",
+  "szlig",
+  "thorn",
+  "times",
+  "uacute",
+  "ucirc",
+  "ugrave",
+  "uml",
+  "uuml",
+  "yacute",
+  "yen",
+  "yuml"
+];
+
+// node_modules/character-entities-html4/index.js
+var characterEntitiesHtml4 = {
+  nbsp: "\xA0",
+  iexcl: "\xA1",
+  cent: "\xA2",
+  pound: "\xA3",
+  curren: "\xA4",
+  yen: "\xA5",
+  brvbar: "\xA6",
+  sect: "\xA7",
+  uml: "\xA8",
+  copy: "\xA9",
+  ordf: "\xAA",
+  laquo: "\xAB",
+  not: "\xAC",
+  shy: "\xAD",
+  reg: "\xAE",
+  macr: "\xAF",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  acute: "\xB4",
+  micro: "\xB5",
+  para: "\xB6",
+  middot: "\xB7",
+  cedil: "\xB8",
+  sup1: "\xB9",
+  ordm: "\xBA",
+  raquo: "\xBB",
+  frac14: "\xBC",
+  frac12: "\xBD",
+  frac34: "\xBE",
+  iquest: "\xBF",
+  Agrave: "\xC0",
+  Aacute: "\xC1",
+  Acirc: "\xC2",
+  Atilde: "\xC3",
+  Auml: "\xC4",
+  Aring: "\xC5",
+  AElig: "\xC6",
+  Ccedil: "\xC7",
+  Egrave: "\xC8",
+  Eacute: "\xC9",
+  Ecirc: "\xCA",
+  Euml: "\xCB",
+  Igrave: "\xCC",
+  Iacute: "\xCD",
+  Icirc: "\xCE",
+  Iuml: "\xCF",
+  ETH: "\xD0",
+  Ntilde: "\xD1",
+  Ograve: "\xD2",
+  Oacute: "\xD3",
+  Ocirc: "\xD4",
+  Otilde: "\xD5",
+  Ouml: "\xD6",
+  times: "\xD7",
+  Oslash: "\xD8",
+  Ugrave: "\xD9",
+  Uacute: "\xDA",
+  Ucirc: "\xDB",
+  Uuml: "\xDC",
+  Yacute: "\xDD",
+  THORN: "\xDE",
+  szlig: "\xDF",
+  agrave: "\xE0",
+  aacute: "\xE1",
+  acirc: "\xE2",
+  atilde: "\xE3",
+  auml: "\xE4",
+  aring: "\xE5",
+  aelig: "\xE6",
+  ccedil: "\xE7",
+  egrave: "\xE8",
+  eacute: "\xE9",
+  ecirc: "\xEA",
+  euml: "\xEB",
+  igrave: "\xEC",
+  iacute: "\xED",
+  icirc: "\xEE",
+  iuml: "\xEF",
+  eth: "\xF0",
+  ntilde: "\xF1",
+  ograve: "\xF2",
+  oacute: "\xF3",
+  ocirc: "\xF4",
+  otilde: "\xF5",
+  ouml: "\xF6",
+  divide: "\xF7",
+  oslash: "\xF8",
+  ugrave: "\xF9",
+  uacute: "\xFA",
+  ucirc: "\xFB",
+  uuml: "\xFC",
+  yacute: "\xFD",
+  thorn: "\xFE",
+  yuml: "\xFF",
+  fnof: "\u0192",
+  Alpha: "\u0391",
+  Beta: "\u0392",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Epsilon: "\u0395",
+  Zeta: "\u0396",
+  Eta: "\u0397",
+  Theta: "\u0398",
+  Iota: "\u0399",
+  Kappa: "\u039A",
+  Lambda: "\u039B",
+  Mu: "\u039C",
+  Nu: "\u039D",
+  Xi: "\u039E",
+  Omicron: "\u039F",
+  Pi: "\u03A0",
+  Rho: "\u03A1",
+  Sigma: "\u03A3",
+  Tau: "\u03A4",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Chi: "\u03A7",
+  Psi: "\u03A8",
+  Omega: "\u03A9",
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigmaf: "\u03C2",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  thetasym: "\u03D1",
+  upsih: "\u03D2",
+  piv: "\u03D6",
+  bull: "\u2022",
+  hellip: "\u2026",
+  prime: "\u2032",
+  Prime: "\u2033",
+  oline: "\u203E",
+  frasl: "\u2044",
+  weierp: "\u2118",
+  image: "\u2111",
+  real: "\u211C",
+  trade: "\u2122",
+  alefsym: "\u2135",
+  larr: "\u2190",
+  uarr: "\u2191",
+  rarr: "\u2192",
+  darr: "\u2193",
+  harr: "\u2194",
+  crarr: "\u21B5",
+  lArr: "\u21D0",
+  uArr: "\u21D1",
+  rArr: "\u21D2",
+  dArr: "\u21D3",
+  hArr: "\u21D4",
+  forall: "\u2200",
+  part: "\u2202",
+  exist: "\u2203",
+  empty: "\u2205",
+  nabla: "\u2207",
+  isin: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  prod: "\u220F",
+  sum: "\u2211",
+  minus: "\u2212",
+  lowast: "\u2217",
+  radic: "\u221A",
+  prop: "\u221D",
+  infin: "\u221E",
+  ang: "\u2220",
+  and: "\u2227",
+  or: "\u2228",
+  cap: "\u2229",
+  cup: "\u222A",
+  int: "\u222B",
+  there4: "\u2234",
+  sim: "\u223C",
+  cong: "\u2245",
+  asymp: "\u2248",
+  ne: "\u2260",
+  equiv: "\u2261",
+  le: "\u2264",
+  ge: "\u2265",
+  sub: "\u2282",
+  sup: "\u2283",
+  nsub: "\u2284",
+  sube: "\u2286",
+  supe: "\u2287",
+  oplus: "\u2295",
+  otimes: "\u2297",
+  perp: "\u22A5",
+  sdot: "\u22C5",
+  lceil: "\u2308",
+  rceil: "\u2309",
+  lfloor: "\u230A",
+  rfloor: "\u230B",
+  lang: "\u2329",
+  rang: "\u232A",
+  loz: "\u25CA",
+  spades: "\u2660",
+  clubs: "\u2663",
+  hearts: "\u2665",
+  diams: "\u2666",
+  quot: '"',
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  OElig: "\u0152",
+  oelig: "\u0153",
+  Scaron: "\u0160",
+  scaron: "\u0161",
+  Yuml: "\u0178",
+  circ: "\u02C6",
+  tilde: "\u02DC",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  thinsp: "\u2009",
+  zwnj: "\u200C",
+  zwj: "\u200D",
+  lrm: "\u200E",
+  rlm: "\u200F",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  dagger: "\u2020",
+  Dagger: "\u2021",
+  permil: "\u2030",
+  lsaquo: "\u2039",
+  rsaquo: "\u203A",
+  euro: "\u20AC"
+};
+
+// node_modules/stringify-entities/lib/constant/dangerous.js
+var dangerous = [
+  "cent",
+  "copy",
+  "divide",
+  "gt",
+  "lt",
+  "not",
+  "para",
+  "times"
+];
+
+// node_modules/stringify-entities/lib/util/to-named.js
+var own2 = {}.hasOwnProperty;
+var characters = {};
+var key;
+for (key in characterEntitiesHtml4) {
+  if (own2.call(characterEntitiesHtml4, key)) {
+    characters[characterEntitiesHtml4[key]] = key;
+  }
+}
+var notAlphanumericRegex = /[^\dA-Za-z]/;
+function toNamed(code, next, omit, attribute) {
+  const character = String.fromCharCode(code);
+  if (own2.call(characters, character)) {
+    const name = characters[character];
+    const value = "&" + name;
+    if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) {
+      return value;
+    }
+    return value + ";";
+  }
+  return "";
+}
+
+// node_modules/stringify-entities/lib/util/format-smart.js
+function formatSmart(code, next, options) {
+  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
+  let named;
+  if (options.useNamedReferences || options.useShortestReferences) {
+    named = toNamed(
+      code,
+      next,
+      options.omitOptionalSemicolons,
+      options.attribute
+    );
+  }
+  if ((options.useShortestReferences || !named) && options.useShortestReferences) {
+    const decimal = toDecimal(code, next, options.omitOptionalSemicolons);
+    if (decimal.length < numeric.length) {
+      numeric = decimal;
+    }
+  }
+  return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
+}
+
+// node_modules/stringify-entities/lib/index.js
+function stringifyEntities(value, options) {
+  return core(value, Object.assign({ format: formatSmart }, options));
+}
+
+// node_modules/hast-util-to-html/lib/handle/comment.js
+var htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
+var bogusCommentEntitySubset = [">"];
+var commentEntitySubset = ["<", ">"];
+function comment(node, _1, _2, state) {
+  return state.settings.bogusComments ? "<?" + stringifyEntities(
+    node.value,
+    Object.assign({}, state.settings.characterReferences, {
+      subset: bogusCommentEntitySubset
+    })
+  ) + ">" : "<!--" + node.value.replace(htmlCommentRegex, encode) + "-->";
+  function encode($0) {
+    return stringifyEntities(
+      $0,
+      Object.assign({}, state.settings.characterReferences, {
+        subset: commentEntitySubset
+      })
+    );
+  }
+}
+
+// node_modules/hast-util-to-html/lib/handle/doctype.js
+function doctype(_1, _2, _3, state) {
+  return "<!" + (state.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state.settings.tightDoctype ? "" : " ") + "html>";
+}
+
+// node_modules/ccount/index.js
+function ccount(value, character) {
+  const source = String(value);
+  if (typeof character !== "string") {
+    throw new TypeError("Expected character");
+  }
+  let count = 0;
+  let index = source.indexOf(character);
+  while (index !== -1) {
+    count++;
+    index = source.indexOf(character, index + character.length);
+  }
+  return count;
+}
+
+// node_modules/comma-separated-tokens/index.js
+function stringify(values, options) {
+  const settings = options || {};
+  const input = values[values.length - 1] === "" ? [...values, ""] : values;
+  return input.join(
+    (settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
+  ).trim();
+}
+
+// node_modules/space-separated-tokens/index.js
+function stringify2(values) {
+  return values.join(" ").trim();
+}
+
+// node_modules/hast-util-whitespace/lib/index.js
+var re = /[ \t\n\f\r]/g;
+function whitespace(thing) {
+  return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
+}
+function empty(value) {
+  return value.replace(re, "") === "";
+}
+
+// node_modules/hast-util-to-html/lib/omission/util/siblings.js
+var siblingAfter = siblings(1);
+var siblingBefore = siblings(-1);
+var emptyChildren = [];
+function siblings(increment2) {
+  return sibling;
+  function sibling(parent, index, includeWhitespace) {
+    const siblings2 = parent ? parent.children : emptyChildren;
+    let offset = (index || 0) + increment2;
+    let next = siblings2[offset];
+    if (!includeWhitespace) {
+      while (next && whitespace(next)) {
+        offset += increment2;
+        next = siblings2[offset];
+      }
+    }
+    return next;
+  }
+}
+
+// node_modules/hast-util-to-html/lib/omission/omission.js
+var own3 = {}.hasOwnProperty;
+function omission(handlers) {
+  return omit;
+  function omit(node, index, parent) {
+    return own3.call(handlers, node.tagName) && handlers[node.tagName](node, index, parent);
+  }
+}
+
+// node_modules/hast-util-to-html/lib/omission/closing.js
+var closing = omission({
+  body,
+  caption: headOrColgroupOrCaption,
+  colgroup: headOrColgroupOrCaption,
+  dd,
+  dt,
+  head: headOrColgroupOrCaption,
+  html: html3,
+  li,
+  optgroup,
+  option,
+  p,
+  rp: rubyElement,
+  rt: rubyElement,
+  tbody,
+  td: cells,
+  tfoot,
+  th: cells,
+  thead,
+  tr
+});
+function headOrColgroupOrCaption(_, index, parent) {
+  const next = siblingAfter(parent, index, true);
+  return !next || next.type !== "comment" && !(next.type === "text" && whitespace(next.value.charAt(0)));
+}
+function html3(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type !== "comment";
+}
+function body(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type !== "comment";
+}
+function p(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return next ? next.type === "element" && (next.tagName === "address" || next.tagName === "article" || next.tagName === "aside" || next.tagName === "blockquote" || next.tagName === "details" || next.tagName === "div" || next.tagName === "dl" || next.tagName === "fieldset" || next.tagName === "figcaption" || next.tagName === "figure" || next.tagName === "footer" || next.tagName === "form" || next.tagName === "h1" || next.tagName === "h2" || next.tagName === "h3" || next.tagName === "h4" || next.tagName === "h5" || next.tagName === "h6" || next.tagName === "header" || next.tagName === "hgroup" || next.tagName === "hr" || next.tagName === "main" || next.tagName === "menu" || next.tagName === "nav" || next.tagName === "ol" || next.tagName === "p" || next.tagName === "pre" || next.tagName === "section" || next.tagName === "table" || next.tagName === "ul") : !parent || // Confusing parent.
+  !(parent.type === "element" && (parent.tagName === "a" || parent.tagName === "audio" || parent.tagName === "del" || parent.tagName === "ins" || parent.tagName === "map" || parent.tagName === "noscript" || parent.tagName === "video"));
+}
+function li(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && next.tagName === "li";
+}
+function dt(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return Boolean(
+    next && next.type === "element" && (next.tagName === "dt" || next.tagName === "dd")
+  );
+}
+function dd(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && (next.tagName === "dt" || next.tagName === "dd");
+}
+function rubyElement(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && (next.tagName === "rp" || next.tagName === "rt");
+}
+function optgroup(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && next.tagName === "optgroup";
+}
+function option(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && (next.tagName === "option" || next.tagName === "optgroup");
+}
+function thead(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return Boolean(
+    next && next.type === "element" && (next.tagName === "tbody" || next.tagName === "tfoot")
+  );
+}
+function tbody(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && (next.tagName === "tbody" || next.tagName === "tfoot");
+}
+function tfoot(_, index, parent) {
+  return !siblingAfter(parent, index);
+}
+function tr(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && next.tagName === "tr";
+}
+function cells(_, index, parent) {
+  const next = siblingAfter(parent, index);
+  return !next || next.type === "element" && (next.tagName === "td" || next.tagName === "th");
+}
+
+// node_modules/hast-util-to-html/lib/omission/opening.js
+var opening = omission({
+  body: body2,
+  colgroup,
+  head,
+  html: html4,
+  tbody: tbody2
+});
+function html4(node) {
+  const head2 = siblingAfter(node, -1);
+  return !head2 || head2.type !== "comment";
+}
+function head(node) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const child2 of node.children) {
+    if (child2.type === "element" && (child2.tagName === "base" || child2.tagName === "title")) {
+      if (seen.has(child2.tagName)) return false;
+      seen.add(child2.tagName);
+    }
+  }
+  const child = node.children[0];
+  return !child || child.type === "element";
+}
+function body2(node) {
+  const head2 = siblingAfter(node, -1, true);
+  return !head2 || head2.type !== "comment" && !(head2.type === "text" && whitespace(head2.value.charAt(0))) && !(head2.type === "element" && (head2.tagName === "meta" || head2.tagName === "link" || head2.tagName === "script" || head2.tagName === "style" || head2.tagName === "template"));
+}
+function colgroup(node, index, parent) {
+  const previous = siblingBefore(parent, index);
+  const head2 = siblingAfter(node, -1, true);
+  if (parent && previous && previous.type === "element" && previous.tagName === "colgroup" && closing(previous, parent.children.indexOf(previous), parent)) {
+    return false;
+  }
+  return Boolean(head2 && head2.type === "element" && head2.tagName === "col");
+}
+function tbody2(node, index, parent) {
+  const previous = siblingBefore(parent, index);
+  const head2 = siblingAfter(node, -1);
+  if (parent && previous && previous.type === "element" && (previous.tagName === "thead" || previous.tagName === "tbody") && closing(previous, parent.children.indexOf(previous), parent)) {
+    return false;
+  }
+  return Boolean(head2 && head2.type === "element" && head2.tagName === "tr");
+}
+
+// node_modules/hast-util-to-html/lib/handle/element.js
+var constants = {
+  // See: <https://html.spec.whatwg.org/#attribute-name-state>.
+  name: [
+    ["	\n\f\r &/=>".split(""), "	\n\f\r \"&'/=>`".split("")],
+    [`\0	
+\f\r "&'/<=>`.split(""), "\0	\n\f\r \"&'/<=>`".split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.
+  unquoted: [
+    ["	\n\f\r &>".split(""), "\0	\n\f\r \"&'<=>`".split("")],
+    ["\0	\n\f\r \"&'<=>`".split(""), "\0	\n\f\r \"&'<=>`".split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.
+  single: [
+    ["&'".split(""), "\"&'`".split("")],
+    ["\0&'".split(""), "\0\"&'`".split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.
+  double: [
+    ['"&'.split(""), "\"&'`".split("")],
+    ['\0"&'.split(""), "\0\"&'`".split("")]
+  ]
+};
+function element(node, index, parent, state) {
+  const schema = state.schema;
+  const omit = schema.space === "svg" ? false : state.settings.omitOptionalTags;
+  let selfClosing = schema.space === "svg" ? state.settings.closeEmptyElements : state.settings.voids.includes(node.tagName.toLowerCase());
+  const parts = [];
+  let last;
+  if (schema.space === "html" && node.tagName === "svg") {
+    state.schema = svg2;
+  }
+  const attributes = serializeAttributes(state, node.properties);
+  const content = state.all(
+    schema.space === "html" && node.tagName === "template" ? node.content : node
+  );
+  state.schema = schema;
+  if (content) selfClosing = false;
+  if (attributes || !omit || !opening(node, index, parent)) {
+    parts.push("<", node.tagName, attributes ? " " + attributes : "");
+    if (selfClosing && (schema.space === "svg" || state.settings.closeSelfClosing)) {
+      last = attributes.charAt(attributes.length - 1);
+      if (!state.settings.tightSelfClosing || last === "/" || last && last !== '"' && last !== "'") {
+        parts.push(" ");
+      }
+      parts.push("/");
+    }
+    parts.push(">");
+  }
+  parts.push(content);
+  if (!selfClosing && (!omit || !closing(node, index, parent))) {
+    parts.push("</" + node.tagName + ">");
+  }
+  return parts.join("");
+}
+function serializeAttributes(state, properties) {
+  const values = [];
+  let index = -1;
+  let key2;
+  if (properties) {
+    for (key2 in properties) {
+      if (properties[key2] !== null && properties[key2] !== void 0) {
+        const value = serializeAttribute(state, key2, properties[key2]);
+        if (value) values.push(value);
+      }
+    }
+  }
+  while (++index < values.length) {
+    const last = state.settings.tightAttributes ? values[index].charAt(values[index].length - 1) : void 0;
+    if (index !== values.length - 1 && last !== '"' && last !== "'") {
+      values[index] += " ";
+    }
+  }
+  return values.join("");
+}
+function serializeAttribute(state, key2, value) {
+  const info = find(state.schema, key2);
+  const x = state.settings.allowParseErrors && state.schema.space === "html" ? 0 : 1;
+  const y = state.settings.allowDangerousCharacters ? 0 : 1;
+  let quote = state.quote;
+  let result;
+  if (info.overloadedBoolean && (value === info.attribute || value === "")) {
+    value = true;
+  } else if ((info.boolean || info.overloadedBoolean) && (typeof value !== "string" || value === info.attribute || value === "")) {
+    value = Boolean(value);
+  }
+  if (value === null || value === void 0 || value === false || typeof value === "number" && Number.isNaN(value)) {
+    return "";
+  }
+  const name = stringifyEntities(
+    info.attribute,
+    Object.assign({}, state.settings.characterReferences, {
+      // Always encode without parse errors in non-HTML.
+      subset: constants.name[x][y]
+    })
+  );
+  if (value === true) return name;
+  value = Array.isArray(value) ? (info.commaSeparated ? stringify : stringify2)(value, {
+    padLeft: !state.settings.tightCommaSeparatedLists
+  }) : String(value);
+  if (state.settings.collapseEmptyAttributes && !value) return name;
+  if (state.settings.preferUnquoted) {
+    result = stringifyEntities(
+      value,
+      Object.assign({}, state.settings.characterReferences, {
+        attribute: true,
+        subset: constants.unquoted[x][y]
+      })
+    );
+  }
+  if (result !== value) {
+    if (state.settings.quoteSmart && ccount(value, quote) > ccount(value, state.alternative)) {
+      quote = state.alternative;
+    }
+    result = quote + stringifyEntities(
+      value,
+      Object.assign({}, state.settings.characterReferences, {
+        // Always encode without parse errors in non-HTML.
+        subset: (quote === "'" ? constants.single : constants.double)[x][y],
+        attribute: true
+      })
+    ) + quote;
+  }
+  return name + (result ? "=" + result : result);
+}
+
+// node_modules/hast-util-to-html/lib/handle/text.js
+var textEntitySubset = ["<", "&"];
+function text(node, _, parent, state) {
+  return parent && parent.type === "element" && (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(
+    node.value,
+    Object.assign({}, state.settings.characterReferences, {
+      subset: textEntitySubset
+    })
+  );
+}
+
+// node_modules/hast-util-to-html/lib/handle/raw.js
+function raw(node, index, parent, state) {
+  return state.settings.allowDangerousHtml ? node.value : text(node, index, parent, state);
+}
+
+// node_modules/hast-util-to-html/lib/handle/root.js
+function root(node, _1, _2, state) {
+  return state.all(node);
+}
+
+// node_modules/hast-util-to-html/lib/handle/index.js
+var handle = zwitch("type", {
+  invalid,
+  unknown,
+  handlers: { comment, doctype, element, raw, root, text }
+});
+function invalid(node) {
+  throw new Error("Expected node, not `" + node + "`");
+}
+function unknown(node_) {
+  const node = (
+    /** @type {Nodes} */
+    node_
+  );
+  throw new Error("Cannot compile unknown node `" + node.type + "`");
+}
+
+// node_modules/hast-util-to-html/lib/index.js
+var emptyOptions = {};
+var emptyCharacterReferences = {};
+var emptyChildren2 = [];
+function toHtml(tree, options) {
+  const options_ = options || emptyOptions;
+  const quote = options_.quote || '"';
+  const alternative = quote === '"' ? "'" : '"';
+  if (quote !== '"' && quote !== "'") {
+    throw new Error("Invalid quote `" + quote + "`, expected `'` or `\"`");
+  }
+  const state = {
+    one,
+    all,
+    settings: {
+      omitOptionalTags: options_.omitOptionalTags || false,
+      allowParseErrors: options_.allowParseErrors || false,
+      allowDangerousCharacters: options_.allowDangerousCharacters || false,
+      quoteSmart: options_.quoteSmart || false,
+      preferUnquoted: options_.preferUnquoted || false,
+      tightAttributes: options_.tightAttributes || false,
+      upperDoctype: options_.upperDoctype || false,
+      tightDoctype: options_.tightDoctype || false,
+      bogusComments: options_.bogusComments || false,
+      tightCommaSeparatedLists: options_.tightCommaSeparatedLists || false,
+      tightSelfClosing: options_.tightSelfClosing || false,
+      collapseEmptyAttributes: options_.collapseEmptyAttributes || false,
+      allowDangerousHtml: options_.allowDangerousHtml || false,
+      voids: options_.voids || htmlVoidElements,
+      characterReferences: options_.characterReferences || emptyCharacterReferences,
+      closeSelfClosing: options_.closeSelfClosing || false,
+      closeEmptyElements: options_.closeEmptyElements || false
+    },
+    schema: options_.space === "svg" ? svg2 : html2,
+    quote,
+    alternative
+  };
+  return state.one(
+    Array.isArray(tree) ? { type: "root", children: tree } : tree,
+    void 0,
+    void 0
+  );
+}
+function one(node, index, parent) {
+  return handle(node, index, parent, this);
+}
+function all(parent) {
+  const results = [];
+  const children = parent && parent.children || emptyChildren2;
+  let index = -1;
+  while (++index < children.length) {
+    results[index] = this.one(children[index], index, parent);
+  }
+  return results.join("");
+}
+
+// node_modules/@pierre/diffs/dist/utils/hastToHtml.js
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var DELEGATED_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "template",
+  "script",
+  "style"
+]);
+var ATTRIBUTE_NAMES = {
+  class: "class",
+  className: "class",
+  id: "id",
+  role: "role",
+  style: "style",
+  tabIndex: "tabindex",
+  tabindex: "tabindex",
+  title: "title"
+};
+var DATA_ATTRIBUTE = /^data-[\w.:-]+$/;
+var TEXT_ESCAPE = /[<&]/g;
+var ATTRIBUTE_ESCAPE = /[\0"&'`]/g;
+var CHARACTER_REFERENCES = {
+  "<": "&#x3C;",
+  "&": "&#x26;",
+  '"': "&#x22;",
+  "'": "&#x27;",
+  "`": "&#x60;",
+  "\0": "&#x0;"
+};
+var MAX_CACHED_STYLES = 256;
+function hastToHtml(tree) {
+  const styles = /* @__PURE__ */ new Map();
+  return Array.isArray(tree) ? serializeChildren(tree, styles) : serializeNode(tree, styles);
+}
+function serializeChildren(children, styles) {
+  let html5 = "";
+  for (const child of children) html5 += serializeNode(child, styles);
+  return html5;
+}
+function serializeNode(node, styles) {
+  switch (node.type) {
+    case "text":
+      return escapeText(node.value);
+    case "element":
+      return serializeElement(node, styles);
+    case "root":
+      return serializeChildren(node.children, styles);
+    default:
+      return toHtml(node);
+  }
+}
+function serializeElement(node, styles) {
+  const { tagName } = node;
+  if (tagName === "span" && node.children.length === 1 && node.children[0].type === "text" && typeof node.properties?.style === "string") {
+    let styleOnly = true;
+    for (const key2 in node.properties) if (key2 !== "style" && node.properties[key2] != null) {
+      styleOnly = false;
+      break;
+    }
+    if (styleOnly) return `<span ${serializeStyle(node.properties.style, styles)}>${escapeText(node.children[0].value)}</span>`;
+  }
+  if (DELEGATED_TAGS.has(tagName)) return toHtml(node);
+  const attributes = serializeAttributes2(node.properties, styles);
+  if (attributes == null) return toHtml(node);
+  const open = attributes === "" ? `<${tagName}>` : `<${tagName} ${attributes}>`;
+  const content = serializeChildren(node.children, styles);
+  if (content === "" && VOID_ELEMENTS.has(tagName.toLowerCase())) return open;
+  return `${open}${content}</${tagName}>`;
+}
+function serializeStyle(value, styles) {
+  let attribute = styles.get(value);
+  if (attribute == null) {
+    attribute = `style="${escapeAttribute(value)}"`;
+    if (styles.size < MAX_CACHED_STYLES) styles.set(value, attribute);
+  }
+  return attribute;
+}
+function serializeAttributes2(properties, styles) {
+  let attributes = "";
+  for (const key2 in properties) {
+    const value = properties[key2];
+    if (value == null) continue;
+    const name = ATTRIBUTE_NAMES[key2] ?? (DATA_ATTRIBUTE.test(key2) ? key2 : void 0);
+    if (name == null) return;
+    if (value === false || typeof value === "number" && Number.isNaN(value)) continue;
+    const attribute = key2 === "style" && typeof value === "string" ? serializeStyle(value, styles) : value === true ? name : `${name}="${escapeAttribute(Array.isArray(value) ? value.join(" ").trim() : String(value))}"`;
+    attributes += attributes === "" ? attribute : ` ${attribute}`;
+  }
+  return attributes;
+}
+function escapeText(value) {
+  return value.indexOf("<") < 0 && value.indexOf("&") < 0 ? value : value.replace(TEXT_ESCAPE, toCharacterReference);
+}
+function escapeAttribute(value) {
+  return value.replace(ATTRIBUTE_ESCAPE, toCharacterReference);
+}
+function toCharacterReference(character) {
+  return CHARACTER_REFERENCES[character];
+}
+
+// node_modules/@pierre/diffs/dist/utils/hast_utils.js
+function createTextNodeElement(value) {
+  return {
+    type: "text",
+    value
+  };
+}
+function createHastElement({ tagName, children = [], properties = {} }) {
+  return {
+    type: "element",
+    tagName,
+    properties,
+    children
+  };
+}
+function createIconElement({ name, width = 16, height = 16, properties }) {
+  return createHastElement({
+    tagName: "svg",
+    properties: {
+      width,
+      height,
+      viewBox: "0 0 16 16",
+      ...properties
+    },
+    children: [createHastElement({
+      tagName: "use",
+      properties: { href: `#${name.replace(/^#/, "")}` }
+    })]
+  });
+}
+function createGutterWrapper(children) {
+  return createHastElement({
+    tagName: "div",
+    properties: { "data-gutter": "" },
+    children
+  });
+}
+function createGutterItem(lineType, lineNumber, lineIndex, properties = {}) {
+  return createHastElement({
+    tagName: "div",
+    properties: {
+      "data-line-type": lineType,
+      "data-column-number": lineNumber,
+      "data-line-index": lineIndex,
+      ...properties
+    },
+    children: lineNumber != null ? [createHastElement({
+      tagName: "span",
+      properties: { "data-line-number-content": "" },
+      children: [createTextNodeElement(`${lineNumber}`)]
+    })] : void 0
+  });
+}
+function createGutterGap(type, bufferType, size) {
+  return createHastElement({
+    tagName: "div",
+    properties: {
+      "data-gutter-buffer": bufferType,
+      "data-buffer-size": size,
+      "data-line-type": bufferType === "annotation" ? void 0 : type,
+      style: bufferType === "annotation" ? `grid-row: span ${size};` : `grid-row: span ${size};min-height:calc(${size} * 1lh);`
+    }
+  });
+}
+
+// node_modules/@pierre/diffs/dist/utils/processLine.js
+function processLine(node, line, state) {
+  const lineInfo = typeof state.lineInfo === "function" ? state.lineInfo(line) : state.lineInfo[line - 1];
+  if (lineInfo == null) {
+    const errorMessage = `processLine: line ${line}, contains no state.lineInfo`;
+    console.error(errorMessage, {
+      node,
+      line,
+      state
+    });
+    throw new Error(errorMessage);
+  }
+  node.tagName = "div";
+  node.properties["data-line"] = lineInfo.lineNumber;
+  node.properties["data-alt-line"] = lineInfo.altLineNumber;
+  node.properties["data-line-type"] = lineInfo.type;
+  node.properties["data-line-index"] = lineInfo.lineIndex;
+  if (node.children.length === 0) node.children.push(createTextNodeElement("\n"));
+  return node;
+}
+
+// node_modules/@pierre/diffs/dist/utils/setDeferredArrayItem.js
+function setDeferredArrayItem(array, index, create2) {
+  let initialized = false;
+  let cached;
+  Object.defineProperty(array, index, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      if (!initialized) {
+        cached = create2();
+        initialized = true;
+      }
+      if (Object.getOwnPropertyDescriptor(array, index)?.configurable === true) Object.defineProperty(array, index, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: cached
+      });
+      return cached;
+    },
+    set(value) {
+      if (Object.getOwnPropertyDescriptor(array, index)?.configurable === true) Object.defineProperty(array, index, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+      });
+      else if (Object.isFrozen(array)) throw new TypeError(`Cannot assign to read only array index '${index}'`);
+      else {
+        cached = value;
+        initialized = true;
+      }
+    }
+  });
+}
+
+// node_modules/@pierre/diffs/dist/utils/tokenStyle.js
+var htmlStyleCache = /* @__PURE__ */ new WeakMap();
+function tokenStyle(token, cacheHtmlStyle = false) {
+  const { htmlStyle } = token;
+  if (htmlStyle != null) {
+    let style2 = cacheHtmlStyle ? htmlStyleCache.get(htmlStyle) : void 0;
+    if (style2 == null) {
+      style2 = "";
+      for (const name in htmlStyle) style2 += `${style2 === "" ? "" : ";"}${name}:${htmlStyle[name]}`;
+      if (cacheHtmlStyle) htmlStyleCache.set(htmlStyle, style2);
+    }
+    return style2;
+  }
+  let style = token.color != null ? `color:${token.color}` : "";
+  if (token.bgColor != null) style += `;background-color:${token.bgColor}`;
+  if (token.fontStyle != null) {
+    if ((token.fontStyle & 1) !== 0) style += ";font-style:italic";
+    if ((token.fontStyle & 2) !== 0) style += ";font-weight:bold";
+    const underline = (token.fontStyle & 4) !== 0;
+    const strikethrough = (token.fontStyle & 8) !== 0;
+    if (underline || strikethrough) style += `;text-decoration:${underline ? "underline" : ""}${underline && strikethrough ? " " : ""}${strikethrough ? "line-through" : ""}`;
+  }
+  return style.replace(/^;/, "");
+}
+
+// node_modules/@pierre/diffs/dist/utils/wrapTokenFragments.js
+var NO_TOKEN = /* @__PURE__ */ Symbol("no-token");
+var MULTIPLE_TOKENS = /* @__PURE__ */ Symbol("multiple-tokens");
+function wrapTokenFragments(container) {
+  const ownTokenChar = getTokenChar(container);
+  if (ownTokenChar != null) return ownTokenChar;
+  let containerTokenState = NO_TOKEN;
+  const wrappedChildren = [];
+  let currentTokenChildren = [];
+  let currentTokenChar;
+  const flushTokenChildren = () => {
+    if (currentTokenChildren.length === 0 || currentTokenChar == null) {
+      currentTokenChildren = [];
+      currentTokenChar = void 0;
+      return;
+    }
+    if (currentTokenChildren.length === 1) {
+      const child = currentTokenChildren[0];
+      if (child?.type === "element") {
+        setTokenChar(child, currentTokenChar);
+        for (const grandChild of child.children) stripTokenChar(grandChild);
+      } else stripTokenChar(child);
+      wrappedChildren.push(child);
+      currentTokenChildren = [];
+      currentTokenChar = void 0;
+      return;
+    }
+    for (const child of currentTokenChildren) stripTokenChar(child);
+    wrappedChildren.push(createHastElement({
+      tagName: "span",
+      properties: { "data-char": currentTokenChar },
+      children: currentTokenChildren
+    }));
+    currentTokenChildren = [];
+    currentTokenChar = void 0;
+  };
+  const mergeContainerTokenState = (childTokenState) => {
+    if (childTokenState === NO_TOKEN) return;
+    if (childTokenState === MULTIPLE_TOKENS) {
+      containerTokenState = MULTIPLE_TOKENS;
+      return;
+    }
+    if (containerTokenState === NO_TOKEN) {
+      containerTokenState = childTokenState;
+      return;
+    }
+    if (containerTokenState !== childTokenState) containerTokenState = MULTIPLE_TOKENS;
+  };
+  for (const child of container.children) {
+    const childTokenState = child.type === "element" ? wrapTokenFragments(child) : NO_TOKEN;
+    mergeContainerTokenState(childTokenState);
+    if (typeof childTokenState !== "number") {
+      flushTokenChildren();
+      wrappedChildren.push(child);
+      continue;
+    }
+    if (currentTokenChar != null && currentTokenChar !== childTokenState) flushTokenChildren();
+    currentTokenChar ??= childTokenState;
+    currentTokenChildren.push(child);
+  }
+  flushTokenChildren();
+  container.children = wrappedChildren;
+  return containerTokenState;
+}
+function getTokenChar(node) {
+  const value = node.properties["data-char"];
+  if (typeof value === "number") return value;
+}
+function stripTokenChar(node) {
+  if (node.type !== "element") return;
+  node.properties["data-char"] = void 0;
+  for (const child of node.children) stripTokenChar(child);
+}
+function setTokenChar(node, char) {
+  node.properties["data-char"] = char;
+}
+
+// node_modules/@pierre/diffs/dist/utils/renderTokenLines.js
+function renderTokenLines(lines, { state, lazyLineAST = false, cacheHtmlStyles = false, useTokenTransformer = false, mergeWhitespaces = "always", decorations = [], lineOffsets = [] }) {
+  let decorationsByLine;
+  for (const decoration of decorations) {
+    const byLine = decorationsByLine ??= /* @__PURE__ */ new Map();
+    const normalized = {
+      ...decoration,
+      start: getDecorationPosition(decoration.start, lineOffsets),
+      end: getDecorationPosition(decoration.end, lineOffsets)
+    };
+    const lastLine = Math.min(normalized.end.line, lines.length - 1);
+    for (let line = normalized.start.line; line <= lastLine; line++) {
+      let spans = byLine.get(line);
+      if (spans == null) byLine.set(line, spans = []);
+      spans.push(normalized);
+    }
+  }
+  const renderLine = (tokens, lineIndex) => {
+    let normalized;
+    if (useTokenTransformer || mergeWhitespaces !== "never") {
+      let pendingWhitespace = "";
+      let whitespaceOffset = 0;
+      for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        if (useTokenTransformer) {
+          const content = token.content.trim();
+          if (content !== "" && content !== token.content) {
+            normalized ??= tokens.slice(0, i);
+            const start = token.content.indexOf(content);
+            if (start > 0) normalized.push({
+              content: token.content.slice(0, start),
+              offset: token.offset
+            });
+            normalized.push({
+              ...token,
+              content,
+              offset: token.offset + start
+            });
+            const end = start + content.length;
+            if (end < token.content.length) normalized.push({
+              content: token.content.slice(end),
+              offset: token.offset + end
+            });
+            continue;
+          }
+        } else {
+          const decoratedWhitespace = ((token.fontStyle ?? 0) & 12) !== 0;
+          if (!decoratedWhitespace && /^\s+$/.test(token.content) && i < tokens.length - 1) {
+            normalized ??= tokens.slice(0, i);
+            if (pendingWhitespace === "") whitespaceOffset = token.offset;
+            pendingWhitespace += token.content;
+            continue;
+          }
+          if (pendingWhitespace !== "" && normalized != null) {
+            if (decoratedWhitespace) normalized.push({
+              content: pendingWhitespace,
+              offset: whitespaceOffset
+            });
+            else token = {
+              ...token,
+              content: pendingWhitespace + token.content,
+              offset: whitespaceOffset
+            };
+            pendingWhitespace = "";
+          }
+        }
+        normalized?.push(token);
+      }
+    }
+    normalized ??= tokens;
+    const line = {
+      type: "element",
+      tagName: state == null ? "span" : "div",
+      properties: state == null ? { class: "line" } : {},
+      children: []
+    };
+    const spans = decorationsByLine?.get(lineIndex);
+    const column = spans == null ? appendTokens(line, normalized, useTokenTransformer, cacheHtmlStyles) : appendDecoratedTokens(line, normalized, spans, lineIndex, useTokenTransformer, cacheHtmlStyles);
+    if (useTokenTransformer && column === 0) line.children.push({
+      type: "element",
+      tagName: "br",
+      properties: {},
+      children: []
+    });
+    if (useTokenTransformer && spans != null) wrapTokenFragments(line);
+    return state == null ? line : processLine(line, lineIndex + 1, state);
+  };
+  if (!lazyLineAST) return lines.map(renderLine);
+  const rows = new Array(lines.length);
+  for (let index = 0; index < lines.length; index++) {
+    const tokens = lines[index];
+    setDeferredArrayItem(rows, index, () => renderLine(tokens, index));
+  }
+  return rows;
+}
+function appendTokens(line, tokens, useTokenTransformer, cacheHtmlStyles) {
+  let column = 0;
+  for (const token of tokens) {
+    if (token.content === "") continue;
+    line.children.push(createTokenSpan(token, tokenStyle(token, cacheHtmlStyles), token.content, column, useTokenTransformer));
+    column += token.content.length;
+  }
+  return column;
+}
+function appendDecoratedTokens(line, tokens, spans, lineIndex, useTokenTransformer, cacheHtmlStyles) {
+  if (spans.length > 1) spans.sort((a, b) => {
+    if (a.start.line !== b.start.line) return a.start.line - b.start.line;
+    if (a.start.character !== b.start.character) return a.start.character - b.start.character;
+    if (a.end.line !== b.end.line) return b.end.line - a.end.line;
+    return b.end.character - a.end.character;
+  });
+  const lineLength = tokens.reduce((length, token) => length + token.content.length, 0);
+  const boundaries = [];
+  for (let order = 0; order < spans.length; order++) {
+    const decoration = spans[order];
+    const range = {
+      decoration,
+      order,
+      from: decoration.start.line === lineIndex ? decoration.start.character : 0,
+      to: decoration.end.line === lineIndex ? decoration.end.character : lineLength
+    };
+    boundaries.push({
+      position: Math.max(0, Math.min(range.from, lineLength)),
+      range,
+      start: true
+    }, {
+      position: Math.max(0, Math.min(range.to, lineLength)),
+      range,
+      start: false
+    });
+  }
+  boundaries.sort((a, b) => a.position - b.position);
+  const active = [];
+  const decorationStack = [];
+  let boundaryIndex = 0;
+  const updateActive = (range, add) => {
+    let low = 0;
+    let high = active.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (active[middle].order < range.order) low = middle + 1;
+      else high = middle;
+    }
+    if (add) active.splice(low, 0, range);
+    else if (active[low] === range) active.splice(low, 1);
+  };
+  const getParent = () => {
+    let parent2 = line;
+    let depth = 0;
+    for (const range of active) {
+      if (decorationStack[depth]?.range !== range) {
+        decorationStack.length = depth;
+        const wrapper = {
+          type: "element",
+          tagName: "span",
+          properties: { ...range.decoration.properties },
+          children: []
+        };
+        parent2.children.push(wrapper);
+        decorationStack.push({
+          range,
+          node: wrapper
+        });
+      }
+      parent2 = decorationStack[depth++].node;
+    }
+    decorationStack.length = depth;
+    return parent2;
+  };
+  let parent = line;
+  const advanceBoundary = (position) => {
+    const first = boundaryIndex;
+    while (boundaries[boundaryIndex]?.position === position) boundaryIndex++;
+    let hasMarker = false;
+    for (let i = first; i < boundaryIndex; i++) {
+      const { range, start } = boundaries[i];
+      if (!start && range.from !== range.to && position < lineLength) updateActive(range, false);
+    }
+    for (let i = first; i < boundaryIndex; i++) {
+      const { range, start } = boundaries[i];
+      if (start && range.from <= position && range.to >= position && (range.to > position || range.from === position || position === lineLength)) {
+        updateActive(range, true);
+        if (range.from === range.to) hasMarker = true;
+      }
+    }
+    if (hasMarker) {
+      getParent();
+      for (let i = first; i < boundaryIndex; i++) {
+        const { range, start } = boundaries[i];
+        if (start && range.from === range.to) updateActive(range, false);
+      }
+    }
+    if (position < lineLength) parent = getParent();
+  };
+  let column = 0;
+  for (const token of tokens) {
+    if (token.content === "") continue;
+    const start = column;
+    const end = start + token.content.length;
+    const style = tokenStyle(token, cacheHtmlStyles);
+    while (column < end) {
+      if (boundaries[boundaryIndex]?.position === column) advanceBoundary(column);
+      const to = Math.min(end, boundaries[boundaryIndex]?.position ?? end);
+      parent.children.push(createTokenSpan(token, style, column === start && to === end ? token.content : token.content.slice(column - start, to - start), start, useTokenTransformer));
+      column = to;
+    }
+  }
+  if (boundaries[boundaryIndex]?.position === column) advanceBoundary(column);
+  return column;
+}
+function createTokenSpan(token, style, text2, start, useTokenTransformer) {
+  const properties = token.htmlAttrs != null ? { ...token.htmlAttrs } : {};
+  if (style !== "") properties.style = style;
+  if (useTokenTransformer) properties["data-char"] = start;
+  return {
+    type: "element",
+    tagName: "span",
+    properties,
+    children: [{
+      type: "text",
+      value: text2
+    }]
+  };
+}
+function getDecorationPosition(position, lineOffsets) {
+  if (typeof position !== "number") return position;
+  let low = 0;
+  let high = lineOffsets.length;
+  while (low + 1 < high) {
+    const middle = low + high >>> 1;
+    if (lineOffsets[middle] <= position) low = middle;
+    else high = middle;
+  }
+  return {
+    line: low,
+    character: position - (lineOffsets[low] ?? 0)
+  };
+}
+
+// node_modules/@pierre/diffs/dist/utils/tokensToHtml.js
+function tokensToHtml(source, result, options, cacheHtmlStyles = false) {
+  const lineOffsets = [0];
+  if (options.decorations?.some((item) => typeof item.start === "number" || typeof item.end === "number") === true) for (let index = source.indexOf("\n"); index !== -1; index = source.indexOf("\n", index + 1)) lineOffsets.push(index + 1);
+  const code = {
+    type: "element",
+    tagName: "code",
+    properties: {},
+    children: []
+  };
+  const lines = renderTokenLines(result.tokens, {
+    decorations: options.decorations,
+    mergeWhitespaces: options.mergeWhitespaces,
+    lineOffsets,
+    cacheHtmlStyles
+  });
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) code.children.push({
+      type: "text",
+      value: "\n"
+    });
+    code.children.push(lines[i]);
+  }
+  const root2 = {
+    type: "root",
+    children: [{
+      type: "element",
+      tagName: "pre",
+      properties: {
+        class: "diffs",
+        style: result.rootStyle === false ? void 0 : result.rootStyle ?? [result.fg != null ? `color:${result.fg}` : "", result.bg != null ? `background-color:${result.bg}` : ""].filter(Boolean).join(";"),
+        tabIndex: 0
+      },
+      children: [code]
+    }]
+  };
+  return hastToHtml(root2);
+}
+
+// node_modules/@pierre/diffs/dist/utils/appendItems.js
+function appendItems(target, items) {
+  for (const item of items) target.push(item);
+}
+
+export {
+  ccount,
+  DIFFS_TAG_NAME,
+  GIT_DIFF_FILE_BREAK_REGEX,
+  SPLIT_WITH_NEWLINES,
+  FILENAME_HEADER_REGEX,
+  INDEX_LINE_METADATA,
+  HEADER_PREFIX_SLOT_ID,
+  HEADER_FILENAME_SUFFIX_SLOT_ID,
+  HEADER_METADATA_SLOT_ID,
+  CUSTOM_HEADER_SLOT_ID,
+  DEFAULT_THEMES,
+  THEME_CSS_ATTRIBUTE,
+  UNSAFE_CSS_ATTRIBUTE,
+  DIFFS_SCROLLBAR_MEASURE_ATTRIBUTE,
+  DIFFS_SCROLLBAR_GUTTER_MEASURED_PROPERTY,
+  DEFAULT_TOKENIZE_MAX_LENGTH,
+  DEFAULT_EXPANDED_REGION,
+  DEFAULT_RENDER_RANGE,
+  EMPTY_LINE_ANNOTATIONS,
+  EMPTY_RENDER_RANGE,
+  HighlighterDisposedError,
+  getHighlighterType,
+  resolveHighlighterType,
+  acquireHighlighterType,
+  releaseHighlighterType,
+  isWorkerContext,
+  customThemes,
+  createDiffsThemeResolver,
+  hastToHtml,
+  createTextNodeElement,
+  createHastElement,
+  createIconElement,
+  createGutterWrapper,
+  createGutterItem,
+  createGutterGap,
+  setDeferredArrayItem,
+  renderTokenLines,
+  tokensToHtml,
+  appendItems
+};
+//# sourceMappingURL=chunk-KIDTSHLT.js.map