diff --git "a/src/backend/gradio_json_markdown/templates/component/index.js" "b/src/backend/gradio_json_markdown/templates/component/index.js" new file mode 100644--- /dev/null +++ "b/src/backend/gradio_json_markdown/templates/component/index.js" @@ -0,0 +1,54327 @@ +var yp = Object.defineProperty; +var Dp = (a, e, t) => e in a ? yp(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t; +var ue = (a, e, t) => Dp(a, typeof e != "symbol" ? e + "" : e, t); +const { + SvelteComponent: Mp, + append: Lp, + attr: Tt, + detach: wp, + init: xp, + insert: Pp, + noop: ra, + safe_not_equal: kp, + svg_element: ys +} = window.__gradio__svelte__internal; +function Up(a) { + let e, t; + return { + c() { + e = ys("svg"), t = ys("polyline"), Tt(t, "points", "20 6 9 17 4 12"), Tt(e, "xmlns", "http://www.w3.org/2000/svg"), Tt(e, "viewBox", "2 0 20 20"), Tt(e, "fill", "none"), Tt(e, "stroke", "currentColor"), Tt(e, "aria-hidden", "true"), Tt(e, "stroke-width", "2"), Tt(e, "stroke-linecap", "round"), Tt(e, "stroke-linejoin", "round"); + }, + m(n, r) { + Pp(n, e, r), Lp(e, t); + }, + p: ra, + i: ra, + o: ra, + d(n) { + n && wp(e); + } + }; +} +class Fp extends Mp { + constructor(e) { + super(), xp(this, e, null, Up, kp, {}); + } +} +const { + SvelteComponent: Bp, + append: ia, + attr: nt, + detach: Gp, + init: Yp, + insert: qp, + noop: oa, + safe_not_equal: Hp, + set_style: _t, + svg_element: Cn +} = window.__gradio__svelte__internal; +function Vp(a) { + let e, t, n, r; + return { + c() { + e = Cn("svg"), t = Cn("g"), n = Cn("path"), r = Cn("path"), nt(n, "d", "M18,6L6.087,17.913"), _t(n, "fill", "none"), _t(n, "fill-rule", "nonzero"), _t(n, "stroke-width", "2px"), nt(t, "transform", "matrix(1.14096,-0.140958,-0.140958,1.14096,-0.0559523,0.0559523)"), nt(r, "d", "M4.364,4.364L19.636,19.636"), _t(r, "fill", "none"), _t(r, "fill-rule", "nonzero"), _t(r, "stroke-width", "2px"), nt(e, "width", "100%"), nt(e, "height", "100%"), nt(e, "viewBox", "0 0 24 24"), nt(e, "version", "1.1"), nt(e, "xmlns", "http://www.w3.org/2000/svg"), nt(e, "xmlns:xlink", "http://www.w3.org/1999/xlink"), nt(e, "xml:space", "preserve"), nt(e, "stroke", "currentColor"), _t(e, "fill-rule", "evenodd"), _t(e, "clip-rule", "evenodd"), _t(e, "stroke-linecap", "round"), _t(e, "stroke-linejoin", "round"); + }, + m(i, o) { + qp(i, e, o), ia(e, t), ia(t, n), ia(e, r); + }, + p: oa, + i: oa, + o: oa, + d(i) { + i && Gp(e); + } + }; +} +class zp extends Bp { + constructor(e) { + super(), Yp(this, e, null, Vp, Hp, {}); + } +} +const { + SvelteComponent: Wp, + append: Ds, + attr: At, + detach: Kp, + init: Qp, + insert: $p, + noop: sa, + safe_not_equal: Xp, + svg_element: la +} = window.__gradio__svelte__internal; +function Zp(a) { + let e, t, n; + return { + c() { + e = la("svg"), t = la("path"), n = la("path"), At(t, "fill", "currentColor"), At(t, "d", "M28 10v18H10V10h18m0-2H10a2 2 0 0 0-2 2v18a2 2 0 0 0 2 2h18a2 2 0 0 0 2-2V10a2 2 0 0 0-2-2Z"), At(n, "fill", "currentColor"), At(n, "d", "M4 18H2V4a2 2 0 0 1 2-2h14v2H4Z"), At(e, "xmlns", "http://www.w3.org/2000/svg"), At(e, "viewBox", "0 0 33 33"), At(e, "color", "currentColor"), At(e, "aria-hidden", "true"); + }, + m(r, i) { + $p(r, e, i), Ds(e, t), Ds(e, n); + }, + p: sa, + i: sa, + o: sa, + d(r) { + r && Kp(e); + } + }; +} +class Jp extends Wp { + constructor(e) { + super(), Qp(this, e, null, Zp, Xp, {}); + } +} +const { + SvelteComponent: jp, + append: em, + attr: at, + detach: tm, + init: nm, + insert: am, + noop: ca, + safe_not_equal: rm, + svg_element: Ms +} = window.__gradio__svelte__internal; +function im(a) { + let e, t; + return { + c() { + e = Ms("svg"), t = Ms("path"), at(t, "fill", "currentColor"), at(t, "d", "M5 3h2v2H5v5a2 2 0 0 1-2 2a2 2 0 0 1 2 2v5h2v2H5c-1.07-.27-2-.9-2-2v-4a2 2 0 0 0-2-2H0v-2h1a2 2 0 0 0 2-2V5a2 2 0 0 1 2-2m14 0a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2h1v2h-1a2 2 0 0 0-2 2v4a2 2 0 0 1-2 2h-2v-2h2v-5a2 2 0 0 1 2-2a2 2 0 0 1-2-2V5h-2V3h2m-7 12a1 1 0 0 1 1 1a1 1 0 0 1-1 1a1 1 0 0 1-1-1a1 1 0 0 1 1-1m-4 0a1 1 0 0 1 1 1a1 1 0 0 1-1 1a1 1 0 0 1-1-1a1 1 0 0 1 1-1m8 0a1 1 0 0 1 1 1a1 1 0 0 1-1 1a1 1 0 0 1-1-1a1 1 0 0 1 1-1Z"), at(e, "xmlns", "http://www.w3.org/2000/svg"), at(e, "xmlns:xlink", "http://www.w3.org/1999/xlink"), at(e, "aria-hidden", "true"), at(e, "role", "img"), at(e, "class", "iconify iconify--mdi"), at(e, "width", "100%"), at(e, "height", "100%"), at(e, "preserveAspectRatio", "xMidYMid meet"), at(e, "viewBox", "0 0 24 24"); + }, + m(n, r) { + am(n, e, r), em(e, t); + }, + p: ca, + i: ca, + o: ca, + d(n) { + n && tm(e); + } + }; +} +let Nu = class extends jp { + constructor(e) { + super(), nm(this, e, null, im, rm, {}); + } +}; +const { + SvelteComponent: om, + assign: sm, + create_slot: lm, + detach: cm, + element: _m, + get_all_dirty_from_scope: dm, + get_slot_changes: um, + get_spread_update: pm, + init: mm, + insert: Em, + safe_not_equal: gm, + set_dynamic_element_data: Ls, + set_style: Ye, + toggle_class: dt, + transition_in: Ou, + transition_out: Au, + update_slot_base: Sm +} = window.__gradio__svelte__internal; +function Tm(a) { + let e, t, n; + const r = ( + /*#slots*/ + a[18].default + ), i = lm( + r, + a, + /*$$scope*/ + a[17], + null + ); + let o = [ + { "data-testid": ( + /*test_id*/ + a[7] + ) }, + { id: ( + /*elem_id*/ + a[2] + ) }, + { + class: t = "block " + /*elem_classes*/ + a[3].join(" ") + " svelte-nl1om8" + } + ], s = {}; + for (let l = 0; l < o.length; l += 1) + s = sm(s, o[l]); + return { + c() { + e = _m( + /*tag*/ + a[14] + ), i && i.c(), Ls( + /*tag*/ + a[14] + )(e, s), dt( + e, + "hidden", + /*visible*/ + a[10] === !1 + ), dt( + e, + "padded", + /*padding*/ + a[6] + ), dt( + e, + "border_focus", + /*border_mode*/ + a[5] === "focus" + ), dt( + e, + "border_contrast", + /*border_mode*/ + a[5] === "contrast" + ), dt(e, "hide-container", !/*explicit_call*/ + a[8] && !/*container*/ + a[9]), Ye( + e, + "height", + /*get_dimension*/ + a[15]( + /*height*/ + a[0] + ) + ), Ye(e, "width", typeof /*width*/ + a[1] == "number" ? `calc(min(${/*width*/ + a[1]}px, 100%))` : ( + /*get_dimension*/ + a[15]( + /*width*/ + a[1] + ) + )), Ye( + e, + "border-style", + /*variant*/ + a[4] + ), Ye( + e, + "overflow", + /*allow_overflow*/ + a[11] ? "visible" : "hidden" + ), Ye( + e, + "flex-grow", + /*scale*/ + a[12] + ), Ye(e, "min-width", `calc(min(${/*min_width*/ + a[13]}px, 100%))`), Ye(e, "border-width", "var(--block-border-width)"); + }, + m(l, c) { + Em(l, e, c), i && i.m(e, null), n = !0; + }, + p(l, c) { + i && i.p && (!n || c & /*$$scope*/ + 131072) && Sm( + i, + r, + l, + /*$$scope*/ + l[17], + n ? um( + r, + /*$$scope*/ + l[17], + c, + null + ) : dm( + /*$$scope*/ + l[17] + ), + null + ), Ls( + /*tag*/ + l[14] + )(e, s = pm(o, [ + (!n || c & /*test_id*/ + 128) && { "data-testid": ( + /*test_id*/ + l[7] + ) }, + (!n || c & /*elem_id*/ + 4) && { id: ( + /*elem_id*/ + l[2] + ) }, + (!n || c & /*elem_classes*/ + 8 && t !== (t = "block " + /*elem_classes*/ + l[3].join(" ") + " svelte-nl1om8")) && { class: t } + ])), dt( + e, + "hidden", + /*visible*/ + l[10] === !1 + ), dt( + e, + "padded", + /*padding*/ + l[6] + ), dt( + e, + "border_focus", + /*border_mode*/ + l[5] === "focus" + ), dt( + e, + "border_contrast", + /*border_mode*/ + l[5] === "contrast" + ), dt(e, "hide-container", !/*explicit_call*/ + l[8] && !/*container*/ + l[9]), c & /*height*/ + 1 && Ye( + e, + "height", + /*get_dimension*/ + l[15]( + /*height*/ + l[0] + ) + ), c & /*width*/ + 2 && Ye(e, "width", typeof /*width*/ + l[1] == "number" ? `calc(min(${/*width*/ + l[1]}px, 100%))` : ( + /*get_dimension*/ + l[15]( + /*width*/ + l[1] + ) + )), c & /*variant*/ + 16 && Ye( + e, + "border-style", + /*variant*/ + l[4] + ), c & /*allow_overflow*/ + 2048 && Ye( + e, + "overflow", + /*allow_overflow*/ + l[11] ? "visible" : "hidden" + ), c & /*scale*/ + 4096 && Ye( + e, + "flex-grow", + /*scale*/ + l[12] + ), c & /*min_width*/ + 8192 && Ye(e, "min-width", `calc(min(${/*min_width*/ + l[13]}px, 100%))`); + }, + i(l) { + n || (Ou(i, l), n = !0); + }, + o(l) { + Au(i, l), n = !1; + }, + d(l) { + l && cm(e), i && i.d(l); + } + }; +} +function fm(a) { + let e, t = ( + /*tag*/ + a[14] && Tm(a) + ); + return { + c() { + t && t.c(); + }, + m(n, r) { + t && t.m(n, r), e = !0; + }, + p(n, [r]) { + /*tag*/ + n[14] && t.p(n, r); + }, + i(n) { + e || (Ou(t, n), e = !0); + }, + o(n) { + Au(t, n), e = !1; + }, + d(n) { + t && t.d(n); + } + }; +} +function bm(a, e, t) { + let { $$slots: n = {}, $$scope: r } = e, { height: i = void 0 } = e, { width: o = void 0 } = e, { elem_id: s = "" } = e, { elem_classes: l = [] } = e, { variant: c = "solid" } = e, { border_mode: _ = "base" } = e, { padding: d = !0 } = e, { type: p = "normal" } = e, { test_id: u = void 0 } = e, { explicit_call: m = !1 } = e, { container: S = !0 } = e, { visible: E = !0 } = e, { allow_overflow: f = !0 } = e, { scale: g = null } = e, { min_width: R = 0 } = e, C = p === "fieldset" ? "fieldset" : "div"; + const h = (N) => { + if (N !== void 0) { + if (typeof N == "number") + return N + "px"; + if (typeof N == "string") + return N; + } + }; + return a.$$set = (N) => { + "height" in N && t(0, i = N.height), "width" in N && t(1, o = N.width), "elem_id" in N && t(2, s = N.elem_id), "elem_classes" in N && t(3, l = N.elem_classes), "variant" in N && t(4, c = N.variant), "border_mode" in N && t(5, _ = N.border_mode), "padding" in N && t(6, d = N.padding), "type" in N && t(16, p = N.type), "test_id" in N && t(7, u = N.test_id), "explicit_call" in N && t(8, m = N.explicit_call), "container" in N && t(9, S = N.container), "visible" in N && t(10, E = N.visible), "allow_overflow" in N && t(11, f = N.allow_overflow), "scale" in N && t(12, g = N.scale), "min_width" in N && t(13, R = N.min_width), "$$scope" in N && t(17, r = N.$$scope); + }, [ + i, + o, + s, + l, + c, + _, + d, + u, + m, + S, + E, + f, + g, + R, + C, + h, + p, + r, + n + ]; +} +class Rm extends om { + constructor(e) { + super(), mm(this, e, bm, fm, gm, { + height: 0, + width: 1, + elem_id: 2, + elem_classes: 3, + variant: 4, + border_mode: 5, + padding: 6, + type: 16, + test_id: 7, + explicit_call: 8, + container: 9, + visible: 10, + allow_overflow: 11, + scale: 12, + min_width: 13 + }); + } +} +const { + SvelteComponent: Cm, + append: _a, + attr: Nn, + create_component: Nm, + destroy_component: Om, + detach: Am, + element: ws, + init: Im, + insert: hm, + mount_component: vm, + safe_not_equal: ym, + set_data: Dm, + space: Mm, + text: Lm, + toggle_class: It, + transition_in: wm, + transition_out: xm +} = window.__gradio__svelte__internal; +function Pm(a) { + let e, t, n, r, i, o; + return n = new /*Icon*/ + a[1]({}), { + c() { + e = ws("label"), t = ws("span"), Nm(n.$$.fragment), r = Mm(), i = Lm( + /*label*/ + a[0] + ), Nn(t, "class", "svelte-9gxdi0"), Nn(e, "for", ""), Nn(e, "data-testid", "block-label"), Nn(e, "class", "svelte-9gxdi0"), It(e, "hide", !/*show_label*/ + a[2]), It(e, "sr-only", !/*show_label*/ + a[2]), It( + e, + "float", + /*float*/ + a[4] + ), It( + e, + "hide-label", + /*disable*/ + a[3] + ); + }, + m(s, l) { + hm(s, e, l), _a(e, t), vm(n, t, null), _a(e, r), _a(e, i), o = !0; + }, + p(s, [l]) { + (!o || l & /*label*/ + 1) && Dm( + i, + /*label*/ + s[0] + ), (!o || l & /*show_label*/ + 4) && It(e, "hide", !/*show_label*/ + s[2]), (!o || l & /*show_label*/ + 4) && It(e, "sr-only", !/*show_label*/ + s[2]), (!o || l & /*float*/ + 16) && It( + e, + "float", + /*float*/ + s[4] + ), (!o || l & /*disable*/ + 8) && It( + e, + "hide-label", + /*disable*/ + s[3] + ); + }, + i(s) { + o || (wm(n.$$.fragment, s), o = !0); + }, + o(s) { + xm(n.$$.fragment, s), o = !1; + }, + d(s) { + s && Am(e), Om(n); + } + }; +} +function km(a, e, t) { + let { label: n = null } = e, { Icon: r } = e, { show_label: i = !0 } = e, { disable: o = !1 } = e, { float: s = !0 } = e; + return a.$$set = (l) => { + "label" in l && t(0, n = l.label), "Icon" in l && t(1, r = l.Icon), "show_label" in l && t(2, i = l.show_label), "disable" in l && t(3, o = l.disable), "float" in l && t(4, s = l.float); + }, [n, r, i, o, s]; +} +class Um extends Cm { + constructor(e) { + super(), Im(this, e, km, Pm, ym, { + label: 0, + Icon: 1, + show_label: 2, + disable: 3, + float: 4 + }); + } +} +const { + SvelteComponent: Fm, + append: Xo, + attr: ft, + bubble: Bm, + create_component: Gm, + destroy_component: Ym, + detach: Iu, + element: Zo, + init: qm, + insert: hu, + listen: Hm, + mount_component: Vm, + safe_not_equal: zm, + set_data: Wm, + set_style: Vt, + space: Km, + text: Qm, + toggle_class: Be, + transition_in: $m, + transition_out: Xm +} = window.__gradio__svelte__internal; +function xs(a) { + let e, t; + return { + c() { + e = Zo("span"), t = Qm( + /*label*/ + a[1] + ), ft(e, "class", "svelte-1lrphxw"); + }, + m(n, r) { + hu(n, e, r), Xo(e, t); + }, + p(n, r) { + r & /*label*/ + 2 && Wm( + t, + /*label*/ + n[1] + ); + }, + d(n) { + n && Iu(e); + } + }; +} +function Zm(a) { + let e, t, n, r, i, o, s, l = ( + /*show_label*/ + a[2] && xs(a) + ); + return r = new /*Icon*/ + a[0]({}), { + c() { + e = Zo("button"), l && l.c(), t = Km(), n = Zo("div"), Gm(r.$$.fragment), ft(n, "class", "svelte-1lrphxw"), Be( + n, + "small", + /*size*/ + a[4] === "small" + ), Be( + n, + "large", + /*size*/ + a[4] === "large" + ), Be( + n, + "medium", + /*size*/ + a[4] === "medium" + ), e.disabled = /*disabled*/ + a[7], ft( + e, + "aria-label", + /*label*/ + a[1] + ), ft( + e, + "aria-haspopup", + /*hasPopup*/ + a[8] + ), ft( + e, + "title", + /*label*/ + a[1] + ), ft(e, "class", "svelte-1lrphxw"), Be( + e, + "pending", + /*pending*/ + a[3] + ), Be( + e, + "padded", + /*padded*/ + a[5] + ), Be( + e, + "highlight", + /*highlight*/ + a[6] + ), Be( + e, + "transparent", + /*transparent*/ + a[9] + ), Vt(e, "color", !/*disabled*/ + a[7] && /*_color*/ + a[12] ? ( + /*_color*/ + a[12] + ) : "var(--block-label-text-color)"), Vt(e, "--bg-color", /*disabled*/ + a[7] ? "auto" : ( + /*background*/ + a[10] + )), Vt( + e, + "margin-left", + /*offset*/ + a[11] + "px" + ); + }, + m(c, _) { + hu(c, e, _), l && l.m(e, null), Xo(e, t), Xo(e, n), Vm(r, n, null), i = !0, o || (s = Hm( + e, + "click", + /*click_handler*/ + a[14] + ), o = !0); + }, + p(c, [_]) { + /*show_label*/ + c[2] ? l ? l.p(c, _) : (l = xs(c), l.c(), l.m(e, t)) : l && (l.d(1), l = null), (!i || _ & /*size*/ + 16) && Be( + n, + "small", + /*size*/ + c[4] === "small" + ), (!i || _ & /*size*/ + 16) && Be( + n, + "large", + /*size*/ + c[4] === "large" + ), (!i || _ & /*size*/ + 16) && Be( + n, + "medium", + /*size*/ + c[4] === "medium" + ), (!i || _ & /*disabled*/ + 128) && (e.disabled = /*disabled*/ + c[7]), (!i || _ & /*label*/ + 2) && ft( + e, + "aria-label", + /*label*/ + c[1] + ), (!i || _ & /*hasPopup*/ + 256) && ft( + e, + "aria-haspopup", + /*hasPopup*/ + c[8] + ), (!i || _ & /*label*/ + 2) && ft( + e, + "title", + /*label*/ + c[1] + ), (!i || _ & /*pending*/ + 8) && Be( + e, + "pending", + /*pending*/ + c[3] + ), (!i || _ & /*padded*/ + 32) && Be( + e, + "padded", + /*padded*/ + c[5] + ), (!i || _ & /*highlight*/ + 64) && Be( + e, + "highlight", + /*highlight*/ + c[6] + ), (!i || _ & /*transparent*/ + 512) && Be( + e, + "transparent", + /*transparent*/ + c[9] + ), _ & /*disabled, _color*/ + 4224 && Vt(e, "color", !/*disabled*/ + c[7] && /*_color*/ + c[12] ? ( + /*_color*/ + c[12] + ) : "var(--block-label-text-color)"), _ & /*disabled, background*/ + 1152 && Vt(e, "--bg-color", /*disabled*/ + c[7] ? "auto" : ( + /*background*/ + c[10] + )), _ & /*offset*/ + 2048 && Vt( + e, + "margin-left", + /*offset*/ + c[11] + "px" + ); + }, + i(c) { + i || ($m(r.$$.fragment, c), i = !0); + }, + o(c) { + Xm(r.$$.fragment, c), i = !1; + }, + d(c) { + c && Iu(e), l && l.d(), Ym(r), o = !1, s(); + } + }; +} +function Jm(a, e, t) { + let n, { Icon: r } = e, { label: i = "" } = e, { show_label: o = !1 } = e, { pending: s = !1 } = e, { size: l = "small" } = e, { padded: c = !0 } = e, { highlight: _ = !1 } = e, { disabled: d = !1 } = e, { hasPopup: p = !1 } = e, { color: u = "var(--block-label-text-color)" } = e, { transparent: m = !1 } = e, { background: S = "var(--background-fill-primary)" } = e, { offset: E = 0 } = e; + function f(g) { + Bm.call(this, a, g); + } + return a.$$set = (g) => { + "Icon" in g && t(0, r = g.Icon), "label" in g && t(1, i = g.label), "show_label" in g && t(2, o = g.show_label), "pending" in g && t(3, s = g.pending), "size" in g && t(4, l = g.size), "padded" in g && t(5, c = g.padded), "highlight" in g && t(6, _ = g.highlight), "disabled" in g && t(7, d = g.disabled), "hasPopup" in g && t(8, p = g.hasPopup), "color" in g && t(13, u = g.color), "transparent" in g && t(9, m = g.transparent), "background" in g && t(10, S = g.background), "offset" in g && t(11, E = g.offset); + }, a.$$.update = () => { + a.$$.dirty & /*highlight, color*/ + 8256 && t(12, n = _ ? "var(--color-accent)" : u); + }, [ + r, + i, + o, + s, + l, + c, + _, + d, + p, + m, + S, + E, + n, + u, + f + ]; +} +class jm extends Fm { + constructor(e) { + super(), qm(this, e, Jm, Zm, zm, { + Icon: 0, + label: 1, + show_label: 2, + pending: 3, + size: 4, + padded: 5, + highlight: 6, + disabled: 7, + hasPopup: 8, + color: 13, + transparent: 9, + background: 10, + offset: 11 + }); + } +} +const { + SvelteComponent: eE, + append: tE, + attr: da, + binding_callbacks: nE, + create_slot: aE, + detach: rE, + element: Ps, + get_all_dirty_from_scope: iE, + get_slot_changes: oE, + init: sE, + insert: lE, + safe_not_equal: cE, + toggle_class: ht, + transition_in: _E, + transition_out: dE, + update_slot_base: uE +} = window.__gradio__svelte__internal; +function pE(a) { + let e, t, n; + const r = ( + /*#slots*/ + a[5].default + ), i = aE( + r, + a, + /*$$scope*/ + a[4], + null + ); + return { + c() { + e = Ps("div"), t = Ps("div"), i && i.c(), da(t, "class", "icon svelte-3w3rth"), da(e, "class", "empty svelte-3w3rth"), da(e, "aria-label", "Empty value"), ht( + e, + "small", + /*size*/ + a[0] === "small" + ), ht( + e, + "large", + /*size*/ + a[0] === "large" + ), ht( + e, + "unpadded_box", + /*unpadded_box*/ + a[1] + ), ht( + e, + "small_parent", + /*parent_height*/ + a[3] + ); + }, + m(o, s) { + lE(o, e, s), tE(e, t), i && i.m(t, null), a[6](e), n = !0; + }, + p(o, [s]) { + i && i.p && (!n || s & /*$$scope*/ + 16) && uE( + i, + r, + o, + /*$$scope*/ + o[4], + n ? oE( + r, + /*$$scope*/ + o[4], + s, + null + ) : iE( + /*$$scope*/ + o[4] + ), + null + ), (!n || s & /*size*/ + 1) && ht( + e, + "small", + /*size*/ + o[0] === "small" + ), (!n || s & /*size*/ + 1) && ht( + e, + "large", + /*size*/ + o[0] === "large" + ), (!n || s & /*unpadded_box*/ + 2) && ht( + e, + "unpadded_box", + /*unpadded_box*/ + o[1] + ), (!n || s & /*parent_height*/ + 8) && ht( + e, + "small_parent", + /*parent_height*/ + o[3] + ); + }, + i(o) { + n || (_E(i, o), n = !0); + }, + o(o) { + dE(i, o), n = !1; + }, + d(o) { + o && rE(e), i && i.d(o), a[6](null); + } + }; +} +function mE(a, e, t) { + let n, { $$slots: r = {}, $$scope: i } = e, { size: o = "small" } = e, { unpadded_box: s = !1 } = e, l; + function c(d) { + var p; + if (!d) return !1; + const { height: u } = d.getBoundingClientRect(), { height: m } = ((p = d.parentElement) === null || p === void 0 ? void 0 : p.getBoundingClientRect()) || { height: u }; + return u > m + 2; + } + function _(d) { + nE[d ? "unshift" : "push"](() => { + l = d, t(2, l); + }); + } + return a.$$set = (d) => { + "size" in d && t(0, o = d.size), "unpadded_box" in d && t(1, s = d.unpadded_box), "$$scope" in d && t(4, i = d.$$scope); + }, a.$$.update = () => { + a.$$.dirty & /*el*/ + 4 && t(3, n = c(l)); + }, [o, s, l, n, i, r, _]; +} +class EE extends eE { + constructor(e) { + super(), sE(this, e, mE, pE, cE, { size: 0, unpadded_box: 1 }); + } +} +const gE = [ + { color: "red", primary: 600, secondary: 100 }, + { color: "green", primary: 600, secondary: 100 }, + { color: "blue", primary: 600, secondary: 100 }, + { color: "yellow", primary: 500, secondary: 100 }, + { color: "purple", primary: 600, secondary: 100 }, + { color: "teal", primary: 600, secondary: 100 }, + { color: "orange", primary: 600, secondary: 100 }, + { color: "cyan", primary: 600, secondary: 100 }, + { color: "lime", primary: 500, secondary: 100 }, + { color: "pink", primary: 600, secondary: 100 } +], ks = { + inherit: "inherit", + current: "currentColor", + transparent: "transparent", + black: "#000", + white: "#fff", + slate: { + 50: "#f8fafc", + 100: "#f1f5f9", + 200: "#e2e8f0", + 300: "#cbd5e1", + 400: "#94a3b8", + 500: "#64748b", + 600: "#475569", + 700: "#334155", + 800: "#1e293b", + 900: "#0f172a", + 950: "#020617" + }, + gray: { + 50: "#f9fafb", + 100: "#f3f4f6", + 200: "#e5e7eb", + 300: "#d1d5db", + 400: "#9ca3af", + 500: "#6b7280", + 600: "#4b5563", + 700: "#374151", + 800: "#1f2937", + 900: "#111827", + 950: "#030712" + }, + zinc: { + 50: "#fafafa", + 100: "#f4f4f5", + 200: "#e4e4e7", + 300: "#d4d4d8", + 400: "#a1a1aa", + 500: "#71717a", + 600: "#52525b", + 700: "#3f3f46", + 800: "#27272a", + 900: "#18181b", + 950: "#09090b" + }, + neutral: { + 50: "#fafafa", + 100: "#f5f5f5", + 200: "#e5e5e5", + 300: "#d4d4d4", + 400: "#a3a3a3", + 500: "#737373", + 600: "#525252", + 700: "#404040", + 800: "#262626", + 900: "#171717", + 950: "#0a0a0a" + }, + stone: { + 50: "#fafaf9", + 100: "#f5f5f4", + 200: "#e7e5e4", + 300: "#d6d3d1", + 400: "#a8a29e", + 500: "#78716c", + 600: "#57534e", + 700: "#44403c", + 800: "#292524", + 900: "#1c1917", + 950: "#0c0a09" + }, + red: { + 50: "#fef2f2", + 100: "#fee2e2", + 200: "#fecaca", + 300: "#fca5a5", + 400: "#f87171", + 500: "#ef4444", + 600: "#dc2626", + 700: "#b91c1c", + 800: "#991b1b", + 900: "#7f1d1d", + 950: "#450a0a" + }, + orange: { + 50: "#fff7ed", + 100: "#ffedd5", + 200: "#fed7aa", + 300: "#fdba74", + 400: "#fb923c", + 500: "#f97316", + 600: "#ea580c", + 700: "#c2410c", + 800: "#9a3412", + 900: "#7c2d12", + 950: "#431407" + }, + amber: { + 50: "#fffbeb", + 100: "#fef3c7", + 200: "#fde68a", + 300: "#fcd34d", + 400: "#fbbf24", + 500: "#f59e0b", + 600: "#d97706", + 700: "#b45309", + 800: "#92400e", + 900: "#78350f", + 950: "#451a03" + }, + yellow: { + 50: "#fefce8", + 100: "#fef9c3", + 200: "#fef08a", + 300: "#fde047", + 400: "#facc15", + 500: "#eab308", + 600: "#ca8a04", + 700: "#a16207", + 800: "#854d0e", + 900: "#713f12", + 950: "#422006" + }, + lime: { + 50: "#f7fee7", + 100: "#ecfccb", + 200: "#d9f99d", + 300: "#bef264", + 400: "#a3e635", + 500: "#84cc16", + 600: "#65a30d", + 700: "#4d7c0f", + 800: "#3f6212", + 900: "#365314", + 950: "#1a2e05" + }, + green: { + 50: "#f0fdf4", + 100: "#dcfce7", + 200: "#bbf7d0", + 300: "#86efac", + 400: "#4ade80", + 500: "#22c55e", + 600: "#16a34a", + 700: "#15803d", + 800: "#166534", + 900: "#14532d", + 950: "#052e16" + }, + emerald: { + 50: "#ecfdf5", + 100: "#d1fae5", + 200: "#a7f3d0", + 300: "#6ee7b7", + 400: "#34d399", + 500: "#10b981", + 600: "#059669", + 700: "#047857", + 800: "#065f46", + 900: "#064e3b", + 950: "#022c22" + }, + teal: { + 50: "#f0fdfa", + 100: "#ccfbf1", + 200: "#99f6e4", + 300: "#5eead4", + 400: "#2dd4bf", + 500: "#14b8a6", + 600: "#0d9488", + 700: "#0f766e", + 800: "#115e59", + 900: "#134e4a", + 950: "#042f2e" + }, + cyan: { + 50: "#ecfeff", + 100: "#cffafe", + 200: "#a5f3fc", + 300: "#67e8f9", + 400: "#22d3ee", + 500: "#06b6d4", + 600: "#0891b2", + 700: "#0e7490", + 800: "#155e75", + 900: "#164e63", + 950: "#083344" + }, + sky: { + 50: "#f0f9ff", + 100: "#e0f2fe", + 200: "#bae6fd", + 300: "#7dd3fc", + 400: "#38bdf8", + 500: "#0ea5e9", + 600: "#0284c7", + 700: "#0369a1", + 800: "#075985", + 900: "#0c4a6e", + 950: "#082f49" + }, + blue: { + 50: "#eff6ff", + 100: "#dbeafe", + 200: "#bfdbfe", + 300: "#93c5fd", + 400: "#60a5fa", + 500: "#3b82f6", + 600: "#2563eb", + 700: "#1d4ed8", + 800: "#1e40af", + 900: "#1e3a8a", + 950: "#172554" + }, + indigo: { + 50: "#eef2ff", + 100: "#e0e7ff", + 200: "#c7d2fe", + 300: "#a5b4fc", + 400: "#818cf8", + 500: "#6366f1", + 600: "#4f46e5", + 700: "#4338ca", + 800: "#3730a3", + 900: "#312e81", + 950: "#1e1b4b" + }, + violet: { + 50: "#f5f3ff", + 100: "#ede9fe", + 200: "#ddd6fe", + 300: "#c4b5fd", + 400: "#a78bfa", + 500: "#8b5cf6", + 600: "#7c3aed", + 700: "#6d28d9", + 800: "#5b21b6", + 900: "#4c1d95", + 950: "#2e1065" + }, + purple: { + 50: "#faf5ff", + 100: "#f3e8ff", + 200: "#e9d5ff", + 300: "#d8b4fe", + 400: "#c084fc", + 500: "#a855f7", + 600: "#9333ea", + 700: "#7e22ce", + 800: "#6b21a8", + 900: "#581c87", + 950: "#3b0764" + }, + fuchsia: { + 50: "#fdf4ff", + 100: "#fae8ff", + 200: "#f5d0fe", + 300: "#f0abfc", + 400: "#e879f9", + 500: "#d946ef", + 600: "#c026d3", + 700: "#a21caf", + 800: "#86198f", + 900: "#701a75", + 950: "#4a044e" + }, + pink: { + 50: "#fdf2f8", + 100: "#fce7f3", + 200: "#fbcfe8", + 300: "#f9a8d4", + 400: "#f472b6", + 500: "#ec4899", + 600: "#db2777", + 700: "#be185d", + 800: "#9d174d", + 900: "#831843", + 950: "#500724" + }, + rose: { + 50: "#fff1f2", + 100: "#ffe4e6", + 200: "#fecdd3", + 300: "#fda4af", + 400: "#fb7185", + 500: "#f43f5e", + 600: "#e11d48", + 700: "#be123c", + 800: "#9f1239", + 900: "#881337", + 950: "#4c0519" + } +}; +gE.reduce( + (a, { color: e, primary: t, secondary: n }) => ({ + ...a, + [e]: { + primary: ks[e][t], + secondary: ks[e][n] + } + }), + {} +); +function os() { + return { + async: !1, + breaks: !1, + extensions: null, + gfm: !0, + hooks: null, + pedantic: !1, + renderer: null, + silent: !1, + tokenizer: null, + walkTokens: null + }; +} +let Bt = os(); +function vu(a) { + Bt = a; +} +const yu = /[&<>"']/, SE = new RegExp(yu.source, "g"), Du = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, TE = new RegExp(Du.source, "g"), fE = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" +}, Us = (a) => fE[a]; +function qe(a, e) { + if (e) { + if (yu.test(a)) + return a.replace(SE, Us); + } else if (Du.test(a)) + return a.replace(TE, Us); + return a; +} +const bE = /(^|[^\[])\^/g; +function ce(a, e) { + let t = typeof a == "string" ? a : a.source; + e = e || ""; + const n = { + replace: (r, i) => { + let o = typeof i == "string" ? i : i.source; + return o = o.replace(bE, "$1"), t = t.replace(r, o), n; + }, + getRegex: () => new RegExp(t, e) + }; + return n; +} +function Fs(a) { + try { + a = encodeURI(a).replace(/%25/g, "%"); + } catch { + return null; + } + return a; +} +const sn = { exec: () => null }; +function Bs(a, e) { + const t = a.replace(/\|/g, (i, o, s) => { + let l = !1, c = o; + for (; --c >= 0 && s[c] === "\\"; ) + l = !l; + return l ? "|" : " |"; + }), n = t.split(/ \|/); + let r = 0; + if (n[0].trim() || n.shift(), n.length > 0 && !n[n.length - 1].trim() && n.pop(), e) + if (n.length > e) + n.splice(e); + else + for (; n.length < e; ) + n.push(""); + for (; r < n.length; r++) + n[r] = n[r].trim().replace(/\\\|/g, "|"); + return n; +} +function jt(a, e, t) { + const n = a.length; + if (n === 0) + return ""; + let r = 0; + for (; r < n; ) { + const i = a.charAt(n - r - 1); + if (i === e && !t) + r++; + else if (i !== e && t) + r++; + else + break; + } + return a.slice(0, n - r); +} +function RE(a, e) { + if (a.indexOf(e[1]) === -1) + return -1; + let t = 0; + for (let n = 0; n < a.length; n++) + if (a[n] === "\\") + n++; + else if (a[n] === e[0]) + t++; + else if (a[n] === e[1] && (t--, t < 0)) + return n; + return -1; +} +function Gs(a, e, t, n) { + const r = e.href, i = e.title ? qe(e.title) : null, o = a[1].replace(/\\([\[\]])/g, "$1"); + if (a[0].charAt(0) !== "!") { + n.state.inLink = !0; + const s = { + type: "link", + raw: t, + href: r, + title: i, + text: o, + tokens: n.inlineTokens(o) + }; + return n.state.inLink = !1, s; + } + return { + type: "image", + raw: t, + href: r, + title: i, + text: qe(o) + }; +} +function CE(a, e) { + const t = a.match(/^(\s+)(?:```)/); + if (t === null) + return e; + const n = t[1]; + return e.split(` +`).map((r) => { + const i = r.match(/^\s+/); + if (i === null) + return r; + const [o] = i; + return o.length >= n.length ? r.slice(n.length) : r; + }).join(` +`); +} +class Ln { + // set by the lexer + constructor(e) { + ue(this, "options"); + ue(this, "rules"); + // set by the lexer + ue(this, "lexer"); + this.options = e || Bt; + } + space(e) { + const t = this.rules.block.newline.exec(e); + if (t && t[0].length > 0) + return { + type: "space", + raw: t[0] + }; + } + code(e) { + const t = this.rules.block.code.exec(e); + if (t) { + const n = t[0].replace(/^ {1,4}/gm, ""); + return { + type: "code", + raw: t[0], + codeBlockStyle: "indented", + text: this.options.pedantic ? n : jt(n, ` +`) + }; + } + } + fences(e) { + const t = this.rules.block.fences.exec(e); + if (t) { + const n = t[0], r = CE(n, t[3] || ""); + return { + type: "code", + raw: n, + lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], + text: r + }; + } + } + heading(e) { + const t = this.rules.block.heading.exec(e); + if (t) { + let n = t[2].trim(); + if (/#$/.test(n)) { + const r = jt(n, "#"); + (this.options.pedantic || !r || / $/.test(r)) && (n = r.trim()); + } + return { + type: "heading", + raw: t[0], + depth: t[1].length, + text: n, + tokens: this.lexer.inline(n) + }; + } + } + hr(e) { + const t = this.rules.block.hr.exec(e); + if (t) + return { + type: "hr", + raw: jt(t[0], ` +`) + }; + } + blockquote(e) { + const t = this.rules.block.blockquote.exec(e); + if (t) { + let n = jt(t[0], ` +`).split(` +`), r = "", i = ""; + const o = []; + for (; n.length > 0; ) { + let s = !1; + const l = []; + let c; + for (c = 0; c < n.length; c++) + if (/^ {0,3}>/.test(n[c])) + l.push(n[c]), s = !0; + else if (!s) + l.push(n[c]); + else + break; + n = n.slice(c); + const _ = l.join(` +`), d = _.replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, ` + $1`).replace(/^ {0,3}>[ \t]?/gm, ""); + r = r ? `${r} +${_}` : _, i = i ? `${i} +${d}` : d; + const p = this.lexer.state.top; + if (this.lexer.state.top = !0, this.lexer.blockTokens(d, o, !0), this.lexer.state.top = p, n.length === 0) + break; + const u = o[o.length - 1]; + if ((u == null ? void 0 : u.type) === "code") + break; + if ((u == null ? void 0 : u.type) === "blockquote") { + const m = u, S = m.raw + ` +` + n.join(` +`), E = this.blockquote(S); + o[o.length - 1] = E, r = r.substring(0, r.length - m.raw.length) + E.raw, i = i.substring(0, i.length - m.text.length) + E.text; + break; + } else if ((u == null ? void 0 : u.type) === "list") { + const m = u, S = m.raw + ` +` + n.join(` +`), E = this.list(S); + o[o.length - 1] = E, r = r.substring(0, r.length - u.raw.length) + E.raw, i = i.substring(0, i.length - m.raw.length) + E.raw, n = S.substring(o[o.length - 1].raw.length).split(` +`); + continue; + } + } + return { + type: "blockquote", + raw: r, + tokens: o, + text: i + }; + } + } + list(e) { + let t = this.rules.block.list.exec(e); + if (t) { + let n = t[1].trim(); + const r = n.length > 1, i = { + type: "list", + raw: "", + ordered: r, + start: r ? +n.slice(0, -1) : "", + loose: !1, + items: [] + }; + n = r ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = r ? n : "[*+-]"); + const o = new RegExp(`^( {0,3}${n})((?:[ ][^\\n]*)?(?:\\n|$))`); + let s = !1; + for (; e; ) { + let l = !1, c = "", _ = ""; + if (!(t = o.exec(e)) || this.rules.block.hr.test(e)) + break; + c = t[0], e = e.substring(c.length); + let d = t[2].split(` +`, 1)[0].replace(/^\t+/, (f) => " ".repeat(3 * f.length)), p = e.split(` +`, 1)[0], u = !d.trim(), m = 0; + if (this.options.pedantic ? (m = 2, _ = d.trimStart()) : u ? m = t[1].length + 1 : (m = t[2].search(/[^ ]/), m = m > 4 ? 1 : m, _ = d.slice(m), m += t[1].length), u && /^ *$/.test(p) && (c += p + ` +`, e = e.substring(p.length + 1), l = !0), !l) { + const f = new RegExp(`^ {0,${Math.min(3, m - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`), g = new RegExp(`^ {0,${Math.min(3, m - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), R = new RegExp(`^ {0,${Math.min(3, m - 1)}}(?:\`\`\`|~~~)`), C = new RegExp(`^ {0,${Math.min(3, m - 1)}}#`); + for (; e; ) { + const h = e.split(` +`, 1)[0]; + if (p = h, this.options.pedantic && (p = p.replace(/^ {1,4}(?=( {4})*[^ ])/g, " ")), R.test(p) || C.test(p) || f.test(p) || g.test(e)) + break; + if (p.search(/[^ ]/) >= m || !p.trim()) + _ += ` +` + p.slice(m); + else { + if (u || d.search(/[^ ]/) >= 4 || R.test(d) || C.test(d) || g.test(d)) + break; + _ += ` +` + p; + } + !u && !p.trim() && (u = !0), c += h + ` +`, e = e.substring(h.length + 1), d = p.slice(m); + } + } + i.loose || (s ? i.loose = !0 : /\n *\n *$/.test(c) && (s = !0)); + let S = null, E; + this.options.gfm && (S = /^\[[ xX]\] /.exec(_), S && (E = S[0] !== "[ ] ", _ = _.replace(/^\[[ xX]\] +/, ""))), i.items.push({ + type: "list_item", + raw: c, + task: !!S, + checked: E, + loose: !1, + text: _, + tokens: [] + }), i.raw += c; + } + i.items[i.items.length - 1].raw = i.items[i.items.length - 1].raw.trimEnd(), i.items[i.items.length - 1].text = i.items[i.items.length - 1].text.trimEnd(), i.raw = i.raw.trimEnd(); + for (let l = 0; l < i.items.length; l++) + if (this.lexer.state.top = !1, i.items[l].tokens = this.lexer.blockTokens(i.items[l].text, []), !i.loose) { + const c = i.items[l].tokens.filter((d) => d.type === "space"), _ = c.length > 0 && c.some((d) => /\n.*\n/.test(d.raw)); + i.loose = _; + } + if (i.loose) + for (let l = 0; l < i.items.length; l++) + i.items[l].loose = !0; + return i; + } + } + html(e) { + const t = this.rules.block.html.exec(e); + if (t) + return { + type: "html", + block: !0, + raw: t[0], + pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", + text: t[0] + }; + } + def(e) { + const t = this.rules.block.def.exec(e); + if (t) { + const n = t[1].toLowerCase().replace(/\s+/g, " "), r = t[2] ? t[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", i = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3]; + return { + type: "def", + tag: n, + raw: t[0], + href: r, + title: i + }; + } + } + table(e) { + const t = this.rules.block.table.exec(e); + if (!t || !/[:|]/.test(t[2])) + return; + const n = Bs(t[1]), r = t[2].replace(/^\||\| *$/g, "").split("|"), i = t[3] && t[3].trim() ? t[3].replace(/\n[ \t]*$/, "").split(` +`) : [], o = { + type: "table", + raw: t[0], + header: [], + align: [], + rows: [] + }; + if (n.length === r.length) { + for (const s of r) + /^ *-+: *$/.test(s) ? o.align.push("right") : /^ *:-+: *$/.test(s) ? o.align.push("center") : /^ *:-+ *$/.test(s) ? o.align.push("left") : o.align.push(null); + for (let s = 0; s < n.length; s++) + o.header.push({ + text: n[s], + tokens: this.lexer.inline(n[s]), + header: !0, + align: o.align[s] + }); + for (const s of i) + o.rows.push(Bs(s, o.header.length).map((l, c) => ({ + text: l, + tokens: this.lexer.inline(l), + header: !1, + align: o.align[c] + }))); + return o; + } + } + lheading(e) { + const t = this.rules.block.lheading.exec(e); + if (t) + return { + type: "heading", + raw: t[0], + depth: t[2].charAt(0) === "=" ? 1 : 2, + text: t[1], + tokens: this.lexer.inline(t[1]) + }; + } + paragraph(e) { + const t = this.rules.block.paragraph.exec(e); + if (t) { + const n = t[1].charAt(t[1].length - 1) === ` +` ? t[1].slice(0, -1) : t[1]; + return { + type: "paragraph", + raw: t[0], + text: n, + tokens: this.lexer.inline(n) + }; + } + } + text(e) { + const t = this.rules.block.text.exec(e); + if (t) + return { + type: "text", + raw: t[0], + text: t[0], + tokens: this.lexer.inline(t[0]) + }; + } + escape(e) { + const t = this.rules.inline.escape.exec(e); + if (t) + return { + type: "escape", + raw: t[0], + text: qe(t[1]) + }; + } + tag(e) { + const t = this.rules.inline.tag.exec(e); + if (t) + return !this.lexer.state.inLink && /^/i.test(t[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(t[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(t[0]) && (this.lexer.state.inRawBlock = !1), { + type: "html", + raw: t[0], + inLink: this.lexer.state.inLink, + inRawBlock: this.lexer.state.inRawBlock, + block: !1, + text: t[0] + }; + } + link(e) { + const t = this.rules.inline.link.exec(e); + if (t) { + const n = t[2].trim(); + if (!this.options.pedantic && /^$/.test(n)) + return; + const o = jt(n.slice(0, -1), "\\"); + if ((n.length - o.length) % 2 === 0) + return; + } else { + const o = RE(t[2], "()"); + if (o > -1) { + const l = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + o; + t[2] = t[2].substring(0, o), t[0] = t[0].substring(0, l).trim(), t[3] = ""; + } + } + let r = t[2], i = ""; + if (this.options.pedantic) { + const o = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(r); + o && (r = o[1], i = o[3]); + } else + i = t[3] ? t[3].slice(1, -1) : ""; + return r = r.trim(), /^$/.test(n) ? r = r.slice(1) : r = r.slice(1, -1)), Gs(t, { + href: r && r.replace(this.rules.inline.anyPunctuation, "$1"), + title: i && i.replace(this.rules.inline.anyPunctuation, "$1") + }, t[0], this.lexer); + } + } + reflink(e, t) { + let n; + if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) { + const r = (n[2] || n[1]).replace(/\s+/g, " "), i = t[r.toLowerCase()]; + if (!i) { + const o = n[0].charAt(0); + return { + type: "text", + raw: o, + text: o + }; + } + return Gs(n, i, n[0], this.lexer); + } + } + emStrong(e, t, n = "") { + let r = this.rules.inline.emStrongLDelim.exec(e); + if (!r || r[3] && n.match(/[\p{L}\p{N}]/u)) + return; + if (!(r[1] || r[2] || "") || !n || this.rules.inline.punctuation.exec(n)) { + const o = [...r[0]].length - 1; + let s, l, c = o, _ = 0; + const d = r[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd; + for (d.lastIndex = 0, t = t.slice(-1 * e.length + o); (r = d.exec(t)) != null; ) { + if (s = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !s) + continue; + if (l = [...s].length, r[3] || r[4]) { + c += l; + continue; + } else if ((r[5] || r[6]) && o % 3 && !((o + l) % 3)) { + _ += l; + continue; + } + if (c -= l, c > 0) + continue; + l = Math.min(l, l + c + _); + const p = [...r[0]][0].length, u = e.slice(0, o + r.index + p + l); + if (Math.min(o, l) % 2) { + const S = u.slice(1, -1); + return { + type: "em", + raw: u, + text: S, + tokens: this.lexer.inlineTokens(S) + }; + } + const m = u.slice(2, -2); + return { + type: "strong", + raw: u, + text: m, + tokens: this.lexer.inlineTokens(m) + }; + } + } + } + codespan(e) { + const t = this.rules.inline.code.exec(e); + if (t) { + let n = t[2].replace(/\n/g, " "); + const r = /[^ ]/.test(n), i = /^ /.test(n) && / $/.test(n); + return r && i && (n = n.substring(1, n.length - 1)), n = qe(n, !0), { + type: "codespan", + raw: t[0], + text: n + }; + } + } + br(e) { + const t = this.rules.inline.br.exec(e); + if (t) + return { + type: "br", + raw: t[0] + }; + } + del(e) { + const t = this.rules.inline.del.exec(e); + if (t) + return { + type: "del", + raw: t[0], + text: t[2], + tokens: this.lexer.inlineTokens(t[2]) + }; + } + autolink(e) { + const t = this.rules.inline.autolink.exec(e); + if (t) { + let n, r; + return t[2] === "@" ? (n = qe(t[1]), r = "mailto:" + n) : (n = qe(t[1]), r = n), { + type: "link", + raw: t[0], + text: n, + href: r, + tokens: [ + { + type: "text", + raw: n, + text: n + } + ] + }; + } + } + url(e) { + var n; + let t; + if (t = this.rules.inline.url.exec(e)) { + let r, i; + if (t[2] === "@") + r = qe(t[0]), i = "mailto:" + r; + else { + let o; + do + o = t[0], t[0] = ((n = this.rules.inline._backpedal.exec(t[0])) == null ? void 0 : n[0]) ?? ""; + while (o !== t[0]); + r = qe(t[0]), t[1] === "www." ? i = "http://" + t[0] : i = t[0]; + } + return { + type: "link", + raw: t[0], + text: r, + href: i, + tokens: [ + { + type: "text", + raw: r, + text: r + } + ] + }; + } + } + inlineText(e) { + const t = this.rules.inline.text.exec(e); + if (t) { + let n; + return this.lexer.state.inRawBlock ? n = t[0] : n = qe(t[0]), { + type: "text", + raw: t[0], + text: n + }; + } + } +} +const NE = /^(?: *(?:\n|$))+/, OE = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/, AE = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, mn = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, IE = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, Mu = /(?:[*+-]|\d{1,9}[.)])/, Lu = ce(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, Mu).replace(/blockCode/g, / {4}/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex(), ss = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, hE = /^[^\n]+/, ls = /(?!\s*\])(?:\\.|[^\[\]\\])+/, vE = ce(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", ls).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), yE = ce(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, Mu).getRegex(), Gn = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", cs = /|$))/, DE = ce("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", cs).replace("tag", Gn).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), wu = ce(ss).replace("hr", mn).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Gn).getRegex(), ME = ce(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", wu).getRegex(), _s = { + blockquote: ME, + code: OE, + def: vE, + fences: AE, + heading: IE, + hr: mn, + html: DE, + lheading: Lu, + list: yE, + newline: NE, + paragraph: wu, + table: sn, + text: hE +}, Ys = ce("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", mn).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Gn).getRegex(), LE = { + ..._s, + table: Ys, + paragraph: ce(ss).replace("hr", mn).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", Ys).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Gn).getRegex() +}, wE = { + ..._s, + html: ce(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", cs).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), + def: /^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, + heading: /^(#{1,6})(.*)(?:\n+|$)/, + fences: sn, + // fences not supported + lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, + paragraph: ce(ss).replace("hr", mn).replace("heading", ` *#{1,6} *[^ +]`).replace("lheading", Lu).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() +}, xu = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, xE = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, Pu = /^( {2,}|\\)\n(?!\s*$)/, PE = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\]*?>/g, FE = ce(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, En).getRegex(), BE = ce("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, En).getRegex(), GE = ce("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, En).getRegex(), YE = ce(/\\([punct])/, "gu").replace(/punct/g, En).getRegex(), qE = ce(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), HE = ce(cs).replace("(?:-->|$)", "-->").getRegex(), VE = ce("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment", HE).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), wn = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/, zE = ce(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", wn).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), ku = ce(/^!?\[(label)\]\[(ref)\]/).replace("label", wn).replace("ref", ls).getRegex(), Uu = ce(/^!?\[(ref)\](?:\[\])?/).replace("ref", ls).getRegex(), WE = ce("reflink|nolink(?!\\()", "g").replace("reflink", ku).replace("nolink", Uu).getRegex(), ds = { + _backpedal: sn, + // only used for GFM url + anyPunctuation: YE, + autolink: qE, + blockSkip: UE, + br: Pu, + code: xE, + del: sn, + emStrongLDelim: FE, + emStrongRDelimAst: BE, + emStrongRDelimUnd: GE, + escape: xu, + link: zE, + nolink: Uu, + punctuation: kE, + reflink: ku, + reflinkSearch: WE, + tag: VE, + text: PE, + url: sn +}, KE = { + ...ds, + link: ce(/^!?\[(label)\]\((.*?)\)/).replace("label", wn).getRegex(), + reflink: ce(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", wn).getRegex() +}, Jo = { + ...ds, + escape: ce(xu).replace("])", "~|])").getRegex(), + url: ce(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), + _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, + del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/, + text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\ l + " ".repeat(c.length)); + let r, i, o; + for (; e; ) + if (!(this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((s) => (r = s.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), !0) : !1))) { + if (r = this.tokenizer.space(e)) { + e = e.substring(r.raw.length), r.raw.length === 1 && t.length > 0 ? t[t.length - 1].raw += ` +` : t.push(r); + continue; + } + if (r = this.tokenizer.code(e)) { + e = e.substring(r.raw.length), i = t[t.length - 1], i && (i.type === "paragraph" || i.type === "text") ? (i.raw += ` +` + r.raw, i.text += ` +` + r.text, this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(r); + continue; + } + if (r = this.tokenizer.fences(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.heading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.hr(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.blockquote(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.list(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.html(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.def(e)) { + e = e.substring(r.raw.length), i = t[t.length - 1], i && (i.type === "paragraph" || i.type === "text") ? (i.raw += ` +` + r.raw, i.text += ` +` + r.raw, this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { + href: r.href, + title: r.title + }); + continue; + } + if (r = this.tokenizer.table(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.lheading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (o = e, this.options.extensions && this.options.extensions.startBlock) { + let s = 1 / 0; + const l = e.slice(1); + let c; + this.options.extensions.startBlock.forEach((_) => { + c = _.call({ lexer: this }, l), typeof c == "number" && c >= 0 && (s = Math.min(s, c)); + }), s < 1 / 0 && s >= 0 && (o = e.substring(0, s + 1)); + } + if (this.state.top && (r = this.tokenizer.paragraph(o))) { + i = t[t.length - 1], n && (i == null ? void 0 : i.type) === "paragraph" ? (i.raw += ` +` + r.raw, i.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(r), n = o.length !== e.length, e = e.substring(r.raw.length); + continue; + } + if (r = this.tokenizer.text(e)) { + e = e.substring(r.raw.length), i = t[t.length - 1], i && i.type === "text" ? (i.raw += ` +` + r.raw, i.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(r); + continue; + } + if (e) { + const s = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(s); + break; + } else + throw new Error(s); + } + } + return this.state.top = !0, t; + } + inline(e, t = []) { + return this.inlineQueue.push({ src: e, tokens: t }), t; + } + /** + * Lexing/Compiling + */ + inlineTokens(e, t = []) { + let n, r, i, o = e, s, l, c; + if (this.tokens.links) { + const _ = Object.keys(this.tokens.links); + if (_.length > 0) + for (; (s = this.tokenizer.rules.inline.reflinkSearch.exec(o)) != null; ) + _.includes(s[0].slice(s[0].lastIndexOf("[") + 1, -1)) && (o = o.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + o.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex)); + } + for (; (s = this.tokenizer.rules.inline.blockSkip.exec(o)) != null; ) + o = o.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + o.slice(this.tokenizer.rules.inline.blockSkip.lastIndex); + for (; (s = this.tokenizer.rules.inline.anyPunctuation.exec(o)) != null; ) + o = o.slice(0, s.index) + "++" + o.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex); + for (; e; ) + if (l || (c = ""), l = !1, !(this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((_) => (n = _.call({ lexer: this }, e, t)) ? (e = e.substring(n.raw.length), t.push(n), !0) : !1))) { + if (n = this.tokenizer.escape(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.tag(e)) { + e = e.substring(n.raw.length), r = t[t.length - 1], r && n.type === "text" && r.type === "text" ? (r.raw += n.raw, r.text += n.text) : t.push(n); + continue; + } + if (n = this.tokenizer.link(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.reflink(e, this.tokens.links)) { + e = e.substring(n.raw.length), r = t[t.length - 1], r && n.type === "text" && r.type === "text" ? (r.raw += n.raw, r.text += n.text) : t.push(n); + continue; + } + if (n = this.tokenizer.emStrong(e, o, c)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.codespan(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.br(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.del(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.autolink(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (!this.state.inLink && (n = this.tokenizer.url(e))) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (i = e, this.options.extensions && this.options.extensions.startInline) { + let _ = 1 / 0; + const d = e.slice(1); + let p; + this.options.extensions.startInline.forEach((u) => { + p = u.call({ lexer: this }, d), typeof p == "number" && p >= 0 && (_ = Math.min(_, p)); + }), _ < 1 / 0 && _ >= 0 && (i = e.substring(0, _ + 1)); + } + if (n = this.tokenizer.inlineText(i)) { + e = e.substring(n.raw.length), n.raw.slice(-1) !== "_" && (c = n.raw.slice(-1)), l = !0, r = t[t.length - 1], r && r.type === "text" ? (r.raw += n.raw, r.text += n.text) : t.push(n); + continue; + } + if (e) { + const _ = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(_); + break; + } else + throw new Error(_); + } + } + return t; + } +} +class xn { + // set by the parser + constructor(e) { + ue(this, "options"); + ue(this, "parser"); + this.options = e || Bt; + } + space(e) { + return ""; + } + code({ text: e, lang: t, escaped: n }) { + var o; + const r = (o = (t || "").match(/^\S*/)) == null ? void 0 : o[0], i = e.replace(/\n$/, "") + ` +`; + return r ? '
' + (n ? i : qe(i, !0)) + `
+` : "
" + (n ? i : qe(i, !0)) + `
+`; + } + blockquote({ tokens: e }) { + return `
+${this.parser.parse(e)}
+`; + } + html({ text: e }) { + return e; + } + heading({ tokens: e, depth: t }) { + return `${this.parser.parseInline(e)} +`; + } + hr(e) { + return `
+`; + } + list(e) { + const t = e.ordered, n = e.start; + let r = ""; + for (let s = 0; s < e.items.length; s++) { + const l = e.items[s]; + r += this.listitem(l); + } + const i = t ? "ol" : "ul", o = t && n !== 1 ? ' start="' + n + '"' : ""; + return "<" + i + o + `> +` + r + " +`; + } + listitem(e) { + let t = ""; + if (e.task) { + const n = this.checkbox({ checked: !!e.checked }); + e.loose ? e.tokens.length > 0 && e.tokens[0].type === "paragraph" ? (e.tokens[0].text = n + " " + e.tokens[0].text, e.tokens[0].tokens && e.tokens[0].tokens.length > 0 && e.tokens[0].tokens[0].type === "text" && (e.tokens[0].tokens[0].text = n + " " + e.tokens[0].tokens[0].text)) : e.tokens.unshift({ + type: "text", + raw: n + " ", + text: n + " " + }) : t += n + " "; + } + return t += this.parser.parse(e.tokens, !!e.loose), `
  • ${t}
    • +`; + } + checkbox({ checked: e }) { + return "'; + } + paragraph({ tokens: e }) { + return `

    ${this.parser.parseInline(e)}

    +`; + } + table(e) { + let t = "", n = ""; + for (let i = 0; i < e.header.length; i++) + n += this.tablecell(e.header[i]); + t += this.tablerow({ text: n }); + let r = ""; + for (let i = 0; i < e.rows.length; i++) { + const o = e.rows[i]; + n = ""; + for (let s = 0; s < o.length; s++) + n += this.tablecell(o[s]); + r += this.tablerow({ text: n }); + } + return r && (r = `${r}`), ` + +` + t + ` +` + r + `
    +`; + } + tablerow({ text: e }) { + return ` +${e} +`; + } + tablecell(e) { + const t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td"; + return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + ` +`; + } + /** + * span level renderer + */ + strong({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + em({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + codespan({ text: e }) { + return `${e}`; + } + br(e) { + return "
    "; + } + del({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + link({ href: e, title: t, tokens: n }) { + const r = this.parser.parseInline(n), i = Fs(e); + if (i === null) + return r; + e = i; + let o = '    ", o; + } + image({ href: e, title: t, text: n }) { + const r = Fs(e); + if (r === null) + return n; + e = r; + let i = `${n} { + const c = s[l].flat(1 / 0); + n = n.concat(this.walkTokens(c, t)); + }) : s.tokens && (n = n.concat(this.walkTokens(s.tokens, t))); + } + } + return n; + } + use(...e) { + const t = this.defaults.extensions || { renderers: {}, childTokens: {} }; + return e.forEach((n) => { + const r = { ...n }; + if (r.async = this.defaults.async || r.async || !1, n.extensions && (n.extensions.forEach((i) => { + if (!i.name) + throw new Error("extension name required"); + if ("renderer" in i) { + const o = t.renderers[i.name]; + o ? t.renderers[i.name] = function(...s) { + let l = i.renderer.apply(this, s); + return l === !1 && (l = o.apply(this, s)), l; + } : t.renderers[i.name] = i.renderer; + } + if ("tokenizer" in i) { + if (!i.level || i.level !== "block" && i.level !== "inline") + throw new Error("extension level must be 'block' or 'inline'"); + const o = t[i.level]; + o ? o.unshift(i.tokenizer) : t[i.level] = [i.tokenizer], i.start && (i.level === "block" ? t.startBlock ? t.startBlock.push(i.start) : t.startBlock = [i.start] : i.level === "inline" && (t.startInline ? t.startInline.push(i.start) : t.startInline = [i.start])); + } + "childTokens" in i && i.childTokens && (t.childTokens[i.name] = i.childTokens); + }), r.extensions = t), n.renderer) { + const i = this.defaults.renderer || new xn(this.defaults); + for (const o in n.renderer) { + if (!(o in i)) + throw new Error(`renderer '${o}' does not exist`); + if (["options", "parser"].includes(o)) + continue; + const s = o, l = n.renderer[s], c = i[s]; + i[s] = (..._) => { + let d = l.apply(i, _); + return d === !1 && (d = c.apply(i, _)), d || ""; + }; + } + r.renderer = i; + } + if (n.tokenizer) { + const i = this.defaults.tokenizer || new Ln(this.defaults); + for (const o in n.tokenizer) { + if (!(o in i)) + throw new Error(`tokenizer '${o}' does not exist`); + if (["options", "rules", "lexer"].includes(o)) + continue; + const s = o, l = n.tokenizer[s], c = i[s]; + i[s] = (..._) => { + let d = l.apply(i, _); + return d === !1 && (d = c.apply(i, _)), d; + }; + } + r.tokenizer = i; + } + if (n.hooks) { + const i = this.defaults.hooks || new ln(); + for (const o in n.hooks) { + if (!(o in i)) + throw new Error(`hook '${o}' does not exist`); + if (["options", "block"].includes(o)) + continue; + const s = o, l = n.hooks[s], c = i[s]; + ln.passThroughHooks.has(o) ? i[s] = (_) => { + if (this.defaults.async) + return Promise.resolve(l.call(i, _)).then((p) => c.call(i, p)); + const d = l.call(i, _); + return c.call(i, d); + } : i[s] = (..._) => { + let d = l.apply(i, _); + return d === !1 && (d = c.apply(i, _)), d; + }; + } + r.hooks = i; + } + if (n.walkTokens) { + const i = this.defaults.walkTokens, o = n.walkTokens; + r.walkTokens = function(s) { + let l = []; + return l.push(o.call(this, s)), i && (l = l.concat(i.call(this, s))), l; + }; + } + this.defaults = { ...this.defaults, ...r }; + }), this; + } + setOptions(e) { + return this.defaults = { ...this.defaults, ...e }, this; + } + lexer(e, t) { + return Ke.lex(e, t ?? this.defaults); + } + parser(e, t) { + return Qe.parse(e, t ?? this.defaults); + } + parseMarkdown(e) { + return (n, r) => { + const i = { ...r }, o = { ...this.defaults, ...i }, s = this.onError(!!o.silent, !!o.async); + if (this.defaults.async === !0 && i.async === !1) + return s(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.")); + if (typeof n > "u" || n === null) + return s(new Error("marked(): input parameter is undefined or null")); + if (typeof n != "string") + return s(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected")); + o.hooks && (o.hooks.options = o, o.hooks.block = e); + const l = o.hooks ? o.hooks.provideLexer() : e ? Ke.lex : Ke.lexInline, c = o.hooks ? o.hooks.provideParser() : e ? Qe.parse : Qe.parseInline; + if (o.async) + return Promise.resolve(o.hooks ? o.hooks.preprocess(n) : n).then((_) => l(_, o)).then((_) => o.hooks ? o.hooks.processAllTokens(_) : _).then((_) => o.walkTokens ? Promise.all(this.walkTokens(_, o.walkTokens)).then(() => _) : _).then((_) => c(_, o)).then((_) => o.hooks ? o.hooks.postprocess(_) : _).catch(s); + try { + o.hooks && (n = o.hooks.preprocess(n)); + let _ = l(n, o); + o.hooks && (_ = o.hooks.processAllTokens(_)), o.walkTokens && this.walkTokens(_, o.walkTokens); + let d = c(_, o); + return o.hooks && (d = o.hooks.postprocess(d)), d; + } catch (_) { + return s(_); + } + }; + } + onError(e, t) { + return (n) => { + if (n.message += ` +Please report this to https://github.com/markedjs/marked.`, e) { + const r = "

    An error occurred:

    " + qe(n.message + "", !0) + "
    "; + return t ? Promise.resolve(r) : r; + } + if (t) + return Promise.reject(n); + throw n; + }; + } +} +const Ft = new Fu(); +function le(a, e) { + return Ft.parse(a, e); +} +le.options = le.setOptions = function(a) { + return Ft.setOptions(a), le.defaults = Ft.defaults, vu(le.defaults), le; +}; +le.getDefaults = os; +le.defaults = Bt; +le.use = function(...a) { + return Ft.use(...a), le.defaults = Ft.defaults, vu(le.defaults), le; +}; +le.walkTokens = function(a, e) { + return Ft.walkTokens(a, e); +}; +le.parseInline = Ft.parseInline; +le.Parser = Qe; +le.parser = Qe.parse; +le.Renderer = xn; +le.TextRenderer = us; +le.Lexer = Ke; +le.lexer = Ke.lex; +le.Tokenizer = Ln; +le.Hooks = ln; +le.parse = le; +le.options; +le.setOptions; +le.use; +le.walkTokens; +le.parseInline; +Qe.parse; +Ke.lex; +function $E(a) { + if (typeof a == "function" && (a = { + highlight: a + }), !a || typeof a.highlight != "function") + throw new Error("Must provide highlight function"); + return typeof a.langPrefix != "string" && (a.langPrefix = "language-"), { + async: !!a.async, + walkTokens(e) { + if (e.type !== "code") + return; + const t = qs(e.lang); + if (a.async) + return Promise.resolve(a.highlight(e.text, t, e.lang || "")).then(Hs(e)); + const n = a.highlight(e.text, t, e.lang || ""); + if (n instanceof Promise) + throw new Error("markedHighlight is not set to async but the highlight function is async. Set the async option to true on markedHighlight to await the async highlight function."); + Hs(e)(n); + }, + useNewRenderer: !0, + renderer: { + code(e, t, n) { + typeof e == "object" && (n = e.escaped, t = e.lang, e = e.text); + const r = qs(t), i = r ? ` class="${a.langPrefix}${zs(r)}"` : ""; + return e = e.replace(/\n$/, ""), `
    ${n ? e : zs(e, !0)}
+
    `; + } + } + }; +} +function qs(a) { + return (a || "").match(/\S*/)[0]; +} +function Hs(a) { + return (e) => { + typeof e == "string" && e !== a.text && (a.escaped = !0, a.text = e); + }; +} +const Bu = /[&<>"']/, XE = new RegExp(Bu.source, "g"), Gu = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, ZE = new RegExp(Gu.source, "g"), JE = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" +}, Vs = (a) => JE[a]; +function zs(a, e) { + if (e) { + if (Bu.test(a)) + return a.replace(XE, Vs); + } else if (Gu.test(a)) + return a.replace(ZE, Vs); + return a; +} +function jE(a) { + return a && a.__esModule && Object.prototype.hasOwnProperty.call(a, "default") ? a.default : a; +} +function Yu(a) { + return a instanceof Map ? a.clear = a.delete = a.set = function() { + throw new Error("map is read-only"); + } : a instanceof Set && (a.add = a.clear = a.delete = function() { + throw new Error("set is read-only"); + }), Object.freeze(a), Object.getOwnPropertyNames(a).forEach((e) => { + const t = a[e], n = typeof t; + (n === "object" || n === "function") && !Object.isFrozen(t) && Yu(t); + }), a; +} +class Ws { + /** + * @param {CompiledMode} mode + */ + constructor(e) { + e.data === void 0 && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1; + } + ignoreMatch() { + this.isMatchIgnored = !0; + } +} +function qu(a) { + return a.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); +} +function yt(a, ...e) { + const t = /* @__PURE__ */ Object.create(null); + for (const n in a) + t[n] = a[n]; + return e.forEach(function(n) { + for (const r in n) + t[r] = n[r]; + }), /** @type {T} */ + t; +} +const eg = "", Ks = (a) => !!a.scope, tg = (a, { prefix: e }) => { + if (a.startsWith("language:")) + return a.replace("language:", "language-"); + if (a.includes(".")) { + const t = a.split("."); + return [ + `${e}${t.shift()}`, + ...t.map((n, r) => `${n}${"_".repeat(r + 1)}`) + ].join(" "); + } + return `${e}${a}`; +}; +class ng { + /** + * Creates a new HTMLRenderer + * + * @param {Tree} parseTree - the parse tree (must support `walk` API) + * @param {{classPrefix: string}} options + */ + constructor(e, t) { + this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this); + } + /** + * Adds texts to the output stream + * + * @param {string} text */ + addText(e) { + this.buffer += qu(e); + } + /** + * Adds a node open to the output stream (if needed) + * + * @param {Node} node */ + openNode(e) { + if (!Ks(e)) return; + const t = tg( + e.scope, + { prefix: this.classPrefix } + ); + this.span(t); + } + /** + * Adds a node close to the output stream (if needed) + * + * @param {Node} node */ + closeNode(e) { + Ks(e) && (this.buffer += eg); + } + /** + * returns the accumulated buffer + */ + value() { + return this.buffer; + } + // helpers + /** + * Builds a span element + * + * @param {string} className */ + span(e) { + this.buffer += ``; + } +} +const Qs = (a = {}) => { + const e = { children: [] }; + return Object.assign(e, a), e; +}; +class ps { + constructor() { + this.rootNode = Qs(), this.stack = [this.rootNode]; + } + get top() { + return this.stack[this.stack.length - 1]; + } + get root() { + return this.rootNode; + } + /** @param {Node} node */ + add(e) { + this.top.children.push(e); + } + /** @param {string} scope */ + openNode(e) { + const t = Qs({ scope: e }); + this.add(t), this.stack.push(t); + } + closeNode() { + if (this.stack.length > 1) + return this.stack.pop(); + } + closeAllNodes() { + for (; this.closeNode(); ) ; + } + toJSON() { + return JSON.stringify(this.rootNode, null, 4); + } + /** + * @typedef { import("./html_renderer").Renderer } Renderer + * @param {Renderer} builder + */ + walk(e) { + return this.constructor._walk(e, this.rootNode); + } + /** + * @param {Renderer} builder + * @param {Node} node + */ + static _walk(e, t) { + return typeof t == "string" ? e.addText(t) : t.children && (e.openNode(t), t.children.forEach((n) => this._walk(e, n)), e.closeNode(t)), e; + } + /** + * @param {Node} node + */ + static _collapse(e) { + typeof e != "string" && e.children && (e.children.every((t) => typeof t == "string") ? e.children = [e.children.join("")] : e.children.forEach((t) => { + ps._collapse(t); + })); + } +} +class ag extends ps { + /** + * @param {*} options + */ + constructor(e) { + super(), this.options = e; + } + /** + * @param {string} text + */ + addText(e) { + e !== "" && this.add(e); + } + /** @param {string} scope */ + startScope(e) { + this.openNode(e); + } + endScope() { + this.closeNode(); + } + /** + * @param {Emitter & {root: DataNode}} emitter + * @param {string} name + */ + __addSublanguage(e, t) { + const n = e.root; + t && (n.scope = `language:${t}`), this.add(n); + } + toHTML() { + return new ng(this, this.options).value(); + } + finalize() { + return this.closeAllNodes(), !0; + } +} +function dn(a) { + return a ? typeof a == "string" ? a : a.source : null; +} +function Hu(a) { + return Gt("(?=", a, ")"); +} +function rg(a) { + return Gt("(?:", a, ")*"); +} +function ig(a) { + return Gt("(?:", a, ")?"); +} +function Gt(...a) { + return a.map((t) => dn(t)).join(""); +} +function og(a) { + const e = a[a.length - 1]; + return typeof e == "object" && e.constructor === Object ? (a.splice(a.length - 1, 1), e) : {}; +} +function ms(...a) { + return "(" + (og(a).capture ? "" : "?:") + a.map((n) => dn(n)).join("|") + ")"; +} +function Vu(a) { + return new RegExp(a.toString() + "|").exec("").length - 1; +} +function sg(a, e) { + const t = a && a.exec(e); + return t && t.index === 0; +} +const lg = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; +function Es(a, { joinWith: e }) { + let t = 0; + return a.map((n) => { + t += 1; + const r = t; + let i = dn(n), o = ""; + for (; i.length > 0; ) { + const s = lg.exec(i); + if (!s) { + o += i; + break; + } + o += i.substring(0, s.index), i = i.substring(s.index + s[0].length), s[0][0] === "\\" && s[1] ? o += "\\" + String(Number(s[1]) + r) : (o += s[0], s[0] === "(" && t++); + } + return o; + }).map((n) => `(${n})`).join(e); +} +const cg = /\b\B/, zu = "[a-zA-Z]\\w*", gs = "[a-zA-Z_]\\w*", Wu = "\\b\\d+(\\.\\d+)?", Ku = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Qu = "\\b(0b[01]+)", _g = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", dg = (a = {}) => { + const e = /^#![ ]*\//; + return a.binary && (a.begin = Gt( + e, + /.*\b/, + a.binary, + /\b.*/ + )), yt({ + scope: "meta", + begin: e, + end: /$/, + relevance: 0, + /** @type {ModeCallback} */ + "on:begin": (t, n) => { + t.index !== 0 && n.ignoreMatch(); + } + }, a); +}, un = { + begin: "\\\\[\\s\\S]", + relevance: 0 +}, ug = { + scope: "string", + begin: "'", + end: "'", + illegal: "\\n", + contains: [un] +}, pg = { + scope: "string", + begin: '"', + end: '"', + illegal: "\\n", + contains: [un] +}, mg = { + begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/ +}, Yn = function(a, e, t = {}) { + const n = yt( + { + scope: "comment", + begin: a, + end: e, + contains: [] + }, + t + ); + n.contains.push({ + scope: "doctag", + // hack to avoid the space from being included. the space is necessary to + // match here to prevent the plain text rule below from gobbling up doctags + begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)", + end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, + excludeBegin: !0, + relevance: 0 + }); + const r = ms( + // list of common 1 and 2 letter words in English + "I", + "a", + "is", + "so", + "us", + "to", + "at", + "if", + "in", + "it", + "on", + // note: this is not an exhaustive list of contractions, just popular ones + /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, + // contractions - can't we'd they're let's, etc + /[A-Za-z]+[-][a-z]+/, + // `no-way`, etc. + /[A-Za-z][a-z]{2,}/ + // allow capitalized words at beginning of sentences + ); + return n.contains.push( + { + // TODO: how to include ", (, ) without breaking grammars that use these for + // comment delimiters? + // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/ + // --- + // this tries to find sequences of 3 english words in a row (without any + // "programming" type syntax) this gives us a strong signal that we've + // TRULY found a comment - vs perhaps scanning with the wrong language. + // It's possible to find something that LOOKS like the start of the + // comment - but then if there is no readable text - good chance it is a + // false match and not a comment. + // + // for a visual example please see: + // https://github.com/highlightjs/highlight.js/issues/2827 + begin: Gt( + /[ ]+/, + // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */ + "(", + r, + /[.]?[:]?([.][ ]|[ ])/, + "){3}" + ) + // look for 3 words in a row + } + ), n; +}, Eg = Yn("//", "$"), gg = Yn("/\\*", "\\*/"), Sg = Yn("#", "$"), Tg = { + scope: "number", + begin: Wu, + relevance: 0 +}, fg = { + scope: "number", + begin: Ku, + relevance: 0 +}, bg = { + scope: "number", + begin: Qu, + relevance: 0 +}, Rg = { + scope: "regexp", + begin: /\/(?=[^/\n]*\/)/, + end: /\/[gimuy]*/, + contains: [ + un, + { + begin: /\[/, + end: /\]/, + relevance: 0, + contains: [un] + } + ] +}, Cg = { + scope: "title", + begin: zu, + relevance: 0 +}, Ng = { + scope: "title", + begin: gs, + relevance: 0 +}, Og = { + // excludes method names from keyword processing + begin: "\\.\\s*" + gs, + relevance: 0 +}, Ag = function(a) { + return Object.assign( + a, + { + /** @type {ModeCallback} */ + "on:begin": (e, t) => { + t.data._beginMatch = e[1]; + }, + /** @type {ModeCallback} */ + "on:end": (e, t) => { + t.data._beginMatch !== e[1] && t.ignoreMatch(); + } + } + ); +}; +var An = /* @__PURE__ */ Object.freeze({ + __proto__: null, + APOS_STRING_MODE: ug, + BACKSLASH_ESCAPE: un, + BINARY_NUMBER_MODE: bg, + BINARY_NUMBER_RE: Qu, + COMMENT: Yn, + C_BLOCK_COMMENT_MODE: gg, + C_LINE_COMMENT_MODE: Eg, + C_NUMBER_MODE: fg, + C_NUMBER_RE: Ku, + END_SAME_AS_BEGIN: Ag, + HASH_COMMENT_MODE: Sg, + IDENT_RE: zu, + MATCH_NOTHING_RE: cg, + METHOD_GUARD: Og, + NUMBER_MODE: Tg, + NUMBER_RE: Wu, + PHRASAL_WORDS_MODE: mg, + QUOTE_STRING_MODE: pg, + REGEXP_MODE: Rg, + RE_STARTERS_RE: _g, + SHEBANG: dg, + TITLE_MODE: Cg, + UNDERSCORE_IDENT_RE: gs, + UNDERSCORE_TITLE_MODE: Ng +}); +function Ig(a, e) { + a.input[a.index - 1] === "." && e.ignoreMatch(); +} +function hg(a, e) { + a.className !== void 0 && (a.scope = a.className, delete a.className); +} +function vg(a, e) { + e && a.beginKeywords && (a.begin = "\\b(" + a.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", a.__beforeBegin = Ig, a.keywords = a.keywords || a.beginKeywords, delete a.beginKeywords, a.relevance === void 0 && (a.relevance = 0)); +} +function yg(a, e) { + Array.isArray(a.illegal) && (a.illegal = ms(...a.illegal)); +} +function Dg(a, e) { + if (a.match) { + if (a.begin || a.end) throw new Error("begin & end are not supported with match"); + a.begin = a.match, delete a.match; + } +} +function Mg(a, e) { + a.relevance === void 0 && (a.relevance = 1); +} +const Lg = (a, e) => { + if (!a.beforeMatch) return; + if (a.starts) throw new Error("beforeMatch cannot be used with starts"); + const t = Object.assign({}, a); + Object.keys(a).forEach((n) => { + delete a[n]; + }), a.keywords = t.keywords, a.begin = Gt(t.beforeMatch, Hu(t.begin)), a.starts = { + relevance: 0, + contains: [ + Object.assign(t, { endsParent: !0 }) + ] + }, a.relevance = 0, delete t.beforeMatch; +}, wg = [ + "of", + "and", + "for", + "in", + "not", + "or", + "if", + "then", + "parent", + // common variable name + "list", + // common variable name + "value" + // common variable name +], xg = "keyword"; +function $u(a, e, t = xg) { + const n = /* @__PURE__ */ Object.create(null); + return typeof a == "string" ? r(t, a.split(" ")) : Array.isArray(a) ? r(t, a) : Object.keys(a).forEach(function(i) { + Object.assign( + n, + $u(a[i], e, i) + ); + }), n; + function r(i, o) { + e && (o = o.map((s) => s.toLowerCase())), o.forEach(function(s) { + const l = s.split("|"); + n[l[0]] = [i, Pg(l[0], l[1])]; + }); + } +} +function Pg(a, e) { + return e ? Number(e) : kg(a) ? 0 : 1; +} +function kg(a) { + return wg.includes(a.toLowerCase()); +} +const $s = {}, kt = (a) => { + console.error(a); +}, Xs = (a, ...e) => { + console.log(`WARN: ${a}`, ...e); +}, zt = (a, e) => { + $s[`${a}/${e}`] || (console.log(`Deprecated as of ${a}. ${e}`), $s[`${a}/${e}`] = !0); +}, Pn = new Error(); +function Xu(a, e, { key: t }) { + let n = 0; + const r = a[t], i = {}, o = {}; + for (let s = 1; s <= e.length; s++) + o[s + n] = r[s], i[s + n] = !0, n += Vu(e[s - 1]); + a[t] = o, a[t]._emit = i, a[t]._multi = !0; +} +function Ug(a) { + if (Array.isArray(a.begin)) { + if (a.skip || a.excludeBegin || a.returnBegin) + throw kt("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), Pn; + if (typeof a.beginScope != "object" || a.beginScope === null) + throw kt("beginScope must be object"), Pn; + Xu(a, a.begin, { key: "beginScope" }), a.begin = Es(a.begin, { joinWith: "" }); + } +} +function Fg(a) { + if (Array.isArray(a.end)) { + if (a.skip || a.excludeEnd || a.returnEnd) + throw kt("skip, excludeEnd, returnEnd not compatible with endScope: {}"), Pn; + if (typeof a.endScope != "object" || a.endScope === null) + throw kt("endScope must be object"), Pn; + Xu(a, a.end, { key: "endScope" }), a.end = Es(a.end, { joinWith: "" }); + } +} +function Bg(a) { + a.scope && typeof a.scope == "object" && a.scope !== null && (a.beginScope = a.scope, delete a.scope); +} +function Gg(a) { + Bg(a), typeof a.beginScope == "string" && (a.beginScope = { _wrap: a.beginScope }), typeof a.endScope == "string" && (a.endScope = { _wrap: a.endScope }), Ug(a), Fg(a); +} +function Yg(a) { + function e(o, s) { + return new RegExp( + dn(o), + "m" + (a.case_insensitive ? "i" : "") + (a.unicodeRegex ? "u" : "") + (s ? "g" : "") + ); + } + class t { + constructor() { + this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0; + } + // @ts-ignore + addRule(s, l) { + l.position = this.position++, this.matchIndexes[this.matchAt] = l, this.regexes.push([l, s]), this.matchAt += Vu(s) + 1; + } + compile() { + this.regexes.length === 0 && (this.exec = () => null); + const s = this.regexes.map((l) => l[1]); + this.matcherRe = e(Es(s, { joinWith: "|" }), !0), this.lastIndex = 0; + } + /** @param {string} s */ + exec(s) { + this.matcherRe.lastIndex = this.lastIndex; + const l = this.matcherRe.exec(s); + if (!l) + return null; + const c = l.findIndex((d, p) => p > 0 && d !== void 0), _ = this.matchIndexes[c]; + return l.splice(0, c), Object.assign(l, _); + } + } + class n { + constructor() { + this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0; + } + // @ts-ignore + getMatcher(s) { + if (this.multiRegexes[s]) return this.multiRegexes[s]; + const l = new t(); + return this.rules.slice(s).forEach(([c, _]) => l.addRule(c, _)), l.compile(), this.multiRegexes[s] = l, l; + } + resumingScanAtSamePosition() { + return this.regexIndex !== 0; + } + considerAll() { + this.regexIndex = 0; + } + // @ts-ignore + addRule(s, l) { + this.rules.push([s, l]), l.type === "begin" && this.count++; + } + /** @param {string} s */ + exec(s) { + const l = this.getMatcher(this.regexIndex); + l.lastIndex = this.lastIndex; + let c = l.exec(s); + if (this.resumingScanAtSamePosition() && !(c && c.index === this.lastIndex)) { + const _ = this.getMatcher(0); + _.lastIndex = this.lastIndex + 1, c = _.exec(s); + } + return c && (this.regexIndex += c.position + 1, this.regexIndex === this.count && this.considerAll()), c; + } + } + function r(o) { + const s = new n(); + return o.contains.forEach((l) => s.addRule(l.begin, { rule: l, type: "begin" })), o.terminatorEnd && s.addRule(o.terminatorEnd, { type: "end" }), o.illegal && s.addRule(o.illegal, { type: "illegal" }), s; + } + function i(o, s) { + const l = ( + /** @type CompiledMode */ + o + ); + if (o.isCompiled) return l; + [ + hg, + // do this early so compiler extensions generally don't have to worry about + // the distinction between match/begin + Dg, + Gg, + Lg + ].forEach((_) => _(o, s)), a.compilerExtensions.forEach((_) => _(o, s)), o.__beforeBegin = null, [ + vg, + // do this later so compiler extensions that come earlier have access to the + // raw array if they wanted to perhaps manipulate it, etc. + yg, + // default to 1 relevance if not specified + Mg + ].forEach((_) => _(o, s)), o.isCompiled = !0; + let c = null; + return typeof o.keywords == "object" && o.keywords.$pattern && (o.keywords = Object.assign({}, o.keywords), c = o.keywords.$pattern, delete o.keywords.$pattern), c = c || /\w+/, o.keywords && (o.keywords = $u(o.keywords, a.case_insensitive)), l.keywordPatternRe = e(c, !0), s && (o.begin || (o.begin = /\B|\b/), l.beginRe = e(l.begin), !o.end && !o.endsWithParent && (o.end = /\B|\b/), o.end && (l.endRe = e(l.end)), l.terminatorEnd = dn(l.end) || "", o.endsWithParent && s.terminatorEnd && (l.terminatorEnd += (o.end ? "|" : "") + s.terminatorEnd)), o.illegal && (l.illegalRe = e( + /** @type {RegExp | string} */ + o.illegal + )), o.contains || (o.contains = []), o.contains = [].concat(...o.contains.map(function(_) { + return qg(_ === "self" ? o : _); + })), o.contains.forEach(function(_) { + i( + /** @type Mode */ + _, + l + ); + }), o.starts && i(o.starts, s), l.matcher = r(l), l; + } + if (a.compilerExtensions || (a.compilerExtensions = []), a.contains && a.contains.includes("self")) + throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation."); + return a.classNameAliases = yt(a.classNameAliases || {}), i( + /** @type Mode */ + a + ); +} +function Zu(a) { + return a ? a.endsWithParent || Zu(a.starts) : !1; +} +function qg(a) { + return a.variants && !a.cachedVariants && (a.cachedVariants = a.variants.map(function(e) { + return yt(a, { variants: null }, e); + })), a.cachedVariants ? a.cachedVariants : Zu(a) ? yt(a, { starts: a.starts ? yt(a.starts) : null }) : Object.isFrozen(a) ? yt(a) : a; +} +var Hg = "11.10.0"; +class Vg extends Error { + constructor(e, t) { + super(e), this.name = "HTMLInjectionError", this.html = t; + } +} +const ua = qu, Zs = yt, Js = Symbol("nomatch"), zg = 7, Ju = function(a) { + const e = /* @__PURE__ */ Object.create(null), t = /* @__PURE__ */ Object.create(null), n = []; + let r = !0; + const i = "Could not find the language '{}', did you forget to load/include a language module?", o = { disableAutodetect: !0, name: "Plain text", contains: [] }; + let s = { + ignoreUnescapedHTML: !1, + throwUnescapedHTML: !1, + noHighlightRe: /^(no-?highlight)$/i, + languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, + classPrefix: "hljs-", + cssSelector: "pre code", + languages: null, + // beta configuration options, subject to change, welcome to discuss + // https://github.com/highlightjs/highlight.js/issues/1086 + __emitter: ag + }; + function l(I) { + return s.noHighlightRe.test(I); + } + function c(I) { + let M = I.className + " "; + M += I.parentNode ? I.parentNode.className : ""; + const B = s.languageDetectRe.exec(M); + if (B) { + const V = D(B[1]); + return V || (Xs(i.replace("{}", B[1])), Xs("Falling back to no-highlight mode for this block.", I)), V ? B[1] : "no-highlight"; + } + return M.split(/\s+/).find((V) => l(V) || D(V)); + } + function _(I, M, B) { + let V = "", F = ""; + typeof M == "object" ? (V = I, B = M.ignoreIllegals, F = M.language) : (zt("10.7.0", "highlight(lang, code, ...args) has been deprecated."), zt("10.7.0", `Please use highlight(code, options) instead. +https://github.com/highlightjs/highlight.js/issues/2277`), F = I, V = M), B === void 0 && (B = !0); + const _e = { + code: V, + language: F + }; + Y("before:highlight", _e); + const K = _e.result ? _e.result : d(_e.language, _e.code, B); + return K.code = _e.code, Y("after:highlight", K), K; + } + function d(I, M, B, V) { + const F = /* @__PURE__ */ Object.create(null); + function _e(L, x) { + return L.keywords[x]; + } + function K() { + if (!G.keywords) { + me.addText(re); + return; + } + let L = 0; + G.keywordPatternRe.lastIndex = 0; + let x = G.keywordPatternRe.exec(re), q = ""; + for (; x; ) { + q += re.substring(L, x.index); + const J = Te.case_insensitive ? x[0].toLowerCase() : x[0], be = _e(G, J); + if (be) { + const [Ie, gt] = be; + if (me.addText(q), q = "", F[J] = (F[J] || 0) + 1, F[J] <= zg && (Je += gt), Ie.startsWith("_")) + q += x[0]; + else { + const Fe = Te.classNameAliases[Ie] || Ie; + ee(x[0], Fe); + } + } else + q += x[0]; + L = G.keywordPatternRe.lastIndex, x = G.keywordPatternRe.exec(re); + } + q += re.substring(L), me.addText(q); + } + function Se() { + if (re === "") return; + let L = null; + if (typeof G.subLanguage == "string") { + if (!e[G.subLanguage]) { + me.addText(re); + return; + } + L = d(G.subLanguage, re, !0, Nt[G.subLanguage]), Nt[G.subLanguage] = /** @type {CompiledMode} */ + L._top; + } else + L = u(re, G.subLanguage.length ? G.subLanguage : null); + G.relevance > 0 && (Je += L.relevance), me.__addSublanguage(L._emitter, L.language); + } + function v() { + G.subLanguage != null ? Se() : K(), re = ""; + } + function ee(L, x) { + L !== "" && (me.startScope(x), me.addText(L), me.endScope()); + } + function Z(L, x) { + let q = 1; + const J = x.length - 1; + for (; q <= J; ) { + if (!L._emit[q]) { + q++; + continue; + } + const be = Te.classNameAliases[L[q]] || L[q], Ie = x[q]; + be ? ee(Ie, be) : (re = Ie, K(), re = ""), q++; + } + } + function $(L, x) { + return L.scope && typeof L.scope == "string" && me.openNode(Te.classNameAliases[L.scope] || L.scope), L.beginScope && (L.beginScope._wrap ? (ee(re, Te.classNameAliases[L.beginScope._wrap] || L.beginScope._wrap), re = "") : L.beginScope._multi && (Z(L.beginScope, x), re = "")), G = Object.create(L, { parent: { value: G } }), G; + } + function ae(L, x, q) { + let J = sg(L.endRe, q); + if (J) { + if (L["on:end"]) { + const be = new Ws(L); + L["on:end"](x, be), be.isMatchIgnored && (J = !1); + } + if (J) { + for (; L.endsParent && L.parent; ) + L = L.parent; + return L; + } + } + if (L.endsWithParent) + return ae(L.parent, x, q); + } + function ie(L) { + return G.matcher.regexIndex === 0 ? (re += L[0], 1) : (Ne = !0, 0); + } + function se(L) { + const x = L[0], q = L.rule, J = new Ws(q), be = [q.__beforeBegin, q["on:begin"]]; + for (const Ie of be) + if (Ie && (Ie(L, J), J.isMatchIgnored)) + return ie(x); + return q.skip ? re += x : (q.excludeBegin && (re += x), v(), !q.returnBegin && !q.excludeBegin && (re = x)), $(q, L), q.returnBegin ? 0 : x.length; + } + function pe(L) { + const x = L[0], q = M.substring(L.index), J = ae(G, L, q); + if (!J) + return Js; + const be = G; + G.endScope && G.endScope._wrap ? (v(), ee(x, G.endScope._wrap)) : G.endScope && G.endScope._multi ? (v(), Z(G.endScope, L)) : be.skip ? re += x : (be.returnEnd || be.excludeEnd || (re += x), v(), be.excludeEnd && (re = x)); + do + G.scope && me.closeNode(), !G.skip && !G.subLanguage && (Je += G.relevance), G = G.parent; + while (G !== J.parent); + return J.starts && $(J.starts, L), be.returnEnd ? 0 : x.length; + } + function Ae() { + const L = []; + for (let x = G; x !== Te; x = x.parent) + x.scope && L.unshift(x.scope); + L.forEach((x) => me.openNode(x)); + } + let Ce = {}; + function De(L, x) { + const q = x && x[0]; + if (re += L, q == null) + return v(), 0; + if (Ce.type === "begin" && x.type === "end" && Ce.index === x.index && q === "") { + if (re += M.slice(x.index, x.index + 1), !r) { + const J = new Error(`0 width match regex (${I})`); + throw J.languageName = I, J.badRule = Ce.rule, J; + } + return 1; + } + if (Ce = x, x.type === "begin") + return se(x); + if (x.type === "illegal" && !B) { + const J = new Error('Illegal lexeme "' + q + '" for mode "' + (G.scope || "") + '"'); + throw J.mode = G, J; + } else if (x.type === "end") { + const J = pe(x); + if (J !== Js) + return J; + } + if (x.type === "illegal" && q === "") + return 1; + if (we > 1e5 && we > x.index * 3) + throw new Error("potential infinite loop, way more iterations than matches"); + return re += q, q.length; + } + const Te = D(I); + if (!Te) + throw kt(i.replace("{}", I)), new Error('Unknown language: "' + I + '"'); + const Ve = Yg(Te); + let ze = "", G = V || Ve; + const Nt = {}, me = new s.__emitter(s); + Ae(); + let re = "", Je = 0, Le = 0, we = 0, Ne = !1; + try { + if (Te.__emitTokens) + Te.__emitTokens(M, me); + else { + for (G.matcher.considerAll(); ; ) { + we++, Ne ? Ne = !1 : G.matcher.considerAll(), G.matcher.lastIndex = Le; + const L = G.matcher.exec(M); + if (!L) break; + const x = M.substring(Le, L.index), q = De(x, L); + Le = L.index + q; + } + De(M.substring(Le)); + } + return me.finalize(), ze = me.toHTML(), { + language: I, + value: ze, + relevance: Je, + illegal: !1, + _emitter: me, + _top: G + }; + } catch (L) { + if (L.message && L.message.includes("Illegal")) + return { + language: I, + value: ua(M), + illegal: !0, + relevance: 0, + _illegalBy: { + message: L.message, + index: Le, + context: M.slice(Le - 100, Le + 100), + mode: L.mode, + resultSoFar: ze + }, + _emitter: me + }; + if (r) + return { + language: I, + value: ua(M), + illegal: !1, + relevance: 0, + errorRaised: L, + _emitter: me, + _top: G + }; + throw L; + } + } + function p(I) { + const M = { + value: ua(I), + illegal: !1, + relevance: 0, + _top: o, + _emitter: new s.__emitter(s) + }; + return M._emitter.addText(I), M; + } + function u(I, M) { + M = M || s.languages || Object.keys(e); + const B = p(I), V = M.filter(D).filter(w).map( + (v) => d(v, I, !1) + ); + V.unshift(B); + const F = V.sort((v, ee) => { + if (v.relevance !== ee.relevance) return ee.relevance - v.relevance; + if (v.language && ee.language) { + if (D(v.language).supersetOf === ee.language) + return 1; + if (D(ee.language).supersetOf === v.language) + return -1; + } + return 0; + }), [_e, K] = F, Se = _e; + return Se.secondBest = K, Se; + } + function m(I, M, B) { + const V = M && t[M] || B; + I.classList.add("hljs"), I.classList.add(`language-${V}`); + } + function S(I) { + let M = null; + const B = c(I); + if (l(B)) return; + if (Y( + "before:highlightElement", + { el: I, language: B } + ), I.dataset.highlighted) { + console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", I); + return; + } + if (I.children.length > 0 && (s.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."), console.warn("https://github.com/highlightjs/highlight.js/wiki/security"), console.warn("The element with unescaped HTML:"), console.warn(I)), s.throwUnescapedHTML)) + throw new Vg( + "One of your code blocks includes unescaped HTML.", + I.innerHTML + ); + M = I; + const V = M.textContent, F = B ? _(V, { language: B, ignoreIllegals: !0 }) : u(V); + I.innerHTML = F.value, I.dataset.highlighted = "yes", m(I, B, F.language), I.result = { + language: F.language, + // TODO: remove with version 11.0 + re: F.relevance, + relevance: F.relevance + }, F.secondBest && (I.secondBest = { + language: F.secondBest.language, + relevance: F.secondBest.relevance + }), Y("after:highlightElement", { el: I, result: F, text: V }); + } + function E(I) { + s = Zs(s, I); + } + const f = () => { + C(), zt("10.6.0", "initHighlighting() deprecated. Use highlightAll() now."); + }; + function g() { + C(), zt("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now."); + } + let R = !1; + function C() { + if (document.readyState === "loading") { + R = !0; + return; + } + document.querySelectorAll(s.cssSelector).forEach(S); + } + function h() { + R && C(); + } + typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", h, !1); + function N(I, M) { + let B = null; + try { + B = M(a); + } catch (V) { + if (kt("Language definition for '{}' could not be registered.".replace("{}", I)), r) + kt(V); + else + throw V; + B = o; + } + B.name || (B.name = I), e[I] = B, B.rawDefinition = M.bind(null, a), B.aliases && P(B.aliases, { languageName: I }); + } + function O(I) { + delete e[I]; + for (const M of Object.keys(t)) + t[M] === I && delete t[M]; + } + function A() { + return Object.keys(e); + } + function D(I) { + return I = (I || "").toLowerCase(), e[I] || e[t[I]]; + } + function P(I, { languageName: M }) { + typeof I == "string" && (I = [I]), I.forEach((B) => { + t[B.toLowerCase()] = M; + }); + } + function w(I) { + const M = D(I); + return M && !M.disableAutodetect; + } + function H(I) { + I["before:highlightBlock"] && !I["before:highlightElement"] && (I["before:highlightElement"] = (M) => { + I["before:highlightBlock"]( + Object.assign({ block: M.el }, M) + ); + }), I["after:highlightBlock"] && !I["after:highlightElement"] && (I["after:highlightElement"] = (M) => { + I["after:highlightBlock"]( + Object.assign({ block: M.el }, M) + ); + }); + } + function te(I) { + H(I), n.push(I); + } + function Q(I) { + const M = n.indexOf(I); + M !== -1 && n.splice(M, 1); + } + function Y(I, M) { + const B = I; + n.forEach(function(V) { + V[B] && V[B](M); + }); + } + function X(I) { + return zt("10.7.0", "highlightBlock will be removed entirely in v12.0"), zt("10.7.0", "Please use highlightElement now."), S(I); + } + Object.assign(a, { + highlight: _, + highlightAuto: u, + highlightAll: C, + highlightElement: S, + // TODO: Remove with v12 API + highlightBlock: X, + configure: E, + initHighlighting: f, + initHighlightingOnLoad: g, + registerLanguage: N, + unregisterLanguage: O, + listLanguages: A, + getLanguage: D, + registerAliases: P, + autoDetection: w, + inherit: Zs, + addPlugin: te, + removePlugin: Q + }), a.debugMode = function() { + r = !1; + }, a.safeMode = function() { + r = !0; + }, a.versionString = Hg, a.regex = { + concat: Gt, + lookahead: Hu, + either: ms, + optional: ig, + anyNumberOfTimes: rg + }; + for (const I in An) + typeof An[I] == "object" && Yu(An[I]); + return Object.assign(a, An), a; +}, Xt = Ju({}); +Xt.newInstance = () => Ju({}); +var Wg = Xt; +Xt.HighlightJS = Xt; +Xt.default = Xt; +var pa, js; +function Kg() { + if (js) return pa; + js = 1; + function a(e) { + const t = "[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]+", i = "далее " + "возврат вызватьисключение выполнить для если и из или иначе иначеесли исключение каждого конецесли конецпопытки конеццикла не новый перейти перем по пока попытка прервать продолжить тогда цикл экспорт ", l = "загрузитьизфайла " + "вебклиент вместо внешнеесоединение клиент конецобласти мобильноеприложениеклиент мобильноеприложениесервер наклиенте наклиентенасервере наклиентенасерверебезконтекста насервере насерверебезконтекста область перед после сервер толстыйклиентобычноеприложение толстыйклиентуправляемоеприложение тонкийклиент ", u = "разделительстраниц разделительстрок символтабуляции " + "ansitooem oemtoansi ввестивидсубконто ввестиперечисление ввестипериод ввестиплансчетов выбранныйплансчетов датагод датамесяц датачисло заголовоксистемы значениевстроку значениеизстроки каталогиб каталогпользователя кодсимв конгода конецпериодаби конецрассчитанногопериодаби конецстандартногоинтервала конквартала конмесяца коннедели лог лог10 максимальноеколичествосубконто названиеинтерфейса названиенабораправ назначитьвид назначитьсчет найтиссылки началопериодаби началостандартногоинтервала начгода начквартала начмесяца начнедели номерднягода номерднянедели номернеделигода обработкаожидания основнойжурналрасчетов основнойплансчетов основнойязык очиститьокносообщений периодстр получитьвремята получитьдатута получитьдокументта получитьзначенияотбора получитьпозициюта получитьпустоезначение получитьта префиксавтонумерации пропись пустоезначение разм разобратьпозициюдокумента рассчитатьрегистрына рассчитатьрегистрыпо симв создатьобъект статусвозврата стрколичествострок сформироватьпозициюдокумента счетпокоду текущеевремя типзначения типзначениястр установитьтана установитьтапо фиксшаблон шаблон " + "acos asin atan base64значение base64строка cos exp log log10 pow sin sqrt tan xmlзначение xmlстрока xmlтип xmlтипзнч активноеокно безопасныйрежим безопасныйрежимразделенияданных булево ввестидату ввестизначение ввестистроку ввестичисло возможностьчтенияxml вопрос восстановитьзначение врег выгрузитьжурналрегистрации выполнитьобработкуоповещения выполнитьпроверкуправдоступа вычислить год данныеформывзначение дата день деньгода деньнедели добавитьмесяц заблокироватьданныедляредактирования заблокироватьработупользователя завершитьработусистемы загрузитьвнешнююкомпоненту закрытьсправку записатьjson записатьxml записатьдатуjson записьжурналарегистрации заполнитьзначениясвойств запроситьразрешениепользователя запуститьприложение запуститьсистему зафиксироватьтранзакцию значениевданныеформы значениевстрокувнутр значениевфайл значениезаполнено значениеизстрокивнутр значениеизфайла изxmlтипа импортмоделиxdto имякомпьютера имяпользователя инициализироватьпредопределенныеданные информацияобошибке каталогбиблиотекимобильногоустройства каталогвременныхфайлов каталогдокументов каталогпрограммы кодироватьстроку кодлокализацииинформационнойбазы кодсимвола командасистемы конецгода конецдня конецквартала конецмесяца конецминуты конецнедели конецчаса конфигурациябазыданныхизмененадинамически конфигурацияизменена копироватьданныеформы копироватьфайл краткоепредставлениеошибки лев макс местноевремя месяц мин минута монопольныйрежим найти найтинедопустимыесимволыxml найтиокнопонавигационнойссылке найтипомеченныенаудаление найтипоссылкам найтифайлы началогода началодня началоквартала началомесяца началоминуты началонедели началочаса начатьзапросразрешенияпользователя начатьзапускприложения начатькопированиефайла начатьперемещениефайла начатьподключениевнешнейкомпоненты начатьподключениерасширенияработыскриптографией начатьподключениерасширенияработысфайлами начатьпоискфайлов начатьполучениекаталогавременныхфайлов начатьполучениекаталогадокументов начатьполучениерабочегокаталогаданныхпользователя начатьполучениефайлов начатьпомещениефайла начатьпомещениефайлов начатьсозданиедвоичныхданныхизфайла начатьсозданиекаталога начатьтранзакцию начатьудалениефайлов начатьустановкувнешнейкомпоненты начатьустановкурасширенияработыскриптографией начатьустановкурасширенияработысфайлами неделягода необходимостьзавершениясоединения номерсеансаинформационнойбазы номерсоединенияинформационнойбазы нрег нстр обновитьинтерфейс обновитьнумерациюобъектов обновитьповторноиспользуемыезначения обработкапрерыванияпользователя объединитьфайлы окр описаниеошибки оповестить оповеститьобизменении отключитьобработчикзапросанастроекклиенталицензирования отключитьобработчикожидания отключитьобработчикоповещения открытьзначение открытьиндекссправки открытьсодержаниесправки открытьсправку открытьформу открытьформумодально отменитьтранзакцию очиститьжурналрегистрации очиститьнастройкипользователя очиститьсообщения параметрыдоступа перейтипонавигационнойссылке переместитьфайл подключитьвнешнююкомпоненту подключитьобработчикзапросанастроекклиенталицензирования подключитьобработчикожидания подключитьобработчикоповещения подключитьрасширениеработыскриптографией подключитьрасширениеработысфайлами подробноепредставлениеошибки показатьвводдаты показатьвводзначения показатьвводстроки показатьвводчисла показатьвопрос показатьзначение показатьинформациюобошибке показатьнакарте показатьоповещениепользователя показатьпредупреждение полноеимяпользователя получитьcomобъект получитьxmlтип получитьадреспоместоположению получитьблокировкусеансов получитьвремязавершенияспящегосеанса получитьвремязасыпанияпассивногосеанса получитьвремяожиданияблокировкиданных получитьданныевыбора получитьдополнительныйпараметрклиенталицензирования получитьдопустимыекодылокализации получитьдопустимыечасовыепояса получитьзаголовокклиентскогоприложения получитьзаголовоксистемы получитьзначенияотборажурналарегистрации получитьидентификаторконфигурации получитьизвременногохранилища получитьимявременногофайла получитьимяклиенталицензирования получитьинформациюэкрановклиента получитьиспользованиежурналарегистрации получитьиспользованиесобытияжурналарегистрации получитькраткийзаголовокприложения получитьмакетоформления получитьмаскувсефайлы получитьмаскувсефайлыклиента получитьмаскувсефайлысервера получитьместоположен��епоадресу получитьминимальнуюдлинупаролейпользователей получитьнавигационнуюссылку получитьнавигационнуюссылкуинформационнойбазы получитьобновлениеконфигурациибазыданных получитьобновлениепредопределенныхданныхинформационнойбазы получитьобщиймакет получитьобщуюформу получитьокна получитьоперативнуюотметкувремени получитьотключениебезопасногорежима получитьпараметрыфункциональныхопцийинтерфейса получитьполноеимяпредопределенногозначения получитьпредставлениянавигационныхссылок получитьпроверкусложностипаролейпользователей получитьразделительпути получитьразделительпутиклиента получитьразделительпутисервера получитьсеансыинформационнойбазы получитьскоростьклиентскогосоединения получитьсоединенияинформационнойбазы получитьсообщенияпользователю получитьсоответствиеобъектаиформы получитьсоставстандартногоинтерфейсаodata получитьструктурухранениябазыданных получитьтекущийсеансинформационнойбазы получитьфайл получитьфайлы получитьформу получитьфункциональнуюопцию получитьфункциональнуюопциюинтерфейса получитьчасовойпоясинформационнойбазы пользователиос поместитьвовременноехранилище поместитьфайл поместитьфайлы прав праводоступа предопределенноезначение представлениекодалокализации представлениепериода представлениеправа представлениеприложения представлениесобытияжурналарегистрации представлениечасовогопояса предупреждение прекратитьработусистемы привилегированныйрежим продолжитьвызов прочитатьjson прочитатьxml прочитатьдатуjson пустаястрока рабочийкаталогданныхпользователя разблокироватьданныедляредактирования разделитьфайл разорватьсоединениесвнешнимисточникомданных раскодироватьстроку рольдоступна секунда сигнал символ скопироватьжурналрегистрации смещениелетнеговремени смещениестандартноговремени соединитьбуферыдвоичныхданных создатькаталог создатьфабрикуxdto сокрл сокрлп сокрп сообщить состояние сохранитьзначение сохранитьнастройкипользователя сред стрдлина стрзаканчиваетсяна стрзаменить стрнайти стрначинаетсяс строка строкасоединенияинформационнойбазы стрполучитьстроку стрразделить стрсоединить стрсравнить стрчисловхождений стрчислострок стршаблон текущаядата текущаядатасеанса текущаяуниверсальнаядата текущаяуниверсальнаядатавмиллисекундах текущийвариантинтерфейсаклиентскогоприложения текущийвариантосновногошрифтаклиентскогоприложения текущийкодлокализации текущийрежимзапуска текущийязык текущийязыксистемы тип типзнч транзакцияактивна трег удалитьданныеинформационнойбазы удалитьизвременногохранилища удалитьобъекты удалитьфайлы универсальноевремя установитьбезопасныйрежим установитьбезопасныйрежимразделенияданных установитьблокировкусеансов установитьвнешнююкомпоненту установитьвремязавершенияспящегосеанса установитьвремязасыпанияпассивногосеанса установитьвремяожиданияблокировкиданных установитьзаголовокклиентскогоприложения установитьзаголовоксистемы установитьиспользованиежурналарегистрации установитьиспользованиесобытияжурналарегистрации установитькраткийзаголовокприложения установитьминимальнуюдлинупаролейпользователей установитьмонопольныйрежим установитьнастройкиклиенталицензирования установитьобновлениепредопределенныхданныхинформационнойбазы установитьотключениебезопасногорежима установитьпараметрыфункциональныхопцийинтерфейса установитьпривилегированныйрежим установитьпроверкусложностипаролейпользователей установитьрасширениеработыскриптографией установитьрасширениеработысфайлами установитьсоединениесвнешнимисточникомданных установитьсоответствиеобъектаиформы установитьсоставстандартногоинтерфейсаodata установитьчасовойпоясинформационнойбазы установитьчасовойпояссеанса формат цел час часовойпояс часовойпояссеанса число числопрописью этоадресвременногохранилища " + "wsссылки библиотекакартинок библиотекамакетовоформлениякомпоновкиданных библиотекастилей бизнеспроцессы внешниеисточникиданных внешниеобработки внешниеотчеты встроенныепокупки главныйинтерфейс главныйстиль документы доставляемыеуведомления журналыдокументов задачи информацияобинтернетсоединении использованиерабочейдаты историяработыпользователя константы критерииотбора метаданные обработки отображениерекламы отправкадоставляемыхуведомлений отчеты панельзадачос параметрзапуска параметрысеанса перечисления планывидоврасчета планывидовхарактеристик планыобмена планысчетов полнотекстовыйпоиск пользователиинформационнойбазы последовательности проверкавстроенныхпокупок рабочаядата расширенияконфигурации регистрыбухгалтерии регистрынакопления регистрырасчета регистрысведений регламентныезадания сериализаторxdto справочники средствагеопозиционирования средствакриптографии средствамультимедиа средстваотображениярекламы средствапочты средствателефонии фабрикаxdto файловыепотоки фоновыезадания хранилищанастроек хранилищевариантовотчетов хранилищенастроекданныхформ хранилищеобщихнастроек хранилищепользовательскихнастроекдинамическихсписков хранилищепользовательскихнастроекотчетов хранилищесистемныхнастроек ", V = "webцвета windowsцвета windowsшрифты библиотекакартинок рамкистиля символы цветастиля шрифтыстиля " + "автоматическоесохранениеданныхформывнастройках автонумерациявформе автораздвижениесерий анимациядиаграммы вариантвыравниванияэлементовизаголовков вариантуправлениявысотойтаблицы вертикальнаяпрокруткаформы вертикальноеположение вертикальноеположениеэлемента видгруппыформы виддекорацииформы виддополненияэлементаформы видизмененияданных видкнопкиформы видпереключателя видподписейкдиаграмме видполяформы видфлажка влияниеразмеранапузырекдиаграммы горизонтальноеположение горизонтальноеположениеэлемента группировкаколонок группировкаподчиненныхэлементовформы группыиэлементы действиеперетаскивания дополнительныйрежимотображения допустимыедействияперетаскивания интервалмеждуэлементамиформы использованиевывода использованиеполосыпрокрутки используемоезначениеточкибиржевойдиаграммы историявыборапривводе источникзначенийоситочекдиаграммы источникзначенияразмерапузырькадиаграммы категориягруппыкоманд максимумсерий начальноеотображениедерева начальноеотображениесписка обновлениетекстаредактирования ориентациядендрограммы ориентациядиаграммы ориентацияметокдиаграммы ориентацияметоксводнойдиаграммы ориентацияэлементаформы отображениевдиаграмме отображениевлегендедиаграммы отображениегруппыкнопок отображениезаголовкашкалыдиаграммы отображениезначенийсводнойдиаграммы отображениезначенияизмерительнойдиаграммы отображениеинтерваладиаграммыганта отображениекнопки отображениекнопкивыбора отображениеобсужденийформы отображениеобычнойгруппы отображениеотрицательныхзначенийпузырьковойдиаграммы отображениепанелипоиска отображениеподсказки отображениепредупрежденияприредактировании отображениеразметкиполосырегулирования отображениестраницформы отображениетаблицы отображениетекстазначениядиаграммыганта отображениеуправленияобычнойгруппы отображениефигурыкнопки палитрацветовдиаграммы поведениеобычнойгруппы поддержкамасштабадендрограммы поддержкамасштабадиаграммыганта поддержкамасштабасводнойдиаграммы поисквтаблицепривводе положениезаголовкаэлементаформы положениекартинкикнопкиформы положениекартинкиэлементаграфическойсхемы положениекоманднойпанелиформы положениекоманднойпанелиэлементаформы положениеопорнойточкиотрисовки положениеподписейкдиаграмме положениеподписейшкалызначенийизмерительнойдиаграммы положениесостоянияпросмотра положениестрокипоиска положениетекстасоединительнойлинии положениеуправленияпоиском положениешкалывремени порядокотображенияточекгоризонтальнойгистограммы порядоксерийвлегендедиаграммы размеркартинки расположениезаголовкашкалыдиаграммы растягиваниеповертикалидиаграммыганта режимавтоотображениясостояния режимвводастроктаблицы режимвыборанезаполненного режимвыделениядаты режимвыделениястрокитаблицы режимвыделениятаблицы режимизмененияразмера режимизменениясвязанногозначения режимиспользованиядиалогапечати режимиспользованияпараметракоманды режиммасштабированияпросмотра режимосновногоокнаклиентскогоприложения режимоткрытияокнаформы режимотображениявыделения режимотображениягеографическойсхемы режимотображениязначенийсерии режимотрисовкисеткиграфическойсхемы режимполупрозрачностидиаграммы режимпробеловдиаграммы режимразмещениянастранице режимредактированияколонки режимсглаживаниядиаграммы режимсглаживанияиндикатора режимсписказадач сквозноевыравнивание сохранениеданныхформывнастройках способзаполнениятекстазаголовкашкалыдиаграммы способопределенияограничивающегозначениядиаграммы стандартнаягруппакоманд стандартноеоформление статусоповещенияпользователя стильстрелки типаппроксимациилиниитрендадиаграммы типдиаграммы типединицышкалывремени типимпортасерийслоягеографическойсхемы типлиниигеографическойсхемы типлиниидиаграммы типмаркерагеографическойсхемы типмаркерадиаграммы типобластиоформления типорганизацииисточникаданныхгеографическойсхемы типотображениясериислоягеографическойсхемы типотображенияточечногообъектагеографическойсхемы типотображенияшкалыэлементалегендыгеографическойсхемы типпоискаобъектовгеографическойсхемы типпроекциигеографическойсхемы типразмещенияизмерений типразмещенияреквизитовизмерений типрамкиэлементауправления типсводнойдиаграммы типсвязидиаграммыганта типсоединениязначенийпосериямдиаграммы типсоединенияточекдиаграммы типсоединительнойлинии типстороныэлементаграфическойсхемы типформыотчета типшкалырадарнойдиаграммы факторлиниитрендадиаграммы фигуракнопки фигурыграфическойсхемы фиксациявтаблице форматдняшкалывремени форматкартинки ширинаподчиненныхэлементовформы " + "виддвижениябухгалтерии виддвижениянакопления видпериодарегистрарасчета видсчета видточкимаршрутабизнеспроцесса использованиеагрегатарегистранакопления использованиегруппиэлементов использованиережимапроведения использованиесреза периодичностьагрегатарегистранакопления режимавтовремя режимзаписидокумента режимпроведениядокумента " + "авторегистрацияизменений допустимыйномерсообщения отправкаэлементаданных получениеэлементаданных " + "использованиерасшифровкитабличногодокумента ориентациястраницы положениеитоговколоноксводнойтаблицы положениеитоговстроксводнойтаблицы положениетекстаотносительнокартинки расположениезаголовкагруппировкитабличногодокумента способчтениязначенийтабличногодокумента типдвустороннейпечати типзаполненияобластитабличногодокумента типкурсоровтабличногодокумента типлиниирисункатабличногодокумента типлинииячейкитабличногодокумента типнаправленияпереходатабличногодокумента типотображениявыделениятабличногодокумента типотображениялинийсводнойтаблицы типразмещениятекстатабличногодокумента типрисункатабличногодокумента типсмещениятабличногодокумента типузоратабличногодокумента типфайлатабличногодокумента точностьпечати чередованиерасположениястраниц " + "отображениевремениэлементовпланировщика " + "типфайлаформатированногодокумента " + "обходрезультатазапроса типзаписизапроса " + "видзаполнениярасшифровкипостроителяотчета типдобавленияпредставлений типизмеренияпостроителяотчета типразмещенияитогов " + "доступкфайлу режимдиалогавыборафайла режимоткрытияфайла " + "типизмеренияпостроителязапроса " + "видданныханализа методкластеризации типединицыинтервалавременианализаданных типзаполнениятаблицырезультатаанализаданных типиспользованиячисловыхзначенийанализаданных типисточникаданныхпоискаассоциаций типколонкианализаданныхдереворешений типколонкианализаданныхкластеризация типколонкианализаданныхобщаястатистика типколонкианализаданныхпоискассоциаций типколонкианализаданныхпоискпоследовательностей типколонкимоделипрогноза типмерырасстоянияанализаданных типотсеченияправилассоциации типполяанализаданных типстандартизациианализаданных типупорядочиванияправилассоциациианализаданных типупорядочиванияшаблоновпоследовательностейанализаданных типупрощениядереварешений " + "wsнаправлениепараметра вариантxpathxs вариантзаписидатыjson вариантпростоготипаxs видгруппымоделиxs видфасетаxdto действиепостроителяdom завершенностьпростоготипаxs завершенностьсоставноготипаxs завершенностьсхемыxs запрещенныеподстановкиxs исключениягруппподстановкиxs категорияиспользованияатрибутаxs категорияограниченияидентичностиxs категорияограниченияпространствименxs методнаследованияxs модельсодержимогоxs назначениетипаxml недопустимыеподстановкиxs обработкапробельныхсимволовxs обработкасодержимогоxs ограничениезначенияxs параметрыотбораузловdom переносстрокjson позициявдокументеdom пробельныесимволыxml типатрибутаxml типзначенияjson типканоническогоxml типкомпонентыxs типпроверкиxml типрезультатаdomxpath типузлаdom типузлаxml формаxml формапредставленияxs форматдатыjson экранированиесимволовjson " + "видсравнениякомпоновкиданных действиеобработкирасшифровкикомпоновкиданных направлениесортировкикомпоновкиданных расположениевложенныхэлементоврезультатакомпоновкиданных расположениеитоговкомпоновкиданных расположениегруппировкикомпоновкиданных расположениеполейгруппировкикомпоновкиданных расположениеполякомпоновкиданных расположениереквизитовкомпоновкиданных расположениересурсовкомпоновкиданных типбухгалтерскогоостаткакомпоновкиданных типвыводатекстакомпоновкиданных типгруппировкикомпоновкиданных типгруппыэлементовотборакомпоновкиданных типдополненияпериодакомпоновкиданных типзаголовкаполейкомпоновкиданных типмакетагруппировкикомпоновкиданных типмакетаобластикомпоновкиданных типостаткакомпоновкиданных типпериодакомпоновкиданных типразмещениятекстакомпоновкиданных типсвязинаборовданныхкомпоновкиданных тип��лементарезультатакомпоновкиданных расположениелегендыдиаграммыкомпоновкиданных типпримененияотборакомпоновкиданных режимотображенияэлементанастройкикомпоновкиданных режимотображениянастроеккомпоновкиданных состояниеэлементанастройкикомпоновкиданных способвосстановлениянастроеккомпоновкиданных режимкомпоновкирезультата использованиепараметракомпоновкиданных автопозицияресурсовкомпоновкиданных вариантиспользованиягруппировкикомпоновкиданных расположениересурсоввдиаграммекомпоновкиданных фиксациякомпоновкиданных использованиеусловногооформлениякомпоновкиданных " + "важностьинтернетпочтовогосообщения обработкатекстаинтернетпочтовогосообщения способкодированияинтернетпочтовоговложения способкодированиянеasciiсимволовинтернетпочтовогосообщения типтекстапочтовогосообщения протоколинтернетпочты статусразборапочтовогосообщения " + "режимтранзакциизаписижурналарегистрации статустранзакциизаписижурналарегистрации уровеньжурналарегистрации " + "расположениехранилищасертификатовкриптографии режимвключениясертификатовкриптографии режимпроверкисертификатакриптографии типхранилищасертификатовкриптографии " + "кодировкаименфайловвzipфайле методсжатияzip методшифрованияzip режимвосстановленияпутейфайловzip режимобработкиподкаталоговzip режимсохраненияпутейzip уровеньсжатияzip " + "звуковоеоповещение направлениепереходакстроке позициявпотоке порядокбайтов режимблокировкиданных режимуправленияблокировкойданных сервисвстроенныхпокупок состояниефоновогозадания типподписчикадоставляемыхуведомлений уровеньиспользованиязащищенногосоединенияftp " + "направлениепорядкасхемызапроса типдополненияпериодамисхемызапроса типконтрольнойточкисхемызапроса типобъединениясхемызапроса типпараметрадоступнойтаблицысхемызапроса типсоединениясхемызапроса " + "httpметод автоиспользованиеобщегореквизита автопрефиксномеразадачи вариантвстроенногоязыка видиерархии видрегистранакопления видтаблицывнешнегоисточникаданных записьдвиженийприпроведении заполнениепоследовательностей индексирование использованиебазыпланавидоврасчета использованиебыстроговыбора использованиеобщегореквизита использованиеподчинения использованиеполнотекстовогопоиска использованиеразделяемыхданныхобщегореквизита использованиереквизита назначениеиспользованияприложения назначениерасширенияконфигурации направлениепередачи обновлениепредопределенныхданных оперативноепроведение основноепредставлениевидарасчета основноепредставлениевидахарактеристики основноепредставлениезадачи основноепредставлениепланаобмена основноепредставлениесправочника основноепредставлениесчета перемещениеграницыприпроведении периодичностьномерабизнеспроцесса периодичностьномерадокумента пери��дичностьрегистрарасчета периодичностьрегистрасведений повторноеиспользованиевозвращаемыхзначений полнотекстовыйпоискпривводепостроке принадлежностьобъекта проведение разделениеаутентификацииобщегореквизита разделениеданныхобщегореквизита разделениерасширенийконфигурацииобщегореквизита режимавтонумерацииобъектов режимзаписирегистра режимиспользованиямодальности режимиспользованиясинхронныхвызововрасширенийплатформыивнешнихкомпонент режимповторногоиспользованиясеансов режимполученияданныхвыборапривводепостроке режимсовместимости режимсовместимостиинтерфейса режимуправленияблокировкойданныхпоумолчанию сериикодовпланавидовхарактеристик сериикодовпланасчетов сериикодовсправочника созданиепривводе способвыбора способпоискастрокипривводепостроке способредактирования типданныхтаблицывнешнегоисточникаданных типкодапланавидоврасчета типкодасправочника типмакета типномерабизнеспроцесса типномерадокумента типномеразадачи типформы удалениедвижений " + "важностьпроблемыприменениярасширенияконфигурации вариантинтерфейсаклиентскогоприложения вариантмасштабаформклиентскогоприложения вариантосновногошрифтаклиентскогоприложения вариантстандартногопериода вариантстандартнойдатыначала видграницы видкартинки видотображенияполнотекстовогопоиска видрамки видсравнения видцвета видчисловогозначения видшрифта допустимаядлина допустимыйзнак использованиеbyteordermark использованиеметаданныхполнотекстовогопоиска источникрасширенийконфигурации клавиша кодвозвратадиалога кодировкаxbase кодировкатекста направлениепоиска направлениесортировки обновлениепредопределенныхданных обновлениеприизмененииданных отображениепанелиразделов проверказаполнения режимдиалогавопрос режимзапускаклиентскогоприложения режимокругления режимоткрытияформприложения режимполнотекстовогопоиска скоростьклиентскогосоединения состояниевнешнегоисточникаданных состояниеобновленияконфигурациибазыданных способвыборасертификатаwindows способкодированиястроки статуссообщения типвнешнейкомпоненты типплатформы типповеденияклавишиenter типэлементаинформацииовыполненииобновленияконфигурациибазыданных уровеньизоляциитранзакций хешфункция частидаты", K = "comобъект ftpсоединение httpзапрос httpсервисответ httpсоединение wsопределения wsпрокси xbase анализданных аннотацияxs блокировкаданных буфердвоичныхданных включениеxs выражениекомпоновкиданных генераторслучайныхчисел географическаясхема географическиекоординаты графическаясхема группамоделиxs данныерасшифровкикомпоновкиданных двоичныеданные дендрограмма диаграмма диаграммаганта диалогвыборафайла диалогвыборацвета диалогвыборашрифта диалограсписаниярегламентногозадания диалогредактированиястандартногопериода диапазон докумен��dom документhtml документацияxs доставляемоеуведомление записьdom записьfastinfoset записьhtml записьjson записьxml записьzipфайла записьданных записьтекста записьузловdom запрос защищенноесоединениеopenssl значенияполейрасшифровкикомпоновкиданных извлечениетекста импортxs интернетпочта интернетпочтовоесообщение интернетпочтовыйпрофиль интернетпрокси интернетсоединение информациядляприложенияxs использованиеатрибутаxs использованиесобытияжурналарегистрации источникдоступныхнастроеккомпоновкиданных итераторузловdom картинка квалификаторыдаты квалификаторыдвоичныхданных квалификаторыстроки квалификаторычисла компоновщикмакетакомпоновкиданных компоновщикнастроеккомпоновкиданных конструктормакетаоформлениякомпоновкиданных конструкторнастроеккомпоновкиданных конструкторформатнойстроки линия макеткомпоновкиданных макетобластикомпоновкиданных макетоформлениякомпоновкиданных маскаxs менеджеркриптографии наборсхемxml настройкикомпоновкиданных настройкисериализацииjson обработкакартинок обработкарасшифровкикомпоновкиданных обходдереваdom объявлениеатрибутаxs объявлениенотацииxs объявлениеэлементаxs описаниеиспользованиясобытиядоступжурналарегистрации описаниеиспользованиясобытияотказвдоступежурналарегистрации описаниеобработкирасшифровкикомпоновкиданных описаниепередаваемогофайла описаниетипов определениегруппыатрибутовxs определениегруппымоделиxs определениеограниченияидентичностиxs определениепростоготипаxs определениесоставноготипаxs определениетипадокументаdom определенияxpathxs отборкомпоновкиданных пакетотображаемыхдокументов параметрвыбора параметркомпоновкиданных параметрызаписиjson параметрызаписиxml параметрычтенияxml переопределениеxs планировщик полеанализаданных полекомпоновкиданных построительdom построительзапроса построительотчета построительотчетаанализаданных построительсхемxml поток потоквпамяти почта почтовоесообщение преобразованиеxsl преобразованиекканоническомуxml процессорвыводарезультатакомпоновкиданныхвколлекциюзначений процессорвыводарезультатакомпоновкиданныхвтабличныйдокумент процессоркомпоновкиданных разыменовательпространствименdom рамка расписаниерегламентногозадания расширенноеимяxml результатчтенияданных своднаядиаграмма связьпараметравыбора связьпотипу связьпотипукомпоновкиданных сериализаторxdto сертификатклиентаwindows сертификатклиентафайл сертификаткриптографии сертификатыудостоверяющихцентровwindows сертификатыудостоверяющихцентровфайл сжатиеданных системнаяинформация сообщениепользователю сочетаниеклавиш сравнениезначений стандартнаядатаначала стандартныйпериод схемаxml схемакомпоновкиданных табличныйдокумент текстовыйдокумент тестируемоеприложение типданныхxml уникальныйидентификатор фабрикаxdto файл файловыйпоток фа��етдлиныxs фасетколичестваразрядовдробнойчастиxs фасетмаксимальноговключающегозначенияxs фасетмаксимальногоисключающегозначенияxs фасетмаксимальнойдлиныxs фасетминимальноговключающегозначенияxs фасетминимальногоисключающегозначенияxs фасетминимальнойдлиныxs фасетобразцаxs фасетобщегоколичестваразрядовxs фасетперечисленияxs фасетпробельныхсимволовxs фильтрузловdom форматированнаястрока форматированныйдокумент фрагментxs хешированиеданных хранилищезначения цвет чтениеfastinfoset чтениеhtml чтениеjson чтениеxml чтениеzipфайла чтениеданных чтениетекста чтениеузловdom шрифт элементрезультатакомпоновкиданных " + "comsafearray деревозначений массив соответствие списокзначений структура таблицазначений фиксированнаяструктура фиксированноесоответствие фиксированныймассив ", Se = "null истина ложь неопределено", v = e.inherit(e.NUMBER_MODE), ee = { + className: "string", + begin: '"|\\|', + end: '"|$', + contains: [{ begin: '""' }] + }, Z = { + begin: "'", + end: "'", + excludeBegin: !0, + excludeEnd: !0, + contains: [ + { + className: "number", + begin: "\\d{4}([\\.\\\\/:-]?\\d{2}){0,5}" + } + ] + }, $ = { + match: /[;()+\-:=,]/, + className: "punctuation", + relevance: 0 + }, ae = e.inherit(e.C_LINE_COMMENT_MODE), ie = { + className: "meta", + begin: "#|&", + end: "$", + keywords: { + $pattern: t, + keyword: i + l + }, + contains: [ae] + }, se = { + className: "symbol", + begin: "~", + end: ";|:", + excludeEnd: !0 + }, pe = { + className: "function", + variants: [ + { + begin: "процедура|функция", + end: "\\)", + keywords: "процедура функция" + }, + { + begin: "конецпроцедуры|конецфункции", + keywords: "конецпроцедуры конецфункции" + } + ], + contains: [ + { + begin: "\\(", + end: "\\)", + endsParent: !0, + contains: [ + { + className: "params", + begin: t, + end: ",", + excludeEnd: !0, + endsWithParent: !0, + keywords: { + $pattern: t, + keyword: "знач", + literal: Se + }, + contains: [ + v, + ee, + Z + ] + }, + ae + ] + }, + e.inherit(e.TITLE_MODE, { begin: t }) + ] + }; + return { + name: "1C:Enterprise", + case_insensitive: !0, + keywords: { + $pattern: t, + keyword: i, + built_in: u, + class: V, + type: K, + literal: Se + }, + contains: [ + ie, + pe, + ae, + se, + v, + ee, + Z, + $ + ] + }; + } + return pa = a, pa; +} +var ma, el; +function Qg() { + if (el) return ma; + el = 1; + function a(e) { + const t = e.regex, n = /^[a-zA-Z][a-zA-Z0-9-]*/, r = [ + "ALPHA", + "BIT", + "CHAR", + "CR", + "CRLF", + "CTL", + "DIGIT", + "DQUOTE", + "HEXDIG", + "HTAB", + "LF", + "LWSP", + "OCTET", + "SP", + "VCHAR", + "WSP" + ], i = e.COMMENT(/;/, /$/), o = { + scope: "symbol", + match: /%b[0-1]+(-[0-1]+|(\.[0-1]+)+)?/ + }, s = { + scope: "symbol", + match: /%d[0-9]+(-[0-9]+|(\.[0-9]+)+)?/ + }, l = { + scope: "symbol", + match: /%x[0-9A-F]+(-[0-9A-F]+|(\.[0-9A-F]+)+)?/ + }, c = { + scope: "symbol", + match: /%[si](?=".*")/ + }, _ = { + scope: "attribute", + match: t.concat(n, /(?=\s*=)/) + }; + return { + name: "Augmented Backus-Naur Form", + illegal: /[!@#$^&',?+~`|:]/, + keywords: r, + contains: [ + { + scope: "operator", + match: /=\/?/ + }, + _, + i, + o, + s, + l, + c, + e.QUOTE_STRING_MODE, + e.NUMBER_MODE + ] + }; + } + return ma = a, ma; +} +var Ea, tl; +function $g() { + if (tl) return Ea; + tl = 1; + function a(e) { + const t = e.regex, n = [ + "GET", + "POST", + "HEAD", + "PUT", + "DELETE", + "CONNECT", + "OPTIONS", + "PATCH", + "TRACE" + ]; + return { + name: "Apache Access Log", + contains: [ + // IP + { + className: "number", + begin: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?\b/, + relevance: 5 + }, + // Other numbers + { + className: "number", + begin: /\b\d+\b/, + relevance: 0 + }, + // Requests + { + className: "string", + begin: t.concat(/"/, t.either(...n)), + end: /"/, + keywords: n, + illegal: /\n/, + relevance: 5, + contains: [ + { + begin: /HTTP\/[12]\.\d'/, + relevance: 5 + } + ] + }, + // Dates + { + className: "string", + // dates must have a certain length, this prevents matching + // simple array accesses a[123] and [] and other common patterns + // found in other languages + begin: /\[\d[^\]\n]{8,}\]/, + illegal: /\n/, + relevance: 1 + }, + { + className: "string", + begin: /\[/, + end: /\]/, + illegal: /\n/, + relevance: 0 + }, + // User agent / relevance boost + { + className: "string", + begin: /"Mozilla\/\d\.\d \(/, + end: /"/, + illegal: /\n/, + relevance: 3 + }, + // Strings + { + className: "string", + begin: /"/, + end: /"/, + illegal: /\n/, + relevance: 0 + } + ] + }; + } + return Ea = a, Ea; +} +var ga, nl; +function Xg() { + if (nl) return ga; + nl = 1; + function a(e) { + const t = e.regex, n = /[a-zA-Z_$][a-zA-Z0-9_$]*/, r = t.concat( + n, + t.concat("(\\.", n, ")*") + ), i = /([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/, o = { + className: "rest_arg", + begin: /[.]{3}/, + end: n, + relevance: 10 + }; + return { + name: "ActionScript", + aliases: ["as"], + keywords: { + keyword: [ + "as", + "break", + "case", + "catch", + "class", + "const", + "continue", + "default", + "delete", + "do", + "dynamic", + "each", + "else", + "extends", + "final", + "finally", + "for", + "function", + "get", + "if", + "implements", + "import", + "in", + "include", + "instanceof", + "interface", + "internal", + "is", + "namespace", + "native", + "new", + "override", + "package", + "private", + "protected", + "public", + "return", + "set", + "static", + "super", + "switch", + "this", + "throw", + "try", + "typeof", + "use", + "var", + "void", + "while", + "with" + ], + literal: [ + "true", + "false", + "null", + "undefined" + ] + }, + contains: [ + e.APOS_STRING_MODE, + e.QUOTE_STRING_MODE, + e.C_LINE_COMMENT_MODE, + e.C_BLOCK_COMMENT_MODE, + e.C_NUMBER_MODE, + { + match: [ + /\bpackage/, + /\s+/, + r + ], + className: { + 1: "keyword", + 3: "title.class" + } + }, + { + match: [ + /\b(?:class|interface|extends|implements)/, + /\s+/, + n + ], + className: { + 1: "keyword", + 3: "title.class" + } + }, + { + className: "meta", + beginKeywords: "import include", + end: /;/, + keywords: { keyword: "import include" } + }, + { + beginKeywords: "function", + end: /[{;]/, + excludeEnd: !0, + illegal: /\S/, + contains: [ + e.inherit(e.TITLE_MODE, { className: "title.function" }), + { + className: "params", + begin: /\(/, + end: /\)/, + contains: [ + e.APOS_STRING_MODE, + e.QUOTE_STRING_MODE, + e.C_LINE_COMMENT_MODE, + e.C_BLOCK_COMMENT_MODE, + o + ] + }, + { begin: t.concat(/:\s*/, i) } + ] + }, + e.METHOD_GUARD + ], + illegal: /#/ + }; + } + return ga = a, ga; +} +var Sa, al; +function Zg() { + if (al) return Sa; + al = 1; + function a(e) { + const t = "\\d(_|\\d)*", n = "[eE][-+]?" + t, r = t + "(\\." + t + ")?(" + n + ")?", i = "\\w+", s = "\\b(" + (t + "#" + i + "(\\." + i + ")?#(" + n + ")?") + "|" + r + ")", l = "[A-Za-z](_?[A-Za-z0-9.])*", c = `[]\\{\\}%#'"`, _ = e.COMMENT("--", "$"), d = { + // TODO: These spaces are not required by the Ada syntax + // however, I have yet to see handwritten Ada code where + // someone does not put spaces around : + begin: "\\s+:\\s+", + end: "\\s*(:=|;|\\)|=>|$)", + // endsWithParent: true, + // returnBegin: true, + illegal: c, + contains: [ + { + // workaround to avoid highlighting + // named loops and declare blocks + beginKeywords: "loop for declare others", + endsParent: !0 + }, + { + // properly highlight all modifiers + className: "keyword", + beginKeywords: "not null constant access function procedure in out aliased exception" + }, + { + className: "type", + begin: l, + endsParent: !0, + relevance: 0 + } + ] + }; + return { + name: "Ada", + case_insensitive: !0, + keywords: { + keyword: [ + "abort", + "else", + "new", + "return", + "abs", + "elsif", + "not", + "reverse", + "abstract", + "end", + "accept", + "entry", + "select", + "access", + "exception", + "of", + "separate", + "aliased", + "exit", + "or", + "some", + "all", + "others", + "subtype", + "and", + "for", + "out", + "synchronized", + "array", + "function", + "overriding", + "at", + "tagged", + "generic", + "package", + "task", + "begin", + "goto", + "pragma", + "terminate", + "body", + "private", + "then", + "if", + "procedure", + "type", + "case", + "in", + "protected", + "constant", + "interface", + "is", + "raise", + "use", + "declare", + "range", + "delay", + "limited", + "record", + "when", + "delta", + "loop", + "rem", + "while", + "digits", + "renames", + "with", + "do", + "mod", + "requeue", + "xor" + ], + literal: [ + "True", + "False" + ] + }, + contains: [ + _, + // strings "foobar" + { + className: "string", + begin: /"/, + end: /"/, + contains: [ + { + begin: /""/, + relevance: 0 + } + ] + }, + // characters '' + { + // character literals always contain one char + className: "string", + begin: /'.'/ + }, + { + // number literals + className: "number", + begin: s, + relevance: 0 + }, + { + // Attributes + className: "symbol", + begin: "'" + l + }, + { + // package definition, maybe inside generic + className: "title", + begin: "(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?", + end: "(is|$)", + keywords: "package body", + excludeBegin: !0, + excludeEnd: !0, + illegal: c + }, + { + // function/procedure declaration/definition + // maybe inside generic + begin: "(\\b(with|overriding)\\s+)?\\b(function|procedure)\\s+", + end: "(\\bis|\\bwith|\\brenames|\\)\\s*;)", + keywords: "overriding function procedure with is renames return", + // we need to re-match the 'function' keyword, so that + // the title mode below matches only exactly once + returnBegin: !0, + contains: [ + _, + { + // name of the function/procedure + className: "title", + begin: "(\\bwith\\s+)?\\b(function|procedure)\\s+", + end: "(\\(|\\s+|$)", + excludeBegin: !0, + excludeEnd: !0, + illegal: c + }, + // 'self' + // // parameter types + d, + { + // return type + className: "type", + begin: "\\breturn\\s+", + end: "(\\s+|;|$)", + keywords: "return", + excludeBegin: !0, + excludeEnd: !0, + // we are done with functions + endsParent: !0, + illegal: c + } + ] + }, + { + // new type declarations + // maybe inside generic + className: "type", + begin: "\\b(sub)?type\\s+", + end: "\\s+", + keywords: "type", + excludeBegin: !0, + illegal: c + }, + // see comment above the definition + d + // no markup + // relevance boosters for small snippets + // {begin: '\\s*=>\\s*'}, + // {begin: '\\s*:=\\s*'}, + // {begin: '\\s+:=\\s+'}, + ] + }; + } + return Sa = a, Sa; +} +var Ta, rl; +function Jg() { + if (rl) return Ta; + rl = 1; + function a(e) { + const t = { + className: "built_in", + begin: "\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)" + }, n = { + className: "symbol", + begin: "[a-zA-Z0-9_]+@" + }, r = { + className: "keyword", + begin: "<", + end: ">", + contains: [ + t, + n + ] + }; + return t.contains = [r], n.contains = [r], { + name: "AngelScript", + aliases: ["asc"], + keywords: [ + "for", + "in|0", + "break", + "continue", + "while", + "do|0", + "return", + "if", + "else", + "case", + "switch", + "namespace", + "is", + "cast", + "or", + "and", + "xor", + "not", + "get|0", + "in", + "inout|10", + "out", + "override", + "set|0", + "private", + "public", + "const", + "default|0", + "final", + "shared", + "external", + "mixin|10", + "enum", + "typedef", + "funcdef", + "this", + "super", + "import", + "from", + "interface", + "abstract|0", + "try", + "catch", + "protected", + "explicit", + "property" + ], + // avoid close detection with C# and JS + illegal: "(^using\\s+[A-Za-z0-9_\\.]+;$|\\bfunction\\s*[^\\(])", + contains: [ + { + // 'strings' + className: "string", + begin: "'", + end: "'", + illegal: "\\n", + contains: [e.BACKSLASH_ESCAPE], + relevance: 0 + }, + // """heredoc strings""" + { + className: "string", + begin: '"""', + end: '"""' + }, + { + // "strings" + className: "string", + begin: '"', + end: '"', + illegal: "\\n", + contains: [e.BACKSLASH_ESCAPE], + relevance: 0 + }, + e.C_LINE_COMMENT_MODE, + // single-line comments + e.C_BLOCK_COMMENT_MODE, + // comment blocks + { + // metadata + className: "string", + begin: "^\\s*\\[", + end: "\\]" + }, + { + // interface or namespace declaration + beginKeywords: "interface namespace", + end: /\{/, + illegal: "[;.\\-]", + contains: [ + { + // interface or namespace name + className: "symbol", + begin: "[a-zA-Z0-9_]+" + } + ] + }, + { + // class declaration + beginKeywords: "class", + end: /\{/, + illegal: "[;.\\-]", + contains: [ + { + // class name + className: "symbol", + begin: "[a-zA-Z0-9_]+", + contains: [ + { + begin: "[:,]\\s*", + contains: [ + { + className: "symbol", + begin: "[a-zA-Z0-9_]+" + } + ] + } + ] + } + ] + }, + t, + // built-in types + n, + // object handles + { + // literals + className: "literal", + begin: "\\b(null|true|false)" + }, + { + // numbers + className: "number", + relevance: 0, + begin: "(-?)(\\b0[xXbBoOdD][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?f?|\\.\\d+f?)([eE][-+]?\\d+f?)?)" + } + ] + }; + } + return Ta = a, Ta; +} +var fa, il; +function jg() { + if (il) return fa; + il = 1; + function a(e) { + const t = { + className: "number", + begin: /[$%]\d+/ + }, n = { + className: "number", + begin: /\b\d+/ + }, r = { + className: "number", + begin: /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?/ + }, i = { + className: "number", + begin: /:\d{1,5}/ + }; + return { + name: "Apache config", + aliases: ["apacheconf"], + case_insensitive: !0, + contains: [ + e.HASH_COMMENT_MODE, + { + className: "section", + begin: /<\/?/, + end: />/, + contains: [ + r, + i, + // low relevance prevents us from claming XML/HTML where this rule would + // match strings inside of XML tags + e.inherit(e.QUOTE_STRING_MODE, { relevance: 0 }) + ] + }, + { + className: "attribute", + begin: /\w+/, + relevance: 0, + // keywords aren’t needed for highlighting per se, they only boost relevance + // for a very generally defined mode (starts with a word, ends with line-end + keywords: { _: [ + "order", + "deny", + "allow", + "setenv", + "rewriterule", + "rewriteengine", + "rewritecond", + "documentroot", + "sethandler", + "errordocument", + "loadmodule", + "options", + "header", + "listen", + "serverroot", + "servername" + ] }, + starts: { + end: /$/, + relevance: 0, + keywords: { literal: "on off all deny allow" }, + contains: [ + { + className: "meta", + begin: /\s\[/, + end: /\]$/ + }, + { + className: "variable", + begin: /[\$%]\{/, + end: /\}/, + contains: [ + "self", + t + ] + }, + r, + n, + e.QUOTE_STRING_MODE + ] + } + } + ], + illegal: /\S/ + }; + } + return fa = a, fa; +} +var ba, ol; +function eS() { + if (ol) return ba; + ol = 1; + function a(e) { + const t = e.regex, n = e.inherit( + e.QUOTE_STRING_MODE, + { illegal: null } + ), r = { + className: "params", + begin: /\(/, + end: /\)/, + contains: [ + "self", + e.C_NUMBER_MODE, + n + ] + }, i = e.COMMENT(/--/, /$/), o = e.COMMENT( + /\(\*/, + /\*\)/, + { contains: [ + "self", + // allow nesting + i + ] } + ), s = [ + i, + o, + e.HASH_COMMENT_MODE + ], l = [ + /apart from/, + /aside from/, + /instead of/, + /out of/, + /greater than/, + /isn't|(doesn't|does not) (equal|come before|come after|contain)/, + /(greater|less) than( or equal)?/, + /(starts?|ends|begins?) with/, + /contained by/, + /comes (before|after)/, + /a (ref|reference)/, + /POSIX (file|path)/, + /(date|time) string/, + /quoted form/ + ], c = [ + /clipboard info/, + /the clipboard/, + /info for/, + /list (disks|folder)/, + /mount volume/, + /path to/, + /(close|open for) access/, + /(get|set) eof/, + /current date/, + /do shell script/, + /get volume settings/, + /random number/, + /set volume/, + /system attribute/, + /system info/, + /time to GMT/, + /(load|run|store) script/, + /scripting components/, + /ASCII (character|number)/, + /localized string/, + /choose (application|color|file|file name|folder|from list|remote application|URL)/, + /display (alert|dialog)/ + ]; + return { + name: "AppleScript", + aliases: ["osascript"], + keywords: { + keyword: "about above after against and around as at back before beginning behind below beneath beside between but by considering contain contains continue copy div does eighth else end equal equals error every exit fifth first for fourth from front get given global if ignoring in into is it its last local me middle mod my ninth not of on onto or over prop property put ref reference repeat returning script second set seventh since sixth some tell tenth that the|0 then third through thru timeout times to transaction try until where while whose with without", + literal: "AppleScript false linefeed return pi quote result space tab true", + built_in: "alias application boolean class constant date file integer list number real record string text activate beep count delay launch log offset read round run say summarize write character characters contents day frontmost id item length month name|0 paragraph paragraphs rest reverse running time version weekday word words year" + }, + contains: [ + n, + e.C_NUMBER_MODE, + { + className: "built_in", + begin: t.concat( + /\b/, + t.either(...c), + /\b/ + ) + }, + { + className: "built_in", + begin: /^\s*return\b/ + }, + { + className: "literal", + begin: /\b(text item delimiters|current application|missing value)\b/ + }, + { + className: "keyword", + begin: t.concat( + /\b/, + t.either(...l), + /\b/ + ) + }, + { + beginKeywords: "on", + illegal: /[${=;\n]/, + contains: [ + e.UNDERSCORE_TITLE_MODE, + r + ] + }, + ...s + ], + illegal: /\/\/|->|=>|\[\[/ + }; + } + return ba = a, ba; +} +var Ra, sl; +function tS() { + if (sl) return Ra; + sl = 1; + function a(e) { + const t = e.regex, n = "[A-Za-z_][0-9A-Za-z_]*", r = { + keyword: [ + "break", + "case", + "catch", + "continue", + "debugger", + "do", + "else", + "export", + "for", + "function", + "if", + "import", + "in", + "new", + "return", + "switch", + "try", + "var", + "void", + "while" + ], + literal: [ + "BackSlash", + "DoubleQuote", + "ForwardSlash", + "Infinity", + "NaN", + "NewLine", + "PI", + "SingleQuote", + "Tab", + "TextFormatting", + "false", + "null", + "true", + "undefined" + ], + built_in: [ + "Abs", + "Acos", + "All", + "Angle", + "Any", + "Area", + "AreaGeodetic", + "Array", + "Asin", + "Atan", + "Atan2", + "Attachments", + "Average", + "Back", + "Bearing", + "Boolean", + "Buffer", + "BufferGeodetic", + "Ceil", + "Centroid", + "ChangeTimeZone", + "Clip", + "Concatenate", + "Console", + "Constrain", + "Contains", + "ConvertDirection", + "ConvexHull", + "Cos", + "Count", + "Crosses", + "Cut", + "Date|0", + "DateAdd", + "DateDiff", + "DateOnly", + "Day", + "Decode", + "DefaultValue", + "Densify", + "DensifyGeodetic", + "Dictionary", + "Difference", + "Disjoint", + "Distance", + "DistanceGeodetic", + "Distinct", + "Domain", + "DomainCode", + "DomainName", + "EnvelopeIntersects", + "Equals", + "Erase", + "Exp", + "Expects", + "Extent", + "Feature", + "FeatureSet", + "FeatureSetByAssociation", + "FeatureSetById", + "FeatureSetByName", + "FeatureSetByPortalItem", + "FeatureSetByRelationshipClass", + "FeatureSetByRelationshipName", + "Filter", + "Find", + "First|0", + "Floor", + "FromCharCode", + "FromCodePoint", + "FromJSON", + "Front", + "GdbVersion", + "Generalize", + "Geometry", + "GetEnvironment", + "GetFeatureSet", + "GetFeatureSetInfo", + "GetUser", + "GroupBy", + "Guid", + "HasKey", + "HasValue", + "Hash", + "Hour", + "IIf", + "ISOMonth", + "ISOWeek", + "ISOWeekday", + "ISOYear", + "Includes", + "IndexOf", + "Insert", + "Intersection", + "Intersects", + "IsEmpty", + "IsNan", + "IsSelfIntersecting", + "IsSimple", + "Left|0", + "Length", + "Length3D", + "LengthGeodetic", + "Log", + "Lower", + "Map", + "Max", + "Mean", + "Mid", + "Millisecond", + "Min", + "Minute", + "Month", + "MultiPartToSinglePart", + "Multipoint", + "NearestCoordinate", + "NearestVertex", + "NextSequenceValue", + "None", + "Now", + "Number", + "Offset", + "OrderBy", + "Overlaps", + "Point", + "Polygon", + "Polyline", + "Pop", + "Portal", + "Pow", + "Proper", + "Push", + "Random", + "Reduce", + "Relate", + "Replace", + "Resize", + "Reverse", + "Right|0", + "RingIsClockwise", + "Rotate", + "Round", + "Schema", + "Second", + "SetGeometry", + "Simplify", + "Sin", + "Slice", + "Sort", + "Splice", + "Split", + "Sqrt", + "StandardizeGuid", + "Stdev", + "SubtypeCode", + "SubtypeName", + "Subtypes", + "Sum", + "SymmetricDifference", + "Tan", + "Text", + "Time", + "TimeZone", + "TimeZoneOffset", + "Timestamp", + "ToCharCode", + "ToCodePoint", + "ToHex", + "ToLocal", + "ToUTC", + "Today", + "Top|0", + "Touches", + "TrackAccelerationAt", + "TrackAccelerationWindow", + "TrackCurrentAcceleration", + "TrackCurrentDistance", + "TrackCurrentSpeed", + "TrackCurrentTime", + "TrackDistanceAt", + "TrackDistanceWindow", + "TrackDuration", + "TrackFieldWindow", + "TrackGeometryWindow", + "TrackIndex", + "TrackSpeedAt", + "TrackSpeedWindow", + "TrackStartTime", + "TrackWindow", + "Trim", + "TypeOf", + "Union", + "Upper", + "UrlEncode", + "Variance", + "Week", + "Weekday", + "When|0", + "Within", + "Year|0" + ] + }, i = [ + "aggregatedFeatures", + "analytic", + "config", + "datapoint", + "datastore", + "editcontext", + "feature", + "featureSet", + "feedfeature", + "fencefeature", + "fencenotificationtype", + "join", + "layer", + "locationupdate", + "map", + "measure", + "measure", + "originalFeature", + "record", + "reference", + "rowindex", + "sourcedatastore", + "sourcefeature", + "sourcelayer", + "target", + "targetdatastore", + "targetfeature", + "targetlayer", + "value", + "view" + ], o = { + className: "symbol", + begin: "\\$" + t.either(...i) + }, s = { + className: "number", + variants: [ + { begin: "\\b(0[bB][01]+)" }, + { begin: "\\b(0[oO][0-7]+)" }, + { begin: e.C_NUMBER_RE } + ], + relevance: 0 + }, l = { + className: "subst", + begin: "\\$\\{", + end: "\\}", + keywords: r, + contains: [] + // defined later + }, c = { + className: "string", + begin: "`", + end: "`", + contains: [ + e.BACKSLASH_ESCAPE, + l + ] + }; + l.contains = [ + e.APOS_STRING_MODE, + e.QUOTE_STRING_MODE, + c, + s, + e.REGEXP_MODE + ]; + const _ = l.contains.concat([ + e.C_BLOCK_COMMENT_MODE, + e.C_LINE_COMMENT_MODE + ]); + return { + name: "ArcGIS Arcade", + case_insensitive: !0, + keywords: r, + contains: [ + e.APOS_STRING_MODE, + e.QUOTE_STRING_MODE, + c, + e.C_LINE_COMMENT_MODE, + e.C_BLOCK_COMMENT_MODE, + o, + s, + { + // object attr container + begin: /[{,]\s*/, + relevance: 0, + contains: [ + { + begin: n + "\\s*:", + returnBegin: !0, + relevance: 0, + contains: [ + { + className: "attr", + begin: n, + relevance: 0 + } + ] + } + ] + }, + { + // "value" container + begin: "(" + e.RE_STARTERS_RE + "|\\b(return)\\b)\\s*", + keywords: "return", + contains: [ + e.C_LINE_COMMENT_MODE, + e.C_BLOCK_COMMENT_MODE, + e.REGEXP_MODE, + { + className: "function", + begin: "(\\(.*?\\)|" + n + ")\\s*=>", + returnBegin: !0, + end: "\\s*=>", + contains: [ + { + className: "params", + variants: [ + { begin: n }, + { begin: /\(\s*\)/ }, + { + begin: /\(/, + end: /\)/, + excludeBegin: !0, + excludeEnd: !0, + keywords: r, + contains: _ + } + ] + } + ] + } + ], + relevance: 0 + }, + { + beginKeywords: "function", + end: /\{/, + excludeEnd: !0, + contains: [ + e.inherit(e.TITLE_MODE, { + className: "title.function", + begin: n + }), + { + className: "params", + begin: /\(/, + end: /\)/, + excludeBegin: !0, + excludeEnd: !0, + contains: _ + } + ], + illegal: /\[|%/ + }, + { begin: /\$[(.]/ } + ], + illegal: /#(?!!)/ + }; + } + return Ra = a, Ra; +} +var Ca, ll; +function nS() { + if (ll) return Ca; + ll = 1; + function a(t) { + const n = t.regex, r = t.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), i = "decltype\\(auto\\)", o = "[a-zA-Z_]\\w*::", l = "(?!struct)(" + i + "|" + n.optional(o) + "[a-zA-Z_]\\w*" + n.optional("<[^<>]+>") + ")", c = { + className: "type", + begin: "\\b[a-z\\d_]*_t\\b" + }, d = { + className: "string", + variants: [ + { + begin: '(u8?|U|L)?"', + end: '"', + illegal: "\\n", + contains: [t.BACKSLASH_ESCAPE] + }, + { + begin: "(u8?|U|L)?'(" + "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)" + "|.)", + end: "'", + illegal: "." + }, + t.END_SAME_AS_BEGIN({ + begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/, + end: /\)([^()\\ ]{0,16})"/ + }) + ] + }, p = { + className: "number", + variants: [ + // Floating-point literal. + { + begin: "[+-]?(?:(?:[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|0[Xx](?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)[Pp][+-]?[0-9](?:'?[0-9])*)(?:[Ff](?:16|32|64|128)?|(BF|bf)16|[Ll]|)" + }, + // Integer literal. + { + begin: "[+-]?\\b(?:0[Bb][01](?:'?[01])*|0[Xx][0-9A-Fa-f](?:'?[0-9A-Fa-f])*|0(?:'?[0-7])*|[1-9](?:'?[0-9])*)(?:[Uu](?:LL?|ll?)|[Uu][Zz]?|(?:LL?|ll?)[Uu]?|[Zz][Uu]|)" + // Note: there are user-defined literal suffixes too, but perhaps having the custom suffix not part of the + // literal highlight actually makes it stand out more. + } + ], + relevance: 0 + }, u = { + className: "meta", + begin: /#\s*[a-z]+\b/, + end: /$/, + keywords: { keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include" }, + contains: [ + { + begin: /\\\n/, + relevance: 0 + }, + t.inherit(d, { className: "string" }), + { + className: "string", + begin: /<.*?>/ + }, + r, + t.C_BLOCK_COMMENT_MODE + ] + }, m = { + className: "title", + begin: n.optional(o) + t.IDENT_RE, + relevance: 0 + }, S = n.optional(o) + t.IDENT_RE + "\\s*\\(", E = [ + "alignas", + "alignof", + "and", + "and_eq", + "asm", + "atomic_cancel", + "atomic_commit", + "atomic_noexcept", + "auto", + "bitand", + "bitor", + "break", + "case", + "catch", + "class", + "co_await", + "co_return", + "co_yield", + "compl", + "concept", + "const_cast|10", + "consteval", + "constexpr", + "constinit", + "continue", + "decltype", + "default", + "delete", + "do", + "dynamic_cast|10", + "else", + "enum", + "explicit", + "export", + "extern", + "false", + "final", + "for", + "friend", + "goto", + "if", + "import", + "inline", + "module", + "mutable", + "namespace", + "new", + "noexcept", + "not", + "not_eq", + "nullptr", + "operator", + "or", + "or_eq", + "override", + "private", + "protected", + "public", + "reflexpr", + "register", + "reinterpret_cast|10", + "requires", + "return", + "sizeof", + "static_assert", + "static_cast|10", + "struct", + "switch", + "synchronized", + "template", + "this", + "thread_local", + "throw", + "transaction_safe", + "transaction_safe_dynamic", + "true", + "try", + "typedef", + "typeid", + "typename", + "union", + "using", + "virtual", + "volatile", + "while", + "xor", + "xor_eq" + ], f = [ + "bool", + "char", + "char16_t", + "char32_t", + "char8_t", + "double", + "float", + "int", + "long", + "short", + "void", + "wchar_t", + "unsigned", + "signed", + "const", + "static" + ], g = [ + "any", + "auto_ptr", + "barrier", + "binary_semaphore", + "bitset", + "complex", + "condition_variable", + "condition_variable_any", + "counting_semaphore", + "deque", + "false_type", + "future", + "imaginary", + "initializer_list", + "istringstream", + "jthread", + "latch", + "lock_guard", + "multimap", + "multiset", + "mutex", + "optional", + "ostringstream", + "packaged_task", + "pair", + "promise", + "priority_queue", + "queue", + "recursive_mutex", + "recursive_timed_mutex", + "scoped_lock", + "set", + "shared_future", + "shared_lock", + "shared_mutex", + "shared_timed_mutex", + "shared_ptr", + "stack", + "string_view", + "stringstream", + "timed_mutex", + "thread", + "true_type", + "tuple", + "unique_lock", + "unique_ptr", + "unordered_map", + "unordered_multimap", + "unordered_multiset", + "unordered_set", + "variant", + "vector", + "weak_ptr", + "wstring", + "wstring_view" + ], R = [ + "abort", + "abs", + "acos", + "apply", + "as_const", + "asin", + "atan", + "atan2", + "calloc", + "ceil", + "cerr", + "cin", + "clog", + "cos", + "cosh", + "cout", + "declval", + "endl", + "exchange", + "exit", + "exp", + "fabs", + "floor", + "fmod", + "forward", + "fprintf", + "fputs", + "free", + "frexp", + "fscanf", + "future", + "invoke", + "isalnum", + "isalpha", + "iscntrl", + "isdigit", + "isgraph", + "islower", + "isprint", + "ispunct", + "isspace", + "isupper", + "isxdigit", + "labs", + "launder", + "ldexp", + "log", + "log10", + "make_pair", + "make_shared", + "make_shared_for_overwrite", + "make_tuple", + "make_unique", + "malloc", + "memchr", + "memcmp", + "memcpy", + "memset", + "modf", + "move", + "pow", + "printf", + "putchar", + "puts", + "realloc", + "scanf", + "sin", + "sinh", + "snprintf", + "sprintf", + "sqrt", + "sscanf", + "std", + "stderr", + "stdin", + "stdout", + "strcat", + "strchr", + "strcmp", + "strcpy", + "strcspn", + "strlen", + "strncat", + "strncmp", + "strncpy", + "strpbrk", + "strrchr", + "strspn", + "strstr", + "swap", + "tan", + "tanh", + "terminate", + "to_underlying", + "tolower", + "toupper", + "vfprintf", + "visit", + "vprintf", + "vsprintf" + ], N = { + type: f, + keyword: E, + literal: [ + "NULL", + "false", + "nullopt", + "nullptr", + "true" + ], + built_in: ["_Pragma"], + _type_hints: g + }, O = { + className: "function.dispatch", + relevance: 0, + keywords: { + // Only for relevance, not highlighting. + _hint: R + }, + begin: n.concat( + /\b/, + /(?!decltype)/, + /(?!if)/, + /(?!for)/, + /(?!switch)/, + /(?!while)/, + t.IDENT_RE, + n.lookahead(/(<[^<>]+>|)\s*\(/) + ) + }, A = [ + O, + u, + c, + r, + t.C_BLOCK_COMMENT_MODE, + p, + d + ], D = { + // This mode covers expression context where we can't expect a function + // definition and shouldn't highlight anything that looks like one: + // `return some()`, `else if()`, `(x*sum(1, 2))` + variants: [ + { + begin: /=/, + end: /;/ + }, + { + begin: /\(/, + end: /\)/ + }, + { + beginKeywords: "new throw return else", + end: /;/ + } + ], + keywords: N, + contains: A.concat([ + { + begin: /\(/, + end: /\)/, + keywords: N, + contains: A.concat(["self"]), + relevance: 0 + } + ]), + relevance: 0 + }, P = { + className: "function", + begin: "(" + l + "[\\*&\\s]+)+" + S, + returnBegin: !0, + end: /[{;=]/, + excludeEnd: !0, + keywords: N, + illegal: /[^\w\s\*&:<>.]/, + contains: [ + { + // to prevent it from being confused as the function title + begin: i, + keywords: N, + relevance: 0 + }, + { + begin: S, + returnBegin: !0, + contains: [m], + relevance: 0 + }, + // needed because we do not have look-behind on the below rule + // to prevent it from grabbing the final : in a :: pair + { + begin: /::/, + relevance: 0 + }, + // initializers + { + begin: /:/, + endsWithParent: !0, + contains: [ + d, + p + ] + }, + // allow for multiple declarations, e.g.: + // extern void f(int), g(char); + { + relevance: 0, + match: /,/ + }, + { + className: "params", + begin: /\(/, + end: /\)/, + keywords: N, + relevance: 0, + contains: [ + r, + t.C_BLOCK_COMMENT_MODE, + d, + p, + c, + // Count matching parentheses. + { + begin: /\(/, + end: /\)/, + keywords: N, + relevance: 0, + contains: [ + "self", + r, + t.C_BLOCK_COMMENT_MODE, + d, + p, + c + ] + } + ] + }, + c, + r, + t.C_BLOCK_COMMENT_MODE, + u + ] + }; + return { + name: "C++", + aliases: [ + "cc", + "c++", + "h++", + "hpp", + "hh", + "hxx", + "cxx" + ], + keywords: N, + illegal: " rooms (9);` + begin: "\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)", + end: ">", + keywords: N, + contains: [ + "self", + c + ] + }, + { + begin: t.IDENT_RE + "::", + keywords: N + }, + { + match: [ + // extra complexity to deal with `enum class` and `enum struct` + /\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/, + /\s+/, + /\w+/ + ], + className: { + 1: "keyword", + 3: "title.class" + } + } + ] + ) + }; + } + function e(t) { + const n = { + type: [ + "boolean", + "byte", + "word", + "String" + ], + built_in: [ + "KeyboardController", + "MouseController", + "SoftwareSerial", + "EthernetServer", + "EthernetClient", + "LiquidCrystal", + "RobotControl", + "GSMVoiceCall", + "EthernetUDP", + "EsploraTFT", + "HttpClient", + "RobotMotor", + "WiFiClient", + "GSMScanner", + "FileSystem", + "Scheduler", + "GSMServer", + "YunClient", + "YunServer", + "IPAddress", + "GSMClient", + "GSMModem", + "Keyboard", + "Ethernet", + "Console", + "GSMBand", + "Esplora", + "Stepper", + "Process", + "WiFiUDP", + "GSM_SMS", + "Mailbox", + "USBHost", + "Firmata", + "PImage", + "Client", + "Server", + "GSMPIN", + "FileIO", + "Bridge", + "Serial", + "EEPROM", + "Stream", + "Mouse", + "Audio", + "Servo", + "File", + "Task", + "GPRS", + "WiFi", + "Wire", + "TFT", + "GSM", + "SPI", + "SD" + ], + _hints: [ + "setup", + "loop", + "runShellCommandAsynchronously", + "analogWriteResolution", + "retrieveCallingNumber", + "printFirmwareVersion", + "analogReadResolution", + "sendDigitalPortPair", + "noListenOnLocalhost", + "readJoystickButton", + "setFirmwareVersion", + "readJoystickSwitch", + "scrollDisplayRight", + "getVoiceCallStatus", + "scrollDisplayLeft", + "writeMicroseconds", + "delayMicroseconds", + "beginTransmission", + "getSignalStrength", + "runAsynchronously", + "getAsynchronously", + "listenOnLocalhost", + "getCurrentCarrier", + "readAccelerometer", + "messageAvailable", + "sendDigitalPorts", + "lineFollowConfig", + "countryNameWrite", + "runShellCommand", + "readStringUntil", + "rewindDirectory", + "readTemperature", + "setClockDivider", + "readLightSensor", + "endTransmission", + "analogReference", + "detachInterrupt", + "countryNameRead", + "attachInterrupt", + "encryptionType", + "readBytesUntil", + "robotNameWrite", + "readMicrophone", + "robotNameRead", + "cityNameWrite", + "userNameWrite", + "readJoystickY", + "readJoystickX", + "mouseReleased", + "openNextFile", + "scanNetworks", + "noInterrupts", + "digitalWrite", + "beginSpeaker", + "mousePressed", + "isActionDone", + "mouseDragged", + "displayLogos", + "noAutoscroll", + "addParameter", + "remoteNumber", + "getModifiers", + "keyboardRead", + "userNameRead", + "waitContinue", + "processInput", + "parseCommand", + "printVersion", + "readNetworks", + "writeMessage", + "blinkVersion", + "cityNameRead", + "readMessage", + "setDataMode", + "parsePacket", + "isListening", + "setBitOrder", + "beginPacket", + "isDirectory", + "motorsWrite", + "drawCompass", + "digitalRead", + "clearScreen", + "serialEvent", + "rightToLeft", + "setTextSize", + "leftToRight", + "requestFrom", + "keyReleased", + "compassRead", + "analogWrite", + "interrupts", + "WiFiServer", + "disconnect", + "playMelody", + "parseFloat", + "autoscroll", + "getPINUsed", + "setPINUsed", + "setTimeout", + "sendAnalog", + "readSlider", + "analogRead", + "beginWrite", + "createChar", + "motorsStop", + "keyPressed", + "tempoWrite", + "readButton", + "subnetMask", + "debugPrint", + "macAddress", + "writeGreen", + "randomSeed", + "attachGPRS", + "readString", + "sendString", + "remotePort", + "releaseAll", + "mouseMoved", + "background", + "getXChange", + "getYChange", + "answerCall", + "getResult", + "voiceCall", + "endPacket", + "constrain", + "getSocket", + "writeJSON", + "getButton", + "available", + "connected", + "findUntil", + "readBytes", + "exitValue", + "readGreen", + "writeBlue", + "startLoop", + "IPAddress", + "isPressed", + "sendSysex", + "pauseMode", + "gatewayIP", + "setCursor", + "getOemKey", + "tuneWrite", + "noDisplay", + "loadImage", + "switchPIN", + "onRequest", + "onReceive", + "changePIN", + "playFile", + "noBuffer", + "parseInt", + "overflow", + "checkPIN", + "knobRead", + "beginTFT", + "bitClear", + "updateIR", + "bitWrite", + "position", + "writeRGB", + "highByte", + "writeRed", + "setSpeed", + "readBlue", + "noStroke", + "remoteIP", + "transfer", + "shutdown", + "hangCall", + "beginSMS", + "endWrite", + "attached", + "maintain", + "noCursor", + "checkReg", + "checkPUK", + "shiftOut", + "isValid", + "shiftIn", + "pulseIn", + "connect", + "println", + "localIP", + "pinMode", + "getIMEI", + "display", + "noBlink", + "process", + "getBand", + "running", + "beginSD", + "drawBMP", + "lowByte", + "setBand", + "release", + "bitRead", + "prepare", + "pointTo", + "readRed", + "setMode", + "noFill", + "remove", + "listen", + "stroke", + "detach", + "attach", + "noTone", + "exists", + "buffer", + "height", + "bitSet", + "circle", + "config", + "cursor", + "random", + "IRread", + "setDNS", + "endSMS", + "getKey", + "micros", + "millis", + "begin", + "print", + "write", + "ready", + "flush", + "width", + "isPIN", + "blink", + "clear", + "press", + "mkdir", + "rmdir", + "close", + "point", + "yield", + "image", + "BSSID", + "click", + "delay", + "read", + "text", + "move", + "peek", + "beep", + "rect", + "line", + "open", + "seek", + "fill", + "size", + "turn", + "stop", + "home", + "find", + "step", + "tone", + "sqrt", + "RSSI", + "SSID", + "end", + "bit", + "tan", + "cos", + "sin", + "pow", + "map", + "abs", + "max", + "min", + "get", + "run", + "put" + ], + literal: [ + "DIGITAL_MESSAGE", + "FIRMATA_STRING", + "ANALOG_MESSAGE", + "REPORT_DIGITAL", + "REPORT_ANALOG", + "INPUT_PULLUP", + "SET_PIN_MODE", + "INTERNAL2V56", + "SYSTEM_RESET", + "LED_BUILTIN", + "INTERNAL1V1", + "SYSEX_START", + "INTERNAL", + "EXTERNAL", + "DEFAULT", + "OUTPUT", + "INPUT", + "HIGH", + "LOW" + ] + }, r = a(t), i = ( + /** @type {Record} */ + r.keywords + ); + return i.type = [ + ...i.type, + ...n.type + ], i.literal = [ + ...i.literal, + ...n.literal + ], i.built_in = [ + ...i.built_in, + ...n.built_in + ], i._hints = n._hints, r.name = "Arduino", r.aliases = ["ino"], r.supersetOf = "cpp", r; + } + return Ca = e, Ca; +} +var Na, cl; +function aS() { + if (cl) return Na; + cl = 1; + function a(e) { + const t = { variants: [ + e.COMMENT("^[ \\t]*(?=#)", "$", { + relevance: 0, + excludeBegin: !0 + }), + e.COMMENT("[;@]", "$", { relevance: 0 }), + e.C_LINE_COMMENT_MODE, + e.C_BLOCK_COMMENT_MODE + ] }; + return { + name: "ARM Assembly", + case_insensitive: !0, + aliases: ["arm"], + keywords: { + $pattern: "\\.?" + e.IDENT_RE, + meta: ( + // GNU preprocs + ".2byte .4byte .align .ascii .asciz .balign .byte .code .data .else .end .endif .endm .endr .equ .err .exitm .extern .global .hword .if .ifdef .ifndef .include .irp .long .macro .rept .req .section .set .skip .space .text .word .arm .thumb .code16 .code32 .force_thumb .thumb_func .ltorg ALIAS ALIGN ARM AREA ASSERT ATTR CN CODE CODE16 CODE32 COMMON CP DATA DCB DCD DCDU DCDO DCFD DCFDU DCI DCQ DCQU DCW DCWU DN ELIF ELSE END ENDFUNC ENDIF ENDP ENTRY EQU EXPORT EXPORTAS EXTERN FIELD FILL FUNCTION GBLA GBLL GBLS GET GLOBAL IF IMPORT INCBIN INCLUDE INFO KEEP LCLA LCLL LCLS LTORG MACRO MAP MEND MEXIT NOFP OPT PRESERVE8 PROC QN READONLY RELOC REQUIRE REQUIRE8 RLIST FN ROUT SETA SETL SETS SN SPACE SUBT THUMB THUMBX TTL WHILE WEND " + ), + built_in: "r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 w0 w1 w2 w3 w4 w5 w6 w7 w8 w9 w10 w11 w12 w13 w14 w15 w16 w17 w18 w19 w20 w21 w22 w23 w24 w25 w26 w27 w28 w29 w30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 pc lr sp ip sl sb fp a1 a2 a3 a4 v1 v2 v3 v4 v5 v6 v7 v8 f0 f1 f2 f3 f4 f5 f6 f7 p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12 q13 q14 q15 cpsr_c cpsr_x cpsr_s cpsr_f cpsr_cx cpsr_cxs cpsr_xs cpsr_xsf cpsr_sf cpsr_cxsf spsr_c spsr_x spsr_s spsr_f spsr_cx spsr_cxs spsr_xs spsr_xsf spsr_sf spsr_cxsf s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12 s13 s14 s15 s16 s17 s18 s19 s20 s21 s22 s23 s24 s25 s26 s27 s28 s29 s30 s31 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14 d15 d16 d17 d18 d19 d20 d21 d22 d23 d24 d25 d26 d27 d28 d29 d30 d31 {PC} {VAR} {TRUE} {FALSE} {OPT} {CONFIG} {ENDIAN} {CODESIZE} {CPU} {FPU} {ARCHITECTURE} {PCSTOREOFFSET} {ARMASM_VERSION} {INTER} {ROPI} {RWPI} {SWST} {NOSWST} . @" + }, + contains: [ + { + className: "keyword", + begin: "\\b(adc|(qd?|sh?|u[qh]?)?add(8|16)?|usada?8|(q|sh?|u[qh]?)?(as|sa)x|and|adrl?|sbc|rs[bc]|asr|b[lx]?|blx|bxj|cbn?z|tb[bh]|bic|bfc|bfi|[su]bfx|bkpt|cdp2?|clz|clrex|cmp|cmn|cpsi[ed]|cps|setend|dbg|dmb|dsb|eor|isb|it[te]{0,3}|lsl|lsr|ror|rrx|ldm(([id][ab])|f[ds])?|ldr((s|ex)?[bhd])?|movt?|mvn|mra|mar|mul|[us]mull|smul[bwt][bt]|smu[as]d|smmul|smmla|mla|umlaal|smlal?([wbt][bt]|d)|mls|smlsl?[ds]|smc|svc|sev|mia([bt]{2}|ph)?|mrr?c2?|mcrr2?|mrs|msr|orr|orn|pkh(tb|bt)|rbit|rev(16|sh)?|sel|[su]sat(16)?|nop|pop|push|rfe([id][ab])?|stm([id][ab])?|str(ex)?[bhd]?|(qd?)?sub|(sh?|q|u[qh]?)?sub(8|16)|[su]xt(a?h|a?b(16)?)|srs([id][ab])?|swpb?|swi|smi|tst|teq|wfe|wfi|yield)(eq|ne|cs|cc|mi|pl|vs|vc|hi|ls|ge|lt|gt|le|al|hs|lo)?[sptrx]?(?=\\s)" + // followed by space + }, + t, + e.QUOTE_STRING_MODE, + { + className: "string", + begin: "'", + end: "[^\\\\]'", + relevance: 0 + }, + { + className: "title", + begin: "\\|", + end: "\\|", + illegal: "\\n", + relevance: 0 + }, + { + className: "number", + variants: [ + { + // hex + begin: "[#$=]?0x[0-9a-f]+" + }, + { + // bin + begin: "[#$=]?0b[01]+" + }, + { + // literal + begin: "[#$=]\\d+" + }, + { + // bare number + begin: "\\b\\d+" + } + ], + relevance: 0 + }, + { + className: "symbol", + variants: [ + { + // GNU ARM syntax + begin: "^[ \\t]*[a-z_\\.\\$][a-z0-9_\\.\\$]+:" + }, + { + // ARM syntax + begin: "^[a-z_\\.\\$][a-z0-9_\\.\\$]+" + }, + { + // label reference + begin: "[=#]\\w+" + } + ], + relevance: 0 + } + ] + }; + } + return Na = a, Na; +} +var Oa, _l; +function rS() { + if (_l) return Oa; + _l = 1; + function a(e) { + const t = e.regex, n = t.concat(/[\p{L}_]/u, t.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u), r = /[\p{L}0-9._:-]+/u, i = { + className: "symbol", + begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/ + }, o = { + begin: /\s/, + contains: [ + { + className: "keyword", + begin: /#?[a-z_][a-z1-9_-]+/, + illegal: /\n/ + } + ] + }, s = e.inherit(o, { + begin: /\(/, + end: /\)/ + }), l = e.inherit(e.APOS_STRING_MODE, { className: "string" }), c = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }), _ = { + endsWithParent: !0, + illegal: /`]+/ } + ] + } + ] + } + ] + }; + return { + name: "HTML, XML", + aliases: [ + "html", + "xhtml", + "rss", + "atom", + "xjb", + "xsd", + "xsl", + "plist", + "wsf", + "svg" + ], + case_insensitive: !0, + unicodeRegex: !0, + contains: [ + { + className: "meta", + begin: //, + relevance: 10, + contains: [ + o, + c, + l, + s, + { + begin: /\[/, + end: /\]/, + contains: [ + { + className: "meta", + begin: //, + contains: [ + o, + s, + c, + l + ] + } + ] + } + ] + }, + e.COMMENT( + //, + { relevance: 10 } + ), + { + begin: //, + relevance: 10 + }, + i, + // xml processing instructions + { + className: "meta", + end: /\?>/, + variants: [ + { + begin: /<\?xml/, + relevance: 10, + contains: [ + c + ] + }, + { + begin: /<\?[a-z][a-z0-9]+/ + } + ] + }, + { + className: "tag", + /* + The lookahead pattern (?=...) ensures that 'begin' only matches + ')/, + end: />/, + keywords: { name: "style" }, + contains: [_], + starts: { + end: /<\/style>/, + returnEnd: !0, + subLanguage: [ + "css", + "xml" + ] + } + }, + { + className: "tag", + // See the comment in the