@distri/react 0.2.7 → 0.3.0

package/dist/chunk-HPUECJDJ.js

@@ -0,0 +1,77 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/groovy.js
+var require_groovy = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/groovy.js"(exports, module) {
+    module.exports = groovy;
+    groovy.displayName = "groovy";
+    groovy.aliases = [];
+    function groovy(Prism) {
+      Prism.languages.groovy = Prism.languages.extend("clike", {
+        string: [
+          {
+            // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+            pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+            greedy: true
+          },
+          {
+            // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+            // simple division (see JS regex), so find a fix maybe?
+            pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            greedy: true
+          }
+        ],
+        keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+        number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+        operator: {
+          pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+          lookbehind: true
+        },
+        punctuation: /\.+|[{}[\];(),:$]/
+      });
+      Prism.languages.insertBefore("groovy", "string", {
+        shebang: {
+          pattern: /#!.+/,
+          alias: "comment"
+        }
+      });
+      Prism.languages.insertBefore("groovy", "punctuation", {
+        "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+      });
+      Prism.languages.insertBefore("groovy", "function", {
+        annotation: {
+          pattern: /(^|[^.])@\w+/,
+          lookbehind: true,
+          alias: "punctuation"
+        }
+      });
+      Prism.hooks.add("wrap", function(env) {
+        if (env.language === "groovy" && env.type === "string") {
+          var delimiter = env.content.value[0];
+          if (delimiter != "'") {
+            var pattern = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
+            if (delimiter === "$") {
+              pattern = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/;
+            }
+            env.content.value = env.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+            env.content = Prism.highlight(env.content.value, {
+              expression: {
+                pattern,
+                lookbehind: true,
+                inside: Prism.languages.groovy
+              }
+            });
+            env.classes.push(delimiter === "/" ? "regex" : "gstring");
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_groovy
+};

package/dist/chunk-HQ25WWHW.js

@@ -0,0 +1,30 @@
+"use client";
+import {
+  require_cpp
+} from "./chunk-N4CDNUSI.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/arduino.js
+var require_arduino = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/arduino.js"(exports, module) {
+    var refractorCpp = require_cpp();
+    module.exports = arduino;
+    arduino.displayName = "arduino";
+    arduino.aliases = ["ino"];
+    function arduino(Prism) {
+      Prism.register(refractorCpp);
+      Prism.languages.arduino = Prism.languages.extend("cpp", {
+        keyword: /\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
+        constant: /\b(?:ANALOG_MESSAGE|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FIRMATA_STRING|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL2V56|LED_BUILTIN|LOW|OUTPUT|REPORT_ANALOG|REPORT_DIGITAL|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET)\b/,
+        builtin: /\b(?:Audio|BSSID|Bridge|Client|Console|EEPROM|Esplora|EsploraTFT|Ethernet|EthernetClient|EthernetServer|EthernetUDP|File|FileIO|FileSystem|Firmata|GPRS|GSM|GSMBand|GSMClient|GSMModem|GSMPIN|GSMScanner|GSMServer|GSMVoiceCall|GSM_SMS|HttpClient|IPAddress|IRread|Keyboard|KeyboardController|LiquidCrystal|LiquidCrystal_I2C|Mailbox|Mouse|MouseController|PImage|Process|RSSI|RobotControl|RobotMotor|SD|SPI|SSID|Scheduler|Serial|Server|Servo|SoftwareSerial|Stepper|Stream|TFT|Task|USBHost|WiFi|WiFiClient|WiFiServer|WiFiUDP|Wire|YunClient|YunServer|abs|addParameter|analogRead|analogReadResolution|analogReference|analogWrite|analogWriteResolution|answerCall|attach|attachGPRS|attachInterrupt|attached|autoscroll|available|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|bitClear|bitRead|bitSet|bitWrite|blink|blinkVersion|buffer|changePIN|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compassRead|config|connect|connected|constrain|cos|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|delay|delayMicroseconds|detach|detachInterrupt|digitalRead|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endTransmission|endWrite|exists|exitValue|fill|find|findUntil|flush|gatewayIP|get|getAsynchronously|getBand|getButton|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|home|image|interrupts|isActionDone|isDirectory|isListening|isPIN|isPressed|isValid|keyPressed|keyReleased|keyboardRead|knobRead|leftToRight|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|lowByte|macAddress|maintain|map|max|messageAvailable|micros|millis|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|noListenOnLocalhost|noStroke|noTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|pinMode|playFile|playMelody|point|pointTo|position|pow|prepare|press|print|printFirmwareVersion|printVersion|println|process|processInput|pulseIn|put|random|randomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|run|runAsynchronously|runShellCommand|runShellCommandAsynchronously|running|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|serialEvent|setBand|setBitOrder|setClockDivider|setCursor|setDNS|setDataMode|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|shiftIn|shiftOut|shutdown|sin|size|sqrt|startLoop|step|stop|stroke|subnetMask|switchPIN|tan|tempoWrite|text|tone|transfer|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRGB|writeRed|yield)\b/
+      });
+      Prism.languages.ino = Prism.languages.arduino;
+    }
+  }
+});
+
+export {
+  require_arduino
+};

package/dist/chunk-IDCGS2LG.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lolcode.js
+var require_lolcode = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lolcode.js"(exports, module) {
+    module.exports = lolcode;
+    lolcode.displayName = "lolcode";
+    lolcode.aliases = [];
+    function lolcode(Prism) {
+      Prism.languages.lolcode = {
+        comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+        string: {
+          pattern: /"(?::.|[^":])*"/,
+          inside: {
+            variable: /:\{[^}]+\}/,
+            symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+          },
+          greedy: true
+        },
+        number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+        symbol: {
+          pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+          lookbehind: true,
+          inside: {
+            keyword: /A(?=\s)/
+          }
+        },
+        label: {
+          pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+          lookbehind: true,
+          alias: "string"
+        },
+        function: {
+          pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+          lookbehind: true
+        },
+        keyword: [
+          {
+            pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
+            lookbehind: true
+          },
+          /'Z(?=\s|,|$)/
+        ],
+        boolean: {
+          pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+          lookbehind: true
+        },
+        variable: {
+          pattern: /(^|\s)IT(?=\s|,|$)/,
+          lookbehind: true
+        },
+        operator: {
+          pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+          lookbehind: true
+        },
+        punctuation: /\.{3}|…|,|!/
+      };
+    }
+  }
+});
+
+export {
+  require_lolcode
+};

