@photonix/basic 1.5.1 → 1.6.0

package/dist/chunk-MXDMZSYV.mjs

@@ -0,0 +1,38 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cmake.js
+cmake.displayName = "cmake";
+cmake.aliases = [];
+function cmake(Prism) {
+  Prism.languages.cmake = {
+    comment: /#.*/,
+    string: {
+      pattern: /"(?:[^\\"]|\\.)*"/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /\$\{(?:[^{}$]|\$\{[^{}$]*\})*\}/,
+          inside: {
+            punctuation: /\$\{|\}/,
+            variable: /\w+/
+          }
+        }
+      }
+    },
+    variable: /\b(?:CMAKE_\w+|\w+_(?:(?:BINARY|SOURCE)_DIR|DESCRIPTION|HOMEPAGE_URL|ROOT|VERSION(?:_MAJOR|_MINOR|_PATCH|_TWEAK)?)|(?:ANDROID|APPLE|BORLAND|BUILD_SHARED_LIBS|CACHE|CPACK_(?:ABSOLUTE_DESTINATION_FILES|COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY|ERROR_ON_ABSOLUTE_INSTALL_DESTINATION|INCLUDE_TOPLEVEL_DIRECTORY|INSTALL_DEFAULT_DIRECTORY_PERMISSIONS|INSTALL_SCRIPT|PACKAGING_INSTALL_PREFIX|SET_DESTDIR|WARN_ON_ABSOLUTE_INSTALL_DESTINATION)|CTEST_(?:BINARY_DIRECTORY|BUILD_COMMAND|BUILD_NAME|BZR_COMMAND|BZR_UPDATE_OPTIONS|CHANGE_ID|CHECKOUT_COMMAND|CONFIGURATION_TYPE|CONFIGURE_COMMAND|COVERAGE_COMMAND|COVERAGE_EXTRA_FLAGS|CURL_OPTIONS|CUSTOM_(?:COVERAGE_EXCLUDE|ERROR_EXCEPTION|ERROR_MATCH|ERROR_POST_CONTEXT|ERROR_PRE_CONTEXT|MAXIMUM_FAILED_TEST_OUTPUT_SIZE|MAXIMUM_NUMBER_OF_(?:ERRORS|WARNINGS)|MAXIMUM_PASSED_TEST_OUTPUT_SIZE|MEMCHECK_IGNORE|POST_MEMCHECK|POST_TEST|PRE_MEMCHECK|PRE_TEST|TESTS_IGNORE|WARNING_EXCEPTION|WARNING_MATCH)|CVS_CHECKOUT|CVS_COMMAND|CVS_UPDATE_OPTIONS|DROP_LOCATION|DROP_METHOD|DROP_SITE|DROP_SITE_CDASH|DROP_SITE_PASSWORD|DROP_SITE_USER|EXTRA_COVERAGE_GLOB|GIT_COMMAND|GIT_INIT_SUBMODULES|GIT_UPDATE_CUSTOM|GIT_UPDATE_OPTIONS|HG_COMMAND|HG_UPDATE_OPTIONS|LABELS_FOR_SUBPROJECTS|MEMORYCHECK_(?:COMMAND|COMMAND_OPTIONS|SANITIZER_OPTIONS|SUPPRESSIONS_FILE|TYPE)|NIGHTLY_START_TIME|P4_CLIENT|P4_COMMAND|P4_OPTIONS|P4_UPDATE_OPTIONS|RUN_CURRENT_SCRIPT|SCP_COMMAND|SITE|SOURCE_DIRECTORY|SUBMIT_URL|SVN_COMMAND|SVN_OPTIONS|SVN_UPDATE_OPTIONS|TEST_LOAD|TEST_TIMEOUT|TRIGGER_SITE|UPDATE_COMMAND|UPDATE_OPTIONS|UPDATE_VERSION_ONLY|USE_LAUNCHERS)|CYGWIN|ENV|EXECUTABLE_OUTPUT_PATH|GHS-MULTI|IOS|LIBRARY_OUTPUT_PATH|MINGW|MSVC(?:10|11|12|14|60|70|71|80|90|_IDE|_TOOLSET_VERSION|_VERSION)?|MSYS|PROJECT_NAME|UNIX|WIN32|WINCE|WINDOWS_PHONE|WINDOWS_STORE|XCODE))\b/,
+    property: /\b(?:cxx_\w+|(?:ARCHIVE_OUTPUT_(?:DIRECTORY|NAME)|COMPILE_DEFINITIONS|COMPILE_PDB_NAME|COMPILE_PDB_OUTPUT_DIRECTORY|EXCLUDE_FROM_DEFAULT_BUILD|IMPORTED_(?:IMPLIB|LIBNAME|LINK_DEPENDENT_LIBRARIES|LINK_INTERFACE_LANGUAGES|LINK_INTERFACE_LIBRARIES|LINK_INTERFACE_MULTIPLICITY|LOCATION|NO_SONAME|OBJECTS|SONAME)|INTERPROCEDURAL_OPTIMIZATION|LIBRARY_OUTPUT_DIRECTORY|LIBRARY_OUTPUT_NAME|LINK_FLAGS|LINK_INTERFACE_LIBRARIES|LINK_INTERFACE_MULTIPLICITY|LOCATION|MAP_IMPORTED_CONFIG|OSX_ARCHITECTURES|OUTPUT_NAME|PDB_NAME|PDB_OUTPUT_DIRECTORY|RUNTIME_OUTPUT_DIRECTORY|RUNTIME_OUTPUT_NAME|STATIC_LIBRARY_FLAGS|VS_CSHARP|VS_DOTNET_REFERENCEPROP|VS_DOTNET_REFERENCE|VS_GLOBAL_SECTION_POST|VS_GLOBAL_SECTION_PRE|VS_GLOBAL|XCODE_ATTRIBUTE)_\w+|\w+_(?:CLANG_TIDY|COMPILER_LAUNCHER|CPPCHECK|CPPLINT|INCLUDE_WHAT_YOU_USE|OUTPUT_NAME|POSTFIX|VISIBILITY_PRESET)|ABSTRACT|ADDITIONAL_MAKE_CLEAN_FILES|ADVANCED|ALIASED_TARGET|ALLOW_DUPLICATE_CUSTOM_TARGETS|ANDROID_(?:ANT_ADDITIONAL_OPTIONS|API|API_MIN|ARCH|ASSETS_DIRECTORIES|GUI|JAR_DEPENDENCIES|NATIVE_LIB_DEPENDENCIES|NATIVE_LIB_DIRECTORIES|PROCESS_MAX|PROGUARD|PROGUARD_CONFIG_PATH|SECURE_PROPS_PATH|SKIP_ANT_STEP|STL_TYPE)|ARCHIVE_OUTPUT_DIRECTORY|ATTACHED_FILES|ATTACHED_FILES_ON_FAIL|AUTOGEN_(?:BUILD_DIR|ORIGIN_DEPENDS|PARALLEL|SOURCE_GROUP|TARGETS_FOLDER|TARGET_DEPENDS)|AUTOMOC|AUTOMOC_(?:COMPILER_PREDEFINES|DEPEND_FILTERS|EXECUTABLE|MACRO_NAMES|MOC_OPTIONS|SOURCE_GROUP|TARGETS_FOLDER)|AUTORCC|AUTORCC_EXECUTABLE|AUTORCC_OPTIONS|AUTORCC_SOURCE_GROUP|AUTOUIC|AUTOUIC_EXECUTABLE|AUTOUIC_OPTIONS|AUTOUIC_SEARCH_PATHS|BINARY_DIR|BUILDSYSTEM_TARGETS|BUILD_RPATH|BUILD_RPATH_USE_ORIGIN|BUILD_WITH_INSTALL_NAME_DIR|BUILD_WITH_INSTALL_RPATH|BUNDLE|BUNDLE_EXTENSION|CACHE_VARIABLES|CLEAN_NO_CUSTOM|COMMON_LANGUAGE_RUNTIME|COMPATIBLE_INTERFACE_(?:BOOL|NUMBER_MAX|NUMBER_MIN|STRING)|COMPILE_(?:DEFINITIONS|FEATURES|FLAGS|OPTIONS|PDB_NAME|PDB_OUTPUT_DIRECTORY)|COST|CPACK_DESKTOP_SHORTCUTS|CPACK_NEVER_OVERWRITE|CPACK_PERMANENT|CPACK_STARTUP_SHORTCUTS|CPACK_START_MENU_SHORTCUTS|CPACK_WIX_ACL|CROSSCOMPILING_EMULATOR|CUDA_EXTENSIONS|CUDA_PTX_COMPILATION|CUDA_RESOLVE_DEVICE_SYMBOLS|CUDA_SEPARABLE_COMPILATION|CUDA_STANDARD|CUDA_STANDARD_REQUIRED|CXX_EXTENSIONS|CXX_STANDARD|CXX_STANDARD_REQUIRED|C_EXTENSIONS|C_STANDARD|C_STANDARD_REQUIRED|DEBUG_CONFIGURATIONS|DEFINE_SYMBOL|DEFINITIONS|DEPENDS|DEPLOYMENT_ADDITIONAL_FILES|DEPLOYMENT_REMOTE_DIRECTORY|DISABLED|DISABLED_FEATURES|ECLIPSE_EXTRA_CPROJECT_CONTENTS|ECLIPSE_EXTRA_NATURES|ENABLED_FEATURES|ENABLED_LANGUAGES|ENABLE_EXPORTS|ENVIRONMENT|EXCLUDE_FROM_ALL|EXCLUDE_FROM_DEFAULT_BUILD|EXPORT_NAME|EXPORT_PROPERTIES|EXTERNAL_OBJECT|EchoString|FAIL_REGULAR_EXPRESSION|FIND_LIBRARY_USE_LIB32_PATHS|FIND_LIBRARY_USE_LIB64_PATHS|FIND_LIBRARY_USE_LIBX32_PATHS|FIND_LIBRARY_USE_OPENBSD_VERSIONING|FIXTURES_CLEANUP|FIXTURES_REQUIRED|FIXTURES_SETUP|FOLDER|FRAMEWORK|Fortran_FORMAT|Fortran_MODULE_DIRECTORY|GENERATED|GENERATOR_FILE_NAME|GENERATOR_IS_MULTI_CONFIG|GHS_INTEGRITY_APP|GHS_NO_SOURCE_GROUP_FILE|GLOBAL_DEPENDS_DEBUG_MODE|GLOBAL_DEPENDS_NO_CYCLES|GNUtoMS|HAS_CXX|HEADER_FILE_ONLY|HELPSTRING|IMPLICIT_DEPENDS_INCLUDE_TRANSFORM|IMPORTED|IMPORTED_(?:COMMON_LANGUAGE_RUNTIME|CONFIGURATIONS|GLOBAL|IMPLIB|LIBNAME|LINK_DEPENDENT_LIBRARIES|LINK_INTERFACE_(?:LANGUAGES|LIBRARIES|MULTIPLICITY)|LOCATION|NO_SONAME|OBJECTS|SONAME)|IMPORT_PREFIX|IMPORT_SUFFIX|INCLUDE_DIRECTORIES|INCLUDE_REGULAR_EXPRESSION|INSTALL_NAME_DIR|INSTALL_RPATH|INSTALL_RPATH_USE_LINK_PATH|INTERFACE_(?:AUTOUIC_OPTIONS|COMPILE_DEFINITIONS|COMPILE_FEATURES|COMPILE_OPTIONS|INCLUDE_DIRECTORIES|LINK_DEPENDS|LINK_DIRECTORIES|LINK_LIBRARIES|LINK_OPTIONS|POSITION_INDEPENDENT_CODE|SOURCES|SYSTEM_INCLUDE_DIRECTORIES)|INTERPROCEDURAL_OPTIMIZATION|IN_TRY_COMPILE|IOS_INSTALL_COMBINED|JOB_POOLS|JOB_POOL_COMPILE|JOB_POOL_LINK|KEEP_EXTENSION|LABELS|LANGUAGE|LIBRARY_OUTPUT_DIRECTORY|LINKER_LANGUAGE|LINK_(?:DEPENDS|DEPENDS_NO_SHARED|DIRECTORIES|FLAGS|INTERFACE_LIBRARIES|INTERFACE_MULTIPLICITY|LIBRARIES|OPTIONS|SEARCH_END_STATIC|SEARCH_START_STATIC|WHAT_YOU_USE)|LISTFILE_STACK|LOCATION|MACOSX_BUNDLE|MACOSX_BUNDLE_INFO_PLIST|MACOSX_FRAMEWORK_INFO_PLIST|MACOSX_PACKAGE_LOCATION|MACOSX_RPATH|MACROS|MANUALLY_ADDED_DEPENDENCIES|MEASUREMENT|MODIFIED|NAME|NO_SONAME|NO_SYSTEM_FROM_IMPORTED|OBJECT_DEPENDS|OBJECT_OUTPUTS|OSX_ARCHITECTURES|OUTPUT_NAME|PACKAGES_FOUND|PACKAGES_NOT_FOUND|PARENT_DIRECTORY|PASS_REGULAR_EXPRESSION|PDB_NAME|PDB_OUTPUT_DIRECTORY|POSITION_INDEPENDENT_CODE|POST_INSTALL_SCRIPT|PREDEFINED_TARGETS_FOLDER|PREFIX|PRE_INSTALL_SCRIPT|PRIVATE_HEADER|PROCESSORS|PROCESSOR_AFFINITY|PROJECT_LABEL|PUBLIC_HEADER|REPORT_UNDEFINED_PROPERTIES|REQUIRED_FILES|RESOURCE|RESOURCE_LOCK|RULE_LAUNCH_COMPILE|RULE_LAUNCH_CUSTOM|RULE_LAUNCH_LINK|RULE_MESSAGES|RUNTIME_OUTPUT_DIRECTORY|RUN_SERIAL|SKIP_AUTOGEN|SKIP_AUTOMOC|SKIP_AUTORCC|SKIP_AUTOUIC|SKIP_BUILD_RPATH|SKIP_RETURN_CODE|SOURCES|SOURCE_DIR|SOVERSION|STATIC_LIBRARY_FLAGS|STATIC_LIBRARY_OPTIONS|STRINGS|SUBDIRECTORIES|SUFFIX|SYMBOLIC|TARGET_ARCHIVES_MAY_BE_SHARED_LIBS|TARGET_MESSAGES|TARGET_SUPPORTS_SHARED_LIBS|TESTS|TEST_INCLUDE_FILE|TEST_INCLUDE_FILES|TIMEOUT|TIMEOUT_AFTER_MATCH|TYPE|USE_FOLDERS|VALUE|VARIABLES|VERSION|VISIBILITY_INLINES_HIDDEN|VS_(?:CONFIGURATION_TYPE|COPY_TO_OUT_DIR|DEBUGGER_(?:COMMAND|COMMAND_ARGUMENTS|ENVIRONMENT|WORKING_DIRECTORY)|DEPLOYMENT_CONTENT|DEPLOYMENT_LOCATION|DOTNET_REFERENCES|DOTNET_REFERENCES_COPY_LOCAL|INCLUDE_IN_VSIX|IOT_STARTUP_TASK|KEYWORD|RESOURCE_GENERATOR|SCC_AUXPATH|SCC_LOCALPATH|SCC_PROJECTNAME|SCC_PROVIDER|SDK_REFERENCES|SHADER_(?:DISABLE_OPTIMIZATIONS|ENABLE_DEBUG|ENTRYPOINT|FLAGS|MODEL|OBJECT_FILE_NAME|OUTPUT_HEADER_FILE|TYPE|VARIABLE_NAME)|STARTUP_PROJECT|TOOL_OVERRIDE|USER_PROPS|WINRT_COMPONENT|WINRT_EXTENSIONS|WINRT_REFERENCES|XAML_TYPE)|WILL_FAIL|WIN32_EXECUTABLE|WINDOWS_EXPORT_ALL_SYMBOLS|WORKING_DIRECTORY|WRAP_EXCLUDE|XCODE_(?:EMIT_EFFECTIVE_PLATFORM_NAME|EXPLICIT_FILE_TYPE|FILE_ATTRIBUTES|LAST_KNOWN_FILE_TYPE|PRODUCT_TYPE|SCHEME_(?:ADDRESS_SANITIZER|ADDRESS_SANITIZER_USE_AFTER_RETURN|ARGUMENTS|DISABLE_MAIN_THREAD_CHECKER|DYNAMIC_LIBRARY_LOADS|DYNAMIC_LINKER_API_USAGE|ENVIRONMENT|EXECUTABLE|GUARD_MALLOC|MAIN_THREAD_CHECKER_STOP|MALLOC_GUARD_EDGES|MALLOC_SCRIBBLE|MALLOC_STACK|THREAD_SANITIZER(?:_STOP)?|UNDEFINED_BEHAVIOUR_SANITIZER(?:_STOP)?|ZOMBIE_OBJECTS))|XCTEST)\b/,
+    keyword: /\b(?:add_compile_definitions|add_compile_options|add_custom_command|add_custom_target|add_definitions|add_dependencies|add_executable|add_library|add_link_options|add_subdirectory|add_test|aux_source_directory|break|build_command|build_name|cmake_host_system_information|cmake_minimum_required|cmake_parse_arguments|cmake_policy|configure_file|continue|create_test_sourcelist|ctest_build|ctest_configure|ctest_coverage|ctest_empty_binary_directory|ctest_memcheck|ctest_read_custom_files|ctest_run_script|ctest_sleep|ctest_start|ctest_submit|ctest_test|ctest_update|ctest_upload|define_property|else|elseif|enable_language|enable_testing|endforeach|endfunction|endif|endmacro|endwhile|exec_program|execute_process|export|export_library_dependencies|file|find_file|find_library|find_package|find_path|find_program|fltk_wrap_ui|foreach|function|get_cmake_property|get_directory_property|get_filename_component|get_property|get_source_file_property|get_target_property|get_test_property|if|include|include_directories|include_external_msproject|include_guard|include_regular_expression|install|install_files|install_programs|install_targets|link_directories|link_libraries|list|load_cache|load_command|macro|make_directory|mark_as_advanced|math|message|option|output_required_files|project|qt_wrap_cpp|qt_wrap_ui|remove|remove_definitions|return|separate_arguments|set|set_directory_properties|set_property|set_source_files_properties|set_target_properties|set_tests_properties|site_name|source_group|string|subdir_depends|subdirs|target_compile_definitions|target_compile_features|target_compile_options|target_include_directories|target_link_directories|target_link_libraries|target_link_options|target_sources|try_compile|try_run|unset|use_mangled_mesa|utility_source|variable_requires|variable_watch|while|write_file)(?=\s*\()\b/,
+    boolean: /\b(?:FALSE|OFF|ON|TRUE)\b/,
+    namespace: /\b(?:INTERFACE|PRIVATE|PROPERTIES|PUBLIC|SHARED|STATIC|TARGET_OBJECTS)\b/,
+    operator: /\b(?:AND|DEFINED|EQUAL|GREATER|LESS|MATCHES|NOT|OR|STREQUAL|STRGREATER|STRLESS|VERSION_EQUAL|VERSION_GREATER|VERSION_LESS)\b/,
+    inserted: {
+      pattern: /\b\w+::\w+\b/,
+      alias: "class-name"
+    },
+    number: /\b\d+(?:\.\d+)*\b/,
+    function: /\b[a-z_]\w*(?=\s*\()\b/i,
+    punctuation: /[()>}]|\$[<{]/
+  };
+}
+
+export {
+  cmake
+};

