v-code-diff 0.3.12 → 1.0.0-alpha.1

package/dist/v2/index.es.js

@@ -0,0 +1,4526 @@
+(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 ke from "vue";
+import kn, { computed as ye } from "@vue/composition-api/dist/vue-composition-api.mjs";
+function $n(e) {
+  e = e || ke, e && !e.__composition_api_installed__ && e.use(kn);
+}
+$n(ke);
+ke.version;
+function Z() {
+}
+Z.prototype = {
+  diff: function(n, t) {
+    var s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, l = s.callback;
+    typeof s == "function" && (l = s, s = {}), this.options = s;
+    var c = this;
+    function i(g) {
+      return l ? (setTimeout(function() {
+        l(void 0, g);
+      }, 0), !0) : g;
+    }
+    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, p = r + a;
+    s.maxEditLength && (p = Math.min(p, s.maxEditLength));
+    var _ = [{
+      newPos: -1,
+      components: []
+    }], f = this.extractCommon(_[0], t, n, 0);
+    if (_[0].newPos + 1 >= r && f + 1 >= a)
+      return i([{
+        value: this.join(t),
+        count: t.length
+      }]);
+    function N() {
+      for (var g = -1 * o; g <= o; g += 2) {
+        var A = void 0, S = _[g - 1], x = _[g + 1], y = (x ? x.newPos : 0) - g;
+        S && (_[g - 1] = void 0);
+        var R = S && S.newPos + 1 < r, L = x && 0 <= y && y < a;
+        if (!R && !L) {
+          _[g] = void 0;
+          continue;
+        }
+        if (!R || L && S.newPos < x.newPos ? (A = Un(x), c.pushComponent(A.components, void 0, !0)) : (A = S, A.newPos++, c.pushComponent(A.components, !0, void 0)), y = c.extractCommon(A, t, n, g), A.newPos + 1 >= r && y + 1 >= a)
+          return i(Bn(c, A.components, t, n, c.useLongestToken));
+        _[g] = A;
+      }
+      o++;
+    }
+    if (l)
+      (function g() {
+        setTimeout(function() {
+          if (o > p)
+            return l();
+          N() || g();
+        }, 0);
+      })();
+    else
+      for (; o <= p; ) {
+        var h = N();
+        if (h)
+          return h;
+      }
+  },
+  pushComponent: function(n, t, s) {
+    var l = n[n.length - 1];
+    l && l.added === t && l.removed === s ? n[n.length - 1] = {
+      count: l.count + 1,
+      added: t,
+      removed: s
+    } : n.push({
+      count: 1,
+      added: t,
+      removed: s
+    });
+  },
+  extractCommon: function(n, t, s, l) {
+    for (var c = t.length, i = s.length, r = n.newPos, a = r - l, o = 0; r + 1 < c && 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 Bn(e, n, t, s, l) {
+  for (var c = 0, i = n.length, r = 0, a = 0; c < i; c++) {
+    var o = n[c];
+    if (o.removed) {
+      if (o.value = e.join(s.slice(a, a + o.count)), a += o.count, c && n[c - 1].added) {
+        var _ = n[c - 1];
+        n[c - 1] = n[c], n[c] = _;
+      }
+    } else {
+      if (!o.added && l) {
+        var p = t.slice(r, r + o.count);
+        p = p.map(function(N, h) {
+          var g = s[a + h];
+          return g.length > N.length ? g : N;
+        }), o.value = e.join(p);
+      } else
+        o.value = e.join(t.slice(r, r + o.count));
+      r += o.count, o.added || (a += o.count);
+    }
+  }
+  var f = n[i - 1];
+  return i > 1 && typeof f.value == "string" && (f.added || f.removed) && e.equals("", f.value) && (n[i - 2].value += f.value, n.pop()), n;
+}
+function Un(e) {
+  return {
+    newPos: e.newPos,
+    components: e.components.slice(0)
+  };
+}
+var Pn = new Z();
+function Hn(e, n, t) {
+  return Pn.diff(e, n, t);
+}
+function zn(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 Xe = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/, Ve = /\S/, $e = new Z();
+$e.equals = function(e, n) {
+  return this.options.ignoreCase && (e = e.toLowerCase(), n = n.toLowerCase()), e === n || this.options.ignoreWhitespace && !Ve.test(e) && !Ve.test(n);
+};
+$e.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] && Xe.test(n[t]) && Xe.test(n[t + 2]) && (n[t] += n[t + 2], n.splice(t + 1, 2), t--);
+  return n;
+};
+function Fn(e, n, t) {
+  return t = zn(t, {
+    ignoreWhitespace: !0
+  }), $e.diff(e, n, t);
+}
+var Be = new Z();
+Be.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 l = t[s];
+    s % 2 && !this.options.newlineIsToken ? n[n.length - 1] += l : (this.options.ignoreWhitespace && (l = l.trim()), n.push(l));
+  }
+  return n;
+};
+function gn(e, n, t) {
+  return Be.diff(e, n, t);
+}
+var Gn = new Z();
+Gn.tokenize = function(e) {
+  return e.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var Kn = new Z();
+Kn.tokenize = function(e) {
+  return e.split(/([{}:;,]|\s+)/);
+};
+function Ae(e) {
+  return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? Ae = function(n) {
+    return typeof n;
+  } : Ae = function(n) {
+    return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+  }, Ae(e);
+}
+var Wn = Object.prototype.toString, ce = new Z();
+ce.useLongestToken = !0;
+ce.tokenize = Be.tokenize;
+ce.castInput = function(e) {
+  var n = this.options, t = n.undefinedReplacement, s = n.stringifyReplacer, l = s === void 0 ? function(c, i) {
+    return typeof i > "u" ? t : i;
+  } : s;
+  return typeof e == "string" ? e : JSON.stringify(Ce(e, null, null, l), l, "  ");
+};
+ce.equals = function(e, n) {
+  return Z.prototype.equals.call(ce, e.replace(/,([\r\n])/g, "$1"), n.replace(/,([\r\n])/g, "$1"));
+};
+function Ce(e, n, t, s, l) {
+  n = n || [], t = t || [], s && (e = s(l, e));
+  var c;
+  for (c = 0; c < n.length; c += 1)
+    if (n[c] === e)
+      return t[c];
+  var i;
+  if (Wn.call(e) === "[object Array]") {
+    for (n.push(e), i = new Array(e.length), t.push(i), c = 0; c < e.length; c += 1)
+      i[c] = Ce(e[c], n, t, s, l);
+    return n.pop(), t.pop(), i;
+  }
+  if (e && e.toJSON && (e = e.toJSON()), Ae(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(), c = 0; c < r.length; c += 1)
+      a = r[c], i[a] = Ce(e[a], n, t, s, a);
+    n.pop(), t.pop();
+  } else
+    i = e;
+  return i;
+}
+var Ie = new Z();
+Ie.tokenize = function(e) {
+  return e.slice();
+};
+Ie.join = Ie.removeEmpty = function(e) {
+  return e;
+};
+var Ue = { exports: {} };
+function Pe(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) && Pe(t);
+  }), e;
+}
+Ue.exports = Pe;
+Ue.exports.default = Pe;
+class je {
+  /**
+   * @param {CompiledMode} mode
+   */
+  constructor(n) {
+    n.data === void 0 && (n.data = {}), this.data = n.data, this.isMatchIgnored = !1;
+  }
+  ignoreMatch() {
+    this.isMatchIgnored = !0;
+  }
+}
+function pn(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function V(e, ...n) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const s in e)
+    t[s] = e[s];
+  return n.forEach(function(s) {
+    for (const l in s)
+      t[l] = s[l];
+  }), /** @type {T} */
+  t;
+}
+const qn = "</span>", Je = (e) => !!e.scope || e.sublanguage && e.language, Yn = (e, { prefix: n }) => {
+  if (e.includes(".")) {
+    const t = e.split(".");
+    return [
+      `${n}${t.shift()}`,
+      ...t.map((s, l) => `${s}${"_".repeat(l + 1)}`)
+    ].join(" ");
+  }
+  return `${n}${e}`;
+};
+class Zn {
+  /**
+   * 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 += pn(n);
+  }
+  /**
+   * Adds a node open to the output stream (if needed)
+   *
+   * @param {Node} node */
+  openNode(n) {
+    if (!Je(n))
+      return;
+    let t = "";
+    n.sublanguage ? t = `language-${n.language}` : t = Yn(n.scope, { prefix: this.classPrefix }), this.span(t);
+  }
+  /**
+   * Adds a node close to the output stream (if needed)
+   *
+   * @param {Node} node */
+  closeNode(n) {
+    Je(n) && (this.buffer += qn);
+  }
+  /**
+   * returns the accumulated buffer
+  */
+  value() {
+    return this.buffer;
+  }
+  // helpers
+  /**
+   * Builds a span element
+   *
+   * @param {string} className */
+  span(n) {
+    this.buffer += `<span class="${n}">`;
+  }
+}
+const en = (e = {}) => {
+  const n = { children: [] };
+  return Object.assign(n, e), n;
+};
+class He {
+  constructor() {
+    this.rootNode = en(), 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 = en({ 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) => {
+      He._collapse(t);
+    }));
+  }
+}
+class Qn extends He {
+  /**
+   * @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 Zn(this, this.options).value();
+  }
+  finalize() {
+    return !0;
+  }
+}
+function le(e) {
+  return e ? typeof e == "string" ? e : e.source : null;
+}
+function _n(e) {
+  return ee("(?=", e, ")");
+}
+function Xn(e) {
+  return ee("(?:", e, ")*");
+}
+function Vn(e) {
+  return ee("(?:", e, ")?");
+}
+function ee(...e) {
+  return e.map((t) => le(t)).join("");
+}
+function jn(e) {
+  const n = e[e.length - 1];
+  return typeof n == "object" && n.constructor === Object ? (e.splice(e.length - 1, 1), n) : {};
+}
+function ze(...e) {
+  return "(" + (jn(e).capture ? "" : "?:") + e.map((s) => le(s)).join("|") + ")";
+}
+function bn(e) {
+  return new RegExp(e.toString() + "|").exec("").length - 1;
+}
+function Jn(e, n) {
+  const t = e && e.exec(n);
+  return t && t.index === 0;
+}
+const et = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+function Fe(e, { joinWith: n }) {
+  let t = 0;
+  return e.map((s) => {
+    t += 1;
+    const l = t;
+    let c = le(s), i = "";
+    for (; c.length > 0; ) {
+      const r = et.exec(c);
+      if (!r) {
+        i += c;
+        break;
+      }
+      i += c.substring(0, r.index), c = c.substring(r.index + r[0].length), r[0][0] === "\\" && r[1] ? i += "\\" + String(Number(r[1]) + l) : (i += r[0], r[0] === "(" && t++);
+    }
+    return i;
+  }).map((s) => `(${s})`).join(n);
+}
+const nt = /\b\B/, hn = "[a-zA-Z]\\w*", Ge = "[a-zA-Z_]\\w*", En = "\\b\\d+(\\.\\d+)?", mn = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", yn = "\\b(0b[01]+)", tt = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", st = (e = {}) => {
+  const n = /^#![ ]*\//;
+  return e.binary && (e.begin = ee(
+    n,
+    /.*\b/,
+    e.binary,
+    /\b.*/
+  )), V({
+    scope: "meta",
+    begin: n,
+    end: /$/,
+    relevance: 0,
+    /** @type {ModeCallback} */
+    "on:begin": (t, s) => {
+      t.index !== 0 && s.ignoreMatch();
+    }
+  }, e);
+}, ue = {
+  begin: "\\\\[\\s\\S]",
+  relevance: 0
+}, rt = {
+  scope: "string",
+  begin: "'",
+  end: "'",
+  illegal: "\\n",
+  contains: [ue]
+}, it = {
+  scope: "string",
+  begin: '"',
+  end: '"',
+  illegal: "\\n",
+  contains: [ue]
+}, at = {
+  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/
+}, Me = function(e, n, t = {}) {
+  const s = V(
+    {
+      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 l = ze(
+    // 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: ee(
+        /[ ]+/,
+        // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+        "(",
+        l,
+        /[.]?[:]?([.][ ]|[ ])/,
+        "){3}"
+      )
+      // look for 3 words in a row
+    }
+  ), s;
+}, ot = Me("//", "$"), ct = Me("/\\*", "\\*/"), lt = Me("#", "$"), ut = {
+  scope: "number",
+  begin: En,
+  relevance: 0
+}, ft = {
+  scope: "number",
+  begin: mn,
+  relevance: 0
+}, dt = {
+  scope: "number",
+  begin: yn,
+  relevance: 0
+}, gt = {
+  // 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: [
+      ue,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [ue]
+      }
+    ]
+  }]
+}, pt = {
+  scope: "title",
+  begin: hn,
+  relevance: 0
+}, _t = {
+  scope: "title",
+  begin: Ge,
+  relevance: 0
+}, bt = {
+  // excludes method names from keyword processing
+  begin: "\\.\\s*" + Ge,
+  relevance: 0
+}, ht = 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 ve = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  MATCH_NOTHING_RE: nt,
+  IDENT_RE: hn,
+  UNDERSCORE_IDENT_RE: Ge,
+  NUMBER_RE: En,
+  C_NUMBER_RE: mn,
+  BINARY_NUMBER_RE: yn,
+  RE_STARTERS_RE: tt,
+  SHEBANG: st,
+  BACKSLASH_ESCAPE: ue,
+  APOS_STRING_MODE: rt,
+  QUOTE_STRING_MODE: it,
+  PHRASAL_WORDS_MODE: at,
+  COMMENT: Me,
+  C_LINE_COMMENT_MODE: ot,
+  C_BLOCK_COMMENT_MODE: ct,
+  HASH_COMMENT_MODE: lt,
+  NUMBER_MODE: ut,
+  C_NUMBER_MODE: ft,
+  BINARY_NUMBER_MODE: dt,
+  REGEXP_MODE: gt,
+  TITLE_MODE: pt,
+  UNDERSCORE_TITLE_MODE: _t,
+  METHOD_GUARD: bt,
+  END_SAME_AS_BEGIN: ht
+});
+function Et(e, n) {
+  e.input[e.index - 1] === "." && n.ignoreMatch();
+}
+function mt(e, n) {
+  e.className !== void 0 && (e.scope = e.className, delete e.className);
+}
+function yt(e, n) {
+  n && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Et, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+}
+function vt(e, n) {
+  Array.isArray(e.illegal) && (e.illegal = ze(...e.illegal));
+}
+function Nt(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 Tt(e, n) {
+  e.relevance === void 0 && (e.relevance = 1);
+}
+const At = (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 = ee(t.beforeMatch, _n(t.begin)), e.starts = {
+    relevance: 0,
+    contains: [
+      Object.assign(t, { endsParent: !0 })
+    ]
+  }, e.relevance = 0, delete t.beforeMatch;
+}, wt = [
+  "of",
+  "and",
+  "for",
+  "in",
+  "not",
+  "or",
+  "if",
+  "then",
+  "parent",
+  // common variable name
+  "list",
+  // common variable name
+  "value"
+  // common variable name
+], St = "keyword";
+function vn(e, n, t = St) {
+  const s = /* @__PURE__ */ Object.create(null);
+  return typeof e == "string" ? l(t, e.split(" ")) : Array.isArray(e) ? l(t, e) : Object.keys(e).forEach(function(c) {
+    Object.assign(
+      s,
+      vn(e[c], n, c)
+    );
+  }), s;
+  function l(c, i) {
+    n && (i = i.map((r) => r.toLowerCase())), i.forEach(function(r) {
+      const a = r.split("|");
+      s[a[0]] = [c, Mt(a[0], a[1])];
+    });
+  }
+}
+function Mt(e, n) {
+  return n ? Number(n) : Rt(e) ? 0 : 1;
+}
+function Rt(e) {
+  return wt.includes(e.toLowerCase());
+}
+const nn = {}, J = (e) => {
+  console.error(e);
+}, tn = (e, ...n) => {
+  console.log(`WARN: ${e}`, ...n);
+}, re = (e, n) => {
+  nn[`${e}/${n}`] || (console.log(`Deprecated as of ${e}. ${n}`), nn[`${e}/${n}`] = !0);
+}, we = new Error();
+function Nn(e, n, { key: t }) {
+  let s = 0;
+  const l = e[t], c = {}, i = {};
+  for (let r = 1; r <= n.length; r++)
+    i[r + s] = l[r], c[r + s] = !0, s += bn(n[r - 1]);
+  e[t] = i, e[t]._emit = c, e[t]._multi = !0;
+}
+function Ot(e) {
+  if (Array.isArray(e.begin)) {
+    if (e.skip || e.excludeBegin || e.returnBegin)
+      throw J("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), we;
+    if (typeof e.beginScope != "object" || e.beginScope === null)
+      throw J("beginScope must be object"), we;
+    Nn(e, e.begin, { key: "beginScope" }), e.begin = Fe(e.begin, { joinWith: "" });
+  }
+}
+function xt(e) {
+  if (Array.isArray(e.end)) {
+    if (e.skip || e.excludeEnd || e.returnEnd)
+      throw J("skip, excludeEnd, returnEnd not compatible with endScope: {}"), we;
+    if (typeof e.endScope != "object" || e.endScope === null)
+      throw J("endScope must be object"), we;
+    Nn(e, e.end, { key: "endScope" }), e.end = Fe(e.end, { joinWith: "" });
+  }
+}
+function Lt(e) {
+  e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+}
+function Dt(e) {
+  Lt(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Ot(e), xt(e);
+}
+function Ct(e) {
+  function n(i, r) {
+    return new RegExp(
+      le(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 += bn(r) + 1;
+    }
+    compile() {
+      this.regexes.length === 0 && (this.exec = () => null);
+      const r = this.regexes.map((a) => a[1]);
+      this.matcherRe = n(Fe(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((_, f) => f > 0 && _ !== void 0), p = this.matchIndexes[o];
+      return a.splice(0, o), Object.assign(a, p);
+    }
+  }
+  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, p]) => a.addRule(o, p)), 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 p = this.getMatcher(0);
+        p.lastIndex = this.lastIndex + 1, o = p.exec(r);
+      }
+      return o && (this.regexIndex += o.position + 1, this.regexIndex === this.count && this.considerAll()), o;
+    }
+  }
+  function l(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 c(i, r) {
+    const a = (
+      /** @type CompiledMode */
+      i
+    );
+    if (i.isCompiled)
+      return a;
+    [
+      mt,
+      // do this early so compiler extensions generally don't have to worry about
+      // the distinction between match/begin
+      Nt,
+      Dt,
+      At
+    ].forEach((p) => p(i, r)), e.compilerExtensions.forEach((p) => p(i, r)), i.__beforeBegin = null, [
+      yt,
+      // do this later so compiler extensions that come earlier have access to the
+      // raw array if they wanted to perhaps manipulate it, etc.
+      vt,
+      // default to 1 relevance if not specified
+      Tt
+    ].forEach((p) => p(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 = vn(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 = le(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(p) {
+      return It(p === "self" ? i : p);
+    })), i.contains.forEach(function(p) {
+      c(
+        /** @type Mode */
+        p,
+        a
+      );
+    }), i.starts && c(i.starts, r), a.matcher = l(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 = V(e.classNameAliases || {}), c(
+    /** @type Mode */
+    e
+  );
+}
+function Tn(e) {
+  return e ? e.endsWithParent || Tn(e.starts) : !1;
+}
+function It(e) {
+  return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(n) {
+    return V(e, { variants: null }, n);
+  })), e.cachedVariants ? e.cachedVariants : Tn(e) ? V(e, { starts: e.starts ? V(e.starts) : null }) : Object.isFrozen(e) ? V(e) : e;
+}
+var kt = "11.7.0";
+class $t extends Error {
+  constructor(n, t) {
+    super(n), this.name = "HTMLInjectionError", this.html = t;
+  }
+}
+const De = pn, sn = V, rn = Symbol("nomatch"), Bt = 7, Ut = function(e) {
+  const n = /* @__PURE__ */ Object.create(null), t = /* @__PURE__ */ Object.create(null), s = [];
+  let l = !0;
+  const c = "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: Qn
+  };
+  function a(u) {
+    return r.noHighlightRe.test(u);
+  }
+  function o(u) {
+    let b = u.className + " ";
+    b += u.parentNode ? u.parentNode.className : "";
+    const T = r.languageDetectRe.exec(b);
+    if (T) {
+      const M = z(T[1]);
+      return M || (tn(c.replace("{}", T[1])), tn("Falling back to no-highlight mode for this block.", u)), M ? T[1] : "no-highlight";
+    }
+    return b.split(/\s+/).find((M) => a(M) || z(M));
+  }
+  function p(u, b, T) {
+    let M = "", I = "";
+    typeof b == "object" ? (M = u, T = b.ignoreIllegals, I = b.language) : (re("10.7.0", "highlight(lang, code, ...args) has been deprecated."), re("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), I = u, M = b), T === void 0 && (T = !0);
+    const U = {
+      code: M,
+      language: I
+    };
+    se("before:highlight", U);
+    const K = U.result ? U.result : _(U.language, U.code, T);
+    return K.code = U.code, se("after:highlight", K), K;
+  }
+  function _(u, b, T, M) {
+    const I = /* @__PURE__ */ Object.create(null);
+    function U(d, E) {
+      return d.keywords[E];
+    }
+    function K() {
+      if (!v.keywords) {
+        $.addText(C);
+        return;
+      }
+      let d = 0;
+      v.keywordPatternRe.lastIndex = 0;
+      let E = v.keywordPatternRe.exec(C), w = "";
+      for (; E; ) {
+        w += C.substring(d, E.index);
+        const O = X.case_insensitive ? E[0].toLowerCase() : E[0], B = U(v, O);
+        if (B) {
+          const [W, Cn] = B;
+          if ($.addText(w), w = "", I[O] = (I[O] || 0) + 1, I[O] <= Bt && (me += Cn), W.startsWith("_"))
+            w += E[0];
+          else {
+            const In = X.classNameAliases[W] || W;
+            $.addKeyword(E[0], In);
+          }
+        } else
+          w += E[0];
+        d = v.keywordPatternRe.lastIndex, E = v.keywordPatternRe.exec(C);
+      }
+      w += C.substring(d), $.addText(w);
+    }
+    function he() {
+      if (C === "")
+        return;
+      let d = null;
+      if (typeof v.subLanguage == "string") {
+        if (!n[v.subLanguage]) {
+          $.addText(C);
+          return;
+        }
+        d = _(v.subLanguage, C, !0, Qe[v.subLanguage]), Qe[v.subLanguage] = /** @type {CompiledMode} */
+        d._top;
+      } else
+        d = N(C, v.subLanguage.length ? v.subLanguage : null);
+      v.relevance > 0 && (me += d.relevance), $.addSublanguage(d._emitter, d.language);
+    }
+    function P() {
+      v.subLanguage != null ? he() : K(), C = "";
+    }
+    function Q(d, E) {
+      let w = 1;
+      const O = E.length - 1;
+      for (; w <= O; ) {
+        if (!d._emit[w]) {
+          w++;
+          continue;
+        }
+        const B = X.classNameAliases[d[w]] || d[w], W = E[w];
+        B ? $.addKeyword(W, B) : (C = W, K(), C = ""), w++;
+      }
+    }
+    function qe(d, E) {
+      return d.scope && typeof d.scope == "string" && $.openNode(X.classNameAliases[d.scope] || d.scope), d.beginScope && (d.beginScope._wrap ? ($.addKeyword(C, X.classNameAliases[d.beginScope._wrap] || d.beginScope._wrap), C = "") : d.beginScope._multi && (Q(d.beginScope, E), C = "")), v = Object.create(d, { parent: { value: v } }), v;
+    }
+    function Ye(d, E, w) {
+      let O = Jn(d.endRe, w);
+      if (O) {
+        if (d["on:end"]) {
+          const B = new je(d);
+          d["on:end"](E, B), B.isMatchIgnored && (O = !1);
+        }
+        if (O) {
+          for (; d.endsParent && d.parent; )
+            d = d.parent;
+          return d;
+        }
+      }
+      if (d.endsWithParent)
+        return Ye(d.parent, E, w);
+    }
+    function Rn(d) {
+      return v.matcher.regexIndex === 0 ? (C += d[0], 1) : (Le = !0, 0);
+    }
+    function On(d) {
+      const E = d[0], w = d.rule, O = new je(w), B = [w.__beforeBegin, w["on:begin"]];
+      for (const W of B)
+        if (W && (W(d, O), O.isMatchIgnored))
+          return Rn(E);
+      return w.skip ? C += E : (w.excludeBegin && (C += E), P(), !w.returnBegin && !w.excludeBegin && (C = E)), qe(w, d), w.returnBegin ? 0 : E.length;
+    }
+    function xn(d) {
+      const E = d[0], w = b.substring(d.index), O = Ye(v, d, w);
+      if (!O)
+        return rn;
+      const B = v;
+      v.endScope && v.endScope._wrap ? (P(), $.addKeyword(E, v.endScope._wrap)) : v.endScope && v.endScope._multi ? (P(), Q(v.endScope, d)) : B.skip ? C += E : (B.returnEnd || B.excludeEnd || (C += E), P(), B.excludeEnd && (C = E));
+      do
+        v.scope && $.closeNode(), !v.skip && !v.subLanguage && (me += v.relevance), v = v.parent;
+      while (v !== O.parent);
+      return O.starts && qe(O.starts, d), B.returnEnd ? 0 : E.length;
+    }
+    function Ln() {
+      const d = [];
+      for (let E = v; E !== X; E = E.parent)
+        E.scope && d.unshift(E.scope);
+      d.forEach((E) => $.openNode(E));
+    }
+    let Ee = {};
+    function Ze(d, E) {
+      const w = E && E[0];
+      if (C += d, w == null)
+        return P(), 0;
+      if (Ee.type === "begin" && E.type === "end" && Ee.index === E.index && w === "") {
+        if (C += b.slice(E.index, E.index + 1), !l) {
+          const O = new Error(`0 width match regex (${u})`);
+          throw O.languageName = u, O.badRule = Ee.rule, O;
+        }
+        return 1;
+      }
+      if (Ee = E, E.type === "begin")
+        return On(E);
+      if (E.type === "illegal" && !T) {
+        const O = new Error('Illegal lexeme "' + w + '" for mode "' + (v.scope || "<unnamed>") + '"');
+        throw O.mode = v, O;
+      } else if (E.type === "end") {
+        const O = xn(E);
+        if (O !== rn)
+          return O;
+      }
+      if (E.type === "illegal" && w === "")
+        return 1;
+      if (xe > 1e5 && xe > E.index * 3)
+        throw new Error("potential infinite loop, way more iterations than matches");
+      return C += w, w.length;
+    }
+    const X = z(u);
+    if (!X)
+      throw J(c.replace("{}", u)), new Error('Unknown language: "' + u + '"');
+    const Dn = Ct(X);
+    let Oe = "", v = M || Dn;
+    const Qe = {}, $ = new r.__emitter(r);
+    Ln();
+    let C = "", me = 0, j = 0, xe = 0, Le = !1;
+    try {
+      for (v.matcher.considerAll(); ; ) {
+        xe++, Le ? Le = !1 : v.matcher.considerAll(), v.matcher.lastIndex = j;
+        const d = v.matcher.exec(b);
+        if (!d)
+          break;
+        const E = b.substring(j, d.index), w = Ze(E, d);
+        j = d.index + w;
+      }
+      return Ze(b.substring(j)), $.closeAllNodes(), $.finalize(), Oe = $.toHTML(), {
+        language: u,
+        value: Oe,
+        relevance: me,
+        illegal: !1,
+        _emitter: $,
+        _top: v
+      };
+    } catch (d) {
+      if (d.message && d.message.includes("Illegal"))
+        return {
+          language: u,
+          value: De(b),
+          illegal: !0,
+          relevance: 0,
+          _illegalBy: {
+            message: d.message,
+            index: j,
+            context: b.slice(j - 100, j + 100),
+            mode: d.mode,
+            resultSoFar: Oe
+          },
+          _emitter: $
+        };
+      if (l)
+        return {
+          language: u,
+          value: De(b),
+          illegal: !1,
+          relevance: 0,
+          errorRaised: d,
+          _emitter: $,
+          _top: v
+        };
+      throw d;
+    }
+  }
+  function f(u) {
+    const b = {
+      value: De(u),
+      illegal: !1,
+      relevance: 0,
+      _top: i,
+      _emitter: new r.__emitter(r)
+    };
+    return b._emitter.addText(u), b;
+  }
+  function N(u, b) {
+    b = b || r.languages || Object.keys(n);
+    const T = f(u), M = b.filter(z).filter(te).map(
+      (P) => _(P, u, !1)
+    );
+    M.unshift(T);
+    const I = M.sort((P, Q) => {
+      if (P.relevance !== Q.relevance)
+        return Q.relevance - P.relevance;
+      if (P.language && Q.language) {
+        if (z(P.language).supersetOf === Q.language)
+          return 1;
+        if (z(Q.language).supersetOf === P.language)
+          return -1;
+      }
+      return 0;
+    }), [U, K] = I, he = U;
+    return he.secondBest = K, he;
+  }
+  function h(u, b, T) {
+    const M = b && t[b] || T;
+    u.classList.add("hljs"), u.classList.add(`language-${M}`);
+  }
+  function g(u) {
+    let b = null;
+    const T = o(u);
+    if (a(T))
+      return;
+    if (se(
+      "before:highlightElement",
+      { el: u, language: T }
+    ), 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 $t(
+        "One of your code blocks includes unescaped HTML.",
+        u.innerHTML
+      );
+    b = u;
+    const M = b.textContent, I = T ? p(M, { language: T, ignoreIllegals: !0 }) : N(M);
+    u.innerHTML = I.value, h(u, T, 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
+    }), se("after:highlightElement", { el: u, result: I, text: M });
+  }
+  function A(u) {
+    r = sn(r, u);
+  }
+  const S = () => {
+    R(), re("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+  };
+  function x() {
+    R(), re("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(g);
+  }
+  function L() {
+    y && R();
+  }
+  typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", L, !1);
+  function D(u, b) {
+    let T = null;
+    try {
+      T = b(e);
+    } catch (M) {
+      if (J("Language definition for '{}' could not be registered.".replace("{}", u)), l)
+        J(M);
+      else
+        throw M;
+      T = i;
+    }
+    T.name || (T.name = u), n[u] = T, T.rawDefinition = b.bind(null, e), T.aliases && ne(T.aliases, { languageName: u });
+  }
+  function k(u) {
+    delete n[u];
+    for (const b of Object.keys(t))
+      t[b] === u && delete t[b];
+  }
+  function H() {
+    return Object.keys(n);
+  }
+  function z(u) {
+    return u = (u || "").toLowerCase(), n[u] || n[t[u]];
+  }
+  function ne(u, { languageName: b }) {
+    typeof u == "string" && (u = [u]), u.forEach((T) => {
+      t[T.toLowerCase()] = b;
+    });
+  }
+  function te(u) {
+    const b = z(u);
+    return b && !b.disableAutodetect;
+  }
+  function oe(u) {
+    u["before:highlightBlock"] && !u["before:highlightElement"] && (u["before:highlightElement"] = (b) => {
+      u["before:highlightBlock"](
+        Object.assign({ block: b.el }, b)
+      );
+    }), u["after:highlightBlock"] && !u["after:highlightElement"] && (u["after:highlightElement"] = (b) => {
+      u["after:highlightBlock"](
+        Object.assign({ block: b.el }, b)
+      );
+    });
+  }
+  function Re(u) {
+    oe(u), s.push(u);
+  }
+  function se(u, b) {
+    const T = u;
+    s.forEach(function(M) {
+      M[T] && M[T](b);
+    });
+  }
+  function be(u) {
+    return re("10.7.0", "highlightBlock will be removed entirely in v12.0"), re("10.7.0", "Please use highlightElement now."), g(u);
+  }
+  Object.assign(e, {
+    highlight: p,
+    highlightAuto: N,
+    highlightAll: R,
+    highlightElement: g,
+    // TODO: Remove with v12 API
+    highlightBlock: be,
+    configure: A,
+    initHighlighting: S,
+    initHighlightingOnLoad: x,
+    registerLanguage: D,
+    unregisterLanguage: k,
+    listLanguages: H,
+    getLanguage: z,
+    registerAliases: ne,
+    autoDetection: te,
+    inherit: sn,
+    addPlugin: Re
+  }), e.debugMode = function() {
+    l = !1;
+  }, e.safeMode = function() {
+    l = !0;
+  }, e.versionString = kt, e.regex = {
+    concat: ee,
+    lookahead: _n,
+    either: ze,
+    optional: Vn,
+    anyNumberOfTimes: Xn
+  };
+  for (const u in ve)
+    typeof ve[u] == "object" && Ue.exports(ve[u]);
+  return Object.assign(e, ve), e;
+};
+var fe = Ut({}), Pt = fe;
+fe.HighlightJS = fe;
+fe.default = fe;
+const G = Pt;
+function Ht(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, l = {
+    className: "symbol",
+    begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
+  }, c = {
+    begin: /\s/,
+    contains: [
+      {
+        className: "keyword",
+        begin: /#?[a-z_][a-z1-9_-]+/,
+        illegal: /\n/
+      }
+    ]
+  }, i = e.inherit(c, {
+    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: [l]
+              },
+              {
+                begin: /'/,
+                end: /'/,
+                contains: [l]
+              },
+              { 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: [
+          c,
+          a,
+          r,
+          i,
+          {
+            begin: /\[/,
+            end: /\]/,
+            contains: [
+              {
+                className: "meta",
+                begin: /<![a-z]/,
+                end: />/,
+                contains: [
+                  c,
+                  i,
+                  a,
+                  r
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      e.COMMENT(
+        /<!--/,
+        /-->/,
+        { relevance: 10 }
+      ),
+      {
+        begin: /<!\[CDATA\[/,
+        end: /\]\]>/,
+        relevance: 10
+      },
+      l,
+      // 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 an = "[A-Za-z$_][0-9A-Za-z$_]*", zt = [
+  "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"
+], Ft = [
+  "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"
+], wn = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], Sn = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], Gt = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "module",
+  "global"
+  // Node.js
+], Kt = [].concat(
+  Sn,
+  An,
+  wn
+);
+function Wt(e) {
+  const n = e.regex, t = (b, { after: T }) => {
+    const M = "</" + b[0].slice(1);
+    return b.input.indexOf(M, T) !== -1;
+  }, s = an, l = {
+    begin: "<>",
+    end: "</>"
+  }, c = /<[A-Za-z0-9\\._:-]+\s*\/>/, i = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (b, T) => {
+      const M = b[0].length + b.index, I = b.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 === ","
+      ) {
+        T.ignoreMatch();
+        return;
+      }
+      I === ">" && (t(b, { after: M }) || T.ignoreMatch());
+      let U;
+      const K = b.input.substring(M);
+      if (U = K.match(/^\s*=/)) {
+        T.ignoreMatch();
+        return;
+      }
+      if ((U = K.match(/^\s+extends\s+/)) && U.index === 0) {
+        T.ignoreMatch();
+        return;
+      }
+    }
+  }, r = {
+    $pattern: an,
+    keyword: zt,
+    literal: Ft,
+    built_in: Kt,
+    "variable.language": Gt
+  }, a = "[0-9](_?[0-9])*", o = `\\.(${a})`, p = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", _ = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${p})((${o})|\\.)?|(${o}))[eE][+-]?(${a})\\b` },
+      { begin: `\\b(${p})\\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
+  }, f = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: r,
+    contains: []
+    // defined later
+  }, N = {
+    begin: "html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        f
+      ],
+      subLanguage: "xml"
+    }
+  }, h = {
+    begin: "css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        f
+      ],
+      subLanguage: "css"
+    }
+  }, g = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      f
+    ]
+  }, 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,
+    N,
+    h,
+    g,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    _
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  f.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, f.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"
+        }
+      }
+    ]
+  }, k = {
+    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,
+        ...wn
+      ]
+    }
+  }, H = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, z = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          s,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [L],
+    illegal: /%/
+  }, ne = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function te(b) {
+    return n.concat("(?!", b.join("|"), ")");
+  }
+  const oe = {
+    match: n.concat(
+      /\b/,
+      te([
+        ...Sn,
+        "super",
+        "import"
+      ]),
+      s,
+      n.lookahead(/\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, Re = {
+    begin: n.concat(/\./, n.lookahead(
+      n.concat(s, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: s,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, se = {
+    match: [
+      /get|set/,
+      /\s+/,
+      s,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      L
+    ]
+  }, be = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", u = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      s,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      n.lookahead(be)
+    ],
+    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: k },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      H,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      N,
+      h,
+      g,
+      S,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      _,
+      k,
+      {
+        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: be,
+            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: l.begin, end: l.end },
+              { match: c },
+              {
+                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"]
+              }
+            ]
+          }
+        ]
+      },
+      z,
+      {
+        // 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
+      },
+      Re,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + s,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [L]
+      },
+      oe,
+      ne,
+      D,
+      se,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function qt(e) {
+  const n = {
+    className: "attr",
+    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    relevance: 1.01
+  }, t = {
+    match: /[{}[\],:]/,
+    className: "punctuation",
+    relevance: 0
+  }, s = [
+    "true",
+    "false",
+    "null"
+  ], l = {
+    scope: "literal",
+    beginKeywords: s.join(" ")
+  };
+  return {
+    name: "JSON",
+    keywords: {
+      literal: s
+    },
+    contains: [
+      n,
+      t,
+      e.QUOTE_STRING_MODE,
+      l,
+      e.C_NUMBER_MODE,
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE
+    ],
+    illegal: "\\S"
+  };
+}
+function Yt(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 :\\/.-]*':(?=[ 	]|$)"
+      }
+    ]
+  }, l = {
+    className: "template-variable",
+    variants: [
+      {
+        // jinja templates Ansible
+        begin: /\{\{/,
+        end: /\}\}/
+      },
+      {
+        // Ruby i18n
+        begin: /%\{/,
+        end: /\}/
+      }
+    ]
+  }, c = {
+    className: "string",
+    relevance: 0,
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      { begin: /\S+/ }
+    ],
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      l
+    ]
+  }, i = e.inherit(c, { 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]*)?", p = "([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?", _ = {
+    className: "number",
+    begin: "\\b" + r + a + o + p + "\\b"
+  }, f = {
+    end: ",",
+    endsWithParent: !0,
+    excludeEnd: !0,
+    keywords: n,
+    relevance: 0
+  }, N = {
+    begin: /\{/,
+    end: /\}/,
+    contains: [f],
+    illegal: "\\n",
+    relevance: 0
+  }, h = {
+    begin: "\\[",
+    end: "\\]",
+    contains: [f],
+    illegal: "\\n",
+    relevance: 0
+  }, g = [
+    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 }
+    },
+    _,
+    // numbers are any valid C-style number that
+    // sit isolated from other words
+    {
+      className: "number",
+      begin: e.C_NUMBER_RE + "\\b",
+      relevance: 0
+    },
+    N,
+    h,
+    c
+  ], A = [...g];
+  return A.pop(), A.push(i), f.contains = A, {
+    name: "YAML",
+    case_insensitive: !0,
+    aliases: ["yml"],
+    contains: g
+  };
+}
+function Zt(e) {
+  return {
+    name: "Plain text",
+    aliases: [
+      "text",
+      "txt"
+    ],
+    disableAutodetect: !0
+  };
+}
+function Qt(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: /#/
+  }, p = {
+    begin: /\{\{/,
+    relevance: 0
+  }, _ = {
+    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,
+          p,
+          o
+        ]
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])"""/,
+        end: /"""/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a,
+          p,
+          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,
+          p,
+          o
+        ]
+      },
+      {
+        begin: /([fF][rR]|[rR][fF]|[fF])"/,
+        end: /"/,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          p,
+          o
+        ]
+      },
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE
+    ]
+  }, f = "[0-9](_?[0-9])*", N = `(\\b(${f}))?\\.(${f})|\\b(${f})\\.`, h = `\\b|${s.join("|")}`, g = {
+    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(${f})|(${N}))[eE][+-]?(${f})[jJ]?(?=${h})`
+      },
+      {
+        begin: `(${N})[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]?(?=${h})`
+      },
+      {
+        begin: `\\b0[bB](_?[01])+[lL]?(?=${h})`
+      },
+      {
+        begin: `\\b0[oO](_?[0-7])+[lL]?(?=${h})`
+      },
+      {
+        begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${h})`
+      },
+      // imagnumber (digitpart-based)
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      {
+        begin: `\\b(${f})[jJ](?=${h})`
+      }
+    ]
+  }, A = {
+    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,
+          g,
+          _,
+          e.HASH_COMMENT_MODE
+        ]
+      }
+    ]
+  };
+  return o.contains = [
+    _,
+    g,
+    a
+  ], {
+    name: "Python",
+    aliases: [
+      "py",
+      "gyp",
+      "ipython"
+    ],
+    unicodeRegex: !0,
+    keywords: r,
+    illegal: /(<\/|->|\?)|=>/,
+    contains: [
+      a,
+      g,
+      {
+        // 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
+      },
+      _,
+      A,
+      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: [
+          g,
+          S,
+          _
+        ]
+      }
+    ]
+  };
+}
+var ie = "[0-9](_*[0-9])*", Ne = `\\.(${ie})`, Te = "[0-9a-fA-F](_*[0-9a-fA-F])*", on = {
+  className: "number",
+  variants: [
+    // DecimalFloatingPointLiteral
+    // including ExponentPart
+    { begin: `(\\b(${ie})((${Ne})|\\.)?|(${Ne}))[eE][+-]?(${ie})[fFdD]?\\b` },
+    // excluding ExponentPart
+    { begin: `\\b(${ie})((${Ne})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+    { begin: `(${Ne})[fFdD]?\\b` },
+    { begin: `\\b(${ie})[fFdD]\\b` },
+    // HexadecimalFloatingPointLiteral
+    { begin: `\\b0[xX]((${Te})\\.?|(${Te})?\\.(${Te}))[pP][+-]?(${ie})[fFdD]?\\b` },
+    // DecimalIntegerLiteral
+    { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" },
+    // HexIntegerLiteral
+    { begin: `\\b0[xX](${Te})[lL]?\\b` },
+    // OctalIntegerLiteral
+    { begin: "\\b0(_*[0-7])*[lL]?\\b" },
+    // BinaryIntegerLiteral
+    { begin: "\\b0[bB][01](_*[01])*[lL]?\\b" }
+  ],
+  relevance: 0
+};
+function Mn(e, n, t) {
+  return t === -1 ? "" : e.replace(n, (s) => Mn(e, n, t - 1));
+}
+function Xt(e) {
+  const n = e.regex, t = "[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*", s = t + Mn("(?:<" + 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
+      }
+    ]
+  }, p = {
+    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: [
+          p,
+          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,
+              on,
+              e.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      on,
+      o
+    ]
+  };
+}
+function Vt(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 l = {
+    className: "subst",
+    begin: /\$\(/,
+    end: /\)/,
+    contains: [e.BACKSLASH_ESCAPE]
+  }, c = {
+    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,
+      l
+    ]
+  };
+  l.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
+    ]
+  }, p = [
+    "fish",
+    "bash",
+    "zsh",
+    "sh",
+    "csh",
+    "ksh",
+    "tcsh",
+    "dash",
+    "scsh"
+  ], _ = e.SHEBANG({
+    binary: `(${p.join("|")})`,
+    relevance: 10
+  }), f = {
+    className: "function",
+    begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
+    returnBegin: !0,
+    contains: [e.inherit(e.TITLE_MODE, { begin: /\w[\w\d_]*/ })],
+    relevance: 0
+  }, N = [
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "in",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "function"
+  ], h = [
+    "true",
+    "false"
+  ], g = { match: /(\/[a-z._-]+)+/ }, A = [
+    "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: N,
+      literal: h,
+      built_in: [
+        ...A,
+        ...S,
+        // Shell modifiers
+        "set",
+        "shopt",
+        ...x,
+        ...y
+      ]
+    },
+    contains: [
+      _,
+      // to catch known shells and boost relevancy
+      e.SHEBANG(),
+      // to catch unknown shells but still highlight the shebang
+      f,
+      o,
+      e.HASH_COMMENT_MODE,
+      c,
+      g,
+      i,
+      r,
+      a,
+      t
+    ]
+  };
+}
+function jt(e) {
+  const n = e.regex, t = e.COMMENT("--", "$"), s = {
+    className: "string",
+    variants: [
+      {
+        begin: /'/,
+        end: /'/,
+        contains: [{ begin: /''/ }]
+      }
+    ]
+  }, l = {
+    begin: /"/,
+    end: /"/,
+    contains: [{ begin: /""/ }]
+  }, c = [
+    "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"
+  ], p = [
+    "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"
+  ], _ = [
+    "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"
+  ], f = [
+    "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"
+  ], N = p, h = [
+    ...o,
+    ...a
+  ].filter((y) => !p.includes(y)), g = {
+    className: "variable",
+    begin: /@[a-z0-9]+/
+  }, A = {
+    className: "operator",
+    begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,
+    relevance: 0
+  }, S = {
+    begin: n.concat(/\b/, n.either(...N), /\s*\(/),
+    relevance: 0,
+    keywords: { built_in: N }
+  };
+  function x(y, {
+    exceptions: R,
+    when: L
+  } = {}) {
+    const D = L;
+    return R = R || [], y.map((k) => k.match(/\|\d+$/) || R.includes(k) ? k : D(k) ? `${k}|0` : k);
+  }
+  return {
+    name: "SQL",
+    case_insensitive: !0,
+    // does not include {} or HTML tags `</`
+    illegal: /[{}]|<\//,
+    keywords: {
+      $pattern: /\b[\w\.]+/,
+      keyword: x(h, { when: (y) => y.length < 3 }),
+      literal: c,
+      type: r,
+      built_in: _
+    },
+    contains: [
+      {
+        begin: n.either(...f),
+        relevance: 0,
+        keywords: {
+          $pattern: /[\w\.]+/,
+          keyword: h.concat(f),
+          literal: c,
+          type: r
+        }
+      },
+      {
+        className: "type",
+        begin: n.either(...i)
+      },
+      S,
+      g,
+      s,
+      l,
+      e.C_NUMBER_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      t,
+      A
+    ]
+  };
+}
+G.registerLanguage("xml", Ht);
+G.registerLanguage("javascript", Wt);
+G.registerLanguage("json", qt);
+G.registerLanguage("yaml", Yt);
+G.registerLanguage("plaintext", Zt);
+G.registerLanguage("python", Qt);
+G.registerLanguage("java", Xt);
+G.registerLanguage("bash", Vt);
+G.registerLanguage("sql", jt);
+var m = /* @__PURE__ */ ((e) => (e.EQUAL = "equal", e.DELETE = "removed", e.ADD = "added", e.EMPTY = "empty", e))(m || {});
+const q = "<code-diff-modified>", Y = "</code-diff-modified>", Jt = q.replace("<", "&lt;").replace(">", "&gt;"), es = Y.replace("<", "&lt;").replace(">", "&gt;"), ae = (e) => e === void 0 ? m.EQUAL : e.added ? m.ADD : e.removed ? m.DELETE : m.EQUAL, Se = (e, n, t = "word") => typeof e > "u" ? n : typeof n > "u" ? e : (t === "char" ? Hn : Fn)(e, n).filter((l) => ae(l) !== m.DELETE).map(
+  (l) => ae(l) === m.ADD ? `${q}${l.value}${Y}` : l.value
+).join(""), F = (e, n) => {
+  if (!n.match(new RegExp(`(${q}|${Y})`, "g")))
+    return G.highlight(n, { language: e }).value;
+  let s = n;
+  const l = n.replace(new RegExp(`(${q}|${Y})`, "g"), ""), c = document.createElement("div");
+  c.innerHTML = G.highlight(l, { 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 p = o.textContent, _ = "";
+        for (i && (_ = _ + q); p.length; ) {
+          if (s.startsWith(q)) {
+            s = s.slice(q.length), _ = _ + q, i = !0;
+            continue;
+          }
+          if (s.startsWith(Y)) {
+            s = s.slice(Y.length), _ = _ + Y, i = !1;
+            continue;
+          }
+          const f = s.match(new RegExp(`(${q}|${Y})`)), N = f && f.index ? f.index : s.length, h = Math.min(N, p.length);
+          _ = _ + s.substring(0, h), s = s.slice(h), p = p.slice(h);
+        }
+        i && (_ = _ + Y), o.textContent = _;
+      }
+    });
+  };
+  return r(c), c.innerHTML.replace(new RegExp(Jt, "g"), '<span class="x">').replace(new RegExp(es, "g"), "</span>");
+};
+function ns(e, n, t = "plaintext", s = "word", l = 10) {
+  var N;
+  const c = () => ({ type: m.EMPTY }), i = (h, g, A) => ({ type: h, num: g, code: A }), r = gn(e, n);
+  let a = 0, o = 0, p = !1;
+  const _ = [];
+  for (let h = 0; h < r.length; h++) {
+    if (p) {
+      p = !1;
+      continue;
+    }
+    const [g, A] = [r[h], r[h + 1]], [S, x] = [ae(g), ae(A)], y = g.value.replace(/\n$/, "").split(`
+`);
+    if (A === void 0) {
+      for (const L of y) {
+        let D = c(), k = c();
+        const H = F(t, L);
+        S === m.EQUAL && (a++, o++, D = i(m.EQUAL, a, H), k = i(m.EQUAL, o, H)), S === m.DELETE && (a++, D = i(m.DELETE, a, H), k = c()), S === m.ADD && (o++, D = c(), k = i(m.ADD, o, H)), _.push({ left: D, right: k });
+      }
+      break;
+    }
+    if (S === m.EQUAL)
+      for (const L of y) {
+        a++, o++;
+        const D = F(t, L);
+        _.push({
+          left: i(m.EQUAL, a, D),
+          right: i(m.EQUAL, o, D)
+        });
+      }
+    const R = A.value.replace(/\n$/, "").split(`
+`);
+    if (S === m.DELETE) {
+      if (x === m.EQUAL)
+        for (const L of y)
+          a++, _.push({
+            left: i(m.DELETE, a, F(t, L)),
+            right: c()
+          });
+      if (x === m.ADD) {
+        p = !0;
+        const L = Math.max(g.count, A.count);
+        for (let D = 0; D < L; D++) {
+          D < g.count && a++, D < A.count && o++;
+          const [k, H] = [y[D], R[D]], z = y.length === R.length ? Se(H, k, s) : k, ne = y.length === R.length ? Se(k, H, s) : H, te = D < g.count ? i(m.DELETE, a, F(t, z)) : c(), oe = D < A.count ? i(m.ADD, o, F(t, ne)) : c();
+          _.push({ left: te, right: oe });
+        }
+      }
+    }
+    if (S === m.ADD)
+      for (const L of y)
+        o++, _.push({
+          left: c(),
+          right: i(m.ADD, o, F(t, L))
+        });
+  }
+  if (e === n) {
+    for (let h = 0; h < _.length; h++)
+      _[h].fold = !1;
+    return _;
+  }
+  for (let h = 0; h < _.length; h++) {
+    const g = _[h];
+    if (g.left.type === m.DELETE || g.right.type === m.ADD) {
+      const [A, S] = [Math.max(h - l, 0), Math.min(h + l + 1, _.length)];
+      for (let x = A; x < S; x++)
+        _[x].fold = !1;
+    }
+    g.fold === void 0 && (g.fold = !0);
+  }
+  const f = [];
+  for (let h = 0; h < _.length; h++) {
+    const g = _[h];
+    if (g.fold === !1) {
+      f.push(g);
+      continue;
+    }
+    g.fold === !0 && ((N = f[f.length - 1]) == null ? void 0 : N.fold) !== !0 && f.push(g);
+  }
+  return f;
+}
+function ts(e, n, t = "plaintext", s = "word", l = 2) {
+  var _;
+  const c = gn(e, n);
+  let i = 0, r = 0, a = !1;
+  const o = [];
+  for (let f = 0; f < c.length; f++) {
+    if (a) {
+      a = !1;
+      continue;
+    }
+    const [N, h] = [c[f], c[f + 1]], [g, A] = [ae(N), ae(h)], S = N.value.replace(/\n$/, "").split(`
+`);
+    if (h === void 0) {
+      for (const y of S) {
+        g === m.EQUAL && (i++, r++), g === m.DELETE && i++, g === m.ADD && r++;
+        const R = F(t, y);
+        o.push({
+          type: g,
+          code: R,
+          addNum: g === m.DELETE ? void 0 : r,
+          delNum: g === m.ADD ? void 0 : i
+        });
+      }
+      break;
+    }
+    if (g === m.EQUAL)
+      for (const y of S) {
+        i++, r++;
+        const R = F(t, y);
+        o.push({ type: m.EQUAL, code: R, delNum: i, addNum: r });
+      }
+    const x = h.value.replace(/\n$/, "").split(`
+`);
+    if (g === m.DELETE)
+      if (A === m.ADD && S.length === x.length) {
+        for (let y = 0; y < S.length; y++) {
+          const R = S[y], L = x[y];
+          i++;
+          const D = F(t, Se(L, R, s));
+          o.push({ type: m.DELETE, code: D, delNum: i });
+        }
+        for (let y = 0; y < x.length; y++) {
+          const R = S[y], L = x[y];
+          r++;
+          const D = F(t, Se(R, L, s));
+          o.push({ type: m.ADD, code: D, addNum: r });
+        }
+        a = !0;
+      } else
+        for (const y of S) {
+          i++;
+          const R = F(t, y);
+          o.push({ type: m.DELETE, code: R, delNum: i });
+        }
+    if (g === m.ADD)
+      for (const y of S) {
+        r++;
+        const R = F(t, y);
+        o.push({ type: m.ADD, code: R, addNum: r });
+      }
+  }
+  for (let f = 0; f < o.length; f++) {
+    const N = o[f];
+    if (N.type === m.DELETE || N.type === m.ADD) {
+      const [h, g] = [Math.max(f - l, 0), Math.min(f + l + 1, o.length)];
+      for (let A = h; A < g; A++)
+        o[A].fold = !1;
+    }
+    N.fold === void 0 && (N.fold = !0);
+  }
+  if (e === n) {
+    for (let f = 0; f < o.length; f++)
+      o[f].fold = !1;
+    return o;
+  }
+  const p = [];
+  for (let f = 0; f < o.length; f++) {
+    const N = o[f];
+    if (N.fold === !1) {
+      p.push(N);
+      continue;
+    }
+    N.fold === !0 && (f === 0 || ((_ = p[p.length - 1]) == null ? void 0 : _.fold) !== !0) && p.push(N);
+  }
+  return p;
+}
+const Ke = {};
+Ke.props = {
+  line: {
+    key: "line",
+    required: !0,
+    type: null
+  }
+};
+Ke.setup = (e, n) => ({
+  DiffType: m,
+  getCodeMarker: (s) => s === m.DELETE ? "-" : s === m.ADD ? "+" : ""
+});
+var ss = function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return e.line.fold ? t("tr", [t("td", {
+    staticClass: "blob-num blob-num-empty empty-cell"
+  }, [e._v(" > ")]), t("td", {
+    staticClass: "blob-num blob-num-empty empty-cell"
+  }, [e._v(" > ")]), t("td", {
+    staticClass: "blob-code blob-code-empty empty-cell",
+    attrs: {
+      align: "left"
+    }
+  }, [e._v(" ⋯ ")])]) : t("tr", [t("td", {
+    staticClass: "blob-num",
+    class: {
+      "blob-num-deletion": e.line.type === e.DiffType.DELETE,
+      "blob-num-addition": e.line.type === e.DiffType.ADD,
+      "blob-num-context": e.line.type === e.DiffType.EQUAL
+    }
+  }, [e._v(" " + e._s(e.line.delNum) + " ")]), t("td", {
+    staticClass: "blob-num",
+    class: {
+      "blob-num-deletion": e.line.type === e.DiffType.DELETE,
+      "blob-num-addition": e.line.type === e.DiffType.ADD,
+      "blob-num-context": e.line.type === e.DiffType.EQUAL
+    }
+  }, [e._v(" " + e._s(e.line.addNum) + " ")]), t("td", {
+    staticClass: "blob-code",
+    class: {
+      "blob-code-deletion": e.line.type === e.DiffType.DELETE,
+      "blob-code-addition": e.line.type === e.DiffType.ADD,
+      "blob-code-context": e.line.type === e.DiffType.EQUAL
+    }
+  }, [t("span", {
+    staticClass: "blob-code-inner blob-code-marker",
+    attrs: {
+      "data-code-marker": e.getCodeMarker(e.line.type)
+    },
+    domProps: {
+      innerHTML: e._s(e.line.code)
+    }
+  })])]);
+}, rs = [];
+function _e(e, n, t, s, l, c, i, r) {
+  var a = typeof e == "function" ? e.options : e;
+  n && (a.render = n, a.staticRenderFns = t, a._compiled = !0), s && (a.functional = !0), c && (a._scopeId = "data-v-" + c);
+  var o;
+  if (i ? (o = function(f) {
+    f = f || // cached call
+    this.$vnode && this.$vnode.ssrContext || // stateful
+    this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext, !f && typeof __VUE_SSR_CONTEXT__ < "u" && (f = __VUE_SSR_CONTEXT__), l && l.call(this, f), f && f._registeredComponents && f._registeredComponents.add(i);
+  }, a._ssrRegister = o) : l && (o = r ? function() {
+    l.call(
+      this,
+      (a.functional ? this.parent : this).$root.$options.shadowRoot
+    );
+  } : l), o)
+    if (a.functional) {
+      a._injectStyles = o;
+      var p = a.render;
+      a.render = function(N, h) {
+        return o.call(h), p(N, h);
+      };
+    } else {
+      var _ = a.beforeCreate;
+      a.beforeCreate = _ ? [].concat(_, o) : [o];
+    }
+  return {
+    exports: e,
+    options: a
+  };
+}
+const cn = {};
+var is = /* @__PURE__ */ _e(
+  Ke,
+  ss,
+  rs,
+  !1,
+  as,
+  null,
+  null,
+  null
+);
+function as(e) {
+  for (let n in cn)
+    this[n] = cn[n];
+}
+const os = /* @__PURE__ */ function() {
+  return is.exports;
+}(), de = {};
+de.props = {
+  diffChange: {
+    key: "diffChange",
+    required: !0,
+    type: null
+  }
+};
+de.setup = (e, n) => ({});
+de.components = Object.assign({
+  UnifiedLine: os
+}, de.components);
+var cs = function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return t("div", {
+    staticClass: "file"
+  }, [t("table", {
+    staticClass: "diff-table"
+  }, [t("tbody", e._l(e.diffChange, function(s, l) {
+    return t("UnifiedLine", {
+      key: l,
+      attrs: {
+        line: s
+      }
+    });
+  }), 1)])]);
+}, ls = [];
+const ln = {};
+var us = /* @__PURE__ */ _e(
+  de,
+  cs,
+  ls,
+  !1,
+  fs,
+  null,
+  null,
+  null
+);
+function fs(e) {
+  for (let n in ln)
+    this[n] = ln[n];
+}
+const ds = /* @__PURE__ */ function() {
+  return us.exports;
+}(), We = {};
+We.props = {
+  splitLine: {
+    key: "splitLine",
+    required: !0,
+    type: null
+  }
+};
+We.setup = (e, n) => ({
+  DiffType: m,
+  getCodeMarker: (s) => s === m.DELETE ? "-" : s === m.ADD ? "+" : ""
+});
+var gs = function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return e.splitLine.fold ? t("tr", [t("td", {
+    staticClass: "blob-num blob-num-empty empty-cell",
+    attrs: {
+      colspan: "1"
+    }
+  }, [e._v(" > ")]), t("td", {
+    staticClass: "blob-code blob-code-empty empty-cell",
+    attrs: {
+      colspan: "3",
+      align: "left"
+    }
+  }, [e._v(" ⋯ ")])]) : t("tr", [e._l([e.splitLine.left, e.splitLine.right], function(s) {
+    return [s.type === e.DiffType.EMPTY ? [t("td", {
+      staticClass: "blob-num blob-num-empty empty-cell"
+    }), t("td", {
+      staticClass: "blob-code blob-code-empty empty-cell"
+    })] : [t("td", {
+      staticClass: "blob-num",
+      class: {
+        "blob-num-deletion": s.type === e.DiffType.DELETE,
+        "blob-num-addition": s.type === e.DiffType.ADD,
+        "blob-num-context": s.type === e.DiffType.EQUAL
+      }
+    }, [e._v(" " + e._s(s.num) + " ")]), t("td", {
+      staticClass: "blob-code",
+      class: {
+        "blob-code-deletion": s.type === e.DiffType.DELETE,
+        "blob-code-addition": s.type === e.DiffType.ADD,
+        "blob-code-context": s.type === e.DiffType.EQUAL
+      }
+    }, [t("span", {
+      staticClass: "blob-code-inner blob-code-marker",
+      attrs: {
+        "data-code-marker": e.getCodeMarker(s.type)
+      },
+      domProps: {
+        innerHTML: e._s(s.code)
+      }
+    })])]];
+  })], 2);
+}, ps = [];
+const un = {};
+var _s = /* @__PURE__ */ _e(
+  We,
+  gs,
+  ps,
+  !1,
+  bs,
+  null,
+  null,
+  null
+);
+function bs(e) {
+  for (let n in un)
+    this[n] = un[n];
+}
+const hs = /* @__PURE__ */ function() {
+  return _s.exports;
+}(), ge = {};
+ge.props = {
+  diffChange: {
+    key: "diffChange",
+    required: !0,
+    type: null
+  }
+};
+ge.setup = (e, n) => ({});
+ge.components = Object.assign({
+  SplitLine: hs
+}, ge.components);
+var Es = function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return t("div", {
+    staticClass: "file"
+  }, [t("table", {
+    staticClass: "file-diff-split diff-table"
+  }, [e._m(0), t("tbody", e._l(e.diffChange, function(s, l) {
+    return t("SplitLine", {
+      key: l,
+      attrs: {
+        "split-line": s
+      }
+    });
+  }), 1)])]);
+}, ms = [function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return t("colgroup", [t("col", {
+    attrs: {
+      width: "44"
+    }
+  }), t("col"), t("col", {
+    attrs: {
+      width: "44"
+    }
+  }), t("col")]);
+}];
+const fn = {};
+var ys = /* @__PURE__ */ _e(
+  ge,
+  Es,
+  ms,
+  !1,
+  vs,
+  null,
+  null,
+  null
+);
+function vs(e) {
+  for (let n in fn)
+    this[n] = fn[n];
+}
+const Ns = /* @__PURE__ */ function() {
+  return ys.exports;
+}();
+const pe = {};
+pe.props = {
+  newString: {
+    key: "newString",
+    required: !0,
+    type: String
+  },
+  oldString: {
+    key: "oldString",
+    required: !0,
+    type: String
+  },
+  language: {
+    key: "language",
+    required: !1,
+    type: String,
+    default: "plaintext"
+  },
+  context: {
+    key: "context",
+    required: !1,
+    type: Number,
+    default: 10
+  },
+  diffStyle: {
+    key: "diffStyle",
+    required: !1,
+    type: String,
+    default: "word"
+  },
+  outputFormat: {
+    key: "outputFormat",
+    required: !1,
+    type: String,
+    default: "line-by-line"
+  },
+  trim: {
+    key: "trim",
+    required: !1,
+    type: Boolean,
+    default: !1
+  },
+  noDiffLineFeed: {
+    key: "noDiffLineFeed",
+    required: !1,
+    type: Boolean,
+    default: !1
+  }
+};
+pe.setup = (e, n) => {
+  const t = e, s = ye(() => t.outputFormat === "line-by-line"), l = ye(() => {
+    const r = t.trim ? t.oldString.trim() : t.oldString;
+    return t.noDiffLineFeed ? r.replace(/(\r\n)/g, `
+`) : r;
+  }), c = ye(() => {
+    const r = t.trim ? t.newString.trim() : t.newString;
+    return t.noDiffLineFeed ? r.replace(/(\r\n)/g, `
+`) : r;
+  }), i = ye(() => s.value ? ts(l.value, c.value, t.language, t.diffStyle, t.context) : ns(l.value, c.value, t.language, t.diffStyle, t.context));
+  return {
+    isUnifiedViewer: s,
+    diffChange: i
+  };
+};
+pe.components = Object.assign({
+  UnifiedViewer: ds,
+  SplitViewer: Ns
+}, pe.components);
+var Ts = function() {
+  var e = this, n = e.$createElement, t = e._self._c || n;
+  return t("div", {
+    staticClass: "code-diff-view"
+  }, [e.isUnifiedViewer ? t("UnifiedViewer", {
+    attrs: {
+      "diff-change": e.diffChange
+    }
+  }) : t("SplitViewer", {
+    attrs: {
+      "diff-change": e.diffChange
+    }
+  })], 1);
+}, As = [];
+const dn = {};
+var ws = /* @__PURE__ */ _e(
+  pe,
+  Ts,
+  As,
+  !1,
+  Ss,
+  null,
+  null,
+  null
+);
+function Ss(e) {
+  for (let n in dn)
+    this[n] = dn[n];
+}
+const Ms = /* @__PURE__ */ function() {
+  return ws.exports;
+}(), Rs = (e) => {
+  e.component("CodeDiff", Ms);
+}, Ls = {
+  install: Rs,
+  hljs: G
+};
+export {
+  Ms as CodeDiff,
+  Ls as default
+};