https://toootiz-mikutts.hf.space/assets/Index-BOG-LPoW.js

1const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./auto-render-DTMSUk0Z-BeunX3LV.js","./katex-BnZ5CZRo-BMBmxj1Y.js","./mermaid.core-vMMZVCDT-alxhRXoZ.js","./index-Bq2njFOY.js","./index-JtiO_h80.css","./i18n-CGlVUOvE.js","./i18n-DmEW90TJ.css","./utils.svelte-Bi9ASwv9.js","./index-DnoGeqVF.js","./dsv-BhAd467f.js","./props-o1aFOJaB.js","./misc-D8a4ZbMA.js","./index-By61_kAe.js","./Upload-xR3P-2U5.js","./snippet-BG7qkY_1.js","./actions-CgRQ2lHA.js","./Upload-B9AbOy1B.css","./ScrollFade.svelte_svelte_type_style_lang-D0JPkGar.js","./ScrollFade-DXC81vHi.css","./MarkdownCode.svelte_svelte_type_style_lang-B29zDiob.js","./prism-python-NrKIQnfs.js","./MarkdownCode-hl0Esrgh.css","./html-Bwif0JPw.js","./input-CXpCw23l.js","./event-modifiers-DanhKw3_.js","./MarkdownCode-BYKuypS7.js","./StreamingBar.svelte_svelte_type_style_lang-DWGn5tT_.js","./StreamingBar-M0OJiclA.css","./Checkbox-dsIC6373.js","./Checkbox-CJBAs2gn.css","./size-CWi277d_.js","./Check-BKMHx_DF.js","./DropdownArrow-3lFHYtTD.js","./Copy-BQlJe6-D.js","./FullscreenButton-C6RgeACK.js","./Maximize-2N5airbC.js","./Example-CSyNUPmz.js","./Example-B0qjHn8W.css"])))=>i.map(i=>d[i]);
2import { j as get, w as writable$1, p as prop, e as init$1, b as set_class, a as set_attribute, h as clsx, i as if_block, d as bind_this, f as set_style$1, s as slot, k as each, t as remove_input_defaults, F as set_value, u as index, q as store_get, m as setup_stores, r as rest_props } from './i18n-CGlVUOvE.js';
3import { ag as __vitePreload, aw as setContext$1, I as tick$1, M as push, Y as legacy_pre_effect, y as deep_read_state, Z as get$1, _ as legacy_pre_effect_reset, t as template_effect, U as event, a as append$1, O as pop, a0 as mutable_source, P as flushSync, Q as child, R as from_html, $ as set, T as reset, a1 as createEventDispatcher$1, N as first_child, S as sibling, u as effect, w as untrack, aj as remove_textarea_child, a3 as comment, ae as derived_safe_equal, a4 as text$1, X as set_text, f as from_svg, a8 as onMount$1, ar as mutate, af as onDestroy$1, aA as afterUpdate$1, av as $window, ad as user_effect } from './index-Bq2njFOY.js';
4import { G as Gradio } from './utils.svelte-Bi9ASwv9.js';
5import { d as dequal$2 } from './index-DnoGeqVF.js';
6import { d as dsvFormat$1 } from './dsv-BhAd467f.js';
7import { b as bind_prop } from './props-o1aFOJaB.js';
8import { b as bubble_event } from './misc-D8a4ZbMA.js';
9import { d as dequal$3 } from './index-By61_kAe.js';
10import { U as Upload } from './Upload-xR3P-2U5.js';
11import { c as component, I as IconButton$1 } from './ScrollFade.svelte_svelte_type_style_lang-D0JPkGar.js';
12import './MarkdownCode.svelte_svelte_type_style_lang-B29zDiob.js';
13import { h as html$1 } from './html-Bwif0JPw.js';
14import { a as action } from './actions-CgRQ2lHA.js';
15import { b as bind_value } from './input-CXpCw23l.js';
16import { s as stopPropagation, p as preventDefault } from './event-modifiers-DanhKw3_.js';
17import { M as MarkdownCode$1 } from './MarkdownCode-BYKuypS7.js';
18import './StreamingBar.svelte_svelte_type_style_lang-DWGn5tT_.js';
19import { C as Checkbox$1 } from './Checkbox-dsIC6373.js';
20import { b as bind_element_size, a as bind_resize_observer } from './size-CWi277d_.js';
21import { C as Check$1 } from './Check-BKMHx_DF.js';
22import { D as DropdownArrow$1 } from './DropdownArrow-3lFHYtTD.js';
23import { C as Copy$1 } from './Copy-BQlJe6-D.js';
24import { F as FullscreenButton$1 } from './FullscreenButton-C6RgeACK.js';
25import Example from './Example-CSyNUPmz.js';
26
27var __defProp = Object.defineProperty;
28var __typeError = (msg) => {
29  throw TypeError(msg);
30};
31var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
32var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
33var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
34var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), member.get(obj));
35var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
36var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
37var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
38var _Marked_instances, parseMarkdown_fn, onError_fn, _currentLine;
39function noop() {
40}
41const identity = (x) => x;
42function assign(tar, src) {
43  for (const k in src) tar[k] = src[k];
44  return (
45    /** @type {T & S} */
46    tar
47  );
48}
49function run(fn) {
50  return fn();
51}
52function blank_object() {
53  return /* @__PURE__ */ Object.create(null);
54}
55function run_all(fns) {
56  fns.forEach(run);
57}
58function is_function(thing) {
59  return typeof thing === "function";
60}
61function safe_not_equal(a, b) {
62  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
63}

