@photonix/basic 1.5.0 → 1.6.0

package/dist/elixir-35SHVRV3.mjs

@@ -0,0 +1,260 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elixir.js
+var require_elixir = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elixir.js"(exports, module) {
+    function elixir(hljs) {
+      const ELIXIR_IDENT_RE = "[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?";
+      const ELIXIR_METHOD_RE = "[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?";
+      const ELIXIR_KEYWORDS = {
+        $pattern: ELIXIR_IDENT_RE,
+        keyword: "and false then defined module in return redo retry end for true self when next until do begin unless nil break not case cond alias while ensure or include use alias fn quote require import with|0"
+      };
+      const SUBST = {
+        className: "subst",
+        begin: /#\{/,
+        end: /\}/,
+        keywords: ELIXIR_KEYWORDS
+      };
+      const NUMBER = {
+        className: "number",
+        begin: "(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[1-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)",
+        relevance: 0
+      };
+      const SIGIL_DELIMITERS = `[/|([{<"']`;
+      const LOWERCASE_SIGIL = {
+        className: "string",
+        begin: "~[a-z](?=" + SIGIL_DELIMITERS + ")",
+        contains: [
+          {
+            endsParent: true,
+            contains: [
+              {
+                contains: [
+                  hljs.BACKSLASH_ESCAPE,
+                  SUBST
+                ],
+                variants: [
+                  {
+                    begin: /"/,
+                    end: /"/
+                  },
+                  {
+                    begin: /'/,
+                    end: /'/
+                  },
+                  {
+                    begin: /\//,
+                    end: /\//
+                  },
+                  {
+                    begin: /\|/,
+                    end: /\|/
+                  },
+                  {
+                    begin: /\(/,
+                    end: /\)/
+                  },
+                  {
+                    begin: /\[/,
+                    end: /\]/
+                  },
+                  {
+                    begin: /\{/,
+                    end: /\}/
+                  },
+                  {
+                    begin: /</,
+                    end: />/
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      };
+      const UPCASE_SIGIL = {
+        className: "string",
+        begin: "~[A-Z](?=" + SIGIL_DELIMITERS + ")",
+        contains: [
+          {
+            begin: /"/,
+            end: /"/
+          },
+          {
+            begin: /'/,
+            end: /'/
+          },
+          {
+            begin: /\//,
+            end: /\//
+          },
+          {
+            begin: /\|/,
+            end: /\|/
+          },
+          {
+            begin: /\(/,
+            end: /\)/
+          },
+          {
+            begin: /\[/,
+            end: /\]/
+          },
+          {
+            begin: /\{/,
+            end: /\}/
+          },
+          {
+            begin: /</,
+            end: />/
+          }
+        ]
+      };
+      const STRING = {
+        className: "string",
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
+        ],
+        variants: [
+          {
+            begin: /"""/,
+            end: /"""/
+          },
+          {
+            begin: /'''/,
+            end: /'''/
+          },
+          {
+            begin: /~S"""/,
+            end: /"""/,
+            contains: []
+            // override default
+          },
+          {
+            begin: /~S"/,
+            end: /"/,
+            contains: []
+            // override default
+          },
+          {
+            begin: /~S'''/,
+            end: /'''/,
+            contains: []
+            // override default
+          },
+          {
+            begin: /~S'/,
+            end: /'/,
+            contains: []
+            // override default
+          },
+          {
+            begin: /'/,
+            end: /'/
+          },
+          {
+            begin: /"/,
+            end: /"/
+          }
+        ]
+      };
+      const FUNCTION = {
+        className: "function",
+        beginKeywords: "def defp defmacro",
+        end: /\B\b/,
+        // the mode is ended by the title
+        contains: [
+          hljs.inherit(hljs.TITLE_MODE, {
+            begin: ELIXIR_IDENT_RE,
+            endsParent: true
+          })
+        ]
+      };
+      const CLASS = hljs.inherit(FUNCTION, {
+        className: "class",
+        beginKeywords: "defimpl defmodule defprotocol defrecord",
+        end: /\bdo\b|$|;/
+      });
+      const ELIXIR_DEFAULT_CONTAINS = [
+        STRING,
+        UPCASE_SIGIL,
+        LOWERCASE_SIGIL,
+        hljs.HASH_COMMENT_MODE,
+        CLASS,
+        FUNCTION,
+        {
+          begin: "::"
+        },
+        {
+          className: "symbol",
+          begin: ":(?![\\s:])",
+          contains: [
+            STRING,
+            {
+              begin: ELIXIR_METHOD_RE
+            }
+          ],
+          relevance: 0
+        },
+        {
+          className: "symbol",
+          begin: ELIXIR_IDENT_RE + ":(?!:)",
+          relevance: 0
+        },
+        NUMBER,
+        {
+          className: "variable",
+          begin: "(\\$\\W)|((\\$|@@?)(\\w+))"
+        },
+        {
+          begin: "->"
+        },
+        {
+          // regexp container
+          begin: "(" + hljs.RE_STARTERS_RE + ")\\s*",
+          contains: [
+            hljs.HASH_COMMENT_MODE,
+            {
+              // to prevent false regex triggers for the division function:
+              // /:
+              begin: /\/: (?=\d+\s*[,\]])/,
+              relevance: 0,
+              contains: [NUMBER]
+            },
+            {
+              className: "regexp",
+              illegal: "\\n",
+              contains: [
+                hljs.BACKSLASH_ESCAPE,
+                SUBST
+              ],
+              variants: [
+                {
+                  begin: "/",
+                  end: "/[a-z]*"
+                },
+                {
+                  begin: "%r\\[",
+                  end: "\\][a-z]*"
+                }
+              ]
+            }
+          ],
+          relevance: 0
+        }
+      ];
+      SUBST.contains = ELIXIR_DEFAULT_CONTAINS;
+      return {
+        name: "Elixir",
+        keywords: ELIXIR_KEYWORDS,
+        contains: ELIXIR_DEFAULT_CONTAINS
+      };
+    }
+    module.exports = elixir;
+  }
+});
+export default require_elixir();