package/dist/chunk-MYWNV5F3.mjs

@@ -0,0 +1,105 @@
+import {
+  typescript
+} from "./chunk-BSW6U4XU.mjs";
+import {
+  javadoclike
+} from "./chunk-NHRQUFUX.mjs";
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsdoc.js
+jsdoc.displayName = "jsdoc";
+jsdoc.aliases = [];
+function jsdoc(Prism) {
+  Prism.register(javadoclike);
+  Prism.register(javascript);
+  Prism.register(typescript);
+  (function(Prism2) {
+    var javascript2 = Prism2.languages.javascript;
+    var type = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source;
+    var parameterPrefix = "(@(?:arg|argument|param|property)\\s+(?:" + type + "\\s+)?)";
+    Prism2.languages.jsdoc = Prism2.languages.extend("javadoclike", {
+      parameter: {
+        // @param {string} foo - foo bar
+        pattern: RegExp(
+          parameterPrefix + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source
+        ),
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    });
+    Prism2.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: javascript2,
+            alias: "language-javascript"
+          },
+          punctuation: /[=[\]]/
+        }
+      },
+      "class-name": [
+        {
+          pattern: RegExp(
+            /(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(
+              /<TYPE>/g,
+              function() {
+                return type;
+              }
+            )
+          ),
+          lookbehind: true,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        {
+          pattern: RegExp("(@[a-z]+\\s+)" + type),
+          lookbehind: true,
+          inside: {
+            string: javascript2.string,
+            number: javascript2.number,
+            boolean: javascript2.boolean,
+            keyword: Prism2.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: javascript2,
+            alias: "language-javascript"
+          }
+        }
+      }
+    });
+    Prism2.languages.javadoclike.addSupport("javascript", Prism2.languages.jsdoc);
+  })(Prism);
+}
+
+export {
+  jsdoc
+};

