@webskill/chatbot 0.0.1

package/dist/ocaml-pvUnnUZt.js

@@ -0,0 +1,58 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ocaml.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+ocaml.displayName = "ocaml";
+ocaml.aliases = [];
+/** @param {Refractor} Prism */
+function ocaml(Prism) {
+	Prism.languages.ocaml = {
+		comment: {
+			pattern: /\(\*[\s\S]*?\*\)/,
+			greedy: true
+		},
+		char: {
+			pattern: /'(?:[^\\\r\n']|\\(?:.|[ox]?[0-9a-f]{1,3}))'/i,
+			greedy: true
+		},
+		string: [{
+			pattern: /"(?:\\(?:[\s\S]|\r\n)|[^\\\r\n"])*"/,
+			greedy: true
+		}, {
+			pattern: /\{([a-z_]*)\|[\s\S]*?\|\1\}/,
+			greedy: true
+		}],
+		number: [
+			/\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\b/i,
+			/\b0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]*)?(?:p[+-]?\d[\d_]*)?(?!\w)/i,
+			/\b\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d[\d_]*)?(?!\w)/i
+		],
+		directive: {
+			pattern: /\B#\w+/,
+			alias: "property"
+		},
+		label: {
+			pattern: /\B~\w+/,
+			alias: "property"
+		},
+		"type-variable": {
+			pattern: /\B'\w+/,
+			alias: "function"
+		},
+		variant: {
+			pattern: /`\w+/,
+			alias: "symbol"
+		},
+		keyword: /\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\b/,
+		boolean: /\b(?:false|true)\b/,
+		"operator-like-punctuation": {
+			pattern: /\[[<>|]|[>|]\]|\{<|>\}/,
+			alias: "punctuation"
+		},
+		operator: /\.[.~]|:[=>]|[=<>@^|&+\-*\/$%!?~][!$%&*+\-.\/:<=>?@^|~]*|\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\b/,
+		punctuation: /;;|::|[(){}\[\].,:;#]|\b_\b/
+	};
+}
+
+//#endregion
+export { ocaml as default };

package/dist/odin-BL970IAo.js

@@ -0,0 +1,89 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/odin.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+odin.displayName = "odin";
+odin.aliases = [];
+/** @param {Refractor} Prism */
+function odin(Prism) {
+	(function(Prism) {
+		var escapes = /\\(?:["'\\abefnrtv]|0[0-7]{2}|U[\dA-Fa-f]{6}|u[\dA-Fa-f]{4}|x[\dA-Fa-f]{2})/;
+		Prism.languages.odin = {
+			/**
+			* The current implementation supports only 1 level of nesting.
+			*
+			* @author Michael Schmidt
+			* @author edukisto
+			*/
+			comment: [
+				{
+					pattern: /\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:\*(?!\/)|[^*])*(?:\*\/|$))*(?:\*\/|$)/,
+					greedy: true
+				},
+				{
+					pattern: /#![^\n\r]*/,
+					greedy: true
+				},
+				{
+					pattern: /\/\/[^\n\r]*/,
+					greedy: true
+				}
+			],
+			/**
+			* Should be found before strings because of '"'"- and '`'`-like sequences.
+			*/
+			char: {
+				pattern: /'(?:\\(?:.|[0Uux][0-9A-Fa-f]{1,6})|[^\n\r'\\])'/,
+				greedy: true,
+				inside: { symbol: escapes }
+			},
+			string: [{
+				pattern: /`[^`]*`/,
+				greedy: true
+			}, {
+				pattern: /"(?:\\.|[^\n\r"\\])*"/,
+				greedy: true,
+				inside: { symbol: escapes }
+			}],
+			directive: {
+				pattern: /#\w+/,
+				alias: "property"
+			},
+			number: /\b0(?:b[01_]+|d[\d_]+|h_*(?:(?:(?:[\dA-Fa-f]_*){8}){1,2}|(?:[\dA-Fa-f]_*){4})|o[0-7_]+|x[\dA-F_a-f]+|z[\dAB_ab]+)\b|(?:\b\d+(?:\.(?!\.)\d*)?|\B\.\d+)(?:[Ee][+-]?\d*)?[ijk]?(?!\w)/,
+			discard: {
+				pattern: /\b_\b/,
+				alias: "keyword"
+			},
+			"procedure-definition": {
+				pattern: /\b\w+(?=[ \t]*(?::\s*){2}proc\b)/,
+				alias: "function"
+			},
+			keyword: /\b(?:asm|auto_cast|bit_set|break|case|cast|context|continue|defer|distinct|do|dynamic|else|enum|fallthrough|for|foreign|if|import|in|map|matrix|not_in|or_else|or_return|package|proc|return|struct|switch|transmute|typeid|union|using|when|where)\b/,
+			/**
+			* false, nil, true can be used as procedure names. "_" and keywords can't.
+			*/
+			"procedure-name": {
+				pattern: /\b\w+(?=[ \t]*\()/,
+				alias: "function"
+			},
+			boolean: /\b(?:false|nil|true)\b/,
+			"constant-parameter-sign": {
+				pattern: /\$/,
+				alias: "important"
+			},
+			undefined: {
+				pattern: /---/,
+				alias: "operator"
+			},
+			arrow: {
+				pattern: /->/,
+				alias: "punctuation"
+			},
+			operator: /\+\+|--|\.\.[<=]?|(?:&~|[-!*+/=~]|[%&<>|]{1,2})=?|[?^]/,
+			punctuation: /[(),.:;@\[\]{}]/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { odin as default };

package/dist/opencl-oLMSxXOb.js

@@ -0,0 +1,56 @@
+import { t as c } from "./c-CS0S7Hsb.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/opencl.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+opencl.displayName = "opencl";
+opencl.aliases = [];
+/** @param {Refractor} Prism */
+function opencl(Prism) {
+	Prism.register(c);
+	(function(Prism) {
+		Prism.languages.opencl = Prism.languages.extend("c", {
+			keyword: /\b(?:(?:__)?(?:constant|global|kernel|local|private|read_only|read_write|write_only)|__attribute__|auto|(?:bool|u?(?:char|int|long|short)|half|quad)(?:2|3|4|8|16)?|break|case|complex|const|continue|(?:double|float)(?:16(?:x(?:1|2|4|8|16))?|1x(?:1|2|4|8|16)|2(?:x(?:1|2|4|8|16))?|3|4(?:x(?:1|2|4|8|16))?|8(?:x(?:1|2|4|8|16))?)?|default|do|else|enum|extern|for|goto|if|imaginary|inline|packed|pipe|register|restrict|return|signed|sizeof|static|struct|switch|typedef|uniform|union|unsigned|void|volatile|while)\b/,
+			number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[fuhl]{0,4}/i,
+			boolean: /\b(?:false|true)\b/,
+			"constant-opencl-kernel": {
+				pattern: /\b(?:CHAR_(?:BIT|MAX|MIN)|CLK_(?:ADDRESS_(?:CLAMP(?:_TO_EDGE)?|NONE|REPEAT)|FILTER_(?:LINEAR|NEAREST)|(?:GLOBAL|LOCAL)_MEM_FENCE|NORMALIZED_COORDS_(?:FALSE|TRUE))|CL_(?:BGRA|(?:HALF_)?FLOAT|INTENSITY|LUMINANCE|A?R?G?B?[Ax]?|(?:(?:UN)?SIGNED|[US]NORM)_(?:INT(?:8|16|32))|UNORM_(?:INT_101010|SHORT_(?:555|565)))|(?:DBL|FLT|HALF)_(?:DIG|EPSILON|(?:MAX|MIN)(?:(?:_10)?_EXP)?|MANT_DIG)|FLT_RADIX|HUGE_VALF?|(?:INT|LONG|SCHAR|SHRT)_(?:MAX|MIN)|INFINITY|MAXFLOAT|M_(?:[12]_PI|2_SQRTPI|E|LN(?:2|10)|LOG(?:2|10)E?|PI(?:_[24])?|SQRT(?:1_2|2))(?:_F|_H)?|NAN|(?:UCHAR|UINT|ULONG|USHRT)_MAX)\b/,
+				alias: "constant"
+			}
+		});
+		Prism.languages.insertBefore("opencl", "class-name", { "builtin-type": {
+			pattern: /\b(?:_cl_(?:command_queue|context|device_id|event|kernel|mem|platform_id|program|sampler)|cl_(?:image_format|mem_fence_flags)|clk_event_t|event_t|image(?:1d_(?:array_|buffer_)?t|2d_(?:array_(?:depth_|msaa_depth_|msaa_)?|depth_|msaa_depth_|msaa_)?t|3d_t)|intptr_t|ndrange_t|ptrdiff_t|queue_t|reserve_id_t|sampler_t|size_t|uintptr_t)\b/,
+			alias: "keyword"
+		} });
+		var attributes = {
+			"type-opencl-host": {
+				pattern: /\b(?:cl_(?:GLenum|GLint|GLuin|addressing_mode|bitfield|bool|buffer_create_type|build_status|channel_(?:order|type)|(?:u?(?:char|int|long|short)|double|float)(?:2|3|4|8|16)?|command_(?:queue(?:_info|_properties)?|type)|context(?:_info|_properties)?|device_(?:exec_capabilities|fp_config|id|info|local_mem_type|mem_cache_type|type)|(?:event|sampler)(?:_info)?|filter_mode|half|image_info|kernel(?:_info|_work_group_info)?|map_flags|mem(?:_flags|_info|_object_type)?|platform_(?:id|info)|profiling_info|program(?:_build_info|_info)?))\b/,
+				alias: "keyword"
+			},
+			"boolean-opencl-host": {
+				pattern: /\bCL_(?:FALSE|TRUE)\b/,
+				alias: "boolean"
+			},
+			"constant-opencl-host": {
+				pattern: /\bCL_(?:A|ABGR|ADDRESS_(?:CLAMP(?:_TO_EDGE)?|MIRRORED_REPEAT|NONE|REPEAT)|ARGB|BGRA|BLOCKING|BUFFER_CREATE_TYPE_REGION|BUILD_(?:ERROR|IN_PROGRESS|NONE|PROGRAM_FAILURE|SUCCESS)|COMMAND_(?:ACQUIRE_GL_OBJECTS|BARRIER|COPY_(?:BUFFER(?:_RECT|_TO_IMAGE)?|IMAGE(?:_TO_BUFFER)?)|FILL_(?:BUFFER|IMAGE)|MAP(?:_BUFFER|_IMAGE)|MARKER|MIGRATE(?:_SVM)?_MEM_OBJECTS|NATIVE_KERNEL|NDRANGE_KERNEL|READ_(?:BUFFER(?:_RECT)?|IMAGE)|RELEASE_GL_OBJECTS|SVM_(?:FREE|MAP|MEMCPY|MEMFILL|UNMAP)|TASK|UNMAP_MEM_OBJECT|USER|WRITE_(?:BUFFER(?:_RECT)?|IMAGE))|COMPILER_NOT_AVAILABLE|COMPILE_PROGRAM_FAILURE|COMPLETE|CONTEXT_(?:DEVICES|INTEROP_USER_SYNC|NUM_DEVICES|PLATFORM|PROPERTIES|REFERENCE_COUNT)|DEPTH(?:_STENCIL)?|DEVICE_(?:ADDRESS_BITS|AFFINITY_DOMAIN_(?:L[1-4]_CACHE|NEXT_PARTITIONABLE|NUMA)|AVAILABLE|BUILT_IN_KERNELS|COMPILER_AVAILABLE|DOUBLE_FP_CONFIG|ENDIAN_LITTLE|ERROR_CORRECTION_SUPPORT|EXECUTION_CAPABILITIES|EXTENSIONS|GLOBAL_(?:MEM_(?:CACHELINE_SIZE|CACHE_SIZE|CACHE_TYPE|SIZE)|VARIABLE_PREFERRED_TOTAL_SIZE)|HOST_UNIFIED_MEMORY|IL_VERSION|IMAGE(?:2D_MAX_(?:HEIGHT|WIDTH)|3D_MAX_(?:DEPTH|HEIGHT|WIDTH)|_BASE_ADDRESS_ALIGNMENT|_MAX_ARRAY_SIZE|_MAX_BUFFER_SIZE|_PITCH_ALIGNMENT|_SUPPORT)|LINKER_AVAILABLE|LOCAL_MEM_SIZE|LOCAL_MEM_TYPE|MAX_(?:CLOCK_FREQUENCY|COMPUTE_UNITS|CONSTANT_ARGS|CONSTANT_BUFFER_SIZE|GLOBAL_VARIABLE_SIZE|MEM_ALLOC_SIZE|NUM_SUB_GROUPS|ON_DEVICE_(?:EVENTS|QUEUES)|PARAMETER_SIZE|PIPE_ARGS|READ_IMAGE_ARGS|READ_WRITE_IMAGE_ARGS|SAMPLERS|WORK_GROUP_SIZE|WORK_ITEM_DIMENSIONS|WORK_ITEM_SIZES|WRITE_IMAGE_ARGS)|MEM_BASE_ADDR_ALIGN|MIN_DATA_TYPE_ALIGN_SIZE|NAME|NATIVE_VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT)|NOT_(?:AVAILABLE|FOUND)|OPENCL_C_VERSION|PARENT_DEVICE|PARTITION_(?:AFFINITY_DOMAIN|BY_AFFINITY_DOMAIN|BY_COUNTS|BY_COUNTS_LIST_END|EQUALLY|FAILED|MAX_SUB_DEVICES|PROPERTIES|TYPE)|PIPE_MAX_(?:ACTIVE_RESERVATIONS|PACKET_SIZE)|PLATFORM|PREFERRED_(?:GLOBAL_ATOMIC_ALIGNMENT|INTEROP_USER_SYNC|LOCAL_ATOMIC_ALIGNMENT|PLATFORM_ATOMIC_ALIGNMENT|VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT))|PRINTF_BUFFER_SIZE|PROFILE|PROFILING_TIMER_RESOLUTION|QUEUE_(?:ON_(?:DEVICE_(?:MAX_SIZE|PREFERRED_SIZE|PROPERTIES)|HOST_PROPERTIES)|PROPERTIES)|REFERENCE_COUNT|SINGLE_FP_CONFIG|SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS|SVM_(?:ATOMICS|CAPABILITIES|COARSE_GRAIN_BUFFER|FINE_GRAIN_BUFFER|FINE_GRAIN_SYSTEM)|TYPE(?:_ACCELERATOR|_ALL|_CPU|_CUSTOM|_DEFAULT|_GPU)?|VENDOR(?:_ID)?|VERSION)|DRIVER_VERSION|EVENT_(?:COMMAND_(?:EXECUTION_STATUS|QUEUE|TYPE)|CONTEXT|REFERENCE_COUNT)|EXEC_(?:KERNEL|NATIVE_KERNEL|STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST)|FILTER_(?:LINEAR|NEAREST)|FLOAT|FP_(?:CORRECTLY_ROUNDED_DIVIDE_SQRT|DENORM|FMA|INF_NAN|ROUND_TO_INF|ROUND_TO_NEAREST|ROUND_TO_ZERO|SOFT_FLOAT)|GLOBAL|HALF_FLOAT|IMAGE_(?:ARRAY_SIZE|BUFFER|DEPTH|ELEMENT_SIZE|FORMAT|FORMAT_MISMATCH|FORMAT_NOT_SUPPORTED|HEIGHT|NUM_MIP_LEVELS|NUM_SAMPLES|ROW_PITCH|SLICE_PITCH|WIDTH)|INTENSITY|INVALID_(?:ARG_INDEX|ARG_SIZE|ARG_VALUE|BINARY|BUFFER_SIZE|BUILD_OPTIONS|COMMAND_QUEUE|COMPILER_OPTIONS|CONTEXT|DEVICE|DEVICE_PARTITION_COUNT|DEVICE_QUEUE|DEVICE_TYPE|EVENT|EVENT_WAIT_LIST|GLOBAL_OFFSET|GLOBAL_WORK_SIZE|GL_OBJECT|HOST_PTR|IMAGE_DESCRIPTOR|IMAGE_FORMAT_DESCRIPTOR|IMAGE_SIZE|KERNEL|KERNEL_ARGS|KERNEL_DEFINITION|KERNEL_NAME|LINKER_OPTIONS|MEM_OBJECT|MIP_LEVEL|OPERATION|PIPE_SIZE|PLATFORM|PROGRAM|PROGRAM_EXECUTABLE|PROPERTY|QUEUE_PROPERTIES|SAMPLER|VALUE|WORK_DIMENSION|WORK_GROUP_SIZE|WORK_ITEM_SIZE)|KERNEL_(?:ARG_(?:ACCESS_(?:NONE|QUALIFIER|READ_ONLY|READ_WRITE|WRITE_ONLY)|ADDRESS_(?:CONSTANT|GLOBAL|LOCAL|PRIVATE|QUALIFIER)|INFO_NOT_AVAILABLE|NAME|TYPE_(?:CONST|NAME|NONE|PIPE|QUALIFIER|RESTRICT|VOLATILE))|ATTRIBUTES|COMPILE_NUM_SUB_GROUPS|COMPILE_WORK_GROUP_SIZE|CONTEXT|EXEC_INFO_SVM_FINE_GRAIN_SYSTEM|EXEC_INFO_SVM_PTRS|FUNCTION_NAME|GLOBAL_WORK_SIZE|LOCAL_MEM_SIZE|LOCAL_SIZE_FOR_SUB_GROUP_COUNT|MAX_NUM_SUB_GROUPS|MAX_SUB_GROUP_SIZE_FOR_NDRANGE|NUM_ARGS|PREFERRED_WORK_GROUP_SIZE_MULTIPLE|PRIVATE_MEM_SIZE|PROGRAM|REFERENCE_COUNT|SUB_GROUP_COUNT_FOR_NDRANGE|WORK_GROUP_SIZE)|LINKER_NOT_AVAILABLE|LINK_PROGRAM_FAILURE|LOCAL|LUMINANCE|MAP_(?:FAILURE|READ|WRITE|WRITE_INVALIDATE_REGION)|MEM_(?:ALLOC_HOST_PTR|ASSOCIATED_MEMOBJECT|CONTEXT|COPY_HOST_PTR|COPY_OVERLAP|FLAGS|HOST_NO_ACCESS|HOST_PTR|HOST_READ_ONLY|HOST_WRITE_ONLY|KERNEL_READ_AND_WRITE|MAP_COUNT|OBJECT_(?:ALLOCATION_FAILURE|BUFFER|IMAGE1D|IMAGE1D_ARRAY|IMAGE1D_BUFFER|IMAGE2D|IMAGE2D_ARRAY|IMAGE3D|PIPE)|OFFSET|READ_ONLY|READ_WRITE|REFERENCE_COUNT|SIZE|SVM_ATOMICS|SVM_FINE_GRAIN_BUFFER|TYPE|USES_SVM_POINTER|USE_HOST_PTR|WRITE_ONLY)|MIGRATE_MEM_OBJECT_(?:CONTENT_UNDEFINED|HOST)|MISALIGNED_SUB_BUFFER_OFFSET|NONE|NON_BLOCKING|OUT_OF_(?:HOST_MEMORY|RESOURCES)|PIPE_(?:MAX_PACKETS|PACKET_SIZE)|PLATFORM_(?:EXTENSIONS|HOST_TIMER_RESOLUTION|NAME|PROFILE|VENDOR|VERSION)|PROFILING_(?:COMMAND_(?:COMPLETE|END|QUEUED|START|SUBMIT)|INFO_NOT_AVAILABLE)|PROGRAM_(?:BINARIES|BINARY_SIZES|BINARY_TYPE(?:_COMPILED_OBJECT|_EXECUTABLE|_LIBRARY|_NONE)?|BUILD_(?:GLOBAL_VARIABLE_TOTAL_SIZE|LOG|OPTIONS|STATUS)|CONTEXT|DEVICES|IL|KERNEL_NAMES|NUM_DEVICES|NUM_KERNELS|REFERENCE_COUNT|SOURCE)|QUEUED|QUEUE_(?:CONTEXT|DEVICE|DEVICE_DEFAULT|ON_DEVICE|ON_DEVICE_DEFAULT|OUT_OF_ORDER_EXEC_MODE_ENABLE|PROFILING_ENABLE|PROPERTIES|REFERENCE_COUNT|SIZE)|R|RA|READ_(?:ONLY|WRITE)_CACHE|RG|RGB|RGBA|RGBx|RGx|RUNNING|Rx|SAMPLER_(?:ADDRESSING_MODE|CONTEXT|FILTER_MODE|LOD_MAX|LOD_MIN|MIP_FILTER_MODE|NORMALIZED_COORDS|REFERENCE_COUNT)|(?:UN)?SIGNED_INT(?:8|16|32)|SNORM_INT(?:8|16)|SUBMITTED|SUCCESS|UNORM_INT(?:8|16|24|_101010|_101010_2)|UNORM_SHORT_(?:555|565)|VERSION_(?:1_0|1_1|1_2|2_0|2_1)|sBGRA|sRGB|sRGBA|sRGBx)\b/,
+				alias: "constant"
+			},
+			"function-opencl-host": {
+				pattern: /\bcl(?:BuildProgram|CloneKernel|CompileProgram|Create(?:Buffer|CommandQueue(?:WithProperties)?|Context|ContextFromType|Image|Image2D|Image3D|Kernel|KernelsInProgram|Pipe|ProgramWith(?:Binary|BuiltInKernels|IL|Source)|Sampler|SamplerWithProperties|SubBuffer|SubDevices|UserEvent)|Enqueue(?:(?:Barrier|Marker)(?:WithWaitList)?|Copy(?:Buffer(?:Rect|ToImage)?|Image(?:ToBuffer)?)|(?:Fill|Map)(?:Buffer|Image)|MigrateMemObjects|NDRangeKernel|NativeKernel|(?:Read|Write)(?:Buffer(?:Rect)?|Image)|SVM(?:Free|Map|MemFill|Memcpy|MigrateMem|Unmap)|Task|UnmapMemObject|WaitForEvents)|Finish|Flush|Get(?:CommandQueueInfo|ContextInfo|Device(?:AndHostTimer|IDs|Info)|Event(?:Profiling)?Info|ExtensionFunctionAddress(?:ForPlatform)?|HostTimer|ImageInfo|Kernel(?:ArgInfo|Info|SubGroupInfo|WorkGroupInfo)|MemObjectInfo|PipeInfo|Platform(?:IDs|Info)|Program(?:Build)?Info|SamplerInfo|SupportedImageFormats)|LinkProgram|(?:Release|Retain)(?:CommandQueue|Context|Device|Event|Kernel|MemObject|Program|Sampler)|SVM(?:Alloc|Free)|Set(?:CommandQueueProperty|DefaultDeviceCommandQueue|EventCallback|Kernel|Kernel(?:Arg(?:SVMPointer)?|ExecInfo)|MemObjectDestructorCallback|UserEventStatus)|Unload(?:Platform)?Compiler|WaitForEvents)\b/,
+				alias: "function"
+			}
+		};
+		Prism.languages.insertBefore("c", "keyword", attributes);
+		if (Prism.languages.cpp) {
+			attributes["type-opencl-host-cpp"] = {
+				pattern: /\b(?:Buffer|BufferGL|BufferRenderGL|CommandQueue|Context|Device|DeviceCommandQueue|EnqueueArgs|Event|Image|Image1D|Image1DArray|Image1DBuffer|Image2D|Image2DArray|Image2DGL|Image3D|Image3DGL|ImageFormat|ImageGL|Kernel|KernelFunctor|LocalSpaceArg|Memory|NDRange|Pipe|Platform|Program|SVMAllocator|SVMTraitAtomic|SVMTraitCoarse|SVMTraitFine|SVMTraitReadOnly|SVMTraitReadWrite|SVMTraitWriteOnly|Sampler|UserEvent)\b/,
+				alias: "keyword"
+			};
+			Prism.languages.insertBefore("cpp", "keyword", attributes);
+		}
+	})(Prism);
+}
+
+//#endregion
+export { opencl as default };

package/dist/openqasm-BCXxEzkz.js

@@ -0,0 +1,30 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/openqasm.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+openqasm.displayName = "openqasm";
+openqasm.aliases = ["qasm"];
+/** @param {Refractor} Prism */
+function openqasm(Prism) {
+	Prism.languages.openqasm = {
+		comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+		string: {
+			pattern: /"[^"\r\n\t]*"|'[^'\r\n\t]*'/,
+			greedy: true
+		},
+		keyword: /\b(?:CX|OPENQASM|U|barrier|boxas|boxto|break|const|continue|ctrl|def|defcal|defcalgrammar|delay|else|end|for|gate|gphase|if|in|include|inv|kernel|lengthof|let|measure|pow|reset|return|rotary|stretchinf|while)\b|#pragma\b/,
+		"class-name": /\b(?:angle|bit|bool|creg|fixed|float|int|length|qreg|qubit|stretch|uint)\b/,
+		function: /\b(?:cos|exp|ln|popcount|rotl|rotr|sin|sqrt|tan)\b(?=\s*\()/,
+		constant: /\b(?:euler|pi|tau)\b|π|𝜏|ℇ/,
+		number: {
+			pattern: /(^|[^.\w$])(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(?:dt|ns|us|µs|ms|s)?/i,
+			lookbehind: true
+		},
+		operator: /->|>>=?|<<=?|&&|\|\||\+\+|--|[!=<>&|~^+\-*/%]=?|@/,
+		punctuation: /[(){}\[\];,:.]/
+	};
+	Prism.languages.qasm = Prism.languages.openqasm;
+}
+
+//#endregion
+export { openqasm as default };

package/dist/openscad-MI1WtN4e.js

@@ -0,0 +1,72 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/openscad.js
+var require_openscad = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function openscad(hljs) {
+		const SPECIAL_VARS = {
+			className: "keyword",
+			begin: "\\$(f[asn]|t|vp[rtd]|children)"
+		};
+		const LITERALS = {
+			className: "literal",
+			begin: "false|true|PI|undef"
+		};
+		const NUMBERS = {
+			className: "number",
+			begin: "\\b\\d+(\\.\\d+)?(e-?\\d+)?",
+			relevance: 0
+		};
+		const STRING = hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null });
+		const PREPRO = {
+			className: "meta",
+			keywords: { "meta-keyword": "include use" },
+			begin: "include|use <",
+			end: ">"
+		};
+		const PARAMS = {
+			className: "params",
+			begin: "\\(",
+			end: "\\)",
+			contains: [
+				"self",
+				NUMBERS,
+				STRING,
+				SPECIAL_VARS,
+				LITERALS
+			]
+		};
+		const MODIFIERS = {
+			begin: "[*!#%]",
+			relevance: 0
+		};
+		const FUNCTIONS = {
+			className: "function",
+			beginKeywords: "module function",
+			end: /=|\{/,
+			contains: [PARAMS, hljs.UNDERSCORE_TITLE_MODE]
+		};
+		return {
+			name: "OpenSCAD",
+			aliases: ["scad"],
+			keywords: {
+				keyword: "function module include use for intersection_for if else \\%",
+				literal: "false true PI undef",
+				built_in: "circle square polygon text sphere cube cylinder polyhedron translate rotate scale resize mirror multmatrix color offset hull minkowski union difference intersection abs sign sin cos tan acos asin atan atan2 floor round ceil ln log pow sqrt exp rands min max concat lookup str chr search version version_num norm cross parent_module echo import import_dxf dxf_linear_extrude linear_extrude rotate_extrude surface projection render children dxf_cross dxf_dim let assign"
+			},
+			contains: [
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.C_BLOCK_COMMENT_MODE,
+				NUMBERS,
+				PREPRO,
+				STRING,
+				SPECIAL_VARS,
+				MODIFIERS,
+				FUNCTIONS
+			]
+		};
+	}
+	module.exports = openscad;
+}));
+
+//#endregion
+export default require_openscad();

package/dist/oxygene-CGz_hbo_.js

@@ -0,0 +1,74 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/oxygene.js
+var require_oxygene = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function oxygene(hljs) {
+		const OXYGENE_KEYWORDS = {
+			$pattern: /\.?\w+/,
+			keyword: "abstract add and array as asc aspect assembly async begin break block by case class concat const copy constructor continue create default delegate desc distinct div do downto dynamic each else empty end ensure enum equals event except exit extension external false final finalize finalizer finally flags for forward from function future global group has if implementation implements implies in index inherited inline interface into invariants is iterator join locked locking loop matching method mod module namespace nested new nil not notify nullable of old on operator or order out override parallel params partial pinned private procedure property protected public queryable raise read readonly record reintroduce remove repeat require result reverse sealed select self sequence set shl shr skip static step soft take then to true try tuple type union unit unsafe until uses using var virtual raises volatile where while with write xor yield await mapped deprecated stdcall cdecl pascal register safecall overload library platform reference packed strict published autoreleasepool selector strong weak unretained"
+		};
+		const CURLY_COMMENT = hljs.COMMENT(/\{/, /\}/, { relevance: 0 });
+		const PAREN_COMMENT = hljs.COMMENT("\\(\\*", "\\*\\)", { relevance: 10 });
+		const STRING = {
+			className: "string",
+			begin: "'",
+			end: "'",
+			contains: [{ begin: "''" }]
+		};
+		const CHAR_STRING = {
+			className: "string",
+			begin: "(#\\d+)+"
+		};
+		const FUNCTION = {
+			className: "function",
+			beginKeywords: "function constructor destructor procedure method",
+			end: "[:;]",
+			keywords: "function constructor|10 destructor|10 procedure|10 method|10",
+			contains: [
+				hljs.TITLE_MODE,
+				{
+					className: "params",
+					begin: "\\(",
+					end: "\\)",
+					keywords: OXYGENE_KEYWORDS,
+					contains: [STRING, CHAR_STRING]
+				},
+				CURLY_COMMENT,
+				PAREN_COMMENT
+			]
+		};
+		return {
+			name: "Oxygene",
+			case_insensitive: true,
+			keywords: OXYGENE_KEYWORDS,
+			illegal: "(\"|\\$[G-Zg-z]|\\/\\*|</|=>|->)",
+			contains: [
+				CURLY_COMMENT,
+				PAREN_COMMENT,
+				hljs.C_LINE_COMMENT_MODE,
+				STRING,
+				CHAR_STRING,
+				hljs.NUMBER_MODE,
+				FUNCTION,
+				{
+					className: "class",
+					begin: "=\\bclass\\b",
+					end: "end;",
+					keywords: OXYGENE_KEYWORDS,
+					contains: [
+						STRING,
+						CHAR_STRING,
+						CURLY_COMMENT,
+						PAREN_COMMENT,
+						hljs.C_LINE_COMMENT_MODE,
+						FUNCTION
+					]
+				}
+			]
+		};
+	}
+	module.exports = oxygene;
+}));
+
+//#endregion
+export default require_oxygene();

package/dist/oz-BIEkjqaK.js

@@ -0,0 +1,37 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/oz.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+oz.displayName = "oz";
+oz.aliases = [];
+/** @param {Refractor} Prism */
+function oz(Prism) {
+	Prism.languages.oz = {
+		comment: {
+			pattern: /\/\*[\s\S]*?\*\/|%.*/,
+			greedy: true
+		},
+		string: {
+			pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+			greedy: true
+		},
+		atom: {
+			pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+			greedy: true,
+			alias: "builtin"
+		},
+		keyword: /\$|\[\]|\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\b/,
+		function: [/\b[a-z][A-Za-z\d]*(?=\()/, {
+			pattern: /(\{)[A-Z][A-Za-z\d]*\b/,
+			lookbehind: true
+		}],
+		number: /\b(?:0[bx][\da-f]+|\d+(?:\.\d*)?(?:e~?\d+)?)\b|&(?:[^\\]|\\(?:\d{3}|.))/i,
+		variable: /`(?:[^`\\]|\\.)+`/,
+		"attr-name": /\b\w+(?=[ \t]*:(?![:=]))/,
+		operator: /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\=:?|!!?|[|#+\-*\/,~^@]|\b(?:andthen|div|mod|orelse)\b/,
+		punctuation: /[\[\](){}.:;?]/
+	};
+}
+
+//#endregion
+export { oz as default };

package/dist/parigp-DFe_jQ_0.js

@@ -0,0 +1,57 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/parigp.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+parigp.displayName = "parigp";
+parigp.aliases = [];
+/** @param {Refractor} Prism */
+function parigp(Prism) {
+	Prism.languages.parigp = {
+		comment: /\/\*[\s\S]*?\*\/|\\\\.*/,
+		string: {
+			pattern: /"(?:[^"\\\r\n]|\\.)*"/,
+			greedy: true
+		},
+		keyword: (function() {
+			var keywords = [
+				"breakpoint",
+				"break",
+				"dbg_down",
+				"dbg_err",
+				"dbg_up",
+				"dbg_x",
+				"forcomposite",
+				"fordiv",
+				"forell",
+				"forpart",
+				"forprime",
+				"forstep",
+				"forsubgroup",
+				"forvec",
+				"for",
+				"iferr",
+				"if",
+				"local",
+				"my",
+				"next",
+				"return",
+				"until",
+				"while"
+			];
+			keywords = keywords.map(function(keyword) {
+				return keyword.split("").join(" *");
+			}).join("|");
+			return RegExp("\\b(?:" + keywords + ")\\b");
+		})(),
+		function: /\b\w(?:[\w ]*\w)?(?= *\()/,
+		number: {
+			pattern: /((?:\. *\. *)?)(?:\b\d(?: *\d)*(?: *(?!\. *\.)\.(?: *\d)*)?|\. *\d(?: *\d)*)(?: *e *(?:[+-] *)?\d(?: *\d)*)?/i,
+			lookbehind: true
+		},
+		operator: /\. *\.|[*\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\(?: *\/)?(?: *=)?|&(?: *&)?|\| *\||['#~^]/,
+		punctuation: /[\[\]{}().,:;|]/
+	};
+}
+
+//#endregion
+export { parigp as default };

package/dist/parser-D8bUDSMy.js

@@ -0,0 +1,81 @@
+import { t as markup } from "./markup-D2NSmoAx.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/parser.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+parser.displayName = "parser";
+parser.aliases = [];
+/** @param {Refractor} Prism */
+function parser(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		var parser = Prism.languages.parser = Prism.languages.extend("markup", {
+			keyword: {
+				pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
+				lookbehind: true
+			},
+			variable: {
+				pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+				lookbehind: true,
+				inside: { punctuation: /\.|:+/ }
+			},
+			function: {
+				pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+				lookbehind: true,
+				inside: {
+					keyword: {
+						pattern: /(^@)(?:GET_|SET_)/,
+						lookbehind: true
+					},
+					punctuation: /\.|:+/
+				}
+			},
+			escape: {
+				pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
+				alias: "builtin"
+			},
+			punctuation: /[\[\](){};]/
+		});
+		parser = Prism.languages.insertBefore("parser", "keyword", {
+			"parser-comment": {
+				pattern: /(\s)#.*/,
+				lookbehind: true,
+				alias: "comment"
+			},
+			expression: {
+				pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
+				greedy: true,
+				lookbehind: true,
+				inside: {
+					string: {
+						pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
+						lookbehind: true
+					},
+					keyword: parser.keyword,
+					variable: parser.variable,
+					function: parser.function,
+					boolean: /\b(?:false|true)\b/,
+					number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
+					escape: parser.escape,
+					operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
+					punctuation: parser.punctuation
+				}
+			}
+		});
+		Prism.languages.insertBefore("inside", "punctuation", {
+			expression: parser.expression,
+			keyword: parser.keyword,
+			variable: parser.variable,
+			function: parser.function,
+			escape: parser.escape,
+			"parser-punctuation": {
+				pattern: parser.punctuation,
+				alias: "punctuation"
+			}
+		}, parser["tag"].inside["attr-value"]);
+	})(Prism);
+}
+
+//#endregion
+export { parser as default };

package/dist/parser3-BtcxMqRE.js

@@ -0,0 +1,46 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/parser3.js
+var require_parser3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function parser3(hljs) {
+		const CURLY_SUBCOMMENT = hljs.COMMENT(/\{/, /\}/, { contains: ["self"] });
+		return {
+			name: "Parser3",
+			subLanguage: "xml",
+			relevance: 0,
+			contains: [
+				hljs.COMMENT("^#", "$"),
+				hljs.COMMENT(/\^rem\{/, /\}/, {
+					relevance: 10,
+					contains: [CURLY_SUBCOMMENT]
+				}),
+				{
+					className: "meta",
+					begin: "^@(?:BASE|USE|CLASS|OPTIONS)$",
+					relevance: 10
+				},
+				{
+					className: "title",
+					begin: "@[\\w\\-]+\\[[\\w^;\\-]*\\](?:\\[[\\w^;\\-]*\\])?(?:.*)$"
+				},
+				{
+					className: "variable",
+					begin: /\$\{?[\w\-.:]+\}?/
+				},
+				{
+					className: "keyword",
+					begin: /\^[\w\-.:]+/
+				},
+				{
+					className: "number",
+					begin: "\\^#[0-9a-fA-F]+"
+				},
+				hljs.C_NUMBER_MODE
+			]
+		};
+	}
+	module.exports = parser3;
+}));
+
+//#endregion
+export default require_parser3();