package/dist/elixir-FLOMFEBC.mjs

@@ -0,0 +1,7 @@
+import {
+  elixir
+} from "./chunk-W3I5J6QO.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  elixir as default
+};

package/dist/elm-3IARWMB4.mjs

@@ -0,0 +1,7 @@
+import {
+  elm
+} from "./chunk-3F53CENZ.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  elm as default
+};

package/dist/elm-WZHLV3WH.mjs

@@ -0,0 +1,120 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elm.js
+var require_elm = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elm.js"(exports, module) {
+    function elm(hljs) {
+      const COMMENT = {
+        variants: [
+          hljs.COMMENT("--", "$"),
+          hljs.COMMENT(
+            /\{-/,
+            /-\}/,
+            {
+              contains: ["self"]
+            }
+          )
+        ]
+      };
+      const CONSTRUCTOR = {
+        className: "type",
+        begin: "\\b[A-Z][\\w']*",
+        // TODO: other constructors (built-in, infix).
+        relevance: 0
+      };
+      const LIST = {
+        begin: "\\(",
+        end: "\\)",
+        illegal: '"',
+        contains: [
+          {
+            className: "type",
+            begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+          },
+          COMMENT
+        ]
+      };
+      const RECORD = {
+        begin: /\{/,
+        end: /\}/,
+        contains: LIST.contains
+      };
+      const CHARACTER = {
+        className: "string",
+        begin: "'\\\\?.",
+        end: "'",
+        illegal: "."
+      };
+      return {
+        name: "Elm",
+        keywords: "let in if then else case of where module import exposing type alias as infix infixl infixr port effect command subscription",
+        contains: [
+          // Top-level constructions.
+          {
+            beginKeywords: "port effect module",
+            end: "exposing",
+            keywords: "port effect module where command subscription exposing",
+            contains: [
+              LIST,
+              COMMENT
+            ],
+            illegal: "\\W\\.|;"
+          },
+          {
+            begin: "import",
+            end: "$",
+            keywords: "import as exposing",
+            contains: [
+              LIST,
+              COMMENT
+            ],
+            illegal: "\\W\\.|;"
+          },
+          {
+            begin: "type",
+            end: "$",
+            keywords: "type alias",
+            contains: [
+              CONSTRUCTOR,
+              LIST,
+              RECORD,
+              COMMENT
+            ]
+          },
+          {
+            beginKeywords: "infix infixl infixr",
+            end: "$",
+            contains: [
+              hljs.C_NUMBER_MODE,
+              COMMENT
+            ]
+          },
+          {
+            begin: "port",
+            end: "$",
+            keywords: "port",
+            contains: [COMMENT]
+          },
+          // Literals and names.
+          CHARACTER,
+          hljs.QUOTE_STRING_MODE,
+          hljs.C_NUMBER_MODE,
+          CONSTRUCTOR,
+          hljs.inherit(hljs.TITLE_MODE, {
+            begin: "^[_a-z][\\w']*"
+          }),
+          COMMENT,
+          {
+            begin: "->|<-"
+          }
+          // No markup, relevance booster
+        ],
+        illegal: /;/
+      };
+    }
+    module.exports = elm;
+  }
+});
+export default require_elm();

