@distri/react 0.2.7 → 0.3.0

package/dist/chunk-XY6WLMUK.js

@@ -0,0 +1,382 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/markdown.js
+var require_markdown = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/markdown.js"(exports, module) {
+    module.exports = markdown;
+    markdown.displayName = "markdown";
+    markdown.aliases = ["md"];
+    function markdown(Prism) {
+      ;
+      (function(Prism2) {
+        var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+        function createInline(pattern) {
+          pattern = pattern.replace(/<inner>/g, function() {
+            return inner;
+          });
+          return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
+        }
+        var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
+        var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
+          /__/g,
+          function() {
+            return tableCell;
+          }
+        );
+        var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+        Prism2.languages.markdown = Prism2.languages.extend("markup", {});
+        Prism2.languages.insertBefore("markdown", "prolog", {
+          "front-matter-block": {
+            pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              punctuation: /^---|---$/,
+              "front-matter": {
+                pattern: /\S+(?:\s+\S+)*/,
+                alias: ["yaml", "language-yaml"],
+                inside: Prism2.languages.yaml
+              }
+            }
+          },
+          blockquote: {
+            // > ...
+            pattern: /^>(?:[\t ]*>)*/m,
+            alias: "punctuation"
+          },
+          table: {
+            pattern: RegExp(
+              "^" + tableRow + tableLine + "(?:" + tableRow + ")*",
+              "m"
+            ),
+            inside: {
+              "table-data-rows": {
+                pattern: RegExp(
+                  "^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"
+                ),
+                lookbehind: true,
+                inside: {
+                  "table-data": {
+                    pattern: RegExp(tableCell),
+                    inside: Prism2.languages.markdown
+                  },
+                  punctuation: /\|/
+                }
+              },
+              "table-line": {
+                pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
+                lookbehind: true,
+                inside: {
+                  punctuation: /\||:?-{3,}:?/
+                }
+              },
+              "table-header-row": {
+                pattern: RegExp("^" + tableRow + "$"),
+                inside: {
+                  "table-header": {
+                    pattern: RegExp(tableCell),
+                    alias: "important",
+                    inside: Prism2.languages.markdown
+                  },
+                  punctuation: /\|/
+                }
+              }
+            }
+          },
+          code: [
+            {
+              // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+              pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+              lookbehind: true,
+              alias: "keyword"
+            },
+            {
+              // ```optional language
+              // code block
+              // ```
+              pattern: /^```[\s\S]*?^```$/m,
+              greedy: true,
+              inside: {
+                "code-block": {
+                  pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+                  lookbehind: true
+                },
+                "code-language": {
+                  pattern: /^(```).+/,
+                  lookbehind: true
+                },
+                punctuation: /```/
+              }
+            }
+          ],
+          title: [
+            {
+              // title 1
+              // =======
+              // title 2
+              // -------
+              pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+              alias: "important",
+              inside: {
+                punctuation: /==+$|--+$/
+              }
+            },
+            {
+              // # title 1
+              // ###### title 6
+              pattern: /(^\s*)#.+/m,
+              lookbehind: true,
+              alias: "important",
+              inside: {
+                punctuation: /^#+|#+$/
+              }
+            }
+          ],
+          hr: {
+            // ***
+            // ---
+            // * * *
+            // -----------
+            pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          list: {
+            // * item
+            // + item
+            // - item
+            // 1. item
+            pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+            lookbehind: true,
+            alias: "punctuation"
+          },
+          "url-reference": {
+            // [id]: http://example.com "Optional title"
+            // [id]: http://example.com 'Optional title'
+            // [id]: http://example.com (Optional title)
+            // [id]: <http://example.com> "Optional title"
+            pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+            inside: {
+              variable: {
+                pattern: /^(!?\[)[^\]]+/,
+                lookbehind: true
+              },
+              string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+              punctuation: /^[\[\]!:]|[<>]/
+            },
+            alias: "url"
+          },
+          bold: {
+            // **strong**
+            // __strong__
+            // allow one nested instance of italic text using the same delimiter
+            pattern: createInline(
+              /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              content: {
+                pattern: /(^..)[\s\S]+(?=..$)/,
+                lookbehind: true,
+                inside: {}
+                // see below
+              },
+              punctuation: /\*\*|__/
+            }
+          },
+          italic: {
+            // *em*
+            // _em_
+            // allow one nested instance of bold text using the same delimiter
+            pattern: createInline(
+              /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              content: {
+                pattern: /(^.)[\s\S]+(?=.$)/,
+                lookbehind: true,
+                inside: {}
+                // see below
+              },
+              punctuation: /[*_]/
+            }
+          },
+          strike: {
+            // ~~strike through~~
+            // ~strike~
+            // eslint-disable-next-line regexp/strict
+            pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              content: {
+                pattern: /(^~~?)[\s\S]+(?=\1$)/,
+                lookbehind: true,
+                inside: {}
+                // see below
+              },
+              punctuation: /~~?/
+            }
+          },
+          "code-snippet": {
+            // `code`
+            // ``code``
+            pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+            lookbehind: true,
+            greedy: true,
+            alias: ["code", "keyword"]
+          },
+          url: {
+            // [example](http://example.com "Optional title")
+            // [example][id]
+            // [example] [id]
+            pattern: createInline(
+              /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              operator: /^!/,
+              content: {
+                pattern: /(^\[)[^\]]+(?=\])/,
+                lookbehind: true,
+                inside: {}
+                // see below
+              },
+              variable: {
+                pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+                lookbehind: true
+              },
+              url: {
+                pattern: /(^\]\()[^\s)]+/,
+                lookbehind: true
+              },
+              string: {
+                pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+                lookbehind: true
+              }
+            }
+          }
+        });
+        ["url", "bold", "italic", "strike"].forEach(function(token) {
+          ;
+          ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(inside) {
+            if (token !== inside) {
+              Prism2.languages.markdown[token].inside.content.inside[inside] = Prism2.languages.markdown[inside];
+            }
+          });
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          if (env.language !== "markdown" && env.language !== "md") {
+            return;
+          }
+          function walkTokens(tokens) {
+            if (!tokens || typeof tokens === "string") {
+              return;
+            }
+            for (var i = 0, l = tokens.length; i < l; i++) {
+              var token = tokens[i];
+              if (token.type !== "code") {
+                walkTokens(token.content);
+                continue;
+              }
+              var codeLang = token.content[1];
+              var codeBlock = token.content[3];
+              if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content === "string") {
+                var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+                lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
+                var alias = "language-" + lang;
+                if (!codeBlock.alias) {
+                  codeBlock.alias = [alias];
+                } else if (typeof codeBlock.alias === "string") {
+                  codeBlock.alias = [codeBlock.alias, alias];
+                } else {
+                  codeBlock.alias.push(alias);
+                }
+              }
+            }
+          }
+          walkTokens(env.tokens);
+        });
+        Prism2.hooks.add("wrap", function(env) {
+          if (env.type !== "code-block") {
+            return;
+          }
+          var codeLang = "";
+          for (var i = 0, l = env.classes.length; i < l; i++) {
+            var cls = env.classes[i];
+            var match = /language-(.+)/.exec(cls);
+            if (match) {
+              codeLang = match[1];
+              break;
+            }
+          }
+          var grammar = Prism2.languages[codeLang];
+          if (!grammar) {
+            if (codeLang && codeLang !== "none" && Prism2.plugins.autoloader) {
+              var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+              env.attributes["id"] = id;
+              Prism2.plugins.autoloader.loadLanguages(codeLang, function() {
+                var ele = document.getElementById(id);
+                if (ele) {
+                  ele.innerHTML = Prism2.highlight(
+                    ele.textContent,
+                    Prism2.languages[codeLang],
+                    codeLang
+                  );
+                }
+              });
+            }
+          } else {
+            env.content = Prism2.highlight(
+              textContent(env.content.value),
+              grammar,
+              codeLang
+            );
+          }
+        });
+        var tagPattern = RegExp(Prism2.languages.markup.tag.pattern.source, "gi");
+        var KNOWN_ENTITY_NAMES = {
+          amp: "&",
+          lt: "<",
+          gt: ">",
+          quot: '"'
+        };
+        var fromCodePoint = String.fromCodePoint || String.fromCharCode;
+        function textContent(html) {
+          var text = html.replace(tagPattern, "");
+          text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(m, code) {
+            code = code.toLowerCase();
+            if (code[0] === "#") {
+              var value;
+              if (code[1] === "x") {
+                value = parseInt(code.slice(2), 16);
+              } else {
+                value = Number(code.slice(1));
+              }
+              return fromCodePoint(value);
+            } else {
+              var known = KNOWN_ENTITY_NAMES[code];
+              if (known) {
+                return known;
+              }
+              return m;
+            }
+          });
+          return text;
+        }
+        Prism2.languages.md = Prism2.languages.markdown;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_markdown
+};

