3143 lines
129 KiB
JavaScript
3143 lines
129 KiB
JavaScript
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).dayjs=e()}(this,(function(){"use strict";var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",f="month",h="quarter",c="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return"["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p=function(t){return t instanceof _},S=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=v;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t)}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return O},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),l=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(h){case c:return r?l(1,0):l(31,11);case f:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),h="set"+(this.$u?"UTC":""),l=(n={},n[a]=h+"Date",n[d]=h+"Date",n[f]=h+"Month",n[c]=h+"FullYear",n[u]=h+"Hours",n[s]=h+"Minutes",n[i]=h+"Seconds",n[r]=h+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,l=this;r=Number(r);var $=O.p(h),y=function(t){var e=w(l);return O.w(e.date(e.date()+Math.round(t*r)),l)};if($===f)return this.set(f,this.$M+r);if($===c)return this.set(c,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},c=function(t){return O.s(s%12||12,t,"0")},d=n.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},$={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,"0"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,"0"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,"0"),h:c(1),hh:c(2),a:d(s,u,!0),A:d(s,u,!1),m:String(u),mm:O.s(u,2,"0"),s:String(this.$s),ss:O.s(this.$s,2,"0"),SSS:O.s(this.$ms,3,"0"),Z:i};return r.replace(y,(function(t,e){return e||$[t]||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,v=this-M,g=O.m(this,M);return g=($={},$[c]=g/12,$[f]=g,$[h]=g/3,$[o]=(v-m)/6048e5,$[a]=(v-m)/864e5,$[u]=v/n,$[s]=v/e,$[i]=v/t,$)[y]||v,l?g:O.a(g)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),T=_.prototype;return w.prototype=T,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",f],["$y",c],["$D",d]].forEach((function(t){T[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=D[g],w.Ls=D,w.p={},w}));
|
||
;
|
||
!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define(r):(e="undefined"!=typeof globalThis?globalThis:e||self).dayjs_plugin_relativeTime=r()}(this,function(){"use strict";return function(p,e,v){p=p||{};var o=e.prototype,M={future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"};function t(e,r,t,n){return o.fromToBase(e,r,t,n)}v.en.relativeTime=M,o.fromToBase=function(e,r,t,n,o){for(var i,d,u=t.$locale().relativeTime||M,f=p.thresholds||[{l:"s",r:44,d:"second"},{l:"m",r:89},{l:"mm",r:44,d:"minute"},{l:"h",r:89},{l:"hh",r:21,d:"hour"},{l:"d",r:35},{l:"dd",r:25,d:"day"},{l:"M",r:45},{l:"MM",r:10,d:"month"},{l:"y",r:17},{l:"yy",d:"year"}],a=f.length,s=0;s<a;s+=1){var l=f[s],h=(l.d&&(i=n?v(e).diff(t,l.d,!0):t.diff(e,l.d,!0)),(p.rounding||Math.round)(Math.abs(i))),m=0<i;if(h<=l.r||!l.r){var c=u[(l=h<=1&&0<s?f[s-1]:l).l];o&&(h=o(""+h)),d="string"==typeof c?c.replace("%d",h):c(h,r,l.l,m);break}}if(r)return d;var y=m?u.future:u.past;return"function"==typeof y?y(d):y.replace("%s",d)},o.to=function(e,r){return t(e,r,this,!0)},o.from=function(e,r){return t(e,r,this)};function r(e){return e.$u?v.utc():v()}o.toNow=function(e){return this.to(r(this),e)},o.fromNow=function(e){return this.from(r(this),e)}}});
|
||
;
|
||
/* Template Name: LotusLabs Docs
|
||
Author: Colin Wilson
|
||
E-mail: colin@aigis.uk
|
||
Created: October 2022
|
||
Version: 1.0.0
|
||
File Description: Main JS file of the docs template
|
||
*/
|
||
|
||
|
||
/*********************************/
|
||
/* INDEX */
|
||
/*================================
|
||
* 01. Toggle Menus *
|
||
* 02. Active Menu *
|
||
* 03. Clickable Menu *
|
||
* 04. Back to top *
|
||
* 05. DD Menu *
|
||
* 06. Active Sidebar Menu *
|
||
* 07. ScrollSpy *
|
||
================================*/
|
||
|
||
|
||
// Menu
|
||
// Toggle menu
|
||
function toggleMenu() {
|
||
document.getElementById('isToggle').classList.toggle('open');
|
||
var isOpen = document.getElementById('navigation')
|
||
if (isOpen.style.display === "block") {
|
||
isOpen.style.display = "none";
|
||
} else {
|
||
isOpen.style.display = "block";
|
||
}
|
||
};
|
||
|
||
// Menu Active
|
||
function getClosest(elem, selector) {
|
||
|
||
// Element.matches() polyfill
|
||
if (!Element.prototype.matches) {
|
||
Element.prototype.matches =
|
||
Element.prototype.matchesSelector ||
|
||
Element.prototype.mozMatchesSelector ||
|
||
Element.prototype.msMatchesSelector ||
|
||
Element.prototype.oMatchesSelector ||
|
||
Element.prototype.webkitMatchesSelector ||
|
||
function (s) {
|
||
var matches = (this.document || this.ownerDocument).querySelectorAll(s),
|
||
i = matches.length;
|
||
while (--i >= 0 && matches.item(i) !== this) { }
|
||
return i > -1;
|
||
};
|
||
}
|
||
|
||
// Get the closest matching element
|
||
for (; elem && elem !== document; elem = elem.parentNode) {
|
||
if (elem.matches(selector)) return elem;
|
||
}
|
||
return null;
|
||
|
||
};
|
||
|
||
function activateMenu() {
|
||
var menuItems = document.getElementsByClassName("sub-menu-item");
|
||
if (menuItems) {
|
||
|
||
var matchingMenuItem = null;
|
||
for (var idx = 0; idx < menuItems.length; idx++) {
|
||
if (menuItems[idx].href === window.location.href) {
|
||
matchingMenuItem = menuItems[idx];
|
||
}
|
||
}
|
||
|
||
if (matchingMenuItem) {
|
||
matchingMenuItem.classList.add('active');
|
||
var immediateParent = getClosest(matchingMenuItem, 'li');
|
||
if (immediateParent) {
|
||
immediateParent.classList.add('active');
|
||
}
|
||
|
||
var parent = getClosest(matchingMenuItem, '.parent-menu-item');
|
||
if (parent) {
|
||
parent.classList.add('active');
|
||
var parentMenuitem = parent.querySelector('.menu-item');
|
||
if (parentMenuitem) {
|
||
parentMenuitem.classList.add('active');
|
||
}
|
||
var parentOfParent = getClosest(parent, '.parent-parent-menu-item');
|
||
if (parentOfParent) {
|
||
parentOfParent.classList.add('active');
|
||
}
|
||
} else {
|
||
var parentOfParent = getClosest(matchingMenuItem, '.parent-parent-menu-item');
|
||
if (parentOfParent) {
|
||
parentOfParent.classList.add('active');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// Sidebar Menu
|
||
function activateSidebarMenu() {
|
||
var current = location.pathname.substring(location.pathname.lastIndexOf('/') + 1);
|
||
if (current !== "" && document.getElementById("sidebar")) {
|
||
var menuItems = document.querySelectorAll('#sidebar button');
|
||
for (var i = 0, len = menuItems.length; i < len; i++) {
|
||
if (menuItems[i].getAttribute("href").indexOf(current) !== -1) {
|
||
menuItems[i].parentElement.className += " active";
|
||
if (menuItems[i].closest(".sidebar-submenu")) {
|
||
menuItems[i].closest(".sidebar-submenu").classList.add("d-block");
|
||
}
|
||
if (menuItems[i].closest(".sidebar-dropdown")) {
|
||
menuItems[i].closest(".sidebar-dropdown").classList.add("active");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (document.getElementById("close-sidebar")) {
|
||
document.getElementById("close-sidebar").addEventListener("click", function () {
|
||
document.getElementsByClassName("page-wrapper")[0].classList.toggle("toggled");
|
||
});
|
||
}
|
||
|
||
// Close Sidebar (mobile)
|
||
if (!window.matchMedia('(min-width: 1024px)').matches) {
|
||
if (document.getElementById("close-sidebar")) {
|
||
const closeSidebar = document.getElementById("close-sidebar");
|
||
const sidebar = document.getElementById("sidebar");
|
||
const sidebarMenuLinks = Array.from(document.querySelectorAll(".sidebar-root-link,.sidebar-nested-link"));
|
||
// Close sidebar by clicking outside
|
||
document.addEventListener('click', function(elem) {
|
||
if (!closeSidebar.contains(elem.target) && !sidebar.contains(elem.target))
|
||
document.getElementsByClassName("page-wrapper")[0].classList.add("toggled");
|
||
});
|
||
// Close sidebar immediately when clicking sidebar menu item
|
||
sidebarMenuLinks.forEach(menuLink => {
|
||
menuLink.addEventListener("click", function () {
|
||
document.getElementsByClassName("page-wrapper")[0].classList.add("toggled");
|
||
});
|
||
});
|
||
}
|
||
}
|
||
|
||
// Clickable Menu
|
||
if (document.getElementById("navigation")) {
|
||
var elements = document.getElementById("navigation").getElementsByTagName("a");
|
||
for (var i = 0, len = elements.length; i < len; i++) {
|
||
elements[i].onclick = function (elem) {
|
||
if (elem.target.getAttribute("href") === "javascript:void(0)") {
|
||
var submenu = elem.target.nextElementSibling.nextElementSibling;
|
||
submenu.classList.toggle('open');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (document.getElementById("sidebar")) {
|
||
var elements = document.getElementById("sidebar").getElementsByTagName("button");
|
||
for (var i = 0, len = elements.length; i < len; i++) {
|
||
elements[i].onclick = function (elem) {
|
||
// if(elem.target !== document.querySelectorAll("li.sidebar-dropdown.active > a")[0]){
|
||
// document.querySelectorAll("li.sidebar-dropdown.active")[0]?.classList?.toggle("active");
|
||
// document.querySelectorAll("div.sidebar-submenu.d-block")[0]?.classList?.toggle("d-block");
|
||
// }
|
||
// if(elem.target.getAttribute("href") === "javascript:void(0)") {
|
||
elem.target.parentElement.classList.toggle("active");
|
||
elem.target.nextElementSibling.classList.toggle("d-block");
|
||
// }
|
||
}
|
||
}
|
||
}
|
||
|
||
// Menu sticky
|
||
function windowScroll() {
|
||
var navbar = document.getElementById("topnav");
|
||
if (navbar === null) {
|
||
|
||
} else if (document.body.scrollTop >= 50 ||
|
||
document.documentElement.scrollTop >= 50) {
|
||
navbar.classList.add("nav-sticky");
|
||
} else {
|
||
navbar.classList.remove("nav-sticky");
|
||
}
|
||
}
|
||
|
||
window.addEventListener('scroll', (ev) => {
|
||
ev.preventDefault();
|
||
windowScroll();
|
||
})
|
||
|
||
// back-to-top
|
||
var mybutton = document.getElementById("back-to-top");
|
||
window.onscroll = function () {
|
||
scrollFunction();
|
||
};
|
||
|
||
function scrollFunction() {
|
||
if (mybutton != null) {
|
||
if (document.body.scrollTop > 500 || document.documentElement.scrollTop > 500) {
|
||
mybutton.style.display = "block";
|
||
} else {
|
||
mybutton.style.display = "none";
|
||
}
|
||
}
|
||
}
|
||
|
||
function topFunction() {
|
||
document.body.scrollTop = 0;
|
||
document.documentElement.scrollTop = 0;
|
||
}
|
||
|
||
// dd-menu
|
||
if (document.getElementsByClassName("dd-menu")) {
|
||
var ddmenu = document.getElementsByClassName("dd-menu");
|
||
for (var i = 0, len = ddmenu.length; i < len; i++) {
|
||
ddmenu[i].onclick = function (elem) {
|
||
elem.stopPropagation();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Active Sidebar
|
||
(function () {
|
||
var current = location.pathname.substring(location.pathname.lastIndexOf('/') + 1);
|
||
if (current === "") return;
|
||
var menuItems = document.querySelectorAll('.sidebar-nav a');
|
||
for (var i = 0, len = menuItems.length; i < len; i++) {
|
||
if (menuItems[i].getAttribute("href").indexOf(current) !== -1) {
|
||
menuItems[i].parentElement.className += " active";
|
||
}
|
||
}
|
||
})();
|
||
|
||
// Last Modified Date of current page (relative time format)
|
||
if (document.getElementById("relativetime")) {
|
||
dayjs.extend(window.dayjs_plugin_relativeTime);
|
||
const modId = document.getElementById('relativetime');
|
||
let modAgo = dayjs(modId.getAttribute('data-authdate')).fromNow();
|
||
document.getElementById("relativetime").innerHTML = modAgo;
|
||
};
|
||
|
||
// Initialize Bootstrap Tooltips
|
||
const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]')
|
||
const tooltipList = [...tooltipTriggerList].map(tooltipTriggerEl => new Tooltip(tooltipTriggerEl))
|
||
|
||
/**
|
||
* Sanitize and encode all HTML in a user-submitted string
|
||
* https://portswigger.net/web-security/cross-site-scripting/preventing
|
||
* @param {String} str The user-submitted string
|
||
* @return {String} str The sanitized string
|
||
*/
|
||
var sanitizeHTML = function (str) {
|
||
return str.replace(/[^\w. ]/gi, function (c) {
|
||
return '&#' + c.charCodeAt(0) + ';';
|
||
});
|
||
};
|
||
;
|
||
!function(t,o){"object"==typeof exports&&"object"==typeof module?module.exports=o():"function"==typeof define&&define.amd?define([],o):"object"==typeof exports?exports.scrollSpy=o():t.scrollSpy=o()}(self,(()=>(()=>{var t={138:(t,o,e)=>{t.exports=(t,o={})=>{const{ScrollSpy:s}=e(218),i=new s(t,o);return window.onload=i.onScroll(),window.addEventListener("scroll",(()=>i.onScroll())),i}},218:(t,o,e)=>{"use strict";e.r(o),e.d(o,{ScrollSpy:()=>s});class s{constructor(t,o={}){if(!t)throw new Error("First argument is query selector to your navigation.");if("object"!=typeof o)throw new Error("Second argument must be instance of Object.");o.smoothScroll=!0===o.smoothScroll&&{}||o.smoothScroll,this.menuList=t instanceof HTMLElement?t:document.querySelector(t),this.options=Object.assign({},{sectionClass:".scrollspy",menuActiveTarget:"li > a",offset:0,hrefAttribute:"href",activeClass:"active",scrollContainer:"",smoothScroll:{}},o),this.options.scrollContainer?this.scroller=this.options.scrollContainer instanceof HTMLElement?this.options.scrollContainer:document.querySelector(this.options.scrollContainer):this.scroller=window,this.sections=document.querySelectorAll(this.options.sectionClass),this.attachEventListeners()}attachEventListeners(){if(this.scroller&&(this.scroller.addEventListener("scroll",(()=>this.onScroll())),this.options.smoothScroll)){this.menuList.querySelectorAll(this.options.menuActiveTarget).forEach((t=>t.addEventListener("click",this.onClick.bind(this))))}}onClick(t){const o=t.target.getAttribute(this.options.hrefAttribute),e=document.querySelector(o);e&&this.options.smoothScroll&&(t.preventDefault(),this.scrollTo(e))}onScroll(){const t=this.getSectionInView(),o=this.getMenuItemBySection(t);o&&(this.removeCurrentActive({ignore:o}),this.setActive(o))}scrollTo(t){const o="function"==typeof this.options.smoothScrollBehavior&&this.options.smoothScrollBehavior;o?o(t,this.options.smoothScroll):t.scrollIntoView({...this.options.smoothScroll,behavior:"smooth"})}getMenuItemBySection(t){if(!t)return;const o=t.getAttribute("id");return this.menuList.querySelector(`[${this.options.hrefAttribute}="#${o}"]`)}getSectionInView(){for(let t=0;t<this.sections.length;t++){const o=this.sections[t].offsetTop,e=o+this.sections[t].offsetHeight;let s=(document.documentElement.scrollTop||document.body.scrollTop)+this.options.offset;this.options.scrollContainer&&this.scroller&&(s=this.scroller.scrollTop+this.options.offset);if(s>o&&s<=e)return this.sections[t]}}setActive(t){t.classList.contains(this.options.activeClass)||t.classList.add(this.options.activeClass)}removeCurrentActive({ignore:t}){const{hrefAttribute:o,menuActiveTarget:e,activeClass:s}=this.options,i=`${e}.${s}:not([${o}="${t.getAttribute(o)}"])`;this.menuList.querySelectorAll(i).forEach((t=>t.classList.remove(this.options.activeClass)))}}}},o={};function e(s){var i=o[s];if(void 0!==i)return i.exports;var r=o[s]={exports:{}};return t[s](r,r.exports,e),r.exports}return e.d=(t,o)=>{for(var s in o)e.o(o,s)&&!e.o(t,s)&&Object.defineProperty(t,s,{enumerable:!0,get:o[s]})},e.o=(t,o)=>Object.prototype.hasOwnProperty.call(t,o),e.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},e(138)})()));
|
||
;
|
||
(() => {
|
||
// <stdin>
|
||
window.onload = function() {
|
||
scrollSpy("toc", {
|
||
sectionClass: "h1,h2,h3,h4",
|
||
// menuActiveTarget: 'href',
|
||
offset: 100
|
||
// scrollContainer: null,
|
||
// smooth scroll
|
||
// smoothScroll: true,
|
||
// smoothScrollBehavior: function(element) {
|
||
// console.log('run "smoothScrollBehavior"...', element)
|
||
// element.scrollIntoView({ behavior: 'smooth' })
|
||
// }
|
||
});
|
||
};
|
||
})();
|
||
|
||
;
|
||
// ToC Mobile Menu (Bootstrap 5 Dropdown with ScrollSpy)
|
||
const scrollArea = document.getElementById('content');
|
||
const tocBtn = document.getElementById('toc-dropdown-btn');
|
||
scrollArea.addEventListener("activate.bs.scrollspy", function(){
|
||
var currentItem = document.querySelector('.dropdown-menu li > a.active').innerHTML;
|
||
tocBtn.innerHTML = currentItem;
|
||
})
|
||
|
||
tocBtn.addEventListener('shown.bs.dropdown', event => {
|
||
tocBtn.style.borderBottom = 'none'
|
||
tocBtn.style.borderRadius = '4px 4px 0 0'
|
||
// console.log("dropdown opened");
|
||
})
|
||
tocBtn.addEventListener('hidden.bs.dropdown', event => {
|
||
tocBtn.style.borderBottom = '1px solid var(--alert-border-color)'
|
||
tocBtn.style.borderRadius = '4px'
|
||
// console.log("dropdown closed");
|
||
});
|
||
;
|
||
(() => {
|
||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||
var __esm = (fn, res) => function __init() {
|
||
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
||
};
|
||
var __commonJS = (cb, mod) => function __require() {
|
||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||
};
|
||
|
||
// ns-hugo-params:<stdin>
|
||
var stdin_default;
|
||
var init_stdin = __esm({
|
||
"ns-hugo-params:<stdin>"() {
|
||
stdin_default = { langPath: "http://localhost:1313/docs/js/components/" };
|
||
}
|
||
});
|
||
|
||
// <stdin>
|
||
var require_stdin = __commonJS({
|
||
"<stdin>"(exports, module) {
|
||
init_stdin();
|
||
var _self = typeof window !== "undefined" ? window : typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope ? self : {};
|
||
var Prism = (function(_self2) {
|
||
var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
|
||
var uniqueId = 0;
|
||
var plainTextGrammar = {};
|
||
var _ = {
|
||
/**
|
||
* By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
|
||
* current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
|
||
* additional languages or plugins yourself.
|
||
*
|
||
* By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
|
||
*
|
||
* You obviously have to change this value before the automatic highlighting started. To do this, you can add an
|
||
* empty Prism object into the global scope before loading the Prism script like this:
|
||
*
|
||
* ```js
|
||
* window.Prism = window.Prism || {};
|
||
* Prism.manual = true;
|
||
* // add a new <script> to load Prism's script
|
||
* ```
|
||
*
|
||
* @default false
|
||
* @type {boolean}
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
manual: _self2.Prism && _self2.Prism.manual,
|
||
/**
|
||
* By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
|
||
* `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
|
||
* own worker, you don't want it to do this.
|
||
*
|
||
* By setting this value to `true`, Prism will not add its own listeners to the worker.
|
||
*
|
||
* You obviously have to change this value before Prism executes. To do this, you can add an
|
||
* empty Prism object into the global scope before loading the Prism script like this:
|
||
*
|
||
* ```js
|
||
* window.Prism = window.Prism || {};
|
||
* Prism.disableWorkerMessageHandler = true;
|
||
* // Load Prism's script
|
||
* ```
|
||
*
|
||
* @default false
|
||
* @type {boolean}
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
disableWorkerMessageHandler: _self2.Prism && _self2.Prism.disableWorkerMessageHandler,
|
||
/**
|
||
* A namespace for utility methods.
|
||
*
|
||
* All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
|
||
* change or disappear at any time.
|
||
*
|
||
* @namespace
|
||
* @memberof Prism
|
||
*/
|
||
util: {
|
||
encode: function encode(tokens) {
|
||
if (tokens instanceof Token) {
|
||
return new Token(tokens.type, encode(tokens.content), tokens.alias);
|
||
} else if (Array.isArray(tokens)) {
|
||
return tokens.map(encode);
|
||
} else {
|
||
return tokens.replace(/&/g, "&").replace(/</g, "<").replace(/\u00a0/g, " ");
|
||
}
|
||
},
|
||
/**
|
||
* Returns the name of the type of the given value.
|
||
*
|
||
* @param {any} o
|
||
* @returns {string}
|
||
* @example
|
||
* type(null) === 'Null'
|
||
* type(undefined) === 'Undefined'
|
||
* type(123) === 'Number'
|
||
* type('foo') === 'String'
|
||
* type(true) === 'Boolean'
|
||
* type([1, 2]) === 'Array'
|
||
* type({}) === 'Object'
|
||
* type(String) === 'Function'
|
||
* type(/abc+/) === 'RegExp'
|
||
*/
|
||
type: function(o) {
|
||
return Object.prototype.toString.call(o).slice(8, -1);
|
||
},
|
||
/**
|
||
* Returns a unique number for the given object. Later calls will still return the same number.
|
||
*
|
||
* @param {Object} obj
|
||
* @returns {number}
|
||
*/
|
||
objId: function(obj) {
|
||
if (!obj["__id"]) {
|
||
Object.defineProperty(obj, "__id", { value: ++uniqueId });
|
||
}
|
||
return obj["__id"];
|
||
},
|
||
/**
|
||
* Creates a deep clone of the given object.
|
||
*
|
||
* The main intended use of this function is to clone language definitions.
|
||
*
|
||
* @param {T} o
|
||
* @param {Record<number, any>} [visited]
|
||
* @returns {T}
|
||
* @template T
|
||
*/
|
||
clone: function deepClone(o, visited) {
|
||
visited = visited || {};
|
||
var clone;
|
||
var id;
|
||
switch (_.util.type(o)) {
|
||
case "Object":
|
||
id = _.util.objId(o);
|
||
if (visited[id]) {
|
||
return visited[id];
|
||
}
|
||
clone = /** @type {Record<string, any>} */
|
||
{};
|
||
visited[id] = clone;
|
||
for (var key in o) {
|
||
if (o.hasOwnProperty(key)) {
|
||
clone[key] = deepClone(o[key], visited);
|
||
}
|
||
}
|
||
return (
|
||
/** @type {any} */
|
||
clone
|
||
);
|
||
case "Array":
|
||
id = _.util.objId(o);
|
||
if (visited[id]) {
|
||
return visited[id];
|
||
}
|
||
clone = [];
|
||
visited[id] = clone;
|
||
/** @type {Array} */
|
||
/** @type {any} */
|
||
o.forEach(function(v, i) {
|
||
clone[i] = deepClone(v, visited);
|
||
});
|
||
return (
|
||
/** @type {any} */
|
||
clone
|
||
);
|
||
default:
|
||
return o;
|
||
}
|
||
},
|
||
/**
|
||
* Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
|
||
*
|
||
* If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
|
||
*
|
||
* @param {Element} element
|
||
* @returns {string}
|
||
*/
|
||
getLanguage: function(element) {
|
||
while (element) {
|
||
var m = lang.exec(element.className);
|
||
if (m) {
|
||
return m[1].toLowerCase();
|
||
}
|
||
element = element.parentElement;
|
||
}
|
||
return "none";
|
||
},
|
||
/**
|
||
* Sets the Prism `language-xxxx` class of the given element.
|
||
*
|
||
* @param {Element} element
|
||
* @param {string} language
|
||
* @returns {void}
|
||
*/
|
||
setLanguage: function(element, language) {
|
||
element.className = element.className.replace(RegExp(lang, "gi"), "");
|
||
element.classList.add("language-" + language);
|
||
},
|
||
/**
|
||
* Returns the script element that is currently executing.
|
||
*
|
||
* This does __not__ work for line script element.
|
||
*
|
||
* @returns {HTMLScriptElement | null}
|
||
*/
|
||
currentScript: function() {
|
||
if (typeof document === "undefined") {
|
||
return null;
|
||
}
|
||
if ("currentScript" in document && 1 < 2) {
|
||
return (
|
||
/** @type {any} */
|
||
document.currentScript
|
||
);
|
||
}
|
||
try {
|
||
throw new Error();
|
||
} catch (err) {
|
||
var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
|
||
if (src) {
|
||
var scripts = document.getElementsByTagName("script");
|
||
for (var i in scripts) {
|
||
if (scripts[i].src == src) {
|
||
return scripts[i];
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
},
|
||
/**
|
||
* Returns whether a given class is active for `element`.
|
||
*
|
||
* The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
|
||
* if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
|
||
* given class is just the given class with a `no-` prefix.
|
||
*
|
||
* Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
|
||
* closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
|
||
* ancestors have the given class or the negated version of it, then the default activation will be returned.
|
||
*
|
||
* In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
|
||
* version of it, the class is considered active.
|
||
*
|
||
* @param {Element} element
|
||
* @param {string} className
|
||
* @param {boolean} [defaultActivation=false]
|
||
* @returns {boolean}
|
||
*/
|
||
isActive: function(element, className, defaultActivation) {
|
||
var no = "no-" + className;
|
||
while (element) {
|
||
var classList = element.classList;
|
||
if (classList.contains(className)) {
|
||
return true;
|
||
}
|
||
if (classList.contains(no)) {
|
||
return false;
|
||
}
|
||
element = element.parentElement;
|
||
}
|
||
return !!defaultActivation;
|
||
}
|
||
},
|
||
/**
|
||
* This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
|
||
*
|
||
* @namespace
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
languages: {
|
||
/**
|
||
* The grammar for plain, unformatted text.
|
||
*/
|
||
plain: plainTextGrammar,
|
||
plaintext: plainTextGrammar,
|
||
text: plainTextGrammar,
|
||
txt: plainTextGrammar,
|
||
/**
|
||
* Creates a deep copy of the language with the given id and appends the given tokens.
|
||
*
|
||
* If a token in `redef` also appears in the copied language, then the existing token in the copied language
|
||
* will be overwritten at its original position.
|
||
*
|
||
* ## Best practices
|
||
*
|
||
* Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
|
||
* doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
|
||
* understand the language definition because, normally, the order of tokens matters in Prism grammars.
|
||
*
|
||
* Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
|
||
* Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
|
||
*
|
||
* @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
|
||
* @param {Grammar} redef The new tokens to append.
|
||
* @returns {Grammar} The new language created.
|
||
* @public
|
||
* @example
|
||
* Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
|
||
* // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
|
||
* // at its original position
|
||
* 'comment': { ... },
|
||
* // CSS doesn't have a 'color' token, so this token will be appended
|
||
* 'color': /\b(?:red|green|blue)\b/
|
||
* });
|
||
*/
|
||
extend: function(id, redef) {
|
||
var lang2 = _.util.clone(_.languages[id]);
|
||
for (var key in redef) {
|
||
lang2[key] = redef[key];
|
||
}
|
||
return lang2;
|
||
},
|
||
/**
|
||
* Inserts tokens _before_ another token in a language definition or any other grammar.
|
||
*
|
||
* ## Usage
|
||
*
|
||
* This helper method makes it easy to modify existing languages. For example, the CSS language definition
|
||
* not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
|
||
* in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
|
||
* appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
|
||
* this:
|
||
*
|
||
* ```js
|
||
* Prism.languages.markup.style = {
|
||
* // token
|
||
* };
|
||
* ```
|
||
*
|
||
* then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
|
||
* before existing tokens. For the CSS example above, you would use it like this:
|
||
*
|
||
* ```js
|
||
* Prism.languages.insertBefore('markup', 'cdata', {
|
||
* 'style': {
|
||
* // token
|
||
* }
|
||
* });
|
||
* ```
|
||
*
|
||
* ## Special cases
|
||
*
|
||
* If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
|
||
* will be ignored.
|
||
*
|
||
* This behavior can be used to insert tokens after `before`:
|
||
*
|
||
* ```js
|
||
* Prism.languages.insertBefore('markup', 'comment', {
|
||
* 'comment': Prism.languages.markup.comment,
|
||
* // tokens after 'comment'
|
||
* });
|
||
* ```
|
||
*
|
||
* ## Limitations
|
||
*
|
||
* The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
|
||
* properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
|
||
* differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
|
||
* deleting properties which is necessary to insert at arbitrary positions.
|
||
*
|
||
* To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
|
||
* Instead, it will create a new object and replace all references to the target object with the new one. This
|
||
* can be done without temporarily deleting properties, so the iteration order is well-defined.
|
||
*
|
||
* However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
|
||
* you hold the target object in a variable, then the value of the variable will not change.
|
||
*
|
||
* ```js
|
||
* var oldMarkup = Prism.languages.markup;
|
||
* var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
|
||
*
|
||
* assert(oldMarkup !== Prism.languages.markup);
|
||
* assert(newMarkup === Prism.languages.markup);
|
||
* ```
|
||
*
|
||
* @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
|
||
* object to be modified.
|
||
* @param {string} before The key to insert before.
|
||
* @param {Grammar} insert An object containing the key-value pairs to be inserted.
|
||
* @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
|
||
* object to be modified.
|
||
*
|
||
* Defaults to `Prism.languages`.
|
||
* @returns {Grammar} The new grammar object.
|
||
* @public
|
||
*/
|
||
insertBefore: function(inside, before, insert, root) {
|
||
root = root || /** @type {any} */
|
||
_.languages;
|
||
var grammar = root[inside];
|
||
var ret = {};
|
||
for (var token in grammar) {
|
||
if (grammar.hasOwnProperty(token)) {
|
||
if (token == before) {
|
||
for (var newToken in insert) {
|
||
if (insert.hasOwnProperty(newToken)) {
|
||
ret[newToken] = insert[newToken];
|
||
}
|
||
}
|
||
}
|
||
if (!insert.hasOwnProperty(token)) {
|
||
ret[token] = grammar[token];
|
||
}
|
||
}
|
||
}
|
||
var old = root[inside];
|
||
root[inside] = ret;
|
||
_.languages.DFS(_.languages, function(key, value) {
|
||
if (value === old && key != inside) {
|
||
this[key] = ret;
|
||
}
|
||
});
|
||
return ret;
|
||
},
|
||
// Traverse a language definition with Depth First Search
|
||
DFS: function DFS(o, callback, type, visited) {
|
||
visited = visited || {};
|
||
var objId = _.util.objId;
|
||
for (var i in o) {
|
||
if (o.hasOwnProperty(i)) {
|
||
callback.call(o, i, o[i], type || i);
|
||
var property = o[i];
|
||
var propertyType = _.util.type(property);
|
||
if (propertyType === "Object" && !visited[objId(property)]) {
|
||
visited[objId(property)] = true;
|
||
DFS(property, callback, null, visited);
|
||
} else if (propertyType === "Array" && !visited[objId(property)]) {
|
||
visited[objId(property)] = true;
|
||
DFS(property, callback, i, visited);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
plugins: {},
|
||
/**
|
||
* This is the most high-level function in Prism’s API.
|
||
* It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
|
||
* each one of them.
|
||
*
|
||
* This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
|
||
*
|
||
* @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
|
||
* @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
highlightAll: function(async, callback) {
|
||
_.highlightAllUnder(document, async, callback);
|
||
},
|
||
/**
|
||
* Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
|
||
* {@link Prism.highlightElement} on each one of them.
|
||
*
|
||
* The following hooks will be run:
|
||
* 1. `before-highlightall`
|
||
* 2. `before-all-elements-highlight`
|
||
* 3. All hooks of {@link Prism.highlightElement} for each element.
|
||
*
|
||
* @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
|
||
* @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
|
||
* @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
highlightAllUnder: function(container, async, callback) {
|
||
var env = {
|
||
callback,
|
||
container,
|
||
selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
|
||
};
|
||
_.hooks.run("before-highlightall", env);
|
||
env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
|
||
_.hooks.run("before-all-elements-highlight", env);
|
||
for (var i = 0, element; element = env.elements[i++]; ) {
|
||
_.highlightElement(element, async === true, env.callback);
|
||
}
|
||
},
|
||
/**
|
||
* Highlights the code inside a single element.
|
||
*
|
||
* The following hooks will be run:
|
||
* 1. `before-sanity-check`
|
||
* 2. `before-highlight`
|
||
* 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
|
||
* 4. `before-insert`
|
||
* 5. `after-highlight`
|
||
* 6. `complete`
|
||
*
|
||
* Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
|
||
* the element's language.
|
||
*
|
||
* @param {Element} element The element containing the code.
|
||
* It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
|
||
* @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
|
||
* to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
|
||
* [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
|
||
*
|
||
* Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
|
||
* asynchronous highlighting to work. You can build your own bundle on the
|
||
* [Download page](https://prismjs.com/download.html).
|
||
* @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
|
||
* Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
highlightElement: function(element, async, callback) {
|
||
var language = _.util.getLanguage(element);
|
||
var grammar = _.languages[language];
|
||
_.util.setLanguage(element, language);
|
||
var parent = element.parentElement;
|
||
if (parent && parent.nodeName.toLowerCase() === "pre") {
|
||
_.util.setLanguage(parent, language);
|
||
}
|
||
var code = element.textContent;
|
||
var env = {
|
||
element,
|
||
language,
|
||
grammar,
|
||
code
|
||
};
|
||
function insertHighlightedCode(highlightedCode) {
|
||
env.highlightedCode = highlightedCode;
|
||
_.hooks.run("before-insert", env);
|
||
env.element.innerHTML = env.highlightedCode;
|
||
_.hooks.run("after-highlight", env);
|
||
_.hooks.run("complete", env);
|
||
callback && callback.call(env.element);
|
||
}
|
||
_.hooks.run("before-sanity-check", env);
|
||
parent = env.element.parentElement;
|
||
if (parent && parent.nodeName.toLowerCase() === "pre" && !parent.hasAttribute("tabindex")) {
|
||
parent.setAttribute("tabindex", "0");
|
||
}
|
||
if (!env.code) {
|
||
_.hooks.run("complete", env);
|
||
callback && callback.call(env.element);
|
||
return;
|
||
}
|
||
_.hooks.run("before-highlight", env);
|
||
if (!env.grammar) {
|
||
insertHighlightedCode(_.util.encode(env.code));
|
||
return;
|
||
}
|
||
if (async && _self2.Worker) {
|
||
var worker = new Worker(_.filename);
|
||
worker.onmessage = function(evt) {
|
||
insertHighlightedCode(evt.data);
|
||
};
|
||
worker.postMessage(JSON.stringify({
|
||
language: env.language,
|
||
code: env.code,
|
||
immediateClose: true
|
||
}));
|
||
} else {
|
||
insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
|
||
}
|
||
},
|
||
/**
|
||
* Low-level function, only use if you know what you’re doing. It accepts a string of text as input
|
||
* and the language definitions to use, and returns a string with the HTML produced.
|
||
*
|
||
* The following hooks will be run:
|
||
* 1. `before-tokenize`
|
||
* 2. `after-tokenize`
|
||
* 3. `wrap`: On each {@link Token}.
|
||
*
|
||
* @param {string} text A string with the code to be highlighted.
|
||
* @param {Grammar} grammar An object containing the tokens to use.
|
||
*
|
||
* Usually a language definition like `Prism.languages.markup`.
|
||
* @param {string} language The name of the language definition passed to `grammar`.
|
||
* @returns {string} The highlighted HTML.
|
||
* @memberof Prism
|
||
* @public
|
||
* @example
|
||
* Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
|
||
*/
|
||
highlight: function(text, grammar, language) {
|
||
var env = {
|
||
code: text,
|
||
grammar,
|
||
language
|
||
};
|
||
_.hooks.run("before-tokenize", env);
|
||
if (!env.grammar) {
|
||
throw new Error('The language "' + env.language + '" has no grammar.');
|
||
}
|
||
env.tokens = _.tokenize(env.code, env.grammar);
|
||
_.hooks.run("after-tokenize", env);
|
||
return Token.stringify(_.util.encode(env.tokens), env.language);
|
||
},
|
||
/**
|
||
* This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
|
||
* and the language definitions to use, and returns an array with the tokenized code.
|
||
*
|
||
* When the language definition includes nested tokens, the function is called recursively on each of these tokens.
|
||
*
|
||
* This method could be useful in other contexts as well, as a very crude parser.
|
||
*
|
||
* @param {string} text A string with the code to be highlighted.
|
||
* @param {Grammar} grammar An object containing the tokens to use.
|
||
*
|
||
* Usually a language definition like `Prism.languages.markup`.
|
||
* @returns {TokenStream} An array of strings and tokens, a token stream.
|
||
* @memberof Prism
|
||
* @public
|
||
* @example
|
||
* let code = `var foo = 0;`;
|
||
* let tokens = Prism.tokenize(code, Prism.languages.javascript);
|
||
* tokens.forEach(token => {
|
||
* if (token instanceof Prism.Token && token.type === 'number') {
|
||
* console.log(`Found numeric literal: ${token.content}`);
|
||
* }
|
||
* });
|
||
*/
|
||
tokenize: function(text, grammar) {
|
||
var rest = grammar.rest;
|
||
if (rest) {
|
||
for (var token in rest) {
|
||
grammar[token] = rest[token];
|
||
}
|
||
delete grammar.rest;
|
||
}
|
||
var tokenList = new LinkedList();
|
||
addAfter(tokenList, tokenList.head, text);
|
||
matchGrammar(text, tokenList, grammar, tokenList.head, 0);
|
||
return toArray(tokenList);
|
||
},
|
||
/**
|
||
* @namespace
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
hooks: {
|
||
all: {},
|
||
/**
|
||
* Adds the given callback to the list of callbacks for the given hook.
|
||
*
|
||
* The callback will be invoked when the hook it is registered for is run.
|
||
* Hooks are usually directly run by a highlight function but you can also run hooks yourself.
|
||
*
|
||
* One callback function can be registered to multiple hooks and the same hook multiple times.
|
||
*
|
||
* @param {string} name The name of the hook.
|
||
* @param {HookCallback} callback The callback function which is given environment variables.
|
||
* @public
|
||
*/
|
||
add: function(name, callback) {
|
||
var hooks = _.hooks.all;
|
||
hooks[name] = hooks[name] || [];
|
||
hooks[name].push(callback);
|
||
},
|
||
/**
|
||
* Runs a hook invoking all registered callbacks with the given environment variables.
|
||
*
|
||
* Callbacks will be invoked synchronously and in the order in which they were registered.
|
||
*
|
||
* @param {string} name The name of the hook.
|
||
* @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
|
||
* @public
|
||
*/
|
||
run: function(name, env) {
|
||
var callbacks = _.hooks.all[name];
|
||
if (!callbacks || !callbacks.length) {
|
||
return;
|
||
}
|
||
for (var i = 0, callback; callback = callbacks[i++]; ) {
|
||
callback(env);
|
||
}
|
||
}
|
||
},
|
||
Token
|
||
};
|
||
_self2.Prism = _;
|
||
function Token(type, content, alias, matchedStr) {
|
||
this.type = type;
|
||
this.content = content;
|
||
this.alias = alias;
|
||
this.length = (matchedStr || "").length | 0;
|
||
}
|
||
Token.stringify = function stringify(o, language) {
|
||
if (typeof o == "string") {
|
||
return o;
|
||
}
|
||
if (Array.isArray(o)) {
|
||
var s = "";
|
||
o.forEach(function(e) {
|
||
s += stringify(e, language);
|
||
});
|
||
return s;
|
||
}
|
||
var env = {
|
||
type: o.type,
|
||
content: stringify(o.content, language),
|
||
tag: "span",
|
||
classes: ["token", o.type],
|
||
attributes: {},
|
||
language
|
||
};
|
||
var aliases = o.alias;
|
||
if (aliases) {
|
||
if (Array.isArray(aliases)) {
|
||
Array.prototype.push.apply(env.classes, aliases);
|
||
} else {
|
||
env.classes.push(aliases);
|
||
}
|
||
}
|
||
_.hooks.run("wrap", env);
|
||
var attributes = "";
|
||
for (var name in env.attributes) {
|
||
attributes += " " + name + '="' + (env.attributes[name] || "").replace(/"/g, """) + '"';
|
||
}
|
||
return "<" + env.tag + ' class="' + env.classes.join(" ") + '"' + attributes + ">" + env.content + "</" + env.tag + ">";
|
||
};
|
||
function matchPattern(pattern, pos, text, lookbehind) {
|
||
pattern.lastIndex = pos;
|
||
var match = pattern.exec(text);
|
||
if (match && lookbehind && match[1]) {
|
||
var lookbehindLength = match[1].length;
|
||
match.index += lookbehindLength;
|
||
match[0] = match[0].slice(lookbehindLength);
|
||
}
|
||
return match;
|
||
}
|
||
function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
|
||
for (var token in grammar) {
|
||
if (!grammar.hasOwnProperty(token) || !grammar[token]) {
|
||
continue;
|
||
}
|
||
var patterns = grammar[token];
|
||
patterns = Array.isArray(patterns) ? patterns : [patterns];
|
||
for (var j = 0; j < patterns.length; ++j) {
|
||
if (rematch && rematch.cause == token + "," + j) {
|
||
return;
|
||
}
|
||
var patternObj = patterns[j];
|
||
var inside = patternObj.inside;
|
||
var lookbehind = !!patternObj.lookbehind;
|
||
var greedy = !!patternObj.greedy;
|
||
var alias = patternObj.alias;
|
||
if (greedy && !patternObj.pattern.global) {
|
||
var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
|
||
patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
|
||
}
|
||
var pattern = patternObj.pattern || patternObj;
|
||
for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
|
||
if (rematch && pos >= rematch.reach) {
|
||
break;
|
||
}
|
||
var str = currentNode.value;
|
||
if (tokenList.length > text.length) {
|
||
return;
|
||
}
|
||
if (str instanceof Token) {
|
||
continue;
|
||
}
|
||
var removeCount = 1;
|
||
var match;
|
||
if (greedy) {
|
||
match = matchPattern(pattern, pos, text, lookbehind);
|
||
if (!match || match.index >= text.length) {
|
||
break;
|
||
}
|
||
var from = match.index;
|
||
var to = match.index + match[0].length;
|
||
var p = pos;
|
||
p += currentNode.value.length;
|
||
while (from >= p) {
|
||
currentNode = currentNode.next;
|
||
p += currentNode.value.length;
|
||
}
|
||
p -= currentNode.value.length;
|
||
pos = p;
|
||
if (currentNode.value instanceof Token) {
|
||
continue;
|
||
}
|
||
for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === "string"); k = k.next) {
|
||
removeCount++;
|
||
p += k.value.length;
|
||
}
|
||
removeCount--;
|
||
str = text.slice(pos, p);
|
||
match.index -= pos;
|
||
} else {
|
||
match = matchPattern(pattern, 0, str, lookbehind);
|
||
if (!match) {
|
||
continue;
|
||
}
|
||
}
|
||
var from = match.index;
|
||
var matchStr = match[0];
|
||
var before = str.slice(0, from);
|
||
var after = str.slice(from + matchStr.length);
|
||
var reach = pos + str.length;
|
||
if (rematch && reach > rematch.reach) {
|
||
rematch.reach = reach;
|
||
}
|
||
var removeFrom = currentNode.prev;
|
||
if (before) {
|
||
removeFrom = addAfter(tokenList, removeFrom, before);
|
||
pos += before.length;
|
||
}
|
||
removeRange(tokenList, removeFrom, removeCount);
|
||
var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
|
||
currentNode = addAfter(tokenList, removeFrom, wrapped);
|
||
if (after) {
|
||
addAfter(tokenList, currentNode, after);
|
||
}
|
||
if (removeCount > 1) {
|
||
var nestedRematch = {
|
||
cause: token + "," + j,
|
||
reach
|
||
};
|
||
matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
|
||
if (rematch && nestedRematch.reach > rematch.reach) {
|
||
rematch.reach = nestedRematch.reach;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function LinkedList() {
|
||
var head = { value: null, prev: null, next: null };
|
||
var tail = { value: null, prev: head, next: null };
|
||
head.next = tail;
|
||
this.head = head;
|
||
this.tail = tail;
|
||
this.length = 0;
|
||
}
|
||
function addAfter(list, node, value) {
|
||
var next = node.next;
|
||
var newNode = { value, prev: node, next };
|
||
node.next = newNode;
|
||
next.prev = newNode;
|
||
list.length++;
|
||
return newNode;
|
||
}
|
||
function removeRange(list, node, count) {
|
||
var next = node.next;
|
||
for (var i = 0; i < count && next !== list.tail; i++) {
|
||
next = next.next;
|
||
}
|
||
node.next = next;
|
||
next.prev = node;
|
||
list.length -= i;
|
||
}
|
||
function toArray(list) {
|
||
var array = [];
|
||
var node = list.head.next;
|
||
while (node !== list.tail) {
|
||
array.push(node.value);
|
||
node = node.next;
|
||
}
|
||
return array;
|
||
}
|
||
if (!_self2.document) {
|
||
if (!_self2.addEventListener) {
|
||
return _;
|
||
}
|
||
if (!_.disableWorkerMessageHandler) {
|
||
_self2.addEventListener("message", function(evt) {
|
||
var message = JSON.parse(evt.data);
|
||
var lang2 = message.language;
|
||
var code = message.code;
|
||
var immediateClose = message.immediateClose;
|
||
_self2.postMessage(_.highlight(code, _.languages[lang2], lang2));
|
||
if (immediateClose) {
|
||
_self2.close();
|
||
}
|
||
}, false);
|
||
}
|
||
return _;
|
||
}
|
||
var script = _.util.currentScript();
|
||
if (script) {
|
||
_.filename = script.src;
|
||
if (script.hasAttribute("data-manual")) {
|
||
_.manual = true;
|
||
}
|
||
}
|
||
function highlightAutomaticallyCallback() {
|
||
if (!_.manual) {
|
||
_.highlightAll();
|
||
}
|
||
}
|
||
if (!_.manual) {
|
||
var readyState = document.readyState;
|
||
if (readyState === "loading" || readyState === "interactive" && script && script.defer) {
|
||
document.addEventListener("DOMContentLoaded", highlightAutomaticallyCallback);
|
||
} else {
|
||
if (window.requestAnimationFrame) {
|
||
window.requestAnimationFrame(highlightAutomaticallyCallback);
|
||
} else {
|
||
window.setTimeout(highlightAutomaticallyCallback, 16);
|
||
}
|
||
}
|
||
}
|
||
return _;
|
||
})(_self);
|
||
if (typeof module !== "undefined" && module.exports) {
|
||
module.exports = Prism;
|
||
}
|
||
if (typeof global !== "undefined") {
|
||
global.Prism = Prism;
|
||
}
|
||
Prism.languages.markup = {
|
||
"comment": {
|
||
pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
|
||
greedy: true
|
||
},
|
||
"prolog": {
|
||
pattern: /<\?[\s\S]+?\?>/,
|
||
greedy: true
|
||
},
|
||
"doctype": {
|
||
// https://www.w3.org/TR/xml/#NT-doctypedecl
|
||
pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
|
||
greedy: true,
|
||
inside: {
|
||
"internal-subset": {
|
||
pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
|
||
lookbehind: true,
|
||
greedy: true,
|
||
inside: null
|
||
// see below
|
||
},
|
||
"string": {
|
||
pattern: /"[^"]*"|'[^']*'/,
|
||
greedy: true
|
||
},
|
||
"punctuation": /^<!|>$|[[\]]/,
|
||
"doctype-tag": /^DOCTYPE/i,
|
||
"name": /[^\s<>'"]+/
|
||
}
|
||
},
|
||
"cdata": {
|
||
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
||
greedy: true
|
||
},
|
||
"tag": {
|
||
pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
|
||
greedy: true,
|
||
inside: {
|
||
"tag": {
|
||
pattern: /^<\/?[^\s>\/]+/,
|
||
inside: {
|
||
"punctuation": /^<\/?/,
|
||
"namespace": /^[^\s>\/:]+:/
|
||
}
|
||
},
|
||
"special-attr": [],
|
||
"attr-value": {
|
||
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
|
||
inside: {
|
||
"punctuation": [
|
||
{
|
||
pattern: /^=/,
|
||
alias: "attr-equals"
|
||
},
|
||
{
|
||
pattern: /^(\s*)["']|["']$/,
|
||
lookbehind: true
|
||
}
|
||
]
|
||
}
|
||
},
|
||
"punctuation": /\/?>/,
|
||
"attr-name": {
|
||
pattern: /[^\s>\/]+/,
|
||
inside: {
|
||
"namespace": /^[^\s>\/:]+:/
|
||
}
|
||
}
|
||
}
|
||
},
|
||
"entity": [
|
||
{
|
||
pattern: /&[\da-z]{1,8};/i,
|
||
alias: "named-entity"
|
||
},
|
||
/&#x?[\da-f]{1,8};/i
|
||
]
|
||
};
|
||
Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism.languages.markup["entity"];
|
||
Prism.languages.markup["doctype"].inside["internal-subset"].inside = Prism.languages.markup;
|
||
Prism.hooks.add("wrap", function(env) {
|
||
if (env.type === "entity") {
|
||
env.attributes["title"] = env.content.replace(/&/, "&");
|
||
}
|
||
});
|
||
Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
|
||
/**
|
||
* Adds an inlined language to markup.
|
||
*
|
||
* An example of an inlined language is CSS with `<style>` tags.
|
||
*
|
||
* @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
|
||
* case insensitive.
|
||
* @param {string} lang The language key.
|
||
* @example
|
||
* addInlined('style', 'css');
|
||
*/
|
||
value: function addInlined(tagName, lang) {
|
||
var includedCdataInside = {};
|
||
includedCdataInside["language-" + lang] = {
|
||
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
|
||
lookbehind: true,
|
||
inside: Prism.languages[lang]
|
||
};
|
||
includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
|
||
var inside = {
|
||
"included-cdata": {
|
||
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
||
inside: includedCdataInside
|
||
}
|
||
};
|
||
inside["language-" + lang] = {
|
||
pattern: /[\s\S]+/,
|
||
inside: Prism.languages[lang]
|
||
};
|
||
var def = {};
|
||
def[tagName] = {
|
||
pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
|
||
return tagName;
|
||
}), "i"),
|
||
lookbehind: true,
|
||
greedy: true,
|
||
inside
|
||
};
|
||
Prism.languages.insertBefore("markup", "cdata", def);
|
||
}
|
||
});
|
||
Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
|
||
/**
|
||
* Adds an pattern to highlight languages embedded in HTML attributes.
|
||
*
|
||
* An example of an inlined language is CSS with `style` attributes.
|
||
*
|
||
* @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
|
||
* case insensitive.
|
||
* @param {string} lang The language key.
|
||
* @example
|
||
* addAttribute('style', 'css');
|
||
*/
|
||
value: function(attrName, lang) {
|
||
Prism.languages.markup.tag.inside["special-attr"].push({
|
||
pattern: RegExp(
|
||
/(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
|
||
"i"
|
||
),
|
||
lookbehind: true,
|
||
inside: {
|
||
"attr-name": /^[^\s=]+/,
|
||
"attr-value": {
|
||
pattern: /=[\s\S]+/,
|
||
inside: {
|
||
"value": {
|
||
pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
|
||
lookbehind: true,
|
||
alias: [lang, "language-" + lang],
|
||
inside: Prism.languages[lang]
|
||
},
|
||
"punctuation": [
|
||
{
|
||
pattern: /^=/,
|
||
alias: "attr-equals"
|
||
},
|
||
/"|'/
|
||
]
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
});
|
||
Prism.languages.html = Prism.languages.markup;
|
||
Prism.languages.mathml = Prism.languages.markup;
|
||
Prism.languages.svg = Prism.languages.markup;
|
||
Prism.languages.xml = Prism.languages.extend("markup", {});
|
||
Prism.languages.ssml = Prism.languages.xml;
|
||
Prism.languages.atom = Prism.languages.xml;
|
||
Prism.languages.rss = Prism.languages.xml;
|
||
(function(Prism2) {
|
||
var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
|
||
Prism2.languages.css = {
|
||
"comment": /\/\*[\s\S]*?\*\//,
|
||
"atrule": {
|
||
pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + string.source + ")*?" + /(?:;|(?=\s*\{))/.source),
|
||
inside: {
|
||
"rule": /^@[\w-]+/,
|
||
"selector-function-argument": {
|
||
pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
|
||
lookbehind: true,
|
||
alias: "selector"
|
||
},
|
||
"keyword": {
|
||
pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
|
||
lookbehind: true
|
||
}
|
||
// See rest below
|
||
}
|
||
},
|
||
"url": {
|
||
// https://drafts.csswg.org/css-values-3/#urls
|
||
pattern: RegExp("\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
|
||
greedy: true,
|
||
inside: {
|
||
"function": /^url/i,
|
||
"punctuation": /^\(|\)$/,
|
||
"string": {
|
||
pattern: RegExp("^" + string.source + "$"),
|
||
alias: "url"
|
||
}
|
||
}
|
||
},
|
||
"selector": {
|
||
pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + string.source + ")*(?=\\s*\\{)"),
|
||
lookbehind: true
|
||
},
|
||
"string": {
|
||
pattern: string,
|
||
greedy: true
|
||
},
|
||
"property": {
|
||
pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
|
||
lookbehind: true
|
||
},
|
||
"important": /!important\b/i,
|
||
"function": {
|
||
pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
|
||
lookbehind: true
|
||
},
|
||
"punctuation": /[(){};:,]/
|
||
};
|
||
Prism2.languages.css["atrule"].inside.rest = Prism2.languages.css;
|
||
var markup = Prism2.languages.markup;
|
||
if (markup) {
|
||
markup.tag.addInlined("style", "css");
|
||
markup.tag.addAttribute("style", "css");
|
||
}
|
||
})(Prism);
|
||
Prism.languages.clike = {
|
||
"comment": [
|
||
{
|
||
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
||
lookbehind: true,
|
||
greedy: true
|
||
},
|
||
{
|
||
pattern: /(^|[^\\:])\/\/.*/,
|
||
lookbehind: true,
|
||
greedy: true
|
||
}
|
||
],
|
||
"string": {
|
||
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
||
greedy: true
|
||
},
|
||
"class-name": {
|
||
pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
|
||
lookbehind: true,
|
||
inside: {
|
||
"punctuation": /[.\\]/
|
||
}
|
||
},
|
||
"keyword": /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
|
||
"boolean": /\b(?:false|true)\b/,
|
||
"function": /\b\w+(?=\()/,
|
||
"number": /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
||
"operator": /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
|
||
"punctuation": /[{}[\];(),.:]/
|
||
};
|
||
Prism.languages.javascript = Prism.languages.extend("clike", {
|
||
"class-name": [
|
||
Prism.languages.clike["class-name"],
|
||
{
|
||
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
|
||
lookbehind: true
|
||
}
|
||
],
|
||
"keyword": [
|
||
{
|
||
pattern: /((?:^|\})\s*)catch\b/,
|
||
lookbehind: true
|
||
},
|
||
{
|
||
pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
|
||
lookbehind: true
|
||
}
|
||
],
|
||
// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
|
||
"function": /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
|
||
"number": {
|
||
pattern: RegExp(
|
||
/(^|[^\w$])/.source + "(?:" + // constant
|
||
(/NaN|Infinity/.source + "|" + // binary integer
|
||
/0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
|
||
/0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
|
||
/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
|
||
/\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
|
||
/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
|
||
),
|
||
lookbehind: true
|
||
},
|
||
"operator": /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
|
||
});
|
||
Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
|
||
Prism.languages.insertBefore("javascript", "keyword", {
|
||
"regex": {
|
||
pattern: RegExp(
|
||
// lookbehind
|
||
// eslint-disable-next-line regexp/no-dupe-characters-character-class
|
||
/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
|
||
// There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
|
||
// classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
|
||
// with the only syntax, so we have to define 2 different regex patterns.
|
||
/\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
|
||
/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
|
||
/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
|
||
),
|
||
lookbehind: true,
|
||
greedy: true,
|
||
inside: {
|
||
"regex-source": {
|
||
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
||
lookbehind: true,
|
||
alias: "language-regex",
|
||
inside: Prism.languages.regex
|
||
},
|
||
"regex-delimiter": /^\/|\/$/,
|
||
"regex-flags": /^[a-z]+$/
|
||
}
|
||
},
|
||
// This must be declared before keyword because we use "function" inside the look-forward
|
||
"function-variable": {
|
||
pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
|
||
alias: "function"
|
||
},
|
||
"parameter": [
|
||
{
|
||
pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
|
||
lookbehind: true,
|
||
inside: Prism.languages.javascript
|
||
},
|
||
{
|
||
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
|
||
lookbehind: true,
|
||
inside: Prism.languages.javascript
|
||
},
|
||
{
|
||
pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
|
||
lookbehind: true,
|
||
inside: Prism.languages.javascript
|
||
},
|
||
{
|
||
pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
|
||
lookbehind: true,
|
||
inside: Prism.languages.javascript
|
||
}
|
||
],
|
||
"constant": /\b[A-Z](?:[A-Z_]|\dx?)*\b/
|
||
});
|
||
Prism.languages.insertBefore("javascript", "string", {
|
||
"hashbang": {
|
||
pattern: /^#!.*/,
|
||
greedy: true,
|
||
alias: "comment"
|
||
},
|
||
"template-string": {
|
||
pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
|
||
greedy: true,
|
||
inside: {
|
||
"template-punctuation": {
|
||
pattern: /^`|`$/,
|
||
alias: "string"
|
||
},
|
||
"interpolation": {
|
||
pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
||
lookbehind: true,
|
||
inside: {
|
||
"interpolation-punctuation": {
|
||
pattern: /^\$\{|\}$/,
|
||
alias: "punctuation"
|
||
},
|
||
rest: Prism.languages.javascript
|
||
}
|
||
},
|
||
"string": /[\s\S]+/
|
||
}
|
||
},
|
||
"string-property": {
|
||
pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
|
||
lookbehind: true,
|
||
greedy: true,
|
||
alias: "property"
|
||
}
|
||
});
|
||
Prism.languages.insertBefore("javascript", "operator", {
|
||
"literal-property": {
|
||
pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
|
||
lookbehind: true,
|
||
alias: "property"
|
||
}
|
||
});
|
||
if (Prism.languages.markup) {
|
||
Prism.languages.markup.tag.addInlined("script", "javascript");
|
||
Prism.languages.markup.tag.addAttribute(
|
||
/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
|
||
"javascript"
|
||
);
|
||
}
|
||
Prism.languages.js = Prism.languages.javascript;
|
||
(function(Prism2) {
|
||
Prism2.languages.diff = {
|
||
"coord": [
|
||
// Match all kinds of coord lines (prefixed by "+++", "---" or "***").
|
||
/^(?:\*{3}|-{3}|\+{3}).*$/m,
|
||
// Match "@@ ... @@" coord lines in unified diff.
|
||
/^@@.*@@$/m,
|
||
// Match coord lines in normal diff (starts with a number).
|
||
/^\d.*$/m
|
||
]
|
||
// deleted, inserted, unchanged, diff
|
||
};
|
||
var PREFIXES = {
|
||
"deleted-sign": "-",
|
||
"deleted-arrow": "<",
|
||
"inserted-sign": "+",
|
||
"inserted-arrow": ">",
|
||
"unchanged": " ",
|
||
"diff": "!"
|
||
};
|
||
Object.keys(PREFIXES).forEach(function(name) {
|
||
var prefix = PREFIXES[name];
|
||
var alias = [];
|
||
if (!/^\w+$/.test(name)) {
|
||
alias.push(/\w+/.exec(name)[0]);
|
||
}
|
||
if (name === "diff") {
|
||
alias.push("bold");
|
||
}
|
||
Prism2.languages.diff[name] = {
|
||
pattern: RegExp("^(?:[" + prefix + "].*(?:\r\n?|\n|(?![\\s\\S])))+", "m"),
|
||
alias,
|
||
inside: {
|
||
"line": {
|
||
pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
|
||
lookbehind: true
|
||
},
|
||
"prefix": {
|
||
pattern: /[\s\S]/,
|
||
alias: /\w+/.exec(name)[0]
|
||
}
|
||
}
|
||
};
|
||
});
|
||
Object.defineProperty(Prism2.languages.diff, "PREFIXES", {
|
||
value: PREFIXES
|
||
});
|
||
})(Prism);
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined" || !document.querySelector) {
|
||
return;
|
||
}
|
||
var LINE_NUMBERS_CLASS = "line-numbers";
|
||
var LINKABLE_LINE_NUMBERS_CLASS = "linkable-line-numbers";
|
||
var NEW_LINE_EXP = /\n(?!$)/g;
|
||
function $$(selector, container) {
|
||
return Array.prototype.slice.call((container || document).querySelectorAll(selector));
|
||
}
|
||
function hasClass(element, className) {
|
||
return element.classList.contains(className);
|
||
}
|
||
function callFunction(func) {
|
||
func();
|
||
}
|
||
var isLineHeightRounded = /* @__PURE__ */ (function() {
|
||
var res;
|
||
return function() {
|
||
if (typeof res === "undefined") {
|
||
var d = document.createElement("div");
|
||
d.style.fontSize = "13px";
|
||
d.style.lineHeight = "1.5";
|
||
d.style.padding = "0";
|
||
d.style.border = "0";
|
||
d.innerHTML = " <br /> ";
|
||
document.body.appendChild(d);
|
||
res = d.offsetHeight === 38;
|
||
document.body.removeChild(d);
|
||
}
|
||
return res;
|
||
};
|
||
})();
|
||
function getContentBoxTopOffset(parent, child) {
|
||
var parentStyle = getComputedStyle(parent);
|
||
var childStyle = getComputedStyle(child);
|
||
function pxToNumber(px) {
|
||
return +px.substr(0, px.length - 2);
|
||
}
|
||
return child.offsetTop + pxToNumber(childStyle.borderTopWidth) + pxToNumber(childStyle.paddingTop) - pxToNumber(parentStyle.paddingTop);
|
||
}
|
||
function isActiveFor(pre) {
|
||
if (!pre || !/pre/i.test(pre.nodeName)) {
|
||
return false;
|
||
}
|
||
if (pre.hasAttribute("data-line")) {
|
||
return true;
|
||
}
|
||
if (pre.id && Prism.util.isActive(pre, LINKABLE_LINE_NUMBERS_CLASS)) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
var scrollIntoView = true;
|
||
Prism.plugins.lineHighlight = {
|
||
/**
|
||
* Highlights the lines of the given pre.
|
||
*
|
||
* This function is split into a DOM measuring and mutate phase to improve performance.
|
||
* The returned function mutates the DOM when called.
|
||
*
|
||
* @param {HTMLElement} pre
|
||
* @param {string | null} [lines]
|
||
* @param {string} [classes='']
|
||
* @returns {() => void}
|
||
*/
|
||
highlightLines: function highlightLines(pre, lines, classes) {
|
||
lines = typeof lines === "string" ? lines : pre.getAttribute("data-line") || "";
|
||
var ranges = lines.replace(/\s+/g, "").split(",").filter(Boolean);
|
||
var offset = +pre.getAttribute("data-line-offset") || 0;
|
||
var parseMethod = isLineHeightRounded() ? parseInt : parseFloat;
|
||
var lineHeight = parseMethod(getComputedStyle(pre).lineHeight);
|
||
var hasLineNumbers = Prism.util.isActive(pre, LINE_NUMBERS_CLASS);
|
||
var codeElement = pre.querySelector("code");
|
||
var parentElement = hasLineNumbers ? pre : codeElement || pre;
|
||
var mutateActions = (
|
||
/** @type {(() => void)[]} */
|
||
[]
|
||
);
|
||
var lineBreakMatch = codeElement.textContent.match(NEW_LINE_EXP);
|
||
var numberOfLines = lineBreakMatch ? lineBreakMatch.length + 1 : 1;
|
||
var codePreOffset = !codeElement || parentElement == codeElement ? 0 : getContentBoxTopOffset(pre, codeElement);
|
||
ranges.forEach(function(currentRange) {
|
||
var range = currentRange.split("-");
|
||
var start2 = +range[0];
|
||
var end = +range[1] || start2;
|
||
end = Math.min(numberOfLines + offset, end);
|
||
if (end < start2) {
|
||
return;
|
||
}
|
||
var line = pre.querySelector('.line-highlight[data-range="' + currentRange + '"]') || document.createElement("div");
|
||
mutateActions.push(function() {
|
||
line.setAttribute("aria-hidden", "true");
|
||
line.setAttribute("data-range", currentRange);
|
||
line.className = (classes || "") + " line-highlight";
|
||
});
|
||
if (hasLineNumbers && Prism.plugins.lineNumbers) {
|
||
var startNode = Prism.plugins.lineNumbers.getLine(pre, start2);
|
||
var endNode = Prism.plugins.lineNumbers.getLine(pre, end);
|
||
if (startNode) {
|
||
var top = startNode.offsetTop + codePreOffset + "px";
|
||
mutateActions.push(function() {
|
||
line.style.top = top;
|
||
});
|
||
}
|
||
if (endNode) {
|
||
var height = endNode.offsetTop - startNode.offsetTop + endNode.offsetHeight + "px";
|
||
mutateActions.push(function() {
|
||
line.style.height = height;
|
||
});
|
||
}
|
||
} else {
|
||
mutateActions.push(function() {
|
||
line.setAttribute("data-start", String(start2));
|
||
if (end > start2) {
|
||
line.setAttribute("data-end", String(end));
|
||
}
|
||
line.style.top = (start2 - offset - 1) * lineHeight + codePreOffset + "px";
|
||
line.textContent = new Array(end - start2 + 2).join(" \n");
|
||
});
|
||
}
|
||
mutateActions.push(function() {
|
||
line.style.width = pre.scrollWidth + "px";
|
||
});
|
||
mutateActions.push(function() {
|
||
parentElement.appendChild(line);
|
||
});
|
||
});
|
||
var id = pre.id;
|
||
if (hasLineNumbers && Prism.util.isActive(pre, LINKABLE_LINE_NUMBERS_CLASS) && id) {
|
||
if (!hasClass(pre, LINKABLE_LINE_NUMBERS_CLASS)) {
|
||
mutateActions.push(function() {
|
||
pre.classList.add(LINKABLE_LINE_NUMBERS_CLASS);
|
||
});
|
||
}
|
||
var start = parseInt(pre.getAttribute("data-start") || "1");
|
||
$$(".line-numbers-rows > span", pre).forEach(function(lineSpan, i) {
|
||
var lineNumber = i + start;
|
||
lineSpan.onclick = function() {
|
||
var hash = id + "." + lineNumber;
|
||
scrollIntoView = false;
|
||
location.hash = hash;
|
||
setTimeout(function() {
|
||
scrollIntoView = true;
|
||
}, 1);
|
||
};
|
||
});
|
||
}
|
||
return function() {
|
||
mutateActions.forEach(callFunction);
|
||
};
|
||
}
|
||
};
|
||
function applyHash() {
|
||
var hash = location.hash.slice(1);
|
||
$$(".temporary.line-highlight").forEach(function(line) {
|
||
line.parentNode.removeChild(line);
|
||
});
|
||
var range = (hash.match(/\.([\d,-]+)$/) || [, ""])[1];
|
||
if (!range || document.getElementById(hash)) {
|
||
return;
|
||
}
|
||
var id = hash.slice(0, hash.lastIndexOf("."));
|
||
var pre = document.getElementById(id);
|
||
if (!pre) {
|
||
return;
|
||
}
|
||
if (!pre.hasAttribute("data-line")) {
|
||
pre.setAttribute("data-line", "");
|
||
}
|
||
var mutateDom = Prism.plugins.lineHighlight.highlightLines(pre, range, "temporary ");
|
||
mutateDom();
|
||
if (scrollIntoView) {
|
||
document.querySelector(".temporary.line-highlight").scrollIntoView();
|
||
}
|
||
}
|
||
var fakeTimer = 0;
|
||
Prism.hooks.add("before-sanity-check", function(env) {
|
||
var pre = env.element.parentElement;
|
||
if (!isActiveFor(pre)) {
|
||
return;
|
||
}
|
||
var num = 0;
|
||
$$(".line-highlight", pre).forEach(function(line) {
|
||
num += line.textContent.length;
|
||
line.parentNode.removeChild(line);
|
||
});
|
||
if (num && /^(?: \n)+$/.test(env.code.slice(-num))) {
|
||
env.code = env.code.slice(0, -num);
|
||
}
|
||
});
|
||
Prism.hooks.add("complete", function completeHook(env) {
|
||
var pre = env.element.parentElement;
|
||
if (!isActiveFor(pre)) {
|
||
return;
|
||
}
|
||
clearTimeout(fakeTimer);
|
||
var hasLineNumbers = Prism.plugins.lineNumbers;
|
||
var isLineNumbersLoaded = env.plugins && env.plugins.lineNumbers;
|
||
if (hasClass(pre, LINE_NUMBERS_CLASS) && hasLineNumbers && !isLineNumbersLoaded) {
|
||
Prism.hooks.add("line-numbers", completeHook);
|
||
} else {
|
||
var mutateDom = Prism.plugins.lineHighlight.highlightLines(pre);
|
||
mutateDom();
|
||
fakeTimer = setTimeout(applyHash, 1);
|
||
}
|
||
});
|
||
window.addEventListener("hashchange", applyHash);
|
||
window.addEventListener("resize", function() {
|
||
var actions = $$("pre").filter(isActiveFor).map(function(pre) {
|
||
return Prism.plugins.lineHighlight.highlightLines(pre);
|
||
});
|
||
actions.forEach(callFunction);
|
||
});
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined") {
|
||
return;
|
||
}
|
||
var PLUGIN_NAME = "line-numbers";
|
||
var NEW_LINE_EXP = /\n(?!$)/g;
|
||
var config = Prism.plugins.lineNumbers = {
|
||
/**
|
||
* Get node for provided line number
|
||
*
|
||
* @param {Element} element pre element
|
||
* @param {number} number line number
|
||
* @returns {Element|undefined}
|
||
*/
|
||
getLine: function(element, number) {
|
||
if (element.tagName !== "PRE" || !element.classList.contains(PLUGIN_NAME)) {
|
||
return;
|
||
}
|
||
var lineNumberRows = element.querySelector(".line-numbers-rows");
|
||
if (!lineNumberRows) {
|
||
return;
|
||
}
|
||
var lineNumberStart = parseInt(element.getAttribute("data-start"), 10) || 1;
|
||
var lineNumberEnd = lineNumberStart + (lineNumberRows.children.length - 1);
|
||
if (number < lineNumberStart) {
|
||
number = lineNumberStart;
|
||
}
|
||
if (number > lineNumberEnd) {
|
||
number = lineNumberEnd;
|
||
}
|
||
var lineIndex = number - lineNumberStart;
|
||
return lineNumberRows.children[lineIndex];
|
||
},
|
||
/**
|
||
* Resizes the line numbers of the given element.
|
||
*
|
||
* This function will not add line numbers. It will only resize existing ones.
|
||
*
|
||
* @param {HTMLElement} element A `<pre>` element with line numbers.
|
||
* @returns {void}
|
||
*/
|
||
resize: function(element) {
|
||
resizeElements([element]);
|
||
},
|
||
/**
|
||
* Whether the plugin can assume that the units font sizes and margins are not depended on the size of
|
||
* the current viewport.
|
||
*
|
||
* Setting this to `true` will allow the plugin to do certain optimizations for better performance.
|
||
*
|
||
* Set this to `false` if you use any of the following CSS units: `vh`, `vw`, `vmin`, `vmax`.
|
||
*
|
||
* @type {boolean}
|
||
*/
|
||
assumeViewportIndependence: true
|
||
};
|
||
function resizeElements(elements) {
|
||
elements = elements.filter(function(e) {
|
||
var codeStyles = getStyles(e);
|
||
var whiteSpace = codeStyles["white-space"];
|
||
return whiteSpace === "pre-wrap" || whiteSpace === "pre-line";
|
||
});
|
||
if (elements.length == 0) {
|
||
return;
|
||
}
|
||
var infos = elements.map(function(element) {
|
||
var codeElement = element.querySelector("code");
|
||
var lineNumbersWrapper = element.querySelector(".line-numbers-rows");
|
||
if (!codeElement || !lineNumbersWrapper) {
|
||
return void 0;
|
||
}
|
||
var lineNumberSizer = element.querySelector(".line-numbers-sizer");
|
||
var codeLines = codeElement.textContent.split(NEW_LINE_EXP);
|
||
if (!lineNumberSizer) {
|
||
lineNumberSizer = document.createElement("span");
|
||
lineNumberSizer.className = "line-numbers-sizer";
|
||
codeElement.appendChild(lineNumberSizer);
|
||
}
|
||
lineNumberSizer.innerHTML = "0";
|
||
lineNumberSizer.style.display = "block";
|
||
var oneLinerHeight = lineNumberSizer.getBoundingClientRect().height;
|
||
lineNumberSizer.innerHTML = "";
|
||
return {
|
||
element,
|
||
lines: codeLines,
|
||
lineHeights: [],
|
||
oneLinerHeight,
|
||
sizer: lineNumberSizer
|
||
};
|
||
}).filter(Boolean);
|
||
infos.forEach(function(info) {
|
||
var lineNumberSizer = info.sizer;
|
||
var lines = info.lines;
|
||
var lineHeights = info.lineHeights;
|
||
var oneLinerHeight = info.oneLinerHeight;
|
||
lineHeights[lines.length - 1] = void 0;
|
||
lines.forEach(function(line, index) {
|
||
if (line && line.length > 1) {
|
||
var e = lineNumberSizer.appendChild(document.createElement("span"));
|
||
e.style.display = "block";
|
||
e.textContent = line;
|
||
} else {
|
||
lineHeights[index] = oneLinerHeight;
|
||
}
|
||
});
|
||
});
|
||
infos.forEach(function(info) {
|
||
var lineNumberSizer = info.sizer;
|
||
var lineHeights = info.lineHeights;
|
||
var childIndex = 0;
|
||
for (var i = 0; i < lineHeights.length; i++) {
|
||
if (lineHeights[i] === void 0) {
|
||
lineHeights[i] = lineNumberSizer.children[childIndex++].getBoundingClientRect().height;
|
||
}
|
||
}
|
||
});
|
||
infos.forEach(function(info) {
|
||
var lineNumberSizer = info.sizer;
|
||
var wrapper = info.element.querySelector(".line-numbers-rows");
|
||
lineNumberSizer.style.display = "none";
|
||
lineNumberSizer.innerHTML = "";
|
||
info.lineHeights.forEach(function(height, lineNumber) {
|
||
wrapper.children[lineNumber].style.height = height + "px";
|
||
});
|
||
});
|
||
}
|
||
function getStyles(element) {
|
||
if (!element) {
|
||
return null;
|
||
}
|
||
return window.getComputedStyle ? getComputedStyle(element) : element.currentStyle || null;
|
||
}
|
||
var lastWidth = void 0;
|
||
window.addEventListener("resize", function() {
|
||
if (config.assumeViewportIndependence && lastWidth === window.innerWidth) {
|
||
return;
|
||
}
|
||
lastWidth = window.innerWidth;
|
||
resizeElements(Array.prototype.slice.call(document.querySelectorAll("pre." + PLUGIN_NAME)));
|
||
});
|
||
Prism.hooks.add("complete", function(env) {
|
||
if (!env.code) {
|
||
return;
|
||
}
|
||
var code = (
|
||
/** @type {Element} */
|
||
env.element
|
||
);
|
||
var pre = (
|
||
/** @type {HTMLElement} */
|
||
code.parentNode
|
||
);
|
||
if (!pre || !/pre/i.test(pre.nodeName)) {
|
||
return;
|
||
}
|
||
if (code.querySelector(".line-numbers-rows")) {
|
||
return;
|
||
}
|
||
if (!Prism.util.isActive(code, PLUGIN_NAME)) {
|
||
return;
|
||
}
|
||
code.classList.remove(PLUGIN_NAME);
|
||
pre.classList.add(PLUGIN_NAME);
|
||
var match = env.code.match(NEW_LINE_EXP);
|
||
var linesNum = match ? match.length + 1 : 1;
|
||
var lineNumbersWrapper;
|
||
var lines = new Array(linesNum + 1).join("<span></span>");
|
||
lineNumbersWrapper = document.createElement("span");
|
||
lineNumbersWrapper.setAttribute("aria-hidden", "true");
|
||
lineNumbersWrapper.className = "line-numbers-rows";
|
||
lineNumbersWrapper.innerHTML = lines;
|
||
if (pre.hasAttribute("data-start")) {
|
||
pre.style.counterReset = "linenumber " + (parseInt(pre.getAttribute("data-start"), 10) - 1);
|
||
}
|
||
env.element.appendChild(lineNumbersWrapper);
|
||
resizeElements([pre]);
|
||
Prism.hooks.run("line-numbers", env);
|
||
});
|
||
Prism.hooks.add("line-numbers", function(env) {
|
||
env.plugins = env.plugins || {};
|
||
env.plugins.lineNumbers = true;
|
||
});
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined") {
|
||
return;
|
||
}
|
||
if (!Element.prototype.matches) {
|
||
Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
|
||
}
|
||
var LOADING_MESSAGE = "Loading\u2026";
|
||
var FAILURE_MESSAGE = function(status, message) {
|
||
return "\u2716 Error " + status + " while fetching file: " + message;
|
||
};
|
||
var FAILURE_EMPTY_MESSAGE = "\u2716 Error: File does not exist or is empty";
|
||
var EXTENSIONS = {
|
||
"js": "javascript",
|
||
"py": "python",
|
||
"rb": "ruby",
|
||
"ps1": "powershell",
|
||
"psm1": "powershell",
|
||
"sh": "bash",
|
||
"bat": "batch",
|
||
"h": "c",
|
||
"tex": "latex"
|
||
};
|
||
var STATUS_ATTR = "data-src-status";
|
||
var STATUS_LOADING = "loading";
|
||
var STATUS_LOADED = "loaded";
|
||
var STATUS_FAILED = "failed";
|
||
var SELECTOR = "pre[data-src]:not([" + STATUS_ATTR + '="' + STATUS_LOADED + '"]):not([' + STATUS_ATTR + '="' + STATUS_LOADING + '"])';
|
||
function loadFile(src, success, error) {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", src, true);
|
||
xhr.onreadystatechange = function() {
|
||
if (xhr.readyState == 4) {
|
||
if (xhr.status < 400 && xhr.responseText) {
|
||
success(xhr.responseText);
|
||
} else {
|
||
if (xhr.status >= 400) {
|
||
error(FAILURE_MESSAGE(xhr.status, xhr.statusText));
|
||
} else {
|
||
error(FAILURE_EMPTY_MESSAGE);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
xhr.send(null);
|
||
}
|
||
function parseRange(range) {
|
||
var m = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(range || "");
|
||
if (m) {
|
||
var start = Number(m[1]);
|
||
var comma = m[2];
|
||
var end = m[3];
|
||
if (!comma) {
|
||
return [start, start];
|
||
}
|
||
if (!end) {
|
||
return [start, void 0];
|
||
}
|
||
return [start, Number(end)];
|
||
}
|
||
return void 0;
|
||
}
|
||
Prism.hooks.add("before-highlightall", function(env) {
|
||
env.selector += ", " + SELECTOR;
|
||
});
|
||
Prism.hooks.add("before-sanity-check", function(env) {
|
||
var pre = (
|
||
/** @type {HTMLPreElement} */
|
||
env.element
|
||
);
|
||
if (pre.matches(SELECTOR)) {
|
||
env.code = "";
|
||
pre.setAttribute(STATUS_ATTR, STATUS_LOADING);
|
||
var code = pre.appendChild(document.createElement("CODE"));
|
||
code.textContent = LOADING_MESSAGE;
|
||
var src = pre.getAttribute("data-src");
|
||
var language = env.language;
|
||
if (language === "none") {
|
||
var extension = (/\.(\w+)$/.exec(src) || [, "none"])[1];
|
||
language = EXTENSIONS[extension] || extension;
|
||
}
|
||
Prism.util.setLanguage(code, language);
|
||
Prism.util.setLanguage(pre, language);
|
||
var autoloader = Prism.plugins.autoloader;
|
||
if (autoloader) {
|
||
autoloader.loadLanguages(language);
|
||
}
|
||
loadFile(
|
||
src,
|
||
function(text) {
|
||
pre.setAttribute(STATUS_ATTR, STATUS_LOADED);
|
||
var range = parseRange(pre.getAttribute("data-range"));
|
||
if (range) {
|
||
var lines = text.split(/\r\n?|\n/g);
|
||
var start = range[0];
|
||
var end = range[1] == null ? lines.length : range[1];
|
||
if (start < 0) {
|
||
start += lines.length;
|
||
}
|
||
start = Math.max(0, Math.min(start - 1, lines.length));
|
||
if (end < 0) {
|
||
end += lines.length;
|
||
}
|
||
end = Math.max(0, Math.min(end, lines.length));
|
||
text = lines.slice(start, end).join("\n");
|
||
if (!pre.hasAttribute("data-start")) {
|
||
pre.setAttribute("data-start", String(start + 1));
|
||
}
|
||
}
|
||
code.textContent = text;
|
||
Prism.highlightElement(code);
|
||
},
|
||
function(error) {
|
||
pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
|
||
code.textContent = error;
|
||
}
|
||
);
|
||
}
|
||
});
|
||
Prism.plugins.fileHighlight = {
|
||
/**
|
||
* Executes the File Highlight plugin for all matching `pre` elements under the given container.
|
||
*
|
||
* Note: Elements which are already loaded or currently loading will not be touched by this method.
|
||
*
|
||
* @param {ParentNode} [container=document]
|
||
*/
|
||
highlight: function highlight(container) {
|
||
var elements = (container || document).querySelectorAll(SELECTOR);
|
||
for (var i = 0, element; element = elements[i++]; ) {
|
||
Prism.highlightElement(element);
|
||
}
|
||
}
|
||
};
|
||
var logged = false;
|
||
Prism.fileHighlight = function() {
|
||
if (!logged) {
|
||
console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead.");
|
||
logged = true;
|
||
}
|
||
Prism.plugins.fileHighlight.highlight.apply(this, arguments);
|
||
};
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined") {
|
||
return;
|
||
}
|
||
var lang_dependencies = (
|
||
/*dependencies_placeholder[*/
|
||
{
|
||
"javascript": "clike",
|
||
"actionscript": "javascript",
|
||
"apex": [
|
||
"clike",
|
||
"sql"
|
||
],
|
||
"arduino": "cpp",
|
||
"aspnet": [
|
||
"markup",
|
||
"csharp"
|
||
],
|
||
"birb": "clike",
|
||
"bison": "c",
|
||
"c": "clike",
|
||
"csharp": "clike",
|
||
"cpp": "c",
|
||
"cfscript": "clike",
|
||
"chaiscript": [
|
||
"clike",
|
||
"cpp"
|
||
],
|
||
"cilkc": "c",
|
||
"cilkcpp": "cpp",
|
||
"coffeescript": "javascript",
|
||
"crystal": "ruby",
|
||
"css-extras": "css",
|
||
"d": "clike",
|
||
"dart": "clike",
|
||
"django": "markup-templating",
|
||
"ejs": [
|
||
"javascript",
|
||
"markup-templating"
|
||
],
|
||
"etlua": [
|
||
"lua",
|
||
"markup-templating"
|
||
],
|
||
"erb": [
|
||
"ruby",
|
||
"markup-templating"
|
||
],
|
||
"fsharp": "clike",
|
||
"firestore-security-rules": "clike",
|
||
"flow": "javascript",
|
||
"ftl": "markup-templating",
|
||
"gml": "clike",
|
||
"glsl": "c",
|
||
"go": "clike",
|
||
"gradle": "clike",
|
||
"groovy": "clike",
|
||
"haml": "ruby",
|
||
"handlebars": "markup-templating",
|
||
"haxe": "clike",
|
||
"hlsl": "c",
|
||
"idris": "haskell",
|
||
"java": "clike",
|
||
"javadoc": [
|
||
"markup",
|
||
"java",
|
||
"javadoclike"
|
||
],
|
||
"jolie": "clike",
|
||
"jsdoc": [
|
||
"javascript",
|
||
"javadoclike",
|
||
"typescript"
|
||
],
|
||
"js-extras": "javascript",
|
||
"json5": "json",
|
||
"jsonp": "json",
|
||
"js-templates": "javascript",
|
||
"kotlin": "clike",
|
||
"latte": [
|
||
"clike",
|
||
"markup-templating",
|
||
"php"
|
||
],
|
||
"less": "css",
|
||
"lilypond": "scheme",
|
||
"liquid": "markup-templating",
|
||
"markdown": "markup",
|
||
"markup-templating": "markup",
|
||
"mongodb": "javascript",
|
||
"n4js": "javascript",
|
||
"objectivec": "c",
|
||
"opencl": "c",
|
||
"parser": "markup",
|
||
"php": "markup-templating",
|
||
"phpdoc": [
|
||
"php",
|
||
"javadoclike"
|
||
],
|
||
"php-extras": "php",
|
||
"plsql": "sql",
|
||
"processing": "clike",
|
||
"protobuf": "clike",
|
||
"pug": [
|
||
"markup",
|
||
"javascript"
|
||
],
|
||
"purebasic": "clike",
|
||
"purescript": "haskell",
|
||
"qsharp": "clike",
|
||
"qml": "javascript",
|
||
"qore": "clike",
|
||
"racket": "scheme",
|
||
"cshtml": [
|
||
"markup",
|
||
"csharp"
|
||
],
|
||
"jsx": [
|
||
"markup",
|
||
"javascript"
|
||
],
|
||
"tsx": [
|
||
"jsx",
|
||
"typescript"
|
||
],
|
||
"reason": "clike",
|
||
"ruby": "clike",
|
||
"sass": "css",
|
||
"scss": "css",
|
||
"scala": "java",
|
||
"shell-session": "bash",
|
||
"smarty": "markup-templating",
|
||
"solidity": "clike",
|
||
"soy": "markup-templating",
|
||
"sparql": "turtle",
|
||
"sqf": "clike",
|
||
"squirrel": "clike",
|
||
"stata": [
|
||
"mata",
|
||
"java",
|
||
"python"
|
||
],
|
||
"t4-cs": [
|
||
"t4-templating",
|
||
"csharp"
|
||
],
|
||
"t4-vb": [
|
||
"t4-templating",
|
||
"vbnet"
|
||
],
|
||
"tap": "yaml",
|
||
"tt2": [
|
||
"clike",
|
||
"markup-templating"
|
||
],
|
||
"textile": "markup",
|
||
"twig": "markup-templating",
|
||
"typescript": "javascript",
|
||
"v": "clike",
|
||
"vala": "clike",
|
||
"vbnet": "basic",
|
||
"velocity": "markup",
|
||
"wiki": "markup",
|
||
"xeora": "markup",
|
||
"xml-doc": "markup",
|
||
"xquery": "markup"
|
||
}
|
||
);
|
||
var lang_aliases = (
|
||
/*aliases_placeholder[*/
|
||
{
|
||
"html": "markup",
|
||
"xml": "markup",
|
||
"svg": "markup",
|
||
"mathml": "markup",
|
||
"ssml": "markup",
|
||
"atom": "markup",
|
||
"rss": "markup",
|
||
"js": "javascript",
|
||
"g4": "antlr4",
|
||
"ino": "arduino",
|
||
"arm-asm": "armasm",
|
||
"art": "arturo",
|
||
"adoc": "asciidoc",
|
||
"avs": "avisynth",
|
||
"avdl": "avro-idl",
|
||
"gawk": "awk",
|
||
"sh": "bash",
|
||
"shell": "bash",
|
||
"shortcode": "bbcode",
|
||
"rbnf": "bnf",
|
||
"oscript": "bsl",
|
||
"cs": "csharp",
|
||
"dotnet": "csharp",
|
||
"cfc": "cfscript",
|
||
"cilk-c": "cilkc",
|
||
"cilk-cpp": "cilkcpp",
|
||
"cilk": "cilkcpp",
|
||
"coffee": "coffeescript",
|
||
"conc": "concurnas",
|
||
"jinja2": "django",
|
||
"dns-zone": "dns-zone-file",
|
||
"dockerfile": "docker",
|
||
"gv": "dot",
|
||
"eta": "ejs",
|
||
"xlsx": "excel-formula",
|
||
"xls": "excel-formula",
|
||
"gamemakerlanguage": "gml",
|
||
"po": "gettext",
|
||
"gni": "gn",
|
||
"ld": "linker-script",
|
||
"go-mod": "go-module",
|
||
"hbs": "handlebars",
|
||
"mustache": "handlebars",
|
||
"hs": "haskell",
|
||
"idr": "idris",
|
||
"gitignore": "ignore",
|
||
"hgignore": "ignore",
|
||
"npmignore": "ignore",
|
||
"webmanifest": "json",
|
||
"kt": "kotlin",
|
||
"kts": "kotlin",
|
||
"kum": "kumir",
|
||
"tex": "latex",
|
||
"context": "latex",
|
||
"ly": "lilypond",
|
||
"emacs": "lisp",
|
||
"elisp": "lisp",
|
||
"emacs-lisp": "lisp",
|
||
"md": "markdown",
|
||
"moon": "moonscript",
|
||
"n4jsd": "n4js",
|
||
"nani": "naniscript",
|
||
"objc": "objectivec",
|
||
"qasm": "openqasm",
|
||
"objectpascal": "pascal",
|
||
"px": "pcaxis",
|
||
"pcode": "peoplecode",
|
||
"plantuml": "plant-uml",
|
||
"pq": "powerquery",
|
||
"mscript": "powerquery",
|
||
"pbfasm": "purebasic",
|
||
"purs": "purescript",
|
||
"py": "python",
|
||
"qs": "qsharp",
|
||
"rkt": "racket",
|
||
"razor": "cshtml",
|
||
"rpy": "renpy",
|
||
"res": "rescript",
|
||
"robot": "robotframework",
|
||
"rb": "ruby",
|
||
"sh-session": "shell-session",
|
||
"shellsession": "shell-session",
|
||
"smlnj": "sml",
|
||
"sol": "solidity",
|
||
"sln": "solution-file",
|
||
"rq": "sparql",
|
||
"sclang": "supercollider",
|
||
"t4": "t4-cs",
|
||
"trickle": "tremor",
|
||
"troy": "tremor",
|
||
"trig": "turtle",
|
||
"ts": "typescript",
|
||
"tsconfig": "typoscript",
|
||
"uscript": "unrealscript",
|
||
"uc": "unrealscript",
|
||
"url": "uri",
|
||
"vb": "visual-basic",
|
||
"vba": "visual-basic",
|
||
"webidl": "web-idl",
|
||
"mathematica": "wolfram",
|
||
"nb": "wolfram",
|
||
"wl": "wolfram",
|
||
"xeoracube": "xeora",
|
||
"yml": "yaml"
|
||
}
|
||
);
|
||
var lang_data = {};
|
||
var ignored_language = "none";
|
||
var languages_path = stdin_default.langPath;
|
||
var script = Prism.util.currentScript();
|
||
if (script) {
|
||
var autoloaderFile = /\bplugins\/autoloader\/prism-autoloader\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i;
|
||
var prismFile = /(^|\/)[\w-]+\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i;
|
||
var autoloaderPath = script.getAttribute("data-autoloader-path");
|
||
if (autoloaderPath != null) {
|
||
languages_path = autoloaderPath.trim().replace(/\/?$/, "/");
|
||
} else {
|
||
var src = script.src;
|
||
if (autoloaderFile.test(src)) {
|
||
languages_path = src.replace(autoloaderFile, "components/");
|
||
} else if (prismFile.test(src)) {
|
||
languages_path = src.replace(prismFile, "$1components/");
|
||
}
|
||
}
|
||
}
|
||
var config = Prism.plugins.autoloader = {
|
||
languages_path,
|
||
use_minified: true,
|
||
loadLanguages
|
||
};
|
||
function addScript(src2, success, error) {
|
||
var s = document.createElement("script");
|
||
s.src = src2;
|
||
s.async = true;
|
||
s.onload = function() {
|
||
document.body.removeChild(s);
|
||
success && success();
|
||
};
|
||
s.onerror = function() {
|
||
document.body.removeChild(s);
|
||
error && error();
|
||
};
|
||
document.body.appendChild(s);
|
||
}
|
||
function getDependencies(element) {
|
||
var deps = (element.getAttribute("data-dependencies") || "").trim();
|
||
if (!deps) {
|
||
var parent = element.parentElement;
|
||
if (parent && parent.tagName.toLowerCase() === "pre") {
|
||
deps = (parent.getAttribute("data-dependencies") || "").trim();
|
||
}
|
||
}
|
||
return deps ? deps.split(/\s*,\s*/g) : [];
|
||
}
|
||
function isLoaded(lang) {
|
||
if (lang.indexOf("!") >= 0) {
|
||
return false;
|
||
}
|
||
lang = lang_aliases[lang] || lang;
|
||
if (lang in Prism.languages) {
|
||
return true;
|
||
}
|
||
var data = lang_data[lang];
|
||
return data && !data.error && data.loading === false;
|
||
}
|
||
function getLanguagePath(lang) {
|
||
return config.languages_path + "prism-" + lang + (config.use_minified ? ".min" : "") + ".js";
|
||
}
|
||
function loadLanguages(languages, success, error) {
|
||
if (typeof languages === "string") {
|
||
languages = [languages];
|
||
}
|
||
var total = languages.length;
|
||
var completed = 0;
|
||
var failed = false;
|
||
if (total === 0) {
|
||
if (success) {
|
||
setTimeout(success, 0);
|
||
}
|
||
return;
|
||
}
|
||
function successCallback() {
|
||
if (failed) {
|
||
return;
|
||
}
|
||
completed++;
|
||
if (completed === total) {
|
||
success && success(languages);
|
||
}
|
||
}
|
||
languages.forEach(function(lang) {
|
||
loadLanguage(lang, successCallback, function() {
|
||
if (failed) {
|
||
return;
|
||
}
|
||
failed = true;
|
||
error && error(lang);
|
||
});
|
||
});
|
||
}
|
||
function loadLanguage(lang, success, error) {
|
||
var force = lang.indexOf("!") >= 0;
|
||
lang = lang.replace("!", "");
|
||
lang = lang_aliases[lang] || lang;
|
||
function load() {
|
||
var data = lang_data[lang];
|
||
if (!data) {
|
||
data = lang_data[lang] = {
|
||
callbacks: []
|
||
};
|
||
}
|
||
data.callbacks.push({
|
||
success,
|
||
error
|
||
});
|
||
if (!force && isLoaded(lang)) {
|
||
languageCallback(lang, "success");
|
||
} else if (!force && data.error) {
|
||
languageCallback(lang, "error");
|
||
} else if (force || !data.loading) {
|
||
data.loading = true;
|
||
data.error = false;
|
||
addScript(getLanguagePath(lang), function() {
|
||
data.loading = false;
|
||
languageCallback(lang, "success");
|
||
}, function() {
|
||
data.loading = false;
|
||
data.error = true;
|
||
languageCallback(lang, "error");
|
||
});
|
||
}
|
||
}
|
||
var dependencies = lang_dependencies[lang];
|
||
if (dependencies && dependencies.length) {
|
||
loadLanguages(dependencies, load, error);
|
||
} else {
|
||
load();
|
||
}
|
||
}
|
||
function languageCallback(lang, type) {
|
||
if (lang_data[lang]) {
|
||
var callbacks = lang_data[lang].callbacks;
|
||
for (var i = 0, l = callbacks.length; i < l; i++) {
|
||
var callback = callbacks[i][type];
|
||
if (callback) {
|
||
setTimeout(callback, 0);
|
||
}
|
||
}
|
||
callbacks.length = 0;
|
||
}
|
||
}
|
||
Prism.hooks.add("complete", function(env) {
|
||
var element = env.element;
|
||
var language = env.language;
|
||
if (!element || !language || language === ignored_language) {
|
||
return;
|
||
}
|
||
var deps = getDependencies(element);
|
||
if (/^diff-./i.test(language)) {
|
||
deps.push("diff");
|
||
deps.push(language.substr("diff-".length));
|
||
} else {
|
||
deps.push(language);
|
||
}
|
||
if (!deps.every(isLoaded)) {
|
||
loadLanguages(deps, function() {
|
||
Prism.highlightElement(element);
|
||
});
|
||
}
|
||
});
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined") {
|
||
return;
|
||
}
|
||
var assign = Object.assign || function(obj1, obj2) {
|
||
for (var name in obj2) {
|
||
if (obj2.hasOwnProperty(name)) {
|
||
obj1[name] = obj2[name];
|
||
}
|
||
}
|
||
return obj1;
|
||
};
|
||
function NormalizeWhitespace(defaults) {
|
||
this.defaults = assign({}, defaults);
|
||
}
|
||
function toCamelCase(value) {
|
||
return value.replace(/-(\w)/g, function(match, firstChar) {
|
||
return firstChar.toUpperCase();
|
||
});
|
||
}
|
||
function tabLen(str) {
|
||
var res = 0;
|
||
for (var i = 0; i < str.length; ++i) {
|
||
if (str.charCodeAt(i) == " ".charCodeAt(0)) {
|
||
res += 3;
|
||
}
|
||
}
|
||
return str.length + res;
|
||
}
|
||
var settingsConfig = {
|
||
"remove-trailing": "boolean",
|
||
"remove-indent": "boolean",
|
||
"left-trim": "boolean",
|
||
"right-trim": "boolean",
|
||
"break-lines": "number",
|
||
"indent": "number",
|
||
"remove-initial-line-feed": "boolean",
|
||
"tabs-to-spaces": "number",
|
||
"spaces-to-tabs": "number"
|
||
};
|
||
NormalizeWhitespace.prototype = {
|
||
setDefaults: function(defaults) {
|
||
this.defaults = assign(this.defaults, defaults);
|
||
},
|
||
normalize: function(input, settings) {
|
||
settings = assign(this.defaults, settings);
|
||
for (var name in settings) {
|
||
var methodName = toCamelCase(name);
|
||
if (name !== "normalize" && methodName !== "setDefaults" && settings[name] && this[methodName]) {
|
||
input = this[methodName].call(this, input, settings[name]);
|
||
}
|
||
}
|
||
return input;
|
||
},
|
||
/*
|
||
* Normalization methods
|
||
*/
|
||
leftTrim: function(input) {
|
||
return input.replace(/^\s+/, "");
|
||
},
|
||
rightTrim: function(input) {
|
||
return input.replace(/\s+$/, "");
|
||
},
|
||
tabsToSpaces: function(input, spaces) {
|
||
spaces = spaces | 0 || 4;
|
||
return input.replace(/\t/g, new Array(++spaces).join(" "));
|
||
},
|
||
spacesToTabs: function(input, spaces) {
|
||
spaces = spaces | 0 || 4;
|
||
return input.replace(RegExp(" {" + spaces + "}", "g"), " ");
|
||
},
|
||
removeTrailing: function(input) {
|
||
return input.replace(/\s*?$/gm, "");
|
||
},
|
||
// Support for deprecated plugin remove-initial-line-feed
|
||
removeInitialLineFeed: function(input) {
|
||
return input.replace(/^(?:\r?\n|\r)/, "");
|
||
},
|
||
removeIndent: function(input) {
|
||
var indents = input.match(/^[^\S\n\r]*(?=\S)/gm);
|
||
if (!indents || !indents[0].length) {
|
||
return input;
|
||
}
|
||
indents.sort(function(a, b) {
|
||
return a.length - b.length;
|
||
});
|
||
if (!indents[0].length) {
|
||
return input;
|
||
}
|
||
return input.replace(RegExp("^" + indents[0], "gm"), "");
|
||
},
|
||
indent: function(input, tabs) {
|
||
return input.replace(/^[^\S\n\r]*(?=\S)/gm, new Array(++tabs).join(" ") + "$&");
|
||
},
|
||
breakLines: function(input, characters) {
|
||
characters = characters === true ? 80 : characters | 0 || 80;
|
||
var lines = input.split("\n");
|
||
for (var i = 0; i < lines.length; ++i) {
|
||
if (tabLen(lines[i]) <= characters) {
|
||
continue;
|
||
}
|
||
var line = lines[i].split(/(\s+)/g);
|
||
var len = 0;
|
||
for (var j = 0; j < line.length; ++j) {
|
||
var tl = tabLen(line[j]);
|
||
len += tl;
|
||
if (len > characters) {
|
||
line[j] = "\n" + line[j];
|
||
len = tl;
|
||
}
|
||
}
|
||
lines[i] = line.join("");
|
||
}
|
||
return lines.join("\n");
|
||
}
|
||
};
|
||
if (typeof module !== "undefined" && module.exports) {
|
||
module.exports = NormalizeWhitespace;
|
||
}
|
||
Prism.plugins.NormalizeWhitespace = new NormalizeWhitespace({
|
||
"remove-trailing": true,
|
||
"remove-indent": true,
|
||
"left-trim": true,
|
||
"right-trim": true
|
||
/*'break-lines': 80,
|
||
'indent': 2,
|
||
'remove-initial-line-feed': false,
|
||
'tabs-to-spaces': 4,
|
||
'spaces-to-tabs': 4*/
|
||
});
|
||
Prism.hooks.add("before-sanity-check", function(env) {
|
||
var Normalizer = Prism.plugins.NormalizeWhitespace;
|
||
if (env.settings && env.settings["whitespace-normalization"] === false) {
|
||
return;
|
||
}
|
||
if (!Prism.util.isActive(env.element, "whitespace-normalization", true)) {
|
||
return;
|
||
}
|
||
if ((!env.element || !env.element.parentNode) && env.code) {
|
||
env.code = Normalizer.normalize(env.code, env.settings);
|
||
return;
|
||
}
|
||
var pre = env.element.parentNode;
|
||
if (!env.code || !pre || pre.nodeName.toLowerCase() !== "pre") {
|
||
return;
|
||
}
|
||
if (env.settings == null) {
|
||
env.settings = {};
|
||
}
|
||
for (var key in settingsConfig) {
|
||
if (Object.hasOwnProperty.call(settingsConfig, key)) {
|
||
var settingType = settingsConfig[key];
|
||
if (pre.hasAttribute("data-" + key)) {
|
||
try {
|
||
var value = JSON.parse(pre.getAttribute("data-" + key) || "true");
|
||
if (typeof value === settingType) {
|
||
env.settings[key] = value;
|
||
}
|
||
} catch (_error) {
|
||
}
|
||
}
|
||
}
|
||
}
|
||
var children = pre.childNodes;
|
||
var before = "";
|
||
var after = "";
|
||
var codeFound = false;
|
||
for (var i = 0; i < children.length; ++i) {
|
||
var node = children[i];
|
||
if (node == env.element) {
|
||
codeFound = true;
|
||
} else if (node.nodeName === "#text") {
|
||
if (codeFound) {
|
||
after += node.nodeValue;
|
||
} else {
|
||
before += node.nodeValue;
|
||
}
|
||
pre.removeChild(node);
|
||
--i;
|
||
}
|
||
}
|
||
if (!env.element.children.length || !Prism.plugins.KeepMarkup) {
|
||
env.code = before + env.code + after;
|
||
env.code = Normalizer.normalize(env.code, env.settings);
|
||
} else {
|
||
var html = before + env.element.innerHTML + after;
|
||
env.element.innerHTML = Normalizer.normalize(html, env.settings);
|
||
env.code = env.element.textContent;
|
||
}
|
||
});
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined") {
|
||
return;
|
||
}
|
||
var callbacks = [];
|
||
var map = {};
|
||
var noop = function() {
|
||
};
|
||
Prism.plugins.toolbar = {};
|
||
var registerButton = Prism.plugins.toolbar.registerButton = function(key, opts) {
|
||
var callback;
|
||
if (typeof opts === "function") {
|
||
callback = opts;
|
||
} else {
|
||
callback = function(env) {
|
||
var element;
|
||
if (typeof opts.onClick === "function") {
|
||
element = document.createElement("button");
|
||
element.type = "button";
|
||
element.addEventListener("click", function() {
|
||
opts.onClick.call(this, env);
|
||
});
|
||
} else if (typeof opts.url === "string") {
|
||
element = document.createElement("a");
|
||
element.href = opts.url;
|
||
} else {
|
||
element = document.createElement("span");
|
||
}
|
||
if (opts.className) {
|
||
element.classList.add(opts.className);
|
||
}
|
||
element.textContent = opts.text;
|
||
return element;
|
||
};
|
||
}
|
||
if (key in map) {
|
||
console.warn('There is a button with the key "' + key + '" registered already.');
|
||
return;
|
||
}
|
||
callbacks.push(map[key] = callback);
|
||
};
|
||
function getOrder(element) {
|
||
while (element) {
|
||
var order = element.getAttribute("data-toolbar-order");
|
||
if (order != null) {
|
||
order = order.trim();
|
||
if (order.length) {
|
||
return order.split(/\s*,\s*/g);
|
||
} else {
|
||
return [];
|
||
}
|
||
}
|
||
element = element.parentElement;
|
||
}
|
||
}
|
||
var hook = Prism.plugins.toolbar.hook = function(env) {
|
||
var pre = env.element.parentNode;
|
||
if (!pre || !/pre/i.test(pre.nodeName)) {
|
||
return;
|
||
}
|
||
if (pre.parentNode.classList.contains("code-toolbar")) {
|
||
return;
|
||
}
|
||
var wrapper = document.createElement("div");
|
||
wrapper.classList.add("code-toolbar");
|
||
pre.parentNode.insertBefore(wrapper, pre);
|
||
wrapper.appendChild(pre);
|
||
var toolbar = document.createElement("div");
|
||
toolbar.classList.add("toolbar");
|
||
var elementCallbacks = callbacks;
|
||
var order = getOrder(env.element);
|
||
if (order) {
|
||
elementCallbacks = order.map(function(key) {
|
||
return map[key] || noop;
|
||
});
|
||
}
|
||
elementCallbacks.forEach(function(callback) {
|
||
var element = callback(env);
|
||
if (!element) {
|
||
return;
|
||
}
|
||
var item = document.createElement("div");
|
||
item.classList.add("toolbar-item");
|
||
item.appendChild(element);
|
||
toolbar.appendChild(item);
|
||
});
|
||
wrapper.appendChild(toolbar);
|
||
};
|
||
registerButton("label", function(env) {
|
||
var pre = env.element.parentNode;
|
||
if (!pre || !/pre/i.test(pre.nodeName)) {
|
||
return;
|
||
}
|
||
if (!pre.hasAttribute("data-label")) {
|
||
return;
|
||
}
|
||
var element;
|
||
var template;
|
||
var text = pre.getAttribute("data-label");
|
||
try {
|
||
template = document.querySelector("template#" + text);
|
||
} catch (e) {
|
||
}
|
||
if (template) {
|
||
element = template.content;
|
||
} else {
|
||
if (pre.hasAttribute("data-url")) {
|
||
element = document.createElement("a");
|
||
element.href = pre.getAttribute("data-url");
|
||
} else {
|
||
element = document.createElement("span");
|
||
}
|
||
element.textContent = text;
|
||
}
|
||
return element;
|
||
});
|
||
Prism.hooks.add("complete", hook);
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined" || typeof document === "undefined") {
|
||
return;
|
||
}
|
||
if (!Prism.plugins.toolbar) {
|
||
console.warn("Copy to Clipboard plugin loaded before Toolbar plugin.");
|
||
return;
|
||
}
|
||
function registerClipboard(element, copyInfo) {
|
||
element.addEventListener("click", function() {
|
||
copyTextToClipboard(copyInfo);
|
||
});
|
||
}
|
||
function fallbackCopyTextToClipboard(copyInfo) {
|
||
var textArea = document.createElement("textarea");
|
||
textArea.value = copyInfo.getText();
|
||
textArea.style.top = "0";
|
||
textArea.style.left = "0";
|
||
textArea.style.position = "fixed";
|
||
document.body.appendChild(textArea);
|
||
textArea.focus();
|
||
textArea.select();
|
||
try {
|
||
var successful = document.execCommand("copy");
|
||
setTimeout(function() {
|
||
if (successful) {
|
||
copyInfo.success();
|
||
} else {
|
||
copyInfo.error();
|
||
}
|
||
}, 1);
|
||
} catch (err) {
|
||
setTimeout(function() {
|
||
copyInfo.error(err);
|
||
}, 1);
|
||
}
|
||
document.body.removeChild(textArea);
|
||
}
|
||
function copyTextToClipboard(copyInfo) {
|
||
if (navigator.clipboard) {
|
||
navigator.clipboard.writeText(copyInfo.getText()).then(copyInfo.success, function() {
|
||
fallbackCopyTextToClipboard(copyInfo);
|
||
});
|
||
} else {
|
||
fallbackCopyTextToClipboard(copyInfo);
|
||
}
|
||
}
|
||
function selectElementText(element) {
|
||
window.getSelection().selectAllChildren(element);
|
||
}
|
||
function getSettings(startElement) {
|
||
var settings = {
|
||
"copy": "Copy",
|
||
"copy-error": "Press Ctrl+C to copy",
|
||
"copy-success": "Copied!",
|
||
"copy-timeout": 5e3
|
||
};
|
||
var prefix = "data-prismjs-";
|
||
for (var key in settings) {
|
||
var attr = prefix + key;
|
||
var element = startElement;
|
||
while (element && !element.hasAttribute(attr)) {
|
||
element = element.parentElement;
|
||
}
|
||
if (element) {
|
||
settings[key] = element.getAttribute(attr);
|
||
}
|
||
}
|
||
return settings;
|
||
}
|
||
Prism.plugins.toolbar.registerButton("copy-to-clipboard", function(env) {
|
||
var element = env.element;
|
||
var settings = getSettings(element);
|
||
var linkCopy = document.createElement("button");
|
||
linkCopy.className = "copy-to-clipboard-button";
|
||
linkCopy.setAttribute("type", "button");
|
||
linkCopy.setAttribute("aria-label", "copy");
|
||
var linkSpan = document.createElement("span");
|
||
linkCopy.appendChild(linkSpan);
|
||
setState("copy");
|
||
registerClipboard(linkCopy, {
|
||
getText: function() {
|
||
return element.textContent;
|
||
},
|
||
success: function() {
|
||
setState("copy-success");
|
||
resetText();
|
||
},
|
||
error: function() {
|
||
setState("copy-error");
|
||
setTimeout(function() {
|
||
selectElementText(element);
|
||
}, 1);
|
||
resetText();
|
||
}
|
||
});
|
||
return linkCopy;
|
||
function resetText() {
|
||
setTimeout(function() {
|
||
setState("copy");
|
||
}, settings["copy-timeout"]);
|
||
}
|
||
function setState(state) {
|
||
linkSpan.textContent = settings[state];
|
||
linkCopy.setAttribute("data-copy-state", state);
|
||
}
|
||
});
|
||
})();
|
||
(function() {
|
||
if (typeof Prism === "undefined") {
|
||
return;
|
||
}
|
||
Prism.languages.treeview = {
|
||
"treeview-part": {
|
||
pattern: /^.+/m,
|
||
inside: {
|
||
"entry-line": [
|
||
{
|
||
pattern: /\|-- |├── /,
|
||
alias: "line-h"
|
||
},
|
||
{
|
||
pattern: /\| {3}|│ {3}/,
|
||
alias: "line-v"
|
||
},
|
||
{
|
||
pattern: /`-- |└── /,
|
||
alias: "line-v-last"
|
||
},
|
||
{
|
||
pattern: / {4}/,
|
||
alias: "line-v-gap"
|
||
}
|
||
],
|
||
"entry-name": {
|
||
pattern: /.*\S.*/,
|
||
inside: {
|
||
// symlink
|
||
"operator": / -> /
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
Prism.hooks.add("wrap", function(env) {
|
||
if (env.language === "treeview" && env.type === "entry-name") {
|
||
var classes = env.classes;
|
||
var folderPattern = /(^|[^\\])\/\s*$/;
|
||
if (folderPattern.test(env.content)) {
|
||
env.content = env.content.replace(folderPattern, "$1");
|
||
classes.push("dir");
|
||
} else {
|
||
env.content = env.content.replace(/(^|[^\\])[=*|]\s*$/, "$1");
|
||
var parts = env.content.toLowerCase().replace(/\s+/g, "").split(".");
|
||
while (parts.length > 1) {
|
||
parts.shift();
|
||
classes.push("ext-" + parts.join("-"));
|
||
}
|
||
}
|
||
if (env.content[0] === ".") {
|
||
classes.push("dotfile");
|
||
}
|
||
}
|
||
});
|
||
})();
|
||
}
|
||
});
|
||
require_stdin();
|
||
})();
|
||
/**
|
||
* Prism: Lightweight, robust, elegant syntax highlighting
|
||
*
|
||
* @license MIT <https://opensource.org/licenses/MIT>
|
||
* @author Lea Verou <https://lea.verou.me>
|
||
* @namespace
|
||
* @public
|
||
*/
|