@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-EOJPSTEK.mjs

@@ -0,0 +1,134 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nevod.js
+nevod.displayName = "nevod";
+nevod.aliases = [];
+function nevod(Prism) {
+  Prism.languages.nevod = {
+    comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
+    string: {
+      pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
+      greedy: true,
+      inside: {
+        "string-attrs": /!$|!\*$|\*$/
+      }
+    },
+    namespace: {
+      pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
+      lookbehind: true
+    },
+    pattern: {
+      pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
+      lookbehind: true,
+      inside: {
+        "pattern-name": {
+          pattern: /^#?[a-zA-Z0-9\-.]+/,
+          alias: "class-name"
+        },
+        fields: {
+          pattern: /\(.*\)/,
+          inside: {
+            "field-name": {
+              pattern: /[a-zA-Z0-9\-.]+/,
+              alias: "variable"
+            },
+            punctuation: /[,()]/,
+            operator: {
+              pattern: /~/,
+              alias: "field-hidden-mark"
+            }
+          }
+        }
+      }
+    },
+    search: {
+      pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
+      alias: "function",
+      lookbehind: true
+    },
+    keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
+    "standard-pattern": {
+      pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
+      inside: {
+        "standard-pattern-name": {
+          pattern: /^[a-zA-Z0-9\-.]+/,
+          alias: "builtin"
+        },
+        quantifier: {
+          pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+          alias: "number"
+        },
+        "standard-pattern-attr": {
+          pattern: /[a-zA-Z0-9\-.]+/,
+          alias: "builtin"
+        },
+        punctuation: /[,()]/
+      }
+    },
+    quantifier: {
+      pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+      alias: "number"
+    },
+    operator: [
+      {
+        pattern: /=/,
+        alias: "pattern-def"
+      },
+      {
+        pattern: /&/,
+        alias: "conjunction"
+      },
+      {
+        pattern: /~/,
+        alias: "exception"
+      },
+      {
+        pattern: /\?/,
+        alias: "optionality"
+      },
+      {
+        pattern: /[[\]]/,
+        alias: "repetition"
+      },
+      {
+        pattern: /[{}]/,
+        alias: "variation"
+      },
+      {
+        pattern: /[+_]/,
+        alias: "sequence"
+      },
+      {
+        pattern: /\.{2,3}/,
+        alias: "span"
+      }
+    ],
+    "field-capture": [
+      {
+        pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
+        lookbehind: true,
+        inside: {
+          "field-name": {
+            pattern: /[a-zA-Z0-9\-.]+/,
+            alias: "variable"
+          },
+          colon: /:/
+        }
+      },
+      {
+        pattern: /[a-zA-Z0-9\-.]+\s*:/,
+        inside: {
+          "field-name": {
+            pattern: /[a-zA-Z0-9\-.]+/,
+            alias: "variable"
+          },
+          colon: /:/
+        }
+      }
+    ],
+    punctuation: /[:;,()]/,
+    name: /[a-zA-Z0-9\-.]+/
+  };
+}
+
+export {
+  nevod
+};

package/dist/chunk-ESX6Q6VJ.mjs

