@distri/react 0.3.1 → 0.3.2

package/dist/chunk-DHUOF54O.js

@@ -0,0 +1,168 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/naniscript.js
+var require_naniscript = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/naniscript.js"(exports, module) {
+    module.exports = naniscript;
+    naniscript.displayName = "naniscript";
+    naniscript.aliases = [];
+    function naniscript(Prism) {
+      ;
+      (function(Prism2) {
+        var expressionDef = /\{[^\r\n\[\]{}]*\}/;
+        var params = {
+          "quoted-string": {
+            pattern: /"(?:[^"\\]|\\.)*"/,
+            alias: "operator"
+          },
+          "command-param-id": {
+            pattern: /(\s)\w+:/,
+            lookbehind: true,
+            alias: "property"
+          },
+          "command-param-value": [
+            {
+              pattern: expressionDef,
+              alias: "selector"
+            },
+            {
+              pattern: /([\t ])\S+/,
+              lookbehind: true,
+              greedy: true,
+              alias: "operator"
+            },
+            {
+              pattern: /\S(?:.*\S)?/,
+              alias: "operator"
+            }
+          ]
+        };
+        Prism2.languages.naniscript = {
+          // ; ...
+          comment: {
+            pattern: /^([\t ]*);.*/m,
+            lookbehind: true
+          },
+          // > ...
+          // Define is a control line starting with '>' followed by a word, a space and a text.
+          define: {
+            pattern: /^>.+/m,
+            alias: "tag",
+            inside: {
+              value: {
+                pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
+                lookbehind: true,
+                alias: "operator"
+              },
+              key: {
+                pattern: /(^>)\w+/,
+                lookbehind: true
+              }
+            }
+          },
+          // # ...
+          label: {
+            pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
+            lookbehind: true,
+            alias: "regex"
+          },
+          command: {
+            pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
+            lookbehind: true,
+            alias: "function",
+            inside: {
+              "command-name": /^@\w+/,
+              expression: {
+                pattern: expressionDef,
+                greedy: true,
+                alias: "selector"
+              },
+              "command-params": {
+                pattern: /\s*\S[\s\S]*/,
+                inside: params
+              }
+            }
+          },
+          // Generic is any line that doesn't start with operators: ;>#@
+          "generic-text": {
+            pattern: /(^[ \t]*)[^#@>;\s].*/m,
+            lookbehind: true,
+            alias: "punctuation",
+            inside: {
+              // \{ ... \} ... \[ ... \] ... \"
+              "escaped-char": /\\[{}\[\]"]/,
+              expression: {
+                pattern: expressionDef,
+                greedy: true,
+                alias: "selector"
+              },
+              "inline-command": {
+                pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
+                greedy: true,
+                alias: "function",
+                inside: {
+                  "command-params": {
+                    pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
+                    lookbehind: true,
+                    inside: params
+                  },
+                  "command-param-name": {
+                    pattern: /^(\[[\t ]*)\w+/,
+                    lookbehind: true,
+                    alias: "name"
+                  },
+                  "start-stop-char": /[\[\]]/
+                }
+              }
+            }
+          }
+        };
+        Prism2.languages.nani = Prism2.languages["naniscript"];
+        Prism2.hooks.add("after-tokenize", function(env) {
+          var tokens = env.tokens;
+          tokens.forEach(function(token) {
+            if (typeof token !== "string" && token.type === "generic-text") {
+              var content = getTextContent(token);
+              if (!isBracketsBalanced(content)) {
+                token.type = "bad-line";
+                token.content = content;
+              }
+            }
+          });
+        });
+        function isBracketsBalanced(input) {
+          var brackets = "[]{}";
+          var stack = [];
+          for (var i = 0; i < input.length; i++) {
+            var bracket = input[i];
+            var bracketsIndex = brackets.indexOf(bracket);
+            if (bracketsIndex !== -1) {
+              if (bracketsIndex % 2 === 0) {
+                stack.push(bracketsIndex + 1);
+              } else if (stack.pop() !== bracketsIndex) {
+                return false;
+              }
+            }
+          }
+          return stack.length === 0;
+        }
+        function getTextContent(token) {
+          if (typeof token === "string") {
+            return token;
+          } else if (Array.isArray(token)) {
+            return token.map(getTextContent).join("");
+          } else {
+            return getTextContent(token.content);
+          }
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_naniscript
+};

package/dist/chunk-DIPKDKOW.js

@@ -0,0 +1,52 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sql.js
+var require_sql = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sql.js"(exports, module) {
+    module.exports = sql;
+    sql.displayName = "sql";
+    sql.aliases = [];
+    function sql(Prism) {
+      Prism.languages.sql = {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+          lookbehind: true
+        },
+        variable: [
+          {
+            pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+            greedy: true
+          },
+          /@[\w.$]+/
+        ],
+        string: {
+          pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+          greedy: true,
+          lookbehind: true
+        },
+        identifier: {
+          pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+          greedy: true,
+          lookbehind: true,
+          inside: {
+            punctuation: /^`|`$/
+          }
+        },
+        function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+        // Should we highlight user defined functions too?
+        keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+        boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+        number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+        operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+        punctuation: /[;[\]()`,.]/
+      };
+    }
+  }
+});
+
+export {
+  require_sql
+};

package/dist/chunk-DKZMCKWJ.js

@@ -0,0 +1,112 @@
+"use client";
+import {
+  require_typescript
+} from "./chunk-33ATF6VZ.js";
+import {
+  require_javadoclike
+} from "./chunk-DRPQ5HML.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsdoc.js
+var require_jsdoc = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsdoc.js"(exports, module) {
+    var refractorJavadoclike = require_javadoclike();
+    var refractorTypescript = require_typescript();
+    module.exports = jsdoc;
+    jsdoc.displayName = "jsdoc";
+    jsdoc.aliases = [];
+    function jsdoc(Prism) {
+      Prism.register(refractorJavadoclike);
+      Prism.register(refractorTypescript);
+      (function(Prism2) {
+        var javascript = 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: javascript,
+                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: javascript.string,
+                number: javascript.number,
+                boolean: javascript.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: javascript,
+                alias: "language-javascript"
+              }
+            }
+          }
+        });
+        Prism2.languages.javadoclike.addSupport("javascript", Prism2.languages.jsdoc);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_jsdoc
+};

package/dist/chunk-DM4V5JFL.js

@@ -0,0 +1,146 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsx.js
+var require_jsx = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jsx.js"(exports, module) {
+    module.exports = jsx;
+    jsx.displayName = "jsx";
+    jsx.aliases = [];
+    function jsx(Prism) {
+      ;
+      (function(Prism2) {
+        var javascript = Prism2.util.clone(Prism2.languages.javascript);
+        var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+        var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+        var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+        function re(source, flags) {
+          source = source.replace(/<S>/g, function() {
+            return space;
+          }).replace(/<BRACES>/g, function() {
+            return braces;
+          }).replace(/<SPREAD>/g, function() {
+            return spread;
+          });
+          return RegExp(source, flags);
+        }
+        spread = re(spread).source;
+        Prism2.languages.jsx = Prism2.languages.extend("markup", javascript);
+        Prism2.languages.jsx.tag.pattern = re(
+          /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+        );
+        Prism2.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
+        Prism2.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+        Prism2.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+        Prism2.languages.jsx.tag.inside["comment"] = javascript["comment"];
+        Prism2.languages.insertBefore(
+          "inside",
+          "attr-name",
+          {
+            spread: {
+              pattern: re(/<SPREAD>/.source),
+              inside: Prism2.languages.jsx
+            }
+          },
+          Prism2.languages.jsx.tag
+        );
+        Prism2.languages.insertBefore(
+          "inside",
+          "special-attr",
+          {
+            script: {
+              // Allow for two levels of nesting
+              pattern: re(/=<BRACES>/.source),
+              alias: "language-javascript",
+              inside: {
+                "script-punctuation": {
+                  pattern: /^=(?=\{)/,
+                  alias: "punctuation"
+                },
+                rest: Prism2.languages.jsx
+              }
+            }
+          },
+          Prism2.languages.jsx.tag
+        );
+        var stringifyToken = function(token) {
+          if (!token) {
+            return "";
+          }
+          if (typeof token === "string") {
+            return token;
+          }
+          if (typeof token.content === "string") {
+            return token.content;
+          }
+          return token.content.map(stringifyToken).join("");
+        };
+        var walkTokens = function(tokens) {
+          var openedTags = [];
+          for (var i = 0; i < tokens.length; i++) {
+            var token = tokens[i];
+            var notTagNorBrace = false;
+            if (typeof token !== "string") {
+              if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+                if (token.content[0].content[0].content === "</") {
+                  if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+                    openedTags.pop();
+                  }
+                } else {
+                  if (token.content[token.content.length - 1].content === "/>") {
+                  } else {
+                    openedTags.push({
+                      tagName: stringifyToken(token.content[0].content[1]),
+                      openedBraces: 0
+                    });
+                  }
+                }
+              } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") {
+                openedTags[openedTags.length - 1].openedBraces++;
+              } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+                openedTags[openedTags.length - 1].openedBraces--;
+              } else {
+                notTagNorBrace = true;
+              }
+            }
+            if (notTagNorBrace || typeof token === "string") {
+              if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+                var plainText = stringifyToken(token);
+                if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+                  plainText += stringifyToken(tokens[i + 1]);
+                  tokens.splice(i + 1, 1);
+                }
+                if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+                  plainText = stringifyToken(tokens[i - 1]) + plainText;
+                  tokens.splice(i - 1, 1);
+                  i--;
+                }
+                tokens[i] = new Prism2.Token(
+                  "plain-text",
+                  plainText,
+                  null,
+                  plainText
+                );
+              }
+            }
+            if (token.content && typeof token.content !== "string") {
+              walkTokens(token.content);
+            }
+          }
+        };
+        Prism2.hooks.add("after-tokenize", function(env) {
+          if (env.language !== "jsx" && env.language !== "tsx") {
+            return;
+          }
+          walkTokens(env.tokens);
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_jsx
+};

package/dist/chunk-DRPQ5HML.js

@@ -0,0 +1,87 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javadoclike.js
+var require_javadoclike = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/javadoclike.js"(exports, module) {
+    module.exports = javadoclike;
+    javadoclike.displayName = "javadoclike";
+    javadoclike.aliases = [];
+    function javadoclike(Prism) {
+      ;
+      (function(Prism2) {
+        var javaDocLike = Prism2.languages.javadoclike = {
+          parameter: {
+            pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
+            lookbehind: true
+          },
+          keyword: {
+            // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.
+            // @word, {@word}
+            pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
+            lookbehind: true
+          },
+          punctuation: /[{}]/
+        };
+        function docCommentSupport(lang, callback) {
+          var tokenName = "doc-comment";
+          var grammar = Prism2.languages[lang];
+          if (!grammar) {
+            return;
+          }
+          var token = grammar[tokenName];
+          if (!token) {
+            var definition = {};
+            definition[tokenName] = {
+              pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+              lookbehind: true,
+              alias: "comment"
+            };
+            grammar = Prism2.languages.insertBefore(lang, "comment", definition);
+            token = grammar[tokenName];
+          }
+          if (token instanceof RegExp) {
+            token = grammar[tokenName] = {
+              pattern: token
+            };
+          }
+          if (Array.isArray(token)) {
+            for (var i = 0, l = token.length; i < l; i++) {
+              if (token[i] instanceof RegExp) {
+                token[i] = {
+                  pattern: token[i]
+                };
+              }
+              callback(token[i]);
+            }
+          } else {
+            callback(token);
+          }
+        }
+        function addSupport(languages, docLanguage) {
+          if (typeof languages === "string") {
+            languages = [languages];
+          }
+          languages.forEach(function(lang) {
+            docCommentSupport(lang, function(pattern) {
+              if (!pattern.inside) {
+                pattern.inside = {};
+              }
+              pattern.inside.rest = docLanguage;
+            });
+          });
+        }
+        Object.defineProperty(javaDocLike, "addSupport", {
+          value: addSupport
+        });
+        javaDocLike.addSupport(["java", "javascript", "php"], javaDocLike);
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_javadoclike
+};

package/dist/chunk-DVS47EX7.js

@@ -0,0 +1,71 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/powerquery.js
+var require_powerquery = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/powerquery.js"(exports, module) {
+    module.exports = powerquery;
+    powerquery.displayName = "powerquery";
+    powerquery.aliases = [];
+    function powerquery(Prism) {
+      Prism.languages.powerquery = {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+          lookbehind: true,
+          greedy: true
+        },
+        "quoted-identifier": {
+          pattern: /#"(?:[^"\r\n]|"")*"(?!")/,
+          greedy: true
+        },
+        string: {
+          pattern: /(?:#!)?"(?:[^"\r\n]|"")*"(?!")/,
+          greedy: true
+        },
+        constant: [
+          /\bDay\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\b/,
+          /\bTraceLevel\.(?:Critical|Error|Information|Verbose|Warning)\b/,
+          /\bOccurrence\.(?:All|First|Last)\b/,
+          /\bOrder\.(?:Ascending|Descending)\b/,
+          /\bRoundingMode\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\b/,
+          /\bMissingField\.(?:Error|Ignore|UseNull)\b/,
+          /\bQuoteStyle\.(?:Csv|None)\b/,
+          /\bJoinKind\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\b/,
+          /\bGroupKind\.(?:Global|Local)\b/,
+          /\bExtraValues\.(?:Error|Ignore|List)\b/,
+          /\bJoinAlgorithm\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\b/,
+          /\bJoinSide\.(?:Left|Right)\b/,
+          /\bPrecision\.(?:Decimal|Double)\b/,
+          /\bRelativePosition\.From(?:End|Start)\b/,
+          /\bTextEncoding\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\b/,
+          /\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\.Type\b/,
+          /\bnull\b/
+        ],
+        boolean: /\b(?:false|true)\b/,
+        keyword: /\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\b/,
+        function: {
+          pattern: /(^|[^#\w.])[a-z_][\w.]*(?=\s*\()/i,
+          lookbehind: true
+        },
+        "data-type": {
+          pattern: /\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\b/,
+          alias: "class-name"
+        },
+        number: {
+          pattern: /\b0x[\da-f]+\b|(?:[+-]?(?:\b\d+\.)?\b\d+|[+-]\.\d+|(^|[^.])\B\.\d+)(?:e[+-]?\d+)?\b/i,
+          lookbehind: true
+        },
+        operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
+        punctuation: /[,;\[\](){}]/
+      };
+      Prism.languages.pq = Prism.languages["powerquery"];
+      Prism.languages.mscript = Prism.languages["powerquery"];
+    }
+  }
+});
+
+export {
+  require_powerquery
+};