@btst/stack 1.9.0 → 1.10.0

package/dist/node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/magma.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+magma.displayName = 'magma';
+magma.aliases = [];
+
+/** @param {Refractor} Prism */
+function magma(Prism) {
+  Prism.languages.magma = {
+    output: {
+      pattern:
+        /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+      lookbehind: true,
+      greedy: true
+    },
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+    keyword:
+      /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+    boolean: /\b(?:false|true)\b/,
+    generator: {
+      pattern: /\b[a-z_]\w*(?=\s*<)/i,
+      alias: 'class-name'
+    },
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    number: {
+      pattern:
+        /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+      lookbehind: true
+    },
+    operator: /->|[-+*/^~!|#=]|:=|\.\./,
+    punctuation: /[()[\]{}<>,;.:]/
+  };
+}
+
+module.exports = magma;

package/dist/node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/magma.mjs

@@ -0,0 +1,45 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+magma.displayName = 'magma';
+magma.aliases = [];
+
+/** @param {Refractor} Prism */
+function magma(Prism) {
+  Prism.languages.magma = {
+    output: {
+      pattern:
+        /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+      lookbehind: true,
+      greedy: true
+    },
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+    keyword:
+      /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+    boolean: /\b(?:false|true)\b/,
+    generator: {
+      pattern: /\b[a-z_]\w*(?=\s*<)/i,
+      alias: 'class-name'
+    },
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    number: {
+      pattern:
+        /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+      lookbehind: true
+    },
+    operator: /->|[-+*/^~!|#=]|:=|\.\./,
+    punctuation: /[()[\]{}<>,;.:]/
+  };
+}
+
+export { magma as default };

package/dist/node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/makefile.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+makefile.displayName = 'makefile';
+makefile.aliases = [];
+
+/** @param {Refractor} Prism */
+function makefile(Prism) {
+  Prism.languages.makefile = {
+    comment: {
+      pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+      lookbehind: true
+    },
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    'builtin-target': {
+      pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+      alias: 'builtin'
+    },
+    target: {
+      pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+      alias: 'symbol',
+      inside: {
+        variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+      }
+    },
+    variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+    // Directives
+    keyword:
+      /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+    function: {
+      pattern:
+        /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+      lookbehind: true
+    },
+    operator: /(?:::|[?:+!])?=|[|@]/,
+    punctuation: /[:;(){}]/
+  };
+}
+
+module.exports = makefile;

package/dist/node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/makefile.mjs

@@ -0,0 +1,44 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+makefile.displayName = 'makefile';
+makefile.aliases = [];
+
+/** @param {Refractor} Prism */
+function makefile(Prism) {
+  Prism.languages.makefile = {
+    comment: {
+      pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+      lookbehind: true
+    },
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    'builtin-target': {
+      pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+      alias: 'builtin'
+    },
+    target: {
+      pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+      alias: 'symbol',
+      inside: {
+        variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+      }
+    },
+    variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+    // Directives
+    keyword:
+      /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+    function: {
+      pattern:
+        /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+      lookbehind: true
+    },
+    operator: /(?:::|[?:+!])?=|[|@]/,
+    punctuation: /[:;(){}]/
+  };
+}
+
+export { makefile as default };

package/dist/node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markdown.cjs

@@ -0,0 +1,403 @@
+'use strict';
+
+const markup = require('./markup.cjs');
+
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+markdown.displayName = 'markdown';
+markdown.aliases = ['md'];
+
+/** @param {Refractor} Prism */
+function markdown(Prism) {
+  Prism.register(markup)
+  ;(function (Prism) {
+    // Allow only one line break
+    var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+
+    /**
+     * This function is intended for the creation of the bold or italic pattern.
+     *
+     * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.
+     *
+     * _Note:_ Keep in mind that this adds a capturing group.
+     *
+     * @param {string} pattern
+     * @returns {RegExp}
+     */
+    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;
+    Prism.languages.markdown = Prism.languages.extend('markup', {});
+    Prism.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: Prism.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: Prism.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: Prism.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) {
+            Prism.languages.markdown[token].inside.content.inside[inside] =
+              Prism.languages.markdown[inside];
+          }
+        }
+      );
+    });
+    Prism.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
+          }
+
+          /*
+           * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token
+           * is optional. But the grammar is defined so that there is only one case we have to handle:
+           *
+           * token.content = [
+           *     <span class="punctuation">```</span>,
+           *     <span class="code-language">xxxx</span>,
+           *     '\n', // exactly one new lines (\r or \n or \r\n)
+           *     <span class="code-block">...</span>,
+           *     '\n', // exactly one new lines again
+           *     <span class="punctuation">```</span>
+           * ];
+           */
+
+          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'
+          ) {
+            // this might be a language that Prism does not support
+
+            // do some replacements to support C++, C#, and F#
+            var lang = codeLang.content
+              .replace(/\b#/g, 'sharp')
+              .replace(/\b\+\+/g, 'pp');
+            // only use the first word
+            lang = (/[a-z][\w-]*/i.exec(lang) || [''])[0].toLowerCase();
+            var alias = 'language-' + lang;
+
+            // add alias
+            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);
+    });
+    Prism.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 = Prism.languages[codeLang];
+      if (!grammar) {
+        if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {
+          var id =
+            'md-' +
+            new Date().valueOf() +
+            '-' +
+            Math.floor(Math.random() * 1e16);
+          env.attributes['id'] = id;
+          Prism.plugins.autoloader.loadLanguages(codeLang, function () {
+            var ele = document.getElementById(id);
+            if (ele) {
+              ele.innerHTML = Prism.highlight(
+                ele.textContent,
+                Prism.languages[codeLang],
+                codeLang
+              );
+            }
+          });
+        }
+      } else {
+        env.content = Prism.highlight(env.content.value, grammar, codeLang);
+      }
+    });
+    RegExp(Prism.languages.markup.tag.pattern.source, 'gi');
+    Prism.languages.md = Prism.languages.markdown;
+  })(Prism);
+}
+
+module.exports = markdown;