package/dist/chunk-IGC26U6E.js

@@ -0,0 +1,91 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-DYCT6UGG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/liquid.js
+var require_liquid = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/liquid.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = liquid;
+    liquid.displayName = "liquid";
+    liquid.aliases = [];
+    function liquid(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      Prism.languages.liquid = {
+        comment: {
+          pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+          lookbehind: true
+        },
+        delimiter: {
+          pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+          alias: "punctuation"
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: true
+        },
+        keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+        object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+        function: [
+          {
+            pattern: /(\|\s*)\w+/,
+            lookbehind: true,
+            alias: "filter"
+          },
+          {
+            // array functions
+            pattern: /(\.\s*)(?:first|last|size)/,
+            lookbehind: true
+          }
+        ],
+        boolean: /\b(?:false|nil|true)\b/,
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        },
+        // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+        number: /\b\d+(?:\.\d+)?\b/,
+        operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+        punctuation: /[.,\[\]()]/,
+        empty: {
+          pattern: /\bempty\b/,
+          alias: "keyword"
+        }
+      };
+      Prism.hooks.add("before-tokenize", function(env) {
+        var liquidPattern = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g;
+        var insideRaw = false;
+        Prism.languages["markup-templating"].buildPlaceholders(
+          env,
+          "liquid",
+          liquidPattern,
+          function(match) {
+            var tagMatch = /^\{%-?\s*(\w+)/.exec(match);
+            if (tagMatch) {
+              var tag = tagMatch[1];
+              if (tag === "raw" && !insideRaw) {
+                insideRaw = true;
+                return true;
+              } else if (tag === "endraw") {
+                insideRaw = false;
+                return true;
+              }
+            }
+            return !insideRaw;
+          }
+        );
+      });
+      Prism.hooks.add("after-tokenize", function(env) {
+        Prism.languages["markup-templating"].tokenizePlaceholders(env, "liquid");
+      });
+    }
+  }
+});
+
+export {
+  require_liquid
+};