package/dist/erb-IHRTJJEQ.mjs

@@ -0,0 +1,11 @@
+import {
+  erb
+} from "./chunk-63T3V7T3.mjs";
+import "./chunk-DFNMTLAN.mjs";
+import "./chunk-VT6UVRUK.mjs";
+import "./chunk-ACDTS7FW.mjs";
+import "./chunk-XWTEQUC3.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  erb as default
+};

package/dist/erb-V33F6ITN.mjs

@@ -0,0 +1,27 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erb.js
+var require_erb = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erb.js"(exports, module) {
+    function erb(hljs) {
+      return {
+        name: "ERB",
+        subLanguage: "xml",
+        contains: [
+          hljs.COMMENT("<%#", "%>"),
+          {
+            begin: "<%[%=-]?",
+            end: "[%-]?%>",
+            subLanguage: "ruby",
+            excludeBegin: true,
+            excludeEnd: true
+          }
+        ]
+      };
+    }
+    module.exports = erb;
+  }
+});
+export default require_erb();

package/dist/erlang-4NE5CUIK.mjs

@@ -0,0 +1,192 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang.js
+var require_erlang = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang.js"(exports, module) {
+    function erlang(hljs) {
+      const BASIC_ATOM_RE = "[a-z'][a-zA-Z0-9_']*";
+      const FUNCTION_NAME_RE = "(" + BASIC_ATOM_RE + ":" + BASIC_ATOM_RE + "|" + BASIC_ATOM_RE + ")";
+      const ERLANG_RESERVED = {
+        keyword: "after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor",
+        literal: "false true"
+      };
+      const COMMENT = hljs.COMMENT("%", "$");
+      const NUMBER = {
+        className: "number",
+        begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+        relevance: 0
+      };
+      const NAMED_FUN = {
+        begin: "fun\\s+" + BASIC_ATOM_RE + "/\\d+"
+      };
+      const FUNCTION_CALL = {
+        begin: FUNCTION_NAME_RE + "\\(",
+        end: "\\)",
+        returnBegin: true,
+        relevance: 0,
+        contains: [
+          {
+            begin: FUNCTION_NAME_RE,
+            relevance: 0
+          },
+          {
+            begin: "\\(",
+            end: "\\)",
+            endsWithParent: true,
+            returnEnd: true,
+            relevance: 0
+            // "contains" defined later
+          }
+        ]
+      };
+      const TUPLE = {
+        begin: /\{/,
+        end: /\}/,
+        relevance: 0
+        // "contains" defined later
+      };
+      const VAR1 = {
+        begin: "\\b_([A-Z][A-Za-z0-9_]*)?",
+        relevance: 0
+      };
+      const VAR2 = {
+        begin: "[A-Z][a-zA-Z0-9_]*",
+        relevance: 0
+      };
+      const RECORD_ACCESS = {
+        begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+        relevance: 0,
+        returnBegin: true,
+        contains: [
+          {
+            begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+            relevance: 0
+          },
+          {
+            begin: /\{/,
+            end: /\}/,
+            relevance: 0
+            // "contains" defined later
+          }
+        ]
+      };
+      const BLOCK_STATEMENTS = {
+        beginKeywords: "fun receive if try case",
+        end: "end",
+        keywords: ERLANG_RESERVED
+      };
+      BLOCK_STATEMENTS.contains = [
+        COMMENT,
+        NAMED_FUN,
+        hljs.inherit(hljs.APOS_STRING_MODE, {
+          className: ""
+        }),
+        BLOCK_STATEMENTS,
+        FUNCTION_CALL,
+        hljs.QUOTE_STRING_MODE,
+        NUMBER,
+        TUPLE,
+        VAR1,
+        VAR2,
+        RECORD_ACCESS
+      ];
+      const BASIC_MODES = [
+        COMMENT,
+        NAMED_FUN,
+        BLOCK_STATEMENTS,
+        FUNCTION_CALL,
+        hljs.QUOTE_STRING_MODE,
+        NUMBER,
+        TUPLE,
+        VAR1,
+        VAR2,
+        RECORD_ACCESS
+      ];
+      FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+      TUPLE.contains = BASIC_MODES;
+      RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+      const DIRECTIVES = [
+        "-module",
+        "-record",
+        "-undef",
+        "-export",
+        "-ifdef",
+        "-ifndef",
+        "-author",
+        "-copyright",
+        "-doc",
+        "-vsn",
+        "-import",
+        "-include",
+        "-include_lib",
+        "-compile",
+        "-define",
+        "-else",
+        "-endif",
+        "-file",
+        "-behaviour",
+        "-behavior",
+        "-spec"
+      ];
+      const PARAMS = {
+        className: "params",
+        begin: "\\(",
+        end: "\\)",
+        contains: BASIC_MODES
+      };
+      return {
+        name: "Erlang",
+        aliases: ["erl"],
+        keywords: ERLANG_RESERVED,
+        illegal: "(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))",
+        contains: [
+          {
+            className: "function",
+            begin: "^" + BASIC_ATOM_RE + "\\s*\\(",
+            end: "->",
+            returnBegin: true,
+            illegal: "\\(|#|//|/\\*|\\\\|:|;",
+            contains: [
+              PARAMS,
+              hljs.inherit(hljs.TITLE_MODE, {
+                begin: BASIC_ATOM_RE
+              })
+            ],
+            starts: {
+              end: ";|\\.",
+              keywords: ERLANG_RESERVED,
+              contains: BASIC_MODES
+            }
+          },
+          COMMENT,
+          {
+            begin: "^-",
+            end: "\\.",
+            relevance: 0,
+            excludeEnd: true,
+            returnBegin: true,
+            keywords: {
+              $pattern: "-" + hljs.IDENT_RE,
+              keyword: DIRECTIVES.map((x) => `${x}|1.5`).join(" ")
+            },
+            contains: [PARAMS]
+          },
+          NUMBER,
+          hljs.QUOTE_STRING_MODE,
+          RECORD_ACCESS,
+          VAR1,
+          VAR2,
+          TUPLE,
+          {
+            begin: /\.$/
+          }
+          // relevance booster
+        ]
+      };
+    }
+    module.exports = erlang;
+  }
+});
+export default require_erlang();

