(function (Prism) {
/**
* @param {string} name
* @returns {RegExp}
*/
function headerValueOf(name) {
return RegExp('(^(?:' + name + '):[ \t]*(?![ \t]))[^]+', 'i');
}
Prism.languages.http = {
'request-line': {
pattern:
/^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m,
inside: {
// HTTP Method
method: {
pattern: /^[A-Z]+\b/,
alias: 'property',
},
// Request Target e.g. http://example.com, /path/to/file
'request-target': {
pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,
lookbehind: true,
alias: 'url',
inside: Prism.languages.uri,
},
// HTTP Version
'http-version': {
pattern: /^(\s)HTTP\/[\d.]+/,
lookbehind: true,
alias: 'property',
},
},
},
'response-status': {
pattern: /^HTTP\/[\d.]+ \d+ .+/m,
inside: {
// HTTP Version
'http-version': {
pattern: /^HTTP\/[\d.]+/,
alias: 'property',
},
// Status Code
'status-code': {
pattern: /^(\s)\d+(?=\s)/,
lookbehind: true,
alias: 'number',
},
// Reason Phrase
'reason-phrase': {
pattern: /^(\s).+/,
lookbehind: true,
alias: 'string',
},
},
},
header: {
pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,
inside: {
'header-value': [
{
pattern: headerValueOf(/Content-Security-Policy/.source),
lookbehind: true,
alias: ['csp', 'languages-csp'],
inside: Prism.languages.csp,
},
{
pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),
lookbehind: true,
alias: ['hpkp', 'languages-hpkp'],
inside: Prism.languages.hpkp,
},
{
pattern: headerValueOf(/Strict-Transport-Security/.source),
lookbehind: true,
alias: ['hsts', 'languages-hsts'],
inside: Prism.languages.hsts,
},
{
pattern: headerValueOf(/[^:]+/.source),
lookbehind: true,
},
],
'header-name': {
pattern: /^[^:]+/,
alias: 'keyword',
},
punctuation: /^:/,
},
},
};
// Create a mapping of Content-Type headers to language definitions
var langs = Prism.languages;
var httpLanguages = {
'application/javascript': langs.javascript,
'application/json': langs.json || langs.javascript,
'application/xml': langs.xml,
'text/xml': langs.xml,
'text/html': langs.html,
'text/css': langs.css,
'text/plain': langs.plain,
};
// Declare which types can also be suffixes
var suffixTypes = {
'application/json': true,
'application/xml': true,
};
/**
* Returns a pattern for the given content type which matches it and any type which has it as a suffix.
*
* @param {string} contentType
* @returns {string}
*/
function getSuffixPattern(contentType) {
var suffix = contentType.replace(/^[a-z]+\//, '');
var suffixPattern = '\\w+/(?:[\\w.-]+\\+)+' + suffix + '(?![+\\w.-])';
return '(?:' + contentType + '|' + suffixPattern + ')';
}
// Insert each content type parser that has its associated language
// currently loaded.
var options;
for (var contentType in httpLanguages) {
if (httpLanguages[contentType]) {
options = options || {};
var pattern = suffixTypes[contentType]
? getSuffixPattern(contentType)
: contentType;
options[contentType.replace(/\//g, '-')] = {
pattern: RegExp(
'(' +
/content-type:\s*/.source +
pattern +
/(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source +
')' +
// This is a little interesting:
// The HTTP format spec required 1 empty line before the body to make everything unambiguous.
// However, when writing code by hand (e.g. to display on a website) people can forget about this,
// so we want to be liberal here. We will allow the empty line to be omitted if the first line of
// the body does not start with a [\w-] character (as headers do).
/[^ \t\w-][\s\S]*/.source,
'i'
),
lookbehind: true,
inside: httpLanguages[contentType],
};
}
}
if (options) {
Prism.languages.insertBefore('http', 'header', options);
}
})(Prism);
1
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
(Prism.languages.uri = {
scheme: {
pattern: /^[a-z][a-z0-9+.-]*:/im,
greedy: !0,
inside: { 'scheme-delimiter': /:$/ },
},
fragment: {
pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
inside: { 'fragment-delimiter': /^#/ },
},
query: {
pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
inside: {
'query-delimiter': { pattern: /^\?/, greedy: !0 },
'pair-delimiter': /[&;]/,
pair: {
pattern: /^[^=][\s\S]*/,
inside: {
key: /^[^=]+/,
value: { pattern: /(^=)[\s\S]+/, lookbehind: !0 },
},
},
},
},
authority: {
pattern: RegExp(
"^//(?:[\\w\\-.~!$&'()*+,;=%:]*@)?(?:\\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\\.[\\w\\-.~!$&'()*+,;=]+)\\]|[\\w\\-.~!$&'()*+,;=%]*)(?::\\d*)?",
'm'
),
inside: {
'authority-delimiter': /^\/\//,
'user-info-segment': {
pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
inside: {
'user-info-delimiter': /@$/,
'user-info': /^[\w\-.~!$&'()*+,;=%:]+/,
},
},
'port-segment': {
pattern: /:\d*$/,
inside: { 'port-delimiter': /^:/, port: /^\d+/ },
},
host: {
pattern: /[\s\S]+/,
inside: {
'ip-literal': {
pattern: /^\[[\s\S]+\]$/,
inside: {
'ip-literal-delimiter': /^\[|\]$/,
'ipv-future': /^v[\s\S]+/,
'ipv6-address': /^[\s\S]+/,
},
},
'ipv4-address':
/^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/,
},
},
},
},
path: {
pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
inside: { 'path-separator': /\// },
},
}),
(Prism.languages.url = Prism.languages.uri);
|