package/dist/chunk-MZQNC4B2.mjs

@@ -0,0 +1,421 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/csharp.js
+csharp.displayName = "csharp";
+csharp.aliases = ["cs", "dotnet"];
+function csharp(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    function replace(pattern, replacements) {
+      return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+        return "(?:" + replacements[+index] + ")";
+      });
+    }
+    function re(pattern, replacements, flags) {
+      return RegExp(replace(pattern, replacements), flags || "");
+    }
+    function nested(pattern, depthLog2) {
+      for (var i = 0; i < depthLog2; i++) {
+        pattern = pattern.replace(/<<self>>/g, function() {
+          return "(?:" + pattern + ")";
+        });
+      }
+      return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+    }
+    var keywordKinds = {
+      // keywords which represent a return or variable type
+      type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+      // keywords which are used to declare a type
+      typeDeclaration: "class enum interface record struct",
+      // contextual keywords
+      // ("var" and "dynamic" are missing because they are used like types)
+      contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+      // all other keywords
+      other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
+    };
+    function keywordsToPattern(words) {
+      return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+    }
+    var typeDeclarationKeywords = keywordsToPattern(
+      keywordKinds.typeDeclaration
+    );
+    var keywords = RegExp(
+      keywordsToPattern(
+        keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other
+      )
+    );
+    var nonTypeKeywords = keywordsToPattern(
+      keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other
+    );
+    var nonContextualKeywords = keywordsToPattern(
+      keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.other
+    );
+    var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
+    var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
+    var name = /@?\b[A-Za-z_]\w*\b/.source;
+    var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
+    var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
+      nonTypeKeywords,
+      genericName
+    ]);
+    var array = /\[\s*(?:,\s*)*\]/.source;
+    var typeExpressionWithoutTuple = replace(
+      /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
+      [identifier, array]
+    );
+    var tupleElement = replace(
+      /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
+      [generic, nestedRound, array]
+    );
+    var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
+    var typeExpression = replace(
+      /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
+      [tuple, identifier, array]
+    );
+    var typeInside = {
+      keyword: keywords,
+      punctuation: /[<>()?,.:[\]]/
+    };
+    var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
+    var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
+    var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+    Prism2.languages.csharp = Prism2.languages.extend("clike", {
+      string: [
+        {
+          pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      "class-name": [
+        {
+          // Using static
+          // using static System.Math;
+          pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
+            identifier
+          ]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // Using alias (type)
+          // using Project = PC.MyCompany.Project;
+          pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
+            name,
+            typeExpression
+          ]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // Using alias (alias)
+          // using Project = PC.MyCompany.Project;
+          pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
+          lookbehind: true
+        },
+        {
+          // Type declarations
+          // class Foo<A, B>
+          // interface Foo<out A, B>
+          pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
+            typeDeclarationKeywords,
+            genericName
+          ]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // Single catch exception declaration
+          // catch(Foo)
+          // (things like catch(Foo e) is covered by variable declaration)
+          pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // Name of the type parameter of generic constraints
+          // where Foo : class
+          pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
+          lookbehind: true
+        },
+        {
+          // Casts and checks via as and is.
+          // as Foo<A>, is Bar<B>
+          // (things like if(a is Foo b) is covered by variable declaration)
+          pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
+            typeExpressionWithoutTuple
+          ]),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // Variable, field and parameter declaration
+          // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+          pattern: re(
+            /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source,
+            [typeExpression, nonContextualKeywords, name]
+          ),
+          inside: typeInside
+        }
+      ],
+      keyword: keywords,
+      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+      number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+      operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+      punctuation: /\?\.?|::|[{}[\];(),.:]/
+    });
+    Prism2.languages.insertBefore("csharp", "number", {
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      }
+    });
+    Prism2.languages.insertBefore("csharp", "punctuation", {
+      "named-parameter": {
+        pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
+        lookbehind: true,
+        alias: "punctuation"
+      }
+    });
+    Prism2.languages.insertBefore("csharp", "class-name", {
+      namespace: {
+        // namespace Foo.Bar {}
+        // using Foo.Bar;
+        pattern: re(
+          /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
+          [name]
+        ),
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      "type-expression": {
+        // default(Foo), typeof(Foo<Bar>), sizeof(int)
+        pattern: re(
+          /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source,
+          [nestedRound]
+        ),
+        lookbehind: true,
+        alias: "class-name",
+        inside: typeInside
+      },
+      "return-type": {
+        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+        // int Foo => 0; int Foo { get; set } = 0;
+        pattern: re(
+          /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
+          [typeExpression, identifier]
+        ),
+        inside: typeInside,
+        alias: "class-name"
+      },
+      "constructor-invocation": {
+        // new List<Foo<Bar[]>> { }
+        pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
+        lookbehind: true,
+        inside: typeInside,
+        alias: "class-name"
+      },
+      /*'explicit-implementation': {
+      // int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+      pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+      inside: classNameInside,
+      alias: 'class-name'
+      },*/
+      "generic-method": {
+        // foo<Bar>()
+        pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
+        inside: {
+          function: re(/^<<0>>/.source, [name]),
+          generic: {
+            pattern: RegExp(generic),
+            alias: "class-name",
+            inside: typeInside
+          }
+        }
+      },
+      "type-list": {
+        // The list of types inherited or of generic constraints
+        // class Foo<F> : Bar, IList<FooBar>
+        // where F : Bar, IList<int>
+        pattern: re(
+          /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source,
+          [
+            typeDeclarationKeywords,
+            genericName,
+            name,
+            typeExpression,
+            keywords.source,
+            nestedRound,
+            /\bnew\s*\(\s*\)/.source
+          ]
+        ),
+        lookbehind: true,
+        inside: {
+          "record-arguments": {
+            pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
+              genericName,
+              nestedRound
+            ]),
+            lookbehind: true,
+            greedy: true,
+            inside: Prism2.languages.csharp
+          },
+          keyword: keywords,
+          "class-name": {
+            pattern: RegExp(typeExpression),
+            greedy: true,
+            inside: typeInside
+          },
+          punctuation: /[,()]/
+        }
+      },
+      preprocessor: {
+        pattern: /(^[\t ]*)#.*/m,
+        lookbehind: true,
+        alias: "property",
+        inside: {
+          // highlight preprocessor directives as keywords
+          directive: {
+            pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+            lookbehind: true,
+            alias: "keyword"
+          }
+        }
+      }
+    });
+    var regularStringOrCharacter = regularString + "|" + character;
+    var regularStringCharacterOrComment = replace(
+      /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
+      [regularStringOrCharacter]
+    );
+    var roundExpression = nested(
+      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+        regularStringCharacterOrComment
+      ]),
+      2
+    );
+    var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
+    var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
+      identifier,
+      roundExpression
+    ]);
+    Prism2.languages.insertBefore("csharp", "class-name", {
+      attribute: {
+        // Attributes
+        // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+        pattern: re(
+          /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source,
+          [attrTarget, attr]
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          target: {
+            pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
+            alias: "keyword"
+          },
+          "attribute-arguments": {
+            pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
+            inside: Prism2.languages.csharp
+          },
+          "class-name": {
+            pattern: RegExp(identifier),
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /[:,]/
+        }
+      }
+    });
+    var formatString = /:[^}\r\n]+/.source;
+    var mInterpolationRound = nested(
+      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+        regularStringCharacterOrComment
+      ]),
+      2
+    );
+    var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+      mInterpolationRound,
+      formatString
+    ]);
+    var sInterpolationRound = nested(
+      replace(
+        /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source,
+        [regularStringOrCharacter]
+      ),
+      2
+    );
+    var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+      sInterpolationRound,
+      formatString
+    ]);
+    function createInterpolationInside(interpolation, interpolationRound) {
+      return {
+        interpolation: {
+          pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
+          lookbehind: true,
+          inside: {
+            "format-string": {
+              pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
+                interpolationRound,
+                formatString
+              ]),
+              lookbehind: true,
+              inside: {
+                punctuation: /^:/
+              }
+            },
+            punctuation: /^\{|\}$/,
+            expression: {
+              pattern: /[\s\S]+/,
+              alias: "language-csharp",
+              inside: Prism2.languages.csharp
+            }
+          }
+        },
+        string: /[\s\S]+/
+      };
+    }
+    Prism2.languages.insertBefore("csharp", "string", {
+      "interpolation-string": [
+        {
+          pattern: re(
+            /(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,
+            [mInterpolation]
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: createInterpolationInside(mInterpolation, mInterpolationRound)
+        },
+        {
+          pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
+            sInterpolation
+          ]),
+          lookbehind: true,
+          greedy: true,
+          inside: createInterpolationInside(sInterpolation, sInterpolationRound)
+        }
+      ],
+      char: {
+        pattern: RegExp(character),
+        greedy: true
+      }
+    });
+    Prism2.languages.dotnet = Prism2.languages.cs = Prism2.languages.csharp;
+  })(Prism);
+}
+
+export {
+  csharp
+};