package/dist/erlang-ONMGKT4M.mjs

@@ -0,0 +1,7 @@
+import {
+  erlang
+} from "./chunk-FVLPKW7Z.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  erlang as default
+};

package/dist/erlang-repl-AIC2Z7PG.mjs

@@ -0,0 +1,70 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang-repl.js
+var require_erlang_repl = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang-repl.js"(exports, module) {
+    function source(re) {
+      if (!re) return null;
+      if (typeof re === "string") return re;
+      return re.source;
+    }
+    function concat(...args) {
+      const joined = args.map((x) => source(x)).join("");
+      return joined;
+    }
+    function erlangRepl(hljs) {
+      return {
+        name: "Erlang REPL",
+        keywords: {
+          built_in: "spawn spawn_link self",
+          keyword: "after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse|10 query receive rem try when xor"
+        },
+        contains: [
+          {
+            className: "meta",
+            begin: "^[0-9]+> ",
+            relevance: 10
+          },
+          hljs.COMMENT("%", "$"),
+          {
+            className: "number",
+            begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+            relevance: 0
+          },
+          hljs.APOS_STRING_MODE,
+          hljs.QUOTE_STRING_MODE,
+          {
+            begin: concat(
+              /\?(::)?/,
+              /([A-Z]\w*)/,
+              // at least one identifier
+              /((::)[A-Z]\w*)*/
+              // perhaps more
+            )
+          },
+          {
+            begin: "->"
+          },
+          {
+            begin: "ok"
+          },
+          {
+            begin: "!"
+          },
+          {
+            begin: "(\\b[a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*)|(\\b[a-z'][a-zA-Z0-9_']*)",
+            relevance: 0
+          },
+          {
+            begin: "[A-Z][a-zA-Z0-9_']*",
+            relevance: 0
+          }
+        ]
+      };
+    }
+    module.exports = erlangRepl;
+  }
+});
+export default require_erlang_repl();