package/dist/chunk-XZLPFOLS.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-Y7ITLLSE.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/solution-file.js
+var require_solution_file = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/solution-file.js"(exports, module) {
+    module.exports = solutionFile;
+    solutionFile.displayName = "solutionFile";
+    solutionFile.aliases = [];
+    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 {
+  require_solution_file
+};

package/dist/chunk-Y7YE4V4F.js

@@ -0,0 +1,37 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xojo.js
+var require_xojo = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/xojo.js"(exports, module) {
+    module.exports = xojo;
+    xojo.displayName = "xojo";
+    xojo.aliases = [];
+    function xojo(Prism) {
+      Prism.languages.xojo = {
+        comment: {
+          pattern: /(?:'|\/\/|Rem\b).+/i,
+          greedy: true
+        },
+        string: {
+          pattern: /"(?:""|[^"])*"/,
+          greedy: true
+        },
+        number: [/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, /&[bchou][a-z\d]+/i],
+        directive: {
+          pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+          alias: "property"
+        },
+        keyword: /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+        operator: /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
+        punctuation: /[.,;:()]/
+      };
+    }
+  }
+});
+
+export {
+  require_xojo
+};

package/dist/chunk-YFWG72PF.js

@@ -0,0 +1,102 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gherkin.js
+var require_gherkin = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gherkin.js"(exports, module) {
+    module.exports = gherkin;
+    gherkin.displayName = "gherkin";
+    gherkin.aliases = [];
+    function gherkin(Prism) {
+      ;
+      (function(Prism2) {
+        var tableRow = /(?:\r?\n|\r)[ \t]*\|.+\|(?:(?!\|).)*/.source;
+        Prism2.languages.gherkin = {
+          pystring: {
+            pattern: /("""|''')[\s\S]+?\1/,
+            alias: "string"
+          },
+          comment: {
+            pattern: /(^[ \t]*)#.*/m,
+            lookbehind: true
+          },
+          tag: {
+            pattern: /(^[ \t]*)@\S*/m,
+            lookbehind: true
+          },
+          feature: {
+            pattern: /((?:^|\r?\n|\r)[ \t]*)(?:Ability|Ahoy matey!|Arwedd|Aspekt|Besigheid Behoefte|Business Need|Caracteristica|Característica|Egenskab|Egenskap|Eiginleiki|Feature|Fīča|Fitur|Fonctionnalité|Fonksyonalite|Funcionalidade|Funcionalitat|Functionalitate|Funcţionalitate|Funcționalitate|Functionaliteit|Fungsi|Funkcia|Funkcija|Funkcionalitāte|Funkcionalnost|Funkcja|Funksie|Funktionalität|Funktionalitéit|Funzionalità|Hwaet|Hwæt|Jellemző|Karakteristik|Lastnost|Mak|Mogucnost|laH|Mogućnost|Moznosti|Možnosti|OH HAI|Omadus|Ominaisuus|Osobina|Özellik|Potrzeba biznesowa|perbogh|poQbogh malja'|Požadavek|Požiadavka|Pretty much|Qap|Qu'meH 'ut|Savybė|Tính năng|Trajto|Vermoë|Vlastnosť|Właściwość|Značilnost|Δυνατότητα|Λειτουργία|Могућност|Мөмкинлек|Особина|Свойство|Үзенчәлеклелек|Функционал|Функционалност|Функция|Функціонал|תכונה|خاصية|خصوصیت|صلاحیت|کاروبار کی ضرورت|وِیژگی|रूप लेख|ਖਾਸੀਅਤ|ਨਕਸ਼ ਨੁਹਾਰ|ਮੁਹਾਂਦਰਾ|గుణము|ಹೆಚ್ಚಳ|ความต้องการทางธุรกิจ|ความสามารถ|โครงหลัก|기능|フィーチャ|功能|機能):(?:[^:\r\n]+(?:\r?\n|\r|$))*/,
+            lookbehind: true,
+            inside: {
+              important: {
+                pattern: /(:)[^\r\n]+/,
+                lookbehind: true
+              },
+              keyword: /[^:\r\n]+:/
+            }
+          },
+          scenario: {
+            pattern: /(^[ \t]*)(?:Abstract Scenario|Abstrakt Scenario|Achtergrond|Aer|Ær|Agtergrond|All y'all|Antecedentes|Antecedents|Atburðarás|Atburðarásir|Awww, look mate|B4|Background|Baggrund|Bakgrund|Bakgrunn|Bakgrunnur|Beispiele|Beispiller|Bối cảnh|Cefndir|Cenario|Cenário|Cenario de Fundo|Cenário de Fundo|Cenarios|Cenários|Contesto|Context|Contexte|Contexto|Conto|Contoh|Contone|Dæmi|Dasar|Dead men tell no tales|Delineacao do Cenario|Delineação do Cenário|Dis is what went down|Dữ liệu|Dyagram Senaryo|Dyagram senaryo|Egzanp|Ejemplos|Eksempler|Ekzemploj|Enghreifftiau|Esbozo do escenario|Escenari|Escenario|Esempi|Esquema de l'escenari|Esquema del escenario|Esquema do Cenario|Esquema do Cenário|EXAMPLZ|Examples|Exempel|Exemple|Exemples|Exemplos|First off|Fono|Forgatókönyv|Forgatókönyv vázlat|Fundo|Geçmiş|Grundlage|Hannergrond|ghantoH|Háttér|Heave to|Istorik|Juhtumid|Keadaan|Khung kịch bản|Khung tình huống|Kịch bản|Koncept|Konsep skenario|Kontèks|Kontekst|Kontekstas|Konteksts|Kontext|Konturo de la scenaro|Latar Belakang|lut chovnatlh|lut|lutmey|Lýsing Atburðarásar|Lýsing Dæma|MISHUN SRSLY|MISHUN|Menggariskan Senario|mo'|Náčrt Scenára|Náčrt Scénáře|Náčrt Scenáru|Oris scenarija|Örnekler|Osnova|Osnova Scenára|Osnova scénáře|Osnutek|Ozadje|Paraugs|Pavyzdžiai|Példák|Piemēri|Plan du scénario|Plan du Scénario|Plan Senaryo|Plan senaryo|Plang vum Szenario|Pozadí|Pozadie|Pozadina|Príklady|Příklady|Primer|Primeri|Primjeri|Przykłady|Raamstsenaarium|Reckon it's like|Rerefons|Scenár|Scénář|Scenarie|Scenarij|Scenarijai|Scenarijaus šablonas|Scenariji|Scenārijs|Scenārijs pēc parauga|Scenarijus|Scenario|Scénario|Scenario Amlinellol|Scenario Outline|Scenario Template|Scenariomal|Scenariomall|Scenarios|Scenariu|Scenariusz|Scenaro|Schema dello scenario|Se ðe|Se the|Se þe|Senario|Senaryo Deskripsyon|Senaryo deskripsyon|Senaryo|Senaryo taslağı|Shiver me timbers|Situācija|Situai|Situasie Uiteensetting|Situasie|Skenario konsep|Skenario|Skica|Structura scenariu|Structură scenariu|Struktura scenarija|Stsenaarium|Swa hwaer swa|Swa|Swa hwær swa|Szablon scenariusza|Szenario|Szenariogrundriss|Tapaukset|Tapaus|Tapausaihio|Taust|Tausta|Template Keadaan|Template Senario|Template Situai|The thing of it is|Tình huống|Variantai|Voorbeelde|Voorbeelden|Wharrimean is|Yo-ho-ho|You'll wanna|Założenia|Παραδείγματα|Περιγραφή Σεναρίου|Σενάρια|Σενάριο|Υπόβαθρο|Кереш|Контекст|Концепт|Мисаллар|Мисоллар|Основа|Передумова|Позадина|Предистория|Предыстория|Приклади|Пример|Примери|Примеры|Рамка на сценарий|Скица|Структура сценарија|Структура сценария|Структура сценарію|Сценарий|Сценарий структураси|Сценарийның төзелеше|Сценарији|Сценарио|Сценарій|Тарих|Үрнәкләр|דוגמאות|רקע|תבנית תרחיש|תרחיש|الخلفية|الگوی سناریو|امثلة|پس منظر|زمینه|سناریو|سيناريو|سيناريو مخطط|مثالیں|منظر نامے کا خاکہ|منظرنامہ|نمونه ها|उदाहरण|परिदृश्य|परिदृश्य रूपरेखा|पृष्ठभूमि|ਉਦਾਹਰਨਾਂ|ਪਟਕਥਾ|ਪਟਕਥਾ ਢਾਂਚਾ|ਪਟਕਥਾ ਰੂਪ ਰੇਖਾ|ਪਿਛੋਕੜ|ఉదాహరణలు|కథనం|నేపథ్యం|సన్నివేశం|ಉದಾಹರಣೆಗಳು|ಕಥಾಸಾರಾಂಶ|ವಿವರಣೆ|ಹಿನ್ನೆಲೆ|โครงสร้างของเหตุการณ์|ชุดของตัวอย่าง|ชุดของเหตุการณ์|แนวคิด|สรุปเหตุการณ์|เหตุการณ์|배경|시나리오|시나리오 개요|예|サンプル|シナリオ|シナリオアウトライン|シナリオテンプレ|シナリオテンプレート|テンプレ|例|例子|剧本|剧本大纲|劇本|劇本大綱|场景|场景大纲|場景|場景大綱|背景):[^:\r\n]*/m,
+            lookbehind: true,
+            inside: {
+              important: {
+                pattern: /(:)[^\r\n]*/,
+                lookbehind: true
+              },
+              keyword: /[^:\r\n]+:/
+            }
+          },
+          "table-body": {
+            // Look-behind is used to skip the table head, which has the same format as any table row
+            pattern: RegExp("(" + tableRow + ")(?:" + tableRow + ")+"),
+            lookbehind: true,
+            inside: {
+              outline: {
+                pattern: /<[^>]+>/,
+                alias: "variable"
+              },
+              td: {
+                pattern: /\s*[^\s|][^|]*/,
+                alias: "string"
+              },
+              punctuation: /\|/
+            }
+          },
+          "table-head": {
+            pattern: RegExp(tableRow),
+            inside: {
+              th: {
+                pattern: /\s*[^\s|][^|]*/,
+                alias: "variable"
+              },
+              punctuation: /\|/
+            }
+          },
+          atrule: {
+            pattern: /(^[ \t]+)(?:'a|'ach|'ej|7|a|A také|A taktiež|A tiež|A zároveň|Aber|Ac|Adott|Akkor|Ak|Aleshores|Ale|Ali|Allora|Alors|Als|Ama|Amennyiben|Amikor|Ampak|an|AN|Ananging|And y'all|And|Angenommen|Anrhegedig a|An|Apabila|Atès|Atesa|Atunci|Avast!|Aye|A|awer|Bagi|Banjur|Bet|Biết|Blimey!|Buh|But at the end of the day I reckon|But y'all|But|BUT|Cal|Când|Cand|Cando|Ce|Cuando|Če|Ða ðe|Ða|Dadas|Dada|Dados|Dado|DaH ghu' bejlu'|dann|Dann|Dano|Dan|Dar|Dat fiind|Data|Date fiind|Date|Dati fiind|Dati|Daţi fiind|Dați fiind|DEN|Dato|De|Den youse gotta|Dengan|Diberi|Diyelim ki|Donada|Donat|Donitaĵo|Do|Dun|Duota|Ðurh|Eeldades|Ef|Eğer ki|Entao|Então|Entón|E|En|Entonces|Epi|És|Etant donnée|Etant donné|Et|Étant données|Étant donnée|Étant donné|Etant données|Etant donnés|Étant donnés|Fakat|Gangway!|Gdy|Gegeben seien|Gegeben sei|Gegeven|Gegewe|ghu' noblu'|Gitt|Given y'all|Given|Givet|Givun|Ha|Cho|I CAN HAZ|In|Ir|It's just unbelievable|I|Ja|Jeśli|Jeżeli|Kad|Kada|Kadar|Kai|Kaj|Když|Keď|Kemudian|Ketika|Khi|Kiedy|Ko|Kuid|Kui|Kun|Lan|latlh|Le sa a|Let go and haul|Le|Lè sa a|Lè|Logo|Lorsqu'<|Lorsque|mä|Maar|Mais|Mając|Ma|Majd|Maka|Manawa|Mas|Men|Menawa|Mutta|Nalika|Nalikaning|Nanging|Når|När|Nato|Nhưng|Niin|Njuk|O zaman|Och|Og|Oletetaan|Ond|Onda|Oraz|Pak|Pero|Però|Podano|Pokiaľ|Pokud|Potem|Potom|Privzeto|Pryd|Quan|Quand|Quando|qaSDI'|Så|Sed|Se|Siis|Sipoze ke|Sipoze Ke|Sipoze|Si|Şi|Și|Soit|Stel|Tada|Tad|Takrat|Tak|Tapi|Ter|Tetapi|Tha the|Tha|Then y'all|Then|Thì|Thurh|Toda|Too right|Un|Und|ugeholl|Và|vaj|Vendar|Ve|wann|Wanneer|WEN|Wenn|When y'all|When|Wtedy|Wun|Y'know|Yeah nah|Yna|Youse know like when|Youse know when youse got|Y|Za predpokladu|Za předpokladu|Zadan|Zadani|Zadano|Zadate|Zadato|Zakładając|Zaradi|Zatati|Þa þe|Þa|Þá|Þegar|Þurh|Αλλά|Δεδομένου|Και|Όταν|Τότε|А також|Агар|Але|Али|Аммо|А|Әгәр|Әйтик|Әмма|Бирок|Ва|Вә|Дадено|Дано|Допустим|Если|Задате|Задати|Задато|И|І|К тому же|Када|Кад|Когато|Когда|Коли|Ләкин|Лекин|Нәтиҗәдә|Нехай|Но|Онда|Припустимо, що|Припустимо|Пусть|Также|Та|Тогда|Тоді|То|Унда|Һәм|Якщо|אבל|אזי|אז|בהינתן|וגם|כאשר|آنگاه|اذاً|اگر|اما|اور|با فرض|بالفرض|بفرض|پھر|تب|ثم|جب|عندما|فرض کیا|لكن|لیکن|متى|هنگامی|و|अगर|और|कदा|किन्तु|चूंकि|जब|तथा|तदा|तब|परन्तु|पर|यदि|ਅਤੇ|ਜਦੋਂ|ਜਿਵੇਂ ਕਿ|ਜੇਕਰ|ਤਦ|ਪਰ|అప్పుడు|ఈ పరిస్థితిలో|కాని|చెప్పబడినది|మరియు|ಆದರೆ|ನಂತರ|ನೀಡಿದ|ಮತ್ತು|ಸ್ಥಿತಿಯನ್ನು|กำหนดให้|ดังนั้น|แต่|เมื่อ|และ|그러면<|그리고<|단<|만약<|만일<|먼저<|조건<|하지만<|かつ<|しかし<|ただし<|ならば<|もし<|並且<|但し<|但是<|假如<|假定<|假設<|假设<|前提<|同时<|同時<|并且<|当<|當<|而且<|那么<|那麼<)(?=[ \t])/m,
+            lookbehind: true
+          },
+          string: {
+            pattern: /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/,
+            inside: {
+              outline: {
+                pattern: /<[^>]+>/,
+                alias: "variable"
+              }
+            }
+          },
+          outline: {
+            pattern: /<[^>]+>/,
+            alias: "variable"
+          }
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_gherkin
+};