/**
 * 
 * @authors yutent (yutent@doui.cc)
 * @date    2017-08-02 21:50:34
 * @version $Id$
 */

define(['./base', 'css!./highlight'], function(Prism) {

    Prism.languages.actionscript = Prism.languages.extend('javascript',  {
        'keyword': /\b(?:as|break|case|catch|class|const|default|delete|do|else|extends|finally|for|function|if|implements|import|in|instanceof|interface|internal|is|native|new|null|package|private|protected|public|return|super|switch|this|throw|try|typeof|use|var|void|while|with|dynamic|each|final|get|include|namespace|native|override|set|static)\b/,
        'operator': /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
    });
    Prism.languages.actionscript['class-name'].alias = 'function';

    if (Prism.languages.markup) {
        Prism.languages.insertBefore('actionscript', 'string', {
            'xml': {
                pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\\1|\\?(?!\1)[\s\S])*\2)*\s*\/?>/,
                lookbehind: true,
                inside: {
                    rest: Prism.languages.markup
                }
            }
        });
    };

    /*--------------------------------------------------------*/

    Prism.languages.apacheconf = {
        'comment': /#.*/,
        'directive-inline': {
            pattern: /^(\s*)\b(AcceptFilter|AcceptPathInfo|AccessFileName|Action|AddAlt|AddAltByEncoding|AddAltByType|AddCharset|AddDefaultCharset|AddDescription|AddEncoding|AddHandler|AddIcon|AddIconByEncoding|AddIconByType|AddInputFilter|AddLanguage|AddModuleInfo|AddOutputFilter|AddOutputFilterByType|AddType|Alias|AliasMatch|Allow|AllowCONNECT|AllowEncodedSlashes|AllowMethods|AllowOverride|AllowOverrideList|Anonymous|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID|Anonymous_VerifyEmail|AsyncRequestWorkerFactor|AuthBasicAuthoritative|AuthBasicFake|AuthBasicProvider|AuthBasicUseDigestAlgorithm|AuthDBDUserPWQuery|AuthDBDUserRealmQuery|AuthDBMGroupFile|AuthDBMType|AuthDBMUserFile|AuthDigestAlgorithm|AuthDigestDomain|AuthDigestNonceLifetime|AuthDigestProvider|AuthDigestQop|AuthDigestShmemSize|AuthFormAuthoritative|AuthFormBody|AuthFormDisableNoStore|AuthFormFakeBasicAuth|AuthFormLocation|AuthFormLoginRequiredLocation|AuthFormLoginSuccessLocation|AuthFormLogoutLocation|AuthFormMethod|AuthFormMimetype|AuthFormPassword|AuthFormProvider|AuthFormSitePassphrase|AuthFormSize|AuthFormUsername|AuthGroupFile|AuthLDAPAuthorizePrefix|AuthLDAPBindAuthoritative|AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareAsUser|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPInitialBindAsUser|AuthLDAPInitialBindPattern|AuthLDAPMaxSubGroupDepth|AuthLDAPRemoteUserAttribute|AuthLDAPRemoteUserIsDN|AuthLDAPSearchAsUser|AuthLDAPSubGroupAttribute|AuthLDAPSubGroupClass|AuthLDAPUrl|AuthMerging|AuthName|AuthnCacheContext|AuthnCacheEnable|AuthnCacheProvideFor|AuthnCacheSOCache|AuthnCacheTimeout|AuthnzFcgiCheckAuthnProvider|AuthnzFcgiDefineProvider|AuthType|AuthUserFile|AuthzDBDLoginToReferer|AuthzDBDQuery|AuthzDBDRedirectQuery|AuthzDBMType|AuthzSendForbiddenOnFailure|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|CacheDefaultExpire|CacheDetailHeader|CacheDirLength|CacheDirLevels|CacheDisable|CacheEnable|CacheFile|CacheHeader|CacheIgnoreCacheControl|CacheIgnoreHeaders|CacheIgnoreNoLastMod|CacheIgnoreQueryString|CacheIgnoreURLSessionIdentifiers|CacheKeyBaseURL|CacheLastModifiedFactor|CacheLock|CacheLockMaxAge|CacheLockPath|CacheMaxExpire|CacheMaxFileSize|CacheMinExpire|CacheMinFileSize|CacheNegotiatedDocs|CacheQuickHandler|CacheReadSize|CacheReadTime|CacheRoot|CacheSocache|CacheSocacheMaxSize|CacheSocacheMaxTime|CacheSocacheMinTime|CacheSocacheReadSize|CacheSocacheReadTime|CacheStaleOnError|CacheStoreExpired|CacheStoreNoStore|CacheStorePrivate|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateInflateLimitRequestBody|DeflateInflateRatioBurst|DeflateInflateRatioLimit|DeflateMemLevel|DeflateWindowSize|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|HeartbeatAddress|HeartbeatListen|HeartbeatMaxServers|HeartbeatStorage|HeartbeatStorage|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|IndexHeadInsert|IndexIgnore|IndexIgnoreReset|IndexOptions|IndexOrderDefault|IndexStyleSheet|InputSed|ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionPoolTTL|LDAPConnectionTimeout|LDAPLibraryDebug|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPReferralHopLimit|LDAPReferrals|LDAPRetries|LDAPRetryDelay|LDAPSharedCacheFile|LDAPSharedCacheSize|LDAPTimeout|LDAPTrustedClientCert|LDAPTrustedGlobalCert|LDAPTrustedMode|LDAPVerifyServerCert|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine|LimitXMLRequestBody|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|LuaHookAccessChecker|LuaHookAuthChecker|LuaHookCheckUserID|LuaHookFixups|LuaHookInsertFilter|LuaHookLog|LuaHookMapToStorage|LuaHookTranslateName|LuaHookTypeChecker|LuaInherit|LuaInputFilter|LuaMapHandler|LuaOutputFilter|LuaPackageCPath|LuaPackagePath|LuaQuickHandler|LuaRoot|LuaScope|MaxConnectionsPerChild|MaxKeepAliveRequests|MaxMemFree|MaxRangeOverlaps|MaxRangeReversals|MaxRanges|MaxRequestWorkers|MaxSpareServers|MaxSpareThreads|MaxThreads|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|ProxyAddHeaders|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyExpressDBMFile|ProxyExpressDBMType|ProxyExpressEnable|ProxyFtpDirCharset|ProxyFtpEscapeWildcards|ProxyFtpListOnWildcard|ProxyHTMLBufSize|ProxyHTMLCharsetOut|ProxyHTMLDocType|ProxyHTMLEnable|ProxyHTMLEvents|ProxyHTMLExtended|ProxyHTMLFixups|ProxyHTMLInterp|ProxyHTMLLinks|ProxyHTMLMeta|ProxyHTMLStripComments|ProxyHTMLURLMap|ProxyIOBufferSize|ProxyMaxForwards|ProxyPass|ProxyPassInherit|ProxyPassInterpolateEnv|ProxyPassMatch|ProxyPassReverse|ProxyPassReverseCookieDomain|ProxyPassReverseCookiePath|ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxySCGIInternalRedirect|ProxySCGISendfile|ProxySet|ProxySourceAddress|ProxyStatus|ProxyTimeout|ProxyVia|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIPHeader|RemoteIPInternalProxy|RemoteIPInternalProxyList|RemoteIPProxiesHeader|RemoteIPTrustedProxy|RemoteIPTrustedProxyList|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|RewriteBase|RewriteCond|RewriteEngine|RewriteMap|RewriteOptions|RewriteRule|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script|ScriptAlias|ScriptAliasMatch|ScriptInterpreterSource|ScriptLog|ScriptLogBuffer|ScriptLogLength|ScriptSock|SecureListen|SeeRequestTail|SendBufferSize|ServerAdmin|ServerAlias|ServerLimit|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|Session|SessionCookieName|SessionCookieName2|SessionCookieRemove|SessionCryptoCipher|SessionCryptoDriver|SessionCryptoPassphrase|SessionCryptoPassphraseFile|SessionDBDCookieName|SessionDBDCookieName2|SessionDBDCookieRemove|SessionDBDDeleteLabel|SessionDBDInsertLabel|SessionDBDPerUser|SessionDBDSelectLabel|SessionDBDUpdateLabel|SessionEnv|SessionExclude|SessionHeader|SessionInclude|SessionMaxAge|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSLCACertificateFile|SSLCACertificatePath|SSLCADNRequestFile|SSLCADNRequestPath|SSLCARevocationCheck|SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLCompression|SSLCryptoDevice|SSLEngine|SSLFIPS|SSLHonorCipherOrder|SSLInsecureRenegotiation|SSLOCSPDefaultResponder|SSLOCSPEnable|SSLOCSPOverrideResponder|SSLOCSPResponderTimeout|SSLOCSPResponseMaxAge|SSLOCSPResponseTimeSkew|SSLOCSPUseRequestNonce|SSLOpenSSLConfCmd|SSLOptions|SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationCheck|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCheckPeerCN|SSLProxyCheckPeerExpire|SSLProxyCheckPeerName|SSLProxyCipherSuite|SSLProxyEngine|SSLProxyMachineCertificateChainFile|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRenegBufferSize|SSLRequire|SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLSessionTicketKeyFile|SSLSRPUnknownUserSeed|SSLSRPVerifierFile|SSLStaplingCache|SSLStaplingErrorCacheTimeout|SSLStaplingFakeTryLater|SSLStaplingForceURL|SSLStaplingResponderTimeout|SSLStaplingResponseMaxAge|SSLStaplingResponseTimeSkew|SSLStaplingReturnResponderErrors|SSLStaplingStandardCacheTimeout|SSLStrictSNIVHostCheck|SSLUserName|SSLUseStapling|SSLVerifyClient|SSLVerifyDepth|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|VirtualDocumentRoot|VirtualDocumentRootIP|VirtualScriptAlias|VirtualScriptAliasIP|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/mi,
            lookbehind: true,
            alias: 'property'
        },
        'directive-block': {
            pattern: /<\/?\b(AuthnProviderAlias|AuthzProviderAlias|Directory|DirectoryMatch|Else|ElseIf|Files|FilesMatch|If|IfDefine|IfModule|IfVersion|Limit|LimitExcept|Location|LocationMatch|Macro|Proxy|RequireAll|RequireAny|RequireNone|VirtualHost)\b *.*>/i,
            inside: {
                'directive-block': {
                    pattern: /^<\/?\w+/,
                    inside: {
                        'punctuation': /^<\/?/
                    },
                    alias: 'tag'
                },
                'directive-block-parameter': {
                    pattern: /.*[^>]/,
                    inside: {
                        'punctuation': /:/,
                        'string': {
                            pattern: /("|').*\1/,
                            inside: {
                                'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/
                            }
                        }
                    },
                    alias: 'attr-value'
                },
                'punctuation': />/
            },
            alias: 'tag'
        },
        'directive-flags': {
            pattern: /\[(\w,?)+\]/,
            alias: 'keyword'
        },
        'string': {
            pattern: /("|').*\1/,
            inside: {
                'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/
            }
        },
        'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/,
        'regex': /\^?.*\$|\^.*\$?/
    };

    /*-------------------------------------------------------------*/

    Prism.languages.aspnet = Prism.languages.extend('markup', {
        'page-directive tag': {
            pattern: /<%\s*@.*%>/i,
            inside: {
                'page-directive tag': /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
                rest: Prism.languages.markup.tag.inside
            }
        },
        'directive tag': {
            pattern: /<%.*%>/i,
            inside: {
                'directive tag': /<%\s*?[$=%#:]{0,2}|%>/i,
                rest: Prism.languages.csharp
            }
        }
    });
    // Regexp copied from prism-markup, with a negative look-ahead added
    Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\s\S])*\1|[^\s'">=]+))?)*\s*\/?>/i;

    // match directives of attribute value foo="<% Bar %>"
    Prism.languages.insertBefore('inside', 'punctuation', {
        'directive tag': Prism.languages.aspnet['directive tag']
    }, Prism.languages.aspnet.tag.inside["attr-value"]);

    Prism.languages.insertBefore('aspnet', 'comment', {
        'asp comment': /<%--[\s\S]*?--%>/
    });

    // script runat="server" contains csharp, not javascript
    Prism.languages.insertBefore('aspnet', Prism.languages.javascript ? 'script' : 'tag', {
        'asp script': {
            pattern: /(<script(?=.*runat=['"]?server['"]?)[\s\S]*?>)[\s\S]*?(?=<\/script>)/i,
            lookbehind: true,
            inside: Prism.languages.csharp || {}
        }
    });

    /*-------------------------------------------------------------------*/

    Prism.languages.basic = {
        'string': /"(?:""|[!#$%&'()*,\/:;<=>?^_ +\-.A-Z\d])*"/i,
        'comment': {
            pattern: /(?:!|REM\b).+/i,
            inside: {
                'keyword': /^REM/i
            }
        },
        'number': /(?:\b|\B[.-])(?:\d+\.?\d*)(?:E[+-]?\d+)?/i,
        'keyword': /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SHARED|SINGLE|SELECT CASE|SHELL|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
        'function': /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
        'operator': /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
        'punctuation': /[,;:()]/
    };


    /*----------------------------------------------------*/

    Prism.languages.c = Prism.languages.extend('clike', {
        'keyword': /\b(asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
        'operator': /\-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*\/]/,
        'number': /\b-?(?:0x[\da-f]+|\d*\.?\d+(?:e[+-]?\d+)?)[ful]*\b/i
    });

    Prism.languages.insertBefore('c', 'string', {
        'macro': {
            // allow for multiline macro definitions
            // spaces after the # character compile fine with gcc
            pattern: /(^\s*)#\s*[a-z]+([^\r\n\\]|\\.|\\(?:\r\n?|\n))*/im,
            lookbehind: true,
            alias: 'property',
            inside: {
                // highlight the path of the include statement as a string
                'string': {
                    pattern: /(#\s*include\s*)(<.+?>|("|')(\\?.)+?\3)/,
                    lookbehind: true
                },
                // highlight macro directives as keywords
                'directive': {
                    pattern: /(#\s*)\b(define|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\b/,
                    lookbehind: true,
                    alias: 'keyword'
                }
            }
        },
        // highlight predefined macros as constants
        'constant': /\b(__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|stdin|stdout|stderr)\b/
    });

    delete Prism.languages.c['class-name'];
    delete Prism.languages.c['boolean'];


    /*---------------------------------------------------*/
    Prism.languages.csharp = Prism.languages.extend('clike', {
        'keyword': /\b(abstract|as|async|await|base|bool|break|byte|case|catch|char|checked|class|const|continue|decimal|default|delegate|do|double|else|enum|event|explicit|extern|false|finally|fixed|float|for|foreach|goto|if|implicit|in|int|interface|internal|is|lock|long|namespace|new|null|object|operator|out|override|params|private|protected|public|readonly|ref|return|sbyte|sealed|short|sizeof|stackalloc|static|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|unsafe|ushort|using|virtual|void|volatile|while|add|alias|ascending|async|await|descending|dynamic|from|get|global|group|into|join|let|orderby|partial|remove|select|set|value|var|where|yield)\b/,
        'string': [
            {
                pattern: /@("|')(\1\1|\\\1|\\?(?!\1)[\s\S])*\1/,
                greedy: true
            },
            {
                pattern: /("|')(\\?.)*?\1/,
                greedy: true
            }
        ],
        'number': /\b-?(0x[\da-f]+|\d*\.?\d+f?)\b/i
    });

    Prism.languages.insertBefore('csharp', 'keyword', {
        'generic-method': {
            pattern: /[a-z0-9_]+\s*<[^>\r\n]+?>\s*(?=\()/i,
            alias: 'function',
            inside: {
                keyword: Prism.languages.csharp.keyword,
                punctuation: /[<>(),.:]/
            }
        },
        'preprocessor': {
            pattern: /(^\s*)#.*/m,
            lookbehind: true,
            alias: 'property',
            inside: {
                // highlight preprocessor directives as keywords
                'directive': {
                    pattern: /(\s*#)\b(define|elif|else|endif|endregion|error|if|line|pragma|region|undef|warning)\b/,
                    lookbehind: true,
                    alias: 'keyword'
                }
            }
        }
    });


    /*-----------------------------------------------------------*/

    Prism.languages.cpp = Prism.languages.extend('c', {
        'keyword': /\b(alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
        'boolean': /\b(true|false)\b/,
        'operator': /[-+]{1,2}|!=?|<{1,2}=?|>{1,2}=?|\->|:{1,2}|={1,2}|\^|~|%|&{1,2}|\|?\||\?|\*|\/|\b(and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/
    });

    Prism.languages.insertBefore('cpp', 'keyword', {
        'class-name': {
            pattern: /(class\s+)[a-z0-9_]+/i,
            lookbehind: true
        }
    });

    /*-----------------------coffeescript-----------------------*/

    ;(function(Prism) {

        // Ignore comments starting with { to privilege string interpolation highlighting
        var comment = /#(?!\{).+/,
            interpolation = {
                pattern: /#\{[^}]+\}/,
                alias: 'variable'
            };

        Prism.languages.coffeescript = Prism.languages.extend('javascript', {
            'comment': comment,
            'string': [

                // Strings are multiline
                {
                    pattern: /'(?:\\?[^\\])*?'/,
                    greedy: true
                },

                {
                    // Strings are multiline
                    pattern: /"(?:\\?[^\\])*?"/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                }
            ],
            'keyword': /\b(and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
            'class-member': {
                pattern: /@(?!\d)\w+/,
                alias: 'variable'
            }
        });

        Prism.languages.insertBefore('coffeescript', 'comment', {
            'multiline-comment': {
                pattern: /###[\s\S]+?###/,
                alias: 'comment'
            },

            // Block regexp can contain comments and interpolation
            'block-regex': {
                pattern: /\/{3}[\s\S]*?\/{3}/,
                alias: 'regex',
                inside: {
                    'comment': comment,
                    'interpolation': interpolation
                }
            }
        });

        Prism.languages.insertBefore('coffeescript', 'string', {
            'inline-javascript': {
                pattern: /`(?:\\?[\s\S])*?`/,
                inside: {
                    'delimiter': {
                        pattern: /^`|`$/,
                        alias: 'punctuation'
                    },
                    rest: Prism.languages.javascript
                }
            },

            // Block strings
            'multiline-string': [
                {
                    pattern: /'''[\s\S]*?'''/,
                    greedy: true,
                    alias: 'string'
                },
                {
                    pattern: /"""[\s\S]*?"""/,
                    greedy: true,
                    alias: 'string',
                    inside: {
                        interpolation: interpolation
                    }
                }
            ]

        });

        Prism.languages.insertBefore('coffeescript', 'keyword', {
            // Object property
            'property': /(?!\d)\w+(?=\s*:(?!:))/
        });

        delete Prism.languages.coffeescript['template-string'];

    }(Prism));


    /*---------------------------ruby---------------------------*/


    (function(Prism) {
        Prism.languages.ruby = Prism.languages.extend('clike', {
            'comment': [
                /#(?!\{[^\r\n]*?\}).*/,
                /^=begin(?:\r?\n|\r)(?:.*(?:\r?\n|\r))*?=end/m
            ],
            'keyword': /\b(alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|false|for|if|in|module|new|next|nil|not|or|raise|redo|require|rescue|retry|return|self|super|then|throw|true|undef|unless|until|when|while|yield)\b/
        });

        var interpolation = {
            pattern: /#\{[^}]+\}/,
            inside: {
                'delimiter': {
                    pattern: /^#\{|\}$/,
                    alias: 'tag'
                },
                rest: Prism.util.clone(Prism.languages.ruby)
            }
        };

        Prism.languages.insertBefore('ruby', 'keyword', {
            'regex': [
                {
                    pattern: /%r([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1[gim]{0,3}/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                },
                {
                    pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                },
                {
                    // Here we need to specifically allow interpolation
                    pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                },
                {
                    pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                },
                {
                    pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
                    greedy: true,
                    inside: {
                        'interpolation': interpolation
                    }
                },
                {
                    pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,
                    lookbehind: true,
                    greedy: true
                }
            ],
            'variable': /[@$]+[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/,
            'symbol': /:[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/
        });

        Prism.languages.insertBefore('ruby', 'number', {
            'builtin': /\b(Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|File|Fixnum|Float|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass)\b/,
            'constant': /\b[A-Z][a-zA-Z_0-9]*(?:[?!]|\b)/
        });

        Prism.languages.ruby.string = [
            {
                pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            },
            {
                pattern: /%[qQiIwWxs]?\((?:[^()\\]|\\[\s\S])*\)/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            },
            {
                // Here we need to specifically allow interpolation
                pattern: /%[qQiIwWxs]?\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            },
            {
                pattern: /%[qQiIwWxs]?\[(?:[^\[\]\\]|\\[\s\S])*\]/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            },
            {
                pattern: /%[qQiIwWxs]?<(?:[^<>\\]|\\[\s\S])*>/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            },
            {
                pattern: /("|')(#\{[^}]+\}|\\(?:\r?\n|\r)|\\?.)*?\1/,
                greedy: true,
                inside: {
                    'interpolation': interpolation
                }
            }
        ];
    }(Prism));


    /*-------------------------------------------------------------*/

    Prism.languages.d = Prism.languages.extend('clike', {
        'string': [
            // r"", x""
            /\b[rx]"(\\.|[^\\"])*"[cwd]?/,
            // q"[]", q"()", q"<>", q"{}"
            /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/,
            // q"IDENT
            // ...
            // IDENT"
            /\bq"([_a-zA-Z][_a-zA-Z\d]*)(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\1"/,
            // q"//", q"||", etc.
            /\bq"(.)[\s\S]*?\1"/,
            // Characters
            /'(?:\\'|\\?[^']+)'/,

            /(["`])(\\.|(?!\1)[^\\])*\1[cwd]?/
        ],

        'number': [
            // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
            // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
            /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]*/i,
            {
                pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]*/i,
                lookbehind: true
            }
        ],

        // In order: $, keywords and special tokens, globally defined symbols
        'keyword': /\$|\b(?:abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|public|pure|real|ref|return|scope|shared|short|static|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|__(?:(?:FILE|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__|gshared|traits|vector|parameters)|string|wstring|dstring|size_t|ptrdiff_t)\b/,
        'operator': /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
    });


    Prism.languages.d.comment = [
        // Shebang
        /^\s*#!.+/,
        // /+ +/
        {
            // Allow one level of nesting
            pattern: /(^|[^\\])\/\+(?:\/\+[\s\S]*?\+\/|[\s\S])*?\+\//,
            lookbehind: true
        }
    ].concat(Prism.languages.d.comment);

    Prism.languages.insertBefore('d', 'comment', {
        'token-string': {
            // Allow one level of nesting
            pattern: /\bq\{(?:|\{[^}]*\}|[^}])*\}/,
            alias: 'string'
        }
    });

    Prism.languages.insertBefore('d', 'keyword', {
        'property': /\B@\w*/
    });

    Prism.languages.insertBefore('d', 'function', {
        'register': {
            // Iasm registers
            pattern: /\b(?:[ABCD][LHX]|E[ABCD]X|E?(?:BP|SP|DI|SI)|[ECSDGF]S|CR[0234]|DR[012367]|TR[3-7]|X?MM[0-7]|R[ABCD]X|[BS]PL|R[BS]P|[DS]IL|R[DS]I|R(?:[89]|1[0-5])[BWD]?|XMM(?:[89]|1[0-5])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
            alias: 'variable'
        }
    });
    Prism.languages.dart = Prism.languages.extend('clike', {
        'string': [
            {
                pattern: /r?("""|''')[\s\S]*?\1/,
                greedy: true
            },
            {
                pattern: /r?("|')(\\?.)*?\1/,
                greedy: true
            }
        ],
        'keyword': [
            /\b(?:async|sync|yield)\*/,
            /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|default|deferred|do|dynamic|else|enum|export|external|extends|factory|final|finally|for|get|if|implements|import|in|library|new|null|operator|part|rethrow|return|set|static|super|switch|this|throw|try|typedef|var|void|while|with|yield)\b/
        ],
        'operator': /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
    });

    Prism.languages.insertBefore('dart','function',{
        'metadata': {
            pattern: /@\w+/,
            alias: 'symbol'
        }
    });


    /*-----------------------------------------------------------*/

    Prism.languages.docker = {
        'keyword': {
            pattern: /(^\s*)(?:ONBUILD|FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|COPY|VOLUME|USER|WORKDIR|CMD|LABEL|ENTRYPOINT)(?=\s)/mi,
            lookbehind: true
        },
        'string': /("|')(?:(?!\1)[^\\\r\n]|\\(?:\r\n|[\s\S]))*?\1/,
        'comment': /#.*/,
        'punctuation': /---|\.\.\.|[:[\]{}\-,|>?]/
    };
    Prism.languages.erlang = {
        'comment': /%.+/,
        'string': {
            pattern: /"(?:\\?.)*?"/,
            greedy: true
        },
        'quoted-function': {
            pattern: /'(?:\\.|[^'\\])+'(?=\()/,
            alias: 'function'
        },
        'quoted-atom': {
            pattern: /'(?:\\.|[^'\\])+'/,
            alias: 'atom'
        },
        'boolean': /\b(?:true|false)\b/,
        'keyword': /\b(?:fun|when|case|of|end|if|receive|after|try|catch)\b/,
        'number': [
            /\$\\?./,
            /\d+#[a-z0-9]+/i,
            /(?:\b|-)\d*\.?\d+([Ee][+-]?\d+)?\b/
        ],
        'function': /\b[a-z][\w@]*(?=\()/,
        'variable': {
            // Look-behind is used to prevent wrong highlighting of atoms containing "@"
            pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
            lookbehind: true
        },
        'operator': [
            /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:bnot|div|rem|band|bor|bxor|bsl|bsr|not|and|or|xor|orelse|andalso)\b/,
            {
                // We don't want to match <<
                pattern: /(^|[^<])<(?!<)/,
                lookbehind: true
            },
            {
                // We don't want to match >>
                pattern: /(^|[^>])>(?!>)/,
                lookbehind: true
            }
        ],
        'atom': /\b[a-z][\w@]*/,
        'punctuation': /[()[\]{}:;,.#|]|<<|>>/

    };

    Prism.languages.git = {
        'comment': /^#.*/m,
        'deleted': /^[-–].*/m,
        'inserted': /^\+.*/m,
        'string': /("|')(\\?.)*?\1/m,
        'command': {
            pattern: /^.*\$ git .*$/m,
            inside: {
                'parameter': /\s(--|-)\w+/m
            }
        },
        'coord': /^@@.*@@$/m,
        'commit_sha1': /^commit \w{40}$/m
    };


    /*-----------------------------------------------------------*/
    Prism.languages.go = Prism.languages.extend('clike', {
        'keyword': /\b(break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
        'builtin': /\b(bool|byte|complex(64|128)|error|float(32|64)|rune|string|u?int(8|16|32|64|)|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(ln)?|real|recover)\b/,
        'boolean': /\b(_|iota|nil|true|false)\b/,
        'operator': /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
        'number': /\b(-?(0x[a-f\d]+|(\d+\.?\d*|\.\d+)(e[-+]?\d+)?)i?)\b/i,
        'string': {
            pattern: /("|'|`)(\\?.|\r|\n)*?\1/,
            greedy: true
        }
    });
    delete Prism.languages.go['class-name'];

    Prism.languages.haskell= {
        'comment': {
            pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(--[^-!#$%*+=?&@|~.:<>^\\\/].*|{-[\s\S]*?-})/m,
            lookbehind: true
        },
        'char': /'([^\\']|\\([abfnrtv\\"'&]|\^[A-Z@[\]\^_]|NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
        'string': {
            pattern: /"([^\\"]|\\([abfnrtv\\"'&]|\^[A-Z@[\]\^_]|NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|\d+|o[0-7]+|x[0-9a-fA-F]+)|\\\s+\\)*"/,
            greedy: true
        },
        'keyword' : /\b(case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
        'import_statement' : {
            // The imported or hidden names are not included in this import
            // statement. This is because we want to highlight those exactly like
            // we do for the names in the program.
            pattern: /(\r?\n|\r|^)\s*import\s+(qualified\s+)?([A-Z][_a-zA-Z0-9']*)(\.[A-Z][_a-zA-Z0-9']*)*(\s+as\s+([A-Z][_a-zA-Z0-9']*)(\.[A-Z][_a-zA-Z0-9']*)*)?(\s+hiding\b)?/m,
            inside: {
                'keyword': /\b(import|qualified|as|hiding)\b/
            }
        },
        // These are builtin variables only. Constructors are highlighted later as a constant.
        'builtin': /\b(abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
        // decimal integers and floating point numbers | octal integers | hexadecimal integers
        'number' : /\b(\d+(\.\d+)?(e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
        // Most of this is needed because of the meaning of a single '.'.
        // If it stands alone freely, it is the function composition.
        // It may also be a separator between a module name and an identifier => no
        // operator. If it comes together with other special characters it is an
        // operator too.
        'operator' : /\s\.\s|[-!#$%*+=?&@|~.:<>^\\\/]*\.[-!#$%*+=?&@|~.:<>^\\\/]+|[-!#$%*+=?&@|~.:<>^\\\/]+\.[-!#$%*+=?&@|~.:<>^\\\/]*|[-!#$%*+=?&@|~:<>^\\\/]+|`([A-Z][_a-zA-Z0-9']*\.)*[_a-z][_a-zA-Z0-9']*`/,
        // In Haskell, nearly everything is a variable, do not highlight these.
        'hvariable': /\b([A-Z][_a-zA-Z0-9']*\.)*[_a-z][_a-zA-Z0-9']*\b/,
        'constant': /\b([A-Z][_a-zA-Z0-9']*\.)*[A-Z][_a-zA-Z0-9']*\b/,
        'punctuation' : /[{}[\];(),.:]/
    };

    /*---------------------------jade---------------------------*/

    ;(function(Prism) {

        Prism.languages.jade = {

            'comment': {
                pattern: /(^([\t ]*))\/\/.*((?:\r?\n|\r)\2[\t ]+.+)*/m,
                lookbehind: true
            },
            'multiline-script': {
                pattern: /(^([\t ]*)script\b.*\.[\t ]*)((?:\r?\n|\r(?!\n))(?:\2[\t ]+.+|\s*?(?=\r?\n|\r)))+/m,
                lookbehind: true,
                inside: {
                    rest: Prism.languages.javascript
                }
            },
            'filter': {
                pattern: /(^([\t ]*)):.+((?:\r?\n|\r(?!\n))(?:\2[\t ]+.+|\s*?(?=\r?\n|\r)))+/m,
                lookbehind: true,
                inside: {
                    'filter-name': {
                        pattern: /^:[\w-]+/,
                        alias: 'variable'
                    }
                }
            },
            'multiline-plain-text': {
                pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)((?:\r?\n|\r(?!\n))(?:\2[\t ]+.+|\s*?(?=\r?\n|\r)))+/m,
                lookbehind: true
            },
            'markup': {
                pattern: /(^[\t ]*)<.+/m,
                lookbehind: true,
                inside: {
                    rest: Prism.languages.markup
                }
            },
            'doctype': {
                pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
                lookbehind: true
            },
            'flow-control': {
                pattern: /(^[\t ]*)(?:if|unless|else|case|when|default|each|while)\b(?: .+)?/m,
                lookbehind: true,
                inside: {
                    'each': {
                        pattern: /^each .+? in\b/,
                        inside: {
                            'keyword': /\b(?:each|in)\b/,
                            'punctuation': /,/
                        }
                    },
                    'branch': {
                        pattern: /^(?:if|unless|else|case|when|default|while)\b/,
                        alias: 'keyword'
                    },
                    rest: Prism.languages.javascript
                }
            },
            'keyword': {
                pattern: /(^[\t ]*)(?:block|extends|include|append|prepend)\b.+/m,
                lookbehind: true
            },
            'mixin': [
                {
                    pattern: /(^[\t ]*)mixin .+/m,
                    lookbehind: true,
                    inside: {
                        'keyword': /^mixin/,
                        'function': /\w+(?=\s*\(|\s*$)/,
                        'punctuation': /[(),.]/
                    }
                },
                {
                    pattern: /(^[\t ]*)\+.+/m,
                    lookbehind: true,
                    inside: {
                        'name': {
                            pattern: /^\+\w+/,
                            alias: 'function'
                        },
                        'rest': Prism.languages.javascript
                    }
                }
            ],
            'script': {
                pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]+).+/m,
                lookbehind: true,
                inside: {
                    rest: Prism.languages.javascript
                }
            },

            'plain-text': {
                pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]+).+/m,
                lookbehind: true
            },
            'tag': {
                pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
                lookbehind: true,
                inside: {
                    'attributes': [
                        {
                            pattern: /&[^(]+\([^)]+\)/,
                            inside: {
                                rest: Prism.languages.javascript
                            }
                        },
                        {
                            pattern: /\([^)]+\)/,
                            inside: {
                                'attr-value': {
                                    pattern: /(=\s*)(?:\{[^}]*\}|[^,)\r\n]+)/,
                                    lookbehind: true,
                                    inside: {
                                        rest: Prism.languages.javascript
                                    }
                                },
                                'attr-name': /[\w-]+(?=\s*!?=|\s*[,)])/,
                                'punctuation': /[!=(),]+/
                            }
                        }
                    ],
                    'punctuation': /:/
                }
            },
            'code': [
                {
                    pattern: /(^[\t ]*(?:-|!?=)).+/m,
                    lookbehind: true,
                    inside: {
                        rest: Prism.languages.javascript
                    }
                }
            ],
            'punctuation': /[.\-!=|]+/
        };

        var filter_pattern = '(^([\\t ]*)):{{filter_name}}((?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ]+.+|\\s*?(?=\\r?\\n|\\r)))+';

        var filters = [
            {filter:'atpl',language:'twig'},
            {filter:'coffee',language:'coffeescript'},
            'ejs',
            'handlebars',
            'hogan',
            'less',
            'livescript',
            'markdown',
            'mustache',
            'plates',
            {filter:'sass',language:'scss'},
            'stylus',
            'swig'

        ];
        var all_filters = {};
        for (var i = 0, l = filters.length; i < l; i++) {
            var filter = filters[i];
            filter = typeof filter === 'string' ? {filter: filter, language: filter} : filter;
            if (Prism.languages[filter.language]) {
                all_filters['filter-' + filter.filter] = {
                    pattern: RegExp(filter_pattern.replace('{{filter_name}}', filter.filter), 'm'),
                    lookbehind: true,
                    inside: {
                        'filter-name': {
                            pattern: /^:[\w-]+/,
                            alias: 'variable'
                        },
                        rest: Prism.languages[filter.language]
                    }
                }
            }
        }

        Prism.languages.insertBefore('jade', 'filter', all_filters);

    }(Prism));

    /*-----------------------------------------------------------*/

    Prism.languages.java = Prism.languages.extend('clike', {
        'keyword': /\b(abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while)\b/,
        'number': /\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp\-]+\b|\b\d*\.?\d+(?:e[+-]?\d+)?[df]?\b/i,
        'operator': {
            pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])/m,
            lookbehind: true
        }
    });

    Prism.languages.insertBefore('java','function', {
        'annotation': {
            alias: 'punctuation',
            pattern: /(^|[^.])@\w+/,
            lookbehind: true
        }
    });

    Prism.languages.json = {
        'property': /"(?:\\.|[^\\"])*"(?=\s*:)/ig,
        'string': /"(?!:)(?:\\.|[^\\"])*"(?!:)/g,
        'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee][+-]?\d+)?)\b/g,
        'punctuation': /[{}[\]);,]/g,
        'operator': /:/g,
        'boolean': /\b(true|false)\b/gi,
        'null': /\bnull\b/gi
    };

    Prism.languages.jsonp = Prism.languages.json;

    /*--------------------------kotlin----------------------------*/

    ;(function (Prism) {
        Prism.languages.kotlin = Prism.languages.extend('clike', {
            'keyword': {
                // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
                pattern: /(^|[^.])\b(?:abstract|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|else|enum|final|finally|for|fun|get|if|import|in|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|out|override|package|private|protected|public|reified|return|sealed|set|super|tailrec|this|throw|to|try|val|var|when|where|while)\b/,
                lookbehind: true
            },
            'function': [
                /\w+(?=\s*\()/,
                {
                    pattern: /(\.)\w+(?=\s*\{)/,
                    lookbehind: true
                }
            ],
            'number': /\b(?:0[bx][\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?[fFL]?)\b/,
            'operator': /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
        });

        delete Prism.languages.kotlin["class-name"];

        Prism.languages.insertBefore('kotlin', 'string', {
            'raw-string': {
                pattern: /(["'])\1\1[\s\S]*?\1{3}/,
                alias: 'string'
                // See interpolation below
            }
        });
        Prism.languages.insertBefore('kotlin', 'keyword', {
            'annotation': {
                pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
                alias: 'builtin'
            }
        });
        Prism.languages.insertBefore('kotlin', 'function', {
            'label': {
                pattern: /\w+@|@\w+/,
                alias: 'symbol'
            }
        });

        var interpolation = [
            {
                pattern: /\$\{[^}]+\}/,
                inside: {
                    delimiter: {
                        pattern: /^\$\{|\}$/,
                        alias: 'variable'
                    },
                    rest: Prism.util.clone(Prism.languages.kotlin)
                }
            },
            {
                pattern: /\$\w+/,
                alias: 'variable'
            }
        ];

        Prism.languages.kotlin['string'].inside = Prism.languages.kotlin['raw-string'].inside = {
            interpolation: interpolation
        };

    }(Prism));


    /*-----------------------------------------------------------*/

    Prism.languages.less = Prism.languages.extend('css', {
        'comment': [
            /\/\*[\s\S]*?\*\//,
            {
                pattern: /(^|[^\\])\/\/.*/,
                lookbehind: true
            }
        ],
        'atrule': {
            pattern: /@[\w-]+?(?:\([^{}]+\)|[^(){};])*?(?=\s*\{)/i,
            inside: {
                'punctuation': /[:()]/
            }
        },
        // selectors and mixins are considered the same
        'selector': {
            pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\([^{}]*\)|[^{};@])*?(?=\s*\{)/,
            inside: {
                // mixin parameters
                'variable': /@+[\w-]+/
            }
        },

        'property': /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/i,
        'punctuation': /[{}();:,]/,
        'operator': /[+\-*\/]/
    });

    // Invert function and punctuation positions
    Prism.languages.insertBefore('less', 'punctuation', {
        'function': Prism.languages.less.function
    });

    Prism.languages.insertBefore('less', 'property', {
        'variable': [
            // Variable declaration (the colon must be consumed!)
            {
                pattern: /@[\w-]+\s*:/,
                inside: {
                    "punctuation": /:/
                }
            },

            // Variable usage
            /@@?[\w-]+/
        ],
        'mixin-usage': {
            pattern: /([{;]\s*)[.#](?!\d)[\w-]+.*?(?=[(;])/,
            lookbehind: true,
            alias: 'function'
        }
    });



    /*-----------------------------------------------------------*/

    Prism.languages.lua = {
        'comment': /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
        // \z may be used to skip the following space
        'string': {
            pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[\s\S]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
            greedy: true
        },
        'number': /\b0x[a-f\d]+\.?[a-f\d]*(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|\.?\d*(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
        'keyword': /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
        'function': /(?!\d)\w+(?=\s*(?:[({]))/,
        'operator': [
            /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
            {
                // Match ".." but don't break "..."
                pattern: /(^|[^.])\.\.(?!\.)/,
                lookbehind: true
            }
        ],
        'punctuation': /[\[\](){},;]|\.+|:+/
    };
    Prism.languages.matlab = {
        // We put string before comment, because of printf() patterns that contain "%"
        'string': /\B'(?:''|[^'\n])*'/,
        'comment': [
            /%\{[\s\S]*?\}%/,
            /%.+/
        ],
        // FIXME We could handle imaginary numbers as a whole
        'number': /\b-?(?:\d*\.?\d+(?:[eE][+-]?\d+)?(?:[ij])?|[ij])\b/,
        'keyword': /\b(?:break|case|catch|continue|else|elseif|end|for|function|if|inf|NaN|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
        'function': /(?!\d)\w+(?=\s*\()/,
        'operator': /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
        'punctuation': /\.{3}|[.,;\[\](){}!]/
    };

    Prism.languages.nim = {
        'comment': /#.*/,
        // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
        // Character literals are handled specifically to prevent issues with numeric type suffixes
        'string': {
            pattern: /(?:(?:\b(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")|'(?:\\(?:\d+|x[\da-fA-F]{2}|.)|[^'])')/,
            greedy: true
        },
        // The negative look ahead prevents wrong highlighting of the .. operator
        'number': /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
        'keyword': /\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
        'function': {
            pattern: /(?:(?!\d)(?:\w|\\x[8-9a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
            inside: {
                'operator': /\*$/
            }
        },
        // We don't want to highlight operators inside backticks
        'ignore': {
            pattern: /`[^`\r\n]+`/,
            inside: {
                'punctuation': /`/
            }
        },
        'operator': {
            // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
            // but allow the slice operator .. to take precedence over them
            // One can define his own operators in Nim so all combination of operators might be an operator.
            pattern: /(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|of|or|in|is|isnot|mod|not|notin|shl|shr|xor)\b)/m,
            lookbehind: true
        },
        'punctuation': /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
    };
    Prism.languages.objectivec = Prism.languages.extend('c', {
        'keyword': /\b(asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while|in|self|super)\b|(@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
        'string': /("|')(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|@"(\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
        'operator': /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
    });


    /*-----------------------------------------------------------*/


    Prism.languages.perl = {
        'comment': [
            {
                // POD
                pattern: /(^\s*)=\w+[\s\S]*?=cut.*/m,
                lookbehind: true
            },
            {
                pattern: /(^|[^\\$])#.*/,
                lookbehind: true
            }
        ],
        // TODO Could be nice to handle Heredoc too.
        'string': [
            // q/.../
            {
                pattern: /\b(?:q|qq|qx|qw)\s*([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1/,
                greedy: true
            },
        
            // q a...a
            {
                pattern: /\b(?:q|qq|qx|qw)\s+([a-zA-Z0-9])(?:[^\\]|\\[\s\S])*?\1/,
                greedy: true
            },
        
            // q(...)
            {
                pattern: /\b(?:q|qq|qx|qw)\s*\((?:[^()\\]|\\[\s\S])*\)/,
                greedy: true
            },
        
            // q{...}
            {
                pattern: /\b(?:q|qq|qx|qw)\s*\{(?:[^{}\\]|\\[\s\S])*\}/,
                greedy: true
            },
        
            // q[...]
            {
                pattern: /\b(?:q|qq|qx|qw)\s*\[(?:[^[\]\\]|\\[\s\S])*\]/,
                greedy: true
            },
        
            // q<...>
            {
                pattern: /\b(?:q|qq|qx|qw)\s*<(?:[^<>\\]|\\[\s\S])*>/,
                greedy: true
            },

            // "...", `...`
            {
                pattern: /("|`)(?:[^\\]|\\[\s\S])*?\1/,
                greedy: true
            },

            // '...'
            // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
            {
                pattern: /'(?:[^'\\\r\n]|\\.)*'/,
                greedy: true
            }
        ],
        'regex': [
            // m/.../
            {
                pattern: /\b(?:m|qr)\s*([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1[msixpodualngc]*/,
                greedy: true
            },
        
            // m a...a
            {
                pattern: /\b(?:m|qr)\s+([a-zA-Z0-9])(?:[^\\]|\\.)*?\1[msixpodualngc]*/,
                greedy: true
            },
        
            // m(...)
            {
                pattern: /\b(?:m|qr)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngc]*/,
                greedy: true
            },
        
            // m{...}
            {
                pattern: /\b(?:m|qr)\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngc]*/,
                greedy: true
            },
        
            // m[...]
            {
                pattern: /\b(?:m|qr)\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngc]*/,
                greedy: true
            },
        
            // m<...>
            {
                pattern: /\b(?:m|qr)\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngc]*/,
                greedy: true
            },

            // The lookbehinds prevent -s from breaking
            // FIXME We don't handle change of separator like s(...)[...]
            // s/.../.../
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s*([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\2(?:[^\\]|\\[\s\S])*?\2[msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // s a...a...a
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s+([a-zA-Z0-9])(?:[^\\]|\\[\s\S])*?\2(?:[^\\]|\\[\s\S])*?\2[msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // s(...)(...)
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s*\((?:[^()\\]|\\[\s\S])*\)\s*\((?:[^()\\]|\\[\s\S])*\)[msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // s{...}{...}
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s*\{(?:[^{}\\]|\\[\s\S])*\}\s*\{(?:[^{}\\]|\\[\s\S])*\}[msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // s[...][...]
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s*\[(?:[^[\]\\]|\\[\s\S])*\]\s*\[(?:[^[\]\\]|\\[\s\S])*\][msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // s<...><...>
            {
                pattern: /(^|[^-]\b)(?:s|tr|y)\s*<(?:[^<>\\]|\\[\s\S])*>\s*<(?:[^<>\\]|\\[\s\S])*>[msixpodualngcer]*/,
                lookbehind: true,
                greedy: true
            },
        
            // /.../
            // The look-ahead tries to prevent two divisions on
            // the same line from being highlighted as regex.
            // This does not support multi-line regex.
            {
                pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(lt|gt|le|ge|eq|ne|cmp|not|and|or|xor|x)\b))/,
                greedy: true
            }
        ],

        // FIXME Not sure about the handling of ::, ', and #
        'variable': [
            // ${^POSTMATCH}
            /[&*$@%]\{\^[A-Z]+\}/,
            // $^V
            /[&*$@%]\^[A-Z_]/,
            // ${...}
            /[&*$@%]#?(?=\{)/,
            // $foo
            /[&*$@%]#?((::)*'?(?!\d)[\w$]+)+(::)*/i,
            // $1
            /[&*$@%]\d+/,
            // $_, @_, %!
            // The negative lookahead prevents from breaking the %= operator
            /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
        ],
        'filehandle': {
            // <>, <FOO>, _
            pattern: /<(?![<=])\S*>|\b_\b/,
            alias: 'symbol'
        },
        'vstring': {
            // v1.2, 1.2.3
            pattern: /v\d+(\.\d+)*|\d+(\.\d+){2,}/,
            alias: 'string'
        },
        'function': {
            pattern: /sub [a-z0-9_]+/i,
            inside: {
                keyword: /sub/
            }
        },
        'keyword': /\b(any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
        'number': /\b-?(0x[\dA-Fa-f](_?[\dA-Fa-f])*|0b[01](_?[01])*|(\d(_?\d)*)?\.?\d(_?\d)*([Ee][+-]?\d+)?)\b/,
        'operator': /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(lt|gt|le|ge|eq|ne|cmp|not|and|or|xor)\b/,
        'punctuation': /[{}[\];(),:]/
    };

    /*-----------------------------------------------------------*/

    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|private|protected|parent|throw|null|echo|print|trait|namespace|final|yield|goto|instanceof|finally|try|catch)\b/i,
        'constant': /\b[A-Z0-9_]{2,}\b/,
        'comment': {
            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
            lookbehind: true
        }
    });

    // Shell-like comments are matched after strings, because they are less
    // common than strings containing hashes...
    Prism.languages.insertBefore('php', 'class-name', {
        'shell-comment': {
            pattern: /(^|[^\\])#.*/,
            lookbehind: true,
            alias: 'comment'
        }
    });

    Prism.languages.insertBefore('php', 'keyword', {
        'delimiter': {
            pattern: /\?>|<\?(?:php|=)?/i,
            alias: 'important'
        },
        'variable': /\$\w+\b/i,
        'package': {
            pattern: /(\\|namespace\s+|use\s+)[\w\\]+/,
            lookbehind: true,
            inside: {
                punctuation: /\\/
            }
        }
    });

    // Must be defined after the function pattern
    Prism.languages.insertBefore('php', 'operator', {
        'property': {
            pattern: /(->)[\w]+/,
            lookbehind: true
        }
    });

    // Add HTML support if 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' || !/(?:<\?php|<\?)/ig.test(env.code)) {
                return;
            }

            env.tokenStack = [];

            env.backupCode = env.code;
            env.code = env.code.replace(/(?:<\?php|<\?)[\s\S]*?(?:\?>|$)/ig, function(match) {
                var i = env.tokenStack.length;
                // Check for existing strings
                while (env.backupCode.indexOf('___PHP' + i + '___') !== -1)
                    ++i;

                // Create a sparse array
                env.tokenStack[i] = match;

                return '___PHP' + i + '___';
            });

            // Switch the grammar to markup
            env.grammar = Prism.languages.markup;
        });

        // Restore env.code for other plugins (e.g. line-numbers)
        Prism.hooks.add('before-insert', function(env) {
            if (env.language === 'php' && env.backupCode) {
                env.code = env.backupCode;
                delete env.backupCode;
            }
        });

        // Re-insert the tokens after highlighting
        Prism.hooks.add('after-highlight', function(env) {
            if (env.language !== 'php' || !env.tokenStack) {
                return;
            }

            // Switch the grammar back
            env.grammar = Prism.languages.php;

            for (var i = 0, keys = Object.keys(env.tokenStack); i < keys.length; ++i) {
                var k = keys[i];
                var t = env.tokenStack[k];

                // The replace prevents $$, $&, $`, $', $n, $nn from being interpreted as special patterns
                env.highlightedCode = env.highlightedCode.replace('___PHP' + k + '___',
                        "<span class=\"token php language-php\">" +
                        Prism.highlight(t, env.grammar, 'php').replace(/\$/g, '$$$$') +
                        "</span>");
            }

            env.element.innerHTML = env.highlightedCode;
        });
    };


    /*------------------------------------------------------------*/

    Prism.languages.powershell = {
        'comment': [
            {
                pattern: /(^|[^`])<#[\s\S]*?#>/,
                lookbehind: true
            },
            {
                pattern: /(^|[^`])#.*/,
                lookbehind: true
            }
        ],
        'string': [
            {
                pattern: /"(`?[\s\S])*?"/,
                greedy: true,
                inside: {
                    'function': {
                        pattern: /[^`]\$\(.*?\)/,
                        // Populated at end of file
                        inside: {}
                    }
                }
            },
            {
                pattern: /'([^']|'')*'/,
                greedy: true
            }
        ],
        // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
        'namespace': /\[[a-z][\s\S]*?\]/i,
        'boolean': /\$(true|false)\b/i,
        'variable': /\$\w+\b/i,
        // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
        // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
        // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
        'function': [
            /\b(Add-(Computer|Content|History|Member|PSSnapin|Type)|Checkpoint-Computer|Clear-(Content|EventLog|History|Item|ItemProperty|Variable)|Compare-Object|Complete-Transaction|Connect-PSSession|ConvertFrom-(Csv|Json|StringData)|Convert-Path|ConvertTo-(Csv|Html|Json|Xml)|Copy-(Item|ItemProperty)|Debug-Process|Disable-(ComputerRestore|PSBreakpoint|PSRemoting|PSSessionConfiguration)|Disconnect-PSSession|Enable-(ComputerRestore|PSBreakpoint|PSRemoting|PSSessionConfiguration)|Enter-PSSession|Exit-PSSession|Export-(Alias|Clixml|Console|Csv|FormatData|ModuleMember|PSSession)|ForEach-Object|Format-(Custom|List|Table|Wide)|Get-(Alias|ChildItem|Command|ComputerRestorePoint|Content|ControlPanelItem|Culture|Date|Event|EventLog|EventSubscriber|FormatData|Help|History|Host|HotFix|Item|ItemProperty|Job|Location|Member|Module|Process|PSBreakpoint|PSCallStack|PSDrive|PSProvider|PSSession|PSSessionConfiguration|PSSnapin|Random|Service|TraceSource|Transaction|TypeData|UICulture|Unique|Variable|WmiObject)|Group-Object|Import-(Alias|Clixml|Csv|LocalizedData|Module|PSSession)|Invoke-(Command|Expression|History|Item|RestMethod|WebRequest|WmiMethod)|Join-Path|Limit-EventLog|Measure-(Command|Object)|Move-(Item|ItemProperty)|New-(Alias|Event|EventLog|Item|ItemProperty|Module|ModuleManifest|Object|PSDrive|PSSession|PSSessionConfigurationFile|PSSessionOption|PSTransportOption|Service|TimeSpan|Variable|WebServiceProxy)|Out-(Default|File|GridView|Host|Null|Printer|String)|Pop-Location|Push-Location|Read-Host|Receive-(Job|PSSession)|Register-(EngineEvent|ObjectEvent|PSSessionConfiguration|WmiEvent)|Remove-(Computer|Event|EventLog|Item|ItemProperty|Job|Module|PSBreakpoint|PSDrive|PSSession|PSSnapin|TypeData|Variable|WmiObject)|Rename-(Computer|Item|ItemProperty)|Reset-ComputerMachinePassword|Resolve-Path|Restart-(Computer|Service)|Restore-Computer|Resume-(Job|Service)|Save-Help|Select-(Object|String|Xml)|Send-MailMessage|Set-(Alias|Content|Date|Item|ItemProperty|Location|PSBreakpoint|PSDebug|PSSessionConfiguration|Service|StrictMode|TraceSource|Variable|WmiInstance)|Show-(Command|ControlPanelItem|EventLog)|Sort-Object|Split-Path|Start-(Job|Process|Service|Sleep|Transaction)|Stop-(Computer|Job|Process|Service)|Suspend-(Job|Service)|Tee-Object|Test-(ComputerSecureChannel|Connection|ModuleManifest|Path|PSSessionConfigurationFile)|Trace-Command|Unblock-File|Undo-Transaction|Unregister-(Event|PSSessionConfiguration)|Update-(FormatData|Help|List|TypeData)|Use-Transaction|Wait-(Event|Job|Process)|Where-Object|Write-(Debug|Error|EventLog|Host|Output|Progress|Verbose|Warning))\b/i,
            /\b(ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
        ],
        // per http://technet.microsoft.com/en-us/library/hh847744.aspx
        'keyword': /\b(Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
        'operator': {
            pattern: /(\W?)(!|-(eq|ne|gt|ge|lt|le|sh[lr]|not|b?(and|x?or)|(Not)?(Like|Match|Contains|In)|Replace|Join|is(Not)?|as)\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
            lookbehind: true
        },
        'punctuation': /[|{}[\];(),.]/
    };

    // Variable interpolation inside strings, and nested expressions
    Prism.languages.powershell.string[0].inside.boolean = Prism.languages.powershell.boolean;
    Prism.languages.powershell.string[0].inside.variable = Prism.languages.powershell.variable;
    Prism.languages.powershell.string[0].inside.function.inside = Prism.util.clone(Prism.languages.powershell);

    /*------------------------------------------------------------*/


    Prism.languages.python= {
        'triple-quoted-string': {
            pattern: /"""[\s\S]+?"""|'''[\s\S]+?'''/,
            alias: 'string'
        },
        'comment': {
            pattern: /(^|[^\\])#.*/,
            lookbehind: true
        },
        'string': {
            pattern: /("|')(?:\\\\|\\?[^\\\r\n])*?\1/,
            greedy: true
        },
        'function' : {
            pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_][a-zA-Z0-9_]*(?=\()/g,
            lookbehind: true
        },
        'class-name': {
            pattern: /(\bclass\s+)[a-z0-9_]+/i,
            lookbehind: true
        },
        'keyword' : /\b(?:as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|pass|print|raise|return|try|while|with|yield)\b/,
        'boolean' : /\b(?:True|False)\b/,
        'number' : /\b-?(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
        'operator' : /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
        'punctuation' : /[{}[\];(),.:]/
    };

    Prism.languages.r = {
        'comment': /#.*/,
        'string': {
            pattern: /(['"])(?:\\?.)*?\1/,
            greedy: true
        },
        'percent-operator': {
            // Includes user-defined operators
            // and %%, %*%, %/%, %in%, %o%, %x%
            pattern: /%[^%\s]*%/,
            alias: 'operator'
        },
        'boolean': /\b(?:TRUE|FALSE)\b/,
        'ellipsis': /\.\.(?:\.|\d+)/,
        'number': [
            /\b(?:NaN|Inf)\b/,
            /\b(?:0x[\dA-Fa-f]+(?:\.\d*)?|\d*\.?\d+)(?:[EePp][+-]?\d+)?[iL]?\b/
        ],
        'keyword': /\b(?:if|else|repeat|while|function|for|in|next|break|NULL|NA|NA_integer_|NA_real_|NA_complex_|NA_character_)\b/,
        'operator': /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
        'punctuation': /[(){}\[\],;]/
    };

    /*------------------------------------------------------------*/

    Prism.languages.rust = {
        'comment': [
            {
                pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
                lookbehind: true
            },
            {
                pattern: /(^|[^\\:])\/\/.*/,
                lookbehind: true
            }
        ],
        'string': [
            {
                pattern: /b?r(#*)"(?:\\?.)*?"\1/,
                greedy: true
            },
            {
                pattern: /b?("|')(?:\\?.)*?\1/,
                greedy: true
            }
        ],
        'keyword': /\b(?:abstract|alignof|as|be|box|break|const|continue|crate|do|else|enum|extern|false|final|fn|for|if|impl|in|let|loop|match|mod|move|mut|offsetof|once|override|priv|pub|pure|ref|return|sizeof|static|self|struct|super|true|trait|type|typeof|unsafe|unsized|use|virtual|where|while|yield)\b/,

        'attribute': {
            pattern: /#!?\[.+?\]/,
            greedy: true,
            alias: 'attr-name'
        },

        'function': [
            /[a-z0-9_]+(?=\s*\()/i,
            // Macros can use parens or brackets
            /[a-z0-9_]+!(?=\s*\(|\[)/i
        ],
        'macro-rules': {
            pattern: /[a-z0-9_]+!/i,
            alias: 'function'
        },

        // Hex, oct, bin, dec numbers with visual separators and type suffix
        'number': /\b-?(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(\d(_?\d)*)?\.?\d(_?\d)*([Ee][+-]?\d+)?)(?:_?(?:[iu](?:8|16|32|64)?|f32|f64))?\b/,

        // Closure params should not be confused with bitwise OR |
        'closure-params': {
            pattern: /\|[^|]*\|(?=\s*[{-])/,
            inside: {
                'punctuation': /[\|:,]/,
                'operator': /[&*]/
            }
        },
        'punctuation': /[{}[\];(),:]|\.+|->/,
        'operator': /[-+*\/%!^=]=?|@|&[&=]?|\|[|=]?|<<?=?|>>?=?/
    };

    /*------------------------------------------------------------*/

    ;(function(Prism) {
        Prism.languages.sass = Prism.languages.extend('css', {
            // Sass comments don't need to be closed, only indented
            'comment': {
                pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t]+.+)*/m,
                lookbehind: true
            }
        });

        Prism.languages.insertBefore('sass', 'atrule', {
            // We want to consume the whole line
            'atrule-line': {
                // Includes support for = and + shortcuts
                pattern: /^(?:[ \t]*)[@+=].+/m,
                inside: {
                    'atrule': /(?:@[\w-]+|[+=])/m
                }
            }
        });
        delete Prism.languages.sass.atrule;


        var variable = /((\$[-_\w]+)|(#\{\$[-_\w]+\}))/i;
        var operator = [
            /[+*\/%]|[=!]=|<=?|>=?|\b(?:and|or|not)\b/,
            {
                pattern: /(\s+)-(?=\s)/,
                lookbehind: true
            }
        ];

        Prism.languages.insertBefore('sass', 'property', {
            // We want to consume the whole line
            'variable-line': {
                pattern: /^[ \t]*\$.+/m,
                inside: {
                    'punctuation': /:/,
                    'variable': variable,
                    'operator': operator
                }
            },
            // We want to consume the whole line
            'property-line': {
                pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s]+.*)/m,
                inside: {
                    'property': [
                        /[^:\s]+(?=\s*:)/,
                        {
                            pattern: /(:)[^:\s]+/,
                            lookbehind: true
                        }
                    ],
                    'punctuation': /:/,
                    'variable': variable,
                    'operator': operator,
                    'important': Prism.languages.sass.important
                }
            }
        });
        delete Prism.languages.sass.property;
        delete Prism.languages.sass.important;

        // Now that whole lines for other patterns are consumed,
        // what's left should be selectors
        delete Prism.languages.sass.selector;
        Prism.languages.insertBefore('sass', 'punctuation', {
            'selector': {
                pattern: /([ \t]*)\S(?:,?[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,?[^,\r\n]+)*)*/,
                lookbehind: true
            }
        });

    }(Prism));
    Prism.languages.scss = Prism.languages.extend('css', {
        'comment': {
            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
            lookbehind: true
        },
        'atrule': {
            pattern: /@[\w-]+(?:\([^()]+\)|[^(])*?(?=\s+[{;])/,
            inside: {
                'rule': /@[\w-]+/
                // See rest below
            }
        },
        // url, compassified
        'url': /(?:[-a-z]+-)*url(?=\()/i,
        // CSS selector regex is not appropriate for Sass
        // since there can be lot more things (var, @ directive, nesting..)
        // a selector must start at the end of a property or after a brace (end of other rules or nesting)
        // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
        // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
        // can "pass" as a selector- e.g: proper#{$erty})
        // this one was hard to do, so please be careful if you edit this one :)
        'selector': {
            // Initial look-ahead is used to prevent matching of blank selectors
            pattern: /(?=\S)[^@;\{\}\(\)]?([^@;\{\}\(\)]|&|#\{\$[-_\w]+\})+(?=\s*\{(\}|\s|[^\}]+(:|\{)[^\}]+))/m,
            inside: {
                'parent': {
                    pattern: /&/,
                    alias: 'important'
                },
                'placeholder': /%[-_\w]+/,
                'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
            }
        }
    });

    Prism.languages.insertBefore('scss', 'atrule', {
        'keyword': [
            /@(?:if|else(?: if)?|for|each|while|import|extend|debug|warn|mixin|include|function|return|content)/i,
            {
                pattern: /( +)(?:from|through)(?= )/,
                lookbehind: true
            }
        ]
    });

    Prism.languages.scss.property = {
        pattern: /(?:[\w-]|\$[-_\w]+|#\{\$[-_\w]+\})+(?=\s*:)/i,
        inside: {
            'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
        }
    };

    Prism.languages.insertBefore('scss', 'important', {
        // var and interpolated vars
        'variable': /\$[-_\w]+|#\{\$[-_\w]+\}/
    });

    Prism.languages.insertBefore('scss', 'function', {
        'placeholder': {
            pattern: /%[-_\w]+/,
            alias: 'selector'
        },
        'statement': {
            pattern: /\B!(?:default|optional)\b/i,
            alias: 'keyword'
        },
        'boolean': /\b(?:true|false)\b/,
        'null': /\bnull\b/,
        'operator': {
            pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|or|not)(?=\s)/,
            lookbehind: true
        }
    });

    Prism.languages.scss['atrule'].inside.rest = Prism.util.clone(Prism.languages.scss);

    /*-----------------------------smarty-------------------------*/

    ;(function(Prism) {

        var smarty_pattern = /\{\*[\s\S]+?\*\}|\{[\s\S]+?\}/g;
        var smarty_litteral_start = '{literal}';
        var smarty_litteral_end = '{/literal}';
        var smarty_litteral_mode = false;

        Prism.languages.smarty = Prism.languages.extend('markup', {
            'smarty': {
                pattern: smarty_pattern,
                inside: {
                    'delimiter': {
                        pattern: /^\{|\}$/i,
                        alias: 'punctuation'
                    },
                    'string': /(["'])(?:\\?.)*?\1/,
                    'number': /\b-?(?:0x[\dA-Fa-f]+|\d*\.?\d+(?:[Ee][-+]?\d+)?)\b/,
                    'variable': [
                        /\$(?!\d)\w+/,
                        /#(?!\d)\w+#/,
                        {
                            pattern: /(\.|->)(?!\d)\w+/,
                            lookbehind: true
                        },
                        {
                            pattern: /(\[)(?!\d)\w+(?=\])/,
                            lookbehind: true
                        }
                    ],
                    'function': [
                        {
                            pattern: /(\|\s*)@?(?!\d)\w+/,
                            lookbehind: true
                        },
                        /^\/?(?!\d)\w+/,
                        /(?!\d)\w+(?=\()/
                    ],
                    'attr-name': {
                        // Value is made optional because it may have already been tokenized
                        pattern: /\w+\s*=\s*(?:(?!\d)\w+)?/,
                        inside: {
                            "variable": {
                                pattern: /(=\s*)(?!\d)\w+/,
                                lookbehind: true
                            },
                            "operator": /=/
                        }
                    },
                    'punctuation': [
                        /[\[\]().,:`]|\->/
                    ],
                    'operator': [
                        /[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
                        /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
                        /\b(?:eq|neq?|gt|lt|gt?e|lt?e|not|mod|or|and)\b/
                    ],
                    'keyword': /\b(?:false|off|on|no|true|yes)\b/
                }
            }
        });

        // Comments are inserted at top so that they can
        // surround markup
        Prism.languages.insertBefore('smarty', 'tag', {
            'smarty-comment': {
                pattern: /\{\*[\s\S]*?\*\}/,
                alias: ['smarty','comment']
            }
        });

        // Tokenize all inline Smarty expressions
        Prism.hooks.add('before-highlight', function(env) {
            if (env.language !== 'smarty') {
                return;
            }

            env.tokenStack = [];

            env.backupCode = env.code;
            env.code = env.code.replace(smarty_pattern, function(match) {

                // Smarty tags inside {literal} block are ignored
                if(match === smarty_litteral_end) {
                    smarty_litteral_mode = false;
                }

                if(!smarty_litteral_mode) {
                    if(match === smarty_litteral_start) {
                        smarty_litteral_mode = true;
                    }

                    var i = env.tokenStack.length;
                    // Check for existing strings
                    while (env.backupCode.indexOf('___SMARTY' + i + '___') !== -1)
                        ++i;

                    // Create a sparse array
                    env.tokenStack[i] = match;

                    return '___SMARTY' + i + '___';
                }
                return match;
            });
        });

        // Restore env.code for other plugins (e.g. line-numbers)
        Prism.hooks.add('before-insert', function(env) {
            if (env.language === 'smarty') {
                env.code = env.backupCode;
                delete env.backupCode;
            }
        });

        // Re-insert the tokens after highlighting
        // and highlight them with defined grammar
        Prism.hooks.add('after-highlight', function(env) {
            if (env.language !== 'smarty') {
                return;
            }

            for (var i = 0, keys = Object.keys(env.tokenStack); i < keys.length; ++i) {
                var k = keys[i];
                var t = env.tokenStack[k];

                // The replace prevents $$, $&, $`, $', $n, $nn from being interpreted as special patterns
                env.highlightedCode = env.highlightedCode.replace('___SMARTY' + k + '___', Prism.highlight(t, env.grammar, 'smarty').replace(/\$/g, '$$$$'));
            }

            env.element.innerHTML = env.highlightedCode;
        });

    }(Prism));

    /*-----------------------------------------------------------*/

    Prism.languages.sql= {
        'comment': {
            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
            lookbehind: true
        },
        'string' : {
            pattern: /(^|[^@\\])("|')(?:\\?[\s\S])*?\2/,
            greedy: true,
            lookbehind: true
        },
        'variable': /@[\w.$]+|@("|'|`)(?:\\?[\s\S])+?\1/,
        'function': /\b(?:COUNT|SUM|AVG|MIN|MAX|FIRST|LAST|UCASE|LCASE|MID|LEN|ROUND|NOW|FORMAT)(?=\s*\()/i, // Should we highlight user defined functions too?
        'keyword': /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR VARYING|CHARACTER (?:SET|VARYING)|CHARSET|CHECK|CHECKPOINT|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMN|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS|CONTAINSTABLE|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|DATA(?:BASES?)?|DATE(?:TIME)?|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITER(?:S)?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE(?: PRECISION)?|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE KEY|ELSE|ENABLE|ENCLOSED BY|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPE(?:D BY)?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTO|INVOKER|ISOLATION LEVEL|JOIN|KEYS?|KILL|LANGUAGE SQL|LAST|LEFT|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MODIFIES SQL DATA|MODIFY|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL(?: CHAR VARYING| CHARACTER(?: VARYING)?| VARCHAR)?|NATURAL|NCHAR(?: VARCHAR)?|NEXT|NO(?: SQL|CHECK|CYCLE)?|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READ(?:S SQL DATA|TEXT)?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEATABLE|REPLICATION|REQUIRE|RESTORE|RESTRICT|RETURNS?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE MODE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|START(?:ING BY)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED BY|TEXT(?:SIZE)?|THEN|TIMESTAMP|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNPIVOT|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?)\b/i,
        'boolean': /\b(?:TRUE|FALSE|NULL)\b/i,
        'number': /\b-?(?:0x)?\d*\.?[\da-f]+\b/,
        'operator': /[-+*\/=%^~]|&&?|\|?\||!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|IN|LIKE|NOT|OR|IS|DIV|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
        'punctuation': /[;[\]()`,.]/
    };

    /*-----------------------------------------------------------*/

    Prism.languages.swift = Prism.languages.extend('clike', {
        'string': {
            pattern: /("|')(\\(?:\((?:[^()]|\([^)]+\))+\)|\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
            greedy: true,
            inside: {
                'interpolation': {
                    pattern: /\\\((?:[^()]|\([^)]+\))+\)/,
                    inside: {
                        delimiter: {
                            pattern: /^\\\(|\)$/,
                            alias: 'variable'
                        }
                        // See rest below
                    }
                }
            }
        },
        'keyword': /\b(as|associativity|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic(?:Type)?|else|enum|extension|fallthrough|final|for|func|get|guard|if|import|in|infix|init|inout|internal|is|lazy|left|let|mutating|new|none|nonmutating|operator|optional|override|postfix|precedence|prefix|private|Protocol|public|repeat|required|rethrows|return|right|safe|self|Self|set|static|struct|subscript|super|switch|throws?|try|Type|typealias|unowned|unsafe|var|weak|where|while|willSet|__(?:COLUMN__|FILE__|FUNCTION__|LINE__))\b/,
        'number': /\b([\d_]+(\.[\de_]+)?|0x[a-f0-9_]+(\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
        'constant': /\b(nil|[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
        'atrule': /@\b(IB(?:Outlet|Designable|Action|Inspectable)|class_protocol|exported|noreturn|NS(?:Copying|Managed)|objc|UIApplicationMain|auto_closure)\b/,
        'builtin': /\b([A-Z]\S+|abs|advance|alignof(?:Value)?|assert|contains|count(?:Elements)?|debugPrint(?:ln)?|distance|drop(?:First|Last)|dump|enumerate|equal|filter|find|first|getVaList|indices|isEmpty|join|last|lexicographicalCompare|map|max(?:Element)?|min(?:Element)?|numericCast|overlaps|partition|print(?:ln)?|reduce|reflect|reverse|sizeof(?:Value)?|sort(?:ed)?|split|startsWith|stride(?:of(?:Value)?)?|suffix|swap|toDebugString|toString|transcode|underestimateCount|unsafeBitCast|with(?:ExtendedLifetime|Unsafe(?:MutablePointers?|Pointers?)|VaList))\b/
    });
    Prism.languages.swift['string'].inside['interpolation'].inside.rest = Prism.util.clone(Prism.languages.swift);
    Prism.languages.typescript = Prism.languages.extend('javascript', {
        // From JavaScript Prism keyword list and TypeScript language spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words
        'keyword': /\b(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|var|void|while|with|yield|false|true|module|declare|constructor|string|Function|any|number|boolean|Array|enum|symbol|namespace|abstract|require|type)\b/
    });

    Prism.languages.ts = Prism.languages.typescript;
    Prism.languages.vim = {
        'string': /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\r\n]|'')*'/,
        'comment': /".*/,
        'function': /\w+(?=\()/,
        'keyword': /\b(?:ab|abbreviate|abc|abclear|abo|aboveleft|al|all|arga|argadd|argd|argdelete|argdo|arge|argedit|argg|argglobal|argl|arglocal|ar|args|argu|argument|as|ascii|bad|badd|ba|ball|bd|bdelete|be|bel|belowright|bf|bfirst|bl|blast|bm|bmodified|bn|bnext|bN|bNext|bo|botright|bp|bprevious|brea|break|breaka|breakadd|breakd|breakdel|breakl|breaklist|br|brewind|bro|browse|bufdo|b|buffer|buffers|bun|bunload|bw|bwipeout|ca|cabbrev|cabc|cabclear|caddb|caddbuffer|cad|caddexpr|caddf|caddfile|cal|call|cat|catch|cb|cbuffer|cc|ccl|cclose|cd|ce|center|cex|cexpr|cf|cfile|cfir|cfirst|cgetb|cgetbuffer|cgete|cgetexpr|cg|cgetfile|c|change|changes|chd|chdir|che|checkpath|checkt|checktime|cla|clast|cl|clist|clo|close|cmapc|cmapclear|cnew|cnewer|cn|cnext|cN|cNext|cnf|cnfile|cNfcNfile|cnorea|cnoreabbrev|col|colder|colo|colorscheme|comc|comclear|comp|compiler|conf|confirm|con|continue|cope|copen|co|copy|cpf|cpfile|cp|cprevious|cq|cquit|cr|crewind|cuna|cunabbrev|cu|cunmap|cw|cwindow|debugg|debuggreedy|delc|delcommand|d|delete|delf|delfunction|delm|delmarks|diffg|diffget|diffoff|diffpatch|diffpu|diffput|diffsplit|diffthis|diffu|diffupdate|dig|digraphs|di|display|dj|djump|dl|dlist|dr|drop|ds|dsearch|dsp|dsplit|earlier|echoe|echoerr|echom|echomsg|echon|e|edit|el|else|elsei|elseif|em|emenu|endfo|endfor|endf|endfunction|endfun|en|endif|endt|endtry|endw|endwhile|ene|enew|ex|exi|exit|exu|exusage|f|file|files|filetype|fina|finally|fin|find|fini|finish|fir|first|fix|fixdel|fo|fold|foldc|foldclose|folddoc|folddoclosed|foldd|folddoopen|foldo|foldopen|for|fu|fun|function|go|goto|gr|grep|grepa|grepadd|ha|hardcopy|h|help|helpf|helpfind|helpg|helpgrep|helpt|helptags|hid|hide|his|history|ia|iabbrev|iabc|iabclear|if|ij|ijump|il|ilist|imapc|imapclear|in|inorea|inoreabbrev|isearch|isp|isplit|iuna|iunabbrev|iu|iunmap|j|join|ju|jumps|k|keepalt|keepj|keepjumps|kee|keepmarks|laddb|laddbuffer|lad|laddexpr|laddf|laddfile|lan|language|la|last|later|lb|lbuffer|lc|lcd|lch|lchdir|lcl|lclose|let|left|lefta|leftabove|lex|lexpr|lf|lfile|lfir|lfirst|lgetb|lgetbuffer|lgete|lgetexpr|lg|lgetfile|lgr|lgrep|lgrepa|lgrepadd|lh|lhelpgrep|l|list|ll|lla|llast|lli|llist|lmak|lmake|lm|lmap|lmapc|lmapclear|lnew|lnewer|lne|lnext|lN|lNext|lnf|lnfile|lNf|lNfile|ln|lnoremap|lo|loadview|loc|lockmarks|lockv|lockvar|lol|lolder|lop|lopen|lpf|lpfile|lp|lprevious|lr|lrewind|ls|lt|ltag|lu|lunmap|lv|lvimgrep|lvimgrepa|lvimgrepadd|lw|lwindow|mak|make|ma|mark|marks|mat|match|menut|menutranslate|mk|mkexrc|mks|mksession|mksp|mkspell|mkvie|mkview|mkv|mkvimrc|mod|mode|m|move|mzf|mzfile|mz|mzscheme|nbkey|new|n|next|N|Next|nmapc|nmapclear|noh|nohlsearch|norea|noreabbrev|nu|number|nun|nunmap|omapc|omapclear|on|only|o|open|opt|options|ou|ounmap|pc|pclose|ped|pedit|pe|perl|perld|perldo|po|pop|popu|popu|popup|pp|ppop|pre|preserve|prev|previous|p|print|P|Print|profd|profdel|prof|profile|promptf|promptfind|promptr|promptrepl|ps|psearch|pta|ptag|ptf|ptfirst|ptj|ptjump|ptl|ptlast|ptn|ptnext|ptN|ptNext|ptp|ptprevious|ptr|ptrewind|pts|ptselect|pu|put|pw|pwd|pyf|pyfile|py|python|qa|qall|q|quit|quita|quitall|r|read|rec|recover|redi|redir|red|redo|redr|redraw|redraws|redrawstatus|reg|registers|res|resize|ret|retab|retu|return|rew|rewind|ri|right|rightb|rightbelow|rub|ruby|rubyd|rubydo|rubyf|rubyfile|ru|runtime|rv|rviminfo|sal|sall|san|sandbox|sa|sargument|sav|saveas|sba|sball|sbf|sbfirst|sbl|sblast|sbm|sbmodified|sbn|sbnext|sbN|sbNext|sbp|sbprevious|sbr|sbrewind|sb|sbuffer|scripte|scriptencoding|scrip|scriptnames|se|set|setf|setfiletype|setg|setglobal|setl|setlocal|sf|sfind|sfir|sfirst|sh|shell|sign|sil|silent|sim|simalt|sla|slast|sl|sleep|sm|smagic|sm|smap|smapc|smapclear|sme|smenu|sn|snext|sN|sNext|sni|sniff|sno|snomagic|snor|snoremap|snoreme|snoremenu|sor|sort|so|source|spelld|spelldump|spe|spellgood|spelli|spellinfo|spellr|spellrepall|spellu|spellundo|spellw|spellwrong|sp|split|spr|sprevious|sre|srewind|sta|stag|startg|startgreplace|star|startinsert|startr|startreplace|stj|stjump|st|stop|stopi|stopinsert|sts|stselect|sun|sunhide|sunm|sunmap|sus|suspend|sv|sview|syncbind|t|tab|tabc|tabclose|tabd|tabdo|tabe|tabedit|tabf|tabfind|tabfir|tabfirst|tabl|tablast|tabm|tabmove|tabnew|tabn|tabnext|tabN|tabNext|tabo|tabonly|tabp|tabprevious|tabr|tabrewind|tabs|ta|tag|tags|tc|tcl|tcld|tcldo|tclf|tclfile|te|tearoff|tf|tfirst|th|throw|tj|tjump|tl|tlast|tm|tm|tmenu|tn|tnext|tN|tNext|to|topleft|tp|tprevious|tr|trewind|try|ts|tselect|tu|tu|tunmenu|una|unabbreviate|u|undo|undoj|undojoin|undol|undolist|unh|unhide|unlet|unlo|unlockvar|unm|unmap|up|update|verb|verbose|ve|version|vert|vertical|vie|view|vim|vimgrep|vimgrepa|vimgrepadd|vi|visual|viu|viusage|vmapc|vmapclear|vne|vnew|vs|vsplit|vu|vunmap|wa|wall|wh|while|winc|wincmd|windo|winp|winpos|win|winsize|wn|wnext|wN|wNext|wp|wprevious|wq|wqa|wqall|w|write|ws|wsverb|wv|wviminfo|X|xa|xall|x|xit|xm|xmap|xmapc|xmapclear|xme|xmenu|XMLent|XMLns|xn|xnoremap|xnoreme|xnoremenu|xu|xunmap|y|yank)\b/,
        'builtin': /\b(?:autocmd|acd|ai|akm|aleph|allowrevins|altkeymap|ambiwidth|ambw|anti|antialias|arab|arabic|arabicshape|ari|arshape|autochdir|autoindent|autoread|autowrite|autowriteall|aw|awa|background|backspace|backup|backupcopy|backupdir|backupext|backupskip|balloondelay|ballooneval|balloonexpr|bdir|bdlay|beval|bex|bexpr|bg|bh|bin|binary|biosk|bioskey|bk|bkc|bomb|breakat|brk|browsedir|bs|bsdir|bsk|bt|bufhidden|buflisted|buftype|casemap|ccv|cdpath|cedit|cfu|ch|charconvert|ci|cin|cindent|cink|cinkeys|cino|cinoptions|cinw|cinwords|clipboard|cmdheight|cmdwinheight|cmp|cms|columns|com|comments|commentstring|compatible|complete|completefunc|completeopt|consk|conskey|copyindent|cot|cpo|cpoptions|cpt|cscopepathcomp|cscopeprg|cscopequickfix|cscopetag|cscopetagorder|cscopeverbose|cspc|csprg|csqf|cst|csto|csverb|cuc|cul|cursorcolumn|cursorline|cwh|debug|deco|def|define|delcombine|dex|dg|dict|dictionary|diff|diffexpr|diffopt|digraph|dip|dir|directory|dy|ea|ead|eadirection|eb|ed|edcompatible|ef|efm|ei|ek|enc|encoding|endofline|eol|ep|equalalways|equalprg|errorbells|errorfile|errorformat|esckeys|et|eventignore|expandtab|exrc|fcl|fcs|fdc|fde|fdi|fdl|fdls|fdm|fdn|fdo|fdt|fen|fenc|fencs|fex|ff|ffs|fileencoding|fileencodings|fileformat|fileformats|fillchars|fk|fkmap|flp|fml|fmr|foldcolumn|foldenable|foldexpr|foldignore|foldlevel|foldlevelstart|foldmarker|foldmethod|foldminlines|foldnestmax|foldtext|formatexpr|formatlistpat|formatoptions|formatprg|fp|fs|fsync|ft|gcr|gd|gdefault|gfm|gfn|gfs|gfw|ghr|gp|grepformat|grepprg|gtl|gtt|guicursor|guifont|guifontset|guifontwide|guiheadroom|guioptions|guipty|guitablabel|guitabtooltip|helpfile|helpheight|helplang|hf|hh|hi|hidden|highlight|hk|hkmap|hkmapp|hkp|hl|hlg|hls|hlsearch|ic|icon|iconstring|ignorecase|im|imactivatekey|imak|imc|imcmdline|imd|imdisable|imi|iminsert|ims|imsearch|inc|include|includeexpr|incsearch|inde|indentexpr|indentkeys|indk|inex|inf|infercase|insertmode|isf|isfname|isi|isident|isk|iskeyword|isprint|joinspaces|js|key|keymap|keymodel|keywordprg|km|kmp|kp|langmap|langmenu|laststatus|lazyredraw|lbr|lcs|linebreak|lines|linespace|lisp|lispwords|listchars|loadplugins|lpl|lsp|lz|macatsui|magic|makeef|makeprg|matchpairs|matchtime|maxcombine|maxfuncdepth|maxmapdepth|maxmem|maxmempattern|maxmemtot|mco|mef|menuitems|mfd|mh|mis|mkspellmem|ml|mls|mm|mmd|mmp|mmt|modeline|modelines|modifiable|modified|more|mouse|mousef|mousefocus|mousehide|mousem|mousemodel|mouses|mouseshape|mouset|mousetime|mp|mps|msm|mzq|mzquantum|nf|nrformats|numberwidth|nuw|odev|oft|ofu|omnifunc|opendevice|operatorfunc|opfunc|osfiletype|pa|para|paragraphs|paste|pastetoggle|patchexpr|patchmode|path|pdev|penc|pex|pexpr|pfn|ph|pheader|pi|pm|pmbcs|pmbfn|popt|preserveindent|previewheight|previewwindow|printdevice|printencoding|printexpr|printfont|printheader|printmbcharset|printmbfont|printoptions|prompt|pt|pumheight|pvh|pvw|qe|quoteescape|readonly|remap|report|restorescreen|revins|rightleft|rightleftcmd|rl|rlc|ro|rs|rtp|ruf|ruler|rulerformat|runtimepath|sbo|sc|scb|scr|scroll|scrollbind|scrolljump|scrolloff|scrollopt|scs|sect|sections|secure|sel|selection|selectmode|sessionoptions|sft|shcf|shellcmdflag|shellpipe|shellquote|shellredir|shellslash|shelltemp|shelltype|shellxquote|shiftround|shiftwidth|shm|shortmess|shortname|showbreak|showcmd|showfulltag|showmatch|showmode|showtabline|shq|si|sidescroll|sidescrolloff|siso|sj|slm|smartcase|smartindent|smarttab|smc|smd|softtabstop|sol|spc|spell|spellcapcheck|spellfile|spelllang|spellsuggest|spf|spl|splitbelow|splitright|sps|sr|srr|ss|ssl|ssop|stal|startofline|statusline|stl|stmp|su|sua|suffixes|suffixesadd|sw|swapfile|swapsync|swb|swf|switchbuf|sws|sxq|syn|synmaxcol|syntax|tabline|tabpagemax|tabstop|tagbsearch|taglength|tagrelative|tagstack|tal|tb|tbi|tbidi|tbis|tbs|tenc|term|termbidi|termencoding|terse|textauto|textmode|textwidth|tgst|thesaurus|tildeop|timeout|timeoutlen|title|titlelen|titleold|titlestring|toolbar|toolbariconsize|top|tpm|tsl|tsr|ttimeout|ttimeoutlen|ttm|tty|ttybuiltin|ttyfast|ttym|ttymouse|ttyscroll|ttytype|tw|tx|uc|ul|undolevels|updatecount|updatetime|ut|vb|vbs|vdir|verbosefile|vfile|viewdir|viewoptions|viminfo|virtualedit|visualbell|vop|wak|warn|wb|wc|wcm|wd|weirdinvert|wfh|wfw|whichwrap|wi|wig|wildchar|wildcharm|wildignore|wildmenu|wildmode|wildoptions|wim|winaltkeys|window|winfixheight|winfixwidth|winheight|winminheight|winminwidth|winwidth|wiv|wiw|wm|wmh|wmnu|wmw|wop|wrap|wrapmargin|wrapscan|writeany|writebackup|writedelay|ww|noacd|noai|noakm|noallowrevins|noaltkeymap|noanti|noantialias|noar|noarab|noarabic|noarabicshape|noari|noarshape|noautochdir|noautoindent|noautoread|noautowrite|noautowriteall|noaw|noawa|nobackup|noballooneval|nobeval|nobin|nobinary|nobiosk|nobioskey|nobk|nobl|nobomb|nobuflisted|nocf|noci|nocin|nocindent|nocompatible|noconfirm|noconsk|noconskey|nocopyindent|nocp|nocscopetag|nocscopeverbose|nocst|nocsverb|nocuc|nocul|nocursorcolumn|nocursorline|nodeco|nodelcombine|nodg|nodiff|nodigraph|nodisable|noea|noeb|noed|noedcompatible|noek|noendofline|noeol|noequalalways|noerrorbells|noesckeys|noet|noex|noexpandtab|noexrc|nofen|nofk|nofkmap|nofoldenable|nogd|nogdefault|noguipty|nohid|nohidden|nohk|nohkmap|nohkmapp|nohkp|nohls|noic|noicon|noignorecase|noim|noimc|noimcmdline|noimd|noincsearch|noinf|noinfercase|noinsertmode|nois|nojoinspaces|nojs|nolazyredraw|nolbr|nolinebreak|nolisp|nolist|noloadplugins|nolpl|nolz|noma|nomacatsui|nomagic|nomh|noml|nomod|nomodeline|nomodifiable|nomodified|nomore|nomousef|nomousefocus|nomousehide|nonu|nonumber|noodev|noopendevice|nopaste|nopi|nopreserveindent|nopreviewwindow|noprompt|nopvw|noreadonly|noremap|norestorescreen|norevins|nori|norightleft|norightleftcmd|norl|norlc|noro|nors|noru|noruler|nosb|nosc|noscb|noscrollbind|noscs|nosecure|nosft|noshellslash|noshelltemp|noshiftround|noshortname|noshowcmd|noshowfulltag|noshowmatch|noshowmode|nosi|nosm|nosmartcase|nosmartindent|nosmarttab|nosmd|nosn|nosol|nospell|nosplitbelow|nosplitright|nospr|nosr|nossl|nosta|nostartofline|nostmp|noswapfile|noswf|nota|notagbsearch|notagrelative|notagstack|notbi|notbidi|notbs|notermbidi|noterse|notextauto|notextmode|notf|notgst|notildeop|notimeout|notitle|noto|notop|notr|nottimeout|nottybuiltin|nottyfast|notx|novb|novisualbell|nowa|nowarn|nowb|noweirdinvert|nowfh|nowfw|nowildmenu|nowinfixheight|nowinfixwidth|nowiv|nowmnu|nowrap|nowrapscan|nowrite|nowriteany|nowritebackup|nows|invacd|invai|invakm|invallowrevins|invaltkeymap|invanti|invantialias|invar|invarab|invarabic|invarabicshape|invari|invarshape|invautochdir|invautoindent|invautoread|invautowrite|invautowriteall|invaw|invawa|invbackup|invballooneval|invbeval|invbin|invbinary|invbiosk|invbioskey|invbk|invbl|invbomb|invbuflisted|invcf|invci|invcin|invcindent|invcompatible|invconfirm|invconsk|invconskey|invcopyindent|invcp|invcscopetag|invcscopeverbose|invcst|invcsverb|invcuc|invcul|invcursorcolumn|invcursorline|invdeco|invdelcombine|invdg|invdiff|invdigraph|invdisable|invea|inveb|inved|invedcompatible|invek|invendofline|inveol|invequalalways|inverrorbells|invesckeys|invet|invex|invexpandtab|invexrc|invfen|invfk|invfkmap|invfoldenable|invgd|invgdefault|invguipty|invhid|invhidden|invhk|invhkmap|invhkmapp|invhkp|invhls|invhlsearch|invic|invicon|invignorecase|invim|invimc|invimcmdline|invimd|invincsearch|invinf|invinfercase|invinsertmode|invis|invjoinspaces|invjs|invlazyredraw|invlbr|invlinebreak|invlisp|invlist|invloadplugins|invlpl|invlz|invma|invmacatsui|invmagic|invmh|invml|invmod|invmodeline|invmodifiable|invmodified|invmore|invmousef|invmousefocus|invmousehide|invnu|invnumber|invodev|invopendevice|invpaste|invpi|invpreserveindent|invpreviewwindow|invprompt|invpvw|invreadonly|invremap|invrestorescreen|invrevins|invri|invrightleft|invrightleftcmd|invrl|invrlc|invro|invrs|invru|invruler|invsb|invsc|invscb|invscrollbind|invscs|invsecure|invsft|invshellslash|invshelltemp|invshiftround|invshortname|invshowcmd|invshowfulltag|invshowmatch|invshowmode|invsi|invsm|invsmartcase|invsmartindent|invsmarttab|invsmd|invsn|invsol|invspell|invsplitbelow|invsplitright|invspr|invsr|invssl|invsta|invstartofline|invstmp|invswapfile|invswf|invta|invtagbsearch|invtagrelative|invtagstack|invtbi|invtbidi|invtbs|invtermbidi|invterse|invtextauto|invtextmode|invtf|invtgst|invtildeop|invtimeout|invtitle|invto|invtop|invtr|invttimeout|invttybuiltin|invttyfast|invtx|invvb|invvisualbell|invwa|invwarn|invwb|invweirdinvert|invwfh|invwfw|invwildmenu|invwinfixheight|invwinfixwidth|invwiv|invwmnu|invwrap|invwrapscan|invwrite|invwriteany|invwritebackup|invws|t_AB|t_AF|t_al|t_AL|t_bc|t_cd|t_ce|t_Ce|t_cl|t_cm|t_Co|t_cs|t_Cs|t_CS|t_CV|t_da|t_db|t_dl|t_DL|t_EI|t_F1|t_F2|t_F3|t_F4|t_F5|t_F6|t_F7|t_F8|t_F9|t_fs|t_IE|t_IS|t_k1|t_K1|t_k2|t_k3|t_K3|t_k4|t_K4|t_k5|t_K5|t_k6|t_K6|t_k7|t_K7|t_k8|t_K8|t_k9|t_K9|t_KA|t_kb|t_kB|t_KB|t_KC|t_kd|t_kD|t_KD|t_ke|t_KE|t_KF|t_KG|t_kh|t_KH|t_kI|t_KI|t_KJ|t_KK|t_kl|t_KL|t_kN|t_kP|t_kr|t_ks|t_ku|t_le|t_mb|t_md|t_me|t_mr|t_ms|t_nd|t_op|t_RI|t_RV|t_Sb|t_se|t_Sf|t_SI|t_so|t_sr|t_te|t_ti|t_ts|t_ue|t_us|t_ut|t_vb|t_ve|t_vi|t_vs|t_WP|t_WS|t_xs|t_ZH|t_ZR)\b/,
        'number': /\b(?:0x[\da-f]+|\d+(?:\.\d+)?)\b/i,
        'operator': /\|\||&&|[-+.]=?|[=!](?:[=~][#?]?)?|[<>]=?[#?]?|[*\/%?]|\b(?:is(?:not)?)\b/,
        'punctuation': /[{}[\](),;:]/
    };

    return Prism
})