@@ -0,0 +1,54 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gn.js
+gn.displayName = "gn";
+gn.aliases = ["gni"];
+function gn(Prism) {
+  Prism.languages.gn = {
+    comment: {
+      pattern: /#.*/,
+      greedy: true
+    },
+    "string-literal": {
+      pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
+          lookbehind: true,
+          inside: {
+            number: /^\$0x[\s\S]{2}$/,
+            variable: /^\$\w+$/,
+            "interpolation-punctuation": {
+              pattern: /^\$\{|\}$/,
+              alias: "punctuation"
+            },
+            expression: {
+              pattern: /[\s\S]+/,
+              inside: null
+              // see below
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    keyword: /\b(?:else|if)\b/,
+    boolean: /\b(?:false|true)\b/,
+    "builtin-function": {
+      // a few functions get special highlighting to improve readability
+      pattern: /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
+      alias: "keyword"
+    },
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    constant: /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
+    number: /-?\b\d+\b/,
+    operator: /[-+!=<>]=?|&&|\|\|/,
+    punctuation: /[(){}[\],.]/
+  };
+  Prism.languages.gn["string-literal"].inside["interpolation"].inside["expression"].inside = Prism.languages.gn;
+  Prism.languages.gni = Prism.languages.gn;
+}
+
+export {
+  gn
+};

package/dist/chunk-EZV6PZAV.mjs

@@ -0,0 +1,21 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gml.js
+gml.displayName = "gml";
+gml.aliases = ["gamemakerlanguage"];
+function gml(Prism) {
+  Prism.register(clike);
+  Prism.languages.gamemakerlanguage = Prism.languages.gml = Prism.languages.extend("clike", {
+    keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/,
+    number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i,
+    operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/,
+    constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/,
+    variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/
+  });
+}
+
+export {
+  gml
+};

package/dist/chunk-FGJTQJNO.mjs

@@ -0,0 +1,89 @@
+import {
+  python
+} from "./chunk-QW6HJC6E.mjs";
+import {
+  mata
+} from "./chunk-6G5OZ7F7.mjs";
+import {
+  java
+} from "./chunk-TG6MIYIG.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/stata.js
+stata.displayName = "stata";
+stata.aliases = [];
+function stata(Prism) {
+  Prism.register(java);
+  Prism.register(mata);
+  Prism.register(python);
+  Prism.languages.stata = {
+    comment: [
+      {
+        pattern: /(^[ \t]*)\*.*/m,
+        lookbehind: true,
+        greedy: true
+      },
+      {
+        pattern: /(^|\s)\/\/.*|\/\*[\s\S]*?\*\//,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    "string-literal": {
+      pattern: /"[^"\r\n]*"|[‘`']".*?"[’`']/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /\$\{[^{}]*\}|[‘`']\w[^’`'\r\n]*[’`']/,
+          inside: {
+            punctuation: /^\$\{|\}$/,
+            expression: {
+              pattern: /[\s\S]+/,
+              inside: null
+              // see below
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    mata: {
+      pattern: /(^[ \t]*mata[ \t]*:)[\s\S]+?(?=^end\b)/m,
+      lookbehind: true,
+      greedy: true,
+      alias: "language-mata",
+      inside: Prism.languages.mata
+    },
+    java: {
+      pattern: /(^[ \t]*java[ \t]*:)[\s\S]+?(?=^end\b)/m,
+      lookbehind: true,
+      greedy: true,
+      alias: "language-java",
+      inside: Prism.languages.java
+    },
+    python: {
+      pattern: /(^[ \t]*python[ \t]*:)[\s\S]+?(?=^end\b)/m,
+      lookbehind: true,
+      greedy: true,
+      alias: "language-python",
+      inside: Prism.languages.python
+    },
+    command: {
+      pattern: /(^[ \t]*(?:\.[ \t]+)?(?:(?:bayes|bootstrap|by|bysort|capture|collect|fmm|fp|frame|jackknife|mfp|mi|nestreg|noisily|permute|quietly|rolling|simulate|statsby|stepwise|svy|version|xi)\b[^:\r\n]*:[ \t]*|(?:capture|noisily|quietly|version)[ \t]+)?)[a-zA-Z]\w*/m,
+      lookbehind: true,
+      greedy: true,
+      alias: "keyword"
+    },
+    variable: /\$\w+|[‘`']\w[^’`'\r\n]*[’`']/,
+    keyword: /\b(?:bayes|bootstrap|by|bysort|capture|clear|collect|fmm|fp|frame|if|in|jackknife|mi[ \t]+estimate|mfp|nestreg|noisily|of|permute|quietly|rolling|simulate|sort|statsby|stepwise|svy|varlist|version|xi)\b/,
+    boolean: /\b(?:off|on)\b/,
+    number: /\b\d+(?:\.\d+)?\b|\B\.\d+/,
+    function: /\b[a-z_]\w*(?=\()/i,
+    operator: /\+\+|--|##?|[<>!=~]=?|[+\-*^&|/]/,
+    punctuation: /[(){}[\],:]/
+  };
+  Prism.languages.stata["string-literal"].inside.interpolation.inside.expression.inside = Prism.languages.stata;
+}
+
+export {
+  stata
+};

package/dist/chunk-FJTCKSD7.mjs

@@ -0,0 +1,57 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/solution-file.js
+solutionFile.displayName = "solution-file";
+solutionFile.aliases = ["sln"];
+function solutionFile(Prism) {
+  ;
+  (function(Prism2) {
+    var guid = {
+      // https://en.wikipedia.org/wiki/Universally_unique_identifier#Format
+      pattern: /\{[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\}/i,
+      alias: "constant",
+      inside: {
+        punctuation: /[{}]/
+      }
+    };
+    Prism2.languages["solution-file"] = {
+      comment: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+        greedy: true,
+        inside: {
+          guid
+        }
+      },
+      object: {
+        // Foo
+        //   Bar("abs") = 9
+        //   EndBar
+        //   Prop = TRUE
+        // EndFoo
+        pattern: /^([ \t]*)(?:([A-Z]\w*)\b(?=.*(?:\r\n?|\n)(?:\1[ \t].*(?:\r\n?|\n))*\1End\2(?=[ \t]*$))|End[A-Z]\w*(?=[ \t]*$))/m,
+        lookbehind: true,
+        greedy: true,
+        alias: "keyword"
+      },
+      property: {
+        pattern: /^([ \t]*)(?!\s)[^\r\n"#=()]*[^\s"#=()](?=\s*=)/m,
+        lookbehind: true,
+        inside: {
+          guid
+        }
+      },
+      guid,
+      number: /\b\d+(?:\.\d+)*\b/,
+      boolean: /\b(?:FALSE|TRUE)\b/,
+      operator: /=/,
+      punctuation: /[(),]/
+    };
+    Prism2.languages["sln"] = Prism2.languages["solution-file"];
+  })(Prism);
+}
+
+export {
+  solutionFile
+};

package/dist/chunk-FKPUAKHH.mjs

@@ -0,0 +1,95 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kotlin.js
+kotlin.displayName = "kotlin";
+kotlin.aliases = ["kt", "kts"];
+function kotlin(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    Prism2.languages.kotlin = Prism2.languages.extend("clike", {
+      keyword: {
+        // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+        pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+        lookbehind: true
+      },
+      function: [
+        {
+          pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+          greedy: true
+        },
+        {
+          pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+      operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+    });
+    delete Prism2.languages.kotlin["class-name"];
+    var interpolationInside = {
+      "interpolation-punctuation": {
+        pattern: /^\$\{?|\}$/,
+        alias: "punctuation"
+      },
+      expression: {
+        pattern: /[\s\S]+/,
+        inside: Prism2.languages.kotlin
+      }
+    };
+    Prism2.languages.insertBefore("kotlin", "string", {
+      // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+      "string-literal": [
+        {
+          pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+          alias: "multiline",
+          inside: {
+            interpolation: {
+              pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              inside: interpolationInside
+            },
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+          alias: "singleline",
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              lookbehind: true,
+              inside: interpolationInside
+            },
+            string: /[\s\S]+/
+          }
+        }
+      ],
+      char: {
+        // https://kotlinlang.org/spec/expressions.html#character-literals
+        pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+        greedy: true
+      }
+    });
+    delete Prism2.languages.kotlin["string"];
+    Prism2.languages.insertBefore("kotlin", "keyword", {
+      annotation: {
+        pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+        alias: "builtin"
+      }
+    });
+    Prism2.languages.insertBefore("kotlin", "function", {
+      label: {
+        pattern: /\b\w+@|@\w+\b/,
+        alias: "symbol"
+      }
+    });
+    Prism2.languages.kt = Prism2.languages.kotlin;
+    Prism2.languages.kts = Prism2.languages.kotlin;
+  })(Prism);
+}
+
+export {
+  kotlin
+};

package/dist/chunk-FOYBPUFA.mjs

@@ -0,0 +1,47 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/smalltalk.js
+smalltalk.displayName = "smalltalk";
+smalltalk.aliases = [];
+function smalltalk(Prism) {
+  Prism.languages.smalltalk = {
+    comment: {
+      pattern: /"(?:""|[^"])*"/,
+      greedy: true
+    },
+    char: {
+      pattern: /\$./,
+      greedy: true
+    },
+    string: {
+      pattern: /'(?:''|[^'])*'/,
+      greedy: true
+    },
+    symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+    "block-arguments": {
+      pattern: /(\[\s*):[^\[|]*\|/,
+      lookbehind: true,
+      inside: {
+        variable: /:[\da-z]+/i,
+        punctuation: /\|/
+      }
+    },
+    "temporary-variables": {
+      pattern: /\|[^|]+\|/,
+      inside: {
+        variable: /[\da-z]+/i,
+        punctuation: /\|/
+      }
+    },
+    keyword: /\b(?:new|nil|self|super)\b/,
+    boolean: /\b(?:false|true)\b/,
+    number: [
+      /\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
+      /\b\d+(?:\.\d+)?(?:e-?\d+)?/
+    ],
+    operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+    punctuation: /[.;:?\[\](){}]/
+  };
+}
+
+export {
+  smalltalk
+};

package/dist/chunk-FPVXAJ2J.mjs

@@ -0,0 +1,35 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/vhdl.js
+vhdl.displayName = "vhdl";
+vhdl.aliases = [];
+function vhdl(Prism) {
+  Prism.languages.vhdl = {
+    comment: /--.+/,
+    // support for all logic vectors
+    "vhdl-vectors": {
+      pattern: /\b[oxb]"[\da-f_]+"|"[01uxzwlh-]+"/i,
+      alias: "number"
+    },
+    // support for operator overloading included
+    "quoted-function": {
+      pattern: /"\S+?"(?=\()/,
+      alias: "function"
+    },
+    string: /"(?:[^\\"\r\n]|\\(?:\r\n|[\s\S]))*"/,
+    attribute: {
+      pattern: /\b'\w+/,
+      alias: "attr-name"
+    },
+    // support for predefined attributes included
+    keyword: /\b(?:access|after|alias|all|architecture|array|assert|attribute|begin|block|body|buffer|bus|case|component|configuration|constant|disconnect|downto|else|elsif|end|entity|exit|file|for|function|generate|generic|group|guarded|if|impure|in|inertial|inout|is|label|library|linkage|literal|loop|map|new|next|null|of|on|open|others|out|package|port|postponed|private|procedure|process|pure|range|record|register|reject|report|return|select|severity|shared|signal|subtype|then|to|transport|type|unaffected|units|until|use|variable|view|wait|when|while|with)\b/i,
+    boolean: /\b(?:false|true)\b/i,
+    function: /\w+(?=\()/,
+    // decimal, based, physical, and exponential numbers supported
+    number: /'[01uxzwlh-]'|\b(?:\d+#[\da-f_.]+#|\d[\d_.]*)(?:e[-+]?\d+)?/i,
+    operator: /[<>]=?|:=|[-+*/&=]|\b(?:abs|and|mod|nand|nor|not|or|rem|rol|ror|sla|sll|sra|srl|xnor|xor)\b/i,
+    punctuation: /[{}[\];(),.:]/
+  };
+}
+
+export {
+  vhdl
+};

package/dist/chunk-FUBI7ADP.mjs

@@ -0,0 +1,26 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/n4js.js
+n4js.displayName = "n4js";
+n4js.aliases = ["n4jsd"];
+function n4js(Prism) {
+  Prism.register(javascript);
+  Prism.languages.n4js = Prism.languages.extend("javascript", {
+    // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html
+    keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/
+  });
+  Prism.languages.insertBefore("n4js", "constant", {
+    // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations
+    annotation: {
+      pattern: /@+\w+/,
+      alias: "operator"
+    }
+  });
+  Prism.languages.n4jsd = Prism.languages.n4js;
+}
+
+export {
+  n4js
+};

package/dist/chunk-FVLPKW7Z.mjs

@@ -0,0 +1,52 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/erlang.js
+erlang.displayName = "erlang";
+erlang.aliases = [];
+function erlang(Prism) {
+  Prism.languages.erlang = {
+    comment: /%.+/,
+    string: {
+      pattern: /"(?:\\.|[^\\"\r\n])*"/,
+      greedy: true
+    },
+    "quoted-function": {
+      pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+      alias: "function"
+    },
+    "quoted-atom": {
+      pattern: /'(?:\\.|[^\\'\r\n])+'/,
+      alias: "atom"
+    },
+    boolean: /\b(?:false|true)\b/,
+    keyword: /\b(?:after|begin|case|catch|end|fun|if|of|receive|try|when)\b/,
+    number: [
+      /\$\\?./,
+      /\b\d+#[a-z0-9]+/i,
+      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
+    ],
+    function: /\b[a-z][\w@]*(?=\()/,
+    variable: {
+      // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+      pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+      lookbehind: true
+    },
+    operator: [
+      /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
+      {
+        // We don't want to match <<
+        pattern: /(^|[^<])<(?!<)/,
+        lookbehind: true
+      },
+      {
+        // We don't want to match >>
+        pattern: /(^|[^>])>(?!>)/,
+        lookbehind: true
+      }
+    ],
+    atom: /\b[a-z][\w@]*/,
+    punctuation: /[()[\]{}:;,.#|]|<<|>>/
+  };
+}
+
+export {
+  erlang
+};

package/dist/chunk-FVUGVS5L.mjs

@@ -0,0 +1,41 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cypher.js
+cypher.displayName = "cypher";
+cypher.aliases = [];
+function cypher(Prism) {
+  Prism.languages.cypher = {
+    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+    comment: /\/\/.*/,
+    string: {
+      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+      greedy: true
+    },
+    "class-name": {
+      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+      lookbehind: true,
+      greedy: true
+    },
+    relationship: {
+      pattern: /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+      lookbehind: true,
+      greedy: true,
+      alias: "property"
+    },
+    identifier: {
+      pattern: /`(?:[^`\\\r\n])*`/,
+      greedy: true
+    },
+    variable: /\$\w+/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+    keyword: /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+    function: /\b\w+\b(?=\s*\()/,
+    boolean: /\b(?:false|null|true)\b/i,
+    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+    punctuation: /[()[\]{},;.]/
+  };
+}
+
+export {
+  cypher
+};