A Pen by Zach Miller on CodePen.
Created
January 17, 2022 07:15
-
-
Save uhlhosting/a3113efac5dee215d2e695b334b4c18e to your computer and use it in GitHub Desktop.
WordPress Snippet Template
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<h1>Title/explanation of Snippet here</h1> | |
<pre class="line-numbers"><code class="language-php"> | |
</code></pre> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Prism: Lightweight, robust, elegant syntax highlighting | |
* MIT license https://www.opensource.org/licenses/mit-license.php/ | |
* @author Lea Verou http://lea.verou.me | |
*/ | |
(function(){ | |
// Private helper vars | |
var lang = /\blang(?:uage)?-(?!\*)(\w+)\b/i; | |
var _ = self.Prism = { | |
util: { | |
type: function (o) { | |
return Object.prototype.toString.call(o).match(/\[object (\w+)\]/)[1]; | |
}, | |
// Deep clone a language definition (e.g. to extend it) | |
clone: function (o) { | |
var type = _.util.type(o); | |
switch (type) { | |
case 'Object': | |
var clone = {}; | |
for (var key in o) { | |
if (o.hasOwnProperty(key)) { | |
clone[key] = _.util.clone(o[key]); | |
} | |
} | |
return clone; | |
case 'Array': | |
return o.slice(); | |
} | |
return o; | |
} | |
}, | |
languages: { | |
extend: function (id, redef) { | |
var lang = _.util.clone(_.languages[id]); | |
for (var key in redef) { | |
lang[key] = redef[key]; | |
} | |
return lang; | |
}, | |
// Insert a token before another token in a language literal | |
insertBefore: function (inside, before, insert, root) { | |
root = root || _.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]; | |
} | |
} | |
} | |
ret[token] = grammar[token]; | |
} | |
} | |
return root[inside] = ret; | |
}, | |
// Traverse a language definition with Depth First Search | |
DFS: function(o, callback) { | |
for (var i in o) { | |
callback.call(o, i, o[i]); | |
if (_.util.type(o) === 'Object') { | |
_.languages.DFS(o[i], callback); | |
} | |
} | |
} | |
}, | |
highlightAll: function(async, callback) { | |
var elements = document.querySelectorAll('code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'); | |
for (var i=0, element; element = elements[i++];) { | |
_.highlightElement(element, async === true, callback); | |
} | |
}, | |
highlightElement: function(element, async, callback) { | |
// Find language | |
var language, grammar, parent = element; | |
while (parent && !lang.test(parent.className)) { | |
parent = parent.parentNode; | |
} | |
if (parent) { | |
language = (parent.className.match(lang) || [,''])[1]; | |
grammar = _.languages[language]; | |
} | |
if (!grammar) { | |
return; | |
} | |
// Set language on the element, if not present | |
element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language; | |
// Set language on the parent, for styling | |
parent = element.parentNode; | |
if (/pre/i.test(parent.nodeName)) { | |
parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language; | |
} | |
var code = element.textContent; | |
if(!code) { | |
return; | |
} | |
code = code.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g, ' '); | |
var env = { | |
element: element, | |
language: language, | |
grammar: grammar, | |
code: code | |
}; | |
_.hooks.run('before-highlight', env); | |
if (async && self.Worker) { | |
var worker = new Worker(_.filename); | |
worker.onmessage = function(evt) { | |
env.highlightedCode = Token.stringify(JSON.parse(evt.data), language); | |
_.hooks.run('before-insert', env); | |
env.element.innerHTML = env.highlightedCode; | |
callback && callback.call(env.element); | |
_.hooks.run('after-highlight', env); | |
}; | |
worker.postMessage(JSON.stringify({ | |
language: env.language, | |
code: env.code | |
})); | |
} | |
else { | |
env.highlightedCode = _.highlight(env.code, env.grammar, env.language) | |
_.hooks.run('before-insert', env); | |
env.element.innerHTML = env.highlightedCode; | |
callback && callback.call(element); | |
_.hooks.run('after-highlight', env); | |
} | |
}, | |
highlight: function (text, grammar, language) { | |
return Token.stringify(_.tokenize(text, grammar), language); | |
}, | |
tokenize: function(text, grammar, language) { | |
var Token = _.Token; | |
var strarr = [text]; | |
var rest = grammar.rest; | |
if (rest) { | |
for (var token in rest) { | |
grammar[token] = rest[token]; | |
} | |
delete grammar.rest; | |
} | |
tokenloop: for (var token in grammar) { | |
if(!grammar.hasOwnProperty(token) || !grammar[token]) { | |
continue; | |
} | |
var pattern = grammar[token], | |
inside = pattern.inside, | |
lookbehind = !!pattern.lookbehind, | |
lookbehindLength = 0; | |
pattern = pattern.pattern || pattern; | |
for (var i=0; i<strarr.length; i++) { // Don’t cache length as it changes during the loop | |
var str = strarr[i]; | |
if (strarr.length > text.length) { | |
// Something went terribly wrong, ABORT, ABORT! | |
break tokenloop; | |
} | |
if (str instanceof Token) { | |
continue; | |
} | |
pattern.lastIndex = 0; | |
var match = pattern.exec(str); | |
if (match) { | |
if(lookbehind) { | |
lookbehindLength = match[1].length; | |
} | |
var from = match.index - 1 + lookbehindLength, | |
match = match[0].slice(lookbehindLength), | |
len = match.length, | |
to = from + len, | |
before = str.slice(0, from + 1), | |
after = str.slice(to + 1); | |
var args = [i, 1]; | |
if (before) { | |
args.push(before); | |
} | |
var wrapped = new Token(token, inside? _.tokenize(match, inside) : match); | |
args.push(wrapped); | |
if (after) { | |
args.push(after); | |
} | |
Array.prototype.splice.apply(strarr, args); | |
} | |
} | |
} | |
return strarr; | |
}, | |
hooks: { | |
all: {}, | |
add: function (name, callback) { | |
var hooks = _.hooks.all; | |
hooks[name] = hooks[name] || []; | |
hooks[name].push(callback); | |
}, | |
run: function (name, env) { | |
var callbacks = _.hooks.all[name]; | |
if (!callbacks || !callbacks.length) { | |
return; | |
} | |
for (var i=0, callback; callback = callbacks[i++];) { | |
callback(env); | |
} | |
} | |
} | |
}; | |
var Token = _.Token = function(type, content) { | |
this.type = type; | |
this.content = content; | |
}; | |
Token.stringify = function(o, language, parent) { | |
if (typeof o == 'string') { | |
return o; | |
} | |
if (Object.prototype.toString.call(o) == '[object Array]') { | |
return o.map(function(element) { | |
return Token.stringify(element, language, o); | |
}).join(''); | |
} | |
var env = { | |
type: o.type, | |
content: Token.stringify(o.content, language, parent), | |
tag: 'span', | |
classes: ['token', o.type], | |
attributes: {}, | |
language: language, | |
parent: parent | |
}; | |
if (env.type == 'comment') { | |
env.attributes['spellcheck'] = 'true'; | |
} | |
_.hooks.run('wrap', env); | |
var attributes = ''; | |
for (var name in env.attributes) { | |
attributes += name + '="' + (env.attributes[name] || '') + '"'; | |
} | |
return '<' + env.tag + ' class="' + env.classes.join(' ') + '" ' + attributes + '>' + env.content + '</' + env.tag + '>'; | |
}; | |
if (!self.document) { | |
// In worker | |
self.addEventListener('message', function(evt) { | |
var message = JSON.parse(evt.data), | |
lang = message.language, | |
code = message.code; | |
self.postMessage(JSON.stringify(_.tokenize(code, _.languages[lang]))); | |
self.close(); | |
}, false); | |
return; | |
} | |
// Get current script and highlight | |
var script = document.getElementsByTagName('script'); | |
script = script[script.length - 1]; | |
if (script) { | |
_.filename = script.src; | |
if (document.addEventListener && !script.hasAttribute('data-manual')) { | |
document.addEventListener('DOMContentLoaded', _.highlightAll); | |
} | |
} | |
})();; | |
Prism.languages.markup = { | |
'comment': /<!--[\w\W]*?-->/g, | |
'prolog': /<\?.+?\?>/, | |
'doctype': /<!DOCTYPE.+?>/, | |
'cdata': /<!\[CDATA\[[\w\W]*?]]>/i, | |
'tag': { | |
pattern: /<\/?[\w:-]+\s*(?:\s+[\w:-]+(?:=(?:("|')(\\?[\w\W])*?\1|\w+))?\s*)*\/?>/gi, | |
inside: { | |
'tag': { | |
pattern: /^<\/?[\w:-]+/i, | |
inside: { | |
'punctuation': /^<\/?/, | |
'namespace': /^[\w-]+?:/ | |
} | |
}, | |
'attr-value': { | |
pattern: /=(?:('|")[\w\W]*?(\1)|[^\s>]+)/gi, | |
inside: { | |
'punctuation': /=|>|"/g | |
} | |
}, | |
'punctuation': /\/?>/g, | |
'attr-name': { | |
pattern: /[\w:-]+/g, | |
inside: { | |
'namespace': /^[\w-]+?:/ | |
} | |
} | |
} | |
}, | |
'entity': /&#?[\da-z]{1,8};/gi | |
}; | |
// Plugin to make entity title show the real entity, idea by Roman Komarov | |
Prism.hooks.add('wrap', function(env) { | |
if (env.type === 'entity') { | |
env.attributes['title'] = env.content.replace(/&/, '&'); | |
} | |
});; | |
Prism.languages.clike = { | |
'comment': { | |
pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|(^|[^:])\/\/.*?(\r?\n|$))/g, | |
lookbehind: true | |
}, | |
'string': /("|')(\\?.)*?\1/g, | |
'class-name': { | |
pattern: /((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/ig, | |
lookbehind: true, | |
inside: { | |
punctuation: /(\.|\\)/ | |
} | |
}, | |
'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|catch|finally|null|break|continue)\b/g, | |
'boolean': /\b(true|false)\b/g, | |
'function': { | |
pattern: /[a-z0-9_]+\(/ig, | |
inside: { | |
punctuation: /\(/ | |
} | |
}, | |
'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g, | |
'operator': /[-+]{1,2}|!|<=?|>=?|={1,3}|(&){1,2}|\|?\||\?|\*|\/|\~|\^|\%/g, | |
'ignore': /&(lt|gt|amp);/gi, | |
'punctuation': /[{}[\];(),.:]/g | |
};; | |
/** | |
* Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/ | |
* Modified by Miles Johnson: http://milesj.me | |
* | |
* Supports the following: | |
* - Extends clike syntax | |
* - Support for PHP 5.3 and 5.4 (namespaces, traits, etc) | |
* - Smarter constant and function matching | |
* | |
* Adds the following new token classes: | |
* constant, delimiter, variable, function, package | |
*/ | |
Prism.languages.php = Prism.languages.extend('clike', { | |
'keyword': /\b(and|or|xor|array|as|break|case|cfunction|class|const|continue|declare|default|die|do|else|elseif|enddeclare|endfor|endforeach|endif|endswitch|endwhile|extends|for|foreach|function|include|include_once|global|if|new|return|static|switch|use|require|require_once|var|while|abstract|interface|public|implements|extends|private|protected|parent|static|throw|null|echo|print|trait|namespace|use|final|yield|goto|instanceof|finally|try|catch)\b/ig, | |
'constant': /\b[A-Z0-9_]{2,}\b/g | |
}); | |
Prism.languages.insertBefore('php', 'keyword', { | |
'delimiter': /(\?>|<\?php|<\?)/ig, | |
'variable': /(\$\w+)\b/ig, | |
'package': { | |
pattern: /(\\|namespace\s+|use\s+)[\w\\]+/g, | |
lookbehind: true, | |
inside: { | |
punctuation: /\\/ | |
} | |
} | |
}); | |
// Must be defined after the function pattern | |
Prism.languages.insertBefore('php', 'operator', { | |
'property': { | |
pattern: /(->)[\w]+/g, | |
lookbehind: true | |
} | |
}); | |
// Add HTML support of the markup language exists | |
if (Prism.languages.markup) { | |
// Tokenize all inline PHP blocks that are wrapped in <?php ?> | |
// This allows for easy PHP + markup highlighting | |
Prism.hooks.add('before-highlight', function(env) { | |
if (env.language !== 'php') { | |
return; | |
} | |
env.tokenStack = []; | |
env.code = env.code.replace(/(?:<\?php|<\?|<\?php|<\?)[\w\W]*?(?:\?>|\?>)/ig, function(match) { | |
env.tokenStack.push(match); | |
return '{{{PHP' + env.tokenStack.length + '}}}'; | |
}); | |
}); | |
// Re-insert the tokens after highlighting | |
Prism.hooks.add('after-highlight', function(env) { | |
if (env.language !== 'php') { | |
return; | |
} | |
for (var i = 0, t; t = env.tokenStack[i]; i++) { | |
env.highlightedCode = env.highlightedCode.replace('{{{PHP' + (i + 1) + '}}}', Prism.highlight(t, env.grammar, 'php')); | |
} | |
env.element.innerHTML = env.highlightedCode; | |
}); | |
// Wrap tokens in classes that are missing them | |
Prism.hooks.add('wrap', function(env) { | |
if (env.language === 'php' && env.type === 'markup') { | |
env.content = env.content.replace(/(\{\{\{PHP[0-9]+\}\}\})/g, "<span class=\"token php\">$1</span>"); | |
} | |
}); | |
// Add the rules before all others | |
Prism.languages.insertBefore('php', 'comment', { | |
'markup': { | |
pattern: /(<|<)[^?]\/?(.*?)(>|>)/g, | |
inside: Prism.languages.markup | |
}, | |
'php': /\{\{\{PHP[0-9]+\}\}\}/g | |
}); | |
}; | |
Prism.hooks.add('after-highlight', function (env) { | |
// works only for <code> wrapped inside <pre data-line-numbers> (not inline) | |
var pre = env.element.parentNode; | |
if (!pre || !/pre/i.test(pre.nodeName) || pre.className.indexOf('line-numbers') === -1) { | |
return; | |
} | |
var linesNum = (1 + env.code.split('\n').length); | |
var lineNumbersWrapper; | |
lines = new Array(linesNum); | |
lines = lines.join('<span></span>'); | |
lineNumbersWrapper = document.createElement('span'); | |
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); | |
});; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
@import "compass/css3"; | |
@import url('https://fonts.googleapis.com/css?family=Roboto'); | |
body { | |
color: #000; | |
padding: 1.5rem; | |
margin: 0; | |
} | |
h1 { | |
font-family: "Roboto", sans-serif; | |
font-size: 1.7rem; | |
max-width: 700px; | |
margin: 0 auto; | |
} | |
.highlight { | |
font-family: monospace; | |
background-color: orange; | |
} | |
pre { | |
max-width: 700px; | |
// background-color: #333; | |
// margin: 0 auto; | |
} | |
/** | |
* prism.js Twilight theme | |
* Based (more or less) on the Twilight theme originally of Textmate fame. | |
* @author Remy Bach | |
*/ | |
code[class*="language-"], | |
pre[class*="language-"] { | |
color: white; | |
direction: ltr; | |
font-family: Consolas, Monaco, 'Andale Mono', monospace; | |
text-align: left; | |
text-shadow: 0 -.1em .2em black; | |
white-space: pre; | |
word-spacing: normal; | |
-moz-tab-size: 4; | |
-o-tab-size: 4; | |
tab-size: 4; | |
-webkit-hyphens: none; | |
-moz-hyphens: none; | |
-ms-hyphens: none; | |
hyphens: none; | |
} | |
pre[class*="language-"], | |
:not(pre) > code[class*="language-"] { | |
background:hsl(0, 0%, 8%); /* #141414 */ | |
} | |
/* Code blocks */ | |
pre[class*="language-"] { | |
// border-radius: .5em; | |
border: .1em solid hsl(0,0%,33%); /* #282A2B */ | |
box-shadow: 1px 1px .5em black inset; | |
// margin: .5em 0; | |
margin: 1.5rem auto 0; | |
overflow: auto; | |
padding: 1rem 1rem 1.8rem; | |
} | |
pre[class*="language-"]::selection { /* Safari */ | |
background:hsl(200, 4%, 16%); /* #282A2B */ | |
} | |
pre[class*="language-"]::selection { /* Firefox */ | |
background:hsl(200, 4%, 16%); /* #282A2B */ | |
} | |
/* Inline code */ | |
:not(pre) > code[class*="language-"] { | |
border-radius: .3em; | |
border: .13em solid hsl(0,0%,33%); /* #545454 */ | |
box-shadow: 1px 1px .3em -.1em black inset; | |
padding: .15em .2em .05em; | |
} | |
.token.comment, | |
.token.prolog, | |
.token.doctype, | |
.token.cdata { | |
color: hsl(0, 0%, 47%); /* #777777 */ | |
} | |
.token.punctuation { | |
opacity: .7; | |
} | |
.namespace { | |
opacity: .7; | |
} | |
.token.tag, | |
.token.boolean, | |
.token.number { | |
color: hsl(14, 58%, 55%); /* #CF6A4C */ | |
} | |
.token.keyword, | |
.token.property, | |
.token.selector { | |
color:hsl(53, 89%, 79%); /* #F9EE98 */ | |
} | |
.token.attr-name, | |
.token.attr-value, | |
.token.string, | |
.token.entity, | |
.token.url, | |
.language-css .token.string, | |
.style .token.string { | |
color:hsl(76, 21%, 52%); /* #8F9D6A */ | |
} | |
.token.operator { | |
color: palevioletred; | |
} | |
.token.atrule { | |
color:hsl(218, 22%, 55%); /* #7587A6 */ | |
} | |
.token.regex, | |
.token.important { | |
color: hsl(42, 75%, 65%); /* #E9C062 */ | |
} | |
.token.important { | |
font-weight: bold; | |
} | |
.token.entity { | |
cursor: help; | |
} | |
pre[data-line] { | |
padding: 1em 0 1em 3em; | |
position: relative; | |
} | |
/* Markup */ | |
.language-markup .token.tag, | |
.language-markup .token.attr-name, | |
.language-markup .token.punctuation { | |
color: hsl(33, 33%, 52%); /* #AC885B */ | |
} | |
/* Text Selection colour */ | |
::selection { | |
background: hsla(0,0%,93%,0.15); /* #EDEDED */ | |
} | |
::-moz-selection { | |
background: hsla(0,0%,93%,0.15); /* #EDEDED */ | |
} | |
/* Make the tokens sit above the line highlight so the colours don't look faded. */ | |
.token { | |
position:relative; | |
z-index:1; | |
} | |
.line-highlight { | |
background: -moz-linear-gradient(left, hsla(0, 0%, 33%,.1) 70%, hsla(0, 0%, 33%,0)); /* #545454 */ | |
background: -o-linear-gradient(left, hsla(0, 0%, 33%,.1) 70%, hsla(0, 0%, 33%,0)); /* #545454 */ | |
background: -webkit-linear-gradient(left, hsla(0, 0%, 33%,.1) 70%, hsla(0, 0%, 33%,0)); /* #545454 */ | |
background: hsla(0, 0%, 33%, 0.25); /* #545454 */ | |
background: linear-gradient(left, hsla(0, 0%, 33%,.1) 70%, hsla(0, 0%, 33%,0)); /* #545454 */ | |
border-bottom:1px dashed hsl(0, 0%, 33%); /* #545454 */ | |
border-top:1px dashed hsl(0, 0%, 33%); /* #545454 */ | |
left: 0; | |
line-height: inherit; | |
margin-top: 0.75em; /* Same as .prism’s padding-top */ | |
padding: inherit 0; | |
pointer-events: none; | |
position: absolute; | |
right: 0; | |
white-space: pre; | |
z-index:0; | |
} | |
.line-highlight:before, | |
.line-highlight[data-end]:after { | |
background-color: hsl(215, 15%, 59%); /* #8794A6 */ | |
border-radius: 999px; | |
box-shadow: 0 1px white; | |
color: hsl(24, 20%, 95%); /* #F5F2F0 */ | |
content: attr(data-start); | |
font: bold 65%/1.5 sans-serif; | |
left: .6em; | |
min-width: 1em; | |
padding: 0 .5em; | |
position: absolute; | |
text-align: center; | |
text-shadow: none; | |
top: .4em; | |
vertical-align: .3em; | |
} | |
.line-highlight[data-end]:after { | |
bottom: .4em; | |
content: attr(data-end); | |
top: auto; | |
} | |
pre.line-numbers { | |
position: relative; | |
padding-left: 3.8em; | |
counter-reset: linenumber; | |
} | |
pre.line-numbers > code { | |
position: relative; | |
} | |
.line-numbers .line-numbers-rows { | |
position: absolute; | |
pointer-events: none; | |
top: 0; | |
font-size: 100%; | |
left: -3.8em; | |
width: 3em; /* works for line-numbers below 1000 lines */ | |
letter-spacing: -1px; | |
border-right: 1px solid #999; | |
-webkit-user-select: none; | |
-moz-user-select: none; | |
-ms-user-select: none; | |
user-select: none; | |
} | |
.line-numbers-rows > span { | |
pointer-events: none; | |
display: block; | |
counter-increment: linenumber; | |
} | |
.line-numbers-rows > span:before { | |
content: counter(linenumber); | |
color: #999; | |
display: block; | |
padding-right: 0.8em; | |
text-align: right; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment