@webskill/chatbot 0.0.1

package/dist/rust-DwYwyKSC.js

@@ -0,0 +1,86 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/rust.js
+var require_rust = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function rust(hljs) {
+		const KEYWORDS = "abstract as async await become box break const continue crate do dyn else enum extern false final fn for if impl in let loop macro match mod move mut override priv pub ref return self Self static struct super trait true try type typeof unsafe unsized use virtual where while yield";
+		const BUILTINS = "drop i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 str char bool Box Option Result String Vec Copy Send Sized Sync Drop Fn FnMut FnOnce ToOwned Clone Debug PartialEq PartialOrd Eq Ord AsRef AsMut Into From Default Iterator Extend IntoIterator DoubleEndedIterator ExactSizeIterator SliceConcatExt ToString assert! assert_eq! bitflags! bytes! cfg! col! concat! concat_idents! debug_assert! debug_assert_eq! env! panic! file! format! format_args! include_bin! include_str! line! local_data_key! module_path! option_env! print! println! select! stringify! try! unimplemented! unreachable! vec! write! writeln! macro_rules! assert_ne! debug_assert_ne!";
+		return {
+			name: "Rust",
+			aliases: ["rs"],
+			keywords: {
+				$pattern: hljs.IDENT_RE + "!?",
+				keyword: KEYWORDS,
+				literal: "true false Some None Ok Err",
+				built_in: BUILTINS
+			},
+			illegal: "</",
+			contains: [
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
+				hljs.inherit(hljs.QUOTE_STRING_MODE, {
+					begin: /b?"/,
+					illegal: null
+				}),
+				{
+					className: "string",
+					variants: [{ begin: /r(#*)"(.|\n)*?"\1(?!#)/ }, { begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/ }]
+				},
+				{
+					className: "symbol",
+					begin: /'[a-zA-Z_][a-zA-Z0-9_]*/
+				},
+				{
+					className: "number",
+					variants: [
+						{ begin: "\\b0b([01_]+)([ui](8|16|32|64|128|size)|f(32|64))?" },
+						{ begin: "\\b0o([0-7_]+)([ui](8|16|32|64|128|size)|f(32|64))?" },
+						{ begin: "\\b0x([A-Fa-f0-9_]+)([ui](8|16|32|64|128|size)|f(32|64))?" },
+						{ begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)([ui](8|16|32|64|128|size)|f(32|64))?" }
+					],
+					relevance: 0
+				},
+				{
+					className: "function",
+					beginKeywords: "fn",
+					end: "(\\(|<)",
+					excludeEnd: true,
+					contains: [hljs.UNDERSCORE_TITLE_MODE]
+				},
+				{
+					className: "meta",
+					begin: "#!?\\[",
+					end: "\\]",
+					contains: [{
+						className: "meta-string",
+						begin: /"/,
+						end: /"/
+					}]
+				},
+				{
+					className: "class",
+					beginKeywords: "type",
+					end: ";",
+					contains: [hljs.inherit(hljs.UNDERSCORE_TITLE_MODE, { endsParent: true })],
+					illegal: "\\S"
+				},
+				{
+					className: "class",
+					beginKeywords: "trait enum struct union",
+					end: /\{/,
+					contains: [hljs.inherit(hljs.UNDERSCORE_TITLE_MODE, { endsParent: true })],
+					illegal: "[\\w\\d]"
+				},
+				{
+					begin: hljs.IDENT_RE + "::",
+					keywords: { built_in: BUILTINS }
+				},
+				{ begin: "->" }
+			]
+		};
+	}
+	module.exports = rust;
+}));
+
+//#endregion
+export default require_rust();

package/dist/rust-NN7KgEj6.js

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rust.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+rust.displayName = "rust";
+rust.aliases = [];
+/** @param {Refractor} Prism */
+function rust(Prism) {
+	(function(Prism) {
+		var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
+		for (var i = 0; i < 2; i++) multilineComment = multilineComment.replace(/<self>/g, function() {
+			return multilineComment;
+		});
+		multilineComment = multilineComment.replace(/<self>/g, function() {
+			return /[^\s\S]/.source;
+		});
+		Prism.languages.rust = {
+			comment: [{
+				pattern: RegExp(/(^|[^\\])/.source + multilineComment),
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: /(^|[^\\:])\/\/.*/,
+				lookbehind: true,
+				greedy: true
+			}],
+			string: {
+				pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+				greedy: true
+			},
+			char: {
+				pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+				greedy: true
+			},
+			attribute: {
+				pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+				greedy: true,
+				alias: "attr-name",
+				inside: { string: null }
+			},
+			"closure-params": {
+				pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					"closure-punctuation": {
+						pattern: /^\||\|$/,
+						alias: "punctuation"
+					},
+					rest: null
+				}
+			},
+			"lifetime-annotation": {
+				pattern: /'\w+/,
+				alias: "symbol"
+			},
+			"fragment-specifier": {
+				pattern: /(\$\w+:)[a-z]+/,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			variable: /\$\w+/,
+			"function-definition": {
+				pattern: /(\bfn\s+)\w+/,
+				lookbehind: true,
+				alias: "function"
+			},
+			"type-definition": {
+				pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+				lookbehind: true,
+				alias: "class-name"
+			},
+			"module-declaration": [{
+				pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+				lookbehind: true,
+				alias: "namespace"
+			}, {
+				pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+				lookbehind: true,
+				alias: "namespace",
+				inside: { punctuation: /::/ }
+			}],
+			keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/],
+			function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+			macro: {
+				pattern: /\b\w+!/,
+				alias: "property"
+			},
+			constant: /\b[A-Z_][A-Z_\d]+\b/,
+			"class-name": /\b[A-Z]\w*\b/,
+			namespace: {
+				pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+				inside: { punctuation: /::/ }
+			},
+			number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+			boolean: /\b(?:false|true)\b/,
+			punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+			operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+		};
+		Prism.languages.rust["closure-params"].inside.rest = Prism.languages.rust;
+		Prism.languages.rust["attribute"].inside["string"] = Prism.languages.rust["string"];
+	})(Prism);
+}
+
+//#endregion
+export { rust as default };

package/dist/sas-B1HEHqVJ.js

@@ -0,0 +1,52 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/sas.js
+var require_sas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function sas(hljs) {
+		return {
+			name: "SAS",
+			case_insensitive: true,
+			keywords: {
+				literal: "null missing _all_ _automatic_ _character_ _infile_ _n_ _name_ _null_ _numeric_ _user_ _webout_",
+				meta: "do if then else end until while abort array attrib by call cards cards4 catname continue datalines datalines4 delete delim delimiter display dm drop endsas error file filename footnote format goto in infile informat input keep label leave length libname link list lostcard merge missing modify options output out page put redirect remove rename replace retain return select set skip startsas stop title update waitsas where window x systask add and alter as cascade check create delete describe distinct drop foreign from group having index insert into in key like message modify msgtype not null on or order primary references reset restrict select set table unique update validate view where"
+			},
+			contains: [
+				{
+					className: "keyword",
+					begin: /^\s*(proc [\w\d_]+|data|run|quit)[\s;]/
+				},
+				{
+					className: "variable",
+					begin: /&[a-zA-Z_&][a-zA-Z0-9_]*\.?/
+				},
+				{
+					className: "emphasis",
+					begin: /^\s*datalines|cards.*;/,
+					end: /^\s*;\s*$/
+				},
+				{
+					className: "built_in",
+					begin: "%(bquote|nrbquote|cmpres|qcmpres|compstor|datatyp|display|do|else|end|eval|global|goto|if|index|input|keydef|label|left|length|let|local|lowcase|macro|mend|nrbquote|nrquote|nrstr|put|qcmpres|qleft|qlowcase|qscan|qsubstr|qsysfunc|qtrim|quote|qupcase|scan|str|substr|superq|syscall|sysevalf|sysexec|sysfunc|sysget|syslput|sysprod|sysrc|sysrput|then|to|trim|unquote|until|upcase|verify|while|window)"
+				},
+				{
+					className: "name",
+					begin: /%[a-zA-Z_][a-zA-Z_0-9]*/
+				},
+				{
+					className: "meta",
+					begin: "[^%](abs|addr|airy|arcos|arsin|atan|attrc|attrn|band|betainv|blshift|bnot|bor|brshift|bxor|byte|cdf|ceil|cexist|cinv|close|cnonct|collate|compbl|compound|compress|cos|cosh|css|curobs|cv|daccdb|daccdbsl|daccsl|daccsyd|dacctab|dairy|date|datejul|datepart|datetime|day|dclose|depdb|depdbsl|depdbsl|depsl|depsl|depsyd|depsyd|deptab|deptab|dequote|dhms|dif|digamma|dim|dinfo|dnum|dopen|doptname|doptnum|dread|dropnote|dsname|erf|erfc|exist|exp|fappend|fclose|fcol|fdelete|fetch|fetchobs|fexist|fget|fileexist|filename|fileref|finfo|finv|fipname|fipnamel|fipstate|floor|fnonct|fnote|fopen|foptname|foptnum|fpoint|fpos|fput|fread|frewind|frlen|fsep|fuzz|fwrite|gaminv|gamma|getoption|getvarc|getvarn|hbound|hms|hosthelp|hour|ibessel|index|indexc|indexw|input|inputc|inputn|int|intck|intnx|intrr|irr|jbessel|juldate|kurtosis|lag|lbound|left|length|lgamma|libname|libref|log|log10|log2|logpdf|logpmf|logsdf|lowcase|max|mdy|mean|min|minute|mod|month|mopen|mort|n|netpv|nmiss|normal|note|npv|open|ordinal|pathname|pdf|peek|peekc|pmf|point|poisson|poke|probbeta|probbnml|probchi|probf|probgam|probhypr|probit|probnegb|probnorm|probt|put|putc|putn|qtr|quote|ranbin|rancau|ranexp|rangam|range|rank|rannor|ranpoi|rantbl|rantri|ranuni|repeat|resolve|reverse|rewind|right|round|saving|scan|sdf|second|sign|sin|sinh|skewness|soundex|spedis|sqrt|std|stderr|stfips|stname|stnamel|substr|sum|symget|sysget|sysmsg|sysprod|sysrc|system|tan|tanh|time|timepart|tinv|tnonct|today|translate|tranwrd|trigamma|trim|trimn|trunc|uniform|upcase|uss|var|varfmt|varinfmt|varlabel|varlen|varname|varnum|varray|varrayx|vartype|verify|vformat|vformatd|vformatdx|vformatn|vformatnx|vformatw|vformatwx|vformatx|vinarray|vinarrayx|vinformat|vinformatd|vinformatdx|vinformatn|vinformatnx|vinformatw|vinformatwx|vinformatx|vlabel|vlabelx|vlength|vlengthx|vname|vnamex|vtype|vtypex|weekday|year|yyq|zipfips|zipname|zipnamel|zipstate)[(]"
+				},
+				{
+					className: "string",
+					variants: [hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE]
+				},
+				hljs.COMMENT("\\*", ";"),
+				hljs.C_BLOCK_COMMENT_MODE
+			]
+		};
+	}
+	module.exports = sas;
+}));
+
+//#endregion
+export default require_sas();

