@distri/react 0.2.7 → 0.3.0

package/dist/chunk-4WZAWVVD.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/monkey.js
+var require_monkey = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/monkey.js"(exports, module) {
+    module.exports = monkey;
+    monkey.displayName = "monkey";
+    monkey.aliases = [];
+    function monkey(Prism) {
+      Prism.languages.monkey = {
+        comment: {
+          pattern: /^#Rem\s[\s\S]*?^#End|'.+/im,
+          greedy: true
+        },
+        string: {
+          pattern: /"[^"\r\n]*"/,
+          greedy: true
+        },
+        preprocessor: {
+          pattern: /(^[ \t]*)#.+/m,
+          lookbehind: true,
+          greedy: true,
+          alias: "property"
+        },
+        function: /\b\w+(?=\()/,
+        "type-char": {
+          pattern: /\b[?%#$]/,
+          alias: "class-name"
+        },
+        number: {
+          pattern: /((?:\.\.)?)(?:(?:\b|\B-\.?|\B\.)\d+(?:(?!\.\.)\.\d*)?|\$[\da-f]+)/i,
+          lookbehind: true
+        },
+        keyword: /\b(?:Abstract|Array|Bool|Case|Catch|Class|Const|Continue|Default|Eachin|Else|ElseIf|End|EndIf|Exit|Extends|Extern|False|Field|Final|Float|For|Forever|Function|Global|If|Implements|Import|Inline|Int|Interface|Local|Method|Module|New|Next|Null|Object|Private|Property|Public|Repeat|Return|Select|Self|Step|Strict|String|Super|Then|Throw|To|True|Try|Until|Void|Wend|While)\b/i,
+        operator: /\.\.|<[=>]?|>=?|:?=|(?:[+\-*\/&~|]|\b(?:Mod|Shl|Shr)\b)=?|\b(?:And|Not|Or)\b/i,
+        punctuation: /[.,:;()\[\]]/
+      };
+    }
+  }
+});
+
+export {
+  require_monkey
+};

package/dist/chunk-4ZSHUF27.js

@@ -0,0 +1,139 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/swift.js
+var require_swift = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/swift.js"(exports, module) {
+    module.exports = swift;
+    swift.displayName = "swift";
+    swift.aliases = [];
+    function swift(Prism) {
+      Prism.languages.swift = {
+        comment: {
+          // Nested comments are supported up to 2 levels
+          pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+          lookbehind: true,
+          greedy: true
+        },
+        "string-literal": [
+          // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+          {
+            pattern: RegExp(
+              /(^|[^"#])/.source + "(?:" + // single-line string
+              /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + // multi-line string
+              /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+                lookbehind: true,
+                inside: null
+                // see below
+              },
+              "interpolation-punctuation": {
+                pattern: /^\)|\\\($/,
+                alias: "punctuation"
+              },
+              punctuation: /\\(?=[\r\n])/,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: RegExp(
+              /(^|[^"#])(#+)/.source + "(?:" + // single-line string
+              /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + // multi-line string
+              /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+                lookbehind: true,
+                inside: null
+                // see below
+              },
+              "interpolation-punctuation": {
+                pattern: /^\)|\\#+\($/,
+                alias: "punctuation"
+              },
+              string: /[\s\S]+/
+            }
+          }
+        ],
+        directive: {
+          // directives with conditions
+          pattern: RegExp(
+            /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + // This regex is a little complex. It's equivalent to this:
+            //   (?:![ \t]*)?(?:\b\w+\b(?:[ \t]*<round>)?|<round>)(?:[ \t]*(?:&&|\|\|))?
+            // where <round> is a general parentheses expression.
+            /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
+          ),
+          alias: "property",
+          inside: {
+            "directive-name": /^#\w+/,
+            boolean: /\b(?:false|true)\b/,
+            number: /\b\d+(?:\.\d+)*\b/,
+            operator: /!|&&|\|\||[<>]=?/,
+            punctuation: /[(),]/
+          }
+        },
+        literal: {
+          pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+          alias: "constant"
+        },
+        "other-directive": {
+          pattern: /#\w+\b/,
+          alias: "property"
+        },
+        attribute: {
+          pattern: /@\w+/,
+          alias: "atrule"
+        },
+        "function-definition": {
+          pattern: /(\bfunc\s+)\w+/,
+          lookbehind: true,
+          alias: "function"
+        },
+        label: {
+          // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+          pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+          lookbehind: true,
+          alias: "important"
+        },
+        keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+        boolean: /\b(?:false|true)\b/,
+        nil: {
+          pattern: /\bnil\b/,
+          alias: "constant"
+        },
+        "short-argument": /\$\d+\b/,
+        omit: {
+          pattern: /\b_\b/,
+          alias: "keyword"
+        },
+        number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+        // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+        "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+        // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+        // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+        // This regex only supports ASCII operators.
+        operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+        punctuation: /[{}[\]();,.:\\]/
+      };
+      Prism.languages.swift["string-literal"].forEach(function(rule) {
+        rule.inside["interpolation"].inside = Prism.languages.swift;
+      });
+    }
+  }
+});
+
+export {
+  require_swift
+};