package/dist/chunk-N5RAVQRR.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/brainfuck.js
+brainfuck.displayName = "brainfuck";
+brainfuck.aliases = [];
+function brainfuck(Prism) {
+  Prism.languages.brainfuck = {
+    pointer: {
+      pattern: /<|>/,
+      alias: "keyword"
+    },
+    increment: {
+      pattern: /\+/,
+      alias: "inserted"
+    },
+    decrement: {
+      pattern: /-/,
+      alias: "deleted"
+    },
+    branching: {
+      pattern: /\[|\]/,
+      alias: "important"
+    },
+    operator: /[.,]/,
+    comment: /\S+/
+  };
+}
+
+export {
+  brainfuck
+};

package/dist/chunk-N7FD4KIM.mjs

@@ -0,0 +1,40 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/supercollider.js
+supercollider.displayName = "supercollider";
+supercollider.aliases = ["sclang"];
+function supercollider(Prism) {
+  Prism.languages.supercollider = {
+    comment: {
+      pattern: /\/\/.*|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\])"(?:[^"\\]|\\[\s\S])*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    char: {
+      pattern: /\$(?:[^\\\r\n]|\\.)/,
+      greedy: true
+    },
+    symbol: {
+      pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'|\\\w+/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /\b(?:_|arg|classvar|const|nil|var|while)\b/,
+    boolean: /\b(?:false|true)\b/,
+    label: {
+      pattern: /\b[a-z_]\w*(?=\s*:)/,
+      alias: "property"
+    },
+    number: /\b(?:inf|pi|0x[0-9a-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?(?:pi)?|\d+r[0-9a-zA-Z]+(?:\.[0-9a-zA-Z]+)?|\d+[sb]{1,4}\d*)\b/,
+    "class-name": /\b[A-Z]\w*\b/,
+    operator: /\.{2,3}|#(?![[{])|&&|[!=]==?|\+>>|\+{1,3}|-[->]|=>|>>|\?\?|@\|?@|\|(?:@|[!=]=)?\||!\?|<[!=>]|\*{1,2}|<{2,3}\*?|[-!%&/<>?@|=`]/,
+    punctuation: /[{}()[\].:,;]|#[[{]/
+  };
+  Prism.languages.sclang = Prism.languages.supercollider;
+}
+
+export {
+  supercollider
+};