@webskill/chatbot 0.0.1

package/dist/swift-B_iuCH-N.js

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/swift.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+swift.displayName = "swift";
+swift.aliases = [];
+/** @param {Refractor} Prism */
+function swift(Prism) {
+	Prism.languages.swift = {
+		comment: {
+			pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+			lookbehind: true,
+			greedy: true
+		},
+		"string-literal": [{
+			pattern: RegExp(/(^|[^"#])/.source + "(?:" + /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+					lookbehind: true,
+					inside: null
+				},
+				"interpolation-punctuation": {
+					pattern: /^\)|\\\($/,
+					alias: "punctuation"
+				},
+				punctuation: /\\(?=[\r\n])/,
+				string: /[\s\S]+/
+			}
+		}, {
+			pattern: RegExp(/(^|[^"#])(#+)/.source + "(?:" + /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+					lookbehind: true,
+					inside: null
+				},
+				"interpolation-punctuation": {
+					pattern: /^\)|\\#+\($/,
+					alias: "punctuation"
+				},
+				string: /[\s\S]+/
+			}
+		}],
+		directive: {
+			pattern: RegExp(/#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"),
+			alias: "property",
+			inside: {
+				"directive-name": /^#\w+/,
+				boolean: /\b(?:false|true)\b/,
+				number: /\b\d+(?:\.\d+)*\b/,
+				operator: /!|&&|\|\||[<>]=?/,
+				punctuation: /[(),]/
+			}
+		},
+		literal: {
+			pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+			alias: "constant"
+		},
+		"other-directive": {
+			pattern: /#\w+\b/,
+			alias: "property"
+		},
+		attribute: {
+			pattern: /@\w+/,
+			alias: "atrule"
+		},
+		"function-definition": {
+			pattern: /(\bfunc\s+)\w+/,
+			lookbehind: true,
+			alias: "function"
+		},
+		label: {
+			pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+			lookbehind: true,
+			alias: "important"
+		},
+		keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+		boolean: /\b(?:false|true)\b/,
+		nil: {
+			pattern: /\bnil\b/,
+			alias: "constant"
+		},
+		"short-argument": /\$\d+\b/,
+		omit: {
+			pattern: /\b_\b/,
+			alias: "keyword"
+		},
+		number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+		"class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+		function: /\b[a-z_]\w*(?=\s*\()/i,
+		constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+		operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+		punctuation: /[{}[\]();,.:\\]/
+	};
+	Prism.languages.swift["string-literal"].forEach(function(rule) {
+		rule.inside["interpolation"].inside = Prism.languages.swift;
+	});
+}
+
+//#endregion
+export { swift as default };

package/dist/swift-D2JCuwOw.js

@@ -0,0 +1,603 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/swift.js
+var require_swift = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* @param {string} value
+	* @returns {RegExp}
+	* */
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function source(re) {
+		if (!re) return null;
+		if (typeof re === "string") return re;
+		return re.source;
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function lookahead(re) {
+		return concat("(?=", re, ")");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] } args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + args.map((x) => source(x)).join("|") + ")";
+	}
+	const keywordWrapper = (keyword) => concat(/\b/, keyword, /\w$/.test(keyword) ? /\b/ : /\B/);
+	const dotKeywords = ["Protocol", "Type"].map(keywordWrapper);
+	const optionalDotKeywords = ["init", "self"].map(keywordWrapper);
+	const keywordTypes = ["Any", "Self"];
+	const keywords = [
+		"associatedtype",
+		"async",
+		"await",
+		/as\?/,
+		/as!/,
+		"as",
+		"break",
+		"case",
+		"catch",
+		"class",
+		"continue",
+		"convenience",
+		"default",
+		"defer",
+		"deinit",
+		"didSet",
+		"do",
+		"dynamic",
+		"else",
+		"enum",
+		"extension",
+		"fallthrough",
+		/fileprivate\(set\)/,
+		"fileprivate",
+		"final",
+		"for",
+		"func",
+		"get",
+		"guard",
+		"if",
+		"import",
+		"indirect",
+		"infix",
+		/init\?/,
+		/init!/,
+		"inout",
+		/internal\(set\)/,
+		"internal",
+		"in",
+		"is",
+		"lazy",
+		"let",
+		"mutating",
+		"nonmutating",
+		/open\(set\)/,
+		"open",
+		"operator",
+		"optional",
+		"override",
+		"postfix",
+		"precedencegroup",
+		"prefix",
+		/private\(set\)/,
+		"private",
+		"protocol",
+		/public\(set\)/,
+		"public",
+		"repeat",
+		"required",
+		"rethrows",
+		"return",
+		"set",
+		"some",
+		"static",
+		"struct",
+		"subscript",
+		"super",
+		"switch",
+		"throws",
+		"throw",
+		/try\?/,
+		/try!/,
+		"try",
+		"typealias",
+		/unowned\(safe\)/,
+		/unowned\(unsafe\)/,
+		"unowned",
+		"var",
+		"weak",
+		"where",
+		"while",
+		"willSet"
+	];
+	const literals = [
+		"false",
+		"nil",
+		"true"
+	];
+	const precedencegroupKeywords = [
+		"assignment",
+		"associativity",
+		"higherThan",
+		"left",
+		"lowerThan",
+		"none",
+		"right"
+	];
+	const numberSignKeywords = [
+		"#colorLiteral",
+		"#column",
+		"#dsohandle",
+		"#else",
+		"#elseif",
+		"#endif",
+		"#error",
+		"#file",
+		"#fileID",
+		"#fileLiteral",
+		"#filePath",
+		"#function",
+		"#if",
+		"#imageLiteral",
+		"#keyPath",
+		"#line",
+		"#selector",
+		"#sourceLocation",
+		"#warn_unqualified_access",
+		"#warning"
+	];
+	const builtIns = [
+		"abs",
+		"all",
+		"any",
+		"assert",
+		"assertionFailure",
+		"debugPrint",
+		"dump",
+		"fatalError",
+		"getVaList",
+		"isKnownUniquelyReferenced",
+		"max",
+		"min",
+		"numericCast",
+		"pointwiseMax",
+		"pointwiseMin",
+		"precondition",
+		"preconditionFailure",
+		"print",
+		"readLine",
+		"repeatElement",
+		"sequence",
+		"stride",
+		"swap",
+		"swift_unboxFromSwiftValueWithType",
+		"transcode",
+		"type",
+		"unsafeBitCast",
+		"unsafeDowncast",
+		"withExtendedLifetime",
+		"withUnsafeMutablePointer",
+		"withUnsafePointer",
+		"withVaList",
+		"withoutActuallyEscaping",
+		"zip"
+	];
+	const operatorHead = either(/[/=\-+!*%<>&|^~?]/, /[\u00A1-\u00A7]/, /[\u00A9\u00AB]/, /[\u00AC\u00AE]/, /[\u00B0\u00B1]/, /[\u00B6\u00BB\u00BF\u00D7\u00F7]/, /[\u2016-\u2017]/, /[\u2020-\u2027]/, /[\u2030-\u203E]/, /[\u2041-\u2053]/, /[\u2055-\u205E]/, /[\u2190-\u23FF]/, /[\u2500-\u2775]/, /[\u2794-\u2BFF]/, /[\u2E00-\u2E7F]/, /[\u3001-\u3003]/, /[\u3008-\u3020]/, /[\u3030]/);
+	const operatorCharacter = either(operatorHead, /[\u0300-\u036F]/, /[\u1DC0-\u1DFF]/, /[\u20D0-\u20FF]/, /[\uFE00-\uFE0F]/, /[\uFE20-\uFE2F]/);
+	const operator = concat(operatorHead, operatorCharacter, "*");
+	const identifierHead = either(/[a-zA-Z_]/, /[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/, /[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/, /[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/, /[\u1E00-\u1FFF]/, /[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/, /[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/, /[\u2C00-\u2DFF\u2E80-\u2FFF]/, /[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/, /[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/, /[\uFE47-\uFEFE\uFF00-\uFFFD]/);
+	const identifierCharacter = either(identifierHead, /\d/, /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/);
+	const identifier = concat(identifierHead, identifierCharacter, "*");
+	const typeIdentifier = concat(/[A-Z]/, identifierCharacter, "*");
+	const keywordAttributes = [
+		"autoclosure",
+		concat(/convention\(/, either("swift", "block", "c"), /\)/),
+		"discardableResult",
+		"dynamicCallable",
+		"dynamicMemberLookup",
+		"escaping",
+		"frozen",
+		"GKInspectable",
+		"IBAction",
+		"IBDesignable",
+		"IBInspectable",
+		"IBOutlet",
+		"IBSegueAction",
+		"inlinable",
+		"main",
+		"nonobjc",
+		"NSApplicationMain",
+		"NSCopying",
+		"NSManaged",
+		concat(/objc\(/, identifier, /\)/),
+		"objc",
+		"objcMembers",
+		"propertyWrapper",
+		"requires_stored_property_inits",
+		"testable",
+		"UIApplicationMain",
+		"unknown",
+		"usableFromInline"
+	];
+	const availabilityKeywords = [
+		"iOS",
+		"iOSApplicationExtension",
+		"macOS",
+		"macOSApplicationExtension",
+		"macCatalyst",
+		"macCatalystApplicationExtension",
+		"watchOS",
+		"watchOSApplicationExtension",
+		"tvOS",
+		"tvOSApplicationExtension",
+		"swift"
+	];
+	/** @type LanguageFn */
+	function swift(hljs) {
+		const WHITESPACE = {
+			match: /\s+/,
+			relevance: 0
+		};
+		const BLOCK_COMMENT = hljs.COMMENT("/\\*", "\\*/", { contains: ["self"] });
+		const COMMENTS = [hljs.C_LINE_COMMENT_MODE, BLOCK_COMMENT];
+		const DOT_KEYWORD = {
+			className: "keyword",
+			begin: concat(/\./, lookahead(either(...dotKeywords, ...optionalDotKeywords))),
+			end: either(...dotKeywords, ...optionalDotKeywords),
+			excludeBegin: true
+		};
+		const KEYWORD_GUARD = {
+			match: concat(/\./, either(...keywords)),
+			relevance: 0
+		};
+		const PLAIN_KEYWORDS = keywords.filter((kw) => typeof kw === "string").concat(["_|0"]);
+		const KEYWORD = { variants: [{
+			className: "keyword",
+			match: either(...keywords.filter((kw) => typeof kw !== "string").concat(keywordTypes).map(keywordWrapper), ...optionalDotKeywords)
+		}] };
+		const KEYWORDS = {
+			$pattern: either(/\b\w+/, /#\w+/),
+			keyword: PLAIN_KEYWORDS.concat(numberSignKeywords),
+			literal: literals
+		};
+		const KEYWORD_MODES = [
+			DOT_KEYWORD,
+			KEYWORD_GUARD,
+			KEYWORD
+		];
+		const BUILT_INS = [{
+			match: concat(/\./, either(...builtIns)),
+			relevance: 0
+		}, {
+			className: "built_in",
+			match: concat(/\b/, either(...builtIns), /(?=\()/)
+		}];
+		const OPERATOR_GUARD = {
+			match: /->/,
+			relevance: 0
+		};
+		const OPERATORS = [OPERATOR_GUARD, {
+			className: "operator",
+			relevance: 0,
+			variants: [{ match: operator }, { match: `\\.(\\.|${operatorCharacter})+` }]
+		}];
+		const decimalDigits = "([0-9]_*)+";
+		const hexDigits = "([0-9a-fA-F]_*)+";
+		const NUMBER = {
+			className: "number",
+			relevance: 0,
+			variants: [
+				{ match: `\\b(${decimalDigits})(\\.(${decimalDigits}))?([eE][+-]?(${decimalDigits}))?\\b` },
+				{ match: `\\b0x(${hexDigits})(\\.(${hexDigits}))?([pP][+-]?(${decimalDigits}))?\\b` },
+				{ match: /\b0o([0-7]_*)+\b/ },
+				{ match: /\b0b([01]_*)+\b/ }
+			]
+		};
+		const ESCAPED_CHARACTER = (rawDelimiter = "") => ({
+			className: "subst",
+			variants: [{ match: concat(/\\/, rawDelimiter, /[0\\tnr"']/) }, { match: concat(/\\/, rawDelimiter, /u\{[0-9a-fA-F]{1,8}\}/) }]
+		});
+		const ESCAPED_NEWLINE = (rawDelimiter = "") => ({
+			className: "subst",
+			match: concat(/\\/, rawDelimiter, /[\t ]*(?:[\r\n]|\r\n)/)
+		});
+		const INTERPOLATION = (rawDelimiter = "") => ({
+			className: "subst",
+			label: "interpol",
+			begin: concat(/\\/, rawDelimiter, /\(/),
+			end: /\)/
+		});
+		const MULTILINE_STRING = (rawDelimiter = "") => ({
+			begin: concat(rawDelimiter, /"""/),
+			end: concat(/"""/, rawDelimiter),
+			contains: [
+				ESCAPED_CHARACTER(rawDelimiter),
+				ESCAPED_NEWLINE(rawDelimiter),
+				INTERPOLATION(rawDelimiter)
+			]
+		});
+		const SINGLE_LINE_STRING = (rawDelimiter = "") => ({
+			begin: concat(rawDelimiter, /"/),
+			end: concat(/"/, rawDelimiter),
+			contains: [ESCAPED_CHARACTER(rawDelimiter), INTERPOLATION(rawDelimiter)]
+		});
+		const STRING = {
+			className: "string",
+			variants: [
+				MULTILINE_STRING(),
+				MULTILINE_STRING("#"),
+				MULTILINE_STRING("##"),
+				MULTILINE_STRING("###"),
+				SINGLE_LINE_STRING(),
+				SINGLE_LINE_STRING("#"),
+				SINGLE_LINE_STRING("##"),
+				SINGLE_LINE_STRING("###")
+			]
+		};
+		const QUOTED_IDENTIFIER = { match: concat(/`/, identifier, /`/) };
+		const IDENTIFIERS = [
+			QUOTED_IDENTIFIER,
+			{
+				className: "variable",
+				match: /\$\d+/
+			},
+			{
+				className: "variable",
+				match: `\\$${identifierCharacter}+`
+			}
+		];
+		const ATTRIBUTES = [
+			{
+				match: /(@|#)available/,
+				className: "keyword",
+				starts: { contains: [{
+					begin: /\(/,
+					end: /\)/,
+					keywords: availabilityKeywords,
+					contains: [
+						...OPERATORS,
+						NUMBER,
+						STRING
+					]
+				}] }
+			},
+			{
+				className: "keyword",
+				match: concat(/@/, either(...keywordAttributes))
+			},
+			{
+				className: "meta",
+				match: concat(/@/, identifier)
+			}
+		];
+		const TYPE = {
+			match: lookahead(/\b[A-Z]/),
+			relevance: 0,
+			contains: [
+				{
+					className: "type",
+					match: concat(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, identifierCharacter, "+")
+				},
+				{
+					className: "type",
+					match: typeIdentifier,
+					relevance: 0
+				},
+				{
+					match: /[?!]+/,
+					relevance: 0
+				},
+				{
+					match: /\.\.\./,
+					relevance: 0
+				},
+				{
+					match: concat(/\s+&\s+/, lookahead(typeIdentifier)),
+					relevance: 0
+				}
+			]
+		};
+		const GENERIC_ARGUMENTS = {
+			begin: /</,
+			end: />/,
+			keywords: KEYWORDS,
+			contains: [
+				...COMMENTS,
+				...KEYWORD_MODES,
+				...ATTRIBUTES,
+				OPERATOR_GUARD,
+				TYPE
+			]
+		};
+		TYPE.contains.push(GENERIC_ARGUMENTS);
+		const TUPLE = {
+			begin: /\(/,
+			end: /\)/,
+			relevance: 0,
+			keywords: KEYWORDS,
+			contains: [
+				"self",
+				{
+					match: concat(identifier, /\s*:/),
+					keywords: "_|0",
+					relevance: 0
+				},
+				...COMMENTS,
+				...KEYWORD_MODES,
+				...BUILT_INS,
+				...OPERATORS,
+				NUMBER,
+				STRING,
+				...IDENTIFIERS,
+				...ATTRIBUTES,
+				TYPE
+			]
+		};
+		const FUNC_PLUS_TITLE = {
+			beginKeywords: "func",
+			contains: [{
+				className: "title",
+				match: either(QUOTED_IDENTIFIER.match, identifier, operator),
+				endsParent: true,
+				relevance: 0
+			}, WHITESPACE]
+		};
+		const GENERIC_PARAMETERS = {
+			begin: /</,
+			end: />/,
+			contains: [...COMMENTS, TYPE]
+		};
+		const FUNCTION_PARAMETERS = {
+			begin: /\(/,
+			end: /\)/,
+			keywords: KEYWORDS,
+			contains: [
+				{
+					begin: either(lookahead(concat(identifier, /\s*:/)), lookahead(concat(identifier, /\s+/, identifier, /\s*:/))),
+					end: /:/,
+					relevance: 0,
+					contains: [{
+						className: "keyword",
+						match: /\b_\b/
+					}, {
+						className: "params",
+						match: identifier
+					}]
+				},
+				...COMMENTS,
+				...KEYWORD_MODES,
+				...OPERATORS,
+				NUMBER,
+				STRING,
+				...ATTRIBUTES,
+				TYPE,
+				TUPLE
+			],
+			endsParent: true,
+			illegal: /["']/
+		};
+		const FUNCTION = {
+			className: "function",
+			match: lookahead(/\bfunc\b/),
+			contains: [
+				FUNC_PLUS_TITLE,
+				GENERIC_PARAMETERS,
+				FUNCTION_PARAMETERS,
+				WHITESPACE
+			],
+			illegal: [/\[/, /%/]
+		};
+		const INIT_SUBSCRIPT = {
+			className: "function",
+			match: /\b(subscript|init[?!]?)\s*(?=[<(])/,
+			keywords: {
+				keyword: "subscript init init? init!",
+				$pattern: /\w+[?!]?/
+			},
+			contains: [
+				GENERIC_PARAMETERS,
+				FUNCTION_PARAMETERS,
+				WHITESPACE
+			],
+			illegal: /\[|%/
+		};
+		const OPERATOR_DECLARATION = {
+			beginKeywords: "operator",
+			end: hljs.MATCH_NOTHING_RE,
+			contains: [{
+				className: "title",
+				match: operator,
+				endsParent: true,
+				relevance: 0
+			}]
+		};
+		const PRECEDENCEGROUP = {
+			beginKeywords: "precedencegroup",
+			end: hljs.MATCH_NOTHING_RE,
+			contains: [{
+				className: "title",
+				match: typeIdentifier,
+				relevance: 0
+			}, {
+				begin: /{/,
+				end: /}/,
+				relevance: 0,
+				endsParent: true,
+				keywords: [...precedencegroupKeywords, ...literals],
+				contains: [TYPE]
+			}]
+		};
+		for (const variant of STRING.variants) {
+			const interpolation = variant.contains.find((mode) => mode.label === "interpol");
+			interpolation.keywords = KEYWORDS;
+			const submodes = [
+				...KEYWORD_MODES,
+				...BUILT_INS,
+				...OPERATORS,
+				NUMBER,
+				STRING,
+				...IDENTIFIERS
+			];
+			interpolation.contains = [...submodes, {
+				begin: /\(/,
+				end: /\)/,
+				contains: ["self", ...submodes]
+			}];
+		}
+		return {
+			name: "Swift",
+			keywords: KEYWORDS,
+			contains: [
+				...COMMENTS,
+				FUNCTION,
+				INIT_SUBSCRIPT,
+				{
+					className: "class",
+					beginKeywords: "struct protocol class extension enum",
+					end: "\\{",
+					excludeEnd: true,
+					keywords: KEYWORDS,
+					contains: [hljs.inherit(hljs.TITLE_MODE, { begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/ }), ...KEYWORD_MODES]
+				},
+				OPERATOR_DECLARATION,
+				PRECEDENCEGROUP,
+				{
+					beginKeywords: "import",
+					end: /$/,
+					contains: [...COMMENTS],
+					relevance: 0
+				},
+				...KEYWORD_MODES,
+				...BUILT_INS,
+				...OPERATORS,
+				NUMBER,
+				STRING,
+				...IDENTIFIERS,
+				...ATTRIBUTES,
+				TYPE,
+				TUPLE
+			]
+		};
+	}
+	module.exports = swift;
+}));
+
+//#endregion
+export default require_swift();