package/dist/chunk-IHY66EFI.js

@@ -0,0 +1,46 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dax.js
+var require_dax = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dax.js"(exports, module) {
+    module.exports = dax;
+    dax.displayName = "dax";
+    dax.aliases = [];
+    function dax(Prism) {
+      Prism.languages.dax = {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
+          lookbehind: true
+        },
+        "data-field": {
+          pattern: /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
+          alias: "symbol"
+        },
+        measure: {
+          pattern: /\[[ \w\xA0-\uFFFF]+\]/,
+          alias: "constant"
+        },
+        string: {
+          pattern: /"(?:[^"]|"")*"(?!")/,
+          greedy: true
+        },
+        function: /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
+        keyword: /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
+        boolean: {
+          pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
+          alias: "constant"
+        },
+        number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
+        operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
+        punctuation: /[;\[\](){}`,.]/
+      };
+    }
+  }
+});
+
+export {
+  require_dax
+};

package/dist/chunk-IOV4LKPF.js

@@ -0,0 +1,132 @@
+"use client";
+import {
+  require_csharp
+} from "./chunk-IZLK5PA4.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cshtml.js
+var require_cshtml = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cshtml.js"(exports, module) {
+    var refractorCsharp = require_csharp();
+    module.exports = cshtml;
+    cshtml.displayName = "cshtml";
+    cshtml.aliases = ["razor"];
+    function cshtml(Prism) {
+      Prism.register(refractorCsharp);
+      (function(Prism2) {
+        var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source;
+        var stringLike = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+        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]").replace(/<str>/g, "(?:" + stringLike + ")").replace(/<comment>/g, "(?:" + commentLike + ")");
+        }
+        var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
+        var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
+        var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
+        var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2);
+        var tagAttrs = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/.source;
+        var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
+        var tagRegion = /\B@?/.source + "(?:" + /<([a-zA-Z][\w:]*)/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+        // eslint-disable-next-line regexp/strict
+        /<\/?(?!\1\b)/.source + tagContent + "|" + // nested start tag
+        nested(
+          // eslint-disable-next-line regexp/strict
+          /<\1/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
+          // eslint-disable-next-line regexp/strict
+          /<\/?(?!\1\b)/.source + tagContent + "|<self>") + ")*" + // eslint-disable-next-line regexp/strict
+          /<\/\1\s*>/.source,
+          2
+        )) + ")*" + // eslint-disable-next-line regexp/strict
+        /<\/\1\s*>/.source + "|" + /</.source + tagContent + ")";
+        Prism2.languages.cshtml = Prism2.languages.extend("markup", {});
+        var csharpWithHtml = Prism2.languages.insertBefore(
+          "csharp",
+          "string",
+          {
+            html: {
+              pattern: RegExp(tagRegion),
+              greedy: true,
+              inside: Prism2.languages.cshtml
+            }
+          },
+          {
+            csharp: Prism2.languages.extend("csharp", {})
+          }
+        );
+        var cs = {
+          pattern: /\S[\s\S]*/,
+          alias: "language-csharp",
+          inside: csharpWithHtml
+        };
+        Prism2.languages.insertBefore("cshtml", "prolog", {
+          "razor-comment": {
+            pattern: /@\*[\s\S]*?\*@/,
+            greedy: true,
+            alias: "comment"
+          },
+          block: {
+            pattern: RegExp(
+              /(^|[^@])@/.source + "(?:" + [
+                // @{ ... }
+                curly,
+                // @code{ ... }
+                /(?:code|functions)\s*/.source + curly,
+                // @for (...) { ... }
+                /(?:for|foreach|lock|switch|using|while)\s*/.source + round + /\s*/.source + curly,
+                // @do { ... } while (...);
+                /do\s*/.source + curly + /\s*while\s*/.source + round + /(?:\s*;)?/.source,
+                // @try { ... } catch (...) { ... } finally { ... }
+                /try\s*/.source + curly + /\s*catch\s*/.source + round + /\s*/.source + curly + /\s*finally\s*/.source + curly,
+                // @if (...) {...} else if (...) {...} else {...}
+                /if\s*/.source + round + /\s*/.source + curly + "(?:" + /\s*else/.source + "(?:" + /\s+if\s*/.source + round + ")?" + /\s*/.source + curly + ")*"
+              ].join("|") + ")"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^@\w*/,
+              csharp: cs
+            }
+          },
+          directive: {
+            pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              keyword: /^@\w+/,
+              csharp: cs
+            }
+          },
+          value: {
+            pattern: RegExp(
+              /(^|[^@])@/.source + /(?:await\b\s*)?/.source + "(?:" + /\w+\b/.source + "|" + round + ")(?:" + /[?!]?\.\w+\b/.source + "|" + round + "|" + square + "|" + angle + round + ")*"
+            ),
+            lookbehind: true,
+            greedy: true,
+            alias: "variable",
+            inside: {
+              keyword: /^@/,
+              csharp: cs
+            }
+          },
+          "delegate-operator": {
+            pattern: /(^|[^@])@(?=<)/,
+            lookbehind: true,
+            alias: "operator"
+          }
+        });
+        Prism2.languages.razor = Prism2.languages.cshtml;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_cshtml
+};

package/dist/chunk-IRYK7EBW.js

@@ -0,0 +1,80 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sml.js
+var require_sml = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sml.js"(exports, module) {
+    module.exports = sml;
+    sml.displayName = "sml";
+    sml.aliases = ["smlnj"];
+    function sml(Prism) {
+      ;
+      (function(Prism2) {
+        var keywords = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+        Prism2.languages.sml = {
+          // allow one level of nesting
+          comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+          string: {
+            pattern: /#?"(?:[^"\\]|\\.)*"/,
+            greedy: true
+          },
+          "class-name": [
+            {
+              // This is only an approximation since the real grammar is context-free
+              //
+              // Why the main loop so complex?
+              // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+              // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+              // followed by a long identifier.
+              pattern: RegExp(
+                /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+                  return /\s*(?:[*,]|->)/.source;
+                }).replace(/<TERMINAL>/g, function() {
+                  return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+                }).replace(/<LONG-ID>/g, function() {
+                  return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+                }).replace(/<KEYWORD>/g, function() {
+                  return keywords.source;
+                }),
+                "i"
+              ),
+              lookbehind: true,
+              greedy: true,
+              inside: null
+              // see below
+            },
+            {
+              pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+              lookbehind: true
+            }
+          ],
+          function: {
+            pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+            lookbehind: true
+          },
+          keyword: keywords,
+          variable: {
+            pattern: /(^|[^\w'])'[\w']*/,
+            lookbehind: true
+          },
+          number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+          word: {
+            pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+            alias: "constant"
+          },
+          boolean: /\b(?:false|true)\b/i,
+          operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+          punctuation: /[(){}\[\].:,;]/
+        };
+        Prism2.languages.sml["class-name"][0].inside = Prism2.languages.sml;
+        Prism2.languages.smlnj = Prism2.languages.sml;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_sml
+};

package/dist/chunk-ITUYRI56.js

@@ -0,0 +1,53 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/eiffel.js
+var require_eiffel = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/eiffel.js"(exports, module) {
+    module.exports = eiffel;
+    eiffel.displayName = "eiffel";
+    eiffel.aliases = [];
+    function eiffel(Prism) {
+      Prism.languages.eiffel = {
+        comment: /--.*/,
+        string: [
+          // Aligned-verbatim-strings
+          {
+            pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
+            greedy: true
+          },
+          // Non-aligned-verbatim-strings
+          {
+            pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
+            greedy: true
+          },
+          // Single-line string
+          {
+            pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
+            greedy: true
+          }
+        ],
+        // normal char | special char | char code
+        char: /'(?:%.|[^%'\r\n])+'/,
+        keyword: /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+        boolean: /\b(?:False|True)\b/i,
+        // Convention: class-names are always all upper-case characters
+        "class-name": /\b[A-Z][\dA-Z_]*\b/,
+        number: [
+          // hexa | octal | bin
+          /\b0[xcb][\da-f](?:_*[\da-f])*\b/i,
+          // Decimal
+          /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
+        ],
+        punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
+        operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
+      };
+    }
+  }
+});
+
+export {
+  require_eiffel
+};