v-code-diff 0.3.12 → 1.0.0

package/dist/v3/index.es.js

@@ -0,0 +1,4315 @@
+(function(){"use strict";try{if(typeof document!="undefined"){var o=document.createElement("style");o.appendChild(document.createTextNode(".file{--color-canvas-default-transparent: rgba(255,255,255,0);--color-page-header-bg: #f6f8fa;--color-marketing-icon-primary: #218bff;--color-marketing-icon-secondary: #54aeff;--color-diff-blob-addition-num-text: #24292f;--color-diff-blob-addition-fg: #24292f;--color-diff-blob-addition-num-bg: #ccffd8;--color-diff-blob-addition-line-bg: #e6ffec;--color-diff-blob-addition-word-bg: #abf2bc;--color-diff-blob-deletion-num-text: #24292f;--color-diff-blob-deletion-fg: #24292f;--color-diff-blob-deletion-num-bg: #ffd7d5;--color-diff-blob-deletion-line-bg: #ffebe9;--color-diff-blob-deletion-word-bg: rgba(255,129,130,.4);--color-diff-blob-hunk-num-bg: rgba(84,174,255,.4);--color-diff-blob-expander-icon: #57606a;--color-diff-blob-selected-line-highlight-mix-blend-mode: multiply;--color-diffstat-deletion-border: rgba(27,31,36,.15);--color-diffstat-addition-border: rgba(27,31,36,.15);--color-diffstat-addition-bg: #2da44e;--color-search-keyword-hl: #fff8c5;--color-prettylights-syntax-comment: #6e7781;--color-prettylights-syntax-constant: #0550ae;--color-prettylights-syntax-entity: #8250df;--color-prettylights-syntax-storage-modifier-import: #24292f;--color-prettylights-syntax-entity-tag: #116329;--color-prettylights-syntax-keyword: #cf222e;--color-prettylights-syntax-string: #0a3069;--color-prettylights-syntax-variable: #953800;--color-prettylights-syntax-brackethighlighter-unmatched: #82071e;--color-prettylights-syntax-invalid-illegal-text: #f6f8fa;--color-prettylights-syntax-invalid-illegal-bg: #82071e;--color-prettylights-syntax-carriage-return-text: #f6f8fa;--color-prettylights-syntax-carriage-return-bg: #cf222e;--color-prettylights-syntax-string-regexp: #116329;--color-prettylights-syntax-markup-list: #3b2300;--color-prettylights-syntax-markup-heading: #0550ae;--color-prettylights-syntax-markup-italic: #24292f;--color-prettylights-syntax-markup-bold: #24292f;--color-prettylights-syntax-markup-deleted-text: #82071e;--color-prettylights-syntax-markup-deleted-bg: #ffebe9;--color-prettylights-syntax-markup-inserted-text: #116329;--color-prettylights-syntax-markup-inserted-bg: #dafbe1;--color-prettylights-syntax-markup-changed-text: #953800;--color-prettylights-syntax-markup-changed-bg: #ffd8b5;--color-prettylights-syntax-markup-ignored-text: #eaeef2;--color-prettylights-syntax-markup-ignored-bg: #0550ae;--color-prettylights-syntax-meta-diff-range: #8250df;--color-prettylights-syntax-brackethighlighter-angle: #57606a;--color-prettylights-syntax-sublimelinter-gutter-mark: #8c959f;--color-prettylights-syntax-constant-other-reference-link: #0a3069;--color-codemirror-text: #24292f;--color-codemirror-bg: #ffffff;--color-codemirror-gutters-bg: #ffffff;--color-codemirror-guttermarker-text: #ffffff;--color-codemirror-guttermarker-subtle-text: #6e7781;--color-codemirror-linenumber-text: #57606a;--color-codemirror-cursor: #24292f;--color-codemirror-selection-bg: rgba(84,174,255,.4);--color-codemirror-activeline-bg: rgba(234,238,242,.5);--color-codemirror-matchingbracket-text: #24292f;--color-codemirror-lines-bg: #ffffff;--color-codemirror-syntax-comment: #24292f;--color-codemirror-syntax-constant: #0550ae;--color-codemirror-syntax-entity: #8250df;--color-codemirror-syntax-keyword: #cf222e;--color-codemirror-syntax-storage: #cf222e;--color-codemirror-syntax-string: #0a3069;--color-codemirror-syntax-support: #0550ae;--color-codemirror-syntax-variable: #953800;--color-checks-bg: #24292f;--color-checks-run-border-width: 0px;--color-checks-container-border-width: 0px;--color-checks-text-primary: #f6f8fa;--color-checks-text-secondary: #8c959f;--color-checks-text-link: #54aeff;--color-checks-btn-icon: #afb8c1;--color-checks-btn-hover-icon: #f6f8fa;--color-checks-btn-hover-bg: rgba(255,255,255,.125);--color-checks-input-text: #eaeef2;--color-checks-input-placeholder-text: #8c959f;--color-checks-input-focus-text: #8c959f;--color-checks-input-bg: #32383f;--color-checks-input-shadow: none;--color-checks-donut-error: #fa4549;--color-checks-donut-pending: #bf8700;--color-checks-donut-success: #2da44e;--color-checks-donut-neutral: #afb8c1;--color-checks-dropdown-text: #afb8c1;--color-checks-dropdown-bg: #32383f;--color-checks-dropdown-border: #424a53;--color-checks-dropdown-shadow: rgba(27,31,36,.3);--color-checks-dropdown-hover-text: #f6f8fa;--color-checks-dropdown-hover-bg: #424a53;--color-checks-dropdown-btn-hover-text: #f6f8fa;--color-checks-dropdown-btn-hover-bg: #32383f;--color-checks-scrollbar-thumb-bg: #57606a;--color-checks-header-label-text: #d0d7de;--color-checks-header-label-open-text: #f6f8fa;--color-checks-header-border: #32383f;--color-checks-header-icon: #8c959f;--color-checks-line-text: #d0d7de;--color-checks-line-num-text: rgba(140,149,159,.75);--color-checks-line-timestamp-text: #8c959f;--color-checks-line-hover-bg: #32383f;--color-checks-line-selected-bg: rgba(33,139,255,.15);--color-checks-line-selected-num-text: #54aeff;--color-checks-line-dt-fm-text: #24292f;--color-checks-line-dt-fm-bg: #9a6700;--color-checks-gate-bg: rgba(125,78,0,.15);--color-checks-gate-text: #d0d7de;--color-checks-gate-waiting-text: #d4a72c;--color-checks-step-header-open-bg: #32383f;--color-checks-step-error-text: #ff8182;--color-checks-step-warning-text: #d4a72c;--color-checks-logline-text: #8c959f;--color-checks-logline-num-text: rgba(140,149,159,.75);--color-checks-logline-debug-text: #c297ff;--color-checks-logline-error-text: #d0d7de;--color-checks-logline-error-num-text: #ff8182;--color-checks-logline-error-bg: rgba(164,14,38,.15);--color-checks-logline-warning-text: #d0d7de;--color-checks-logline-warning-num-text: #d4a72c;--color-checks-logline-warning-bg: rgba(125,78,0,.15);--color-checks-logline-command-text: #54aeff;--color-checks-logline-section-text: #4ac26b;--color-checks-ansi-black: #24292f;--color-checks-ansi-black-bright: #32383f;--color-checks-ansi-white: #d0d7de;--color-checks-ansi-white-bright: #d0d7de;--color-checks-ansi-gray: #8c959f;--color-checks-ansi-red: #ff8182;--color-checks-ansi-red-bright: #ffaba8;--color-checks-ansi-green: #4ac26b;--color-checks-ansi-green-bright: #6fdd8b;--color-checks-ansi-yellow: #d4a72c;--color-checks-ansi-yellow-bright: #eac54f;--color-checks-ansi-blue: #54aeff;--color-checks-ansi-blue-bright: #80ccff;--color-checks-ansi-magenta: #c297ff;--color-checks-ansi-magenta-bright: #d8b9ff;--color-checks-ansi-cyan: #76e3ea;--color-checks-ansi-cyan-bright: #b3f0ff;--color-project-header-bg: #24292f;--color-project-sidebar-bg: #ffffff;--color-project-gradient-in: #ffffff;--color-project-gradient-out: rgba(255,255,255,0);--color-mktg-btn-bg: #1b1f23;--color-mktg-btn-shadow-outline: rgb(0 0 0 / 15%) 0 0 0 1px inset;--color-mktg-btn-shadow-focus: rgb(0 0 0 / 15%) 0 0 0 4px;--color-mktg-btn-shadow-hover: 0 3px 2px rgba(0, 0, 0, .07), 0 7px 5px rgba(0, 0, 0, .04), 0 12px 10px rgba(0, 0, 0, .03), 0 22px 18px rgba(0, 0, 0, .03), 0 42px 33px rgba(0, 0, 0, .02), 0 100px 80px rgba(0, 0, 0, .02);--color-mktg-btn-shadow-hover-muted: rgb(0 0 0 / 70%) 0 0 0 2px inset;--color-avatar-bg: #ffffff;--color-avatar-border: rgba(27,31,36,.15);--color-avatar-stack-fade: #afb8c1;--color-avatar-stack-fade-more: #d0d7de;--color-avatar-child-shadow: -2px -2px 0 rgba(255,255,255,.8);--color-topic-tag-border: rgba(0,0,0,0);--color-counter-border: rgba(0,0,0,0);--color-select-menu-backdrop-border: rgba(0,0,0,0);--color-select-menu-tap-highlight: rgba(175,184,193,.5);--color-select-menu-tap-focus-bg: #b6e3ff;--color-overlay-shadow: 0 1px 3px rgba(27,31,36,.12), 0 8px 24px rgba(66,74,83,.12);--color-header-text: rgba(255,255,255,.7);--color-header-bg: #24292f;--color-header-divider: #57606a;--color-header-logo: #ffffff;--color-header-search-bg: #24292f;--color-header-search-border: #57606a;--color-sidenav-selected-bg: #ffffff;--color-menu-bg-active: rgba(0,0,0,0);--color-input-disabled-bg: rgba(175,184,193,.2);--color-timeline-badge-bg: #eaeef2;--color-ansi-black: #24292f;--color-ansi-black-bright: #57606a;--color-ansi-white: #6e7781;--color-ansi-white-bright: #8c959f;--color-ansi-gray: #6e7781;--color-ansi-red: #cf222e;--color-ansi-red-bright: #a40e26;--color-ansi-green: #116329;--color-ansi-green-bright: #1a7f37;--color-ansi-yellow: #4d2d00;--color-ansi-yellow-bright: #633c01;--color-ansi-blue: #0969da;--color-ansi-blue-bright: #218bff;--color-ansi-magenta: #8250df;--color-ansi-magenta-bright: #a475f9;--color-ansi-cyan: #1b7c83;--color-ansi-cyan-bright: #3192aa;--color-btn-text: #24292f;--color-btn-bg: #f6f8fa;--color-btn-border: rgba(27,31,36,.15);--color-btn-shadow: 0 1px 0 rgba(27,31,36,.04);--color-btn-inset-shadow: inset 0 1px 0 rgba(255,255,255,.25);--color-btn-hover-bg: #f3f4f6;--color-btn-hover-border: rgba(27,31,36,.15);--color-btn-active-bg: hsla(220,14%,93%,1);--color-btn-active-border: rgba(27,31,36,.15);--color-btn-selected-bg: hsla(220,14%,94%,1);--color-btn-focus-bg: #f6f8fa;--color-btn-focus-border: rgba(27,31,36,.15);--color-btn-focus-shadow: 0 0 0 3px rgba(9,105,218,.3);--color-btn-shadow-active: inset 0 .15em .3em rgba(27,31,36,.15);--color-btn-shadow-input-focus: 0 0 0 .2em rgba(9,105,218,.3);--color-btn-counter-bg: rgba(27,31,36,.08);--color-btn-primary-text: #ffffff;--color-btn-primary-bg: #2da44e;--color-btn-primary-border: rgba(27,31,36,.15);--color-btn-primary-shadow: 0 1px 0 rgba(27,31,36,.1);--color-btn-primary-inset-shadow: inset 0 1px 0 rgba(255,255,255,.03);--color-btn-primary-hover-bg: #2c974b;--color-btn-primary-hover-border: rgba(27,31,36,.15);--color-btn-primary-selected-bg: hsla(137,55%,36%,1);--color-btn-primary-selected-shadow: inset 0 1px 0 rgba(0,45,17,.2);--color-btn-primary-disabled-text: rgba(255,255,255,.8);--color-btn-primary-disabled-bg: #94d3a2;--color-btn-primary-disabled-border: rgba(27,31,36,.15);--color-btn-primary-focus-bg: #2da44e;--color-btn-primary-focus-border: rgba(27,31,36,.15);--color-btn-primary-focus-shadow: 0 0 0 3px rgba(45,164,78,.4);--color-btn-primary-icon: rgba(255,255,255,.8);--color-btn-primary-counter-bg: rgba(255,255,255,.2);--color-btn-outline-text: #0969da;--color-btn-outline-hover-text: #ffffff;--color-btn-outline-hover-bg: #0969da;--color-btn-outline-hover-border: rgba(27,31,36,.15);--color-btn-outline-hover-shadow: 0 1px 0 rgba(27,31,36,.1);--color-btn-outline-hover-inset-shadow: inset 0 1px 0 rgba(255,255,255,.03);--color-btn-outline-hover-counter-bg: rgba(255,255,255,.2);--color-btn-outline-selected-text: #ffffff;--color-btn-outline-selected-bg: hsla(212,92%,42%,1);--color-btn-outline-selected-border: rgba(27,31,36,.15);--color-btn-outline-selected-shadow: inset 0 1px 0 rgba(0,33,85,.2);--color-btn-outline-disabled-text: rgba(9,105,218,.5);--color-btn-outline-disabled-bg: #f6f8fa;--color-btn-outline-disabled-counter-bg: rgba(9,105,218,.05);--color-btn-outline-focus-border: rgba(27,31,36,.15);--color-btn-outline-focus-shadow: 0 0 0 3px rgba(5,80,174,.4);--color-btn-outline-counter-bg: rgba(9,105,218,.1);--color-btn-danger-text: #cf222e;--color-btn-danger-hover-text: #ffffff;--color-btn-danger-hover-bg: #a40e26;--color-btn-danger-hover-border: rgba(27,31,36,.15);--color-btn-danger-hover-shadow: 0 1px 0 rgba(27,31,36,.1);--color-btn-danger-hover-inset-shadow: inset 0 1px 0 rgba(255,255,255,.03);--color-btn-danger-hover-counter-bg: rgba(255,255,255,.2);--color-btn-danger-selected-text: #ffffff;--color-btn-danger-selected-bg: hsla(356,72%,44%,1);--color-btn-danger-selected-border: rgba(27,31,36,.15);--color-btn-danger-selected-shadow: inset 0 1px 0 rgba(76,0,20,.2);--color-btn-danger-disabled-text: rgba(207,34,46,.5);--color-btn-danger-disabled-bg: #f6f8fa;--color-btn-danger-disabled-counter-bg: rgba(207,34,46,.05);--color-btn-danger-focus-border: rgba(27,31,36,.15);--color-btn-danger-focus-shadow: 0 0 0 3px rgba(164,14,38,.4);--color-btn-danger-counter-bg: rgba(207,34,46,.1);--color-btn-danger-icon: #cf222e;--color-btn-danger-hover-icon: #ffffff;--color-underlinenav-icon: #6e7781;--color-underlinenav-border-hover: rgba(175,184,193,.2);--color-action-list-item-inline-divider: rgba(208,215,222,.48);--color-action-list-item-default-hover-bg: rgba(208,215,222,.32);--color-action-list-item-default-hover-border: rgba(0,0,0,0);--color-action-list-item-default-active-bg: rgba(208,215,222,.48);--color-action-list-item-default-active-border: rgba(0,0,0,0);--color-action-list-item-default-selected-bg: rgba(208,215,222,.24);--color-action-list-item-danger-hover-bg: rgba(255,235,233,.64);--color-action-list-item-danger-active-bg: #ffebe9;--color-action-list-item-danger-hover-text: #cf222e;--color-switch-track-bg: #eaeef2;--color-switch-track-border: #afb8c1;--color-switch-track-checked-bg: #ddf4ff;--color-switch-track-checked-hover-bg: #b6e3ff;--color-switch-track-checked-active-bg: #80ccff;--color-switch-track-checked-border: #54aeff;--color-switch-knob-checked-bg: #0969da;--color-switch-knob-checked-disabled-bg: #6e7781;--color-segmented-control-bg: #eaeef2;--color-segmented-control-button-hover-bg: rgba(175,184,193,.2);--color-segmented-control-button-active-bg: rgba(175,184,193,.4);--color-segmented-control-button-selected-border: #6e7781;--color-fg-default: #24292f;--color-fg-muted: #57606a;--color-fg-subtle: #6e7781;--color-fg-on-emphasis: #ffffff;--color-canvas-default: #ffffff;--color-canvas-overlay: #ffffff;--color-canvas-inset: #f6f8fa;--color-canvas-subtle: #f6f8fa;--color-border-default: #d0d7de;--color-border-muted: hsla(210,18%,87%,1);--color-border-subtle: rgba(27,31,36,.15);--color-shadow-small: 0 1px 0 rgba(27,31,36,.04);--color-shadow-medium: 0 3px 6px rgba(140,149,159,.15);--color-shadow-large: 0 8px 24px rgba(140,149,159,.2);--color-shadow-extra-large: 0 12px 28px rgba(140,149,159,.3);--color-neutral-emphasis-plus: #24292f;--color-neutral-emphasis: #6e7781;--color-neutral-muted: rgba(175,184,193,.2);--color-neutral-subtle: rgba(234,238,242,.5);--color-accent-fg: #0969da;--color-accent-emphasis: #0969da;--color-accent-muted: rgba(84,174,255,.4);--color-accent-subtle: #ddf4ff;--color-success-fg: #1a7f37;--color-success-emphasis: #2da44e;--color-success-muted: rgba(74,194,107,.4);--color-success-subtle: #dafbe1;--color-attention-fg: #9a6700;--color-attention-emphasis: #bf8700;--color-attention-muted: rgba(212,167,44,.4);--color-attention-subtle: #fff8c5;--color-severe-fg: #bc4c00;--color-severe-emphasis: #bc4c00;--color-severe-muted: rgba(251,143,68,.4);--color-severe-subtle: #fff1e5;--color-danger-fg: #cf222e;--color-danger-emphasis: #cf222e;--color-danger-muted: rgba(255,129,130,.4);--color-danger-subtle: #ffebe9;--color-open-fg: #1a7f37;--color-open-emphasis: #2da44e;--color-open-muted: rgba(74,194,107,.4);--color-open-subtle: #dafbe1;--color-closed-fg: #cf222e;--color-closed-emphasis: #cf222e;--color-closed-muted: rgba(255,129,130,.4);--color-closed-subtle: #ffebe9;--color-done-fg: #8250df;--color-done-emphasis: #8250df;--color-done-muted: rgba(194,151,255,.4);--color-done-subtle: #fbefff;--color-sponsors-fg: #bf3989;--color-sponsors-emphasis: #bf3989;--color-sponsors-muted: rgba(255,128,200,.4);--color-sponsors-subtle: #ffeff7;--color-primer-fg-disabled: #8c959f;--color-primer-canvas-backdrop: rgba(27,31,36,.5);--color-primer-canvas-sticky: rgba(255,255,255,.95);--color-primer-border-active: #fd8c73;--color-primer-border-contrast: rgba(27,31,36,.1);--color-primer-shadow-highlight: inset 0 1px 0 rgba(255,255,255,.25);--color-primer-shadow-inset: inset 0 1px 0 rgba(208,215,222,.2);--color-primer-shadow-focus: 0 0 0 3px rgba(9,105,218,.3);--color-scale-black: #1b1f24;--color-scale-white: #ffffff;--color-scale-gray-0: #f6f8fa;--color-scale-gray-1: #eaeef2;--color-scale-gray-2: #d0d7de;--color-scale-gray-3: #afb8c1;--color-scale-gray-4: #8c959f;--color-scale-gray-5: #6e7781;--color-scale-gray-6: #57606a;--color-scale-gray-7: #424a53;--color-scale-gray-8: #32383f;--color-scale-gray-9: #24292f;--color-scale-blue-0: #ddf4ff;--color-scale-blue-1: #b6e3ff;--color-scale-blue-2: #80ccff;--color-scale-blue-3: #54aeff;--color-scale-blue-4: #218bff;--color-scale-blue-5: #0969da;--color-scale-blue-6: #0550ae;--color-scale-blue-7: #033d8b;--color-scale-blue-8: #0a3069;--color-scale-blue-9: #002155;--color-scale-green-0: #dafbe1;--color-scale-green-1: #aceebb;--color-scale-green-2: #6fdd8b;--color-scale-green-3: #4ac26b;--color-scale-green-4: #2da44e;--color-scale-green-5: #1a7f37;--color-scale-green-6: #116329;--color-scale-green-7: #044f1e;--color-scale-green-8: #003d16;--color-scale-green-9: #002d11;--color-scale-yellow-0: #fff8c5;--color-scale-yellow-1: #fae17d;--color-scale-yellow-2: #eac54f;--color-scale-yellow-3: #d4a72c;--color-scale-yellow-4: #bf8700;--color-scale-yellow-5: #9a6700;--color-scale-yellow-6: #7d4e00;--color-scale-yellow-7: #633c01;--color-scale-yellow-8: #4d2d00;--color-scale-yellow-9: #3b2300;--color-scale-orange-0: #fff1e5;--color-scale-orange-1: #ffd8b5;--color-scale-orange-2: #ffb77c;--color-scale-orange-3: #fb8f44;--color-scale-orange-4: #e16f24;--color-scale-orange-5: #bc4c00;--color-scale-orange-6: #953800;--color-scale-orange-7: #762c00;--color-scale-orange-8: #5c2200;--color-scale-orange-9: #471700;--color-scale-red-0: #ffebe9;--color-scale-red-1: #ffcecb;--color-scale-red-2: #ffaba8;--color-scale-red-3: #ff8182;--color-scale-red-4: #fa4549;--color-scale-red-5: #cf222e;--color-scale-red-6: #a40e26;--color-scale-red-7: #82071e;--color-scale-red-8: #660018;--color-scale-red-9: #4c0014;--color-scale-purple-0: #fbefff;--color-scale-purple-1: #ecd8ff;--color-scale-purple-2: #d8b9ff;--color-scale-purple-3: #c297ff;--color-scale-purple-4: #a475f9;--color-scale-purple-5: #8250df;--color-scale-purple-6: #6639ba;--color-scale-purple-7: #512a97;--color-scale-purple-8: #3e1f79;--color-scale-purple-9: #2e1461;--color-scale-pink-0: #ffeff7;--color-scale-pink-1: #ffd3eb;--color-scale-pink-2: #ffadda;--color-scale-pink-3: #ff80c8;--color-scale-pink-4: #e85aad;--color-scale-pink-5: #bf3989;--color-scale-pink-6: #99286e;--color-scale-pink-7: #772057;--color-scale-pink-8: #611347;--color-scale-pink-9: #4d0336;--color-scale-coral-0: #fff0eb;--color-scale-coral-1: #ffd6cc;--color-scale-coral-2: #ffb4a1;--color-scale-coral-3: #fd8c73;--color-scale-coral-4: #ec6547;--color-scale-coral-5: #c4432b;--color-scale-coral-6: #9e2f1c;--color-scale-coral-7: #801f0f;--color-scale-coral-8: #691105;--color-scale-coral-9: #510901}.code-diff-view *{position:static}.code-diff-view .file{position:relative;margin-top:16px;margin-bottom:16px;border:1px solid var(--color-border-default, #ddd);border-radius:2px}.code-diff-view .file table{border-spacing:0}.code-diff-view .file .diff-table{width:100%}.code-diff-view .file .diff-table .blob-num{position:relative;width:1%;min-width:50px;padding-right:10px;padding-left:10px;font-family:ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;font-size:12px;line-height:20px;color:var(--color-fg-subtle);text-align:right;white-space:nowrap;vertical-align:top;cursor:pointer;-webkit-user-select:none;user-select:none}.code-diff-view .file .diff-table .blob-num-deletion{color:var(--color-diff-blob-deletion-num-text);background-color:var(--color-diff-blob-deletion-num-bg);border-color:var(--color-danger-emphasis)}.code-diff-view .file .diff-table .blob-num-addition{color:var(--color-diff-blob-addition-num-text);background-color:var(--color-diff-blob-addition-num-bg);border-color:var(--color-success-emphasis)}.code-diff-view .file .diff-table .blob-code{position:relative;padding-right:10px;padding-left:10px;line-height:20px;vertical-align:top}.code-diff-view .file .diff-table .blob-code .blob-code-inner{display:table-cell;overflow:visible;font-family:ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;font-size:12px;color:var(--color-fg-default);word-wrap:anywhere;white-space:pre-wrap}.code-diff-view .file .diff-table .blob-code-deletion{background-color:var(--color-diff-blob-deletion-line-bg);outline:1px dashed transparent}.code-diff-view .file .diff-table .blob-code-deletion .x{color:var(--color-diff-blob-deletion-fg);background-color:var(--color-diff-blob-deletion-word-bg)}.code-diff-view .file .diff-table .blob-code-addition{background-color:var(--color-diff-blob-addition-line-bg);outline:1px dotted transparent}.code-diff-view .file .diff-table .blob-code-addition .x{color:var(--color-diff-blob-addition-fg);background-color:var(--color-diff-blob-addition-word-bg)}.code-diff-view .file .diff-table .blob-code-context,.code-diff-view .file .diff-table .blob-code-addition,.code-diff-view .file .diff-table .blob-code-deletion{padding-left:22px!important}.code-diff-view .file .diff-table .blob-code-marker:before{position:absolute;top:1px;left:8px;padding-right:8px;content:attr(data-code-marker)}.code-diff-view .file .file-diff-split{table-layout:fixed}.code-diff-view .file .file-diff-split .blob-code+.blob-num{border-left:1px solid var(--color-border-muted)}.code-diff-view .file .empty-cell{cursor:default;background-color:var(--color-neutral-subtle);border-right-color:var(--color-border-muted)}pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{background:#fff;color:#000}.hljs-comment,.hljs-quote,.hljs-variable{color:green}.hljs-built_in,.hljs-keyword,.hljs-name,.hljs-selector-tag,.hljs-tag{color:#00f}.hljs-addition,.hljs-attribute,.hljs-literal,.hljs-section,.hljs-string,.hljs-template-tag,.hljs-template-variable,.hljs-title,.hljs-type{color:#a31515}.hljs-deletion,.hljs-meta,.hljs-selector-attr,.hljs-selector-pseudo{color:#2b91af}.hljs-doctag{color:gray}.hljs-attr{color:red}.hljs-bullet,.hljs-link,.hljs-symbol{color:#00b0e8}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:700}")),document.head.appendChild(o)}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
+import { defineComponent as _e, openBlock as P, createElementBlock as G, createElementVNode as k, normalizeClass as ge, unref as $, toDisplayString as $e, Fragment as ue, renderList as He, createBlock as Re, computed as ve } from "vue";
+function j() {
+}
+j.prototype = {
+  diff: function(n, t) {
+    var s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, c = s.callback;
+    typeof s == "function" && (c = s, s = {}), this.options = s;
+    var l = this;
+    function i(d) {
+      return c ? (setTimeout(function() {
+        c(void 0, d);
+      }, 0), !0) : d;
+    }
+    n = this.castInput(n), t = this.castInput(t), n = this.removeEmpty(this.tokenize(n)), t = this.removeEmpty(this.tokenize(t));
+    var r = t.length, a = n.length, o = 1, b = r + a;
+    s.maxEditLength && (b = Math.min(b, s.maxEditLength));
+    var E = [{
+      newPos: -1,
+      components: []
+    }], p = this.extractCommon(E[0], t, n, 0);
+    if (E[0].newPos + 1 >= r && p + 1 >= a)
+      return i([{
+        value: this.join(t),
+        count: t.length
+      }]);
+    function v() {
+      for (var d = -1 * o; d <= o; d += 2) {
+        var T = void 0, S = E[d - 1], x = E[d + 1], y = (x ? x.newPos : 0) - d;
+        S && (E[d - 1] = void 0);
+        var R = S && S.newPos + 1 < r, L = x && 0 <= y && y < a;
+        if (!R && !L) {
+          E[d] = void 0;
+          continue;
+        }
+        if (!R || L && S.newPos < x.newPos ? (T = In(x), l.pushComponent(T.components, void 0, !0)) : (T = S, T.newPos++, l.pushComponent(T.components, !0, void 0)), y = l.extractCommon(T, t, n, d), T.newPos + 1 >= r && y + 1 >= a)
+          return i(Cn(l, T.components, t, n, l.useLongestToken));
+        E[d] = T;
+      }
+      o++;
+    }
+    if (c)
+      (function d() {
+        setTimeout(function() {
+          if (o > b)
+            return c();
+          v() || d();
+        }, 0);
+      })();
+    else
+      for (; o <= b; ) {
+        var m = v();
+        if (m)
+          return m;
+      }
+  },
+  pushComponent: function(n, t, s) {
+    var c = n[n.length - 1];
+    c && c.added === t && c.removed === s ? n[n.length - 1] = {
+      count: c.count + 1,
+      added: t,
+      removed: s
+    } : n.push({
+      count: 1,
+      added: t,
+      removed: s
+    });
+  },
+  extractCommon: function(n, t, s, c) {
+    for (var l = t.length, i = s.length, r = n.newPos, a = r - c, o = 0; r + 1 < l && a + 1 < i && this.equals(t[r + 1], s[a + 1]); )
+      r++, a++, o++;
+    return o && n.components.push({
+      count: o
+    }), n.newPos = r, a;
+  },
+  equals: function(n, t) {
+    return this.options.comparator ? this.options.comparator(n, t) : n === t || this.options.ignoreCase && n.toLowerCase() === t.toLowerCase();
+  },
+  removeEmpty: function(n) {
+    for (var t = [], s = 0; s < n.length; s++)
+      n[s] && t.push(n[s]);
+    return t;
+  },
+  castInput: function(n) {
+    return n;
+  },
+  tokenize: function(n) {
+    return n.split("");
+  },
+  join: function(n) {
+    return n.join("");
+  }
+};
+function Cn(e, n, t, s, c) {
+  for (var l = 0, i = n.length, r = 0, a = 0; l < i; l++) {
+    var o = n[l];
+    if (o.removed) {
+      if (o.value = e.join(s.slice(a, a + o.count)), a += o.count, l && n[l - 1].added) {
+        var E = n[l - 1];
+        n[l - 1] = n[l], n[l] = E;
+      }
+    } else {
+      if (!o.added && c) {
+        var b = t.slice(r, r + o.count);
+        b = b.map(function(v, m) {
+          var d = s[a + m];
+          return d.length > v.length ? d : v;
+        }), o.value = e.join(b);
+      } else
+        o.value = e.join(t.slice(r, r + o.count));
+      r += o.count, o.added || (a += o.count);
+    }
+  }
+  var p = n[i - 1];
+  return i > 1 && typeof p.value == "string" && (p.added || p.removed) && e.equals("", p.value) && (n[i - 2].value += p.value, n.pop()), n;
+}
+function In(e) {
+  return {
+    newPos: e.newPos,
+    components: e.components.slice(0)
+  };
+}
+var kn = new j();
+function Bn(e, n, t) {
+  return kn.diff(e, n, t);
+}
+function $n(e, n) {
+  if (typeof e == "function")
+    n.callback = e;
+  else if (e)
+    for (var t in e)
+      e.hasOwnProperty(t) && (n[t] = e[t]);
+  return n;
+}
+var Je = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/, en = /\S/, ze = new j();
+ze.equals = function(e, n) {
+  return this.options.ignoreCase && (e = e.toLowerCase(), n = n.toLowerCase()), e === n || this.options.ignoreWhitespace && !en.test(e) && !en.test(n);
+};
+ze.tokenize = function(e) {
+  for (var n = e.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/), t = 0; t < n.length - 1; t++)
+    !n[t + 1] && n[t + 2] && Je.test(n[t]) && Je.test(n[t + 2]) && (n[t] += n[t + 2], n.splice(t + 1, 2), t--);
+  return n;
+};
+function Un(e, n, t) {
+  return t = $n(t, {
+    ignoreWhitespace: !0
+  }), ze.diff(e, n, t);
+}
+var Fe = new j();
+Fe.tokenize = function(e) {
+  var n = [], t = e.split(/(\n|\r\n)/);
+  t[t.length - 1] || t.pop();
+  for (var s = 0; s < t.length; s++) {
+    var c = t[s];
+    s % 2 && !this.options.newlineIsToken ? n[n.length - 1] += c : (this.options.ignoreWhitespace && (c = c.trim()), n.push(c));
+  }
+  return n;
+};
+function fn(e, n, t) {
+  return Fe.diff(e, n, t);
+}
+var Pn = new j();
+Pn.tokenize = function(e) {
+  return e.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var Hn = new j();
+Hn.tokenize = function(e) {
+  return e.split(/([{}:;,]|\s+)/);
+};
+function Me(e) {
+  return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? Me = function(n) {
+    return typeof n;
+  } : Me = function(n) {
+    return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+  }, Me(e);
+}
+var zn = Object.prototype.toString, pe = new j();
+pe.useLongestToken = !0;
+pe.tokenize = Fe.tokenize;
+pe.castInput = function(e) {
+  var n = this.options, t = n.undefinedReplacement, s = n.stringifyReplacer, c = s === void 0 ? function(l, i) {
+    return typeof i > "u" ? t : i;
+  } : s;
+  return typeof e == "string" ? e : JSON.stringify(Ue(e, null, null, c), c, "  ");
+};
+pe.equals = function(e, n) {
+  return j.prototype.equals.call(pe, e.replace(/,([\r\n])/g, "$1"), n.replace(/,([\r\n])/g, "$1"));
+};
+function Ue(e, n, t, s, c) {
+  n = n || [], t = t || [], s && (e = s(c, e));
+  var l;
+  for (l = 0; l < n.length; l += 1)
+    if (n[l] === e)
+      return t[l];
+  var i;
+  if (zn.call(e) === "[object Array]") {
+    for (n.push(e), i = new Array(e.length), t.push(i), l = 0; l < e.length; l += 1)
+      i[l] = Ue(e[l], n, t, s, c);
+    return n.pop(), t.pop(), i;
+  }
+  if (e && e.toJSON && (e = e.toJSON()), Me(e) === "object" && e !== null) {
+    n.push(e), i = {}, t.push(i);
+    var r = [], a;
+    for (a in e)
+      e.hasOwnProperty(a) && r.push(a);
+    for (r.sort(), l = 0; l < r.length; l += 1)
+      a = r[l], i[a] = Ue(e[a], n, t, s, a);
+    n.pop(), t.pop();
+  } else
+    i = e;
+  return i;
+}
+var Pe = new j();
+Pe.tokenize = function(e) {
+  return e.slice();
+};
+Pe.join = Pe.removeEmpty = function(e) {
+  return e;
+};
+var Ge = { exports: {} };
+function Ke(e) {
+  return e instanceof Map ? e.clear = e.delete = e.set = function() {
+    throw new Error("map is read-only");
+  } : e instanceof Set && (e.add = e.clear = e.delete = function() {
+    throw new Error("set is read-only");
+  }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach(function(n) {
+    var t = e[n];
+    typeof t == "object" && !Object.isFrozen(t) && Ke(t);
+  }), e;
+}
+Ge.exports = Ke;
+Ge.exports.default = Ke;
+class nn {
+  /**
+   * @param {CompiledMode} mode
+   */
+  constructor(n) {
+    n.data === void 0 && (n.data = {}), this.data = n.data, this.isMatchIgnored = !1;
+  }
+  ignoreMatch() {
+    this.isMatchIgnored = !0;
+  }
+}
+function dn(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function ne(e, ...n) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const s in e)
+    t[s] = e[s];
+  return n.forEach(function(s) {
+    for (const c in s)
+      t[c] = s[c];
+  }), /** @type {T} */
+  t;
+}
+const Fn = "</span>", tn = (e) => !!e.scope || e.sublanguage && e.language, Gn = (e, { prefix: n }) => {
+  if (e.includes(".")) {
+    const t = e.split(".");
+    return [
+      `${n}${t.shift()}`,
+      ...t.map((s, c) => `${s}${"_".repeat(c + 1)}`)
+    ].join(" ");
+  }
+  return `${n}${e}`;
+};
+class Kn {
+  /**
+   * Creates a new HTMLRenderer
+   *
+   * @param {Tree} parseTree - the parse tree (must support `walk` API)
+   * @param {{classPrefix: string}} options
+   */
+  constructor(n, t) {
+    this.buffer = "", this.classPrefix = t.classPrefix, n.walk(this);
+  }
+  /**
+   * Adds texts to the output stream
+   *
+   * @param {string} text */
+  addText(n) {
+    this.buffer += dn(n);
+  }
+  /**
+   * Adds a node open to the output stream (if needed)
+   *
+   * @param {Node} node */
+  openNode(n) {
+    if (!tn(n))
+      return;
+    let t = "";
+    n.sublanguage ? t = `language-${n.language}` : t = Gn(n.scope, { prefix: this.classPrefix }), this.span(t);
+  }
+  /**
+   * Adds a node close to the output stream (if needed)
+   *
+   * @param {Node} node */
+  closeNode(n) {
+    tn(n) && (this.buffer += Fn);
+  }
+  /**
+   * returns the accumulated buffer
+  */
+  value() {
+    return this.buffer;
+  }
+  // helpers
+  /**
+   * Builds a span element
+   *
+   * @param {string} className */
+  span(n) {
+    this.buffer += `<span class="${n}">`;
+  }
+}
+const sn = (e = {}) => {
+  const n = { children: [] };
+  return Object.assign(n, e), n;
+};
+class We {
+  constructor() {
+    this.rootNode = sn(), this.stack = [this.rootNode];
+  }
+  get top() {
+    return this.stack[this.stack.length - 1];
+  }
+  get root() {
+    return this.rootNode;
+  }
+  /** @param {Node} node */
+  add(n) {
+    this.top.children.push(n);
+  }
+  /** @param {string} scope */
+  openNode(n) {
+    const t = sn({ scope: n });
+    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(n) {
+    return this.constructor._walk(n, this.rootNode);
+  }
+  /**
+   * @param {Renderer} builder
+   * @param {Node} node
+   */
+  static _walk(n, t) {
+    return typeof t == "string" ? n.addText(t) : t.children && (n.openNode(t), t.children.forEach((s) => this._walk(n, s)), n.closeNode(t)), n;
+  }
+  /**
+   * @param {Node} node
+   */
+  static _collapse(n) {
+    typeof n != "string" && n.children && (n.children.every((t) => typeof t == "string") ? n.children = [n.children.join("")] : n.children.forEach((t) => {
+      We._collapse(t);
+    }));
+  }
+}
+class Wn extends We {
+  /**
+   * @param {*} options
+   */
+  constructor(n) {
+    super(), this.options = n;
+  }
+  /**
+   * @param {string} text
+   * @param {string} scope
+   */
+  addKeyword(n, t) {
+    n !== "" && (this.openNode(t), this.addText(n), this.closeNode());
+  }
+  /**
+   * @param {string} text
+   */
+  addText(n) {
+    n !== "" && this.add(n);
+  }
+  /**
+   * @param {Emitter & {root: DataNode}} emitter
+   * @param {string} name
+   */
+  addSublanguage(n, t) {
+    const s = n.root;
+    s.sublanguage = !0, s.language = t, this.add(s);
+  }
+  toHTML() {
+    return new Kn(this, this.options).value();
+  }
+  finalize() {
+    return !0;
+  }
+}
+function be(e) {
+  return e ? typeof e == "string" ? e : e.source : null;
+}
+function gn(e) {
+  return ie("(?=", e, ")");
+}
+function Yn(e) {
+  return ie("(?:", e, ")*");
+}
+function Zn(e) {
+  return ie("(?:", e, ")?");
+}
+function ie(...e) {
+  return e.map((t) => be(t)).join("");
+}
+function Qn(e) {
+  const n = e[e.length - 1];
+  return typeof n == "object" && n.constructor === Object ? (e.splice(e.length - 1, 1), n) : {};
+}
+function Ye(...e) {
+  return "(" + (Qn(e).capture ? "" : "?:") + e.map((s) => be(s)).join("|") + ")";
+}
+function pn(e) {
+  return new RegExp(e.toString() + "|").exec("").length - 1;
+}
+function qn(e, n) {
+  const t = e && e.exec(n);
+  return t && t.index === 0;
+}
+const Xn = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+function Ze(e, { joinWith: n }) {
+  let t = 0;
+  return e.map((s) => {
+    t += 1;
+    const c = t;
+    let l = be(s), i = "";
+    for (; l.length > 0; ) {
+      const r = Xn.exec(l);
+      if (!r) {
+        i += l;
+        break;
+      }
+      i += l.substring(0, r.index), l = l.substring(r.index + r[0].length), r[0][0] === "\\" && r[1] ? i += "\\" + String(Number(r[1]) + c) : (i += r[0], r[0] === "(" && t++);
+    }
+    return i;
+  }).map((s) => `(${s})`).join(n);
+}
+const Vn = /\b\B/, bn = "[a-zA-Z]\\w*", Qe = "[a-zA-Z_]\\w*", hn = "\\b\\d+(\\.\\d+)?", En = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", _n = "\\b(0b[01]+)", jn = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Jn = (e = {}) => {
+  const n = /^#![ ]*\//;
+  return e.binary && (e.begin = ie(
+    n,
+    /.*\b/,
+    e.binary,
+    /\b.*/
+  )), ne({
+    scope: "meta",
+    begin: n,
+    end: /$/,
+    relevance: 0,
+    /** @type {ModeCallback} */
+    "on:begin": (t, s) => {
+      t.index !== 0 && s.ignoreMatch();
+    }
+  }, e);
+}, he = {
+  begin: "\\\\[\\s\\S]",
+  relevance: 0
+}, et = {
+  scope: "string",
+  begin: "'",
+  end: "'",
+  illegal: "\\n",
+  contains: [he]
+}, nt = {
+  scope: "string",
+  begin: '"',
+  end: '"',
+  illegal: "\\n",
+  contains: [he]
+}, tt = {
+  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/
+}, Le = function(e, n, t = {}) {
+  const s = ne(
+    {
+      scope: "comment",
+      begin: e,
+      end: n,
+      contains: []
+    },
+    t
+  );
+  s.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 c = Ye(
+    // 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 s.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: ie(
+        /[ ]+/,
+        // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+        "(",
+        c,
+        /[.]?[:]?([.][ ]|[ ])/,
+        "){3}"
+      )
+      // look for 3 words in a row
+    }
+  ), s;
+}, st = Le("//", "$"), it = Le("/\\*", "\\*/"), rt = Le("#", "$"), at = {
+  scope: "number",
+  begin: hn,
+  relevance: 0
+}, ot = {
+  scope: "number",
+  begin: En,
+  relevance: 0
+}, ct = {
+  scope: "number",
+  begin: _n,
+  relevance: 0
+}, lt = {
+  // this outer rule makes sure we actually have a WHOLE regex and not simply
+  // an expression such as:
+  //
+  //     3 / something
+  //
+  // (which will then blow up when regex's `illegal` sees the newline)
+  begin: /(?=\/[^/\n]*\/)/,
+  contains: [{
+    scope: "regexp",
+    begin: /\//,
+    end: /\/[gimuy]*/,
+    illegal: /\n/,
+    contains: [
+      he,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [he]
+      }
+    ]
+  }]
+}, ut = {
+  scope: "title",
+  begin: bn,
+  relevance: 0
+}, ft = {
+  scope: "title",
+  begin: Qe,
+  relevance: 0
+}, dt = {
+  // excludes method names from keyword processing
+  begin: "\\.\\s*" + Qe,
+  relevance: 0
+}, gt = function(e) {
+  return Object.assign(
+    e,
+    {
+      /** @type {ModeCallback} */
+      "on:begin": (n, t) => {
+        t.data._beginMatch = n[1];
+      },
+      /** @type {ModeCallback} */
+      "on:end": (n, t) => {
+        t.data._beginMatch !== n[1] && t.ignoreMatch();
+      }
+    }
+  );
+};
+var Te = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  MATCH_NOTHING_RE: Vn,
+  IDENT_RE: bn,
+  UNDERSCORE_IDENT_RE: Qe,
+  NUMBER_RE: hn,
+  C_NUMBER_RE: En,
+  BINARY_NUMBER_RE: _n,
+  RE_STARTERS_RE: jn,
+  SHEBANG: Jn,
+  BACKSLASH_ESCAPE: he,
+  APOS_STRING_MODE: et,
+  QUOTE_STRING_MODE: nt,
+  PHRASAL_WORDS_MODE: tt,
+  COMMENT: Le,
+  C_LINE_COMMENT_MODE: st,
+  C_BLOCK_COMMENT_MODE: it,
+  HASH_COMMENT_MODE: rt,
+  NUMBER_MODE: at,
+  C_NUMBER_MODE: ot,
+  BINARY_NUMBER_MODE: ct,
+  REGEXP_MODE: lt,
+  TITLE_MODE: ut,
+  UNDERSCORE_TITLE_MODE: ft,
+  METHOD_GUARD: dt,
+  END_SAME_AS_BEGIN: gt
+});
+function pt(e, n) {
+  e.input[e.index - 1] === "." && n.ignoreMatch();
+}
+function bt(e, n) {
+  e.className !== void 0 && (e.scope = e.className, delete e.className);
+}
+function ht(e, n) {
+  n && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = pt, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+}
+function Et(e, n) {
+  Array.isArray(e.illegal) && (e.illegal = Ye(...e.illegal));
+}
+function _t(e, n) {
+  if (e.match) {
+    if (e.begin || e.end)
+      throw new Error("begin & end are not supported with match");
+    e.begin = e.match, delete e.match;
+  }
+}
+function mt(e, n) {
+  e.relevance === void 0 && (e.relevance = 1);
+}
+const yt = (e, n) => {
+  if (!e.beforeMatch)
+    return;
+  if (e.starts)
+    throw new Error("beforeMatch cannot be used with starts");
+  const t = Object.assign({}, e);
+  Object.keys(e).forEach((s) => {
+    delete e[s];
+  }), e.keywords = t.keywords, e.begin = ie(t.beforeMatch, gn(t.begin)), e.starts = {
+    relevance: 0,
+    contains: [
+      Object.assign(t, { endsParent: !0 })
+    ]
+  }, e.relevance = 0, delete t.beforeMatch;
+}, Nt = [
+  "of",
+  "and",
+  "for",
+  "in",
+  "not",
+  "or",
+  "if",
+  "then",
+  "parent",
+  // common variable name
+  "list",
+  // common variable name
+  "value"
+  // common variable name
+], At = "keyword";
+function mn(e, n, t = At) {
+  const s = /* @__PURE__ */ Object.create(null);
+  return typeof e == "string" ? c(t, e.split(" ")) : Array.isArray(e) ? c(t, e) : Object.keys(e).forEach(function(l) {
+    Object.assign(
+      s,
+      mn(e[l], n, l)
+    );
+  }), s;
+  function c(l, i) {
+    n && (i = i.map((r) => r.toLowerCase())), i.forEach(function(r) {
+      const a = r.split("|");
+      s[a[0]] = [l, vt(a[0], a[1])];
+    });
+  }
+}
+function vt(e, n) {
+  return n ? Number(n) : Tt(e) ? 0 : 1;
+}
+function Tt(e) {
+  return Nt.includes(e.toLowerCase());
+}
+const rn = {}, se = (e) => {
+  console.error(e);
+}, an = (e, ...n) => {
+  console.log(`WARN: ${e}`, ...n);
+}, ce = (e, n) => {
+  rn[`${e}/${n}`] || (console.log(`Deprecated as of ${e}. ${n}`), rn[`${e}/${n}`] = !0);
+}, Oe = new Error();
+function yn(e, n, { key: t }) {
+  let s = 0;
+  const c = e[t], l = {}, i = {};
+  for (let r = 1; r <= n.length; r++)
+    i[r + s] = c[r], l[r + s] = !0, s += pn(n[r - 1]);
+  e[t] = i, e[t]._emit = l, e[t]._multi = !0;
+}
+function wt(e) {
+  if (Array.isArray(e.begin)) {
+    if (e.skip || e.excludeBegin || e.returnBegin)
+      throw se("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), Oe;
+    if (typeof e.beginScope != "object" || e.beginScope === null)
+      throw se("beginScope must be object"), Oe;
+    yn(e, e.begin, { key: "beginScope" }), e.begin = Ze(e.begin, { joinWith: "" });
+  }
+}
+function St(e) {
+  if (Array.isArray(e.end)) {
+    if (e.skip || e.excludeEnd || e.returnEnd)
+      throw se("skip, excludeEnd, returnEnd not compatible with endScope: {}"), Oe;
+    if (typeof e.endScope != "object" || e.endScope === null)
+      throw se("endScope must be object"), Oe;
+    yn(e, e.end, { key: "endScope" }), e.end = Ze(e.end, { joinWith: "" });
+  }
+}
+function Mt(e) {
+  e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+}
+function Rt(e) {
+  Mt(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), wt(e), St(e);
+}
+function Ot(e) {
+  function n(i, r) {
+    return new RegExp(
+      be(i),
+      "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (r ? "g" : "")
+    );
+  }
+  class t {
+    constructor() {
+      this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+    }
+    // @ts-ignore
+    addRule(r, a) {
+      a.position = this.position++, this.matchIndexes[this.matchAt] = a, this.regexes.push([a, r]), this.matchAt += pn(r) + 1;
+    }
+    compile() {
+      this.regexes.length === 0 && (this.exec = () => null);
+      const r = this.regexes.map((a) => a[1]);
+      this.matcherRe = n(Ze(r, { joinWith: "|" }), !0), this.lastIndex = 0;
+    }
+    /** @param {string} s */
+    exec(r) {
+      this.matcherRe.lastIndex = this.lastIndex;
+      const a = this.matcherRe.exec(r);
+      if (!a)
+        return null;
+      const o = a.findIndex((E, p) => p > 0 && E !== void 0), b = this.matchIndexes[o];
+      return a.splice(0, o), Object.assign(a, b);
+    }
+  }
+  class s {
+    constructor() {
+      this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+    }
+    // @ts-ignore
+    getMatcher(r) {
+      if (this.multiRegexes[r])
+        return this.multiRegexes[r];
+      const a = new t();
+      return this.rules.slice(r).forEach(([o, b]) => a.addRule(o, b)), a.compile(), this.multiRegexes[r] = a, a;
+    }
+    resumingScanAtSamePosition() {
+      return this.regexIndex !== 0;
+    }
+    considerAll() {
+      this.regexIndex = 0;
+    }
+    // @ts-ignore
+    addRule(r, a) {
+      this.rules.push([r, a]), a.type === "begin" && this.count++;
+    }
+    /** @param {string} s */
+    exec(r) {
+      const a = this.getMatcher(this.regexIndex);
+      a.lastIndex = this.lastIndex;
+      let o = a.exec(r);
+      if (this.resumingScanAtSamePosition() && !(o && o.index === this.lastIndex)) {
+        const b = this.getMatcher(0);
+        b.lastIndex = this.lastIndex + 1, o = b.exec(r);
+      }
+      return o && (this.regexIndex += o.position + 1, this.regexIndex === this.count && this.considerAll()), o;
+    }
+  }
+  function c(i) {
+    const r = new s();
+    return i.contains.forEach((a) => r.addRule(a.begin, { rule: a, type: "begin" })), i.terminatorEnd && r.addRule(i.terminatorEnd, { type: "end" }), i.illegal && r.addRule(i.illegal, { type: "illegal" }), r;
+  }
+  function l(i, r) {
+    const a = (
+      /** @type CompiledMode */
+      i
+    );
+    if (i.isCompiled)
+      return a;
+    [
+      bt,
+      // do this early so compiler extensions generally don't have to worry about
+      // the distinction between match/begin
+      _t,
+      Rt,
+      yt
+    ].forEach((b) => b(i, r)), e.compilerExtensions.forEach((b) => b(i, r)), i.__beforeBegin = null, [
+      ht,
+      // do this later so compiler extensions that come earlier have access to the
+      // raw array if they wanted to perhaps manipulate it, etc.
+      Et,
+      // default to 1 relevance if not specified
+      mt
+    ].forEach((b) => b(i, r)), i.isCompiled = !0;
+    let o = null;
+    return typeof i.keywords == "object" && i.keywords.$pattern && (i.keywords = Object.assign({}, i.keywords), o = i.keywords.$pattern, delete i.keywords.$pattern), o = o || /\w+/, i.keywords && (i.keywords = mn(i.keywords, e.case_insensitive)), a.keywordPatternRe = n(o, !0), r && (i.begin || (i.begin = /\B|\b/), a.beginRe = n(a.begin), !i.end && !i.endsWithParent && (i.end = /\B|\b/), i.end && (a.endRe = n(a.end)), a.terminatorEnd = be(a.end) || "", i.endsWithParent && r.terminatorEnd && (a.terminatorEnd += (i.end ? "|" : "") + r.terminatorEnd)), i.illegal && (a.illegalRe = n(
+      /** @type {RegExp | string} */
+      i.illegal
+    )), i.contains || (i.contains = []), i.contains = [].concat(...i.contains.map(function(b) {
+      return xt(b === "self" ? i : b);
+    })), i.contains.forEach(function(b) {
+      l(
+        /** @type Mode */
+        b,
+        a
+      );
+    }), i.starts && l(i.starts, r), a.matcher = c(a), a;
+  }
+  if (e.compilerExtensions || (e.compilerExtensions = []), e.contains && e.contains.includes("self"))
+    throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+  return e.classNameAliases = ne(e.classNameAliases || {}), l(
+    /** @type Mode */
+    e
+  );
+}
+function Nn(e) {
+  return e ? e.endsWithParent || Nn(e.starts) : !1;
+}
+function xt(e) {
+  return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(n) {
+    return ne(e, { variants: null }, n);
+  })), e.cachedVariants ? e.cachedVariants : Nn(e) ? ne(e, { starts: e.starts ? ne(e.starts) : null }) : Object.isFrozen(e) ? ne(e) : e;
+}
+var Lt = "11.7.0";
+class Dt extends Error {
+  constructor(n, t) {
+    super(n), this.name = "HTMLInjectionError", this.html = t;
+  }
+}
+const Be = dn, on = ne, cn = Symbol("nomatch"), Ct = 7, It = function(e) {
+  const n = /* @__PURE__ */ Object.create(null), t = /* @__PURE__ */ Object.create(null), s = [];
+  let c = !0;
+  const l = "Could not find the language '{}', did you forget to load/include a language module?", i = { disableAutodetect: !0, name: "Plain text", contains: [] };
+  let r = {
+    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: Wn
+  };
+  function a(u) {
+    return r.noHighlightRe.test(u);
+  }
+  function o(u) {
+    let h = u.className + " ";
+    h += u.parentNode ? u.parentNode.className : "";
+    const A = r.languageDetectRe.exec(h);
+    if (A) {
+      const M = W(A[1]);
+      return M || (an(l.replace("{}", A[1])), an("Falling back to no-highlight mode for this block.", u)), M ? A[1] : "no-highlight";
+    }
+    return h.split(/\s+/).find((M) => a(M) || W(M));
+  }
+  function b(u, h, A) {
+    let M = "", I = "";
+    typeof h == "object" ? (M = u, A = h.ignoreIllegals, I = h.language) : (ce("10.7.0", "highlight(lang, code, ...args) has been deprecated."), ce("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), I = u, M = h), A === void 0 && (A = !0);
+    const z = {
+      code: M,
+      language: I
+    };
+    oe("before:highlight", z);
+    const Q = z.result ? z.result : E(z.language, z.code, A);
+    return Q.code = z.code, oe("after:highlight", Q), Q;
+  }
+  function E(u, h, A, M) {
+    const I = /* @__PURE__ */ Object.create(null);
+    function z(f, _) {
+      return f.keywords[_];
+    }
+    function Q() {
+      if (!N.keywords) {
+        U.addText(C);
+        return;
+      }
+      let f = 0;
+      N.keywordPatternRe.lastIndex = 0;
+      let _ = N.keywordPatternRe.exec(C), w = "";
+      for (; _; ) {
+        w += C.substring(f, _.index);
+        const O = ee.case_insensitive ? _[0].toLowerCase() : _[0], H = z(N, O);
+        if (H) {
+          const [q, Ln] = H;
+          if (U.addText(w), w = "", I[O] = (I[O] || 0) + 1, I[O] <= Ct && (Ae += Ln), q.startsWith("_"))
+            w += _[0];
+          else {
+            const Dn = ee.classNameAliases[q] || q;
+            U.addKeyword(_[0], Dn);
+          }
+        } else
+          w += _[0];
+        f = N.keywordPatternRe.lastIndex, _ = N.keywordPatternRe.exec(C);
+      }
+      w += C.substring(f), U.addText(w);
+    }
+    function ye() {
+      if (C === "")
+        return;
+      let f = null;
+      if (typeof N.subLanguage == "string") {
+        if (!n[N.subLanguage]) {
+          U.addText(C);
+          return;
+        }
+        f = E(N.subLanguage, C, !0, je[N.subLanguage]), je[N.subLanguage] = /** @type {CompiledMode} */
+        f._top;
+      } else
+        f = v(C, N.subLanguage.length ? N.subLanguage : null);
+      N.relevance > 0 && (Ae += f.relevance), U.addSublanguage(f._emitter, f.language);
+    }
+    function F() {
+      N.subLanguage != null ? ye() : Q(), C = "";
+    }
+    function J(f, _) {
+      let w = 1;
+      const O = _.length - 1;
+      for (; w <= O; ) {
+        if (!f._emit[w]) {
+          w++;
+          continue;
+        }
+        const H = ee.classNameAliases[f[w]] || f[w], q = _[w];
+        H ? U.addKeyword(q, H) : (C = q, Q(), C = ""), w++;
+      }
+    }
+    function qe(f, _) {
+      return f.scope && typeof f.scope == "string" && U.openNode(ee.classNameAliases[f.scope] || f.scope), f.beginScope && (f.beginScope._wrap ? (U.addKeyword(C, ee.classNameAliases[f.beginScope._wrap] || f.beginScope._wrap), C = "") : f.beginScope._multi && (J(f.beginScope, _), C = "")), N = Object.create(f, { parent: { value: N } }), N;
+    }
+    function Xe(f, _, w) {
+      let O = qn(f.endRe, w);
+      if (O) {
+        if (f["on:end"]) {
+          const H = new nn(f);
+          f["on:end"](_, H), H.isMatchIgnored && (O = !1);
+        }
+        if (O) {
+          for (; f.endsParent && f.parent; )
+            f = f.parent;
+          return f;
+        }
+      }
+      if (f.endsWithParent)
+        return Xe(f.parent, _, w);
+    }
+    function Sn(f) {
+      return N.matcher.regexIndex === 0 ? (C += f[0], 1) : (ke = !0, 0);
+    }
+    function Mn(f) {
+      const _ = f[0], w = f.rule, O = new nn(w), H = [w.__beforeBegin, w["on:begin"]];
+      for (const q of H)
+        if (q && (q(f, O), O.isMatchIgnored))
+          return Sn(_);
+      return w.skip ? C += _ : (w.excludeBegin && (C += _), F(), !w.returnBegin && !w.excludeBegin && (C = _)), qe(w, f), w.returnBegin ? 0 : _.length;
+    }
+    function Rn(f) {
+      const _ = f[0], w = h.substring(f.index), O = Xe(N, f, w);
+      if (!O)
+        return cn;
+      const H = N;
+      N.endScope && N.endScope._wrap ? (F(), U.addKeyword(_, N.endScope._wrap)) : N.endScope && N.endScope._multi ? (F(), J(N.endScope, f)) : H.skip ? C += _ : (H.returnEnd || H.excludeEnd || (C += _), F(), H.excludeEnd && (C = _));
+      do
+        N.scope && U.closeNode(), !N.skip && !N.subLanguage && (Ae += N.relevance), N = N.parent;
+      while (N !== O.parent);
+      return O.starts && qe(O.starts, f), H.returnEnd ? 0 : _.length;
+    }
+    function On() {
+      const f = [];
+      for (let _ = N; _ !== ee; _ = _.parent)
+        _.scope && f.unshift(_.scope);
+      f.forEach((_) => U.openNode(_));
+    }
+    let Ne = {};
+    function Ve(f, _) {
+      const w = _ && _[0];
+      if (C += f, w == null)
+        return F(), 0;
+      if (Ne.type === "begin" && _.type === "end" && Ne.index === _.index && w === "") {
+        if (C += h.slice(_.index, _.index + 1), !c) {
+          const O = new Error(`0 width match regex (${u})`);
+          throw O.languageName = u, O.badRule = Ne.rule, O;
+        }
+        return 1;
+      }
+      if (Ne = _, _.type === "begin")
+        return Mn(_);
+      if (_.type === "illegal" && !A) {
+        const O = new Error('Illegal lexeme "' + w + '" for mode "' + (N.scope || "<unnamed>") + '"');
+        throw O.mode = N, O;
+      } else if (_.type === "end") {
+        const O = Rn(_);
+        if (O !== cn)
+          return O;
+      }
+      if (_.type === "illegal" && w === "")
+        return 1;
+      if (Ie > 1e5 && Ie > _.index * 3)
+        throw new Error("potential infinite loop, way more iterations than matches");
+      return C += w, w.length;
+    }
+    const ee = W(u);
+    if (!ee)
+      throw se(l.replace("{}", u)), new Error('Unknown language: "' + u + '"');
+    const xn = Ot(ee);
+    let Ce = "", N = M || xn;
+    const je = {}, U = new r.__emitter(r);
+    On();
+    let C = "", Ae = 0, te = 0, Ie = 0, ke = !1;
+    try {
+      for (N.matcher.considerAll(); ; ) {
+        Ie++, ke ? ke = !1 : N.matcher.considerAll(), N.matcher.lastIndex = te;
+        const f = N.matcher.exec(h);
+        if (!f)
+          break;
+        const _ = h.substring(te, f.index), w = Ve(_, f);
+        te = f.index + w;
+      }
+      return Ve(h.substring(te)), U.closeAllNodes(), U.finalize(), Ce = U.toHTML(), {
+        language: u,
+        value: Ce,
+        relevance: Ae,
+        illegal: !1,
+        _emitter: U,
+        _top: N
+      };
+    } catch (f) {
+      if (f.message && f.message.includes("Illegal"))
+        return {
+          language: u,
+          value: Be(h),
+          illegal: !0,
+          relevance: 0,
+          _illegalBy: {
+            message: f.message,
+            index: te,
+            context: h.slice(te - 100, te + 100),
+            mode: f.mode,
+            resultSoFar: Ce
+          },
+          _emitter: U
+        };
+      if (c)
+        return {
+          language: u,
+          value: Be(h),
+          illegal: !1,
+          relevance: 0,
+          errorRaised: f,
+          _emitter: U,
+          _top: N
+        };
+      throw f;
+    }
+  }
+  function p(u) {
+    const h = {
+      value: Be(u),
+      illegal: !1,
+      relevance: 0,
+      _top: i,
+      _emitter: new r.__emitter(r)
+    };
+    return h._emitter.addText(u), h;
+  }
+  function v(u, h) {
+    h = h || r.languages || Object.keys(n);
+    const A = p(u), M = h.filter(W).filter(ae).map(
+      (F) => E(F, u, !1)
+    );
+    M.unshift(A);
+    const I = M.sort((F, J) => {
+      if (F.relevance !== J.relevance)
+        return J.relevance - F.relevance;
+      if (F.language && J.language) {
+        if (W(F.language).supersetOf === J.language)
+          return 1;
+        if (W(J.language).supersetOf === F.language)
+          return -1;
+      }
+      return 0;
+    }), [z, Q] = I, ye = z;
+    return ye.secondBest = Q, ye;
+  }
+  function m(u, h, A) {
+    const M = h && t[h] || A;
+    u.classList.add("hljs"), u.classList.add(`language-${M}`);
+  }
+  function d(u) {
+    let h = null;
+    const A = o(u);
+    if (a(A))
+      return;
+    if (oe(
+      "before:highlightElement",
+      { el: u, language: A }
+    ), u.children.length > 0 && (r.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(u)), r.throwUnescapedHTML))
+      throw new Dt(
+        "One of your code blocks includes unescaped HTML.",
+        u.innerHTML
+      );
+    h = u;
+    const M = h.textContent, I = A ? b(M, { language: A, ignoreIllegals: !0 }) : v(M);
+    u.innerHTML = I.value, m(u, A, I.language), u.result = {
+      language: I.language,
+      // TODO: remove with version 11.0
+      re: I.relevance,
+      relevance: I.relevance
+    }, I.secondBest && (u.secondBest = {
+      language: I.secondBest.language,
+      relevance: I.secondBest.relevance
+    }), oe("after:highlightElement", { el: u, result: I, text: M });
+  }
+  function T(u) {
+    r = on(r, u);
+  }
+  const S = () => {
+    R(), ce("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+  };
+  function x() {
+    R(), ce("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+  }
+  let y = !1;
+  function R() {
+    if (document.readyState === "loading") {
+      y = !0;
+      return;
+    }
+    document.querySelectorAll(r.cssSelector).forEach(d);
+  }
+  function L() {
+    y && R();
+  }
+  typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", L, !1);
+  function D(u, h) {
+    let A = null;
+    try {
+      A = h(e);
+    } catch (M) {
+      if (se("Language definition for '{}' could not be registered.".replace("{}", u)), c)
+        se(M);
+      else
+        throw M;
+      A = i;
+    }
+    A.name || (A.name = u), n[u] = A, A.rawDefinition = h.bind(null, e), A.aliases && re(A.aliases, { languageName: u });
+  }
+  function B(u) {
+    delete n[u];
+    for (const h of Object.keys(t))
+      t[h] === u && delete t[h];
+  }
+  function K() {
+    return Object.keys(n);
+  }
+  function W(u) {
+    return u = (u || "").toLowerCase(), n[u] || n[t[u]];
+  }
+  function re(u, { languageName: h }) {
+    typeof u == "string" && (u = [u]), u.forEach((A) => {
+      t[A.toLowerCase()] = h;
+    });
+  }
+  function ae(u) {
+    const h = W(u);
+    return h && !h.disableAutodetect;
+  }
+  function de(u) {
+    u["before:highlightBlock"] && !u["before:highlightElement"] && (u["before:highlightElement"] = (h) => {
+      u["before:highlightBlock"](
+        Object.assign({ block: h.el }, h)
+      );
+    }), u["after:highlightBlock"] && !u["after:highlightElement"] && (u["after:highlightElement"] = (h) => {
+      u["after:highlightBlock"](
+        Object.assign({ block: h.el }, h)
+      );
+    });
+  }
+  function De(u) {
+    de(u), s.push(u);
+  }
+  function oe(u, h) {
+    const A = u;
+    s.forEach(function(M) {
+      M[A] && M[A](h);
+    });
+  }
+  function me(u) {
+    return ce("10.7.0", "highlightBlock will be removed entirely in v12.0"), ce("10.7.0", "Please use highlightElement now."), d(u);
+  }
+  Object.assign(e, {
+    highlight: b,
+    highlightAuto: v,
+    highlightAll: R,
+    highlightElement: d,
+    // TODO: Remove with v12 API
+    highlightBlock: me,
+    configure: T,
+    initHighlighting: S,
+    initHighlightingOnLoad: x,
+    registerLanguage: D,
+    unregisterLanguage: B,
+    listLanguages: K,
+    getLanguage: W,
+    registerAliases: re,
+    autoDetection: ae,
+    inherit: on,
+    addPlugin: De
+  }), e.debugMode = function() {
+    c = !1;
+  }, e.safeMode = function() {
+    c = !0;
+  }, e.versionString = Lt, e.regex = {
+    concat: ie,
+    lookahead: gn,
+    either: Ye,
+    optional: Zn,
+    anyNumberOfTimes: Yn
+  };
+  for (const u in Te)
+    typeof Te[u] == "object" && Ge.exports(Te[u]);
+  return Object.assign(e, Te), e;
+};
+var Ee = It({}), kt = Ee;
+Ee.HighlightJS = Ee;
+Ee.default = Ee;
+const Z = kt;
+function Bt(e) {
+  const n = e.regex, t = n.concat(/[\p{L}_]/u, n.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u), s = /[\p{L}0-9._:-]+/u, c = {
+    className: "symbol",
+    begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
+  }, l = {
+    begin: /\s/,
+    contains: [
+      {
+        className: "keyword",
+        begin: /#?[a-z_][a-z1-9_-]+/,
+        illegal: /\n/
+      }
+    ]
+  }, i = e.inherit(l, {
+    begin: /\(/,
+    end: /\)/
+  }), r = e.inherit(e.APOS_STRING_MODE, { className: "string" }), a = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }), o = {
+    endsWithParent: !0,
+    illegal: /</,
+    relevance: 0,
+    contains: [
+      {
+        className: "attr",
+        begin: s,
+        relevance: 0
+      },
+      {
+        begin: /=\s*/,
+        relevance: 0,
+        contains: [
+          {
+            className: "string",
+            endsParent: !0,
+            variants: [
+              {
+                begin: /"/,
+                end: /"/,
+                contains: [c]
+              },
+              {
+                begin: /'/,
+                end: /'/,
+                contains: [c]
+              },
+              { begin: /[^\s"'=<>`]+/ }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+  return {
+    name: "HTML, XML",
+    aliases: [
+      "html",
+      "xhtml",
+      "rss",
+      "atom",
+      "xjb",
+      "xsd",
+      "xsl",
+      "plist",
+      "wsf",
+      "svg"
+    ],
+    case_insensitive: !0,
+    unicodeRegex: !0,
+    contains: [
+      {
+        className: "meta",
+        begin: /<![a-z]/,
+        end: />/,
+        relevance: 10,
+        contains: [
+          l,
+          a,
+          r,
+          i,
+          {
+            begin: /\[/,
+            end: /\]/,
+            contains: [
+              {
+                className: "meta",
+                begin: /<![a-z]/,
+                end: />/,
+                contains: [
+                  l,
+                  i,
+                  a,
+                  r
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      e.COMMENT(
+        /<!--/,
+        /-->/,
+        { relevance: 10 }
+      ),
+      {
+        begin: /<!\[CDATA\[/,
+        end: /\]\]>/,
+        relevance: 10
+      },
+      c,
+      // xml processing instructions
+      {
+        className: "meta",
+        end: /\?>/,
+        variants: [
+          {
+            begin: /<\?xml/,
+            relevance: 10,
+            contains: [
+              a
+            ]
+          },
+          {
+            begin: /<\?[a-z][a-z0-9]+/
+          }
+        ]
+      },
+      {
+        className: "tag",
+        /*
+        The lookahead pattern (?=...) ensures that 'begin' only matches
+        '<style' as a single word, followed by a whitespace or an
+        ending bracket.
+        */
+        begin: /<style(?=\s|>)/,
+        end: />/,
+        keywords: { name: "style" },
+        contains: [o],
+        starts: {
+          end: /<\/style>/,
+          returnEnd: !0,
+          subLanguage: [
+            "css",
+            "xml"
+          ]
+        }
+      },
+      {
+        className: "tag",
+        // See the comment in the <style tag about the lookahead pattern
+        begin: /<script(?=\s|>)/,
+        end: />/,
+        keywords: { name: "script" },
+        contains: [o],
+        starts: {
+          end: /<\/script>/,
+          returnEnd: !0,
+          subLanguage: [
+            "javascript",
+            "handlebars",
+            "xml"
+          ]
+        }
+      },
+      // we need this for now for jSX
+      {
+        className: "tag",
+        begin: /<>|<\/>/
+      },
+      // open tag
+      {
+        className: "tag",
+        begin: n.concat(
+          /</,
+          n.lookahead(n.concat(
+            t,
+            // <tag/>
+            // <tag>
+            // <tag ...
+            n.either(/\/>/, />/, /\s/)
+          ))
+        ),
+        end: /\/?>/,
+        contains: [
+          {
+            className: "name",
+            begin: t,
+            relevance: 0,
+            starts: o
+          }
+        ]
+      },
+      // close tag
+      {
+        className: "tag",
+        begin: n.concat(
+          /<\//,
+          n.lookahead(n.concat(
+            t,
+            />/
+          ))
+        ),
+        contains: [
+          {
+            className: "name",
+            begin: t,
+            relevance: 0
+          },
+          {
+            begin: />/,
+            relevance: 0,
+            endsParent: !0
+          }
+        ]
+      }
+    ]
+  };
+}
+const ln = "[A-Za-z$_][0-9A-Za-z$_]*", $t = [
+  "as",
+  // for exports
+  "in",
+  "of",
+  "if",
+  "for",
+  "while",
+  "finally",
+  "var",
+  "new",
+  "function",
+  "do",
+  "return",
+  "void",
+  "else",
+  "break",
+  "catch",
+  "instanceof",
+  "with",
+  "throw",
+  "case",
+  "default",
+  "try",
+  "switch",
+  "continue",
+  "typeof",
+  "delete",
+  "let",
+  "yield",
+  "const",
+  "class",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends"
+], Ut = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], An = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+], vn = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], Tn = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], Pt = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "module",
+  "global"
+  // Node.js
+], Ht = [].concat(
+  Tn,
+  An,
+  vn
+);
+function zt(e) {
+  const n = e.regex, t = (h, { after: A }) => {
+    const M = "</" + h[0].slice(1);
+    return h.input.indexOf(M, A) !== -1;
+  }, s = ln, c = {
+    begin: "<>",
+    end: "</>"
+  }, l = /<[A-Za-z0-9\\._:-]+\s*\/>/, i = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (h, A) => {
+      const M = h[0].length + h.index, I = h.input[M];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        I === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        I === ","
+      ) {
+        A.ignoreMatch();
+        return;
+      }
+      I === ">" && (t(h, { after: M }) || A.ignoreMatch());
+      let z;
+      const Q = h.input.substring(M);
+      if (z = Q.match(/^\s*=/)) {
+        A.ignoreMatch();
+        return;
+      }
+      if ((z = Q.match(/^\s+extends\s+/)) && z.index === 0) {
+        A.ignoreMatch();
+        return;
+      }
+    }
+  }, r = {
+    $pattern: ln,
+    keyword: $t,
+    literal: Ut,
+    built_in: Ht,
+    "variable.language": Pt
+  }, a = "[0-9](_?[0-9])*", o = `\\.(${a})`, b = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", E = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${b})((${o})|\\.)?|(${o}))[eE][+-]?(${a})\\b` },
+      { begin: `\\b(${b})\\b((${o})\\b|\\.)?|(${o})\\b` },
+      // DecimalBigIntegerLiteral
+      { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+      // NonDecimalIntegerLiteral
+      { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+      { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+      { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" }
+    ],
+    relevance: 0
+  }, p = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: r,
+    contains: []
+    // defined later
+  }, v = {
+    begin: "html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        p
+      ],
+      subLanguage: "xml"
+    }
+  }, m = {
+    begin: "css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        p
+      ],
+      subLanguage: "css"
+    }
+  }, d = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      p
+    ]
+  }, S = {
+    className: "comment",
+    variants: [
+      e.COMMENT(
+        /\/\*\*(?!\/)/,
+        "\\*/",
+        {
+          relevance: 0,
+          contains: [
+            {
+              begin: "(?=@[A-Za-z]+)",
+              relevance: 0,
+              contains: [
+                {
+                  className: "doctag",
+                  begin: "@[A-Za-z]+"
+                },
+                {
+                  className: "type",
+                  begin: "\\{",
+                  end: "\\}",
+                  excludeEnd: !0,
+                  excludeBegin: !0,
+                  relevance: 0
+                },
+                {
+                  className: "variable",
+                  begin: s + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_BLOCK_COMMENT_MODE,
+      e.C_LINE_COMMENT_MODE
+    ]
+  }, x = [
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    v,
+    m,
+    d,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    E
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  p.contains = x.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: r,
+    contains: [
+      "self"
+    ].concat(x)
+  });
+  const y = [].concat(S, p.contains), R = y.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /\(/,
+      end: /\)/,
+      keywords: r,
+      contains: ["self"].concat(y)
+    }
+  ]), L = {
+    className: "params",
+    begin: /\(/,
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: r,
+    contains: R
+  }, D = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          s,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          n.concat(s, "(", n.concat(/\./, s), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          s
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, B = {
+    relevance: 0,
+    match: n.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...An,
+        ...vn
+      ]
+    }
+  }, K = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, W = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          s,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [L],
+    illegal: /%/
+  }, re = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function ae(h) {
+    return n.concat("(?!", h.join("|"), ")");
+  }
+  const de = {
+    match: n.concat(
+      /\b/,
+      ae([
+        ...Tn,
+        "super",
+        "import"
+      ]),
+      s,
+      n.lookahead(/\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, De = {
+    begin: n.concat(/\./, n.lookahead(
+      n.concat(s, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: s,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, oe = {
+    match: [
+      /get|set/,
+      /\s+/,
+      s,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      L
+    ]
+  }, me = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", u = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      s,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      n.lookahead(me)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      L
+    ]
+  };
+  return {
+    name: "Javascript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: r,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: R, CLASS_REFERENCE: B },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      K,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      v,
+      m,
+      d,
+      S,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      E,
+      B,
+      {
+        className: "attr",
+        begin: s + n.lookahead(":"),
+        relevance: 0
+      },
+      u,
+      {
+        // "value" container
+        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          S,
+          e.REGEXP_MODE,
+          {
+            className: "function",
+            // we have to count the parens to make sure we actually have the
+            // correct bounding ( ) before the =>.  There could be any number of
+            // sub-expressions inside also surrounded by parens.
+            begin: me,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: e.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: r,
+                    contains: R
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: c.begin, end: c.end },
+              { match: l },
+              {
+                begin: i.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": i.isTrulyOpeningTag,
+                end: i.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: i.begin,
+                end: i.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      W,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // we have to count the parens to make sure we actually have the correct
+        // bounding ( ).  There could be any number of sub-expressions inside
+        // also surrounded by parens.
+        begin: "\\b(?!function)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          L,
+          e.inherit(e.TITLE_MODE, { begin: s, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      De,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + s,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [L]
+      },
+      de,
+      re,
+      D,
+      oe,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function Ft(e) {
+  const n = {
+    className: "attr",
+    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    relevance: 1.01
+  }, t = {
+    match: /[{}[\],:]/,
+    className: "punctuation",
+    relevance: 0
+  }, s = [
+    "true",
+    "false",
+    "null"
+  ], c = {
+    scope: "literal",
+    beginKeywords: s.join(" ")
+  };
+  return {
+    name: "JSON",
+    keywords: {
+      literal: s
+    },
+    contains: [
+      n,
+      t,
+      e.QUOTE_STRING_MODE,
+      c,
+      e.C_NUMBER_MODE,
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE
+    ],
+    illegal: "\\S"
+  };
+}
+function Gt(e) {
+  const n = "true false yes no null", t = "[\\w#;/?:@&=+$,.~*'()[\\]]+", s = {
+    className: "attr",
+    variants: [
+      { begin: "\\w[\\w :\\/.-]*:(?=[ 	]|$)" },
+      {
+        // double quoted keys
+        begin: '"\\w[\\w :\\/.-]*":(?=[ 	]|$)'
+      },
+      {
+        // single quoted keys
+        begin: "'\\w[\\w :\\/.-]*':(?=[ 	]|$)"
+      }
+    ]
+  }, c = {
+    className: "template-variable",
+    variants: [
+      {
+        // jinja templates Ansible
+        begin: /\{\{/,
+        end: /\}\}/
+      },
+      {
+        // Ruby i18n
+        begin: /%\{/,
+        end: /\}/
+      }
+    ]
+  }, l = {
+    className: "string",
+    relevance: 0,
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      { begin: /\S+/ }
+    ],
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      c
+    ]
+  }, i = e.inherit(l, { variants: [
+    {
+      begin: /'/,
+      end: /'/
+    },
+    {
+      begin: /"/,
+      end: /"/
+    },
+    { begin: /[^\s,{}[\]]+/ }
+  ] }), r = "[0-9]{4}(-[0-9][0-9]){0,2}", a = "([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?", o = "(\\.[0-9]*)?", b = "([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?", E = {
+    className: "number",
+    begin: "\\b" + r + a + o + b + "\\b"
+  }, p = {
+    end: ",",
+    endsWithParent: !0,
+    excludeEnd: !0,
+    keywords: n,
+    relevance: 0
+  }, v = {
+    begin: /\{/,
+    end: /\}/,
+    contains: [p],
+    illegal: "\\n",
+    relevance: 0
+  }, m = {
+    begin: "\\[",
+    end: "\\]",
+    contains: [p],
+    illegal: "\\n",
+    relevance: 0
+  }, d = [
+    s,
+    {
+      className: "meta",
+      begin: "^---\\s*$",
+      relevance: 10
+    },
+    {
+      // multi line string
+      // Blocks start with a | or > followed by a newline
+      //
+      // Indentation of subsequent lines must be the same to
+      // be considered part of the block
+      className: "string",
+      begin: "[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"
+    },
+    {
+      // Ruby/Rails erb
+      begin: "<%[%=-]?",
+      end: "[%-]?%>",
+      subLanguage: "ruby",
+      excludeBegin: !0,
+      excludeEnd: !0,
+      relevance: 0
+    },
+    {
+      // named tags
+      className: "type",
+      begin: "!\\w+!" + t
+    },
+    // https://yaml.org/spec/1.2/spec.html#id2784064
+    {
+      // verbatim tags
+      className: "type",
+      begin: "!<" + t + ">"
+    },
+    {
+      // primary tags
+      className: "type",
+      begin: "!" + t
+    },
+    {
+      // secondary tags
+      className: "type",
+      begin: "!!" + t
+    },
+    {
+      // fragment id &ref
+      className: "meta",
+      begin: "&" + e.UNDERSCORE_IDENT_RE + "$"
+    },
+    {
+      // fragment reference *ref
+      className: "meta",
+      begin: "\\*" + e.UNDERSCORE_IDENT_RE + "$"
+    },
+    {
+      // array listing
+      className: "bullet",
+      // TODO: remove |$ hack when we have proper look-ahead support
+      begin: "-(?=[ ]|$)",
+      relevance: 0
+    },
+    e.HASH_COMMENT_MODE,
+    {
+      beginKeywords: n,
+      keywords: { literal: n }
+    },
+    E,
+    // numbers are any valid C-style number that
+    // sit isolated from other words
+    {
+      className: "number",
+      begin: e.C_NUMBER_RE + "\\b",
+      relevance: 0
+    },
+    v,
+    m,
+    l
+  ], T = [...d];
+  return T.pop(), T.push(i), p.contains = T, {
+    name: "YAML",
+    case_insensitive: !0,
+    aliases: ["yml"],
+    contains: d
+  };
+}
+function Kt(e) {
+  return {
+    name: "Plain text",
+    aliases: [
+      "text",
+      "txt"
+    ],
+    disableAutodetect: !0
+  };
+}
+function Wt(e) {
+  const n = e.regex, t = /[\p{XID_Start}_]\p{XID_Continue}*/u, s = [
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "case",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "match",
+    "nonlocal|10",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+  ], r = {
+    $pattern: /[A-Za-z]\w+|__\w+__/,
+    keyword: s,
+    built_in: [
+      "__import__",
+      "abs",
+      "all",
+      "any",
+      "ascii",
+      "bin",
+      "bool",
+      "breakpoint",
+      "bytearray",
+      "bytes",
+      "callable",
+      "chr",
+      "classmethod",
+      "compile",
+      "complex",
+      "delattr",
+      "dict",
+      "dir",
+      "divmod",
+      "enumerate",
+      "eval",
+      "exec",
+      "filter",
+      "float",
+      "format",
+      "frozenset",
+      "getattr",
+      "globals",
+      "hasattr",
+      "hash",
+      "help",
+      "hex",
+      "id",
+      "input",
+      "int",
+      "isinstance",
+      "issubclass",
+      "iter",
+      "len",
+      "list",
+      "locals",
+      "map",
+      "max",
+      "memoryview",
+      "min",
+      "next",
+      "object",
+      "oct",
+      "open",
+      "ord",
+      "pow",
+      "print",
+      "property",
+      "range",
+      "repr",
+      "reversed",
+      "round",
+      "set",
+      "setattr",
+      "slice",
+      "sorted",
+      "staticmethod",
+      "str",
+      "sum",
+      "super",
+      "tuple",
+      "type",
+      "vars",
+      "zip"
+    ],
+    literal: [
+      "__debug__",
+      "Ellipsis",
+      "False",
+      "None",
+      "NotImplemented",
+      "True"
+    ],
+    type: [
+      "Any",
+      "Callable",
+      "Coroutine",
+      "Dict",
+      "List",
+      "Literal",
+      "Generic",
+      "Optional",
+      "Sequence",
+      "Set",
+      "Tuple",
+      "Type",
+      "Union"
+    ]
+  }, a = {
+    className: "meta",
+    begin: /^(>>>|\.\.\.) /
+  }, o = {
+    className: "subst",
+    begin: /\{/,
+    end: /\}/,
+    keywords: r,
+    illegal: /#/
+  }, b = {
+    begin: /\{\{/,
+    relevance: 0
+  }, E = {
+    className: "string",
+    contains: [e.BACKSLASH_ESCAPE],
+    variants: [
+      {
+        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
+        end: /'''/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a
+        ],
+        relevance: 10
+      },
+      {
+        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
+        end: /"""/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a
+        ],
+        relevance: 10
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])'''/,
+        end: /'''/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a,
+          b,
+          o
+        ]
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])"""/,
+        end: /"""/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a,
+          b,
+          o
+        ]
+      },
+      {
+        begin: /([uU]|[rR])'/,
+        end: /'/,
+        relevance: 10
+      },
+      {
+        begin: /([uU]|[rR])"/,
+        end: /"/,
+        relevance: 10
+      },
+      {
+        begin: /([bB]|[bB][rR]|[rR][bB])'/,
+        end: /'/
+      },
+      {
+        begin: /([bB]|[bB][rR]|[rR][bB])"/,
+        end: /"/
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])'/,
+        end: /'/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          b,
+          o
+        ]
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])"/,
+        end: /"/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          b,
+          o
+        ]
+      },
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE
+    ]
+  }, p = "[0-9](_?[0-9])*", v = `(\\b(${p}))?\\.(${p})|\\b(${p})\\.`, m = `\\b|${s.join("|")}`, d = {
+    className: "number",
+    relevance: 0,
+    variants: [
+      // exponentfloat, pointfloat
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#floating-point-literals
+      // optionally imaginary
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      // Note: no leading \b because floats can start with a decimal point
+      // and we don't want to mishandle e.g. `fn(.5)`,
+      // no trailing \b for pointfloat because it can end with a decimal point
+      // and we don't want to mishandle e.g. `0..hex()`; this should be safe
+      // because both MUST contain a decimal point and so cannot be confused with
+      // the interior part of an identifier
+      {
+        begin: `(\\b(${p})|(${v}))[eE][+-]?(${p})[jJ]?(?=${m})`
+      },
+      {
+        begin: `(${v})[jJ]?`
+      },
+      // decinteger, bininteger, octinteger, hexinteger
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
+      // optionally "long" in Python 2
+      // https://docs.python.org/2.7/reference/lexical_analysis.html#integer-and-long-integer-literals
+      // decinteger is optionally imaginary
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      {
+        begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${m})`
+      },
+      {
+        begin: `\\b0[bB](_?[01])+[lL]?(?=${m})`
+      },
+      {
+        begin: `\\b0[oO](_?[0-7])+[lL]?(?=${m})`
+      },
+      {
+        begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${m})`
+      },
+      // imagnumber (digitpart-based)
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      {
+        begin: `\\b(${p})[jJ](?=${m})`
+      }
+    ]
+  }, T = {
+    className: "comment",
+    begin: n.lookahead(/# type:/),
+    end: /$/,
+    keywords: r,
+    contains: [
+      {
+        // prevent keywords from coloring `type`
+        begin: /# type:/
+      },
+      // comment within a datatype comment includes no keywords
+      {
+        begin: /#/,
+        end: /\b\B/,
+        endsWithParent: !0
+      }
+    ]
+  }, S = {
+    className: "params",
+    variants: [
+      // Exclude params in functions without params
+      {
+        className: "",
+        begin: /\(\s*\)/,
+        skip: !0
+      },
+      {
+        begin: /\(/,
+        end: /\)/,
+        excludeBegin: !0,
+        excludeEnd: !0,
+        keywords: r,
+        contains: [
+          "self",
+          a,
+          d,
+          E,
+          e.HASH_COMMENT_MODE
+        ]
+      }
+    ]
+  };
+  return o.contains = [
+    E,
+    d,
+    a
+  ], {
+    name: "Python",
+    aliases: [
+      "py",
+      "gyp",
+      "ipython"
+    ],
+    unicodeRegex: !0,
+    keywords: r,
+    illegal: /(<\/|->|\?)|=>/,
+    contains: [
+      a,
+      d,
+      {
+        // very common convention
+        begin: /\bself\b/
+      },
+      {
+        // eat "if" prior to string so that it won't accidentally be
+        // labeled as an f-string
+        beginKeywords: "if",
+        relevance: 0
+      },
+      E,
+      T,
+      e.HASH_COMMENT_MODE,
+      {
+        match: [
+          /\bdef/,
+          /\s+/,
+          t
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.function"
+        },
+        contains: [S]
+      },
+      {
+        variants: [
+          {
+            match: [
+              /\bclass/,
+              /\s+/,
+              t,
+              /\s*/,
+              /\(\s*/,
+              t,
+              /\s*\)/
+            ]
+          },
+          {
+            match: [
+              /\bclass/,
+              /\s+/,
+              t
+            ]
+          }
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          6: "title.class.inherited"
+        }
+      },
+      {
+        className: "meta",
+        begin: /^[\t ]*@/,
+        end: /(?=#)|$/,
+        contains: [
+          d,
+          S,
+          E
+        ]
+      }
+    ]
+  };
+}
+var le = "[0-9](_*[0-9])*", we = `\\.(${le})`, Se = "[0-9a-fA-F](_*[0-9a-fA-F])*", un = {
+  className: "number",
+  variants: [
+    // DecimalFloatingPointLiteral
+    // including ExponentPart
+    { begin: `(\\b(${le})((${we})|\\.)?|(${we}))[eE][+-]?(${le})[fFdD]?\\b` },
+    // excluding ExponentPart
+    { begin: `\\b(${le})((${we})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+    { begin: `(${we})[fFdD]?\\b` },
+    { begin: `\\b(${le})[fFdD]\\b` },
+    // HexadecimalFloatingPointLiteral
+    { begin: `\\b0[xX]((${Se})\\.?|(${Se})?\\.(${Se}))[pP][+-]?(${le})[fFdD]?\\b` },
+    // DecimalIntegerLiteral
+    { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" },
+    // HexIntegerLiteral
+    { begin: `\\b0[xX](${Se})[lL]?\\b` },
+    // OctalIntegerLiteral
+    { begin: "\\b0(_*[0-7])*[lL]?\\b" },
+    // BinaryIntegerLiteral
+    { begin: "\\b0[bB][01](_*[01])*[lL]?\\b" }
+  ],
+  relevance: 0
+};
+function wn(e, n, t) {
+  return t === -1 ? "" : e.replace(n, (s) => wn(e, n, t - 1));
+}
+function Yt(e) {
+  const n = e.regex, t = "[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*", s = t + wn("(?:<" + t + "~~~(?:\\s*,\\s*" + t + "~~~)*>)?", /~~~/g, 2), a = {
+    keyword: [
+      "synchronized",
+      "abstract",
+      "private",
+      "var",
+      "static",
+      "if",
+      "const ",
+      "for",
+      "while",
+      "strictfp",
+      "finally",
+      "protected",
+      "import",
+      "native",
+      "final",
+      "void",
+      "enum",
+      "else",
+      "break",
+      "transient",
+      "catch",
+      "instanceof",
+      "volatile",
+      "case",
+      "assert",
+      "package",
+      "default",
+      "public",
+      "try",
+      "switch",
+      "continue",
+      "throws",
+      "protected",
+      "public",
+      "private",
+      "module",
+      "requires",
+      "exports",
+      "do",
+      "sealed",
+      "yield",
+      "permits"
+    ],
+    literal: [
+      "false",
+      "true",
+      "null"
+    ],
+    type: [
+      "char",
+      "boolean",
+      "long",
+      "float",
+      "int",
+      "byte",
+      "short",
+      "double"
+    ],
+    built_in: [
+      "super",
+      "this"
+    ]
+  }, o = {
+    className: "meta",
+    begin: "@" + t,
+    contains: [
+      {
+        begin: /\(/,
+        end: /\)/,
+        contains: ["self"]
+        // allow nested () inside our annotation
+      }
+    ]
+  }, b = {
+    className: "params",
+    begin: /\(/,
+    end: /\)/,
+    keywords: a,
+    relevance: 0,
+    contains: [e.C_BLOCK_COMMENT_MODE],
+    endsParent: !0
+  };
+  return {
+    name: "Java",
+    aliases: ["jsp"],
+    keywords: a,
+    illegal: /<\/|#/,
+    contains: [
+      e.COMMENT(
+        "/\\*\\*",
+        "\\*/",
+        {
+          relevance: 0,
+          contains: [
+            {
+              // eat up @'s in emails to prevent them to be recognized as doctags
+              begin: /\w+@/,
+              relevance: 0
+            },
+            {
+              className: "doctag",
+              begin: "@[A-Za-z]+"
+            }
+          ]
+        }
+      ),
+      // relevance boost
+      {
+        begin: /import java\.[a-z]+\./,
+        keywords: "import",
+        relevance: 2
+      },
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      {
+        begin: /"""/,
+        end: /"""/,
+        className: "string",
+        contains: [e.BACKSLASH_ESCAPE]
+      },
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      {
+        match: [
+          /\b(?:class|interface|enum|extends|implements|new)/,
+          /\s+/,
+          t
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        // Exceptions for hyphenated keywords
+        match: /non-sealed/,
+        scope: "keyword"
+      },
+      {
+        begin: [
+          n.concat(/(?!else)/, t),
+          /\s+/,
+          t,
+          /\s+/,
+          /=(?!=)/
+        ],
+        className: {
+          1: "type",
+          3: "variable",
+          5: "operator"
+        }
+      },
+      {
+        begin: [
+          /record/,
+          /\s+/,
+          t
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        },
+        contains: [
+          b,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        // Expression keywords prevent 'keyword Name(...)' from being
+        // recognized as a function definition
+        beginKeywords: "new throw return else",
+        relevance: 0
+      },
+      {
+        begin: [
+          "(?:" + s + "\\s+)",
+          e.UNDERSCORE_IDENT_RE,
+          /\s*(?=\()/
+        ],
+        className: { 2: "title.function" },
+        keywords: a,
+        contains: [
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            keywords: a,
+            relevance: 0,
+            contains: [
+              o,
+              e.APOS_STRING_MODE,
+              e.QUOTE_STRING_MODE,
+              un,
+              e.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      un,
+      o
+    ]
+  };
+}
+function Zt(e) {
+  const n = e.regex, t = {}, s = {
+    begin: /\$\{/,
+    end: /\}/,
+    contains: [
+      "self",
+      {
+        begin: /:-/,
+        contains: [t]
+      }
+      // default values
+    ]
+  };
+  Object.assign(t, {
+    className: "variable",
+    variants: [
+      { begin: n.concat(
+        /\$[\w\d#@][\w\d_]*/,
+        // negative look-ahead tries to avoid matching patterns that are not
+        // Perl at all like $ident$, @ident@, etc.
+        "(?![\\w\\d])(?![$])"
+      ) },
+      s
+    ]
+  });
+  const c = {
+    className: "subst",
+    begin: /\$\(/,
+    end: /\)/,
+    contains: [e.BACKSLASH_ESCAPE]
+  }, l = {
+    begin: /<<-?\s*(?=\w+)/,
+    starts: { contains: [
+      e.END_SAME_AS_BEGIN({
+        begin: /(\w+)/,
+        end: /(\w+)/,
+        className: "string"
+      })
+    ] }
+  }, i = {
+    className: "string",
+    begin: /"/,
+    end: /"/,
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      t,
+      c
+    ]
+  };
+  c.contains.push(i);
+  const r = {
+    className: "",
+    begin: /\\"/
+  }, a = {
+    className: "string",
+    begin: /'/,
+    end: /'/
+  }, o = {
+    begin: /\$?\(\(/,
+    end: /\)\)/,
+    contains: [
+      {
+        begin: /\d+#[0-9a-f]+/,
+        className: "number"
+      },
+      e.NUMBER_MODE,
+      t
+    ]
+  }, b = [
+    "fish",
+    "bash",
+    "zsh",
+    "sh",
+    "csh",
+    "ksh",
+    "tcsh",
+    "dash",
+    "scsh"
+  ], E = e.SHEBANG({
+    binary: `(${b.join("|")})`,
+    relevance: 10
+  }), p = {
+    className: "function",
+    begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
+    returnBegin: !0,
+    contains: [e.inherit(e.TITLE_MODE, { begin: /\w[\w\d_]*/ })],
+    relevance: 0
+  }, v = [
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "in",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "function"
+  ], m = [
+    "true",
+    "false"
+  ], d = { match: /(\/[a-z._-]+)+/ }, T = [
+    "break",
+    "cd",
+    "continue",
+    "eval",
+    "exec",
+    "exit",
+    "export",
+    "getopts",
+    "hash",
+    "pwd",
+    "readonly",
+    "return",
+    "shift",
+    "test",
+    "times",
+    "trap",
+    "umask",
+    "unset"
+  ], S = [
+    "alias",
+    "bind",
+    "builtin",
+    "caller",
+    "command",
+    "declare",
+    "echo",
+    "enable",
+    "help",
+    "let",
+    "local",
+    "logout",
+    "mapfile",
+    "printf",
+    "read",
+    "readarray",
+    "source",
+    "type",
+    "typeset",
+    "ulimit",
+    "unalias"
+  ], x = [
+    "autoload",
+    "bg",
+    "bindkey",
+    "bye",
+    "cap",
+    "chdir",
+    "clone",
+    "comparguments",
+    "compcall",
+    "compctl",
+    "compdescribe",
+    "compfiles",
+    "compgroups",
+    "compquote",
+    "comptags",
+    "comptry",
+    "compvalues",
+    "dirs",
+    "disable",
+    "disown",
+    "echotc",
+    "echoti",
+    "emulate",
+    "fc",
+    "fg",
+    "float",
+    "functions",
+    "getcap",
+    "getln",
+    "history",
+    "integer",
+    "jobs",
+    "kill",
+    "limit",
+    "log",
+    "noglob",
+    "popd",
+    "print",
+    "pushd",
+    "pushln",
+    "rehash",
+    "sched",
+    "setcap",
+    "setopt",
+    "stat",
+    "suspend",
+    "ttyctl",
+    "unfunction",
+    "unhash",
+    "unlimit",
+    "unsetopt",
+    "vared",
+    "wait",
+    "whence",
+    "where",
+    "which",
+    "zcompile",
+    "zformat",
+    "zftp",
+    "zle",
+    "zmodload",
+    "zparseopts",
+    "zprof",
+    "zpty",
+    "zregexparse",
+    "zsocket",
+    "zstyle",
+    "ztcp"
+  ], y = [
+    "chcon",
+    "chgrp",
+    "chown",
+    "chmod",
+    "cp",
+    "dd",
+    "df",
+    "dir",
+    "dircolors",
+    "ln",
+    "ls",
+    "mkdir",
+    "mkfifo",
+    "mknod",
+    "mktemp",
+    "mv",
+    "realpath",
+    "rm",
+    "rmdir",
+    "shred",
+    "sync",
+    "touch",
+    "truncate",
+    "vdir",
+    "b2sum",
+    "base32",
+    "base64",
+    "cat",
+    "cksum",
+    "comm",
+    "csplit",
+    "cut",
+    "expand",
+    "fmt",
+    "fold",
+    "head",
+    "join",
+    "md5sum",
+    "nl",
+    "numfmt",
+    "od",
+    "paste",
+    "ptx",
+    "pr",
+    "sha1sum",
+    "sha224sum",
+    "sha256sum",
+    "sha384sum",
+    "sha512sum",
+    "shuf",
+    "sort",
+    "split",
+    "sum",
+    "tac",
+    "tail",
+    "tr",
+    "tsort",
+    "unexpand",
+    "uniq",
+    "wc",
+    "arch",
+    "basename",
+    "chroot",
+    "date",
+    "dirname",
+    "du",
+    "echo",
+    "env",
+    "expr",
+    "factor",
+    // "false", // keyword literal already
+    "groups",
+    "hostid",
+    "id",
+    "link",
+    "logname",
+    "nice",
+    "nohup",
+    "nproc",
+    "pathchk",
+    "pinky",
+    "printenv",
+    "printf",
+    "pwd",
+    "readlink",
+    "runcon",
+    "seq",
+    "sleep",
+    "stat",
+    "stdbuf",
+    "stty",
+    "tee",
+    "test",
+    "timeout",
+    // "true", // keyword literal already
+    "tty",
+    "uname",
+    "unlink",
+    "uptime",
+    "users",
+    "who",
+    "whoami",
+    "yes"
+  ];
+  return {
+    name: "Bash",
+    aliases: ["sh"],
+    keywords: {
+      $pattern: /\b[a-z][a-z0-9._-]+\b/,
+      keyword: v,
+      literal: m,
+      built_in: [
+        ...T,
+        ...S,
+        // Shell modifiers
+        "set",
+        "shopt",
+        ...x,
+        ...y
+      ]
+    },
+    contains: [
+      E,
+      // to catch known shells and boost relevancy
+      e.SHEBANG(),
+      // to catch unknown shells but still highlight the shebang
+      p,
+      o,
+      e.HASH_COMMENT_MODE,
+      l,
+      d,
+      i,
+      r,
+      a,
+      t
+    ]
+  };
+}
+function Qt(e) {
+  const n = e.regex, t = e.COMMENT("--", "$"), s = {
+    className: "string",
+    variants: [
+      {
+        begin: /'/,
+        end: /'/,
+        contains: [{ begin: /''/ }]
+      }
+    ]
+  }, c = {
+    begin: /"/,
+    end: /"/,
+    contains: [{ begin: /""/ }]
+  }, l = [
+    "true",
+    "false",
+    // Not sure it's correct to call NULL literal, and clauses like IS [NOT] NULL look strange that way.
+    // "null",
+    "unknown"
+  ], i = [
+    "double precision",
+    "large object",
+    "with timezone",
+    "without timezone"
+  ], r = [
+    "bigint",
+    "binary",
+    "blob",
+    "boolean",
+    "char",
+    "character",
+    "clob",
+    "date",
+    "dec",
+    "decfloat",
+    "decimal",
+    "float",
+    "int",
+    "integer",
+    "interval",
+    "nchar",
+    "nclob",
+    "national",
+    "numeric",
+    "real",
+    "row",
+    "smallint",
+    "time",
+    "timestamp",
+    "varchar",
+    "varying",
+    // modifier (character varying)
+    "varbinary"
+  ], a = [
+    "add",
+    "asc",
+    "collation",
+    "desc",
+    "final",
+    "first",
+    "last",
+    "view"
+  ], o = [
+    "abs",
+    "acos",
+    "all",
+    "allocate",
+    "alter",
+    "and",
+    "any",
+    "are",
+    "array",
+    "array_agg",
+    "array_max_cardinality",
+    "as",
+    "asensitive",
+    "asin",
+    "asymmetric",
+    "at",
+    "atan",
+    "atomic",
+    "authorization",
+    "avg",
+    "begin",
+    "begin_frame",
+    "begin_partition",
+    "between",
+    "bigint",
+    "binary",
+    "blob",
+    "boolean",
+    "both",
+    "by",
+    "call",
+    "called",
+    "cardinality",
+    "cascaded",
+    "case",
+    "cast",
+    "ceil",
+    "ceiling",
+    "char",
+    "char_length",
+    "character",
+    "character_length",
+    "check",
+    "classifier",
+    "clob",
+    "close",
+    "coalesce",
+    "collate",
+    "collect",
+    "column",
+    "commit",
+    "condition",
+    "connect",
+    "constraint",
+    "contains",
+    "convert",
+    "copy",
+    "corr",
+    "corresponding",
+    "cos",
+    "cosh",
+    "count",
+    "covar_pop",
+    "covar_samp",
+    "create",
+    "cross",
+    "cube",
+    "cume_dist",
+    "current",
+    "current_catalog",
+    "current_date",
+    "current_default_transform_group",
+    "current_path",
+    "current_role",
+    "current_row",
+    "current_schema",
+    "current_time",
+    "current_timestamp",
+    "current_path",
+    "current_role",
+    "current_transform_group_for_type",
+    "current_user",
+    "cursor",
+    "cycle",
+    "date",
+    "day",
+    "deallocate",
+    "dec",
+    "decimal",
+    "decfloat",
+    "declare",
+    "default",
+    "define",
+    "delete",
+    "dense_rank",
+    "deref",
+    "describe",
+    "deterministic",
+    "disconnect",
+    "distinct",
+    "double",
+    "drop",
+    "dynamic",
+    "each",
+    "element",
+    "else",
+    "empty",
+    "end",
+    "end_frame",
+    "end_partition",
+    "end-exec",
+    "equals",
+    "escape",
+    "every",
+    "except",
+    "exec",
+    "execute",
+    "exists",
+    "exp",
+    "external",
+    "extract",
+    "false",
+    "fetch",
+    "filter",
+    "first_value",
+    "float",
+    "floor",
+    "for",
+    "foreign",
+    "frame_row",
+    "free",
+    "from",
+    "full",
+    "function",
+    "fusion",
+    "get",
+    "global",
+    "grant",
+    "group",
+    "grouping",
+    "groups",
+    "having",
+    "hold",
+    "hour",
+    "identity",
+    "in",
+    "indicator",
+    "initial",
+    "inner",
+    "inout",
+    "insensitive",
+    "insert",
+    "int",
+    "integer",
+    "intersect",
+    "intersection",
+    "interval",
+    "into",
+    "is",
+    "join",
+    "json_array",
+    "json_arrayagg",
+    "json_exists",
+    "json_object",
+    "json_objectagg",
+    "json_query",
+    "json_table",
+    "json_table_primitive",
+    "json_value",
+    "lag",
+    "language",
+    "large",
+    "last_value",
+    "lateral",
+    "lead",
+    "leading",
+    "left",
+    "like",
+    "like_regex",
+    "listagg",
+    "ln",
+    "local",
+    "localtime",
+    "localtimestamp",
+    "log",
+    "log10",
+    "lower",
+    "match",
+    "match_number",
+    "match_recognize",
+    "matches",
+    "max",
+    "member",
+    "merge",
+    "method",
+    "min",
+    "minute",
+    "mod",
+    "modifies",
+    "module",
+    "month",
+    "multiset",
+    "national",
+    "natural",
+    "nchar",
+    "nclob",
+    "new",
+    "no",
+    "none",
+    "normalize",
+    "not",
+    "nth_value",
+    "ntile",
+    "null",
+    "nullif",
+    "numeric",
+    "octet_length",
+    "occurrences_regex",
+    "of",
+    "offset",
+    "old",
+    "omit",
+    "on",
+    "one",
+    "only",
+    "open",
+    "or",
+    "order",
+    "out",
+    "outer",
+    "over",
+    "overlaps",
+    "overlay",
+    "parameter",
+    "partition",
+    "pattern",
+    "per",
+    "percent",
+    "percent_rank",
+    "percentile_cont",
+    "percentile_disc",
+    "period",
+    "portion",
+    "position",
+    "position_regex",
+    "power",
+    "precedes",
+    "precision",
+    "prepare",
+    "primary",
+    "procedure",
+    "ptf",
+    "range",
+    "rank",
+    "reads",
+    "real",
+    "recursive",
+    "ref",
+    "references",
+    "referencing",
+    "regr_avgx",
+    "regr_avgy",
+    "regr_count",
+    "regr_intercept",
+    "regr_r2",
+    "regr_slope",
+    "regr_sxx",
+    "regr_sxy",
+    "regr_syy",
+    "release",
+    "result",
+    "return",
+    "returns",
+    "revoke",
+    "right",
+    "rollback",
+    "rollup",
+    "row",
+    "row_number",
+    "rows",
+    "running",
+    "savepoint",
+    "scope",
+    "scroll",
+    "search",
+    "second",
+    "seek",
+    "select",
+    "sensitive",
+    "session_user",
+    "set",
+    "show",
+    "similar",
+    "sin",
+    "sinh",
+    "skip",
+    "smallint",
+    "some",
+    "specific",
+    "specifictype",
+    "sql",
+    "sqlexception",
+    "sqlstate",
+    "sqlwarning",
+    "sqrt",
+    "start",
+    "static",
+    "stddev_pop",
+    "stddev_samp",
+    "submultiset",
+    "subset",
+    "substring",
+    "substring_regex",
+    "succeeds",
+    "sum",
+    "symmetric",
+    "system",
+    "system_time",
+    "system_user",
+    "table",
+    "tablesample",
+    "tan",
+    "tanh",
+    "then",
+    "time",
+    "timestamp",
+    "timezone_hour",
+    "timezone_minute",
+    "to",
+    "trailing",
+    "translate",
+    "translate_regex",
+    "translation",
+    "treat",
+    "trigger",
+    "trim",
+    "trim_array",
+    "true",
+    "truncate",
+    "uescape",
+    "union",
+    "unique",
+    "unknown",
+    "unnest",
+    "update",
+    "upper",
+    "user",
+    "using",
+    "value",
+    "values",
+    "value_of",
+    "var_pop",
+    "var_samp",
+    "varbinary",
+    "varchar",
+    "varying",
+    "versioning",
+    "when",
+    "whenever",
+    "where",
+    "width_bucket",
+    "window",
+    "with",
+    "within",
+    "without",
+    "year"
+  ], b = [
+    "abs",
+    "acos",
+    "array_agg",
+    "asin",
+    "atan",
+    "avg",
+    "cast",
+    "ceil",
+    "ceiling",
+    "coalesce",
+    "corr",
+    "cos",
+    "cosh",
+    "count",
+    "covar_pop",
+    "covar_samp",
+    "cume_dist",
+    "dense_rank",
+    "deref",
+    "element",
+    "exp",
+    "extract",
+    "first_value",
+    "floor",
+    "json_array",
+    "json_arrayagg",
+    "json_exists",
+    "json_object",
+    "json_objectagg",
+    "json_query",
+    "json_table",
+    "json_table_primitive",
+    "json_value",
+    "lag",
+    "last_value",
+    "lead",
+    "listagg",
+    "ln",
+    "log",
+    "log10",
+    "lower",
+    "max",
+    "min",
+    "mod",
+    "nth_value",
+    "ntile",
+    "nullif",
+    "percent_rank",
+    "percentile_cont",
+    "percentile_disc",
+    "position",
+    "position_regex",
+    "power",
+    "rank",
+    "regr_avgx",
+    "regr_avgy",
+    "regr_count",
+    "regr_intercept",
+    "regr_r2",
+    "regr_slope",
+    "regr_sxx",
+    "regr_sxy",
+    "regr_syy",
+    "row_number",
+    "sin",
+    "sinh",
+    "sqrt",
+    "stddev_pop",
+    "stddev_samp",
+    "substring",
+    "substring_regex",
+    "sum",
+    "tan",
+    "tanh",
+    "translate",
+    "translate_regex",
+    "treat",
+    "trim",
+    "trim_array",
+    "unnest",
+    "upper",
+    "value_of",
+    "var_pop",
+    "var_samp",
+    "width_bucket"
+  ], E = [
+    "current_catalog",
+    "current_date",
+    "current_default_transform_group",
+    "current_path",
+    "current_role",
+    "current_schema",
+    "current_transform_group_for_type",
+    "current_user",
+    "session_user",
+    "system_time",
+    "system_user",
+    "current_time",
+    "localtime",
+    "current_timestamp",
+    "localtimestamp"
+  ], p = [
+    "create table",
+    "insert into",
+    "primary key",
+    "foreign key",
+    "not null",
+    "alter table",
+    "add constraint",
+    "grouping sets",
+    "on overflow",
+    "character set",
+    "respect nulls",
+    "ignore nulls",
+    "nulls first",
+    "nulls last",
+    "depth first",
+    "breadth first"
+  ], v = b, m = [
+    ...o,
+    ...a
+  ].filter((y) => !b.includes(y)), d = {
+    className: "variable",
+    begin: /@[a-z0-9]+/
+  }, T = {
+    className: "operator",
+    begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,
+    relevance: 0
+  }, S = {
+    begin: n.concat(/\b/, n.either(...v), /\s*\(/),
+    relevance: 0,
+    keywords: { built_in: v }
+  };
+  function x(y, {
+    exceptions: R,
+    when: L
+  } = {}) {
+    const D = L;
+    return R = R || [], y.map((B) => B.match(/\|\d+$/) || R.includes(B) ? B : D(B) ? `${B}|0` : B);
+  }
+  return {
+    name: "SQL",
+    case_insensitive: !0,
+    // does not include {} or HTML tags `</`
+    illegal: /[{}]|<\//,
+    keywords: {
+      $pattern: /\b[\w\.]+/,
+      keyword: x(m, { when: (y) => y.length < 3 }),
+      literal: l,
+      type: r,
+      built_in: E
+    },
+    contains: [
+      {
+        begin: n.either(...p),
+        relevance: 0,
+        keywords: {
+          $pattern: /[\w\.]+/,
+          keyword: m.concat(p),
+          literal: l,
+          type: r
+        }
+      },
+      {
+        className: "type",
+        begin: n.either(...i)
+      },
+      S,
+      d,
+      s,
+      c,
+      e.C_NUMBER_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      t,
+      T
+    ]
+  };
+}
+Z.registerLanguage("xml", Bt);
+Z.registerLanguage("javascript", zt);
+Z.registerLanguage("json", Ft);
+Z.registerLanguage("yaml", Gt);
+Z.registerLanguage("plaintext", Kt);
+Z.registerLanguage("python", Wt);
+Z.registerLanguage("java", Yt);
+Z.registerLanguage("bash", Zt);
+Z.registerLanguage("sql", Qt);
+var g = /* @__PURE__ */ ((e) => (e.EQUAL = "equal", e.DELETE = "removed", e.ADD = "added", e.EMPTY = "empty", e))(g || {});
+const X = "<code-diff-modified>", V = "</code-diff-modified>", qt = X.replace("<", "&lt;").replace(">", "&gt;"), Xt = V.replace("<", "&lt;").replace(">", "&gt;"), fe = (e) => e === void 0 ? g.EQUAL : e.added ? g.ADD : e.removed ? g.DELETE : g.EQUAL, xe = (e, n, t = "word") => typeof e > "u" ? n : typeof n > "u" ? e : (t === "char" ? Bn : Un)(e, n).filter((c) => fe(c) !== g.DELETE).map(
+  (c) => fe(c) === g.ADD ? `${X}${c.value}${V}` : c.value
+).join(""), Y = (e, n) => {
+  if (!n.match(new RegExp(`(${X}|${V})`, "g")))
+    return Z.highlight(n, { language: e }).value;
+  let s = n;
+  const c = n.replace(new RegExp(`(${X}|${V})`, "g"), ""), l = document.createElement("div");
+  l.innerHTML = Z.highlight(c, { language: e }).value;
+  let i = !1;
+  const r = (a) => {
+    a.childNodes.forEach((o) => {
+      if (o.nodeType === Node.ELEMENT_NODE && r(o), o.nodeType === Node.TEXT_NODE) {
+        if (!o.textContent)
+          return;
+        let b = o.textContent, E = "";
+        for (i && (E = E + X); b.length; ) {
+          if (s.startsWith(X)) {
+            s = s.slice(X.length), E = E + X, i = !0;
+            continue;
+          }
+          if (s.startsWith(V)) {
+            s = s.slice(V.length), E = E + V, i = !1;
+            continue;
+          }
+          const p = s.match(new RegExp(`(${X}|${V})`)), v = p && p.index ? p.index : s.length, m = Math.min(v, b.length);
+          E = E + s.substring(0, m), s = s.slice(m), b = b.slice(m);
+        }
+        i && (E = E + V), o.textContent = E;
+      }
+    });
+  };
+  return r(l), l.innerHTML.replace(new RegExp(qt, "g"), '<span class="x">').replace(new RegExp(Xt, "g"), "</span>");
+};
+function Vt(e, n, t = "plaintext", s = "word", c = 10) {
+  var v;
+  const l = () => ({ type: g.EMPTY }), i = (m, d, T) => ({ type: m, num: d, code: T }), r = fn(e, n);
+  let a = 0, o = 0, b = !1;
+  const E = [];
+  for (let m = 0; m < r.length; m++) {
+    if (b) {
+      b = !1;
+      continue;
+    }
+    const [d, T] = [r[m], r[m + 1]], [S, x] = [fe(d), fe(T)], y = d.value.replace(/\n$/, "").split(`
+`);
+    if (T === void 0) {
+      for (const L of y) {
+        let D = l(), B = l();
+        const K = Y(t, L);
+        S === g.EQUAL && (a++, o++, D = i(g.EQUAL, a, K), B = i(g.EQUAL, o, K)), S === g.DELETE && (a++, D = i(g.DELETE, a, K), B = l()), S === g.ADD && (o++, D = l(), B = i(g.ADD, o, K)), E.push({ left: D, right: B });
+      }
+      break;
+    }
+    if (S === g.EQUAL)
+      for (const L of y) {
+        a++, o++;
+        const D = Y(t, L);
+        E.push({
+          left: i(g.EQUAL, a, D),
+          right: i(g.EQUAL, o, D)
+        });
+      }
+    const R = T.value.replace(/\n$/, "").split(`
+`);
+    if (S === g.DELETE) {
+      if (x === g.EQUAL)
+        for (const L of y)
+          a++, E.push({
+            left: i(g.DELETE, a, Y(t, L)),
+            right: l()
+          });
+      if (x === g.ADD) {
+        b = !0;
+        const L = Math.max(d.count, T.count);
+        for (let D = 0; D < L; D++) {
+          D < d.count && a++, D < T.count && o++;
+          const [B, K] = [y[D], R[D]], W = y.length === R.length ? xe(K, B, s) : B, re = y.length === R.length ? xe(B, K, s) : K, ae = D < d.count ? i(g.DELETE, a, Y(t, W)) : l(), de = D < T.count ? i(g.ADD, o, Y(t, re)) : l();
+          E.push({ left: ae, right: de });
+        }
+      }
+    }
+    if (S === g.ADD)
+      for (const L of y)
+        o++, E.push({
+          left: l(),
+          right: i(g.ADD, o, Y(t, L))
+        });
+  }
+  if (e === n) {
+    for (let m = 0; m < E.length; m++)
+      E[m].fold = !1;
+    return E;
+  }
+  for (let m = 0; m < E.length; m++) {
+    const d = E[m];
+    if (d.left.type === g.DELETE || d.right.type === g.ADD) {
+      const [T, S] = [Math.max(m - c, 0), Math.min(m + c + 1, E.length)];
+      for (let x = T; x < S; x++)
+        E[x].fold = !1;
+    }
+    d.fold === void 0 && (d.fold = !0);
+  }
+  const p = [];
+  for (let m = 0; m < E.length; m++) {
+    const d = E[m];
+    if (d.fold === !1) {
+      p.push(d);
+      continue;
+    }
+    d.fold === !0 && ((v = p[p.length - 1]) == null ? void 0 : v.fold) !== !0 && p.push(d);
+  }
+  return p;
+}
+function jt(e, n, t = "plaintext", s = "word", c = 2) {
+  var E;
+  const l = fn(e, n);
+  let i = 0, r = 0, a = !1;
+  const o = [];
+  for (let p = 0; p < l.length; p++) {
+    if (a) {
+      a = !1;
+      continue;
+    }
+    const [v, m] = [l[p], l[p + 1]], [d, T] = [fe(v), fe(m)], S = v.value.replace(/\n$/, "").split(`
+`);
+    if (m === void 0) {
+      for (const y of S) {
+        d === g.EQUAL && (i++, r++), d === g.DELETE && i++, d === g.ADD && r++;
+        const R = Y(t, y);
+        o.push({
+          type: d,
+          code: R,
+          addNum: d === g.DELETE ? void 0 : r,
+          delNum: d === g.ADD ? void 0 : i
+        });
+      }
+      break;
+    }
+    if (d === g.EQUAL)
+      for (const y of S) {
+        i++, r++;
+        const R = Y(t, y);
+        o.push({ type: g.EQUAL, code: R, delNum: i, addNum: r });
+      }
+    const x = m.value.replace(/\n$/, "").split(`
+`);
+    if (d === g.DELETE)
+      if (T === g.ADD && S.length === x.length) {
+        for (let y = 0; y < S.length; y++) {
+          const R = S[y], L = x[y];
+          i++;
+          const D = Y(t, xe(L, R, s));
+          o.push({ type: g.DELETE, code: D, delNum: i });
+        }
+        for (let y = 0; y < x.length; y++) {
+          const R = S[y], L = x[y];
+          r++;
+          const D = Y(t, xe(R, L, s));
+          o.push({ type: g.ADD, code: D, addNum: r });
+        }
+        a = !0;
+      } else
+        for (const y of S) {
+          i++;
+          const R = Y(t, y);
+          o.push({ type: g.DELETE, code: R, delNum: i });
+        }
+    if (d === g.ADD)
+      for (const y of S) {
+        r++;
+        const R = Y(t, y);
+        o.push({ type: g.ADD, code: R, addNum: r });
+      }
+  }
+  for (let p = 0; p < o.length; p++) {
+    const v = o[p];
+    if (v.type === g.DELETE || v.type === g.ADD) {
+      const [m, d] = [Math.max(p - c, 0), Math.min(p + c + 1, o.length)];
+      for (let T = m; T < d; T++)
+        o[T].fold = !1;
+    }
+    v.fold === void 0 && (v.fold = !0);
+  }
+  if (e === n) {
+    for (let p = 0; p < o.length; p++)
+      o[p].fold = !1;
+    return o;
+  }
+  const b = [];
+  for (let p = 0; p < o.length; p++) {
+    const v = o[p];
+    if (v.fold === !1) {
+      b.push(v);
+      continue;
+    }
+    v.fold === !0 && (p === 0 || ((E = b[b.length - 1]) == null ? void 0 : E.fold) !== !0) && b.push(v);
+  }
+  return b;
+}
+const Jt = { key: 0 }, es = /* @__PURE__ */ k("td", { class: "blob-num blob-num-empty empty-cell" }, " > ", -1), ns = /* @__PURE__ */ k("td", { class: "blob-num blob-num-empty empty-cell" }, " > ", -1), ts = /* @__PURE__ */ k("td", {
+  class: "blob-code blob-code-empty empty-cell",
+  align: "left"
+}, " ⋯ ", -1), ss = [
+  es,
+  ns,
+  ts
+], is = { key: 1 }, rs = ["data-code-marker", "innerHTML"], as = /* @__PURE__ */ _e({
+  __name: "UnifiedLine",
+  props: {
+    line: null
+  },
+  setup(e) {
+    const n = (t) => t === g.DELETE ? "-" : t === g.ADD ? "+" : "";
+    return (t, s) => e.line.fold ? (P(), G("tr", Jt, ss)) : (P(), G("tr", is, [
+      k("td", {
+        class: ge(["blob-num", {
+          "blob-num-deletion": e.line.type === $(g).DELETE,
+          "blob-num-addition": e.line.type === $(g).ADD,
+          "blob-num-context": e.line.type === $(g).EQUAL
+        }])
+      }, $e(e.line.delNum), 3),
+      k("td", {
+        class: ge(["blob-num", {
+          "blob-num-deletion": e.line.type === $(g).DELETE,
+          "blob-num-addition": e.line.type === $(g).ADD,
+          "blob-num-context": e.line.type === $(g).EQUAL
+        }])
+      }, $e(e.line.addNum), 3),
+      k("td", {
+        class: ge(["blob-code", {
+          "blob-code-deletion": e.line.type === $(g).DELETE,
+          "blob-code-addition": e.line.type === $(g).ADD,
+          "blob-code-context": e.line.type === $(g).EQUAL
+        }])
+      }, [
+        k("span", {
+          class: "blob-code-inner blob-code-marker",
+          "data-code-marker": n(e.line.type),
+          innerHTML: e.line.code
+        }, null, 8, rs)
+      ], 2)
+    ]));
+  }
+}), os = { class: "file" }, cs = { class: "diff-table" }, ls = /* @__PURE__ */ _e({
+  __name: "UnifiedViewer",
+  props: {
+    diffChange: null
+  },
+  setup(e) {
+    return (n, t) => (P(), G("div", os, [
+      k("table", cs, [
+        k("tbody", null, [
+          (P(!0), G(ue, null, He(e.diffChange, (s, c) => (P(), Re(as, {
+            key: c,
+            line: s
+          }, null, 8, ["line"]))), 128))
+        ])
+      ])
+    ]));
+  }
+}), us = { key: 0 }, fs = /* @__PURE__ */ k("td", {
+  class: "blob-num blob-num-empty empty-cell",
+  colspan: "1"
+}, " > ", -1), ds = /* @__PURE__ */ k("td", {
+  class: "blob-code blob-code-empty empty-cell",
+  colspan: "3",
+  align: "left"
+}, " ⋯ ", -1), gs = [
+  fs,
+  ds
+], ps = { key: 1 }, bs = /* @__PURE__ */ k("td", { class: "blob-num blob-num-empty empty-cell" }, null, -1), hs = /* @__PURE__ */ k("td", { class: "blob-code blob-code-empty empty-cell" }, null, -1), Es = ["data-code-marker", "innerHTML"], _s = /* @__PURE__ */ _e({
+  __name: "SplitLine",
+  props: {
+    splitLine: null
+  },
+  setup(e) {
+    const n = (t) => t === g.DELETE ? "-" : t === g.ADD ? "+" : "";
+    return (t, s) => e.splitLine.fold ? (P(), G("tr", us, gs)) : (P(), G("tr", ps, [
+      (P(!0), G(ue, null, He([e.splitLine.left, e.splitLine.right], (c) => (P(), G(ue, null, [
+        c.type === $(g).EMPTY ? (P(), G(ue, { key: 0 }, [
+          bs,
+          hs
+        ], 64)) : (P(), G(ue, { key: 1 }, [
+          k("td", {
+            class: ge(["blob-num", {
+              "blob-num-deletion": c.type === $(g).DELETE,
+              "blob-num-addition": c.type === $(g).ADD,
+              "blob-num-context": c.type === $(g).EQUAL
+            }])
+          }, $e(c.num), 3),
+          k("td", {
+            class: ge(["blob-code", {
+              "blob-code-deletion": c.type === $(g).DELETE,
+              "blob-code-addition": c.type === $(g).ADD,
+              "blob-code-context": c.type === $(g).EQUAL
+            }])
+          }, [
+            k("span", {
+              class: "blob-code-inner blob-code-marker",
+              "data-code-marker": n(c.type),
+              innerHTML: c.code
+            }, null, 8, Es)
+          ], 2)
+        ], 64))
+      ], 64))), 256))
+    ]));
+  }
+}), ms = { class: "file" }, ys = { class: "file-diff-split diff-table" }, Ns = /* @__PURE__ */ k("colgroup", null, [
+  /* @__PURE__ */ k("col", { width: "44" }),
+  /* @__PURE__ */ k("col"),
+  /* @__PURE__ */ k("col", { width: "44" }),
+  /* @__PURE__ */ k("col")
+], -1), As = /* @__PURE__ */ _e({
+  __name: "SplitViewer",
+  props: {
+    diffChange: null
+  },
+  setup(e) {
+    return (n, t) => (P(), G("div", ms, [
+      k("table", ys, [
+        Ns,
+        k("tbody", null, [
+          (P(!0), G(ue, null, He(e.diffChange, (s, c) => (P(), Re(_s, {
+            key: c,
+            "split-line": s
+          }, null, 8, ["split-line"]))), 128))
+        ])
+      ])
+    ]));
+  }
+});
+const vs = { class: "code-diff-view" }, Ts = /* @__PURE__ */ _e({
+  __name: "CodeDiff",
+  props: {
+    newString: null,
+    oldString: null,
+    language: { default: "plaintext" },
+    context: { default: 10 },
+    diffStyle: { default: "word" },
+    outputFormat: { default: "line-by-line" },
+    trim: { type: Boolean, default: !1 },
+    noDiffLineFeed: { type: Boolean, default: !1 }
+  },
+  setup(e) {
+    const n = e, t = ve(() => n.outputFormat === "line-by-line"), s = ve(() => {
+      const i = n.trim ? n.oldString.trim() : n.oldString;
+      return n.noDiffLineFeed ? i.replace(/(\r\n)/g, `
+`) : i;
+    }), c = ve(() => {
+      const i = n.trim ? n.newString.trim() : n.newString;
+      return n.noDiffLineFeed ? i.replace(/(\r\n)/g, `
+`) : i;
+    }), l = ve(
+      () => t.value ? jt(s.value, c.value, n.language, n.diffStyle, n.context) : Vt(s.value, c.value, n.language, n.diffStyle, n.context)
+    );
+    return (i, r) => (P(), G("div", vs, [
+      $(t) ? (P(), Re(ls, {
+        key: 0,
+        "diff-change": $(l)
+      }, null, 8, ["diff-change"])) : (P(), Re(As, {
+        key: 1,
+        "diff-change": $(l)
+      }, null, 8, ["diff-change"]))
+    ]));
+  }
+}), ws = (e) => {
+  e.component("CodeDiff", Ts);
+}, Ms = {
+  install: ws,
+  hljs: Z
+};
+export {
+  Ts as CodeDiff,
+  Ms as default
+};