package/dist/sas-smX4XTMW.js

@@ -0,0 +1,305 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sas.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+sas.displayName = "sas";
+sas.aliases = [];
+/** @param {Refractor} Prism */
+function sas(Prism) {
+	(function(Prism) {
+		var stringPattern = /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))/.source;
+		var number = /\b(?:\d[\da-f]*x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i;
+		var numericConstant = {
+			pattern: RegExp(stringPattern + "[bx]"),
+			alias: "number"
+		};
+		var macroVariable = { pattern: /&[a-z_]\w*/i };
+		var macroKeyword = {
+			pattern: /((?:^|\s|=|\())%(?:ABORT|BY|CMS|COPY|DISPLAY|DO|ELSE|END|EVAL|GLOBAL|GO|GOTO|IF|INC|INCLUDE|INDEX|INPUT|KTRIM|LENGTH|LET|LIST|LOCAL|PUT|QKTRIM|QSCAN|QSUBSTR|QSYSFUNC|QUPCASE|RETURN|RUN|SCAN|SUBSTR|SUPERQ|SYMDEL|SYMEXIST|SYMGLOBL|SYMLOCAL|SYSCALL|SYSEVALF|SYSEXEC|SYSFUNC|SYSGET|SYSRPUT|THEN|TO|TSO|UNQUOTE|UNTIL|UPCASE|WHILE|WINDOW)\b/i,
+			lookbehind: true,
+			alias: "keyword"
+		};
+		var step = {
+			pattern: /(^|\s)(?:proc\s+\w+|data(?!=)|quit|run)\b/i,
+			alias: "keyword",
+			lookbehind: true
+		};
+		var comment = [/\/\*[\s\S]*?\*\//, {
+			pattern: /(^[ \t]*|;\s*)\*[^;]*;/m,
+			lookbehind: true
+		}];
+		var string = {
+			pattern: RegExp(stringPattern),
+			greedy: true
+		};
+		var punctuation = /[$%@.(){}\[\];,\\]/;
+		var func = {
+			pattern: /%?\b\w+(?=\()/,
+			alias: "keyword"
+		};
+		var args = {
+			function: func,
+			"arg-value": {
+				pattern: /(=\s*)[A-Z\.]+/i,
+				lookbehind: true
+			},
+			operator: /=/,
+			"macro-variable": macroVariable,
+			arg: {
+				pattern: /[A-Z]+/i,
+				alias: "keyword"
+			},
+			number,
+			"numeric-constant": numericConstant,
+			punctuation,
+			string
+		};
+		var format = {
+			pattern: /\b(?:format|put)\b=?[\w'$.]+/i,
+			inside: {
+				keyword: /^(?:format|put)(?==)/i,
+				equals: /=/,
+				format: {
+					pattern: /(?:\w|\$\d)+\.\d?/,
+					alias: "number"
+				}
+			}
+		};
+		var altformat = {
+			pattern: /\b(?:format|put)\s+[\w']+(?:\s+[$.\w]+)+(?=;)/i,
+			inside: {
+				keyword: /^(?:format|put)/i,
+				format: {
+					pattern: /[\w$]+\.\d?/,
+					alias: "number"
+				}
+			}
+		};
+		var globalStatements = {
+			pattern: /((?:^|\s)=?)(?:catname|checkpoint execute_always|dm|endsas|filename|footnote|%include|libname|%list|lock|missing|options|page|resetline|%run|sasfile|skip|sysecho|title\d?)\b/i,
+			lookbehind: true,
+			alias: "keyword"
+		};
+		var submitStatement = {
+			pattern: /(^|\s)(?:submit(?:\s+(?:load|norun|parseonly))?|endsubmit)\b/i,
+			lookbehind: true,
+			alias: "keyword"
+		};
+		var actionSets = /aStore|accessControl|aggregation|audio|autotune|bayesianNetClassifier|bioMedImage|boolRule|builtins|cardinality|cdm|clustering|conditionalRandomFields|configuration|copula|countreg|dataDiscovery|dataPreprocess|dataSciencePilot|dataStep|decisionTree|deduplication|deepLearn|deepNeural|deepRnn|ds2|ecm|entityRes|espCluster|explainModel|factmac|fastKnn|fcmpact|fedSql|freqTab|gVarCluster|gam|gleam|graphSemiSupLearn|hiddenMarkovModel|hyperGroup|ica|image|iml|kernalPca|langModel|ldaTopic|loadStreams|mbc|mixed|mlTools|modelPublishing|network|neuralNet|nmf|nonParametricBayes|nonlinear|optNetwork|optimization|panel|pca|percentile|phreg|pls|qkb|qlim|quantreg|recommend|regression|reinforcementLearn|robustPca|ruleMining|sampling|sandwich|sccasl|search(?:Analytics)?|sentimentAnalysis|sequence|session(?:Prop)?|severity|simSystem|simple|smartData|sparkEmbeddedProcess|sparseML|spatialreg|spc|stabilityMonitoring|svDataDescription|svm|table|text(?:Filters|Frequency|Mining|Parse|Rule(?:Develop|Score)|Topic|Util)|timeData|transpose|tsInfo|tsReconcile|uniTimeSeries|varReduce/.source;
+		var casActions = {
+			pattern: RegExp(/(^|\s)(?:action\s+)?(?:<act>)\.[a-z]+\b[^;]+/.source.replace(/<act>/g, function() {
+				return actionSets;
+			}), "i"),
+			lookbehind: true,
+			inside: {
+				keyword: RegExp(/(?:<act>)\.[a-z]+\b/.source.replace(/<act>/g, function() {
+					return actionSets;
+				}), "i"),
+				action: {
+					pattern: /(?:action)/i,
+					alias: "keyword"
+				},
+				comment,
+				function: func,
+				"arg-value": args["arg-value"],
+				operator: args.operator,
+				argument: args.arg,
+				number,
+				"numeric-constant": numericConstant,
+				punctuation,
+				string
+			}
+		};
+		var keywords = {
+			pattern: /((?:^|\s)=?)(?:after|analysis|and|array|barchart|barwidth|begingraph|by|call|cas|cbarline|cfill|class(?:lev)?|close|column|computed?|contains|continue|data(?==)|define|delete|describe|document|do\s+over|do|dol|drop|dul|else|end(?:comp|source)?|entryTitle|eval(?:uate)?|exec(?:ute)?|exit|file(?:name)?|fill(?:attrs)?|flist|fnc|function(?:list)?|global|goto|group(?:by)?|headline|headskip|histogram|if|infile|keep|keylabel|keyword|label|layout|leave|legendlabel|length|libname|loadactionset|merge|midpoints|_?null_|name|noobs|nowd|ods|options|or|otherwise|out(?:put)?|over(?:lay)?|plot|print|put|raise|ranexp|rannor|rbreak|retain|return|select|session|sessref|set|source|statgraph|sum|summarize|table|temp|terminate|then\s+do|then|title\d?|to|var|when|where|xaxisopts|y2axisopts|yaxisopts)\b/i,
+			lookbehind: true
+		};
+		Prism.languages.sas = {
+			datalines: {
+				pattern: /^([ \t]*)(?:cards|(?:data)?lines);[\s\S]+?^[ \t]*;/im,
+				lookbehind: true,
+				alias: "string",
+				inside: {
+					keyword: { pattern: /^(?:cards|(?:data)?lines)/i },
+					punctuation: /;/
+				}
+			},
+			"proc-sql": {
+				pattern: /(^proc\s+(?:fed)?sql(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+				lookbehind: true,
+				inside: {
+					sql: {
+						pattern: RegExp(/^[ \t]*(?:select|alter\s+table|(?:create|describe|drop)\s+(?:index|table(?:\s+constraints)?|view)|create\s+unique\s+index|insert\s+into|update)(?:<str>|[^;"'])+;/.source.replace(/<str>/g, function() {
+							return stringPattern;
+						}), "im"),
+						alias: "language-sql",
+						inside: Prism.languages.sql
+					},
+					"global-statements": globalStatements,
+					"sql-statements": {
+						pattern: /(^|\s)(?:disconnect\s+from|begin|commit|exec(?:ute)?|reset|rollback|validate)\b/i,
+						lookbehind: true,
+						alias: "keyword"
+					},
+					number,
+					"numeric-constant": numericConstant,
+					punctuation,
+					string
+				}
+			},
+			"proc-groovy": {
+				pattern: /(^proc\s+groovy(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+				lookbehind: true,
+				inside: {
+					comment,
+					groovy: {
+						pattern: RegExp(/(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(/<str>/g, function() {
+							return stringPattern;
+						}), "im"),
+						lookbehind: true,
+						alias: "language-groovy",
+						inside: Prism.languages.groovy
+					},
+					keyword: keywords,
+					"submit-statement": submitStatement,
+					"global-statements": globalStatements,
+					number,
+					"numeric-constant": numericConstant,
+					punctuation,
+					string
+				}
+			},
+			"proc-lua": {
+				pattern: /(^proc\s+lua(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+				lookbehind: true,
+				inside: {
+					comment,
+					lua: {
+						pattern: RegExp(/(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(/<str>/g, function() {
+							return stringPattern;
+						}), "im"),
+						lookbehind: true,
+						alias: "language-lua",
+						inside: Prism.languages.lua
+					},
+					keyword: keywords,
+					"submit-statement": submitStatement,
+					"global-statements": globalStatements,
+					number,
+					"numeric-constant": numericConstant,
+					punctuation,
+					string
+				}
+			},
+			"proc-cas": {
+				pattern: /(^proc\s+cas(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|quit|data);|(?![\s\S]))/im,
+				lookbehind: true,
+				inside: {
+					comment,
+					"statement-var": {
+						pattern: /((?:^|\s)=?)saveresult\s[^;]+/im,
+						lookbehind: true,
+						inside: {
+							statement: {
+								pattern: /^saveresult\s+\S+/i,
+								inside: { keyword: /^(?:saveresult)/i }
+							},
+							rest: args
+						}
+					},
+					"cas-actions": casActions,
+					statement: {
+						pattern: /((?:^|\s)=?)(?:default|(?:un)?set|on|output|upload)[^;]+/im,
+						lookbehind: true,
+						inside: args
+					},
+					step,
+					keyword: keywords,
+					function: func,
+					format,
+					altformat,
+					"global-statements": globalStatements,
+					number,
+					"numeric-constant": numericConstant,
+					punctuation,
+					string
+				}
+			},
+			"proc-args": {
+				pattern: RegExp(/(^proc\s+\w+\s+)(?!\s)(?:[^;"']|<str>)+;/.source.replace(/<str>/g, function() {
+					return stringPattern;
+				}), "im"),
+				lookbehind: true,
+				inside: args
+			},
+			"macro-keyword": macroKeyword,
+			"macro-variable": macroVariable,
+			"macro-string-functions": {
+				pattern: /((?:^|\s|=))%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)\(.*?(?:[^%]\))/i,
+				lookbehind: true,
+				inside: {
+					function: {
+						pattern: /%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)/i,
+						alias: "keyword"
+					},
+					"macro-keyword": macroKeyword,
+					"macro-variable": macroVariable,
+					"escaped-char": { pattern: /%['"()<>=¬^~;,#]/ },
+					punctuation
+				}
+			},
+			"macro-declaration": {
+				pattern: /^%macro[^;]+(?=;)/im,
+				inside: { keyword: /%macro/i }
+			},
+			"macro-end": {
+				pattern: /^%mend[^;]+(?=;)/im,
+				inside: { keyword: /%mend/i }
+			},
+			macro: {
+				pattern: /%_\w+(?=\()/,
+				alias: "keyword"
+			},
+			input: {
+				pattern: /\binput\s[-\w\s/*.$&]+;/i,
+				inside: {
+					input: {
+						alias: "keyword",
+						pattern: /^input/i
+					},
+					comment,
+					number,
+					"numeric-constant": numericConstant
+				}
+			},
+			"options-args": {
+				pattern: /(^options)[-'"|/\\<>*+=:()\w\s]*(?=;)/im,
+				lookbehind: true,
+				inside: args
+			},
+			"cas-actions": casActions,
+			comment,
+			function: func,
+			format,
+			altformat,
+			"numeric-constant": numericConstant,
+			datetime: {
+				pattern: RegExp(stringPattern + "(?:dt?|t)"),
+				alias: "number"
+			},
+			string,
+			step,
+			keyword: keywords,
+			"operator-keyword": {
+				pattern: /\b(?:eq|ge|gt|in|le|lt|ne|not)\b/i,
+				alias: "operator"
+			},
+			number,
+			operator: /\*\*?|\|\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\/=&]|[~¬^]=?/,
+			punctuation
+		};
+	})(Prism);
+}
+
+//#endregion
+export { sas as default };

package/dist/sass-C7gSyJgV.js

@@ -0,0 +1,65 @@
+import css from "./css-Q6-w6BPM.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sass.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+sass.displayName = "sass";
+sass.aliases = [];
+/** @param {Refractor} Prism */
+function sass(Prism) {
+	Prism.register(css);
+	(function(Prism) {
+		Prism.languages.sass = Prism.languages.extend("css", { comment: {
+			pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
+			lookbehind: true,
+			greedy: true
+		} });
+		Prism.languages.insertBefore("sass", "atrule", { "atrule-line": {
+			pattern: /^(?:[ \t]*)[@+=].+/m,
+			greedy: true,
+			inside: { atrule: /(?:@[\w-]+|[+=])/ }
+		} });
+		delete Prism.languages.sass.atrule;
+		var variable = /\$[-\w]+|#\{\$[-\w]+\}/;
+		var operator = [/[+*\/%]|[=!]=|<=?|>=?|\b(?:and|not|or)\b/, {
+			pattern: /(\s)-(?=\s)/,
+			lookbehind: true
+		}];
+		Prism.languages.insertBefore("sass", "property", {
+			"variable-line": {
+				pattern: /^[ \t]*\$.+/m,
+				greedy: true,
+				inside: {
+					punctuation: /:/,
+					variable,
+					operator
+				}
+			},
+			"property-line": {
+				pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
+				greedy: true,
+				inside: {
+					property: [/[^:\s]+(?=\s*:)/, {
+						pattern: /(:)[^:\s]+/,
+						lookbehind: true
+					}],
+					punctuation: /:/,
+					variable,
+					operator,
+					important: Prism.languages.sass.important
+				}
+			}
+		});
+		delete Prism.languages.sass.property;
+		delete Prism.languages.sass.important;
+		Prism.languages.insertBefore("sass", "punctuation", { selector: {
+			pattern: /^([ \t]*)\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*)*/m,
+			lookbehind: true,
+			greedy: true
+		} });
+	})(Prism);
+}
+
+//#endregion
+export { sass as default };