package/dist/chunk-53MOB7QD.js

@@ -0,0 +1,111 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/java.js
+var require_java = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/java.js"(exports, module) {
+    module.exports = java;
+    java.displayName = "java";
+    java.aliases = [];
+    function java(Prism) {
+      ;
+      (function(Prism2) {
+        var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
+        var classNamePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+        var className = {
+          pattern: RegExp(classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+          lookbehind: true,
+          inside: {
+            namespace: {
+              pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            punctuation: /\./
+          }
+        };
+        Prism2.languages.java = Prism2.languages.extend("clike", {
+          string: {
+            pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+            lookbehind: true,
+            greedy: true
+          },
+          "class-name": [
+            className,
+            {
+              // variables and parameters
+              // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+              pattern: RegExp(
+                classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+              ),
+              lookbehind: true,
+              inside: className.inside
+            }
+          ],
+          keyword: keywords,
+          function: [
+            Prism2.languages.clike.function,
+            {
+              pattern: /(::\s*)[a-z_]\w*/,
+              lookbehind: true
+            }
+          ],
+          number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+          operator: {
+            pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+            lookbehind: true
+          }
+        });
+        Prism2.languages.insertBefore("java", "string", {
+          "triple-quoted-string": {
+            // http://openjdk.java.net/jeps/355#Description
+            pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+            greedy: true,
+            alias: "string"
+          },
+          char: {
+            pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+            greedy: true
+          }
+        });
+        Prism2.languages.insertBefore("java", "class-name", {
+          annotation: {
+            pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          generics: {
+            pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+            inside: {
+              "class-name": className,
+              keyword: keywords,
+              punctuation: /[<>(),.:]/,
+              operator: /[?&|]/
+            }
+          },
+          namespace: {
+            pattern: RegExp(
+              /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(
+                /<keyword>/g,
+                function() {
+                  return keywords.source;
+                }
+              )
+            ),
+            lookbehind: true,
+            inside: {
+              punctuation: /\./
+            }
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_java
+};

package/dist/chunk-53TH3G7L.js

@@ -0,0 +1,187 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/avisynth.js
+var require_avisynth = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/avisynth.js"(exports, module) {
+    module.exports = avisynth;
+    avisynth.displayName = "avisynth";
+    avisynth.aliases = ["avs"];
+    function avisynth(Prism) {
+      ;
+      (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 || "");
+        }
+        var types = /bool|clip|float|int|string|val/.source;
+        var internals = [
+          // bools
+          /is(?:bool|clip|float|int|string)|defined|(?:(?:internal)?function|var)?exists?/.source,
+          // control
+          /apply|assert|default|eval|import|nop|select|undefined/.source,
+          // global
+          /opt_(?:allowfloataudio|avipadscanlines|dwchannelmask|enable_(?:b64a|planartopackedrgb|v210|y3_10_10|y3_10_16)|usewaveextensible|vdubplanarhack)|set(?:cachemode|maxcpu|memorymax|planarlegacyalignment|workingdir)/.source,
+          // conv
+          /hex(?:value)?|value/.source,
+          // numeric
+          /abs|ceil|continued(?:denominator|numerator)?|exp|floor|fmod|frac|log(?:10)?|max|min|muldiv|pi|pow|rand|round|sign|spline|sqrt/.source,
+          // trig
+          /a?sinh?|a?cosh?|a?tan[2h]?/.source,
+          // bit
+          /(?:bit(?:and|not|x?or|[lr]?shift[aslu]?|sh[lr]|sa[lr]|[lr]rotatel?|ro[rl]|te?st|set(?:count)?|cl(?:ea)?r|ch(?:an)?ge?))/.source,
+          // runtime
+          /average(?:[bgr]|chroma[uv]|luma)|(?:[rgb]|chroma[uv]|luma|rgb|[yuv](?=difference(?:fromprevious|tonext)))difference(?:fromprevious|tonext)?|[yuvrgb]plane(?:median|min|max|minmaxdifference)/.source,
+          // script
+          /getprocessinfo|logmsg|script(?:dir(?:utf8)?|file(?:utf8)?|name(?:utf8)?)|setlogparams/.source,
+          // string
+          /chr|(?:fill|find|left|mid|replace|rev|right)str|format|[lu]case|ord|str(?:cmpi?|fromutf8|len|toutf8)|time|trim(?:all|left|right)/.source,
+          // version
+          /isversionorgreater|version(?:number|string)/.source,
+          // helper
+          /buildpixeltype|colorspacenametopixeltype/.source,
+          // avsplus
+          /addautoloaddir|on(?:cpu|cuda)|prefetch|setfiltermtmode/.source
+        ].join("|");
+        var properties = [
+          // content
+          /has(?:audio|video)/.source,
+          // resolution
+          /height|width/.source,
+          // framerate
+          /frame(?:count|rate)|framerate(?:denominator|numerator)/.source,
+          // interlacing
+          /getparity|is(?:field|frame)based/.source,
+          // color format
+          /bitspercomponent|componentsize|hasalpha|is(?:planar(?:rgba?)?|interleaved|rgb(?:24|32|48|64)?|y(?:8|u(?:va?|y2))?|yv(?:12|16|24|411)|420|422|444|packedrgb)|numcomponents|pixeltype/.source,
+          // audio
+          /audio(?:bits|channels|duration|length(?:[fs]|hi|lo)?|rate)|isaudio(?:float|int)/.source
+        ].join("|");
+        var filters = [
+          // source
+          /avi(?:file)?source|directshowsource|image(?:reader|source|sourceanim)|opendmlsource|segmented(?:avisource|directshowsource)|wavsource/.source,
+          // color
+          /coloryuv|convertbacktoyuy2|convertto(?:RGB(?:24|32|48|64)|(?:planar)?RGBA?|Y8?|YV(?:12|16|24|411)|YUVA?(?:411|420|422|444)|YUY2)|fixluminance|gr[ae]yscale|invert|levels|limiter|mergea?rgb|merge(?:chroma|luma)|rgbadjust|show(?:alpha|blue|green|red)|swapuv|tweak|[uv]toy8?|ytouv/.source,
+          // overlay
+          /(?:colorkey|reset)mask|layer|mask(?:hs)?|merge|overlay|subtract/.source,
+          // geometry
+          /addborders|(?:bicubic|bilinear|blackman|gauss|lanczos4|lanczos|point|sinc|spline(?:16|36|64))resize|crop(?:bottom)?|flip(?:horizontal|vertical)|(?:horizontal|vertical)?reduceby2|letterbox|skewrows|turn(?:180|left|right)/.source,
+          // pixel
+          /blur|fixbrokenchromaupsampling|generalconvolution|(?:spatial|temporal)soften|sharpen/.source,
+          // timeline
+          /trim|(?:un)?alignedsplice|(?:assume|assumescaled|change|convert)FPS|(?:delete|duplicate)frame|dissolve|fade(?:in|io|out)[02]?|freezeframe|interleave|loop|reverse|select(?:even|odd|(?:range)?every)/.source,
+          // interlace
+          /assume[bt]ff|assume(?:field|frame)based|bob|complementparity|doubleweave|peculiarblend|pulldown|separate(?:columns|fields|rows)|swapfields|weave(?:columns|rows)?/.source,
+          // audio
+          /amplify(?:db)?|assumesamplerate|audiodub(?:ex)?|audiotrim|convertaudioto(?:(?:8|16|24|32)bit|float)|converttomono|delayaudio|ensurevbrmp3sync|get(?:left|right)?channel|kill(?:audio|video)|mergechannels|mixaudio|monotostereo|normalize|resampleaudio|ssrc|supereq|timestretch/.source,
+          // conditional
+          /animate|applyrange|conditional(?:filter|reader|select)|frameevaluate|scriptclip|tcp(?:server|source)|writefile(?:end|if|start)?/.source,
+          // export
+          /imagewriter/.source,
+          // debug
+          /blackness|blankclip|colorbars(?:hd)?|compare|dumpfiltergraph|echo|histogram|info|messageclip|preroll|setgraphanalysis|show(?:framenumber|smpte|time)|showfiveversions|stack(?:horizontal|vertical)|subtitle|tone|version/.source
+        ].join("|");
+        var allinternals = [internals, properties, filters].join("|");
+        Prism2.languages.avisynth = {
+          comment: [
+            {
+              // Matches [* *] nestable block comments, but only supports 1 level of nested comments
+              // /\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|<self>)*\*\]/
+              pattern: /(^|[^\\])\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|\[\*(?:[^\[*]|\[(?!\*)|\*(?!\]))*\*\])*\*\]/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // Matches /* */ block comments
+              pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // Matches # comments
+              pattern: /(^|[^\\$])#.*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          // Handle before strings because optional arguments are surrounded by double quotes
+          argument: {
+            pattern: re(/\b(?:<<0>>)\s+("?)\w+\1/.source, [types], "i"),
+            inside: {
+              keyword: /^\w+/
+            }
+          },
+          // Optional argument assignment
+          "argument-label": {
+            pattern: /([,(][\s\\]*)\w+\s*=(?!=)/,
+            lookbehind: true,
+            inside: {
+              "argument-name": {
+                pattern: /^\w+/,
+                alias: "punctuation"
+              },
+              punctuation: /=$/
+            }
+          },
+          string: [
+            {
+              // triple double-quoted
+              pattern: /"""[\s\S]*?"""/,
+              greedy: true
+            },
+            {
+              // single double-quoted
+              pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+              greedy: true,
+              inside: {
+                constant: {
+                  // These *are* case-sensitive!
+                  pattern: /\b(?:DEFAULT_MT_MODE|(?:MAINSCRIPT|PROGRAM|SCRIPT)DIR|(?:MACHINE|USER)_(?:CLASSIC|PLUS)_PLUGINS)\b/
+                }
+              }
+            }
+          ],
+          // The special "last" variable that takes the value of the last implicitly returned clip
+          variable: /\b(?:last)\b/i,
+          boolean: /\b(?:false|no|true|yes)\b/i,
+          keyword: /\b(?:catch|else|for|function|global|if|return|try|while|__END__)\b/i,
+          constant: /\bMT_(?:MULTI_INSTANCE|NICE_FILTER|SERIALIZED|SPECIAL_MT)\b/,
+          // AviSynth's internal functions, filters, and properties
+          "builtin-function": {
+            pattern: re(/\b(?:<<0>>)\b/.source, [allinternals], "i"),
+            alias: "function"
+          },
+          "type-cast": {
+            pattern: re(/\b(?:<<0>>)(?=\s*\()/.source, [types], "i"),
+            alias: "keyword"
+          },
+          // External/user-defined filters
+          function: {
+            pattern: /\b[a-z_]\w*(?=\s*\()|(\.)[a-z_]\w*\b/i,
+            lookbehind: true
+          },
+          // Matches a \ as the first or last character on a line
+          "line-continuation": {
+            pattern: /(^[ \t]*)\\|\\(?=[ \t]*$)/m,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          number: /\B\$(?:[\da-f]{6}|[\da-f]{8})\b|(?:(?:\b|\B-)\d+(?:\.\d*)?\b|\B\.\d+\b)/i,
+          operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
+          punctuation: /[{}\[\]();,.]/
+        };
+        Prism2.languages.avs = Prism2.languages.avisynth;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_avisynth
+};

package/dist/chunk-55TJCXPI.js

@@ -0,0 +1,34 @@
+"use client";
+import {
+  require_c
+} from "./chunk-RSMTA6GK.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/objectivec.js
+var require_objectivec = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/objectivec.js"(exports, module) {
+    var refractorC = require_c();
+    module.exports = objectivec;
+    objectivec.displayName = "objectivec";
+    objectivec.aliases = ["objc"];
+    function objectivec(Prism) {
+      Prism.register(refractorC);
+      Prism.languages.objectivec = Prism.languages.extend("c", {
+        string: {
+          pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
+        operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
+      });
+      delete Prism.languages.objectivec["class-name"];
+      Prism.languages.objc = Prism.languages.objectivec;
+    }
+  }
+});
+
+export {
+  require_objectivec
+};

package/dist/chunk-5BE7MV5Y.js

@@ -0,0 +1,62 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/squirrel.js
+var require_squirrel = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/squirrel.js"(exports, module) {
+    module.exports = squirrel;
+    squirrel.displayName = "squirrel";
+    squirrel.aliases = [];
+    function squirrel(Prism) {
+      Prism.languages.squirrel = Prism.languages.extend("clike", {
+        comment: [
+          Prism.languages.clike["comment"][0],
+          {
+            pattern: /(^|[^\\:])(?:\/\/|#).*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /(^|[^\\"'@])(?:@"(?:[^"]|"")*"(?!")|"(?:[^\\\r\n"]|\\.)*")/,
+          lookbehind: true,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:class|enum|extends|instanceof)\s+)\w+(?:\.\w+)*/,
+          lookbehind: true,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        keyword: /\b(?:__FILE__|__LINE__|base|break|case|catch|class|clone|const|constructor|continue|default|delete|else|enum|extends|for|foreach|function|if|in|instanceof|local|null|resume|return|static|switch|this|throw|try|typeof|while|yield)\b/,
+        number: /\b(?:0x[0-9a-fA-F]+|\d+(?:\.(?:\d+|[eE][+-]?\d+))?)\b/,
+        operator: /\+\+|--|<=>|<[-<]|>>>?|&&?|\|\|?|[-+*/%!=<>]=?|[~^]|::?/,
+        punctuation: /[(){}\[\],;.]/
+      });
+      Prism.languages.insertBefore("squirrel", "string", {
+        char: {
+          pattern: /(^|[^\\"'])'(?:[^\\']|\\(?:[xuU][0-9a-fA-F]{0,8}|[\s\S]))'/,
+          lookbehind: true,
+          greedy: true
+        }
+      });
+      Prism.languages.insertBefore("squirrel", "operator", {
+        "attribute-punctuation": {
+          pattern: /<\/|\/>/,
+          alias: "important"
+        },
+        lambda: {
+          pattern: /@(?=\()/,
+          alias: "operator"
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_squirrel
+};

package/dist/chunk-5MBEKVFI.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cypher.js
+var require_cypher = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/cypher.js"(exports, module) {
+    module.exports = cypher;
+    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 {
+  require_cypher
+};