@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-5EQAM3IR.mjs

@@ -1,374 +0,0 @@
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markdown.js
-markdown.displayName = "markdown";
-markdown.aliases = ["md"];
-function markdown(Prism) {
-  Prism.register(markup);
-  (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(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 {
-  markdown
-};

package/dist/chunk-5N4QW4WH.mjs

@@ -1,55 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gap.js
-gap.displayName = "gap";
-gap.aliases = [];
-function gap(Prism) {
-  Prism.languages.gap = {
-    shell: {
-      pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
-      greedy: true,
-      inside: {
-        gap: {
-          pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/,
-          lookbehind: true,
-          inside: null
-          // see below
-        },
-        punctuation: /^gap>/
-      }
-    },
-    comment: {
-      pattern: /#.*/,
-      greedy: true
-    },
-    string: {
-      pattern: /(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/,
-      lookbehind: true,
-      greedy: true,
-      inside: {
-        continuation: {
-          pattern: /([\r\n])>/,
-          lookbehind: true,
-          alias: "punctuation"
-        }
-      }
-    },
-    keyword: /\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/,
-    boolean: /\b(?:false|true)\b/,
-    function: /\b[a-z_]\w*(?=\s*\()/i,
-    number: {
-      pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
-      lookbehind: true
-    },
-    continuation: {
-      pattern: /([\r\n])>/,
-      lookbehind: true,
-      alias: "punctuation"
-    },
-    operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
-    punctuation: /[()[\]{},;.:]/
-  };
-  Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap;
-}
-
-export {
-  gap
-};

package/dist/chunk-5QFNPN2C.mjs

@@ -1,72 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/latex.js
-latex.displayName = "latex";
-latex.aliases = ["context", "tex"];
-function latex(Prism) {
-  ;
-  (function(Prism2) {
-    var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i;
-    var insideEqu = {
-      "equation-command": {
-        pattern: funcPattern,
-        alias: "regex"
-      }
-    };
-    Prism2.languages.latex = {
-      comment: /%.*/,
-      // the verbatim environment prints whitespace to the document
-      cdata: {
-        pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
-        lookbehind: true
-      },
-      /*
-       * equations can be between $$ $$ or $ $ or \( \) or \[ \]
-       * (all are multiline)
-       */
-      equation: [
-        {
-          pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/,
-          inside: insideEqu,
-          alias: "string"
-        },
-        {
-          pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
-          lookbehind: true,
-          inside: insideEqu,
-          alias: "string"
-        }
-      ],
-      /*
-       * arguments which are keywords or references are highlighted
-       * as keywords
-       */
-      keyword: {
-        pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
-        lookbehind: true
-      },
-      url: {
-        pattern: /(\\url\{)[^}]+(?=\})/,
-        lookbehind: true
-      },
-      /*
-       * section or chapter headlines are highlighted as bold so that
-       * they stand out more
-       */
-      headline: {
-        pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
-        lookbehind: true,
-        alias: "class-name"
-      },
-      function: {
-        pattern: funcPattern,
-        alias: "selector"
-      },
-      punctuation: /[[\]{}&]/
-    };
-    Prism2.languages.tex = Prism2.languages.latex;
-    Prism2.languages.context = Prism2.languages.latex;
-  })(Prism);
-}
-
-export {
-  latex
-};

package/dist/chunk-5QYYCOPJ.mjs

@@ -1,186 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/lisp.js
-lisp.displayName = "lisp";
-lisp.aliases = ["elisp", "emacs", "emacs-lisp"];
-function lisp(Prism) {
-  ;
-  (function(Prism2) {
-    function simple_form(name) {
-      return RegExp(/(\()/.source + "(?:" + name + ")" + /(?=[\s\)])/.source);
-    }
-    function primitive(pattern) {
-      return RegExp(
-        /([\s([])/.source + "(?:" + pattern + ")" + /(?=[\s)])/.source
-      );
-    }
-    var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
-    var marker = "&" + symbol;
-    var par = "(\\()";
-    var endpar = "(?=\\))";
-    var space = "(?=\\s)";
-    var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
-    var language = {
-      // Three or four semicolons are considered a heading.
-      // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
-      heading: {
-        pattern: /;;;.*/,
-        alias: ["comment", "title"]
-      },
-      comment: /;.*/,
-      string: {
-        pattern: /"(?:[^"\\]|\\.)*"/,
-        greedy: true,
-        inside: {
-          argument: /[-A-Z]+(?=[.,\s])/,
-          symbol: RegExp("`" + symbol + "'")
-        }
-      },
-      "quoted-symbol": {
-        pattern: RegExp("#?'" + symbol),
-        alias: ["variable", "symbol"]
-      },
-      "lisp-property": {
-        pattern: RegExp(":" + symbol),
-        alias: "property"
-      },
-      splice: {
-        pattern: RegExp(",@?" + symbol),
-        alias: ["symbol", "variable"]
-      },
-      keyword: [
-        {
-          pattern: RegExp(
-            par + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + space
-          ),
-          lookbehind: true
-        },
-        {
-          pattern: RegExp(
-            par + "(?:append|by|collect|concat|do|finally|for|in|return)" + space
-          ),
-          lookbehind: true
-        }
-      ],
-      declare: {
-        pattern: simple_form(/declare/.source),
-        lookbehind: true,
-        alias: "keyword"
-      },
-      interactive: {
-        pattern: simple_form(/interactive/.source),
-        lookbehind: true,
-        alias: "keyword"
-      },
-      boolean: {
-        pattern: primitive(/nil|t/.source),
-        lookbehind: true
-      },
-      number: {
-        pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
-        lookbehind: true
-      },
-      defvar: {
-        pattern: RegExp(par + "def(?:const|custom|group|var)\\s+" + symbol),
-        lookbehind: true,
-        inside: {
-          keyword: /^def[a-z]+/,
-          variable: RegExp(symbol)
-        }
-      },
-      defun: {
-        pattern: RegExp(
-          par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          keyword: /^(?:cl-)?def\S+/,
-          // See below, this property needs to be defined later so that it can
-          // reference the language object.
-          arguments: null,
-          function: {
-            pattern: RegExp("(^\\s)" + symbol),
-            lookbehind: true
-          },
-          punctuation: /[()]/
-        }
-      },
-      lambda: {
-        pattern: RegExp(
-          par + "lambda\\s+\\(\\s*(?:&?" + symbol + "(?:\\s+&?" + symbol + ")*\\s*)?\\)"
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          keyword: /^lambda/,
-          // See below, this property needs to be defined later so that it can
-          // reference the language object.
-          arguments: null,
-          punctuation: /[()]/
-        }
-      },
-      car: {
-        pattern: RegExp(par + symbol),
-        lookbehind: true
-      },
-      punctuation: [
-        // open paren, brackets, and close paren
-        /(?:['`,]?\(|[)\[\]])/,
-        // cons
-        {
-          pattern: /(\s)\.(?=\s)/,
-          lookbehind: true
-        }
-      ]
-    };
-    var arg = {
-      "lisp-marker": RegExp(marker),
-      varform: {
-        pattern: RegExp(
-          /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source
-        ),
-        inside: language
-      },
-      argument: {
-        pattern: RegExp(/(^|[\s(])/.source + symbol),
-        lookbehind: true,
-        alias: "variable"
-      },
-      rest: language
-    };
-    var forms = "\\S+(?:\\s+\\S+)*";
-    var arglist = {
-      pattern: RegExp(par + nestedPar + endpar),
-      lookbehind: true,
-      inside: {
-        "rest-vars": {
-          pattern: RegExp("&(?:body|rest)\\s+" + forms),
-          inside: arg
-        },
-        "other-marker-vars": {
-          pattern: RegExp("&(?:aux|optional)\\s+" + forms),
-          inside: arg
-        },
-        keys: {
-          pattern: RegExp("&key\\s+" + forms + "(?:\\s+&allow-other-keys)?"),
-          inside: arg
-        },
-        argument: {
-          pattern: RegExp(symbol),
-          alias: "variable"
-        },
-        punctuation: /[()]/
-      }
-    };
-    language["lambda"].inside.arguments = arglist;
-    language["defun"].inside.arguments = Prism2.util.clone(arglist);
-    language["defun"].inside.arguments.inside.sublist = arglist;
-    Prism2.languages.lisp = language;
-    Prism2.languages.elisp = language;
-    Prism2.languages.emacs = language;
-    Prism2.languages["emacs-lisp"] = language;
-  })(Prism);
-}
-
-export {
-  lisp
-};