diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/hpkp.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hpkp.js new file mode 100644 index 0000000000000000000000000000000000000000..ac011d1ff15aaa178ca64b50cf5d899635a0af2a --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hpkp.js @@ -0,0 +1,25 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +hpkp.displayName = 'hpkp' +hpkp.aliases = [] + +/** @param {Refractor} Prism */ +export default function hpkp(Prism) { + /** + * Original by Scott Helme. + * + * Reference: https://scotthelme.co.uk/hpkp-cheat-sheet/ + */ + + Prism.languages.hpkp = { + directive: { + pattern: + /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i, + alias: 'property' + }, + operator: /=/, + punctuation: /;/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed2165eb207a03b42f9977a4db2bd79518351f71 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function hsts(Prism: any): void; +declare namespace hsts { + let displayName: string; + let aliases: any[]; +} +export default hsts; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.js new file mode 100644 index 0000000000000000000000000000000000000000..45edf2a1ad225523f5b67f60e513256c39f9eeaa --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/hsts.js @@ -0,0 +1,24 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +hsts.displayName = 'hsts' +hsts.aliases = [] + +/** @param {Refractor} Prism */ +export default function hsts(Prism) { + /** + * Original by Scott Helme. + * + * Reference: https://scotthelme.co.uk/hsts-cheat-sheet/ + */ + + Prism.languages.hsts = { + directive: { + pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i, + alias: 'property' + }, + operator: /=/, + punctuation: /;/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d296dbaf6269b1f3663ef4d35e7a3e4cf6dc36d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function http(Prism: any): void; +declare namespace http { + let displayName: string; + let aliases: any[]; +} +export default http; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.js new file mode 100644 index 0000000000000000000000000000000000000000..7652e0110b007ed106cfa6377373cd57b625cd5d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/http.js @@ -0,0 +1,164 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +http.displayName = 'http' +http.aliases = [] + +/** @param {Refractor} Prism */ +export default function http(Prism) { + ;(function (Prism) { + /** + * @param {string} name + * @returns {RegExp} + */ + function headerValueOf(name) { + return RegExp('(^(?:' + name + '):[ \t]*(?![ \t]))[^]+', 'i') + } + Prism.languages.http = { + 'request-line': { + pattern: + /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m, + inside: { + // HTTP Method + method: { + pattern: /^[A-Z]+\b/, + alias: 'property' + }, + // Request Target e.g. http://example.com, /path/to/file + 'request-target': { + pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/, + lookbehind: true, + alias: 'url', + inside: Prism.languages.uri + }, + // HTTP Version + 'http-version': { + pattern: /^(\s)HTTP\/[\d.]+/, + lookbehind: true, + alias: 'property' + } + } + }, + 'response-status': { + pattern: /^HTTP\/[\d.]+ \d+ .+/m, + inside: { + // HTTP Version + 'http-version': { + pattern: /^HTTP\/[\d.]+/, + alias: 'property' + }, + // Status Code + 'status-code': { + pattern: /^(\s)\d+(?=\s)/, + lookbehind: true, + alias: 'number' + }, + // Reason Phrase + 'reason-phrase': { + pattern: /^(\s).+/, + lookbehind: true, + alias: 'string' + } + } + }, + header: { + pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m, + inside: { + 'header-value': [ + { + pattern: headerValueOf(/Content-Security-Policy/.source), + lookbehind: true, + alias: ['csp', 'languages-csp'], + inside: Prism.languages.csp + }, + { + pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source), + lookbehind: true, + alias: ['hpkp', 'languages-hpkp'], + inside: Prism.languages.hpkp + }, + { + pattern: headerValueOf(/Strict-Transport-Security/.source), + lookbehind: true, + alias: ['hsts', 'languages-hsts'], + inside: Prism.languages.hsts + }, + { + pattern: headerValueOf(/[^:]+/.source), + lookbehind: true + } + ], + 'header-name': { + pattern: /^[^:]+/, + alias: 'keyword' + }, + punctuation: /^:/ + } + } + } + + // Create a mapping of Content-Type headers to language definitions + var langs = Prism.languages + var httpLanguages = { + 'application/javascript': langs.javascript, + 'application/json': langs.json || langs.javascript, + 'application/xml': langs.xml, + 'text/xml': langs.xml, + 'text/html': langs.html, + 'text/css': langs.css, + 'text/plain': langs.plain + } + + // Declare which types can also be suffixes + var suffixTypes = { + 'application/json': true, + 'application/xml': true + } + + /** + * Returns a pattern for the given content type which matches it and any type which has it as a suffix. + * + * @param {string} contentType + * @returns {string} + */ + function getSuffixPattern(contentType) { + var suffix = contentType.replace(/^[a-z]+\//, '') + var suffixPattern = '\\w+/(?:[\\w.-]+\\+)+' + suffix + '(?![+\\w.-])' + return '(?:' + contentType + '|' + suffixPattern + ')' + } + + // Insert each content type parser that has its associated language + // currently loaded. + var options + for (var contentType in httpLanguages) { + if (httpLanguages[contentType]) { + options = options || {} + var pattern = suffixTypes[contentType] + ? getSuffixPattern(contentType) + : contentType + options[contentType.replace(/\//g, '-')] = { + pattern: RegExp( + '(' + + /content-type:\s*/.source + + pattern + + /(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source + + ')' + + // This is a little interesting: + // The HTTP format spec required 1 empty line before the body to make everything unambiguous. + // However, when writing code by hand (e.g. to display on a website) people can forget about this, + // so we want to be liberal here. We will allow the empty line to be omitted if the first line of + // the body does not start with a [\w-] character (as headers do). + /[^ \t\w-][\s\S]*/.source, + 'i' + ), + lookbehind: true, + inside: httpLanguages[contentType] + } + } + } + if (options) { + Prism.languages.insertBefore('http', 'header', options) + } + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1fcf6814294199960f48683e9336f140c51ef2c --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function ichigojam(Prism: any): void; +declare namespace ichigojam { + let displayName: string; + let aliases: any[]; +} +export default ichigojam; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.js new file mode 100644 index 0000000000000000000000000000000000000000..7231a9aebe2cfc660dfcd3fb193da950492cfd34 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ichigojam.js @@ -0,0 +1,27 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +ichigojam.displayName = 'ichigojam' +ichigojam.aliases = [] + +/** @param {Refractor} Prism */ +export default function ichigojam(Prism) { + // according to the offical reference (EN) + // https://ichigojam.net/IchigoJam-en.html + Prism.languages.ichigojam = { + comment: /(?:\B'|REM)(?:[^\n\r]*)/i, + string: { + pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/, + greedy: true + }, + number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, + keyword: + /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i, + function: + /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i, + label: /(?:\B@\S+)/, + operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i, + punctuation: /[\[,;:()\]]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2a6df9af73b88c369ed87d31d67eae06853fdf8f --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function icon(Prism: any): void; +declare namespace icon { + let displayName: string; + let aliases: any[]; +} +export default icon; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.js new file mode 100644 index 0000000000000000000000000000000000000000..1328ec4456f1d7912090f7a629cfcac4aa1172cb --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icon.js @@ -0,0 +1,33 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +icon.displayName = 'icon' +icon.aliases = [] + +/** @param {Refractor} Prism */ +export default function icon(Prism) { + Prism.languages.icon = { + comment: /#.*/, + string: { + pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/, + greedy: true + }, + number: /\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i, + 'builtin-keyword': { + pattern: + /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/, + alias: 'variable' + }, + directive: { + pattern: /\$\w+/, + alias: 'builtin' + }, + keyword: + /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/, + function: /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/, + operator: + /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/, + punctuation: /[\[\](){},;]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..633cc19e14ad94631d0d0056be7471806df0e5d0 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function icuMessageFormat(Prism: any): void; +declare namespace icuMessageFormat { + let displayName: string; + let aliases: any[]; +} +export default icuMessageFormat; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.js new file mode 100644 index 0000000000000000000000000000000000000000..a84c4e152e0c8b0a166dd3d7b564e3dd673096d3 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/icu-message-format.js @@ -0,0 +1,164 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +icuMessageFormat.displayName = 'icu-message-format' +icuMessageFormat.aliases = [] + +/** @param {Refractor} Prism */ +export default function icuMessageFormat(Prism) { + // https://unicode-org.github.io/icu/userguide/format_parse/messages/ + // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/MessageFormat.html + + ;(function (Prism) { + /** + * @param {string} source + * @param {number} level + * @returns {string} + */ + function nested(source, level) { + if (level <= 0) { + return /[]/.source + } else { + return source.replace(//g, function () { + return nested(source, level - 1) + }) + } + } + var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/ + var escape = { + pattern: /''/, + greedy: true, + alias: 'operator' + } + var string = { + pattern: stringPattern, + greedy: true, + inside: { + escape: escape + } + } + var argumentSource = nested( + /\{(?:[^{}']|'(?![{},'])|''||)*\}/.source.replace( + //g, + function () { + return stringPattern.source + } + ), + 8 + ) + var nestedMessage = { + pattern: RegExp(argumentSource), + inside: { + message: { + pattern: /^(\{)[\s\S]+(?=\}$)/, + lookbehind: true, + inside: null // see below + }, + 'message-delimiter': { + pattern: /./, + alias: 'punctuation' + } + } + } + Prism.languages['icu-message-format'] = { + argument: { + pattern: RegExp(argumentSource), + greedy: true, + inside: { + content: { + pattern: /^(\{)[\s\S]+(?=\}$)/, + lookbehind: true, + inside: { + 'argument-name': { + pattern: /^(\s*)[^{}:=,\s]+/, + lookbehind: true + }, + 'choice-style': { + // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details + pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/, + lookbehind: true, + inside: { + punctuation: /\|/, + range: { + pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/, + lookbehind: true, + inside: { + operator: /[<#\u2264]/, + number: /\S+/ + } + }, + rest: null // see below + } + }, + 'plural-style': { + // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation + pattern: + /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/, + lookbehind: true, + inside: { + offset: /^offset:\s*\d+/, + 'nested-message': nestedMessage, + selector: { + pattern: /=\d+|[^{}:=,\s]+/, + inside: { + keyword: /^(?:few|many|one|other|two|zero)$/ + } + } + } + }, + 'select-style': { + // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation + pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/, + lookbehind: true, + inside: { + 'nested-message': nestedMessage, + selector: { + pattern: /[^{}:=,\s]+/, + inside: { + keyword: /^other$/ + } + } + } + }, + keyword: /\b(?:choice|plural|select|selectordinal)\b/, + 'arg-type': { + pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/, + alias: 'keyword' + }, + 'arg-skeleton': { + pattern: /(,\s*)::[^{}:=,\s]+/, + lookbehind: true + }, + 'arg-style': { + pattern: + /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/, + lookbehind: true + }, + 'arg-style-text': { + pattern: RegExp( + /(^\s*,\s*(?=\S))/.source + + nested(/(?:[^{}']|'[^']*'|\{(?:)?\})+/.source, 8) + + '$' + ), + lookbehind: true, + alias: 'string' + }, + punctuation: /,/ + } + }, + 'argument-delimiter': { + pattern: /./, + alias: 'operator' + } + } + }, + escape: escape, + string: string + } + nestedMessage.inside.message.inside = Prism.languages['icu-message-format'] + Prism.languages['icu-message-format'].argument.inside.content.inside[ + 'choice-style' + ].inside.rest = Prism.languages['icu-message-format'] + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f6e5d8f466c993c9421a15f51f79568a0e3c5447 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function idris(Prism: any): void; +declare namespace idris { + let displayName: string; + let aliases: string[]; +} +export default idris; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.js new file mode 100644 index 0000000000000000000000000000000000000000..648df15ab47a2097f962779be0b3987c923ea645 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/idris.js @@ -0,0 +1,30 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorHaskell from './haskell.js' +idris.displayName = 'idris' +idris.aliases = ['idr'] + +/** @param {Refractor} Prism */ +export default function idris(Prism) { + Prism.register(refractorHaskell) + Prism.languages.idris = Prism.languages.extend('haskell', { + comment: { + pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m + }, + keyword: + /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/, + builtin: undefined + }) + Prism.languages.insertBefore('idris', 'keyword', { + 'import-statement': { + pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m, + lookbehind: true, + inside: { + punctuation: /\./ + } + } + }) + Prism.languages.idr = Prism.languages.idris +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3dc5bd9ed1ae0e99777c92c5976349ddf4aa6a56 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function iecst(Prism: any): void; +declare namespace iecst { + let displayName: string; + let aliases: any[]; +} +export default iecst; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.js new file mode 100644 index 0000000000000000000000000000000000000000..040003b1813883731ddd901b6d4df19ebaf3af87 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/iecst.js @@ -0,0 +1,46 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +iecst.displayName = 'iecst' +iecst.aliases = [] + +/** @param {Refractor} Prism */ +export default function iecst(Prism) { + Prism.languages.iecst = { + comment: [ + { + pattern: + /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/, + lookbehind: true, + greedy: true + }, + { + pattern: /(^|[^\\:])\/\/.*/, + lookbehind: true, + greedy: true + } + ], + string: { + pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, + greedy: true + }, + keyword: [ + /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i, + /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/ + ], + 'class-name': + /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/, + address: { + pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/, + alias: 'symbol' + }, + number: + /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, + boolean: /\b(?:FALSE|NULL|TRUE)\b/, + operator: + /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/, + function: /\b[a-z_]\w*(?=\s*\()/i, + punctuation: /[()[\].,;]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea144d13ba25900b70b489ae89329366cc1d28ae --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function ignore(Prism: any): void; +declare namespace ignore { + let displayName: string; + let aliases: string[]; +} +export default ignore; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.js new file mode 100644 index 0000000000000000000000000000000000000000..34ec051dc83d6bcbc85dad39f6eec84714cde3c7 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ignore.js @@ -0,0 +1,31 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +ignore.displayName = 'ignore' +ignore.aliases = ['gitignore', 'hgignore', 'npmignore'] + +/** @param {Refractor} Prism */ +export default function ignore(Prism) { + ;(function (Prism) { + Prism.languages.ignore = { + // https://git-scm.com/docs/gitignore + comment: /^#.*/m, + entry: { + pattern: /\S(?:.*(?:(?:\\ )|\S))?/, + alias: 'string', + inside: { + operator: /^!|\*\*?|\?/, + regex: { + pattern: /(^|[^\\])\[[^\[\]]*\]/, + lookbehind: true + }, + punctuation: /\// + } + } + } + Prism.languages.gitignore = Prism.languages.ignore + Prism.languages.hgignore = Prism.languages.ignore + Prism.languages.npmignore = Prism.languages.ignore + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..430c7c5b39478e2dda5da9d16e92abbe2470a739 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function inform7(Prism: any): void; +declare namespace inform7 { + let displayName: string; + let aliases: any[]; +} +export default inform7; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.js new file mode 100644 index 0000000000000000000000000000000000000000..7a865b6d711aeb2358e27ad2a47b388d402b117f --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/inform7.js @@ -0,0 +1,77 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +inform7.displayName = 'inform7' +inform7.aliases = [] + +/** @param {Refractor} Prism */ +export default function inform7(Prism) { + Prism.languages.inform7 = { + string: { + pattern: /"[^"]*"/, + inside: { + substitution: { + pattern: /\[[^\[\]]+\]/, + inside: { + delimiter: { + pattern: /\[|\]/, + alias: 'punctuation' + } + // See rest below + } + } + } + }, + comment: { + pattern: /\[[^\[\]]+\]/, + greedy: true + }, + title: { + pattern: /^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im, + alias: 'important' + }, + number: { + pattern: + /(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i, + lookbehind: true + }, + verb: { + pattern: + /(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i, + lookbehind: true, + alias: 'operator' + }, + keyword: { + pattern: + /(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i, + lookbehind: true + }, + property: { + pattern: + /(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i, + lookbehind: true, + alias: 'symbol' + }, + position: { + pattern: + /(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i, + lookbehind: true, + alias: 'keyword' + }, + type: { + pattern: + /(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i, + lookbehind: true, + alias: 'variable' + }, + punctuation: /[.,:;(){}]/ + } + Prism.languages.inform7['string'].inside['substitution'].inside.rest = + Prism.languages.inform7 + // We don't want the remaining text in the substitution to be highlighted as the string. + Prism.languages.inform7['string'].inside['substitution'].inside.rest.text = { + pattern: /\S(?:\s*\S)*/, + alias: 'comment' + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c9ee97d7023c0edc9d64bc92108e4bc26e9b2214 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function ini(Prism: any): void; +declare namespace ini { + let displayName: string; + let aliases: any[]; +} +export default ini; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.js new file mode 100644 index 0000000000000000000000000000000000000000..6f238ae7804eff0e7d628fbfeb5e3b5ab6010da7 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/ini.js @@ -0,0 +1,52 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +ini.displayName = 'ini' +ini.aliases = [] + +/** @param {Refractor} Prism */ +export default function ini(Prism) { + Prism.languages.ini = { + /** + * The component mimics the behavior of the Win32 API parser. + * + * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723} + */ + + comment: { + pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m, + lookbehind: true + }, + section: { + pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m, + lookbehind: true, + inside: { + 'section-name': { + pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/, + lookbehind: true, + alias: 'selector' + }, + punctuation: /\[|\]/ + } + }, + key: { + pattern: + /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m, + lookbehind: true, + alias: 'attr-name' + }, + value: { + pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/, + lookbehind: true, + alias: 'attr-value', + inside: { + 'inner-value': { + pattern: /^("|').+(?=\1$)/, + lookbehind: true + } + } + }, + punctuation: /=/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7823f5c5b84441b557045b05d951b6afcd1b859f --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function io(Prism: any): void; +declare namespace io { + let displayName: string; + let aliases: any[]; +} +export default io; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.js new file mode 100644 index 0000000000000000000000000000000000000000..099a0d947ebfdecf2a725ae945502b93da4e550a --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/io.js @@ -0,0 +1,35 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +io.displayName = 'io' +io.aliases = [] + +/** @param {Refractor} Prism */ +export default function io(Prism) { + Prism.languages.io = { + comment: { + pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/, + lookbehind: true, + greedy: true + }, + 'triple-quoted-string': { + pattern: /"""(?:\\[\s\S]|(?!""")[^\\])*"""/, + greedy: true, + alias: 'string' + }, + string: { + pattern: /"(?:\\.|[^\\\r\n"])*"/, + greedy: true + }, + keyword: + /\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\b/, + builtin: + /\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\b/, + boolean: /\b(?:false|nil|true)\b/, + number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i, + operator: + /[=!*/%+\-^&|]=|>>?=?|<+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/, + alias: 'keyword' + }, + number: + /\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/, + adverb: { + pattern: /[~}]|[\/\\]\.?|[bfM]\.|t[.:]/, + alias: 'builtin' + }, + operator: /[=a][.:]|_\./, + conjunction: { + pattern: /&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/, + alias: 'variable' + }, + punctuation: /[()]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f24ac7f39d9b0eb937a0191fbaa54ad02d7f2dc1 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function java(Prism: any): void; +declare namespace java { + let displayName: string; + let aliases: any[]; +} +export default java; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.js new file mode 100644 index 0000000000000000000000000000000000000000..c7bbef27fa25d2d71e803f47917dfc402677fb01 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/java.js @@ -0,0 +1,163 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorClike from './clike.js' +java.displayName = 'java' +java.aliases = [] + +/** @param {Refractor} Prism */ +export default function java(Prism) { + Prism.register(refractorClike) + ;(function (Prism) { + var keywords = + /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/ + + // full package (optional) + parent classes (optional) + var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source + + // based on the java naming conventions + var className = { + pattern: RegExp( + /(^|[^\w.])/.source + + classNamePrefix + + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source + ), + lookbehind: true, + inside: { + namespace: { + pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/, + inside: { + punctuation: /\./ + } + }, + punctuation: /\./ + } + } + Prism.languages.java = Prism.languages.extend('clike', { + string: { + pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/, + lookbehind: true, + greedy: true + }, + 'class-name': [ + className, + { + // variables, parameters, and constructor references + // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods) + pattern: RegExp( + /(^|[^\w.])/.source + + classNamePrefix + + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/ + .source + ), + lookbehind: true, + inside: className.inside + }, + { + // class names based on keyword + // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods) + pattern: RegExp( + /(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/ + .source + + classNamePrefix + + /[A-Z]\w*\b/.source + ), + lookbehind: true, + inside: className.inside + } + ], + keyword: keywords, + function: [ + Prism.languages.clike.function, + { + pattern: /(::\s*)[a-z_]\w*/, + lookbehind: true + } + ], + number: + /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i, + operator: { + pattern: + /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m, + lookbehind: true + }, + constant: /\b[A-Z][A-Z_\d]+\b/ + }) + Prism.languages.insertBefore('java', 'string', { + 'triple-quoted-string': { + // http://openjdk.java.net/jeps/355#Description + pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/, + greedy: true, + alias: 'string' + }, + char: { + pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, + greedy: true + } + }) + Prism.languages.insertBefore('java', 'class-name', { + annotation: { + pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/, + lookbehind: true, + alias: 'punctuation' + }, + generics: { + pattern: + /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/, + inside: { + 'class-name': className, + keyword: keywords, + punctuation: /[<>(),.:]/, + operator: /[?&|]/ + } + }, + import: [ + { + pattern: RegExp( + /(\bimport\s+)/.source + + classNamePrefix + + /(?:[A-Z]\w*|\*)(?=\s*;)/.source + ), + lookbehind: true, + inside: { + namespace: className.inside.namespace, + punctuation: /\./, + operator: /\*/, + 'class-name': /\w+/ + } + }, + { + pattern: RegExp( + /(\bimport\s+static\s+)/.source + + classNamePrefix + + /(?:\w+|\*)(?=\s*;)/.source + ), + lookbehind: true, + alias: 'static', + inside: { + namespace: className.inside.namespace, + static: /\b\w+$/, + punctuation: /\./, + operator: /\*/, + 'class-name': /\w+/ + } + } + ], + namespace: { + pattern: RegExp( + /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace( + //g, + function () { + return keywords.source + } + ) + ), + lookbehind: true, + inside: { + punctuation: /\./ + } + } + }) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c0f71b1ae1d38b63f073fdec1a13726c740ef280 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function javadoc(Prism: any): void; +declare namespace javadoc { + let displayName: string; + let aliases: any[]; +} +export default javadoc; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.js new file mode 100644 index 0000000000000000000000000000000000000000..66015dc112560102b099d76c41d482299e526b8e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoc.js @@ -0,0 +1,108 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJava from './java.js' +import refractorJavadoclike from './javadoclike.js' +import refractorMarkup from './markup.js' +javadoc.displayName = 'javadoc' +javadoc.aliases = [] + +/** @param {Refractor} Prism */ +export default function javadoc(Prism) { + Prism.register(refractorJava) + Prism.register(refractorJavadoclike) + Prism.register(refractorMarkup) + ;(function (Prism) { + var codeLinePattern = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m + var memberReference = /#\s*\w+(?:\s*\([^()]*\))?/.source + var reference = + /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*)?|/.source.replace( + //g, + function () { + return memberReference + } + ) + Prism.languages.javadoc = Prism.languages.extend('javadoclike', {}) + Prism.languages.insertBefore('javadoc', 'keyword', { + reference: { + pattern: RegExp( + /(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/ + .source + + '(?:' + + reference + + ')' + ), + lookbehind: true, + inside: { + function: { + pattern: /(#\s*)\w+(?=\s*\()/, + lookbehind: true + }, + field: { + pattern: /(#\s*)\w+/, + lookbehind: true + }, + namespace: { + pattern: /\b(?:[a-z]\w*\s*\.\s*)+/, + inside: { + punctuation: /\./ + } + }, + 'class-name': /\b[A-Z]\w*/, + keyword: Prism.languages.java.keyword, + punctuation: /[#()[\],.]/ + } + }, + 'class-name': { + // @param the first generic type parameter + pattern: /(@param\s+)<[A-Z]\w*>/, + lookbehind: true, + inside: { + punctuation: /[.<>]/ + } + }, + 'code-section': [ + { + pattern: + /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/, + lookbehind: true, + inside: { + code: { + // there can't be any HTML inside of {@code} tags + pattern: codeLinePattern, + lookbehind: true, + inside: Prism.languages.java, + alias: 'language-java' + } + } + }, + { + pattern: + /(<(code|pre|tt)>(?!)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/, + lookbehind: true, + inside: { + line: { + pattern: codeLinePattern, + lookbehind: true, + inside: { + // highlight HTML tags and entities + tag: Prism.languages.markup.tag, + entity: Prism.languages.markup.entity, + code: { + // everything else is Java code + pattern: /.+/, + inside: Prism.languages.java, + alias: 'language-java' + } + } + } + } + } + ], + tag: Prism.languages.markup.tag, + entity: Prism.languages.markup.entity + }) + Prism.languages.javadoclike.addSupport('java', Prism.languages.javadoc) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d173e6b71414bb6c0c3b70202efc736bf36d22a --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function javadoclike(Prism: any): void; +declare namespace javadoclike { + let displayName: string; + let aliases: any[]; +} +export default javadoclike; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.js new file mode 100644 index 0000000000000000000000000000000000000000..1ba6efcebda3f24c9a6382f15b616cdd9acc91e1 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javadoclike.js @@ -0,0 +1,94 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +javadoclike.displayName = 'javadoclike' +javadoclike.aliases = [] + +/** @param {Refractor} Prism */ +export default function javadoclike(Prism) { + ;(function (Prism) { + var javaDocLike = (Prism.languages.javadoclike = { + parameter: { + pattern: + /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m, + lookbehind: true + }, + keyword: { + // keywords are the first word in a line preceded be an `@` or surrounded by curly braces. + // @word, {@word} + pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m, + lookbehind: true + }, + punctuation: /[{}]/ + }) + + /** + * Adds doc comment support to the given language and calls a given callback on each doc comment pattern. + * + * @param {string} lang the language add doc comment support to. + * @param {(pattern: {inside: {rest: undefined}}) => void} callback the function called with each doc comment pattern as argument. + */ + function docCommentSupport(lang, callback) { + var tokenName = 'doc-comment' + var grammar = Prism.languages[lang] + if (!grammar) { + return + } + var token = grammar[tokenName] + if (!token) { + // add doc comment: /** */ + var definition = {} + definition[tokenName] = { + pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, + lookbehind: true, + alias: 'comment' + } + grammar = Prism.languages.insertBefore(lang, 'comment', definition) + token = grammar[tokenName] + } + if (token instanceof RegExp) { + // convert regex to object + token = grammar[tokenName] = { + pattern: token + } + } + if (Array.isArray(token)) { + for (var i = 0, l = token.length; i < l; i++) { + if (token[i] instanceof RegExp) { + token[i] = { + pattern: token[i] + } + } + callback(token[i]) + } + } else { + callback(token) + } + } + + /** + * Adds doc-comment support to the given languages for the given documentation language. + * + * @param {string[]|string} languages + * @param {Object} docLanguage + */ + function addSupport(languages, docLanguage) { + if (typeof languages === 'string') { + languages = [languages] + } + languages.forEach(function (lang) { + docCommentSupport(lang, function (pattern) { + if (!pattern.inside) { + pattern.inside = {} + } + pattern.inside.rest = docLanguage + }) + }) + } + Object.defineProperty(javaDocLike, 'addSupport', { + value: addSupport + }) + javaDocLike.addSupport(['java', 'javascript', 'php'], javaDocLike) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc5afd07b3837b96bb85ca81d6ef172e779badc0 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function javascript(Prism: any): void; +declare namespace javascript { + let displayName: string; + let aliases: string[]; +} +export default javascript; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.js new file mode 100644 index 0000000000000000000000000000000000000000..8a041b5e40f05280ce0e476534eac013078c99e2 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javascript.js @@ -0,0 +1,195 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorClike from './clike.js' +javascript.displayName = 'javascript' +javascript.aliases = ['js'] + +/** @param {Refractor} Prism */ +export default function javascript(Prism) { + Prism.register(refractorClike) + Prism.languages.javascript = Prism.languages.extend('clike', { + 'class-name': [ + Prism.languages.clike['class-name'], + { + pattern: + /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, + lookbehind: true + } + ], + keyword: [ + { + pattern: /((?:^|\})\s*)catch\b/, + lookbehind: true + }, + { + pattern: + /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, + lookbehind: true + } + ], + // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444) + function: + /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, + number: { + pattern: RegExp( + /(^|[^\w$])/.source + + '(?:' + + // constant + (/NaN|Infinity/.source + + '|' + + // binary integer + /0[bB][01]+(?:_[01]+)*n?/.source + + '|' + + // octal integer + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + + '|' + + // hexadecimal integer + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + + '|' + + // decimal bigint + /\d+(?:_\d+)*n/.source + + '|' + + // decimal number (integer or float) but no bigint + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/ + .source) + + ')' + + /(?![\w$])/.source + ), + lookbehind: true + }, + operator: + /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ + }) + Prism.languages.javascript['class-name'][0].pattern = + /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/ + Prism.languages.insertBefore('javascript', 'keyword', { + regex: { + pattern: RegExp( + // lookbehind + // eslint-disable-next-line regexp/no-dupe-characters-character-class + /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + + // Regex pattern: + // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character + // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible + // with the only syntax, so we have to define 2 different regex patterns. + /\//.source + + '(?:' + + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/ + .source + + '|' + + // `v` flag syntax. This supports 3 levels of nested character classes. + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/ + .source + + ')' + + // lookahead + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/ + .source + ), + lookbehind: true, + greedy: true, + inside: { + 'regex-source': { + pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, + lookbehind: true, + alias: 'language-regex', + inside: Prism.languages.regex + }, + 'regex-delimiter': /^\/|\/$/, + 'regex-flags': /^[a-z]+$/ + } + }, + // This must be declared before keyword because we use "function" inside the look-forward + 'function-variable': { + pattern: + /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, + alias: 'function' + }, + parameter: [ + { + pattern: + /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, + lookbehind: true, + inside: Prism.languages.javascript + }, + { + pattern: + /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, + lookbehind: true, + inside: Prism.languages.javascript + }, + { + pattern: + /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, + lookbehind: true, + inside: Prism.languages.javascript + }, + { + pattern: + /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/, + lookbehind: true, + inside: Prism.languages.javascript + } + ], + constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ + }) + Prism.languages.insertBefore('javascript', 'string', { + hashbang: { + pattern: /^#!.*/, + greedy: true, + alias: 'comment' + }, + 'template-string': { + pattern: + /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/, + greedy: true, + inside: { + 'template-punctuation': { + pattern: /^`|`$/, + alias: 'string' + }, + interpolation: { + pattern: + /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/, + lookbehind: true, + inside: { + 'interpolation-punctuation': { + pattern: /^\$\{|\}$/, + alias: 'punctuation' + }, + rest: Prism.languages.javascript + } + }, + string: /[\s\S]+/ + } + }, + 'string-property': { + pattern: + /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m, + lookbehind: true, + greedy: true, + alias: 'property' + } + }) + Prism.languages.insertBefore('javascript', 'operator', { + 'literal-property': { + pattern: + /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, + lookbehind: true, + alias: 'property' + } + }) + if (Prism.languages.markup) { + Prism.languages.markup.tag.addInlined('script', 'javascript') + + // add attribute support for all DOM events. + // https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events + Prism.languages.markup.tag.addAttribute( + /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/ + .source, + 'javascript' + ) + } + Prism.languages.js = Prism.languages.javascript +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5ebc3b9428751a632e26e781e30063eb480a0af --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function javastacktrace(Prism: any): void; +declare namespace javastacktrace { + let displayName: string; + let aliases: any[]; +} +export default javastacktrace; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.js new file mode 100644 index 0000000000000000000000000000000000000000..37c2ffd630bea532d0aa31913eda453b1e843b1b --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/javastacktrace.js @@ -0,0 +1,149 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +javastacktrace.displayName = 'javastacktrace' +javastacktrace.aliases = [] + +/** @param {Refractor} Prism */ +export default function javastacktrace(Prism) { + // Specification: + // https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/Throwable.html#printStackTrace() + + Prism.languages.javastacktrace = { + // java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...] + // Caused by: java.sql.SQLException: Violation of unique constraint MY_ENTITY_UK_1: duplicate value(s) for column(s) MY_COLUMN in statement [...] + // Caused by: com.example.myproject.MyProjectServletException + // Caused by: MidLevelException: LowLevelException + // Suppressed: Resource$CloseFailException: Resource ID = 0 + summary: { + pattern: + /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m, + lookbehind: true, + inside: { + keyword: { + pattern: + /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m, + lookbehind: true + }, + // the current thread if the summary starts with 'Exception in thread' + string: { + pattern: /^(\s*)"[^"]*"/, + lookbehind: true + }, + exceptions: { + pattern: /^(:?\s*)[\w$.]+(?=:|$)/, + lookbehind: true, + inside: { + 'class-name': /[\w$]+$/, + namespace: /\b[a-z]\w*\b/, + punctuation: /\./ + } + }, + message: { + pattern: /(:\s*)\S.*/, + lookbehind: true, + alias: 'string' + }, + punctuation: /:/ + } + }, + // at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1166) + // at org.hsqldb.jdbc.Util.throwError(Unknown Source) here could be some notes + // at java.base/java.lang.Class.forName0(Native Method) + // at Util.(Unknown Source) + // at com.foo.loader/foo@9.0/com.foo.Main.run(Main.java:101) + // at com.foo.loader//com.foo.bar.App.run(App.java:12) + // at acme@2.1/org.acme.Lib.test(Lib.java:80) + // at MyClass.mash(MyClass.java:9) + // + // More information: + // https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/StackTraceElement.html#toString() + // + // A valid Java module name is defined as: + // "A module name consists of one or more Java identifiers (ยง3.8) separated by "." tokens." + // https://docs.oracle.com/javase/specs/jls/se9/html/jls-6.html#jls-ModuleName + // + // A Java module version is defined by this class: + // https://docs.oracle.com/javase/9/docs/api/java/lang/module/ModuleDescriptor.Version.html + // This is the implementation of the `parse` method in JDK13: + // https://github.com/matcdac/jdk/blob/2305df71d1b7710266ae0956d73927a225132c0f/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java#L1108 + // However, to keep this simple, a version will be matched by the pattern /@[\w$.+-]*/. + 'stack-frame': { + pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:)?\([^()]*\)/m, + lookbehind: true, + inside: { + keyword: { + pattern: /^(\s*)at(?= )/, + lookbehind: true + }, + source: [ + // (Main.java:15) + // (Main.scala:15) + { + pattern: /(\()\w+\.\w+:\d+(?=\))/, + lookbehind: true, + inside: { + file: /^\w+\.\w+/, + punctuation: /:/, + 'line-number': { + pattern: /\b\d+\b/, + alias: 'number' + } + } + }, + // (Unknown Source) + // (Native Method) + // (...something...) + { + pattern: /(\()[^()]*(?=\))/, + lookbehind: true, + inside: { + keyword: /^(?:Native Method|Unknown Source)$/ + } + } + ], + 'class-name': /[\w$]+(?=\.(?:|[\w$]+)\()/, + function: /(?:|[\w$]+)(?=\()/, + 'class-loader': { + pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/, + lookbehind: true, + alias: 'namespace', + inside: { + punctuation: /\./ + } + }, + module: { + pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/, + lookbehind: true, + inside: { + version: { + pattern: /(@)[\s\S]+/, + lookbehind: true, + alias: 'number' + }, + punctuation: /[@.]/ + } + }, + namespace: { + pattern: /(?:\b[a-z]\w*\.)+/, + inside: { + punctuation: /\./ + } + }, + punctuation: /[()/.]/ + } + }, + // ... 32 more + // ... 32 common frames omitted + more: { + pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m, + lookbehind: true, + inside: { + punctuation: /\.{3}/, + number: /\d+/, + keyword: /\b[a-z]+(?: [a-z]+)*\b/ + } + } + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..de330e0b2b6792c01dd8e80154f2cd9b210d5fa2 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jexl(Prism: any): void; +declare namespace jexl { + let displayName: string; + let aliases: any[]; +} +export default jexl; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.js new file mode 100644 index 0000000000000000000000000000000000000000..a7cd1c6c231de23f6a13f5a9fc513be8c53277e0 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jexl.js @@ -0,0 +1,26 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +jexl.displayName = 'jexl' +jexl.aliases = [] + +/** @param {Refractor} Prism */ +export default function jexl(Prism) { + Prism.languages.jexl = { + string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/, + transform: { + pattern: + /(\|\s*)[a-zA-Zะฐ-ัะ-ะฏ_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wะฐ-ัะ-ะฏ\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/, + alias: 'function', + lookbehind: true + }, + function: + /[a-zA-Zะฐ-ัะ-ะฏ_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wะฐ-ัะ-ะฏ\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*\s*(?=\()/, + number: /\b\d+(?:\.\d+)?\b|\B\.\d+\b/, + operator: /[<>!]=?|-|\+|&&|==|\|\|?|\/\/?|[?:*^%]/, + boolean: /\b(?:false|true)\b/, + keyword: /\bin\b/, + punctuation: /[{}[\](),.]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..32da0370a1ee091cb5dbdc8e0824ab00cf75802d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jolie(Prism: any): void; +declare namespace jolie { + let displayName: string; + let aliases: any[]; +} +export default jolie; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.js new file mode 100644 index 0000000000000000000000000000000000000000..1e3b40e0e939dbd635d1c4e18197f94d09cc0ddf --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jolie.js @@ -0,0 +1,58 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorClike from './clike.js' +jolie.displayName = 'jolie' +jolie.aliases = [] + +/** @param {Refractor} Prism */ +export default function jolie(Prism) { + Prism.register(refractorClike) + Prism.languages.jolie = Prism.languages.extend('clike', { + string: { + pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/, + lookbehind: true, + greedy: true + }, + 'class-name': { + pattern: + /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/, + lookbehind: true + }, + keyword: + /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/, + function: /\b[a-z_]\w*(?=[ \t]*[@(])/i, + number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i, + operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/, + punctuation: /[()[\]{},;.:]/, + builtin: + /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/ + }) + Prism.languages.insertBefore('jolie', 'keyword', { + aggregates: { + pattern: + /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/, + lookbehind: true, + inside: { + keyword: /\bwith\b/, + 'class-name': /\w+/, + punctuation: /,/ + } + }, + redirects: { + pattern: + /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/, + lookbehind: true, + inside: { + punctuation: /,/, + 'class-name': /\w+/, + operator: /=>/ + } + }, + property: { + pattern: + /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/ + } + }) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6d1f48088a291fea24e6fe10f6452691ee1064d9 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jq(Prism: any): void; +declare namespace jq { + let displayName: string; + let aliases: any[]; +} +export default jq; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.js new file mode 100644 index 0000000000000000000000000000000000000000..e2bbd9701956e7e1c99d25eeaa7ec13d53627cae --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jq.js @@ -0,0 +1,80 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +jq.displayName = 'jq' +jq.aliases = [] + +/** @param {Refractor} Prism */ +export default function jq(Prism) { + ;(function (Prism) { + var interpolation = /\\\((?:[^()]|\([^()]*\))*\)/.source + var string = RegExp( + /(^|[^\\])"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace( + /__/g, + function () { + return interpolation + } + ) + ) + var stringInterpolation = { + interpolation: { + pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + interpolation), + lookbehind: true, + inside: { + content: { + pattern: /^(\\\()[\s\S]+(?=\)$)/, + lookbehind: true, + inside: null // see below + }, + punctuation: /^\\\(|\)$/ + } + } + } + var jq = (Prism.languages.jq = { + comment: /#.*/, + property: { + pattern: RegExp(string.source + /(?=\s*:(?!:))/.source), + lookbehind: true, + greedy: true, + inside: stringInterpolation + }, + string: { + pattern: string, + lookbehind: true, + greedy: true, + inside: stringInterpolation + }, + function: { + pattern: /(\bdef\s+)[a-z_]\w+/i, + lookbehind: true + }, + variable: /\B\$\w+/, + 'property-literal': { + pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i, + alias: 'property' + }, + keyword: + /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/, + boolean: /\b(?:false|true)\b/, + number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/, + operator: [ + { + pattern: /\|=?/, + alias: 'pipe' + }, + /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/ + ], + 'c-style-function': { + pattern: /\b[a-z_]\w*(?=\s*\()/i, + alias: 'function' + }, + punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/, + dot: { + pattern: /\./, + alias: 'important' + } + }) + stringInterpolation.interpolation.inside.content.inside = jq + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f24e855b500173207cff9a73ac355dd17c7bebc --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsExtras(Prism: any): void; +declare namespace jsExtras { + let displayName: string; + let aliases: any[]; +} +export default jsExtras; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.js new file mode 100644 index 0000000000000000000000000000000000000000..c0a769d049a07df843d7d267792195621ce1bc5e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-extras.js @@ -0,0 +1,160 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJavascript from './javascript.js' +jsExtras.displayName = 'js-extras' +jsExtras.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsExtras(Prism) { + Prism.register(refractorJavascript) + ;(function (Prism) { + Prism.languages.insertBefore('javascript', 'function-variable', { + 'method-variable': { + pattern: RegExp( + '(\\.\\s*)' + + Prism.languages.javascript['function-variable'].pattern.source + ), + lookbehind: true, + alias: ['function-variable', 'method', 'function', 'property-access'] + } + }) + Prism.languages.insertBefore('javascript', 'function', { + method: { + pattern: RegExp( + '(\\.\\s*)' + Prism.languages.javascript['function'].source + ), + lookbehind: true, + alias: ['function', 'property-access'] + } + }) + Prism.languages.insertBefore('javascript', 'constant', { + 'known-class-name': [ + { + // standard built-ins + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects + pattern: + /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/, + alias: 'class-name' + }, + { + // errors + pattern: /\b(?:[A-Z]\w*)Error\b/, + alias: 'class-name' + } + ] + }) + + /** + * Replaces the `` placeholder in the given pattern with a pattern for general JS identifiers. + * + * @param {string} source + * @param {string} [flags] + * @returns {RegExp} + */ + function withId(source, flags) { + return RegExp( + source.replace(//g, function () { + return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source + }), + flags + ) + } + Prism.languages.insertBefore('javascript', 'keyword', { + imports: { + // https://tc39.es/ecma262/#sec-imports + pattern: withId( + /(\bimport\b\s*)(?:(?:\s*,\s*(?:\*\s*as\s+|\{[^{}]*\}))?|\*\s*as\s+|\{[^{}]*\})(?=\s*\bfrom\b)/ + .source + ), + lookbehind: true, + inside: Prism.languages.javascript + }, + exports: { + // https://tc39.es/ecma262/#sec-exports + pattern: withId( + /(\bexport\b\s*)(?:\*(?:\s*as\s+)?(?=\s*\bfrom\b)|\{[^{}]*\})/ + .source + ), + lookbehind: true, + inside: Prism.languages.javascript + } + }) + Prism.languages.javascript['keyword'].unshift( + { + pattern: /\b(?:as|default|export|from|import)\b/, + alias: 'module' + }, + { + pattern: + /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/, + alias: 'control-flow' + }, + { + pattern: /\bnull\b/, + alias: ['null', 'nil'] + }, + { + pattern: /\bundefined\b/, + alias: 'nil' + } + ) + Prism.languages.insertBefore('javascript', 'operator', { + spread: { + pattern: /\.{3}/, + alias: 'operator' + }, + arrow: { + pattern: /=>/, + alias: 'operator' + } + }) + Prism.languages.insertBefore('javascript', 'punctuation', { + 'property-access': { + pattern: withId(/(\.\s*)#?/.source), + lookbehind: true + }, + 'maybe-class-name': { + pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/, + lookbehind: true + }, + dom: { + // this contains only a few commonly used DOM variables + pattern: + /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/, + alias: 'variable' + }, + console: { + pattern: /\bconsole(?=\s*\.)/, + alias: 'class-name' + } + }) + + // add 'maybe-class-name' to tokens which might be a class name + var maybeClassNameTokens = [ + 'function', + 'function-variable', + 'method', + 'method-variable', + 'property-access' + ] + for (var i = 0; i < maybeClassNameTokens.length; i++) { + var token = maybeClassNameTokens[i] + var value = Prism.languages.javascript[token] + + // convert regex to object + if (Prism.util.type(value) === 'RegExp') { + value = Prism.languages.javascript[token] = { + pattern: value + } + } + + // keep in mind that we don't support arrays + + var inside = value.inside || {} + value.inside = inside + inside['maybe-class-name'] = /^[A-Z][\s\S]*/ + } + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c4470325987ad8ab867ec466c15e18a4f45d523e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsTemplates(Prism: any): void; +declare namespace jsTemplates { + let displayName: string; + let aliases: any[]; +} +export default jsTemplates; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.js new file mode 100644 index 0000000000000000000000000000000000000000..3049de144fdd474ec980de0138a8f87ad6fb1c0d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/js-templates.js @@ -0,0 +1,366 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJavascript from './javascript.js' +jsTemplates.displayName = 'js-templates' +jsTemplates.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsTemplates(Prism) { + Prism.register(refractorJavascript) + ;(function (Prism) { + var templateString = Prism.languages.javascript['template-string'] + + // see the pattern in prism-javascript.js + var templateLiteralPattern = templateString.pattern.source + var interpolationObject = templateString.inside['interpolation'] + var interpolationPunctuationObject = + interpolationObject.inside['interpolation-punctuation'] + var interpolationPattern = interpolationObject.pattern.source + + /** + * Creates a new pattern to match a template string with a special tag. + * + * This will return `undefined` if there is no grammar with the given language id. + * + * @param {string} language The language id of the embedded language. E.g. `markdown`. + * @param {string} tag The regex pattern to match the tag. + * @returns {object | undefined} + * @example + * createTemplate('css', /\bcss/.source); + */ + function createTemplate(language, tag) { + if (!Prism.languages[language]) { + return undefined + } + return { + pattern: RegExp('((?:' + tag + ')\\s*)' + templateLiteralPattern), + lookbehind: true, + greedy: true, + inside: { + 'template-punctuation': { + pattern: /^`|`$/, + alias: 'string' + }, + 'embedded-code': { + pattern: /[\s\S]+/, + alias: language + } + } + } + } + Prism.languages.javascript['template-string'] = [ + // styled-jsx: + // css`a { color: #25F; }` + // styled-components: + // styled.h1`color: red;` + createTemplate( + 'css', + /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/ + .source + ), + // html`

` + // div.innerHTML = `

` + createTemplate('html', /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), + // svg`` + createTemplate('svg', /\bsvg/.source), + // md`# h1`, markdown`## h2` + createTemplate('markdown', /\b(?:markdown|md)/.source), + // gql`...`, graphql`...`, graphql.experimental`...` + createTemplate( + 'graphql', + /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source + ), + // sql`...` + createTemplate('sql', /\bsql/.source), + // vanilla template string + templateString + ].filter(Boolean) + + /** + * Returns a specific placeholder literal for the given language. + * + * @param {number} counter + * @param {string} language + * @returns {string} + */ + function getPlaceholder(counter, language) { + return '___' + language.toUpperCase() + '_' + counter + '___' + } + + /** + * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks. + * + * @param {string} code + * @param {any} grammar + * @param {string} language + * @returns {(string|Token)[]} + */ + function tokenizeWithHooks(code, grammar, language) { + var env = { + code: code, + grammar: grammar, + language: language + } + Prism.hooks.run('before-tokenize', env) + env.tokens = Prism.tokenize(env.code, env.grammar) + Prism.hooks.run('after-tokenize', env) + return env.tokens + } + + /** + * Returns the token of the given JavaScript interpolation expression. + * + * @param {string} expression The code of the expression. E.g. `"${42}"` + * @returns {Token} + */ + function tokenizeInterpolationExpression(expression) { + var tempGrammar = {} + tempGrammar['interpolation-punctuation'] = interpolationPunctuationObject + + /** @type {Array} */ + var tokens = Prism.tokenize(expression, tempGrammar) + if (tokens.length === 3) { + /** + * The token array will look like this + * [ + * ["interpolation-punctuation", "${"] + * "..." // JavaScript expression of the interpolation + * ["interpolation-punctuation", "}"] + * ] + */ + + var args = [1, 1] + args.push.apply( + args, + tokenizeWithHooks(tokens[1], Prism.languages.javascript, 'javascript') + ) + tokens.splice.apply(tokens, args) + } + return new Prism.Token( + 'interpolation', + tokens, + interpolationObject.alias, + expression + ) + } + + /** + * Tokenizes the given code with support for JavaScript interpolation expressions mixed in. + * + * This function has 3 phases: + * + * 1. Replace all JavaScript interpolation expression with a placeholder. + * The placeholder will have the syntax of a identify of the target language. + * 2. Tokenize the code with placeholders. + * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code. + * The insertion only works if a placeholder hasn't been "ripped apart" meaning that the placeholder has been + * tokenized as two tokens by the grammar of the embedded language. + * + * @param {string} code + * @param {object} grammar + * @param {string} language + * @returns {Token} + */ + function tokenizeEmbedded(code, grammar, language) { + // 1. First filter out all interpolations + + // because they might be escaped, we need a lookbehind, so we use Prism + /** @type {(Token|string)[]} */ + var _tokens = Prism.tokenize(code, { + interpolation: { + pattern: RegExp(interpolationPattern), + lookbehind: true + } + }) + + // replace all interpolations with a placeholder which is not in the code already + var placeholderCounter = 0 + /** @type {Object} */ + var placeholderMap = {} + var embeddedCode = _tokens + .map(function (token) { + if (typeof token === 'string') { + return token + } else { + var interpolationExpression = token.content + var placeholder + while ( + code.indexOf( + (placeholder = getPlaceholder(placeholderCounter++, language)) + ) !== -1 + ) { + /* noop */ + } + placeholderMap[placeholder] = interpolationExpression + return placeholder + } + }) + .join('') + + // 2. Tokenize the embedded code + + var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language) + + // 3. Re-insert the interpolation + + var placeholders = Object.keys(placeholderMap) + placeholderCounter = 0 + + /** + * + * @param {(Token|string)[]} tokens + * @returns {void} + */ + function walkTokens(tokens) { + for (var i = 0; i < tokens.length; i++) { + if (placeholderCounter >= placeholders.length) { + return + } + var token = tokens[i] + if (typeof token === 'string' || typeof token.content === 'string') { + var placeholder = placeholders[placeholderCounter] + var s = + typeof token === 'string' + ? token + : /** @type {string} */ token.content + var index = s.indexOf(placeholder) + if (index !== -1) { + ++placeholderCounter + var before = s.substring(0, index) + var middle = tokenizeInterpolationExpression( + placeholderMap[placeholder] + ) + var after = s.substring(index + placeholder.length) + var replacement = [] + if (before) { + replacement.push(before) + } + replacement.push(middle) + if (after) { + var afterTokens = [after] + walkTokens(afterTokens) + replacement.push.apply(replacement, afterTokens) + } + if (typeof token === 'string') { + tokens.splice.apply(tokens, [i, 1].concat(replacement)) + i += replacement.length - 1 + } else { + token.content = replacement + } + } + } else { + var content = token.content + if (Array.isArray(content)) { + walkTokens(content) + } else { + walkTokens([content]) + } + } + } + } + walkTokens(embeddedTokens) + return new Prism.Token( + language, + embeddedTokens, + 'language-' + language, + code + ) + } + + /** + * The languages for which JS templating will handle tagged template literals. + * + * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX. + */ + var supportedLanguages = { + javascript: true, + js: true, + typescript: true, + ts: true, + jsx: true, + tsx: true + } + Prism.hooks.add('after-tokenize', function (env) { + if (!(env.language in supportedLanguages)) { + return + } + + /** + * Finds and tokenizes all template strings with an embedded languages. + * + * @param {(Token | string)[]} tokens + * @returns {void} + */ + function findTemplateStrings(tokens) { + for (var i = 0, l = tokens.length; i < l; i++) { + var token = tokens[i] + if (typeof token === 'string') { + continue + } + var content = token.content + if (!Array.isArray(content)) { + if (typeof content !== 'string') { + findTemplateStrings([content]) + } + continue + } + if (token.type === 'template-string') { + /** + * A JavaScript template-string token will look like this: + * + * ["template-string", [ + * ["template-punctuation", "`"], + * ( + * An array of "string" and "interpolation" tokens. This is the simple string case. + * or + * ["embedded-code", "..."] This is the token containing the embedded code. + * It also has an alias which is the language of the embedded code. + * ), + * ["template-punctuation", "`"] + * ]] + */ + + var embedded = content[1] + if ( + content.length === 3 && + typeof embedded !== 'string' && + embedded.type === 'embedded-code' + ) { + // get string content + var code = stringContent(embedded) + var alias = embedded.alias + var language = Array.isArray(alias) ? alias[0] : alias + var grammar = Prism.languages[language] + if (!grammar) { + // the embedded language isn't registered. + continue + } + content[1] = tokenizeEmbedded(code, grammar, language) + } + } else { + findTemplateStrings(content) + } + } + } + findTemplateStrings(env.tokens) + }) + + /** + * Returns the string content of a token or token stream. + * + * @param {string | Token | (string | Token)[]} value + * @returns {string} + */ + function stringContent(value) { + if (typeof value === 'string') { + return value + } else if (Array.isArray(value)) { + return value.map(stringContent).join('') + } else { + return stringContent(value.content) + } + } + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a2715faf54c2393814da725f9f7ddb02a5357288 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsdoc(Prism: any): void; +declare namespace jsdoc { + let displayName: string; + let aliases: any[]; +} +export default jsdoc; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.js new file mode 100644 index 0000000000000000000000000000000000000000..bed638bf40982e5bda6bf71d27a82ba101d5d67d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsdoc.js @@ -0,0 +1,102 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJavadoclike from './javadoclike.js' +import refractorJavascript from './javascript.js' +import refractorTypescript from './typescript.js' +jsdoc.displayName = 'jsdoc' +jsdoc.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsdoc(Prism) { + Prism.register(refractorJavadoclike) + Prism.register(refractorJavascript) + Prism.register(refractorTypescript) + ;(function (Prism) { + var javascript = Prism.languages.javascript + var type = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source + var parameterPrefix = + '(@(?:arg|argument|param|property)\\s+(?:' + type + '\\s+)?)' + Prism.languages.jsdoc = Prism.languages.extend('javadoclike', { + parameter: { + // @param {string} foo - foo bar + pattern: RegExp( + parameterPrefix + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source + ), + lookbehind: true, + inside: { + punctuation: /\./ + } + } + }) + Prism.languages.insertBefore('jsdoc', 'keyword', { + 'optional-parameter': { + // @param {string} [baz.foo="bar"] foo bar + pattern: RegExp( + parameterPrefix + + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source + ), + lookbehind: true, + inside: { + parameter: { + pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/, + lookbehind: true, + inside: { + punctuation: /\./ + } + }, + code: { + pattern: /(=)[\s\S]*(?=\]$)/, + lookbehind: true, + inside: javascript, + alias: 'language-javascript' + }, + punctuation: /[=[\]]/ + } + }, + 'class-name': [ + { + pattern: RegExp( + /(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace( + //g, + function () { + return type + } + ) + ), + lookbehind: true, + inside: { + punctuation: /\./ + } + }, + { + pattern: RegExp('(@[a-z]+\\s+)' + type), + lookbehind: true, + inside: { + string: javascript.string, + number: javascript.number, + boolean: javascript.boolean, + keyword: Prism.languages.typescript.keyword, + operator: /=>|\.\.\.|[&|?:*]/, + punctuation: /[.,;=<>{}()[\]]/ + } + } + ], + example: { + pattern: + /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, + lookbehind: true, + inside: { + code: { + pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, + lookbehind: true, + inside: javascript, + alias: 'language-javascript' + } + } + } + }) + Prism.languages.javadoclike.addSupport('javascript', Prism.languages.jsdoc) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d1e5082080196f7d320ad722446dada5701a805 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function json(Prism: any): void; +declare namespace json { + let displayName: string; + let aliases: string[]; +} +export default json; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.js new file mode 100644 index 0000000000000000000000000000000000000000..5aaad2e41bfb0e53c1a9ea23bdd6fa1d3ff1181c --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json.js @@ -0,0 +1,36 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +json.displayName = 'json' +json.aliases = ['webmanifest'] + +/** @param {Refractor} Prism */ +export default function json(Prism) { + // https://www.json.org/json-en.html + Prism.languages.json = { + property: { + pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/, + lookbehind: true, + greedy: true + }, + string: { + pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/, + lookbehind: true, + greedy: true + }, + comment: { + pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, + greedy: true + }, + number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, + punctuation: /[{}[\],]/, + operator: /:/, + boolean: /\b(?:false|true)\b/, + null: { + pattern: /\bnull\b/, + alias: 'keyword' + } + } + Prism.languages.webmanifest = Prism.languages.json +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..77f704f60573ed903b9e941f8f4a51970b40c2f5 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function json5(Prism: any): void; +declare namespace json5 { + let displayName: string; + let aliases: any[]; +} +export default json5; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.js new file mode 100644 index 0000000000000000000000000000000000000000..f8002eb4f4421ce171044991c7dea54dee94aff0 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/json5.js @@ -0,0 +1,34 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJson from './json.js' +json5.displayName = 'json5' +json5.aliases = [] + +/** @param {Refractor} Prism */ +export default function json5(Prism) { + Prism.register(refractorJson) + ;(function (Prism) { + var string = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/ + Prism.languages.json5 = Prism.languages.extend('json', { + property: [ + { + pattern: RegExp(string.source + '(?=\\s*:)'), + greedy: true + }, + { + pattern: + /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/, + alias: 'unquoted' + } + ], + string: { + pattern: string, + greedy: true + }, + number: + /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/ + }) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5f53fdb96d66fda1c4c903f60cb3b72342b02475 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsonp(Prism: any): void; +declare namespace jsonp { + let displayName: string; + let aliases: any[]; +} +export default jsonp; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.js new file mode 100644 index 0000000000000000000000000000000000000000..d510b71915342fa873eabd0dfb6fa4d3ece8245c --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsonp.js @@ -0,0 +1,18 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJson from './json.js' +jsonp.displayName = 'jsonp' +jsonp.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsonp(Prism) { + Prism.register(refractorJson) + Prism.languages.jsonp = Prism.languages.extend('json', { + punctuation: /[{}[\]();,.]/ + }) + Prism.languages.insertBefore('jsonp', 'punctuation', { + function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/ + }) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b6c5a180e622eec2dd6e6fbdb95a2ed337f88aa --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsstacktrace(Prism: any): void; +declare namespace jsstacktrace { + let displayName: string; + let aliases: any[]; +} +export default jsstacktrace; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.js new file mode 100644 index 0000000000000000000000000000000000000000..ac40ef04487d036a390e39282fd79e2f0e944873 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsstacktrace.js @@ -0,0 +1,53 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +jsstacktrace.displayName = 'jsstacktrace' +jsstacktrace.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsstacktrace(Prism) { + Prism.languages.jsstacktrace = { + 'error-message': { + pattern: /^\S.*/m, + alias: 'string' + }, + 'stack-frame': { + pattern: /(^[ \t]+)at[ \t].*/m, + lookbehind: true, + inside: { + 'not-my-code': { + pattern: + /^at[ \t]+(?!\s)(?:node\.js||.*(?:node_modules|\(\)|\(|$|\(internal\/|\(node\.js)).*/m, + alias: 'comment' + }, + filename: { + pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/, + lookbehind: true, + alias: 'url' + }, + function: { + pattern: + /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/, + lookbehind: true, + inside: { + punctuation: /\./ + } + }, + punctuation: /[()]/, + keyword: /\b(?:at|new)\b/, + alias: { + pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/, + alias: 'variable' + }, + 'line-number': { + pattern: /:\d+(?::\d+)?\b/, + alias: 'number', + inside: { + punctuation: /:/ + } + } + } + } + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06155c01a665f4b70475259618644ae9575e043d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function jsx(Prism: any): void; +declare namespace jsx { + let displayName: string; + let aliases: any[]; +} +export default jsx; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.js new file mode 100644 index 0000000000000000000000000000000000000000..c3dfe8c4e8ce43e07bd331a52e6be6b7e406ecec --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/jsx.js @@ -0,0 +1,193 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorJavascript from './javascript.js' +import refractorMarkup from './markup.js' +jsx.displayName = 'jsx' +jsx.aliases = [] + +/** @param {Refractor} Prism */ +export default function jsx(Prism) { + Prism.register(refractorJavascript) + Prism.register(refractorMarkup) + ;(function (Prism) { + var javascript = Prism.util.clone(Prism.languages.javascript) + var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source + var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source + var spread = /(?:\{*\.{3}(?:[^{}]|)*\})/.source + + /** + * @param {string} source + * @param {string} [flags] + */ + function re(source, flags) { + source = source + .replace(//g, function () { + return space + }) + .replace(//g, function () { + return braces + }) + .replace(//g, function () { + return spread + }) + return RegExp(source, flags) + } + spread = re(spread).source + Prism.languages.jsx = Prism.languages.extend('markup', javascript) + Prism.languages.jsx.tag.pattern = re( + /<\/?(?:[\w.:-]+(?:+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|))?|))**\/?)?>/ + .source + ) + Prism.languages.jsx.tag.inside['tag'].pattern = /^<\/?[^\s>\/]*/ + Prism.languages.jsx.tag.inside['attr-value'].pattern = + /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/ + Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = + /^[A-Z]\w*(?:\.[A-Z]\w*)*$/ + Prism.languages.jsx.tag.inside['comment'] = javascript['comment'] + Prism.languages.insertBefore( + 'inside', + 'attr-name', + { + spread: { + pattern: re(//.source), + inside: Prism.languages.jsx + } + }, + Prism.languages.jsx.tag + ) + Prism.languages.insertBefore( + 'inside', + 'special-attr', + { + script: { + // Allow for two levels of nesting + pattern: re(/=/.source), + alias: 'language-javascript', + inside: { + 'script-punctuation': { + pattern: /^=(?=\{)/, + alias: 'punctuation' + }, + rest: Prism.languages.jsx + } + } + }, + Prism.languages.jsx.tag + ) + + // The following will handle plain text inside tags + var stringifyToken = function (token) { + if (!token) { + return '' + } + if (typeof token === 'string') { + return token + } + if (typeof token.content === 'string') { + return token.content + } + return token.content.map(stringifyToken).join('') + } + var walkTokens = function (tokens) { + var openedTags = [] + for (var i = 0; i < tokens.length; i++) { + var token = tokens[i] + var notTagNorBrace = false + if (typeof token !== 'string') { + if ( + token.type === 'tag' && + token.content[0] && + token.content[0].type === 'tag' + ) { + // We found a tag, now find its kind + + if (token.content[0].content[0].content === ' 0 && + openedTags[openedTags.length - 1].tagName === + stringifyToken(token.content[0].content[1]) + ) { + // Pop matching opening tag + openedTags.pop() + } + } else { + if (token.content[token.content.length - 1].content === '/>') { + // Autoclosed tag, ignore + } else { + // Opening tag + openedTags.push({ + tagName: stringifyToken(token.content[0].content[1]), + openedBraces: 0 + }) + } + } + } else if ( + openedTags.length > 0 && + token.type === 'punctuation' && + token.content === '{' + ) { + // Here we might have entered a JSX context inside a tag + openedTags[openedTags.length - 1].openedBraces++ + } else if ( + openedTags.length > 0 && + openedTags[openedTags.length - 1].openedBraces > 0 && + token.type === 'punctuation' && + token.content === '}' + ) { + // Here we might have left a JSX context inside a tag + openedTags[openedTags.length - 1].openedBraces-- + } else { + notTagNorBrace = true + } + } + if (notTagNorBrace || typeof token === 'string') { + if ( + openedTags.length > 0 && + openedTags[openedTags.length - 1].openedBraces === 0 + ) { + // Here we are inside a tag, and not inside a JSX context. + // That's plain text: drop any tokens matched. + var plainText = stringifyToken(token) + + // And merge text with adjacent text + if ( + i < tokens.length - 1 && + (typeof tokens[i + 1] === 'string' || + tokens[i + 1].type === 'plain-text') + ) { + plainText += stringifyToken(tokens[i + 1]) + tokens.splice(i + 1, 1) + } + if ( + i > 0 && + (typeof tokens[i - 1] === 'string' || + tokens[i - 1].type === 'plain-text') + ) { + plainText = stringifyToken(tokens[i - 1]) + plainText + tokens.splice(i - 1, 1) + i-- + } + tokens[i] = new Prism.Token( + 'plain-text', + plainText, + null, + plainText + ) + } + } + if (token.content && typeof token.content !== 'string') { + walkTokens(token.content) + } + } + } + Prism.hooks.add('after-tokenize', function (env) { + if (env.language !== 'jsx' && env.language !== 'tsx') { + return + } + walkTokens(env.tokens) + }) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..761a259ae193f49f3b0223189f28b3bb6b787445 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function julia(Prism: any): void; +declare namespace julia { + let displayName: string; + let aliases: any[]; +} +export default julia; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.js new file mode 100644 index 0000000000000000000000000000000000000000..2cfadfbf4ed602a93f7a1ca57741e23b348e25dc --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/julia.js @@ -0,0 +1,50 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +julia.displayName = 'julia' +julia.aliases = [] + +/** @param {Refractor} Prism */ +export default function julia(Prism) { + Prism.languages.julia = { + comment: { + // support one level of nested comments + // https://github.com/JuliaLang/julia/pull/6128 + pattern: + /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/, + lookbehind: true + }, + regex: { + // https://docs.julialang.org/en/v1/manual/strings/#Regular-Expressions-1 + pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/, + greedy: true + }, + string: { + // https://docs.julialang.org/en/v1/manual/strings/#String-Basics-1 + // https://docs.julialang.org/en/v1/manual/strings/#non-standard-string-literals-1 + // https://docs.julialang.org/en/v1/manual/running-external-programs/#Running-External-Programs-1 + pattern: + /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/, + greedy: true + }, + char: { + // https://docs.julialang.org/en/v1/manual/strings/#man-characters-1 + pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/, + lookbehind: true, + greedy: true + }, + keyword: + /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/, + boolean: /\b(?:false|true)\b/, + number: + /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i, + // https://docs.julialang.org/en/v1/manual/mathematical-operations/ + // https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity-1 + operator: + /&&|\|\||[-+*^%รทโŠป&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~โ‰ โ‰คโ‰ฅ'โˆšโˆ›]/, + punctuation: /::?|[{}[\]();,.?]/, + // https://docs.julialang.org/en/v1/base/numbers/#Base.im + constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[ฯ€โ„ฏ]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4269138f751892b3e8f44f0e6192f9416c823d5d --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function keepalived(Prism: any): void; +declare namespace keepalived { + let displayName: string; + let aliases: any[]; +} +export default keepalived; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.js new file mode 100644 index 0000000000000000000000000000000000000000..0078089dc25f647ce8749bb73fb33c35462799cd --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keepalived.js @@ -0,0 +1,63 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +keepalived.displayName = 'keepalived' +keepalived.aliases = [] + +/** @param {Refractor} Prism */ +export default function keepalived(Prism) { + Prism.languages.keepalived = { + comment: { + pattern: /[#!].*/, + greedy: true + }, + string: { + pattern: + /(^|[^\\])(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, + lookbehind: true, + greedy: true + }, + // support IPv4, IPv6, subnet mask + ip: { + pattern: RegExp( + /\b(?:(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){5}:(?:[\da-f]{1,4}:)?[\da-f]{1,4}|(?:[\da-f]{1,4}:){4}:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4}|(?:[\da-f]{1,4}:){3}:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4}|(?:[\da-f]{1,4}:){2}:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4}|(?:[\da-f]{1,4}:){6}|(?:[\da-f]{1,4}:){0,5}:|::(?:[\da-f]{1,4}:){0,5}|[\da-f]{1,4}::(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4}|::(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:)(?:\/\d{1,3})?|(?:\/\d{1,2})?)\b/.source.replace( + //g, + function () { + return /(?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d))/ + .source + } + ), + 'i' + ), + alias: 'number' + }, + // support *nix / Windows, directory / file + path: { + pattern: + /(\s)\/(?:[^\/\s]+\/)*[^\/\s]*|\b[a-zA-Z]:\\(?:[^\\\s]+\\)*[^\\\s]*/, + lookbehind: true, + alias: 'string' + }, + variable: /\$\{?\w+\}?/, + email: { + pattern: /[\w-]+@[\w-]+(?:\.[\w-]{2,3}){1,2}/, + alias: 'string' + }, + 'conditional-configuration': { + pattern: /@\^?[\w-]+/, + alias: 'variable' + }, + operator: /=/, + property: + /\b(?:BFD_CHECK|DNS_CHECK|FILE_CHECK|HTTP_GET|MISC_CHECK|NAME|PING_CHECK|SCRIPTS|SMTP_CHECK|SSL|SSL_GET|TCP_CHECK|UDP_CHECK|accept|advert_int|alpha|auth_pass|auth_type|authentication|bfd_cpu_affinity|bfd_instance|bfd_no_swap|bfd_priority|bfd_process_name|bfd_rlimit_rttime|bfd_rt_priority|bind_if|bind_port|bindto|ca|certificate|check_unicast_src|checker|checker_cpu_affinity|checker_log_all_failures|checker_no_swap|checker_priority|checker_rlimit_rttime|checker_rt_priority|child_wait_time|connect_ip|connect_port|connect_timeout|dbus_service_name|debug|default_interface|delay|delay_before_retry|delay_loop|digest|dont_track_primary|dynamic|dynamic_interfaces|enable_(?:dbus|script_security|sni|snmp_checker|snmp_rfc|snmp_rfcv2|snmp_rfcv3|snmp_vrrp|traps)|end|fall|fast_recovery|file|flag-[123]|fork_delay|full_command|fwmark|garp_group|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|global_defs|global_tracking|gna_interval|group|ha_suspend|hashed|helo_name|higher_prio_send_advert|hoplimit|http_protocol|hysteresis|idle_tx|include|inhibit_on_failure|init_fail|init_file|instance|interface|interfaces|interval|ip_family|ipvs_process_name|keepalived.conf|kernel_rx_buf_size|key|linkbeat_interfaces|linkbeat_use_polling|log_all_failures|log_unknown_vrids|lower_prio_no_advert|lthreshold|lvs_flush|lvs_flush_onstop|lvs_method|lvs_netlink_cmd_rcv_bufs|lvs_netlink_cmd_rcv_bufs_force|lvs_netlink_monitor_rcv_bufs|lvs_netlink_monitor_rcv_bufs_force|lvs_notify_fifo|lvs_notify_fifo_script|lvs_sched|lvs_sync_daemon|max_auto_priority|max_hops|mcast_src_ip|mh-fallback|mh-port|min_auto_priority_delay|min_rx|min_tx|misc_dynamic|misc_path|misc_timeout|multiplier|name|namespace_with_ipsets|native_ipv6|neighbor_ip|net_namespace|net_namespace_ipvs|nftables|nftables_counters|nftables_ifindex|nftables_priority|no_accept|no_checker_emails|no_email_faults|nopreempt|notification_email|notification_email_from|notify|notify_backup|notify_deleted|notify_down|notify_fault|notify_fifo|notify_fifo_script|notify_master|notify_master_rx_lower_pri|notify_priority_changes|notify_stop|notify_up|old_unicast_checksum|omega|ops|param_match|passive|password|path|persistence_engine|persistence_granularity|persistence_timeout|preempt|preempt_delay|priority|process|process_monitor_rcv_bufs|process_monitor_rcv_bufs_force|process_name|process_names|promote_secondaries|protocol|proxy_arp|proxy_arp_pvlan|quorum|quorum_down|quorum_max|quorum_up|random_seed|real_server|regex|regex_max_offset|regex_min_offset|regex_no_match|regex_options|regex_stack|reload_repeat|reload_time_file|require_reply|retry|rise|router_id|rs_init_notifies|script|script_user|sh-fallback|sh-port|shutdown_script|shutdown_script_timeout|skip_check_adv_addr|smtp_alert|smtp_alert_checker|smtp_alert_vrrp|smtp_connect_timeout|smtp_helo_name|smtp_server|snmp_socket|sorry_server|sorry_server_inhibit|sorry_server_lvs_method|source_ip|start|startup_script|startup_script_timeout|state|static_ipaddress|static_routes|static_rules|status_code|step|strict_mode|sync_group_tracking_weight|terminate_delay|timeout|track_bfd|track_file|track_group|track_interface|track_process|track_script|track_src_ip|ttl|type|umask|unicast_peer|unicast_src_ip|unicast_ttl|url|use_ipvlan|use_pid_dir|use_vmac|user|uthreshold|val[123]|version|virtual_ipaddress|virtual_ipaddress_excluded|virtual_router_id|virtual_routes|virtual_rules|virtual_server|virtual_server_group|virtualhost|vmac_xmit_base|vrrp|vrrp_(?:check_unicast_src|cpu_affinity|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|gna_interval|higher_prio_send_advert|instance|ipsets|iptables|lower_prio_no_advert|mcast_group4|mcast_group6|min_garp|netlink_cmd_rcv_bufs|netlink_cmd_rcv_bufs_force|netlink_monitor_rcv_bufs|netlink_monitor_rcv_bufs_force|no_swap|notify_fifo|notify_fifo_script|notify_priority_changes|priority|process_name|rlimit_rttime|rt_priority|rx_bufs_multiplier|rx_bufs_policy|script|skip_check_adv_addr|startup_delay|strict|sync_group|track_process|version)|warmup|weight)\b/, + constant: + /\b(?:A|AAAA|AH|BACKUP|CNAME|DR|MASTER|MX|NAT|NS|PASS|SCTP|SOA|TCP|TUN|TXT|UDP|dh|fo|lblc|lblcr|lc|mh|nq|ovf|rr|sed|sh|wlc|wrr)\b/, + number: { + pattern: /(^|[^\w.-])-?\d+(?:\.\d+)?/, + lookbehind: true + }, + boolean: /\b(?:false|no|off|on|true|yes)\b/, + punctuation: /[\{\}]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..23dc1f4d0f011ad3e3512554db5e6ee2f86caabb --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function keyman(Prism: any): void; +declare namespace keyman { + let displayName: string; + let aliases: any[]; +} +export default keyman; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.js new file mode 100644 index 0000000000000000000000000000000000000000..815dc9561c4d0d8326ed467522415a9121522e6a --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/keyman.js @@ -0,0 +1,54 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +keyman.displayName = 'keyman' +keyman.aliases = [] + +/** @param {Refractor} Prism */ +export default function keyman(Prism) { + Prism.languages.keyman = { + comment: { + pattern: /\bc .*/i, + greedy: true + }, + string: { + pattern: /"[^"\r\n]*"|'[^'\r\n]*'/, + greedy: true + }, + 'virtual-key': { + pattern: + /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i, + greedy: true, + alias: 'function' // alias for styles + }, + // https://help.keyman.com/developer/language/guide/headers + 'header-keyword': { + pattern: /&\w+/, + alias: 'bold' // alias for styles + }, + 'header-statement': { + pattern: + /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i, + alias: 'bold' // alias for styles + }, + 'rule-keyword': { + pattern: + /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i, + alias: 'keyword' + }, + 'structural-keyword': { + pattern: + /\b(?:ansi|begin|group|match|newcontext|nomatch|postkeystroke|readonly|unicode|using keys)\b/i, + alias: 'keyword' + }, + 'compile-target': { + pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i, + alias: 'property' + }, + // U+####, x###, d### characters and numbers + number: /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i, + operator: /[+>\\$]|\.\./, + punctuation: /[()=,]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7ba064ef50654a2b7be9c08e7edc4fafccdbecea --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function kotlin(Prism: any): void; +declare namespace kotlin { + let displayName: string; + let aliases: string[]; +} +export default kotlin; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.js new file mode 100644 index 0000000000000000000000000000000000000000..37998ed781cf70b6bc4343242d60c6da1b76b9f6 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kotlin.js @@ -0,0 +1,96 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorClike from './clike.js' +kotlin.displayName = 'kotlin' +kotlin.aliases = ['kt', 'kts'] + +/** @param {Refractor} Prism */ +export default function kotlin(Prism) { + Prism.register(refractorClike) + ;(function (Prism) { + Prism.languages.kotlin = Prism.languages.extend('clike', { + keyword: { + // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get + pattern: + /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/, + lookbehind: true + }, + function: [ + { + pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, + greedy: true + }, + { + pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/, + lookbehind: true, + greedy: true + } + ], + number: + /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/, + operator: + /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/ + }) + delete Prism.languages.kotlin['class-name'] + var interpolationInside = { + 'interpolation-punctuation': { + pattern: /^\$\{?|\}$/, + alias: 'punctuation' + }, + expression: { + pattern: /[\s\S]+/, + inside: Prism.languages.kotlin + } + } + Prism.languages.insertBefore('kotlin', 'string', { + // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions + 'string-literal': [ + { + pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, + alias: 'multiline', + inside: { + interpolation: { + pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, + inside: interpolationInside + }, + string: /[\s\S]+/ + } + }, + { + pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, + alias: 'singleline', + inside: { + interpolation: { + pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, + lookbehind: true, + inside: interpolationInside + }, + string: /[\s\S]+/ + } + } + ], + char: { + // https://kotlinlang.org/spec/expressions.html#character-literals + pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, + greedy: true + } + }) + delete Prism.languages.kotlin['string'] + Prism.languages.insertBefore('kotlin', 'keyword', { + annotation: { + pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, + alias: 'builtin' + } + }) + Prism.languages.insertBefore('kotlin', 'function', { + label: { + pattern: /\b\w+@|@\w+\b/, + alias: 'symbol' + } + }) + Prism.languages.kt = Prism.languages.kotlin + Prism.languages.kts = Prism.languages.kotlin + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd0c2885c75d2bf3a843ceed99f2d7b8d335d030 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function kumir(Prism: any): void; +declare namespace kumir { + let displayName: string; + let aliases: string[]; +} +export default kumir; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.js new file mode 100644 index 0000000000000000000000000000000000000000..67a9e9e4e99581a284f55bad5d715f51baa573aa --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kumir.js @@ -0,0 +1,116 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +kumir.displayName = 'kumir' +kumir.aliases = ['kum'] + +/** @param {Refractor} Prism */ +export default function kumir(Prism) { + /* eslint-disable regexp/no-dupe-characters-character-class */ + ;(function (Prism) { + /** + * Regular expression for characters that are not allowed in identifiers. + * + * @type {string} + */ + var nonId = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source + + /** + * Surround a regular expression for IDs with patterns for non-ID sequences. + * + * @param {string} pattern A regular expression for identifiers. + * @param {string} [flags] The regular expression flags. + * @returns {RegExp} A wrapped regular expression for identifiers. + */ + function wrapId(pattern, flags) { + return RegExp(pattern.replace(//g, nonId), flags) + } + Prism.languages.kumir = { + comment: { + pattern: /\|.*/ + }, + prolog: { + pattern: /#.*/, + greedy: true + }, + string: { + pattern: /"[^\n\r"]*"|'[^\n\r']*'/, + greedy: true + }, + boolean: { + pattern: wrapId(/(^|[])(?:ะดะฐ|ะฝะตั‚)(?=[]|$)/.source), + lookbehind: true + }, + 'operator-word': { + pattern: wrapId(/(^|[])(?:ะธ|ะธะปะธ|ะฝะต)(?=[]|$)/.source), + lookbehind: true, + alias: 'keyword' + }, + 'system-variable': { + pattern: wrapId(/(^|[])ะทะฝะฐั‡(?=[]|$)/.source), + lookbehind: true, + alias: 'keyword' + }, + type: [ + { + pattern: wrapId( + /(^|[])(?:ะฒะตั‰|ะปะธั‚|ะปะพะณ|ัะธะผ|ั†ะตะป)(?:\x20*ั‚ะฐะฑ)?(?=[]|$)/ + .source + ), + lookbehind: true, + alias: 'builtin' + }, + { + pattern: wrapId( + /(^|[])(?:ะบะพะผะฟะป|ัะบะฐะฝะบะพะด|ั„ะฐะนะป|ั†ะฒะตั‚)(?=[]|$)/.source + ), + lookbehind: true, + alias: 'important' + } + ], + /** + * Should be performed after searching for type names because of "ั‚ะฐะฑ". + * "ั‚ะฐะฑ" is a reserved word, but never used without a preceding type name. + * "ะะะ—ะะะงะ˜ะขะฌ", "ะคะฒะฒะพะด", and "ะคะฒั‹ะฒะพะด" are not reserved words. + */ + keyword: { + pattern: wrapId( + /(^|[])(?:ะฐะปะณ|ะฐั€ะณ(?:\x20*ั€ะตะท)?|ะฒะฒะพะด|ะ’ะšะ›ะฎะงะ˜ะขะฌ|ะฒั[ะตั‘]|ะฒั‹ะฑะพั€|ะฒั‹ะฒะพะด|ะฒั‹ั…ะพะด|ะดะฐะฝะพ|ะดะปั|ะดะพ|ะดั|ะตัะปะธ|ะธะฝะฐั‡ะต|ะธัะฟ|ะธัะฟะพะปัŒะทะพะฒะฐั‚ัŒ|ะบะพะฝ(?:(?:\x20+|_)ะธัะฟ)?|ะบั†(?:(?:\x20+|_)ะฟั€ะธ)?|ะฝะฐะดะพ|ะฝะฐั‡|ะฝั|ะฝั†|ะพั‚|ะฟะฐัƒะทะฐ|ะฟะพะบะฐ|ะฟั€ะธ|ั€ะฐะทะฐ?|ั€ะตะท|ัั‚ะพะฟ|ั‚ะฐะฑ|ั‚ะพ|ัƒั‚ะฒ|ัˆะฐะณ)(?=[]|$)/ + .source + ), + lookbehind: true + }, + /** Should be performed after searching for reserved words. */ + name: { + // eslint-disable-next-line regexp/no-super-linear-backtracking + pattern: wrapId( + /(^|[])[^\d][^]*(?:\x20+[^]+)*(?=[]|$)/ + .source + ), + lookbehind: true + }, + /** Should be performed after searching for names. */ + number: { + pattern: wrapId( + /(^|[])(?:\B\$[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?=[]|$)/ + .source, + 'i' + ), + lookbehind: true + }, + /** Should be performed after searching for words. */ + punctuation: /:=|[(),:;\[\]]/, + /** + * Should be performed after searching for + * - numeric constants (because of "+" and "-"); + * - punctuation marks (because of ":=" and "="). + */ + 'operator-char': { + pattern: /\*\*?|<[=>]?|>=?|[-+/=]/, + alias: 'operator' + } + } + Prism.languages.kum = Prism.languages.kumir + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..53e2e56afcdffa20802f46f8b33819011b60c9f6 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function kusto(Prism: any): void; +declare namespace kusto { + let displayName: string; + let aliases: any[]; +} +export default kusto; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.js new file mode 100644 index 0000000000000000000000000000000000000000..418095f238893efae07641e24dd5903a503582b5 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/kusto.js @@ -0,0 +1,54 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +kusto.displayName = 'kusto' +kusto.aliases = [] + +/** @param {Refractor} Prism */ +export default function kusto(Prism) { + Prism.languages.kusto = { + comment: { + pattern: /\/\/.*/, + greedy: true + }, + string: { + pattern: + /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/, + greedy: true + }, + verb: { + pattern: /(\|\s*)[a-z][\w-]*/i, + lookbehind: true, + alias: 'keyword' + }, + command: { + pattern: /\.[a-z][a-z\d-]*\b/, + alias: 'keyword' + }, + 'class-name': + /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/, + keyword: + /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/, + boolean: /\b(?:false|null|true)\b/, + function: /\b[a-z_]\w*(?=\s*\()/, + datetime: [ + { + // RFC 822 + RFC 850 + pattern: + /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/, + alias: 'number' + }, + { + // ISO 8601 + pattern: + /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/, + alias: 'number' + } + ], + number: + /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnยต]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/, + operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./, + punctuation: /[()\[\]{},;.:]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..98f303bed5dd50b7d8d3874f19f84653026a5275 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function latex(Prism: any): void; +declare namespace latex { + let displayName: string; + let aliases: string[]; +} +export default latex; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.js new file mode 100644 index 0000000000000000000000000000000000000000..2d2d0c37cd5e8fd525f2ac710c8be61cacf74868 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latex.js @@ -0,0 +1,77 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +latex.displayName = 'latex' +latex.aliases = ['context', 'tex'] + +/** @param {Refractor} Prism */ +export default function latex(Prism) { + ;(function (Prism) { + var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i + var insideEqu = { + 'equation-command': { + pattern: funcPattern, + alias: 'regex' + } + } + Prism.languages.latex = { + comment: /%.*/, + // the verbatim environment prints whitespace to the document + cdata: { + pattern: + /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/, + lookbehind: true + }, + /* + * equations can be between $$ $$ or $ $ or \( \) or \[ \] + * (all are multiline) + */ + equation: [ + { + pattern: + /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/, + inside: insideEqu, + alias: 'string' + }, + { + pattern: + /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/, + lookbehind: true, + inside: insideEqu, + alias: 'string' + } + ], + /* + * arguments which are keywords or references are highlighted + * as keywords + */ + keyword: { + pattern: + /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/, + lookbehind: true + }, + url: { + pattern: /(\\url\{)[^}]+(?=\})/, + lookbehind: true + }, + /* + * section or chapter headlines are highlighted as bold so that + * they stand out more + */ + headline: { + pattern: + /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/, + lookbehind: true, + alias: 'class-name' + }, + function: { + pattern: funcPattern, + alias: 'selector' + }, + punctuation: /[[\]{}&]/ + } + Prism.languages.tex = Prism.languages.latex + Prism.languages.context = Prism.languages.latex + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fcf3e6be0e4b9363594841f87f92215c2a8370ef --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function latte(Prism: any): void; +declare namespace latte { + let displayName: string; + let aliases: any[]; +} +export default latte; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.js new file mode 100644 index 0000000000000000000000000000000000000000..420d8ee5d33ffa2f9559682ef2abea3e96744cf3 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/latte.js @@ -0,0 +1,85 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorClike from './clike.js' +import refractorMarkupTemplating from './markup-templating.js' +import refractorPhp from './php.js' +latte.displayName = 'latte' +latte.aliases = [] + +/** @param {Refractor} Prism */ +export default function latte(Prism) { + Prism.register(refractorClike) + Prism.register(refractorMarkupTemplating) + Prism.register(refractorPhp) + ;(function (Prism) { + Prism.languages.latte = { + comment: /^\{\*[\s\S]*/, + 'latte-tag': { + // https://latte.nette.org/en/tags + pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i, + lookbehind: true, + alias: 'important' + }, + delimiter: { + pattern: /^\{\/?|\}$/, + alias: 'punctuation' + }, + php: { + pattern: /\S(?:[\s\S]*\S)?/, + alias: 'language-php', + inside: Prism.languages.php + } + } + var markupLatte = Prism.languages.extend('markup', {}) + Prism.languages.insertBefore( + 'inside', + 'attr-value', + { + 'n-attr': { + pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/, + inside: { + 'attr-name': { + pattern: /^[^\s=]+/, + alias: 'important' + }, + 'attr-value': { + pattern: /=[\s\S]+/, + inside: { + punctuation: [ + /^=/, + { + pattern: /^(\s*)["']|["']$/, + lookbehind: true + } + ], + php: { + pattern: /\S(?:[\s\S]*\S)?/, + inside: Prism.languages.php + } + } + } + } + } + }, + markupLatte.tag + ) + Prism.hooks.add('before-tokenize', function (env) { + if (env.language !== 'latte') { + return + } + var lattePattern = + /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g + Prism.languages['markup-templating'].buildPlaceholders( + env, + 'latte', + lattePattern + ) + env.grammar = markupLatte + }) + Prism.hooks.add('after-tokenize', function (env) { + Prism.languages['markup-templating'].tokenizePlaceholders(env, 'latte') + }) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..afb21a96891245772ffb899cc546306ac4b992af --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function less(Prism: any): void; +declare namespace less { + let displayName: string; + let aliases: any[]; +} +export default less; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.js new file mode 100644 index 0000000000000000000000000000000000000000..bd10d0c88557b57a86e4c26c555c31eb79259773 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/less.js @@ -0,0 +1,65 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorCss from './css.js' +less.displayName = 'less' +less.aliases = [] + +/** @param {Refractor} Prism */ +export default function less(Prism) { + Prism.register(refractorCss) + /* FIXME : +:extend() is not handled specifically : its highlighting is buggy. +Mixin usage must be inside a ruleset to be highlighted. +At-rules (e.g. import) containing interpolations are buggy. +Detached rulesets are highlighted as at-rules. +A comment before a mixin usage prevents the latter to be properly highlighted. +*/ + + Prism.languages.less = Prism.languages.extend('css', { + comment: [ + /\/\*[\s\S]*?\*\//, + { + pattern: /(^|[^\\])\/\/.*/, + lookbehind: true + } + ], + atrule: { + pattern: + /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/, + inside: { + punctuation: /[:()]/ + } + }, + // selectors and mixins are considered the same + selector: { + pattern: + /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/, + inside: { + // mixin parameters + variable: /@+[\w-]+/ + } + }, + property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/, + operator: /[+\-*\/]/ + }) + 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' + } + }) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b1f2878297618262489b43d7aa18e449ed80f356 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function lilypond(Prism: any): void; +declare namespace lilypond { + let displayName: string; + let aliases: string[]; +} +export default lilypond; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.js new file mode 100644 index 0000000000000000000000000000000000000000..bfc0f88831e0e4fdc590fb87defcc7c64069265e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lilypond.js @@ -0,0 +1,90 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorScheme from './scheme.js' +lilypond.displayName = 'lilypond' +lilypond.aliases = ['ly'] + +/** @param {Refractor} Prism */ +export default function lilypond(Prism) { + Prism.register(refractorScheme) + ;(function (Prism) { + var schemeExpression = + /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|)*\)/ + .source + // allow for up to pow(2, recursivenessLog2) many levels of recursive brace expressions + // For some reason, this can't be 4 + var recursivenessLog2 = 5 + for (var i = 0; i < recursivenessLog2; i++) { + schemeExpression = schemeExpression.replace(//g, function () { + return schemeExpression + }) + } + schemeExpression = schemeExpression.replace(//g, /[^\s\S]/.source) + var lilypond = (Prism.languages.lilypond = { + comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/, + 'embedded-scheme': { + pattern: RegExp( + /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|))/.source.replace( + //g, + function () { + return schemeExpression + } + ), + 'm' + ), + lookbehind: true, + greedy: true, + inside: { + scheme: { + pattern: /^(#)[\s\S]+$/, + lookbehind: true, + alias: 'language-scheme', + inside: { + 'embedded-lilypond': { + pattern: /#\{[\s\S]*?#\}/, + greedy: true, + inside: { + punctuation: /^#\{|#\}$/, + lilypond: { + pattern: /[\s\S]+/, + alias: 'language-lilypond', + inside: null // see below + } + } + }, + rest: Prism.languages.scheme + } + }, + punctuation: /#/ + } + }, + string: { + pattern: /"(?:[^"\\]|\\.)*"/, + greedy: true + }, + 'class-name': { + pattern: /(\\new\s+)[\w-]+/, + lookbehind: true + }, + keyword: { + pattern: /\\[a-z][-\w]*/i, + inside: { + punctuation: /^\\/ + } + }, + operator: /[=|]|<<|>>/, + punctuation: { + pattern: + /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/, + lookbehind: true + }, + number: /\b\d+(?:\/\d+)?\b/ + }) + lilypond['embedded-scheme'].inside['scheme'].inside[ + 'embedded-lilypond' + ].inside['lilypond'].inside = lilypond + Prism.languages.ly = lilypond + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..20554710fe95538a75bf7d19327a7ab4143d38d9 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function linkerScript(Prism: any): void; +declare namespace linkerScript { + let displayName: string; + let aliases: string[]; +} +export default linkerScript; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.js new file mode 100644 index 0000000000000000000000000000000000000000..af19f420ab2e4931aa066b85cb5b16f52906ee31 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/linker-script.js @@ -0,0 +1,35 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +linkerScript.displayName = 'linker-script' +linkerScript.aliases = ['ld'] + +/** @param {Refractor} Prism */ +export default function linkerScript(Prism) { + Prism.languages['linker-script'] = { + comment: { + pattern: /(^|\s)\/\*[\s\S]*?(?:$|\*\/)/, + lookbehind: true, + greedy: true + }, + identifier: { + pattern: /"[^"\r\n]*"/, + greedy: true + }, + 'location-counter': { + pattern: /\B\.\B/, + alias: 'important' + }, + section: { + pattern: /(^|[^\w*])\.\w+\b/, + lookbehind: true, + alias: 'keyword' + }, + function: /\b[A-Z][A-Z_]*(?=\s*\()/, + number: /\b(?:0[xX][a-fA-F0-9]+|\d+)[KM]?\b/, + operator: />>=?|<<=?|->|\+\+|--|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?/, + punctuation: /[(){},;]/ + } + Prism.languages['ld'] = Prism.languages['linker-script'] +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..800478b14b84eeca9b76a07f92153ec54a654bc6 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function liquid(Prism: any): void; +declare namespace liquid { + let displayName: string; + let aliases: any[]; +} +export default liquid; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.js new file mode 100644 index 0000000000000000000000000000000000000000..fe47f93aeda59f846f820b6607aedf6300c9abe5 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/liquid.js @@ -0,0 +1,82 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorMarkupTemplating from './markup-templating.js' +liquid.displayName = 'liquid' +liquid.aliases = [] + +/** @param {Refractor} Prism */ +export default function liquid(Prism) { + Prism.register(refractorMarkupTemplating) + Prism.languages.liquid = { + comment: { + pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/, + lookbehind: true + }, + delimiter: { + pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/, + alias: 'punctuation' + }, + string: { + pattern: /"[^"]*"|'[^']*'/, + greedy: true + }, + keyword: + /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/, + object: + /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/, + function: [ + { + pattern: /(\|\s*)\w+/, + lookbehind: true, + alias: 'filter' + }, + { + // array functions + pattern: /(\.\s*)(?:first|last|size)/, + lookbehind: true + } + ], + boolean: /\b(?:false|nil|true)\b/, + range: { + pattern: /\.\./, + alias: 'operator' + }, + // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21 + number: /\b\d+(?:\.\d+)?\b/, + operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/, + punctuation: /[.,\[\]()]/, + empty: { + pattern: /\bempty\b/, + alias: 'keyword' + } + } + Prism.hooks.add('before-tokenize', function (env) { + var liquidPattern = + /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g + var insideRaw = false + Prism.languages['markup-templating'].buildPlaceholders( + env, + 'liquid', + liquidPattern, + function (match) { + var tagMatch = /^\{%-?\s*(\w+)/.exec(match) + if (tagMatch) { + var tag = tagMatch[1] + if (tag === 'raw' && !insideRaw) { + insideRaw = true + return true + } else if (tag === 'endraw') { + insideRaw = false + return true + } + } + return !insideRaw + } + ) + }) + Prism.hooks.add('after-tokenize', function (env) { + Prism.languages['markup-templating'].tokenizePlaceholders(env, 'liquid') + }) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b978e06e7bd77dd4d44a6dda4b24561a47043803 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function lisp(Prism: any): void; +declare namespace lisp { + let displayName: string; + let aliases: string[]; +} +export default lisp; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.js new file mode 100644 index 0000000000000000000000000000000000000000..844de3e8459e25d96d0821e55efdd7aee13fdfd3 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lisp.js @@ -0,0 +1,223 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +lisp.displayName = 'lisp' +lisp.aliases = ['elisp', 'emacs', 'emacs-lisp'] + +/** @param {Refractor} Prism */ +export default function lisp(Prism) { + ;(function (Prism) { + /** + * Functions to construct regular expressions + * e.g. (interactive ... or (interactive) + * + * @param {string} name + * @returns {RegExp} + */ + function simple_form(name) { + return RegExp(/(\()/.source + '(?:' + name + ')' + /(?=[\s\)])/.source) + } + /** + * booleans and numbers + * + * @param {string} pattern + * @returns {RegExp} + */ + function primitive(pattern) { + return RegExp( + /([\s([])/.source + '(?:' + pattern + ')' + /(?=[\s)])/.source + ) + } + + // Patterns in regular expressions + + // Symbol name. See https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html + // & and : are excluded as they are usually used for special purposes + var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source + // symbol starting with & used in function arguments + var marker = '&' + symbol + // Open parenthesis for look-behind + var par = '(\\()' + var endpar = '(?=\\))' + // End the pattern with look-ahead space + var space = '(?=\\s)' + var nestedPar = + /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/ + .source + var language = { + // Three or four semicolons are considered a heading. + // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html + heading: { + pattern: /;;;.*/, + alias: ['comment', 'title'] + }, + comment: /;.*/, + string: { + pattern: /"(?:[^"\\]|\\.)*"/, + greedy: true, + inside: { + argument: /[-A-Z]+(?=[.,\s])/, + symbol: RegExp('`' + symbol + "'") + } + }, + 'quoted-symbol': { + pattern: RegExp("#?'" + symbol), + alias: ['variable', 'symbol'] + }, + 'lisp-property': { + pattern: RegExp(':' + symbol), + alias: 'property' + }, + splice: { + pattern: RegExp(',@?' + symbol), + alias: ['symbol', 'variable'] + }, + keyword: [ + { + pattern: RegExp( + par + + '(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)' + + space + ), + lookbehind: true + }, + { + pattern: RegExp( + par + + '(?:append|by|collect|concat|do|finally|for|in|return)' + + space + ), + lookbehind: true + } + ], + declare: { + pattern: simple_form(/declare/.source), + lookbehind: true, + alias: 'keyword' + }, + interactive: { + pattern: simple_form(/interactive/.source), + lookbehind: true, + alias: 'keyword' + }, + boolean: { + pattern: primitive(/nil|t/.source), + lookbehind: true + }, + number: { + pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source), + lookbehind: true + }, + defvar: { + pattern: RegExp(par + 'def(?:const|custom|group|var)\\s+' + symbol), + lookbehind: true, + inside: { + keyword: /^def[a-z]+/, + variable: RegExp(symbol) + } + }, + defun: { + pattern: RegExp( + par + + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + + symbol + + /\s+\(/.source + + nestedPar + + /\)/.source + ), + lookbehind: true, + greedy: true, + inside: { + keyword: /^(?:cl-)?def\S+/, + // See below, this property needs to be defined later so that it can + // reference the language object. + arguments: null, + function: { + pattern: RegExp('(^\\s)' + symbol), + lookbehind: true + }, + punctuation: /[()]/ + } + }, + lambda: { + pattern: RegExp( + par + + 'lambda\\s+\\(\\s*(?:&?' + + symbol + + '(?:\\s+&?' + + symbol + + ')*\\s*)?\\)' + ), + lookbehind: true, + greedy: true, + inside: { + keyword: /^lambda/, + // See below, this property needs to be defined later so that it can + // reference the language object. + arguments: null, + punctuation: /[()]/ + } + }, + car: { + pattern: RegExp(par + symbol), + lookbehind: true + }, + punctuation: [ + // open paren, brackets, and close paren + /(?:['`,]?\(|[)\[\]])/, + // cons + { + pattern: /(\s)\.(?=\s)/, + lookbehind: true + } + ] + } + var arg = { + 'lisp-marker': RegExp(marker), + varform: { + pattern: RegExp( + /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source + ), + inside: language + }, + argument: { + pattern: RegExp(/(^|[\s(])/.source + symbol), + lookbehind: true, + alias: 'variable' + }, + rest: language + } + var forms = '\\S+(?:\\s+\\S+)*' + var arglist = { + pattern: RegExp(par + nestedPar + endpar), + lookbehind: true, + inside: { + 'rest-vars': { + pattern: RegExp('&(?:body|rest)\\s+' + forms), + inside: arg + }, + 'other-marker-vars': { + pattern: RegExp('&(?:aux|optional)\\s+' + forms), + inside: arg + }, + keys: { + pattern: RegExp('&key\\s+' + forms + '(?:\\s+&allow-other-keys)?'), + inside: arg + }, + argument: { + pattern: RegExp(symbol), + alias: 'variable' + }, + punctuation: /[()]/ + } + } + language['lambda'].inside.arguments = arglist + language['defun'].inside.arguments = Prism.util.clone(arglist) + language['defun'].inside.arguments.inside.sublist = arglist + Prism.languages.lisp = language + Prism.languages.elisp = language + Prism.languages.emacs = language + Prism.languages['emacs-lisp'] = language + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ebc25e7521071cc5a8855610945cbbab86ef24f --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function livescript(Prism: any): void; +declare namespace livescript { + let displayName: string; + let aliases: any[]; +} +export default livescript; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.js new file mode 100644 index 0000000000000000000000000000000000000000..97a537ad1ab2765072042917a06a04029f178acc --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/livescript.js @@ -0,0 +1,132 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +livescript.displayName = 'livescript' +livescript.aliases = [] + +/** @param {Refractor} Prism */ +export default function livescript(Prism) { + Prism.languages.livescript = { + comment: [ + { + pattern: /(^|[^\\])\/\*[\s\S]*?\*\//, + lookbehind: true + }, + { + pattern: /(^|[^\\])#.*/, + lookbehind: true + } + ], + 'interpolated-string': { + /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern + * forcing it to match """-quoted string when it would otherwise match "-quoted first. */ + pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/, + lookbehind: true, + greedy: true, + inside: { + variable: { + pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m, + lookbehind: true + }, + interpolation: { + pattern: /(^|[^\\])#\{[^}]+\}/m, + lookbehind: true, + inside: { + 'interpolation-punctuation': { + pattern: /^#\{|\}$/, + alias: 'variable' + } + // See rest below + } + }, + string: /[\s\S]+/ + } + }, + string: [ + { + pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/, + greedy: true + }, + { + pattern: /<\[[\s\S]*?\]>/, + greedy: true + }, + /\\[^\s,;\])}]+/ + ], + regex: [ + { + pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/, + greedy: true, + inside: { + comment: { + pattern: /(^|[^\\])#.*/, + lookbehind: true + } + } + }, + { + pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/, + greedy: true + } + ], + keyword: { + pattern: + /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m, + lookbehind: true + }, + 'keyword-operator': { + pattern: + /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m, + lookbehind: true, + alias: 'operator' + }, + boolean: { + pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m, + lookbehind: true + }, + argument: { + // Don't match .&. nor && + pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m, + lookbehind: true, + alias: 'variable' + }, + number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i, + identifier: /[a-z_](?:-?[a-z]|[\d_])*/i, + operator: [ + // Spaced . + { + pattern: /( )\.(?= )/, + lookbehind: true + }, + // Full list, in order: + // .= .~ .. ... + // .&. .^. .<<. .>>. .>>>. + // := :: ::= + // && + // || |> + // < << <<< <<<< + // <- <-- <-! <--! + // <~ <~~ <~! <~~! + // <| <= >> >= >? + // - -- -> --> + // + ++ + // @ @@ + // % %% + // * ** + // ! != !~= + // !~> !~~> + // !-> !--> + // ~ ~> ~~> ~= + // = == + // ^ ^^ + // / ? + /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/ + ], + punctuation: /[(){}\[\]|.,:;`]/ + } + Prism.languages.livescript['interpolated-string'].inside[ + 'interpolation' + ].inside.rest = Prism.languages.livescript +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee7815e7aadbc4efa1eaae327197396d2b7ebf67 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function llvm(Prism: any): void; +declare namespace llvm { + let displayName: string; + let aliases: any[]; +} +export default llvm; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.js new file mode 100644 index 0000000000000000000000000000000000000000..62fd2f91f66fdff0fd345922f1849d419cc0f523 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/llvm.js @@ -0,0 +1,31 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +llvm.displayName = 'llvm' +llvm.aliases = [] + +/** @param {Refractor} Prism */ +export default function llvm(Prism) { + ;(function (Prism) { + Prism.languages.llvm = { + comment: /;.*/, + string: { + pattern: /"[^"]*"/, + greedy: true + }, + boolean: /\b(?:false|true)\b/, + variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i, + label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i, + type: { + pattern: + /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/, + alias: 'class-name' + }, + keyword: /\b[a-z_][a-z_0-9]*\b/, + number: + /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/, + punctuation: /[{}[\];(),.!*=<>]/ + } + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d266fa931ddb1d26c6b49acb3bc9863dc3a061ef --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function log(Prism: any): void; +declare namespace log { + let displayName: string; + let aliases: any[]; +} +export default log; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.js new file mode 100644 index 0000000000000000000000000000000000000000..fe4fbe2ea6845aa70fbbcbe5fb2d3b00a621a4e9 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/log.js @@ -0,0 +1,129 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +log.displayName = 'log' +log.aliases = [] + +/** @param {Refractor} Prism */ +export default function log(Prism) { + // This is a language definition for generic log files. + // Since there is no one log format, this language definition has to support all formats to some degree. + // + // Based on https://github.com/MTDL9/vim-log-highlighting + + Prism.languages.log = { + string: { + // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy + pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/, + greedy: true + }, + exception: { + pattern: + /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/, + lookbehind: true, + greedy: true, + alias: ['javastacktrace', 'language-javastacktrace'], + inside: Prism.languages['javastacktrace'] || { + keyword: /\bat\b/, + function: /[a-z_][\w$]*(?=\()/, + punctuation: /[.:()]/ + } + }, + level: [ + { + pattern: + /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/, + alias: ['error', 'important'] + }, + { + pattern: /\b(?:WARN|WARNING|WRN)\b/, + alias: ['warning', 'important'] + }, + { + pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/, + alias: ['info', 'keyword'] + }, + { + pattern: /\b(?:DBG|DEBUG|FINE)\b/, + alias: ['debug', 'keyword'] + }, + { + pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/, + alias: ['trace', 'comment'] + } + ], + property: { + pattern: + /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im, + lookbehind: true + }, + separator: { + pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m, + lookbehind: true, + alias: 'comment' + }, + url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/, + email: { + pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/, + lookbehind: true, + alias: 'url' + }, + 'ip-address': { + pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/, + alias: 'constant' + }, + 'mac-address': { + pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i, + alias: 'constant' + }, + domain: { + pattern: + /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/, + lookbehind: true, + alias: 'constant' + }, + uuid: { + pattern: + /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, + alias: 'constant' + }, + hash: { + pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i, + alias: 'constant' + }, + 'file-path': { + pattern: + /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i, + lookbehind: true, + greedy: true, + alias: 'string' + }, + date: { + pattern: RegExp( + /\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source + + '|' + + /\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/ + .source + + '|' + + /\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/ + .source, + 'i' + ), + alias: 'number' + }, + time: { + pattern: + /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/, + alias: 'number' + }, + boolean: /\b(?:false|null|true)\b/i, + number: { + pattern: + /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i, + lookbehind: true + }, + operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/, + punctuation: /[\[\].,]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b5a017487dd6a10a871bcf3e46c90a5318400913 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function lolcode(Prism: any): void; +declare namespace lolcode { + let displayName: string; + let aliases: any[]; +} +export default lolcode; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.js new file mode 100644 index 0000000000000000000000000000000000000000..705aae818fbc502577fa0d5e739541d7e5cfaf9e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lolcode.js @@ -0,0 +1,60 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +lolcode.displayName = 'lolcode' +lolcode.aliases = [] + +/** @param {Refractor} Prism */ +export default function lolcode(Prism) { + Prism.languages.lolcode = { + comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/], + string: { + pattern: /"(?::.|[^":])*"/, + inside: { + variable: /:\{[^}]+\}/, + symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/] + }, + greedy: true + }, + number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/, + symbol: { + pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/, + lookbehind: true, + inside: { + keyword: /A(?=\s)/ + } + }, + label: { + pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/, + lookbehind: true, + alias: 'string' + }, + function: { + pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/, + lookbehind: true + }, + keyword: [ + { + pattern: + /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/, + lookbehind: true + }, + /'Z(?=\s|,|$)/ + ], + boolean: { + pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/, + lookbehind: true + }, + variable: { + pattern: /(^|\s)IT(?=\s|,|$)/, + lookbehind: true + }, + operator: { + pattern: + /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/, + lookbehind: true + }, + punctuation: /\.{3}|โ€ฆ|,|!/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..44464f69236e4bf63cd7050a2aa6c894e7b96590 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function lua(Prism: any): void; +declare namespace lua { + let displayName: string; + let aliases: any[]; +} +export default lua; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.js new file mode 100644 index 0000000000000000000000000000000000000000..fee49f05038f441af22b1ed7cea4bf6551d2d2b1 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/lua.js @@ -0,0 +1,33 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +lua.displayName = 'lua' +lua.aliases = [] + +/** @param {Refractor} Prism */ +export default function lua(Prism) { + 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|[^z]))*\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: /[\[\](){},;]|\.+|:+/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbcbc02a9ed57f33ca456e688c94875274b28378 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function magma(Prism: any): void; +declare namespace magma { + let displayName: string; + let aliases: any[]; +} +export default magma; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.js new file mode 100644 index 0000000000000000000000000000000000000000..6b2eabff998061ca722a2d2e57c8462bf2b1cc65 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/magma.js @@ -0,0 +1,43 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +magma.displayName = 'magma' +magma.aliases = [] + +/** @param {Refractor} Prism */ +export default function magma(Prism) { + Prism.languages.magma = { + output: { + pattern: + /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m, + lookbehind: true, + greedy: true + }, + comment: { + pattern: /\/\/.*|\/\*[\s\S]*?\*\//, + greedy: true + }, + string: { + pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/, + lookbehind: true, + greedy: true + }, + // http://magma.maths.usyd.edu.au/magma/handbook/text/82 + keyword: + /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/, + boolean: /\b(?:false|true)\b/, + generator: { + pattern: /\b[a-z_]\w*(?=\s*<)/i, + alias: 'class-name' + }, + function: /\b[a-z_]\w*(?=\s*\()/i, + number: { + pattern: + /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/, + lookbehind: true + }, + operator: /->|[-+*/^~!|#=]|:=|\.\./, + punctuation: /[()[\]{}<>,;.:]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..adbeb86130a4c46c34bac073d6848c5e0ab60fec --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function makefile(Prism: any): void; +declare namespace makefile { + let displayName: string; + let aliases: any[]; +} +export default makefile; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.js new file mode 100644 index 0000000000000000000000000000000000000000..8a41db4c72878b437f674dcd6faad853c7a936d1 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/makefile.js @@ -0,0 +1,42 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +makefile.displayName = 'makefile' +makefile.aliases = [] + +/** @param {Refractor} Prism */ +export default function makefile(Prism) { + Prism.languages.makefile = { + comment: { + pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/, + lookbehind: true + }, + string: { + pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, + greedy: true + }, + 'builtin-target': { + pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/, + alias: 'builtin' + }, + target: { + pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m, + alias: 'symbol', + inside: { + variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/ + } + }, + variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/, + // Directives + keyword: + /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/, + function: { + pattern: + /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/, + lookbehind: true + }, + operator: /(?:::|[?:+!])?=|[|@]/, + punctuation: /[:;(){}]/ + } +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..441a215bfe4af7b419da7afef024e9f0d5434b25 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function markdown(Prism: any): void; +declare namespace markdown { + let displayName: string; + let aliases: string[]; +} +export default markdown; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.js new file mode 100644 index 0000000000000000000000000000000000000000..b478aa4cf896f05022dd4e940f5a4858155d1c9e --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markdown.js @@ -0,0 +1,449 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorMarkup from './markup.js' +markdown.displayName = 'markdown' +markdown.aliases = ['md'] + +/** @param {Refractor} Prism */ +export default function markdown(Prism) { + Prism.register(refractorMarkup) + ;(function (Prism) { + // Allow only one line break + var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source + + /** + * This function is intended for the creation of the bold or italic pattern. + * + * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped. + * + * _Note:_ Keep in mind that this adds a capturing group. + * + * @param {string} pattern + * @returns {RegExp} + */ + function createInline(pattern) { + pattern = pattern.replace(//g, function () { + return inner + }) + return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + '(?:' + pattern + ')') + } + var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/ + .source + var tableRow = + /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace( + /__/g, + function () { + return tableCell + } + ) + var tableLine = + /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/ + .source + Prism.languages.markdown = Prism.languages.extend('markup', {}) + Prism.languages.insertBefore('markdown', 'prolog', { + 'front-matter-block': { + pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, + lookbehind: true, + greedy: true, + inside: { + punctuation: /^---|---$/, + 'front-matter': { + pattern: /\S+(?:\s+\S+)*/, + alias: ['yaml', 'language-yaml'], + inside: Prism.languages.yaml + } + } + }, + blockquote: { + // > ... + pattern: /^>(?:[\t ]*>)*/m, + alias: 'punctuation' + }, + table: { + pattern: RegExp( + '^' + tableRow + tableLine + '(?:' + tableRow + ')*', + 'm' + ), + inside: { + 'table-data-rows': { + pattern: RegExp( + '^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$' + ), + lookbehind: true, + inside: { + 'table-data': { + pattern: RegExp(tableCell), + inside: Prism.languages.markdown + }, + punctuation: /\|/ + } + }, + 'table-line': { + pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'), + lookbehind: true, + inside: { + punctuation: /\||:?-{3,}:?/ + } + }, + 'table-header-row': { + pattern: RegExp('^' + tableRow + '$'), + inside: { + 'table-header': { + pattern: RegExp(tableCell), + alias: 'important', + inside: Prism.languages.markdown + }, + punctuation: /\|/ + } + } + } + }, + code: [ + { + // Prefixed by 4 spaces or 1 tab and preceded by an empty line + pattern: + /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, + lookbehind: true, + alias: 'keyword' + }, + { + // ```optional language + // code block + // ``` + pattern: /^```[\s\S]*?^```$/m, + greedy: true, + inside: { + 'code-block': { + pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, + lookbehind: true + }, + 'code-language': { + pattern: /^(```).+/, + lookbehind: true + }, + punctuation: /```/ + } + } + ], + title: [ + { + // title 1 + // ======= + + // title 2 + // ------- + pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, + alias: 'important', + inside: { + punctuation: /==+$|--+$/ + } + }, + { + // # title 1 + // ###### title 6 + pattern: /(^\s*)#.+/m, + lookbehind: true, + alias: 'important', + inside: { + punctuation: /^#+|#+$/ + } + } + ], + hr: { + // *** + // --- + // * * * + // ----------- + pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, + lookbehind: true, + alias: 'punctuation' + }, + list: { + // * item + // + item + // - item + // 1. item + pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, + lookbehind: true, + alias: 'punctuation' + }, + 'url-reference': { + // [id]: http://example.com "Optional title" + // [id]: http://example.com 'Optional title' + // [id]: http://example.com (Optional title) + // [id]: "Optional title" + pattern: + /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, + inside: { + variable: { + pattern: /^(!?\[)[^\]]+/, + lookbehind: true + }, + string: + /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, + punctuation: /^[\[\]!:]|[<>]/ + }, + alias: 'url' + }, + bold: { + // **strong** + // __strong__ + + // allow one nested instance of italic text using the same delimiter + pattern: createInline( + /\b__(?:(?!_)|_(?:(?!_))+_)+__\b|\*\*(?:(?!\*)|\*(?:(?!\*))+\*)+\*\*/ + .source + ), + lookbehind: true, + greedy: true, + inside: { + content: { + pattern: /(^..)[\s\S]+(?=..$)/, + lookbehind: true, + inside: {} // see below + }, + punctuation: /\*\*|__/ + } + }, + italic: { + // *em* + // _em_ + + // allow one nested instance of bold text using the same delimiter + pattern: createInline( + /\b_(?:(?!_)|__(?:(?!_))+__)+_\b|\*(?:(?!\*)|\*\*(?:(?!\*))+\*\*)+\*/ + .source + ), + lookbehind: true, + greedy: true, + inside: { + content: { + pattern: /(^.)[\s\S]+(?=.$)/, + lookbehind: true, + inside: {} // see below + }, + punctuation: /[*_]/ + } + }, + strike: { + // ~~strike through~~ + // ~strike~ + // eslint-disable-next-line regexp/strict + pattern: createInline(/(~~?)(?:(?!~))+\2/.source), + lookbehind: true, + greedy: true, + inside: { + content: { + pattern: /(^~~?)[\s\S]+(?=\1$)/, + lookbehind: true, + inside: {} // see below + }, + punctuation: /~~?/ + } + }, + 'code-snippet': { + // `code` + // ``code`` + pattern: + /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, + lookbehind: true, + greedy: true, + alias: ['code', 'keyword'] + }, + url: { + // [example](http://example.com "Optional title") + // [example][id] + // [example] [id] + pattern: createInline( + /!?\[(?:(?!\]))+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\]))+\])/ + .source + ), + lookbehind: true, + greedy: true, + inside: { + operator: /^!/, + content: { + pattern: /(^\[)[^\]]+(?=\])/, + lookbehind: true, + inside: {} // see below + }, + variable: { + pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, + lookbehind: true + }, + url: { + pattern: /(^\]\()[^\s)]+/, + lookbehind: true + }, + string: { + pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, + lookbehind: true + } + } + } + }) + ;['url', 'bold', 'italic', 'strike'].forEach(function (token) { + ;['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach( + function (inside) { + if (token !== inside) { + Prism.languages.markdown[token].inside.content.inside[inside] = + Prism.languages.markdown[inside] + } + } + ) + }) + Prism.hooks.add('after-tokenize', function (env) { + if (env.language !== 'markdown' && env.language !== 'md') { + return + } + function walkTokens(tokens) { + if (!tokens || typeof tokens === 'string') { + return + } + for (var i = 0, l = tokens.length; i < l; i++) { + var token = tokens[i] + if (token.type !== 'code') { + walkTokens(token.content) + continue + } + + /* + * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token + * is optional. But the grammar is defined so that there is only one case we have to handle: + * + * token.content = [ + * ```, + * xxxx, + * '\n', // exactly one new lines (\r or \n or \r\n) + * ..., + * '\n', // exactly one new lines again + * ``` + * ]; + */ + + var codeLang = token.content[1] + var codeBlock = token.content[3] + if ( + codeLang && + codeBlock && + codeLang.type === 'code-language' && + codeBlock.type === 'code-block' && + typeof codeLang.content === 'string' + ) { + // this might be a language that Prism does not support + + // do some replacements to support C++, C#, and F# + var lang = codeLang.content + .replace(/\b#/g, 'sharp') + .replace(/\b\+\+/g, 'pp') + // only use the first word + lang = (/[a-z][\w-]*/i.exec(lang) || [''])[0].toLowerCase() + var alias = 'language-' + lang + + // add alias + if (!codeBlock.alias) { + codeBlock.alias = [alias] + } else if (typeof codeBlock.alias === 'string') { + codeBlock.alias = [codeBlock.alias, alias] + } else { + codeBlock.alias.push(alias) + } + } + } + } + walkTokens(env.tokens) + }) + Prism.hooks.add('wrap', function (env) { + if (env.type !== 'code-block') { + return + } + var codeLang = '' + for (var i = 0, l = env.classes.length; i < l; i++) { + var cls = env.classes[i] + var match = /language-(.+)/.exec(cls) + if (match) { + codeLang = match[1] + break + } + } + var grammar = Prism.languages[codeLang] + if (!grammar) { + if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) { + var id = + 'md-' + + new Date().valueOf() + + '-' + + Math.floor(Math.random() * 1e16) + env.attributes['id'] = id + Prism.plugins.autoloader.loadLanguages(codeLang, function () { + var ele = document.getElementById(id) + if (ele) { + ele.innerHTML = Prism.highlight( + ele.textContent, + Prism.languages[codeLang], + codeLang + ) + } + }) + } + } else { + env.content = Prism.highlight(env.content.value, grammar, codeLang) + } + }) + var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi') + + /** + * A list of known entity names. + * + * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function. + * + * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2} + */ + var KNOWN_ENTITY_NAMES = { + amp: '&', + lt: '<', + gt: '>', + quot: '"' + } + + // IE 11 doesn't support `String.fromCodePoint` + var fromCodePoint = String.fromCodePoint || String.fromCharCode + + /** + * Returns the text content of a given HTML source code string. + * + * @param {string} html + * @returns {string} + */ + function textContent(html) { + // remove all tags + var text = html.replace(tagPattern, '') + + // decode known entities + text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function (m, code) { + code = code.toLowerCase() + if (code[0] === '#') { + var value + if (code[1] === 'x') { + value = parseInt(code.slice(2), 16) + } else { + value = Number(code.slice(1)) + } + return fromCodePoint(value) + } else { + var known = KNOWN_ENTITY_NAMES[code] + if (known) { + return known + } + + // unable to decode + return m + } + }) + return text + } + Prism.languages.md = Prism.languages.markdown + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ba4adc40695953c31751a1ac95ac2ce544ed252 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function markupTemplating(Prism: any): void; +declare namespace markupTemplating { + let displayName: string; + let aliases: any[]; +} +export default markupTemplating; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.js new file mode 100644 index 0000000000000000000000000000000000000000..9941bf0b9688052e373bfc7779a82b470dc9a0fb --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup-templating.js @@ -0,0 +1,134 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +import refractorMarkup from './markup.js' +markupTemplating.displayName = 'markup-templating' +markupTemplating.aliases = [] + +/** @param {Refractor} Prism */ +export default function markupTemplating(Prism) { + Prism.register(refractorMarkup) + ;(function (Prism) { + /** + * Returns the placeholder for the given language id and index. + * + * @param {string} language + * @param {string|number} index + * @returns {string} + */ + function getPlaceholder(language, index) { + return '___' + language.toUpperCase() + index + '___' + } + Object.defineProperties((Prism.languages['markup-templating'] = {}), { + buildPlaceholders: { + /** + * Tokenize all inline templating expressions matching `placeholderPattern`. + * + * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns + * `true` will be replaced. + * + * @param {object} env The environment of the `before-tokenize` hook. + * @param {string} language The language id. + * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders. + * @param {(match: string) => boolean} [replaceFilter] + */ + value: function (env, language, placeholderPattern, replaceFilter) { + if (env.language !== language) { + return + } + var tokenStack = (env.tokenStack = []) + env.code = env.code.replace(placeholderPattern, function (match) { + if (typeof replaceFilter === 'function' && !replaceFilter(match)) { + return match + } + var i = tokenStack.length + var placeholder + + // Check for existing strings + while ( + env.code.indexOf((placeholder = getPlaceholder(language, i))) !== + -1 + ) { + ++i + } + + // Create a sparse array + tokenStack[i] = match + return placeholder + }) + + // Switch the grammar to markup + env.grammar = Prism.languages.markup + } + }, + tokenizePlaceholders: { + /** + * Replace placeholders with proper tokens after tokenizing. + * + * @param {object} env The environment of the `after-tokenize` hook. + * @param {string} language The language id. + */ + value: function (env, language) { + if (env.language !== language || !env.tokenStack) { + return + } + + // Switch the grammar back + env.grammar = Prism.languages[language] + var j = 0 + var keys = Object.keys(env.tokenStack) + function walkTokens(tokens) { + for (var i = 0; i < tokens.length; i++) { + // all placeholders are replaced already + if (j >= keys.length) { + break + } + var token = tokens[i] + if ( + typeof token === 'string' || + (token.content && typeof token.content === 'string') + ) { + var k = keys[j] + var t = env.tokenStack[k] + var s = typeof token === 'string' ? token : token.content + var placeholder = getPlaceholder(language, k) + var index = s.indexOf(placeholder) + if (index > -1) { + ++j + var before = s.substring(0, index) + var middle = new Prism.Token( + language, + Prism.tokenize(t, env.grammar), + 'language-' + language, + t + ) + var after = s.substring(index + placeholder.length) + var replacement = [] + if (before) { + replacement.push.apply(replacement, walkTokens([before])) + } + replacement.push(middle) + if (after) { + replacement.push.apply(replacement, walkTokens([after])) + } + if (typeof token === 'string') { + tokens.splice.apply(tokens, [i, 1].concat(replacement)) + } else { + token.content = replacement + } + } + } else if ( + token.content /* && typeof token.content !== 'string' */ + ) { + walkTokens(token.content) + } + } + return tokens + } + walkTokens(env.tokens) + } + } + }) + })(Prism) +} diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.d.ts b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ab704e94c2b0dba9ebe603b81bf137ee6c002393 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.d.ts @@ -0,0 +1,7 @@ +/** @type {import('../core.js').Syntax} */ +declare function markup(Prism: any): void; +declare namespace markup { + let displayName: string; + let aliases: string[]; +} +export default markup; diff --git a/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.js b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.js new file mode 100644 index 0000000000000000000000000000000000000000..f43930cc15ba1d524ece97b107a682236b7840b0 --- /dev/null +++ b/loan-advisor-chatgpt-app/node_modules/refractor/lang/markup.js @@ -0,0 +1,202 @@ +// @ts-nocheck +/** + * @import {Refractor} from '../lib/core.js' + */ +markup.displayName = 'markup' +markup.aliases = ['atom', 'html', 'mathml', 'rss', 'ssml', 'svg', 'xml'] + +/** @param {Refractor} Prism */ +export default function markup(Prism) { + Prism.languages.markup = { + comment: { + pattern: //, + greedy: true + }, + prolog: { + pattern: /<\?[\s\S]+?\?>/, + greedy: true + }, + doctype: { + // https://www.w3.org/TR/xml/#NT-doctypedecl + pattern: + /"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|)*\]\s*)?>/i, + greedy: true, + inside: { + 'internal-subset': { + pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, + lookbehind: true, + greedy: true, + inside: null // see below + }, + string: { + pattern: /"[^"]*"|'[^']*'/, + greedy: true + }, + punctuation: /^$|[[\]]/, + 'doctype-tag': /^DOCTYPE/i, + name: /[^\s<>'"]+/ + } + }, + cdata: { + pattern: //i, + greedy: true + }, + tag: { + pattern: + /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/, + greedy: true, + inside: { + tag: { + pattern: /^<\/?[^\s>\/]+/, + inside: { + punctuation: /^<\/?/, + namespace: /^[^\s>\/:]+:/ + } + }, + 'special-attr': [], + 'attr-value': { + pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/, + inside: { + punctuation: [ + { + pattern: /^=/, + alias: 'attr-equals' + }, + { + pattern: /^(\s*)["']|["']$/, + lookbehind: true + } + ] + } + }, + punctuation: /\/?>/, + 'attr-name': { + pattern: /[^\s>\/]+/, + inside: { + namespace: /^[^\s>\/:]+:/ + } + } + } + }, + entity: [ + { + pattern: /&[\da-z]{1,8};/i, + alias: 'named-entity' + }, + /&#x?[\da-f]{1,8};/i + ] + } + Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = + Prism.languages.markup['entity'] + Prism.languages.markup['doctype'].inside['internal-subset'].inside = + Prism.languages.markup + + // Plugin to make entity title show the real entity, idea by Roman Komarov + Prism.hooks.add('wrap', function (env) { + if (env.type === 'entity') { + env.attributes['title'] = env.content.value.replace(/&/, '&') + } + }) + Object.defineProperty(Prism.languages.markup.tag, 'addInlined', { + /** + * Adds an inlined language to markup. + * + * An example of an inlined language is CSS with `