MediaWiki:Gadget-prism-language-csharp.js

来自萌娘共享
跳转至： 导航、 搜索

注意：在保存之后，您可能需要清除浏览器缓存才能看到所作出的变更的影响。

  • Firefox或Safari：按住Shift的同时单击刷新，或按Ctrl-F5或Ctrl-R（Mac为⌘-R）
  • Google Chrome：按Ctrl-Shift-R（Mac为⌘-Shift-R）
  • Internet Explorer：按住Ctrl的同时单击刷新，或按Ctrl-F5
  • Opera：前往菜单 → 设置（Mac为Opera → Preferences），然后隐私和安全 → 清除浏览数据 → 缓存的图片和文件。
  1. /**
  2.  * -------------------------------------------------------------------------
  3.  * !!! DON'T MODIFY THIS PAGE MANUALLY, YOUR CHANGES WILL BE OVERWRITTEN !!!
  4.  * -------------------------------------------------------------------------
  5.  */
  6. var _addText = '{{GHIACode|page=GHIA:MoegirlPediaInterfaceCodes/blob/master/src/gadgets/prism-language-csharp/Gadget-prism-language-csharp.js|user=[[U:AnnAngela]]|co-authors=GH:github-actions[bot]|longId=103d1a563ea4ccc8ff29fb55c9bcd88329a56eb5|shortId=103d1a56|summary=feat: rename (#594)|body=<nowiki>Co-authored-by: github-actions[bot] <41898282+github-actions[bot]📧users.noreply.github.com></nowiki>}}'; 
  7.  
  8. /* <pre> */
  9.  
  10. "use strict";
  11. (function (Prism) {
  12.     function replace(pattern, replacements) {
  13.         return pattern.replace(/<<(\d+)>>/g, function (m, index) {
  14.             return '(?:' + replacements[+index] + ')';
  15.         });
  16.     }
  17.     function re(pattern, replacements, flags) {
  18.         return RegExp(replace(pattern, replacements), flags || '');
  19.     }
  20.     function nested(pattern, depthLog2) {
  21.         for (var i = 0; i < depthLog2; i++) {
  22.             pattern = pattern.replace(/<<self>>/g, function () { return '(?:' + pattern + ')'; });
  23.         }
  24.         return pattern.replace(/<<self>>/g, '[^\\s\\S]');
  25.     }
  26.     var keywordKinds = {
  27.         type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
  28.         typeDeclaration: 'class enum interface record struct',
  29.         contextual: 'add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)',
  30.         other: 'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'
  31.     };
  32.     function keywordsToPattern(words) {
  33.         return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b';
  34.     }
  35.     var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);
  36.     var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other));
  37.     var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other);
  38.     var nonContextualKeywords = keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other);
  39.     var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
  40.     var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
  41.     var name = /@?\b[A-Za-z_]\w*\b/.source;
  42.     var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
  43.     var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [nonTypeKeywords, genericName]);
  44.     var array = /\[\s*(?:,\s*)*\]/.source;
  45.     var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [identifier, array]);
  46.     var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [generic, nestedRound, array]);
  47.     var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
  48.     var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [tuple, identifier, array]);
  49.     var typeInside = {
  50.         'keyword': keywords,
  51.         'punctuation': /[<>()?,.:[\]]/
  52.     };
  53.     var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
  54.     var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
  55.     var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
  56.     Prism.languages.csharp = Prism.languages.extend('clike', {
  57.         'string': [
  58.             {
  59.                 pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
  60.                 lookbehind: true,
  61.                 greedy: true
  62.             },
  63.             {
  64.                 pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
  65.                 lookbehind: true,
  66.                 greedy: true
  67.             }
  68.         ],
  69.         'class-name': [
  70.             {
  71.                 pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [identifier]),
  72.                 lookbehind: true,
  73.                 inside: typeInside
  74.             },
  75.             {
  76.                 pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [name, typeExpression]),
  77.                 lookbehind: true,
  78.                 inside: typeInside
  79.             },
  80.             {
  81.                 pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
  82.                 lookbehind: true
  83.             },
  84.             {
  85.                 pattern: re(/(\b<<0>>\s+)<<1>>/.source, [typeDeclarationKeywords, genericName]),
  86.                 lookbehind: true,
  87.                 inside: typeInside
  88.             },
  89.             {
  90.                 pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
  91.                 lookbehind: true,
  92.                 inside: typeInside
  93.             },
  94.             {
  95.                 pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
  96.                 lookbehind: true
  97.             },
  98.             {
  99.                 pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [typeExpressionWithoutTuple]),
  100.                 lookbehind: true,
  101.                 inside: typeInside
  102.             },
  103.             {
  104.                 pattern: re(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [typeExpression, nonContextualKeywords, name]),
  105.                 inside: typeInside
  106.             }
  107.         ],
  108.         'keyword': keywords,
  109.         'number': /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
  110.         'operator': />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
  111.         'punctuation': /\?\.?|::|[{}[\];(),.:]/
  112.     });
  113.     Prism.languages.insertBefore('csharp', 'number', {
  114.         'range': {
  115.             pattern: /\.\./,
  116.             alias: 'operator'
  117.         }
  118.     });
  119.     Prism.languages.insertBefore('csharp', 'punctuation', {
  120.         'named-parameter': {
  121.             pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
  122.             lookbehind: true,
  123.             alias: 'punctuation'
  124.         }
  125.     });
  126.     Prism.languages.insertBefore('csharp', 'class-name', {
  127.         'namespace': {
  128.             pattern: re(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [name]),
  129.             lookbehind: true,
  130.             inside: {
  131.                 'punctuation': /\./
  132.             }
  133.         },
  134.         'type-expression': {
  135.             pattern: re(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [nestedRound]),
  136.             lookbehind: true,
  137.             alias: 'class-name',
  138.             inside: typeInside
  139.         },
  140.         'return-type': {
  141.             pattern: re(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [typeExpression, identifier]),
  142.             inside: typeInside,
  143.             alias: 'class-name'
  144.         },
  145.         'constructor-invocation': {
  146.             pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
  147.             lookbehind: true,
  148.             inside: typeInside,
  149.             alias: 'class-name'
  150.         },
  151.         'generic-method': {
  152.             pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
  153.             inside: {
  154.                 'function': re(/^<<0>>/.source, [name]),
  155.                 'generic': {
  156.                     pattern: RegExp(generic),
  157.                     alias: 'class-name',
  158.                     inside: typeInside
  159.                 }
  160.             }
  161.         },
  162.         'type-list': {
  163.             pattern: re(/\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source, [typeDeclarationKeywords, genericName, name, typeExpression, keywords.source, nestedRound, /\bnew\s*\(\s*\)/.source]),
  164.             lookbehind: true,
  165.             inside: {
  166.                 'record-arguments': {
  167.                     pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [genericName, nestedRound]),
  168.                     lookbehind: true,
  169.                     greedy: true,
  170.                     inside: Prism.languages.csharp
  171.                 },
  172.                 'keyword': keywords,
  173.                 'class-name': {
  174.                     pattern: RegExp(typeExpression),
  175.                     greedy: true,
  176.                     inside: typeInside
  177.                 },
  178.                 'punctuation': /[,()]/
  179.             }
  180.         },
  181.         'preprocessor': {
  182.             pattern: /(^[\t ]*)#.*/m,
  183.             lookbehind: true,
  184.             alias: 'property',
  185.             inside: {
  186.                 'directive': {
  187.                     pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
  188.                     lookbehind: true,
  189.                     alias: 'keyword'
  190.                 }
  191.             }
  192.         }
  193.     });
  194.     var regularStringOrCharacter = regularString + '|' + character;
  195.     var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]);
  196.     var roundExpression = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
  197.     var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
  198.     var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [identifier, roundExpression]);
  199.     Prism.languages.insertBefore('csharp', 'class-name', {
  200.         'attribute': {
  201.             pattern: re(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [attrTarget, attr]),
  202.             lookbehind: true,
  203.             greedy: true,
  204.             inside: {
  205.                 'target': {
  206.                     pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
  207.                     alias: 'keyword'
  208.                 },
  209.                 'attribute-arguments': {
  210.                     pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
  211.                     inside: Prism.languages.csharp
  212.                 },
  213.                 'class-name': {
  214.                     pattern: RegExp(identifier),
  215.                     inside: {
  216.                         'punctuation': /\./
  217.                     }
  218.                 },
  219.                 'punctuation': /[:,]/
  220.             }
  221.         }
  222.     });
  223.     var formatString = /:[^}\r\n]+/.source;
  224.     var mInterpolationRound = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
  225.     var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [mInterpolationRound, formatString]);
  226.     var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [regularStringOrCharacter]), 2);
  227.     var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [sInterpolationRound, formatString]);
  228.     function createInterpolationInside(interpolation, interpolationRound) {
  229.         return {
  230.             'interpolation': {
  231.                 pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
  232.                 lookbehind: true,
  233.                 inside: {
  234.                     'format-string': {
  235.                         pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [interpolationRound, formatString]),
  236.                         lookbehind: true,
  237.                         inside: {
  238.                             'punctuation': /^:/
  239.                         }
  240.                     },
  241.                     'punctuation': /^\{|\}$/,
  242.                     'expression': {
  243.                         pattern: /[\s\S]+/,
  244.                         alias: 'language-csharp',
  245.                         inside: Prism.languages.csharp
  246.                     }
  247.                 }
  248.             },
  249.             'string': /[\s\S]+/
  250.         };
  251.     }
  252.     Prism.languages.insertBefore('csharp', 'string', {
  253.         'interpolation-string': [
  254.             {
  255.                 pattern: re(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [mInterpolation]),
  256.                 lookbehind: true,
  257.                 greedy: true,
  258.                 inside: createInterpolationInside(mInterpolation, mInterpolationRound)
  259.             },
  260.             {
  261.                 pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]),
  262.                 lookbehind: true,
  263.                 greedy: true,
  264.                 inside: createInterpolationInside(sInterpolation, sInterpolationRound)
  265.             }
  266.         ],
  267.         'char': {
  268.             pattern: RegExp(character),
  269.             greedy: true
  270.         }
  271.     });
  272.     Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
  273. }(Prism)); 
  274.  
  275. /* </pre> */
取自“https://commons.moegirl.org.cn/index.php?title=MediaWiki:Gadget-prism-language-csharp.js&oldid=2519319”