64let src_url_equal_anchor;
65function src_url_equal(element_src, url) {
66  if (element_src === url) return true;
67  if (!src_url_equal_anchor) {
68    src_url_equal_anchor = document.createElement("a");
69  }
70  src_url_equal_anchor.href = url;
71  return element_src === src_url_equal_anchor.href;
72}
73function is_empty(obj) {
74  return Object.keys(obj).length === 0;
75}
76function subscribe(store, ...callbacks) {
77  if (store == null) {
78    for (const callback of callbacks) {
79      callback(void 0);
80    }
81    return noop;
82  }
83  const unsub = store.subscribe(...callbacks);
84  return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
85}
86function get_store_value(store) {
87  let value;
88  subscribe(store, (_) => value = _)();
89  return value;
90}
91function component_subscribe(component, store, callback) {
92  component.$$.on_destroy.push(subscribe(store, callback));
93}
94function create_slot(definition, ctx, $$scope, fn) {
95  if (definition) {
96    const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
97    return definition[0](slot_ctx);
98  }
99}
100function get_slot_context(definition, ctx, $$scope, fn) {
101  return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
102}
103function get_slot_changes(definition, $$scope, dirty, fn) {
104  if (definition[2] && fn) {
105    const lets = definition[2](fn(dirty));
106    if ($$scope.dirty === void 0) {
107      return lets;
108    }
109    if (typeof lets === "object") {
110      const merged = [];
111      const len = Math.max($$scope.dirty.length, lets.length);
112      for (let i = 0; i < len; i += 1) {
113        merged[i] = $$scope.dirty[i] | lets[i];
114      }
115      return merged;
116    }
117    return $$scope.dirty | lets;
118  }
119  return $$scope.dirty;
120}
121function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
122  if (slot_changes) {
123    const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
124    slot.p(slot_context, slot_changes);
125  }
126}
127function get_all_dirty_from_scope($$scope) {
128  if ($$scope.ctx.length > 32) {
129    const dirty = [];
130    const length = $$scope.ctx.length / 32;
131    for (let i = 0; i < length; i++) {
132      dirty[i] = -1;
133    }
134    return dirty;
135  }
136  return -1;
137}
138function exclude_internal_props(props) {
139  const result = {};
140  for (const k in props) if (k[0] !== "$") result[k] = props[k];
141  return result;
142}
143function compute_rest_props(props, keys) {
144  const rest = {};
145  keys = new Set(keys);
146  for (const k in props) if (!keys.has(k) && k[0] !== "$") rest[k] = props[k];
147  return rest;
148}
149function null_to_empty(value) {
150  return value == null ? "" : value;
151}
152function action_destroyer(action_result) {
153  return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
154}
155const is_client = typeof window !== "undefined";
156let now = is_client ? () => window.performance.now() : () => Date.now();
157let raf$1 = is_client ? (cb) => requestAnimationFrame(cb) : noop;
158const tasks = /* @__PURE__ */ new Set();
159function run_tasks(now2) {
160  tasks.forEach((task) => {
161    if (!task.c(now2)) {
162      tasks.delete(task);
163      task.f();
164    }
165  });
166  if (tasks.size !== 0) raf$1(run_tasks);
167}
168function loop(callback) {
169  let task;
170  if (tasks.size === 0) raf$1(run_tasks);
171  return {
172    promise: new Promise((fulfill) => {
173      tasks.add(task = { c: callback, f: fulfill });
174    }),
175    abort() {
176      tasks.delete(task);
177    }
178  };
179}
180const globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : (
181  // @ts-ignore Node typings have this
182  global
183);
184class ResizeObserverSingleton {
185  /** @param {ResizeObserverOptions} options */
186  constructor(options) {
187    /**
188     * @private
189     * @readonly
190     * @type {WeakMap<Element, import('./private.js').Listener>}
191     */
192    __publicField(this, "_listeners", "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0);
193    /**
194     * @private
195     * @type {ResizeObserver}
196     */
197    __publicField(this, "_observer");
198    /** @type {ResizeObserverOptions} */
199    __publicField(this, "options");
200    this.options = options;
201  }
202  /**
203   * @param {Element} element
204   * @param {import('./private.js').Listener} listener
205   * @returns {() => void}
206   */
207  observe(element2, listener) {
208    this._listeners.set(element2, listener);
209    this._getObserver().observe(element2, this.options);
210    return () => {
211      this._listeners.delete(element2);
212      this._observer.unobserve(element2);
213    };
214  }
215  /**
216   * @private
217   */
218  _getObserver() {
219    return this._observer ?? (this._observer = new ResizeObserver((entries) => {
220      var _a;

221      for (const entry of entries) {
222        ResizeObserverSingleton.entries.set(entry.target, entry);
223        (_a = this._listeners.get(entry.target)) == null ? void 0 : _a(entry);
224      }
225    }));
226  }
227}
228ResizeObserverSingleton.entries = "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0;
229function append(target, node) {
230  target.appendChild(node);
231}
232function get_root_for_style(node) {
233  if (!node) return document;
234  const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
235  if (root && /** @type {ShadowRoot} */
236  root.host) {
237    return (
238      /** @type {ShadowRoot} */
239      root
240    );
241  }
242  return node.ownerDocument;
243}
244function append_empty_stylesheet(node) {
245  const style_element = element("style");
246  style_element.textContent = "/* empty */";
247  append_stylesheet(get_root_for_style(node), style_element);
248  return style_element.sheet;
249}
250function append_stylesheet(node, style) {
251  append(
252    /** @type {Document} */
253    node.head || node,
254    style
255  );
256  return style.sheet;
257}
258function insert(target, node, anchor) {
259  target.insertBefore(node, anchor || null);
260}
261function detach(node) {
262  if (node.parentNode) {
263    node.parentNode.removeChild(node);
264  }
265}
266function destroy_each(iterations, detaching) {
267  for (let i = 0; i < iterations.length; i += 1) {
268    if (iterations[i]) iterations[i].d(detaching);
269  }
270}
271function element(name) {
272  return document.createElement(name);
273}
274function svg_element(name) {
275  return document.createElementNS("http://www.w3.org/2000/svg", name);
276}
277function text(data) {
278  return document.createTextNode(data);
279}
280function space() {
281  return text(" ");
282}
283function empty() {
284  return text("");
285}
286function listen(node, event, handler, options) {
287  node.addEventListener(event, handler, options);
288  return () => node.removeEventListener(event, handler, options);
289}
290function prevent_default(fn) {
291  return function(event) {
292    event.preventDefault();
293    return fn.call(this, event);
294  };
295}
296function stop_propagation(fn) {
297  return function(event) {
298    event.stopPropagation();
299    return fn.call(this, event);
300  };
301}
302function attr(node, attribute, value) {
303  if (value == null) node.removeAttribute(attribute);
304  else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value);
305}
306const always_set_through_set_attribute = ["width", "height"];
307function set_attributes(node, attributes) {
308  const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
309  for (const key in attributes) {
310    if (attributes[key] == null) {
311      node.removeAttribute(key);
312    } else if (key === "style") {
313      node.style.cssText = attributes[key];
314    } else if (key === "__value") {
315      node.value = node[key] = attributes[key];
316    } else if (descriptors[key] && descriptors[key].set && always_set_through_set_attribute.indexOf(key) === -1) {
317      node[key] = attributes[key];
318    } else {
319      attr(node, key, attributes[key]);
320    }
321  }
322}
323function set_custom_element_data_map(node, data_map) {
324  Object.keys(data_map).forEach((key) => {
325    set_custom_element_data(node, key, data_map[key]);
326  });
327}
328function set_custom_element_data(node, prop, value) {
329  const lower = prop.toLowerCase();
330  if (lower in node) {
331    node[lower] = typeof node[lower] === "boolean" && value === "" ? true : value;
332  } else if (prop in node) {
333    node[prop] = typeof node[prop] === "boolean" && value === "" ? true : value;
334  } else {
335    attr(node, prop, value);
336  }
337}
338function set_dynamic_element_data(tag2) {
339  return /-/.test(tag2) ? set_custom_element_data_map : set_attributes;
340}
341function children(element2) {
342  return Array.from(element2.childNodes);
343}
344function set_data(text2, data) {
345  data = "" + data;
346  if (text2.data === data) return;
347  text2.data = /** @type {string} */
348  data;
349}
350function set_input_value(input, value) {
351  input.value = value == null ? "" : value;
352}
353function set_style(node, key, value, important) {
354  if (value == null) {
355    node.style.removeProperty(key);
356  } else {
357    node.style.setProperty(key, value, "");
358  }
359}
360let crossorigin;
361function is_crossorigin() {
362  if (crossorigin === void 0) {
363    crossorigin = false;

364    try {
365      if (typeof window !== "undefined" && window.parent) {
366        void window.parent.document;
367      }
368    } catch (error) {
369      crossorigin = true;
370    }
371  }
372  return crossorigin;
373}
374function add_iframe_resize_listener(node, fn) {
375  const computed_style = getComputedStyle(node);
376  if (computed_style.position === "static") {
377    node.style.position = "relative";
378  }
379  const iframe = element("iframe");
380  iframe.setAttribute(
381    "style",
382    "display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;"
383  );
384  iframe.setAttribute("aria-hidden", "true");
385  iframe.tabIndex = -1;
386  const crossorigin2 = is_crossorigin();
387  let unsubscribe;
388  if (crossorigin2) {
389    iframe.src = "data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}<\/script>";
390    unsubscribe = listen(
391      window,
392      "message",
393      /** @param {MessageEvent} event */
394      (event) => {
395        if (event.source === iframe.contentWindow) fn();
396      }
397    );
398  } else {
399    iframe.src = "about:blank";
400    iframe.onload = () => {
401      unsubscribe = listen(iframe.contentWindow, "resize", fn);
402      fn();
403    };
404  }
405  append(node, iframe);
406  return () => {
407    if (crossorigin2) {
408      unsubscribe();
409    } else if (unsubscribe && iframe.contentWindow) {
410      unsubscribe();
411    }
412    detach(iframe);
413  };
414}
415const resize_observer_content_box = /* @__PURE__ */ new ResizeObserverSingleton({
416  box: "content-box"
417});
418function toggle_class(element2, name, toggle) {
419  element2.classList.toggle(name, !!toggle);
420}
421function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
422  return new CustomEvent(type, { detail, bubbles, cancelable });
423}
424class HtmlTag {
425  constructor(is_svg = false) {
426    /**
427     * @private
428     * @default false
429     */
430    __publicField(this, "is_svg", false);
431    /** parent for creating node */
432    __publicField(this, "e");
433    /** html tag nodes */
434    __publicField(this, "n");
435    /** target */
436    __publicField(this, "t");
437    /** anchor */
438    __publicField(this, "a");
439    this.is_svg = is_svg;
440    this.e = this.n = null;
441  }
442  /**
443   * @param {string} html
444   * @returns {void}
445   */
446  c(html2) {
447    this.h(html2);
448  }
449  /**
450   * @param {string} html
451   * @param {HTMLElement | SVGElement} target
452   * @param {HTMLElement | SVGElement} anchor
453   * @returns {void}
454   */
455  m(html2, target, anchor = null) {
456    if (!this.e) {
457      if (this.is_svg)
458        this.e = svg_element(
459          /** @type {keyof SVGElementTagNameMap} */
460          target.nodeName
461        );
462      else
463        this.e = element(
464          /** @type {keyof HTMLElementTagNameMap} */
465          target.nodeType === 11 ? "TEMPLATE" : target.nodeName
466        );
467      this.t = target.tagName !== "TEMPLATE" ? target : (
468        /** @type {HTMLTemplateElement} */
469        target.content
470      );
471      this.c(html2);
472    }
473    this.i(anchor);
474  }
475  /**
476   * @param {string} html
477   * @returns {void}
478   */
479  h(html2) {
480    this.e.innerHTML = html2;
481    this.n = Array.from(
482      this.e.nodeName === "TEMPLATE" ? this.e.content.childNodes : this.e.childNodes
483    );
484  }
485  /**
486   * @returns {void} */
487  i(anchor) {
488    for (let i = 0; i < this.n.length; i += 1) {
489      insert(this.t, this.n[i], anchor);
490    }
491  }
492  /**
493   * @param {string} html
494   * @returns {void}
495   */
496  p(html2) {
497    this.d();
498    this.h(html2);
499    this.i(this.a);
500  }
501  /**
502   * @returns {void} */
503  d() {
504    this.n.forEach(detach);
505  }
506}
507function construct_svelte_component(component, props) {
508  return new component(props);
509}
510const managed_styles = /* @__PURE__ */ new Map();
511let active = 0;
512function hash(str) {
513  let hash2 = 5381;
514  let i = str.length;
515  while (i--) hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i);
516  return hash2 >>> 0;
517}
518function create_style_information(doc, node) {
519  const info = { stylesheet: append_empty_stylesheet(node), rules: {} };
520  managed_styles.set(doc, info);
521  return info;
522}
523function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
524  const step = 16.666 / duration;
525  let keyframes = "{\n";
526  for (let p = 0; p <= 1; p += step) {
527    const t = a + (b - a) * ease(p);

528    keyframes += p * 100 + `%{${fn(t, 1 - t)}}
529`;
530  }
531  const rule = keyframes + `100% {${fn(b, 1 - b)}}
532}`;
533  const name = `__svelte_${hash(rule)}_${uid}`;
534  const doc = get_root_for_style(node);
535  const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);
536  if (!rules[name]) {
537    rules[name] = true;
538    stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
539  }
540  const animation = node.style.animation || "";
541  node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay}ms 1 both`;
542  active += 1;
543  return name;
544}
545function delete_rule(node, name) {
546  const previous = (node.style.animation || "").split(", ");
547  const next = previous.filter(
548    name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1
549    // remove all Svelte animations
550  );
551  const deleted = previous.length - next.length;
552  if (deleted) {
553    node.style.animation = next.join(", ");
554    active -= deleted;
555    if (!active) clear_rules();
556  }
557}
558function clear_rules() {
559  raf$1(() => {
560    if (active) return;
561    managed_styles.forEach((info) => {
562      const { ownerNode } = info.stylesheet;
563      if (ownerNode) detach(ownerNode);
564    });
565    managed_styles.clear();
566  });
567}
568let current_component;
569function set_current_component(component) {
570  current_component = component;
571}
572function get_current_component() {
573  if (!current_component) throw new Error("Function called outside component initialization");
574  return current_component;
575}
576function onMount(fn) {
577  get_current_component().$$.on_mount.push(fn);
578}
579function afterUpdate(fn) {
580  get_current_component().$$.after_update.push(fn);
581}
582function onDestroy(fn) {
583  get_current_component().$$.on_destroy.push(fn);
584}
585function createEventDispatcher() {
586  const component = get_current_component();
587  return (type, detail, { cancelable = false } = {}) => {
588    const callbacks = component.$$.callbacks[type];
589    if (callbacks) {
590      const event = custom_event(
591        /** @type {string} */
592        type,
593        detail,
594        { cancelable }
595      );
596      callbacks.slice().forEach((fn) => {
597        fn.call(component, event);
598      });
599      return !event.defaultPrevented;
600    }
601    return true;
602  };
603}
604function setContext(key, context) {
605  get_current_component().$$.context.set(key, context);
606  return context;
607}
608function bubble(component, event) {
609  const callbacks = component.$$.callbacks[event.type];
610  if (callbacks) {
611    callbacks.slice().forEach((fn) => fn.call(this, event));
612  }
613}
614const dirty_components = [];
615const binding_callbacks = [];
616let render_callbacks = [];
617const flush_callbacks = [];
618const resolved_promise = /* @__PURE__ */ Promise.resolve();
619let update_scheduled = false;
620function schedule_update() {
621  if (!update_scheduled) {
622    update_scheduled = true;
623    resolved_promise.then(flush);
624  }
625}
626function tick() {
627  schedule_update();
628  return resolved_promise;
629}
630function add_render_callback(fn) {
631  render_callbacks.push(fn);
632}
633function add_flush_callback(fn) {
634  flush_callbacks.push(fn);
635}
636const seen_callbacks = /* @__PURE__ */ new Set();
637let flushidx = 0;
638function flush() {
639  if (flushidx !== 0) {
640    return;
641  }
642  const saved_component = current_component;
643  do {
644    try {
645      while (flushidx < dirty_components.length) {
646        const component = dirty_components[flushidx];
647        flushidx++;
648        set_current_component(component);
649        update(component.$$);
650      }
651    } catch (e) {
652      dirty_components.length = 0;
653      flushidx = 0;
654      throw e;
655    }
656    set_current_component(null);
657    dirty_components.length = 0;
658    flushidx = 0;
659    while (binding_callbacks.length) binding_callbacks.pop()();
660    for (let i = 0; i < render_callbacks.length; i += 1) {
661      const callback = render_callbacks[i];
662      if (!seen_callbacks.has(callback)) {
663        seen_callbacks.add(callback);
664        callback();
665      }
666    }
667    render_callbacks.length = 0;
668  } while (dirty_components.length);
669  while (flush_callbacks.length) {
670    flush_callbacks.pop()();
671  }
672  update_scheduled = false;

673  seen_callbacks.clear();
674  set_current_component(saved_component);
675}
676function update($$) {
677  if ($$.fragment !== null) {
678    $$.update();
679    run_all($$.before_update);
680    const dirty = $$.dirty;
681    $$.dirty = [-1];
682    $$.fragment && $$.fragment.p($$.ctx, dirty);
683    $$.after_update.forEach(add_render_callback);
684  }
685}
686function flush_render_callbacks(fns) {
687  const filtered = [];
688  const targets = [];
689  render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
690  targets.forEach((c) => c());
691  render_callbacks = filtered;
692}
693let promise;
694function wait() {
695  if (!promise) {
696    promise = Promise.resolve();
697    promise.then(() => {
698      promise = null;
699    });
700  }
701  return promise;
702}
703function dispatch(node, direction, kind) {
704  node.dispatchEvent(custom_event(`${"intro"}${kind}`));
705}
706const outroing = /* @__PURE__ */ new Set();
707let outros;
708function group_outros() {
709  outros = {
710    r: 0,
711    c: [],
712    p: outros
713    // parent group
714  };
715}
716function check_outros() {
717  if (!outros.r) {
718    run_all(outros.c);
719  }
720  outros = outros.p;
721}
722function transition_in(block2, local) {
723  if (block2 && block2.i) {
724    outroing.delete(block2);
725    block2.i(local);
726  }
727}
728function transition_out(block2, local, detach2, callback) {
729  if (block2 && block2.o) {
730    if (outroing.has(block2)) return;
731    outroing.add(block2);
732    outros.c.push(() => {
733      outroing.delete(block2);
734      if (callback) {
735        if (detach2) block2.d(1);
736        callback();
737      }
738    });
739    block2.o(local);
740  } else if (callback) {
741    callback();
742  }
743}
744const null_transition = { duration: 0 };
745function create_in_transition(node, fn, params) {
746  const options = { direction: "in" };
747  let config = fn(node, params, options);
748  let running = false;
749  let animation_name;
750  let task;
751  let uid = 0;
752  function cleanup() {
753    if (animation_name) delete_rule(node, animation_name);
754  }
755  function go() {
756    const {
757      delay = 0,
758      duration = 300,
759      easing = identity,
760      tick: tick2 = noop,
761      css
762    } = config || null_transition;
763    if (css) animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);
764    tick2(0, 1);
765    const start_time = now() + delay;
766    const end_time = start_time + duration;
767    if (task) task.abort();
768    running = true;
769    add_render_callback(() => dispatch(node, true, "start"));
770    task = loop((now2) => {
771      if (running) {
772        if (now2 >= end_time) {
773          tick2(1, 0);
774          dispatch(node, true, "end");
775          cleanup();
776          return running = false;
777        }
778        if (now2 >= start_time) {
779          const t = easing((now2 - start_time) / duration);
780          tick2(t, 1 - t);
781        }
782      }
783      return running;
784    });
785  }
786  let started = false;
787  return {
788    start() {
789      if (started) return;
790      started = true;
791      delete_rule(node);
792      if (is_function(config)) {
793        config = config(options);
794        wait().then(go);
795      } else {
796        go();
797      }
798    },
799    invalidate() {
800      started = false;
801    },
802    end() {
803      if (running) {
804        cleanup();
805        running = false;
806      }
807    }
808  };
809}
810function ensure_array_like(array_like_or_iterator) {
811  return (array_like_or_iterator == null ? void 0 : array_like_or_iterator.length) !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
812}
813function outro_and_destroy_block(block2, lookup) {
814  transition_out(block2, 1, 1, () => {
815    lookup.delete(block2.key);
816  });
817}
818function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list2, lookup, node, destroy, create_each_block2, next, get_context) {
819  let o = old_blocks.length;
820  let n = list2.length;
821  let i = o;
822  const old_indexes = {};
823  while (i--) old_indexes[old_blocks[i].key] = i;
824  const new_blocks = [];
825  const new_lookup = /* @__PURE__ */ new Map();
826  const deltas = /* @__PURE__ */ new Map();
827  const updates = [];
828  i = n;
829  while (i--) {
830    const child_ctx = get_context(ctx, list2, i);
831    const key = get_key(child_ctx);
832    let block2 = lookup.get(key);
833    if (!block2) {
834      block2 = create_each_block2(key, child_ctx);
835      block2.c();
836    } else {
837      updates.push(() => block2.p(child_ctx, dirty));
838    }
839    new_lookup.set(key, new_blocks[i] = block2);
840    if (key in old_indexes) deltas.set(key, Math.abs(i - old_indexes[key]));
841  }
842  const will_move = /* @__PURE__ */ new Set();
843  const did_move = /* @__PURE__ */ new Set();
844  function insert2(block2) {
845    transition_in(block2, 1);
846    block2.m(node, next);
847    lookup.set(block2.key, block2);
848    next = block2.first;
849    n--;
850  }
851  while (o && n) {
852    const new_block = new_blocks[n - 1];
853    const old_block = old_blocks[o - 1];
854    const new_key = new_block.key;
855    const old_key = old_block.key;
856    if (new_block === old_block) {
857      next = new_block.first;
858      o--;
859      n--;
860    } else if (!new_lookup.has(old_key)) {
861      destroy(old_block, lookup);
862      o--;
863    } else if (!lookup.has(new_key) || will_move.has(new_key)) {
864      insert2(new_block);
865    } else if (did_move.has(old_key)) {
866      o--;
867    } else if (deltas.get(new_key) > deltas.get(old_key)) {
868      did_move.add(new_key);
869      insert2(new_block);
870    } else {
871      will_move.add(old_key);
872      o--;
873    }
874  }
875  while (o--) {
876    const old_block = old_blocks[o];
877    if (!new_lookup.has(old_block.key)) destroy(old_block, lookup);
878  }
879  while (n) insert2(new_blocks[n - 1]);
880  run_all(updates);
881  return new_blocks;
882}
883function get_spread_update(levels, updates) {
884  const update2 = {};
885  const to_null_out = {};
886  const accounted_for = { $$scope: 1 };
887  let i = levels.length;
888  while (i--) {
889    const o = levels[i];
890    const n = updates[i];
891    if (n) {
892      for (const key in o) {
893        if (!(key in n)) to_null_out[key] = 1;
894      }
895      for (const key in n) {
896        if (!accounted_for[key]) {
897          update2[key] = n[key];
898          accounted_for[key] = 1;
899        }
900      }
901      levels[i] = n;
902    } else {
903      for (const key in o) {
904        accounted_for[key] = 1;
905      }
906    }
907  }
908  for (const key in to_null_out) {
909    if (!(key in update2)) update2[key] = void 0;
910  }
911  return update2;
912}
913function get_spread_object(spread_props) {
914  return typeof spread_props === "object" && spread_props !== null ? spread_props : {};
915}
916function bind(component, name, callback) {
917  const index = component.$$.props[name];
918  if (index !== void 0) {
919    component.$$.bound[index] = callback;
920    callback(component.$$.ctx[index]);
921  }
922}
923function create_component(block2) {
924  block2 && block2.c();
925}
926function mount_component(component, target, anchor) {
927  const { fragment, after_update } = component.$$;
928  fragment && fragment.m(target, anchor);
929  add_render_callback(() => {
930    const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
931    if (component.$$.on_destroy) {
932      component.$$.on_destroy.push(...new_on_destroy);
933    } else {
934      run_all(new_on_destroy);
935    }
936    component.$$.on_mount = [];
937  });
938  after_update.forEach(add_render_callback);
939}
940function destroy_component(component, detaching) {
941  const $$ = component.$$;
942  if ($$.fragment !== null) {
943    flush_render_callbacks($$.after_update);
944    run_all($$.on_destroy);
945    $$.fragment && $$.fragment.d(detaching);
946    $$.on_destroy = $$.fragment = null;
947    $$.ctx = [];
948  }
949}
950function make_dirty(component, i) {
951  if (component.$$.dirty[0] === -1) {
952    dirty_components.push(component);
953    schedule_update();
954    component.$$.dirty.fill(0);
955  }
956  component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
957}

958function init(component, options, instance2, create_fragment2, not_equal, props, append_styles = null, dirty = [-1]) {
959  const parent_component = current_component;
960  set_current_component(component);
961  const $$ = component.$$ = {
962    fragment: null,
963    ctx: [],
964    // state
965    props,
966    update: noop,
967    not_equal,
968    bound: blank_object(),
969    // lifecycle
970    on_mount: [],
971    on_destroy: [],
972    on_disconnect: [],
973    before_update: [],
974    after_update: [],
975    context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
976    // everything else
977    callbacks: blank_object(),
978    dirty,
979    skip_bound: false,
980    root: options.target || parent_component.$$.root
981  };
982  append_styles && append_styles($$.root);
983  let ready = false;
984  $$.ctx = instance2 ? instance2(component, options.props || {}, (i, ret, ...rest) => {
985    const value = rest.length ? rest[0] : ret;
986    if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
987      if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
988      if (ready) make_dirty(component, i);
989    }
990    return ret;
991  }) : [];
992  $$.update();
993  ready = true;
994  run_all($$.before_update);
995  $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false;
996  if (options.target) {
997    if (options.hydrate) {
998      const nodes = children(options.target);
999      $$.fragment && $$.fragment.l(nodes);
1000      nodes.forEach(detach);
1001    } else {
1002      $$.fragment && $$.fragment.c();
1003    }
1004    if (options.intro) transition_in(component.$$.fragment);
1005    mount_component(component, options.target, options.anchor);
1006    flush();
1007  }
1008  set_current_component(parent_component);
1009}
1010class SvelteComponent {
1011  constructor() {
1012    /**
1013     * ### PRIVATE API
1014     *
1015     * Do not use, may change at any time
1016     *
1017     * @type {any}
1018     */
1019    __publicField(this, "$$");
1020    /**
1021     * ### PRIVATE API
1022     *
1023     * Do not use, may change at any time
1024     *
1025     * @type {any}
1026     */
1027    __publicField(this, "$$set");
1028  }
1029  /** @returns {void} */
1030  $destroy() {
1031    destroy_component(this, 1);
1032    this.$destroy = noop;
1033  }
1034  /**
1035   * @template {Extract<keyof Events, string>} K
1036   * @param {K} type
1037   * @param {((e: Events[K]) => void) | null | undefined} callback
1038   * @returns {() => void}
1039   */
1040  $on(type, callback) {
1041    if (!is_function(callback)) {
1042      return noop;
1043    }
1044    const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
1045    callbacks.push(callback);
1046    return () => {
1047      const index = callbacks.indexOf(callback);
1048      if (index !== -1) callbacks.splice(index, 1);
1049    };
1050  }
1051  /**
1052   * @param {Partial<Props>} props
1053   * @returns {void}
1054   */
1055  $set(props) {
1056    if (this.$$set && !is_empty(props)) {
1057      this.$$.skip_bound = true;
1058      this.$$set(props);
1059      this.$$.skip_bound = false;
1060    }
1061  }
1062}
1063const PUBLIC_VERSION = "4";
1064if (typeof window !== "undefined")
1065  (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION);
1066function create_if_block_1$f(ctx) {
1067  let svg;
1068  let line0;
1069  let line1;
1070  let mounted;
1071  let dispose;
1072  return {
1073    c() {
1074      svg = svg_element("svg");
1075      line0 = svg_element("line");
1076      line1 = svg_element("line");
1077      attr(line0, "x1", "1");
1078      attr(line0, "y1", "9");
1079      attr(line0, "x2", "9");
1080      attr(line0, "y2", "1");
1081      attr(line0, "stroke", "gray");
1082      attr(line0, "stroke-width", "0.5");
1083      attr(line1, "x1", "5");
1084      attr(line1, "y1", "9");
1085      attr(line1, "x2", "9");
1086      attr(line1, "y2", "5");
1087      attr(line1, "stroke", "gray");
1088      attr(line1, "stroke-width", "0.5");
1089      attr(svg, "class", "resize-handle svelte-239wnu");
1090      attr(svg, "xmlns", "http://www.w3.org/2000/svg");
1091      attr(svg, "viewBox", "0 0 10 10");
1092    },
1093    m(target, anchor) {
1094      insert(target, svg, anchor);
1095      append(svg, line0);
1096      append(svg, line1);
1097      if (!mounted) {
1098        dispose = listen(
1099          svg,
1100          "mousedown",
1101          /*resize*/
1102          ctx[27]
1103        );
1104        mounted = true;
1105      }
1106    },
1107    p: noop,
1108    d(detaching) {
1109      if (detaching) {
1110        detach(svg);
1111      }
1112      mounted = false;

1113      dispose();
1114    }
1115  };
1116}
1117function create_dynamic_element(ctx) {
1118  var _a;
1119  let svelte_element;
1120  let t;
1121  let svelte_element_class_value;
1122  let svelte_element_dir_value;
1123  let current;
1124  const default_slot_template = (
1125    /*#slots*/
1126    ctx[31].default
1127  );
1128  const default_slot = create_slot(
1129    default_slot_template,
1130    ctx,
1131    /*$$scope*/
1132    ctx[30],
1133    null
1134  );
1135  let if_block = (
1136    /*resizable*/
1137    ctx[19] && create_if_block_1$f(ctx)
1138  );
1139  let svelte_element_levels = [
1140    { "data-testid": (
1141      /*test_id*/
1142      ctx[11]
1143    ) },
1144    { id: (
1145      /*elem_id*/
1146      ctx[6]
1147    ) },
1148    {
1149      class: svelte_element_class_value = "block " + /*elem_classes*/
1150      (((_a = ctx[7]) == null ? void 0 : _a.join(" ")) || "") + " svelte-239wnu"
1151    },
1152    {
1153      dir: svelte_element_dir_value = /*rtl*/
1154      ctx[20] ? "rtl" : "ltr"
1155    }
1156  ];
1157  let svelte_element_data = {};
1158  for (let i = 0; i < svelte_element_levels.length; i += 1) {
1159    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
1160  }
1161  return {
1162    c() {
1163      svelte_element = element(
1164        /*tag*/
1165        ctx[25]
1166      );
1167      if (default_slot) default_slot.c();
1168      t = space();
1169      if (if_block) if_block.c();
1170      set_dynamic_element_data(
1171        /*tag*/
1172        ctx[25]
1173      )(svelte_element, svelte_element_data);
1174      toggle_class(
1175        svelte_element,
1176        "hidden",
1177        /*visible*/
1178        ctx[14] === false || /*visible*/
1179        ctx[14] === "hidden"
1180      );
1181      toggle_class(
1182        svelte_element,
1183        "padded",
1184        /*padding*/
1185        ctx[10]
1186      );
1187      toggle_class(
1188        svelte_element,
1189        "flex",
1190        /*flex*/
1191        ctx[1]
1192      );
1193      toggle_class(
1194        svelte_element,
1195        "border_focus",
1196        /*border_mode*/
1197        ctx[9] === "focus"
1198      );
1199      toggle_class(
1200        svelte_element,
1201        "border_contrast",
1202        /*border_mode*/
1203        ctx[9] === "contrast"
1204      );
1205      toggle_class(svelte_element, "hide-container", !/*explicit_call*/
1206      ctx[12] && !/*container*/
1207      ctx[13]);
1208      toggle_class(
1209        svelte_element,
1210        "fullscreen",
1211        /*fullscreen*/
1212        ctx[0]
1213      );
1214      toggle_class(
1215        svelte_element,
1216        "animating",
1217        /*fullscreen*/
1218        ctx[0] && /*preexpansionBoundingRect*/
1219        ctx[24] !== null
1220      );
1221      toggle_class(
1222        svelte_element,
1223        "auto-margin",
1224        /*scale*/
1225        ctx[17] === null
1226      );
1227      set_style(
1228        svelte_element,
1229        "height",
1230        /*fullscreen*/
1231        ctx[0] ? void 0 : (
1232          /*get_dimension*/
1233          ctx[26](
1234            /*height*/
1235            ctx[2]
1236          )
1237        )
1238      );
1239      set_style(
1240        svelte_element,
1241        "min-height",
1242        /*fullscreen*/
1243        ctx[0] ? void 0 : (
1244          /*get_dimension*/
1245          ctx[26](
1246            /*min_height*/
1247            ctx[3]
1248          )
1249        )
1250      );
1251      set_style(
1252        svelte_element,
1253        "max-height",
1254        /*fullscreen*/
1255        ctx[0] ? void 0 : (
1256          /*get_dimension*/
1257          ctx[26](
1258            /*max_height*/
1259            ctx[4]
1260          )
1261        )
1262      );
1263      set_style(
1264        svelte_element,
1265        "--start-top",
1266        /*preexpansionBoundingRect*/
1267        ctx[24] ? `${/*preexpansionBoundingRect*/
1268        ctx[24].top}px` : "0px"
1269      );
1270      set_style(
1271        svelte_element,
1272        "--start-left",
1273        /*preexpansionBoundingRect*/
1274        ctx[24] ? `${/*preexpansionBoundingRect*/
1275        ctx[24].left}px` : "0px"
1276      );
1277      set_style(
1278        svelte_element,
1279        "--start-width",
1280        /*preexpansionBoundingRect*/
1281        ctx[24] ? `${/*preexpansionBoundingRect*/
1282        ctx[24].width}px` : "0px"
1283      );
1284      set_style(
1285        svelte_element,
1286        "--start-height",
1287        /*preexpansionBoundingRect*/
1288        ctx[24] ? `${/*preexpansionBoundingRect*/
1289        ctx[24].height}px` : "0px"
1290      );
1291      set_style(
1292        svelte_element,
1293        "width",
1294        /*fullscreen*/
1295        ctx[0] ? void 0 : typeof /*width*/
1296        ctx[5] === "number" ? `calc(min(${/*width*/
1297        ctx[5]}px, 100%))` : (
1298          /*get_dimension*/
1299          ctx[26](
1300            /*width*/
1301            ctx[5]
1302          )
1303        )
1304      );
1305      set_style(
1306        svelte_element,
1307        "border-style",
1308        /*variant*/
1309        ctx[8]
1310      );
1311      set_style(
1312        svelte_element,
1313        "overflow",
1314        /*allow_overflow*/
1315        ctx[15] ? (
1316          /*overflow_behavior*/
1317          ctx[16]
1318        ) : "hidden"
1319      );
1320      set_style(
1321        svelte_element,
1322        "flex-grow",
1323        /*scale*/
1324        ctx[17]
1325      );
1326      set_style(svelte_element, "min-width", `calc(min(${/*min_width*/
1327      ctx[18]}px, 100%))`);
1328      set_style(svelte_element, "border-width", `var(--block-border-width)`);
1329    },
1330    m(target, anchor) {

1331      insert(target, svelte_element, anchor);
1332      if (default_slot) {
1333        default_slot.m(svelte_element, null);
1334      }
1335      append(svelte_element, t);
1336      if (if_block) if_block.m(svelte_element, null);
1337      ctx[32](svelte_element);
1338      current = true;
1339    },
1340    p(ctx2, dirty) {
1341      var _a2;
1342      if (default_slot) {
1343        if (default_slot.p && (!current || dirty[0] & /*$$scope*/
1344        1073741824)) {
1345          update_slot_base(
1346            default_slot,
1347            default_slot_template,
1348            ctx2,
1349            /*$$scope*/
1350            ctx2[30],
1351            !current ? get_all_dirty_from_scope(
1352              /*$$scope*/
1353              ctx2[30]
1354            ) : get_slot_changes(
1355              default_slot_template,
1356              /*$$scope*/
1357              ctx2[30],
1358              dirty,
1359              null
1360            ),
1361            null
1362          );
1363        }
1364      }
1365      if (
1366        /*resizable*/
1367        ctx2[19]
1368      ) {
1369        if (if_block) {
1370          if_block.p(ctx2, dirty);
1371        } else {
1372          if_block = create_if_block_1$f(ctx2);
1373          if_block.c();
1374          if_block.m(svelte_element, null);
1375        }
1376      } else if (if_block) {
1377        if_block.d(1);
1378        if_block = null;
1379      }
1380      set_dynamic_element_data(
1381        /*tag*/
1382        ctx2[25]
1383      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
1384        (!current || dirty[0] & /*test_id*/
1385        2048) && { "data-testid": (
1386          /*test_id*/
1387          ctx2[11]
1388        ) },
1389        (!current || dirty[0] & /*elem_id*/
1390        64) && { id: (
1391          /*elem_id*/
1392          ctx2[6]
1393        ) },
1394        (!current || dirty[0] & /*elem_classes*/
1395        128 && svelte_element_class_value !== (svelte_element_class_value = "block " + /*elem_classes*/
1396        (((_a2 = ctx2[7]) == null ? void 0 : _a2.join(" ")) || "") + " svelte-239wnu")) && { class: svelte_element_class_value },
1397        (!current || dirty[0] & /*rtl*/
1398        1048576 && svelte_element_dir_value !== (svelte_element_dir_value = /*rtl*/
1399        ctx2[20] ? "rtl" : "ltr")) && { dir: svelte_element_dir_value }
1400      ]));
1401      toggle_class(
1402        svelte_element,
1403        "hidden",
1404        /*visible*/
1405        ctx2[14] === false || /*visible*/
1406        ctx2[14] === "hidden"
1407      );
1408      toggle_class(
1409        svelte_element,
1410        "padded",
1411        /*padding*/
1412        ctx2[10]
1413      );
1414      toggle_class(
1415        svelte_element,
1416        "flex",
1417        /*flex*/
1418        ctx2[1]
1419      );
1420      toggle_class(
1421        svelte_element,
1422        "border_focus",
1423        /*border_mode*/
1424        ctx2[9] === "focus"
1425      );
1426      toggle_class(
1427        svelte_element,
1428        "border_contrast",
1429        /*border_mode*/
1430        ctx2[9] === "contrast"
1431      );
1432      toggle_class(svelte_element, "hide-container", !/*explicit_call*/
1433      ctx2[12] && !/*container*/
1434      ctx2[13]);
1435      toggle_class(
1436        svelte_element,
1437        "fullscreen",
1438        /*fullscreen*/
1439        ctx2[0]
1440      );
1441      toggle_class(
1442        svelte_element,
1443        "animating",
1444        /*fullscreen*/
1445        ctx2[0] && /*preexpansionBoundingRect*/
1446        ctx2[24] !== null
1447      );
1448      toggle_class(
1449        svelte_element,
1450        "auto-margin",
1451        /*scale*/
1452        ctx2[17] === null
1453      );
1454      if (dirty[0] & /*fullscreen, height*/
1455      5) {
1456        set_style(
1457          svelte_element,
1458          "height",
1459          /*fullscreen*/
1460          ctx2[0] ? void 0 : (
1461            /*get_dimension*/
1462            ctx2[26](
1463              /*height*/
1464              ctx2[2]
1465            )
1466          )
1467        );
1468      }
1469      if (dirty[0] & /*fullscreen, min_height*/
1470      9) {
1471        set_style(
1472          svelte_element,
1473          "min-height",
1474          /*fullscreen*/
1475          ctx2[0] ? void 0 : (
1476            /*get_dimension*/
1477            ctx2[26](
1478              /*min_height*/
1479              ctx2[3]
1480            )
1481          )
1482        );
1483      }
1484      if (dirty[0] & /*fullscreen, max_height*/
1485      17) {
1486        set_style(
1487          svelte_element,
1488          "max-height",
1489          /*fullscreen*/
1490          ctx2[0] ? void 0 : (
1491            /*get_dimension*/
1492            ctx2[26](
1493              /*max_height*/
1494              ctx2[4]
1495            )
1496          )
1497        );
1498      }

1499      if (dirty[0] & /*preexpansionBoundingRect*/
1500      16777216) {
1501        set_style(
1502          svelte_element,
1503          "--start-top",
1504          /*preexpansionBoundingRect*/
1505          ctx2[24] ? `${/*preexpansionBoundingRect*/
1506          ctx2[24].top}px` : "0px"
1507        );
1508      }
1509      if (dirty[0] & /*preexpansionBoundingRect*/
1510      16777216) {
1511        set_style(
1512          svelte_element,
1513          "--start-left",
1514          /*preexpansionBoundingRect*/
1515          ctx2[24] ? `${/*preexpansionBoundingRect*/
1516          ctx2[24].left}px` : "0px"
1517        );
1518      }
1519      if (dirty[0] & /*preexpansionBoundingRect*/
1520      16777216) {
1521        set_style(
1522          svelte_element,
1523          "--start-width",
1524          /*preexpansionBoundingRect*/
1525          ctx2[24] ? `${/*preexpansionBoundingRect*/
1526          ctx2[24].width}px` : "0px"
1527        );
1528      }
1529      if (dirty[0] & /*preexpansionBoundingRect*/
1530      16777216) {
1531        set_style(
1532          svelte_element,
1533          "--start-height",
1534          /*preexpansionBoundingRect*/
1535          ctx2[24] ? `${/*preexpansionBoundingRect*/
1536          ctx2[24].height}px` : "0px"
1537        );
1538      }
1539      if (dirty[0] & /*fullscreen, width*/
1540      33) {
1541        set_style(
1542          svelte_element,
1543          "width",
1544          /*fullscreen*/
1545          ctx2[0] ? void 0 : typeof /*width*/
1546          ctx2[5] === "number" ? `calc(min(${/*width*/
1547          ctx2[5]}px, 100%))` : (
1548            /*get_dimension*/
1549            ctx2[26](
1550              /*width*/
1551              ctx2[5]
1552            )
1553          )
1554        );
1555      }
1556      if (dirty[0] & /*variant*/
1557      256) {
1558        set_style(
1559          svelte_element,
1560          "border-style",
1561          /*variant*/
1562          ctx2[8]
1563        );
1564      }
1565      if (dirty[0] & /*allow_overflow, overflow_behavior*/
1566      98304) {
1567        set_style(
1568          svelte_element,
1569          "overflow",
1570          /*allow_overflow*/
1571          ctx2[15] ? (
1572            /*overflow_behavior*/
1573            ctx2[16]
1574          ) : "hidden"
1575        );
1576      }
1577      if (dirty[0] & /*scale*/
1578      131072) {
1579        set_style(
1580          svelte_element,
1581          "flex-grow",
1582          /*scale*/
1583          ctx2[17]
1584        );
1585      }
1586      if (dirty[0] & /*min_width*/
1587      262144) {
1588        set_style(svelte_element, "min-width", `calc(min(${/*min_width*/
1589        ctx2[18]}px, 100%))`);
1590      }
1591    },
1592    i(local) {
1593      if (current) return;
1594      transition_in(default_slot, local);
1595      current = true;
1596    },
1597    o(local) {
1598      transition_out(default_slot, local);
1599      current = false;
1600    },
1601    d(detaching) {
1602      if (detaching) {
1603        detach(svelte_element);
1604      }
1605      if (default_slot) default_slot.d(detaching);
1606      if (if_block) if_block.d();
1607      ctx[32](null);
1608    }
1609  };
1610}
1611function create_if_block$m(ctx) {
1612  let div;
1613  return {
1614    c() {
1615      div = element("div");
1616      attr(div, "class", "placeholder svelte-239wnu");
1617      set_style(
1618        div,
1619        "height",
1620        /*placeholder_height*/
1621        ctx[22] + "px"
1622      );
1623      set_style(
1624        div,
1625        "width",
1626        /*placeholder_width*/
1627        ctx[23] + "px"
1628      );
1629    },
1630    m(target, anchor) {
1631      insert(target, div, anchor);
1632    },
1633    p(ctx2, dirty) {
1634      if (dirty[0] & /*placeholder_height*/
1635      4194304) {
1636        set_style(
1637          div,
1638          "height",
1639          /*placeholder_height*/
1640          ctx2[22] + "px"
1641        );
1642      }
1643      if (dirty[0] & /*placeholder_width*/
1644      8388608) {
1645        set_style(
1646          div,
1647          "width",
1648          /*placeholder_width*/
1649          ctx2[23] + "px"
1650        );
1651      }
1652    },
1653    d(detaching) {
1654      if (detaching) {
1655        detach(div);
1656      }
1657    }
1658  };
1659}
1660function create_fragment$W(ctx) {
1661  let t;
1662  let if_block_anchor;
1663  let current;
1664  let svelte_element = (
1665    /*tag*/
1666    ctx[25] && create_dynamic_element(ctx)
1667  );
1668  let if_block = (
1669    /*fullscreen*/
1670    ctx[0] && create_if_block$m(ctx)
1671  );
1672  return {
1673    c() {
1674      if (svelte_element) svelte_element.c();
1675      t = space();
1676      if (if_block) if_block.c();
1677      if_block_anchor = empty();
1678    },
1679    m(target, anchor) {
1680      if (svelte_element) svelte_element.m(target, anchor);
1681      insert(target, t, anchor);
1682      if (if_block) if_block.m(target, anchor);
1683      insert(target, if_block_anchor, anchor);
1684      current = true;
1685    },
1686    p(ctx2, dirty) {
1687      if (
1688        /*tag*/
1689        ctx2[25]
1690      ) {
1691        svelte_element.p(ctx2, dirty);
1692      }
1693      if (
1694        /*fullscreen*/
1695        ctx2[0]
1696      ) {
1697        if (if_block) {
1698          if_block.p(ctx2, dirty);
1699        } else {
1700          if_block = create_if_block$m(ctx2);
1701          if_block.c();
1702          if_block.m(if_block_anchor.parentNode, if_block_anchor);
1703        }
1704      } else if (if_block) {
1705        if_block.d(1);
1706        if_block = null;
1707      }
1708    },
1709    i(local) {
1710      if (current) return;
1711      transition_in(svelte_element, local);
1712      current = true;
1713    },
1714    o(local) {
1715      transition_out(svelte_element, local);
1716      current = false;

1717    },
1718    d(detaching) {
1719      if (detaching) {
1720        detach(t);
1721        detach(if_block_anchor);
1722      }
1723      if (svelte_element) svelte_element.d(detaching);
1724      if (if_block) if_block.d(detaching);
1725    }
1726  };
1727}
1728function instance$F($$self, $$props, $$invalidate) {
1729  let { $$slots: slots = {}, $$scope } = $$props;
1730  let { height: height2 = void 0 } = $$props;
1731  let { min_height = void 0 } = $$props;
1732  let { max_height = void 0 } = $$props;
1733  let { width = void 0 } = $$props;
1734  let { elem_id = "" } = $$props;
1735  let { elem_classes = [] } = $$props;
1736  let { variant = "solid" } = $$props;
1737  let { border_mode = "base" } = $$props;
1738  let { padding = true } = $$props;
1739  let { type = "normal" } = $$props;
1740  let { test_id = void 0 } = $$props;
1741  let { explicit_call = false } = $$props;
1742  let { container = true } = $$props;
1743  let { visible = true } = $$props;
1744  let { allow_overflow = true } = $$props;
1745  let { overflow_behavior = "auto" } = $$props;
1746  let { scale = null } = $$props;
1747  let { min_width = 0 } = $$props;
1748  let { flex = false } = $$props;
1749  let { resizable = false } = $$props;
1750  let { rtl = false } = $$props;
1751  let { fullscreen = false } = $$props;
1752  let old_fullscreen = fullscreen;
1753  let element2;
1754  let tag2 = type === "fieldset" ? "fieldset" : "div";
1755  let placeholder_height = 0;
1756  let placeholder_width = 0;
1757  let preexpansionBoundingRect = null;
1758  function handleKeydown(event) {
1759    if (fullscreen && event.key === "Escape") {
1760      $$invalidate(0, fullscreen = false);
1761    }
1762  }
1763  const get_dimension = (dimension_value) => {
1764    if (dimension_value === void 0) {
1765      return void 0;
1766    }
1767    if (typeof dimension_value === "number") {
1768      return dimension_value + "px";
1769    } else if (typeof dimension_value === "string") {
1770      return dimension_value;
1771    }
1772  };
1773  const resize = (e) => {
1774    let prevY = e.clientY;
1775    const onMouseMove = (e2) => {
1776      const dy = e2.clientY - prevY;
1777      prevY = e2.clientY;
1778      $$invalidate(21, element2.style.height = `${element2.offsetHeight + dy}px`, element2);
1779    };
1780    const onMouseUp = () => {
1781      window.removeEventListener("mousemove", onMouseMove);
1782      window.removeEventListener("mouseup", onMouseUp);
1783    };
1784    window.addEventListener("mousemove", onMouseMove);
1785    window.addEventListener("mouseup", onMouseUp);
1786  };
1787  function svelte_element_binding($$value) {
1788    binding_callbacks[$$value ? "unshift" : "push"](() => {
1789      element2 = $$value;
1790      $$invalidate(21, element2);
1791    });
1792  }
1793  $$self.$$set = ($$props2) => {
1794    if ("height" in $$props2) $$invalidate(2, height2 = $$props2.height);
1795    if ("min_height" in $$props2) $$invalidate(3, min_height = $$props2.min_height);
1796    if ("max_height" in $$props2) $$invalidate(4, max_height = $$props2.max_height);
1797    if ("width" in $$props2) $$invalidate(5, width = $$props2.width);
1798    if ("elem_id" in $$props2) $$invalidate(6, elem_id = $$props2.elem_id);
1799    if ("elem_classes" in $$props2) $$invalidate(7, elem_classes = $$props2.elem_classes);
1800    if ("variant" in $$props2) $$invalidate(8, variant = $$props2.variant);
1801    if ("border_mode" in $$props2) $$invalidate(9, border_mode = $$props2.border_mode);
1802    if ("padding" in $$props2) $$invalidate(10, padding = $$props2.padding);
1803    if ("type" in $$props2) $$invalidate(28, type = $$props2.type);
1804    if ("test_id" in $$props2) $$invalidate(11, test_id = $$props2.test_id);
1805    if ("explicit_call" in $$props2) $$invalidate(12, explicit_call = $$props2.explicit_call);
1806    if ("container" in $$props2) $$invalidate(13, container = $$props2.container);
1807    if ("visible" in $$props2) $$invalidate(14, visible = $$props2.visible);
1808    if ("allow_overflow" in $$props2) $$invalidate(15, allow_overflow = $$props2.allow_overflow);
1809    if ("overflow_behavior" in $$props2) $$invalidate(16, overflow_behavior = $$props2.overflow_behavior);
1810    if ("scale" in $$props2) $$invalidate(17, scale = $$props2.scale);
1811    if ("min_width" in $$props2) $$invalidate(18, min_width = $$props2.min_width);
1812    if ("flex" in $$props2) $$invalidate(1, flex = $$props2.flex);

1813    if ("resizable" in $$props2) $$invalidate(19, resizable = $$props2.resizable);
1814    if ("rtl" in $$props2) $$invalidate(20, rtl = $$props2.rtl);
1815    if ("fullscreen" in $$props2) $$invalidate(0, fullscreen = $$props2.fullscreen);
1816    if ("$$scope" in $$props2) $$invalidate(30, $$scope = $$props2.$$scope);
1817  };
1818  $$self.$$.update = () => {
1819    if ($$self.$$.dirty[0] & /*fullscreen, old_fullscreen, element*/
1820    538968065) {
1821      if (fullscreen !== old_fullscreen) {
1822        $$invalidate(29, old_fullscreen = fullscreen);
1823        if (fullscreen) {
1824          $$invalidate(24, preexpansionBoundingRect = element2.getBoundingClientRect());
1825          $$invalidate(22, placeholder_height = element2.offsetHeight);
1826          $$invalidate(23, placeholder_width = element2.offsetWidth);
1827          window.addEventListener("keydown", handleKeydown);
1828        } else {
1829          $$invalidate(24, preexpansionBoundingRect = null);
1830          window.removeEventListener("keydown", handleKeydown);
1831        }
1832      }
1833    }
1834    if ($$self.$$.dirty[0] & /*visible*/
1835    16384) {
1836      if (!visible) {
1837        $$invalidate(1, flex = false);
1838      }
1839    }
1840  };
1841  return [
1842    fullscreen,
1843    flex,
1844    height2,
1845    min_height,
1846    max_height,
1847    width,
1848    elem_id,
1849    elem_classes,
1850    variant,
1851    border_mode,
1852    padding,
1853    test_id,
1854    explicit_call,
1855    container,
1856    visible,
1857    allow_overflow,
1858    overflow_behavior,
1859    scale,
1860    min_width,
1861    resizable,
1862    rtl,
1863    element2,
1864    placeholder_height,
1865    placeholder_width,
1866    preexpansionBoundingRect,
1867    tag2,
1868    get_dimension,
1869    resize,
1870    type,
1871    old_fullscreen,
1872    $$scope,
1873    slots,
1874    svelte_element_binding
1875  ];
1876}
1877class Block extends SvelteComponent {
1878  constructor(options) {
1879    super();
1880    init(
1881      this,
1882      options,
1883      instance$F,
1884      create_fragment$W,
1885      safe_not_equal,
1886      {
1887        height: 2,
1888        min_height: 3,
1889        max_height: 4,
1890        width: 5,
1891        elem_id: 6,
1892        elem_classes: 7,
1893        variant: 8,
1894        border_mode: 9,
1895        padding: 10,
1896        type: 28,
1897        test_id: 11,
1898        explicit_call: 12,
1899        container: 13,
1900        visible: 14,
1901        allow_overflow: 15,
1902        overflow_behavior: 16,
1903        scale: 17,
1904        min_width: 18,
1905        flex: 1,
1906        resizable: 19,
1907        rtl: 20,
1908        fullscreen: 0
1909      },
1910      null,
1911      [-1, -1]
1912    );
1913  }
1914}
1915function _getDefaults() {
1916  return {
1917    async: false,
1918    breaks: false,
1919    extensions: null,
1920    gfm: true,
1921    hooks: null,
1922    pedantic: false,
1923    renderer: null,
1924    silent: false,
1925    tokenizer: null,
1926    walkTokens: null
1927  };
1928}
1929let _defaults = _getDefaults();
1930function changeDefaults(newDefaults) {
1931  _defaults = newDefaults;
1932}
1933const escapeTest$1 = /[&<>"']/;
1934const escapeReplace$1 = new RegExp(escapeTest$1.source, "g");
1935const escapeTestNoEncode$1 = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
1936const escapeReplaceNoEncode$1 = new RegExp(escapeTestNoEncode$1.source, "g");
1937const escapeReplacements$1 = {
1938  "&": "&amp;",
1939  "<": "&lt;",
1940  ">": "&gt;",
1941  '"': "&quot;",
1942  "'": "&#39;"
1943};
1944const getEscapeReplacement$1 = (ch) => escapeReplacements$1[ch];
1945function escape$1$1(html2, encode) {
1946  if (encode) {
1947    if (escapeTest$1.test(html2)) {
1948      return html2.replace(escapeReplace$1, getEscapeReplacement$1);
1949    }
1950  } else {
1951    if (escapeTestNoEncode$1.test(html2)) {
1952      return html2.replace(escapeReplaceNoEncode$1, getEscapeReplacement$1);
1953    }
1954  }
1955  return html2;
1956}
1957const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
1958function unescape(html2) {
1959  return html2.replace(unescapeTest, (_, n) => {
1960    n = n.toLowerCase();
1961    if (n === "colon")
1962      return ":";
1963    if (n.charAt(0) === "#") {
1964      return n.charAt(1) === "x" ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
1965    }
1966    return "";
1967  });
1968}
1969const caret = /(^|[^\[])\^/g;
1970function edit(regex2, opt) {
1971  let source = typeof regex2 === "string" ? regex2 : regex2.source;
1972  opt = opt || "";
1973  const obj = {
1974    replace: (name, val) => {
1975      let valSource = typeof val === "string" ? val : val.source;
1976      valSource = valSource.replace(caret, "$1");
1977      source = source.replace(name, valSource);
1978      return obj;
1979    },
1980    getRegex: () => {
1981      return new RegExp(source, opt);
1982    }
1983  };
1984  return obj;
1985}
1986function cleanUrl(href) {
1987  try {
1988    href = encodeURI(href).replace(/%25/g, "%");
1989  } catch (e) {
1990    return null;
1991  }
1992  return href;
1993}
1994const noopTest = { exec: () => null };
1995function splitCells(tableRow, count) {

1996  const row = tableRow.replace(/\|/g, (match, offset, str) => {
1997    let escaped = false;
1998    let curr = offset;
1999    while (--curr >= 0 && str[curr] === "\\")
2000      escaped = !escaped;
2001    if (escaped) {
2002      return "|";
2003    } else {
2004      return " |";
2005    }
2006  }), cells = row.split(/ \|/);
2007  let i = 0;
2008  if (!cells[0].trim()) {
2009    cells.shift();
2010  }
2011  if (cells.length > 0 && !cells[cells.length - 1].trim()) {
2012    cells.pop();
2013  }
2014  if (count) {
2015    if (cells.length > count) {
2016      cells.splice(count);
2017    } else {
2018      while (cells.length < count)
2019        cells.push("");
2020    }
2021  }
2022  for (; i < cells.length; i++) {
2023    cells[i] = cells[i].trim().replace(/\\\|/g, "|");
2024  }
2025  return cells;
2026}
2027function rtrim(str, c, invert) {
2028  const l = str.length;
2029  if (l === 0) {
2030    return "";
2031  }
2032  let suffLen = 0;
2033  while (suffLen < l) {
2034    const currChar = str.charAt(l - suffLen - 1);
2035    if (currChar === c && true) {
2036      suffLen++;
2037    } else {
2038      break;
2039    }
2040  }
2041  return str.slice(0, l - suffLen);
2042}
2043function findClosingBracket(str, b) {
2044  if (str.indexOf(b[1]) === -1) {
2045    return -1;
2046  }
2047  let level = 0;
2048  for (let i = 0; i < str.length; i++) {
2049    if (str[i] === "\\") {
2050      i++;
2051    } else if (str[i] === b[0]) {
2052      level++;
2053    } else if (str[i] === b[1]) {
2054      level--;
2055      if (level < 0) {
2056        return i;
2057      }
2058    }
2059  }
2060  return -1;
2061}
2062function outputLink(cap, link2, raw, lexer) {
2063  const href = link2.href;
2064  const title = link2.title ? escape$1$1(link2.title) : null;
2065  const text2 = cap[1].replace(/\\([\[\]])/g, "$1");
2066  if (cap[0].charAt(0) !== "!") {
2067    lexer.state.inLink = true;
2068    const token = {
2069      type: "link",
2070      raw,
2071      href,
2072      title,
2073      text: text2,
2074      tokens: lexer.inlineTokens(text2)
2075    };
2076    lexer.state.inLink = false;
2077    return token;
2078  }
2079  return {
2080    type: "image",
2081    raw,
2082    href,
2083    title,
2084    text: escape$1$1(text2)
2085  };
2086}
2087function indentCodeCompensation(raw, text2) {
2088  const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
2089  if (matchIndentToCode === null) {
2090    return text2;
2091  }
2092  const indentToCode = matchIndentToCode[1];
2093  return text2.split("\n").map((node) => {
2094    const matchIndentInNode = node.match(/^\s+/);
2095    if (matchIndentInNode === null) {
2096      return node;
2097    }
2098    const [indentInNode] = matchIndentInNode;
2099    if (indentInNode.length >= indentToCode.length) {
2100      return node.slice(indentToCode.length);
2101    }
2102    return node;
2103  }).join("\n");
2104}
2105class _Tokenizer {
2106  // set by the lexer
2107  constructor(options) {
2108    __publicField(this, "options");
2109    __publicField(this, "rules");
2110    // set by the lexer
2111    __publicField(this, "lexer");
2112    this.options = options || _defaults;
2113  }
2114  space(src) {
2115    const cap = this.rules.block.newline.exec(src);
2116    if (cap && cap[0].length > 0) {
2117      return {
2118        type: "space",
2119        raw: cap[0]
2120      };
2121    }
2122  }
2123  code(src) {
2124    const cap = this.rules.block.code.exec(src);
2125    if (cap) {
2126      const text2 = cap[0].replace(/^ {1,4}/gm, "");
2127      return {
2128        type: "code",
2129        raw: cap[0],
2130        codeBlockStyle: "indented",
2131        text: !this.options.pedantic ? rtrim(text2, "\n") : text2
2132      };
2133    }
2134  }
2135  fences(src) {
2136    const cap = this.rules.block.fences.exec(src);
2137    if (cap) {
2138      const raw = cap[0];
2139      const text2 = indentCodeCompensation(raw, cap[3] || "");
2140      return {
2141        type: "code",
2142        raw,
2143        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
2144        text: text2
2145      };
2146    }
2147  }
2148  heading(src) {
2149    const cap = this.rules.block.heading.exec(src);
2150    if (cap) {
2151      let text2 = cap[2].trim();
2152      if (/#$/.test(text2)) {
2153        const trimmed = rtrim(text2, "#");
2154        if (this.options.pedantic) {
2155          text2 = trimmed.trim();
2156        } else if (!trimmed || / $/.test(trimmed)) {
2157          text2 = trimmed.trim();
2158        }
2159      }
2160      return {
2161        type: "heading",
2162        raw: cap[0],
2163        depth: cap[1].length,
2164        text: text2,
2165        tokens: this.lexer.inline(text2)
2166      };
2167    }
2168  }
2169  hr(src) {
2170    const cap = this.rules.block.hr.exec(src);
2171    if (cap) {
2172      return {
2173        type: "hr",
2174        raw: cap[0]
2175      };
2176    }
2177  }
2178  blockquote(src) {
2179    const cap = this.rules.block.blockquote.exec(src);
2180    if (cap) {
2181      let text2 = cap[0].replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, "\n    $1");
2182      text2 = rtrim(text2.replace(/^ *>[ \t]?/gm, ""), "\n");
2183      const top = this.lexer.state.top;
2184      this.lexer.state.top = true;
2185      const tokens = this.lexer.blockTokens(text2);
2186      this.lexer.state.top = top;
2187      return {
2188        type: "blockquote",
2189        raw: cap[0],
2190        tokens,
2191        text: text2
2192      };
2193    }
2194  }
2195  list(src) {

2196    let cap = this.rules.block.list.exec(src);
2197    if (cap) {
2198      let bull = cap[1].trim();
2199      const isordered = bull.length > 1;
2200      const list2 = {
2201        type: "list",
2202        raw: "",
2203        ordered: isordered,
2204        start: isordered ? +bull.slice(0, -1) : "",
2205        loose: false,
2206        items: []
2207      };
2208      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
2209      if (this.options.pedantic) {
2210        bull = isordered ? bull : "[*+-]";
2211      }
2212      const itemRegex = new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`);
2213      let raw = "";
2214      let itemContents = "";
2215      let endsWithBlankLine = false;
2216      while (src) {
2217        let endEarly = false;
2218        if (!(cap = itemRegex.exec(src))) {
2219          break;
2220        }
2221        if (this.rules.block.hr.test(src)) {
2222          break;
2223        }
2224        raw = cap[0];
2225        src = src.substring(raw.length);
2226        let line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length));
2227        let nextLine = src.split("\n", 1)[0];
2228        let indent = 0;
2229        if (this.options.pedantic) {
2230          indent = 2;
2231          itemContents = line.trimStart();
2232        } else {
2233          indent = cap[2].search(/[^ ]/);
2234          indent = indent > 4 ? 1 : indent;
2235          itemContents = line.slice(indent);
2236          indent += cap[1].length;
2237        }
2238        let blankLine = false;
2239        if (!line && /^ *$/.test(nextLine)) {
2240          raw += nextLine + "\n";
2241          src = src.substring(nextLine.length + 1);
2242          endEarly = true;
2243        }
2244        if (!endEarly) {
2245          const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`);
2246          const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
2247          const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
2248          const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
2249          while (src) {
2250            const rawLine = src.split("\n", 1)[0];
2251            nextLine = rawLine;
2252            if (this.options.pedantic) {
2253              nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ");
2254            }
2255            if (fencesBeginRegex.test(nextLine)) {
2256              break;
2257            }
2258            if (headingBeginRegex.test(nextLine)) {
2259              break;
2260            }
2261            if (nextBulletRegex.test(nextLine)) {
2262              break;
2263            }
2264            if (hrRegex.test(src)) {
2265              break;
2266            }
2267            if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) {
2268              itemContents += "\n" + nextLine.slice(indent);
2269            } else {
2270              if (blankLine) {
2271                break;
2272              }
2273              if (line.search(/[^ ]/) >= 4) {
2274                break;
2275              }
2276              if (fencesBeginRegex.test(line)) {
2277                break;
2278              }
2279              if (headingBeginRegex.test(line)) {
2280                break;
2281              }
2282              if (hrRegex.test(line)) {
2283                break;
2284              }
2285              itemContents += "\n" + nextLine;
2286            }
2287            if (!blankLine && !nextLine.trim()) {
2288              blankLine = true;
2289            }
2290            raw += rawLine + "\n";
2291            src = src.substring(rawLine.length + 1);
2292            line = nextLine.slice(indent);
2293          }
2294        }
2295        if (!list2.loose) {
2296          if (endsWithBlankLine) {
2297            list2.loose = true;
2298          } else if (/\n *\n *$/.test(raw)) {
2299            endsWithBlankLine = true;
2300          }
2301        }
2302        let istask = null;
2303        let ischecked;
2304        if (this.options.gfm) {
2305          istask = /^\[[ xX]\] /.exec(itemContents);
2306          if (istask) {
2307            ischecked = istask[0] !== "[ ] ";
2308            itemContents = itemContents.replace(/^\[[ xX]\] +/, "");
2309          }
2310        }
2311        list2.items.push({
2312          type: "list_item",
2313          raw,
2314          task: !!istask,
2315          checked: ischecked,
2316          loose: false,
2317          text: itemContents,
2318          tokens: []
2319        });
2320        list2.raw += raw;
2321      }
2322      list2.items[list2.items.length - 1].raw = raw.trimEnd();
2323      list2.items[list2.items.length - 1].text = itemContents.trimEnd();
2324      list2.raw = list2.raw.trimEnd();
2325      for (let i = 0; i < list2.items.length; i++) {
2326        this.lexer.state.top = false;
2327        list2.items[i].tokens = this.lexer.blockTokens(list2.items[i].text, []);
2328        if (!list2.loose) {
2329          const spacers = list2.items[i].tokens.filter((t) => t.type === "space");
2330          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw));
2331          list2.loose = hasMultipleLineBreaks;
2332        }
2333      }
2334      if (list2.loose) {
2335        for (let i = 0; i < list2.items.length; i++) {
2336          list2.items[i].loose = true;
2337        }
2338      }
2339      return list2;
2340    }
2341  }
2342  html(src) {
2343    const cap = this.rules.block.html.exec(src);
2344    if (cap) {
2345      const token = {
2346        type: "html",
2347        block: true,
2348        raw: cap[0],
2349        pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
2350        text: cap[0]
2351      };
2352      return token;
2353    }
2354  }
2355  def(src) {
2356    const cap = this.rules.block.def.exec(src);
2357    if (cap) {
2358      const tag2 = cap[1].toLowerCase().replace(/\s+/g, " ");
2359      const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
2360      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
2361      return {
2362        type: "def",
2363        tag: tag2,
2364        raw: cap[0],
2365        href,
2366        title
2367      };
2368    }
2369  }
2370  table(src) {
2371    const cap = this.rules.block.table.exec(src);
2372    if (!cap) {
2373      return;
2374    }
2375    if (!/[:|]/.test(cap[2])) {
2376      return;
2377    }
2378    const headers = splitCells(cap[1]);
2379    const aligns = cap[2].replace(/^\||\| *$/g, "").split("|");
2380    const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [];
2381    const item = {
2382      type: "table",
2383      raw: cap[0],
2384      header: [],
2385      align: [],
2386      rows: []
2387    };
2388    if (headers.length !== aligns.length) {
2389      return;
2390    }
2391    for (const align of aligns) {
2392      if (/^ *-+: *$/.test(align)) {
2393        item.align.push("right");
2394      } else if (/^ *:-+: *$/.test(align)) {
2395        item.align.push("center");
2396      } else if (/^ *:-+ *$/.test(align)) {
2397        item.align.push("left");
2398      } else {
2399        item.align.push(null);
2400      }
2401    }
2402    for (const header of headers) {
2403      item.header.push({
2404        text: header,
2405        tokens: this.lexer.inline(header)
2406      });
2407    }
2408    for (const row of rows) {
2409      item.rows.push(splitCells(row, item.header.length).map((cell) => {
2410        return {
2411          text: cell,
2412          tokens: this.lexer.inline(cell)
2413        };
2414      }));
2415    }
2416    return item;
2417  }
2418  lheading(src) {
2419    const cap = this.rules.block.lheading.exec(src);
2420    if (cap) {
2421      return {
2422        type: "heading",
2423        raw: cap[0],
2424        depth: cap[2].charAt(0) === "=" ? 1 : 2,
2425        text: cap[1],
2426        tokens: this.lexer.inline(cap[1])
2427      };
2428    }
2429  }
2430  paragraph(src) {
2431    const cap = this.rules.block.paragraph.exec(src);
2432    if (cap) {
2433      const text2 = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
2434      return {
2435        type: "paragraph",
2436        raw: cap[0],
2437        text: text2,
2438        tokens: this.lexer.inline(text2)
2439      };
2440    }
2441  }
2442  text(src) {
2443    const cap = this.rules.block.text.exec(src);
2444    if (cap) {
2445      return {
2446        type: "text",
2447        raw: cap[0],
2448        text: cap[0],
2449        tokens: this.lexer.inline(cap[0])
2450      };
2451    }
2452  }
2453  escape(src) {
2454    const cap = this.rules.inline.escape.exec(src);
2455    if (cap) {
2456      return {
2457        type: "escape",
2458        raw: cap[0],
2459        text: escape$1$1(cap[1])
2460      };
2461    }
2462  }
2463  tag(src) {
2464    const cap = this.rules.inline.tag.exec(src);
2465    if (cap) {
2466      if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {
2467        this.lexer.state.inLink = true;
2468      } else if (this.lexer.state.inLink && /^<\/a>/i.test(cap[0])) {
2469        this.lexer.state.inLink = false;
2470      }
2471      if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
2472        this.lexer.state.inRawBlock = true;
2473      } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
2474        this.lexer.state.inRawBlock = false;
2475      }
2476      return {
2477        type: "html",
2478        raw: cap[0],
2479        inLink: this.lexer.state.inLink,
2480        inRawBlock: this.lexer.state.inRawBlock,
2481        block: false,
2482        text: cap[0]
2483      };
2484    }
2485  }
2486  link(src) {
2487    const cap = this.rules.inline.link.exec(src);
2488    if (cap) {
2489      const trimmedUrl = cap[2].trim();
2490      if (!this.options.pedantic && /^</.test(trimmedUrl)) {
2491        if (!/>$/.test(trimmedUrl)) {
2492          return;
2493        }
2494        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
2495        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
2496          return;
2497        }
2498      } else {
2499        const lastParenIndex = findClosingBracket(cap[2], "()");
2500        if (lastParenIndex > -1) {
2501          const start = cap[0].indexOf("!") === 0 ? 5 : 4;
2502          const linkLen = start + cap[1].length + lastParenIndex;
2503          cap[2] = cap[2].substring(0, lastParenIndex);
2504          cap[0] = cap[0].substring(0, linkLen).trim();
2505          cap[3] = "";
2506        }
2507      }
2508      let href = cap[2];
2509      let title = "";
2510      if (this.options.pedantic) {
2511        const link2 = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
2512        if (link2) {
2513          href = link2[1];
2514          title = link2[3];
2515        }
2516      } else {
2517        title = cap[3] ? cap[3].slice(1, -1) : "";
2518      }
2519      href = href.trim();
2520      if (/^</.test(href)) {
2521        if (this.options.pedantic && !/>$/.test(trimmedUrl)) {
2522          href = href.slice(1);
2523        } else {
2524          href = href.slice(1, -1);
2525        }
2526      }
2527      return outputLink(cap, {
2528        href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
2529        title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
2530      }, cap[0], this.lexer);
2531    }
2532  }
2533  reflink(src, links) {

2534    let cap;
2535    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
2536      const linkString = (cap[2] || cap[1]).replace(/\s+/g, " ");
2537      const link2 = links[linkString.toLowerCase()];
2538      if (!link2) {
2539        const text2 = cap[0].charAt(0);
2540        return {
2541          type: "text",
2542          raw: text2,
2543          text: text2
2544        };
2545      }
2546      return outputLink(cap, link2, cap[0], this.lexer);
2547    }
2548  }
2549  emStrong(src, maskedSrc, prevChar = "") {
2550    let match = this.rules.inline.emStrongLDelim.exec(src);
2551    if (!match)
2552      return;
2553    if (match[3] && prevChar.match(/[\p{L}\p{N}]/u))
2554      return;
2555    const nextChar = match[1] || match[2] || "";
2556    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
2557      const lLength = [...match[0]].length - 1;
2558      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
2559      const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
2560      endReg.lastIndex = 0;
2561      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
2562      while ((match = endReg.exec(maskedSrc)) != null) {
2563        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
2564        if (!rDelim)
2565          continue;
2566        rLength = [...rDelim].length;
2567        if (match[3] || match[4]) {
2568          delimTotal += rLength;
2569          continue;
2570        } else if (match[5] || match[6]) {
2571          if (lLength % 3 && !((lLength + rLength) % 3)) {
2572            midDelimTotal += rLength;
2573            continue;
2574          }
2575        }
2576        delimTotal -= rLength;
2577        if (delimTotal > 0)
2578          continue;
2579        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
2580        const lastCharLength = [...match[0]][0].length;
2581        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
2582        if (Math.min(lLength, rLength) % 2) {
2583          const text3 = raw.slice(1, -1);
2584          return {
2585            type: "em",
2586            raw,
2587            text: text3,
2588            tokens: this.lexer.inlineTokens(text3)
2589          };
2590        }
2591        const text2 = raw.slice(2, -2);
2592        return {
2593          type: "strong",
2594          raw,
2595          text: text2,
2596          tokens: this.lexer.inlineTokens(text2)
2597        };
2598      }
2599    }
2600  }
2601  codespan(src) {
2602    const cap = this.rules.inline.code.exec(src);
2603    if (cap) {
2604      let text2 = cap[2].replace(/\n/g, " ");
2605      const hasNonSpaceChars = /[^ ]/.test(text2);
2606      const hasSpaceCharsOnBothEnds = /^ /.test(text2) && / $/.test(text2);
2607      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
2608        text2 = text2.substring(1, text2.length - 1);
2609      }
2610      text2 = escape$1$1(text2, true);
2611      return {
2612        type: "codespan",
2613        raw: cap[0],
2614        text: text2
2615      };
2616    }
2617  }
2618  br(src) {
2619    const cap = this.rules.inline.br.exec(src);
2620    if (cap) {
2621      return {
2622        type: "br",
2623        raw: cap[0]
2624      };
2625    }
2626  }
2627  del(src) {
2628    const cap = this.rules.inline.del.exec(src);
2629    if (cap) {
2630      return {
2631        type: "del",
2632        raw: cap[0],
2633        text: cap[2],
2634        tokens: this.lexer.inlineTokens(cap[2])
2635      };
2636    }
2637  }
2638  autolink(src) {
2639    const cap = this.rules.inline.autolink.exec(src);
2640    if (cap) {
2641      let text2, href;
2642      if (cap[2] === "@") {
2643        text2 = escape$1$1(cap[1]);
2644        href = "mailto:" + text2;
2645      } else {
2646        text2 = escape$1$1(cap[1]);
2647        href = text2;
2648      }
2649      return {
2650        type: "link",
2651        raw: cap[0],
2652        text: text2,
2653        href,
2654        tokens: [
2655          {
2656            type: "text",
2657            raw: text2,
2658            text: text2
2659          }
2660        ]
2661      };
2662    }
2663  }
2664  url(src) {
2665    var _a;
2666    let cap;
2667    if (cap = this.rules.inline.url.exec(src)) {
2668      let text2, href;
2669      if (cap[2] === "@") {
2670        text2 = escape$1$1(cap[0]);
2671        href = "mailto:" + text2;
2672      } else {
2673        let prevCapZero;
2674        do {
2675          prevCapZero = cap[0];
2676          cap[0] = ((_a = this.rules.inline._backpedal.exec(cap[0])) == null ? void 0 : _a[0]) ?? "";
2677        } while (prevCapZero !== cap[0]);
2678        text2 = escape$1$1(cap[0]);
2679        if (cap[1] === "www.") {
2680          href = "http://" + cap[0];
2681        } else {
2682          href = cap[0];
2683        }
2684      }
2685      return {
2686        type: "link",
2687        raw: cap[0],
2688        text: text2,
2689        href,
2690        tokens: [
2691          {
2692            type: "text",
2693            raw: text2,
2694            text: text2
2695          }
2696        ]
2697      };
2698    }
2699  }
2700  inlineText(src) {
2701    const cap = this.rules.inline.text.exec(src);
2702    if (cap) {
2703      let text2;
2704      if (this.lexer.state.inRawBlock) {
2705        text2 = cap[0];
2706      } else {
2707        text2 = escape$1$1(cap[0]);
2708      }
2709      return {
2710        type: "text",
2711        raw: cap[0],
2712        text: text2
2713      };
2714    }
2715  }
2716}
2717const newline = /^(?: *(?:\n|$))+/;
2718const blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/;
2719const fences = /^ {0,3}(`{3,}