@photonix/basic 1.5.1 → 1.6.0

package/dist/handlebars-QNCCSFVH.mjs

@@ -0,0 +1,270 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/handlebars.js
+var require_handlebars = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/handlebars.js"(exports, module) {
+    function source(re) {
+      if (!re) return null;
+      if (typeof re === "string") return re;
+      return re.source;
+    }
+    function anyNumberOfTimes(re) {
+      return concat("(", re, ")*");
+    }
+    function optional(re) {
+      return concat("(", re, ")?");
+    }
+    function concat(...args) {
+      const joined = args.map((x) => source(x)).join("");
+      return joined;
+    }
+    function either(...args) {
+      const joined = "(" + args.map((x) => source(x)).join("|") + ")";
+      return joined;
+    }
+    function handlebars(hljs) {
+      const BUILT_INS = {
+        "builtin-name": [
+          "action",
+          "bindattr",
+          "collection",
+          "component",
+          "concat",
+          "debugger",
+          "each",
+          "each-in",
+          "get",
+          "hash",
+          "if",
+          "in",
+          "input",
+          "link-to",
+          "loc",
+          "log",
+          "lookup",
+          "mut",
+          "outlet",
+          "partial",
+          "query-params",
+          "render",
+          "template",
+          "textarea",
+          "unbound",
+          "unless",
+          "view",
+          "with",
+          "yield"
+        ]
+      };
+      const LITERALS = {
+        literal: [
+          "true",
+          "false",
+          "undefined",
+          "null"
+        ]
+      };
+      const DOUBLE_QUOTED_ID_REGEX = /""|"[^"]+"/;
+      const SINGLE_QUOTED_ID_REGEX = /''|'[^']+'/;
+      const BRACKET_QUOTED_ID_REGEX = /\[\]|\[[^\]]+\]/;
+      const PLAIN_ID_REGEX = /[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/;
+      const PATH_DELIMITER_REGEX = /(\.|\/)/;
+      const ANY_ID = either(
+        DOUBLE_QUOTED_ID_REGEX,
+        SINGLE_QUOTED_ID_REGEX,
+        BRACKET_QUOTED_ID_REGEX,
+        PLAIN_ID_REGEX
+      );
+      const IDENTIFIER_REGEX = concat(
+        optional(/\.|\.\/|\//),
+        // relative or absolute path
+        ANY_ID,
+        anyNumberOfTimes(concat(
+          PATH_DELIMITER_REGEX,
+          ANY_ID
+        ))
+      );
+      const HASH_PARAM_REGEX = concat(
+        "(",
+        BRACKET_QUOTED_ID_REGEX,
+        "|",
+        PLAIN_ID_REGEX,
+        ")(?==)"
+      );
+      const HELPER_NAME_OR_PATH_EXPRESSION = {
+        begin: IDENTIFIER_REGEX,
+        lexemes: /[\w.\/]+/
+      };
+      const HELPER_PARAMETER = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+        keywords: LITERALS
+      });
+      const SUB_EXPRESSION = {
+        begin: /\(/,
+        end: /\)/
+        // the "contains" is added below when all necessary sub-modes are defined
+      };
+      const HASH = {
+        // fka "attribute-assignment", parameters of the form 'key=value'
+        className: "attr",
+        begin: HASH_PARAM_REGEX,
+        relevance: 0,
+        starts: {
+          begin: /=/,
+          end: /=/,
+          starts: {
+            contains: [
+              hljs.NUMBER_MODE,
+              hljs.QUOTE_STRING_MODE,
+              hljs.APOS_STRING_MODE,
+              HELPER_PARAMETER,
+              SUB_EXPRESSION
+            ]
+          }
+        }
+      };
+      const BLOCK_PARAMS = {
+        // parameters of the form '{{#with x as | y |}}...{{/with}}'
+        begin: /as\s+\|/,
+        keywords: {
+          keyword: "as"
+        },
+        end: /\|/,
+        contains: [
+          {
+            // define sub-mode in order to prevent highlighting of block-parameter named "as"
+            begin: /\w+/
+          }
+        ]
+      };
+      const HELPER_PARAMETERS = {
+        contains: [
+          hljs.NUMBER_MODE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          BLOCK_PARAMS,
+          HASH,
+          HELPER_PARAMETER,
+          SUB_EXPRESSION
+        ],
+        returnEnd: true
+        // the property "end" is defined through inheritance when the mode is used. If depends
+        // on the surrounding mode, but "endsWithParent" does not work here (i.e. it includes the
+        // end-token of the surrounding mode)
+      };
+      const SUB_EXPRESSION_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+        className: "name",
+        keywords: BUILT_INS,
+        starts: hljs.inherit(HELPER_PARAMETERS, {
+          end: /\)/
+        })
+      });
+      SUB_EXPRESSION.contains = [SUB_EXPRESSION_CONTENTS];
+      const OPENING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+        keywords: BUILT_INS,
+        className: "name",
+        starts: hljs.inherit(HELPER_PARAMETERS, {
+          end: /\}\}/
+        })
+      });
+      const CLOSING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+        keywords: BUILT_INS,
+        className: "name"
+      });
+      const BASIC_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+        className: "name",
+        keywords: BUILT_INS,
+        starts: hljs.inherit(HELPER_PARAMETERS, {
+          end: /\}\}/
+        })
+      });
+      const ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH = {
+        begin: /\\\{\{/,
+        skip: true
+      };
+      const PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH = {
+        begin: /\\\\(?=\{\{)/,
+        skip: true
+      };
+      return {
+        name: "Handlebars",
+        aliases: [
+          "hbs",
+          "html.hbs",
+          "html.handlebars",
+          "htmlbars"
+        ],
+        case_insensitive: true,
+        subLanguage: "xml",
+        contains: [
+          ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH,
+          PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH,
+          hljs.COMMENT(/\{\{!--/, /--\}\}/),
+          hljs.COMMENT(/\{\{!/, /\}\}/),
+          {
+            // open raw block "{{{{raw}}}} content not evaluated {{{{/raw}}}}"
+            className: "template-tag",
+            begin: /\{\{\{\{(?!\/)/,
+            end: /\}\}\}\}/,
+            contains: [OPENING_BLOCK_MUSTACHE_CONTENTS],
+            starts: {
+              end: /\{\{\{\{\//,
+              returnEnd: true,
+              subLanguage: "xml"
+            }
+          },
+          {
+            // close raw block
+            className: "template-tag",
+            begin: /\{\{\{\{\//,
+            end: /\}\}\}\}/,
+            contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+          },
+          {
+            // open block statement
+            className: "template-tag",
+            begin: /\{\{#/,
+            end: /\}\}/,
+            contains: [OPENING_BLOCK_MUSTACHE_CONTENTS]
+          },
+          {
+            className: "template-tag",
+            begin: /\{\{(?=else\}\})/,
+            end: /\}\}/,
+            keywords: "else"
+          },
+          {
+            className: "template-tag",
+            begin: /\{\{(?=else if)/,
+            end: /\}\}/,
+            keywords: "else if"
+          },
+          {
+            // closing block statement
+            className: "template-tag",
+            begin: /\{\{\//,
+            end: /\}\}/,
+            contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+          },
+          {
+            // template variable or helper-call that is NOT html-escaped
+            className: "template-variable",
+            begin: /\{\{\{/,
+            end: /\}\}\}/,
+            contains: [BASIC_MUSTACHE_CONTENTS]
+          },
+          {
+            // template variable or helper-call that is html-escaped
+            className: "template-variable",
+            begin: /\{\{/,
+            end: /\}\}/,
+            contains: [BASIC_MUSTACHE_CONTENTS]
+          }
+        ]
+      };
+    }
+    module.exports = handlebars;
+  }
+});
+export default require_handlebars();

package/dist/haskell-35ZVQPTJ.mjs

@@ -0,0 +1,163 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/haskell.js
+var require_haskell = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/haskell.js"(exports, module) {
+    function haskell(hljs) {
+      const COMMENT = {
+        variants: [
+          hljs.COMMENT("--", "$"),
+          hljs.COMMENT(
+            /\{-/,
+            /-\}/,
+            {
+              contains: ["self"]
+            }
+          )
+        ]
+      };
+      const PRAGMA = {
+        className: "meta",
+        begin: /\{-#/,
+        end: /#-\}/
+      };
+      const PREPROCESSOR = {
+        className: "meta",
+        begin: "^#",
+        end: "$"
+      };
+      const CONSTRUCTOR = {
+        className: "type",
+        begin: "\\b[A-Z][\\w']*",
+        // TODO: other constructors (build-in, infix).
+        relevance: 0
+      };
+      const LIST = {
+        begin: "\\(",
+        end: "\\)",
+        illegal: '"',
+        contains: [
+          PRAGMA,
+          PREPROCESSOR,
+          {
+            className: "type",
+            begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+          },
+          hljs.inherit(hljs.TITLE_MODE, {
+            begin: "[_a-z][\\w']*"
+          }),
+          COMMENT
+        ]
+      };
+      const RECORD = {
+        begin: /\{/,
+        end: /\}/,
+        contains: LIST.contains
+      };
+      return {
+        name: "Haskell",
+        aliases: ["hs"],
+        keywords: "let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",
+        contains: [
+          // Top-level constructions.
+          {
+            beginKeywords: "module",
+            end: "where",
+            keywords: "module where",
+            contains: [
+              LIST,
+              COMMENT
+            ],
+            illegal: "\\W\\.|;"
+          },
+          {
+            begin: "\\bimport\\b",
+            end: "$",
+            keywords: "import qualified as hiding",
+            contains: [
+              LIST,
+              COMMENT
+            ],
+            illegal: "\\W\\.|;"
+          },
+          {
+            className: "class",
+            begin: "^(\\s*)?(class|instance)\\b",
+            end: "where",
+            keywords: "class family instance where",
+            contains: [
+              CONSTRUCTOR,
+              LIST,
+              COMMENT
+            ]
+          },
+          {
+            className: "class",
+            begin: "\\b(data|(new)?type)\\b",
+            end: "$",
+            keywords: "data family type newtype deriving",
+            contains: [
+              PRAGMA,
+              CONSTRUCTOR,
+              LIST,
+              RECORD,
+              COMMENT
+            ]
+          },
+          {
+            beginKeywords: "default",
+            end: "$",
+            contains: [
+              CONSTRUCTOR,
+              LIST,
+              COMMENT
+            ]
+          },
+          {
+            beginKeywords: "infix infixl infixr",
+            end: "$",
+            contains: [
+              hljs.C_NUMBER_MODE,
+              COMMENT
+            ]
+          },
+          {
+            begin: "\\bforeign\\b",
+            end: "$",
+            keywords: "foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",
+            contains: [
+              CONSTRUCTOR,
+              hljs.QUOTE_STRING_MODE,
+              COMMENT
+            ]
+          },
+          {
+            className: "meta",
+            begin: "#!\\/usr\\/bin\\/env runhaskell",
+            end: "$"
+          },
+          // "Whitespaces".
+          PRAGMA,
+          PREPROCESSOR,
+          // Literals and names.
+          // TODO: characters.
+          hljs.QUOTE_STRING_MODE,
+          hljs.C_NUMBER_MODE,
+          CONSTRUCTOR,
+          hljs.inherit(hljs.TITLE_MODE, {
+            begin: "^[_a-z][\\w']*"
+          }),
+          COMMENT,
+          {
+            // No markup, relevance booster
+            begin: "->|<-"
+          }
+        ]
+      };
+    }
+    module.exports = haskell;
+  }
+});
+export default require_haskell();

package/dist/haskell-MAVWIOZH.mjs

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

package/dist/haxe-6ZTT6RMP.mjs

@@ -0,0 +1,8 @@
+import {
+  haxe
+} from "./chunk-3QESMYNO.mjs";
+import "./chunk-XWTEQUC3.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  haxe as default
+};

package/dist/haxe-G6EATY6F.mjs

@@ -0,0 +1,162 @@
+import {
+  __commonJS
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/haxe.js
+var require_haxe = __commonJS({
+  "../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/haxe.js"(exports, module) {
+    function haxe(hljs) {
+      const HAXE_BASIC_TYPES = "Int Float String Bool Dynamic Void Array ";
+      return {
+        name: "Haxe",
+        aliases: ["hx"],
+        keywords: {
+          keyword: "break case cast catch continue default do dynamic else enum extern for function here if import in inline never new override package private get set public return static super switch this throw trace try typedef untyped using var while " + HAXE_BASIC_TYPES,
+          built_in: "trace this",
+          literal: "true false null _"
+        },
+        contains: [
+          {
+            className: "string",
+            // interpolate-able strings
+            begin: "'",
+            end: "'",
+            contains: [
+              hljs.BACKSLASH_ESCAPE,
+              {
+                className: "subst",
+                // interpolation
+                begin: "\\$\\{",
+                end: "\\}"
+              },
+              {
+                className: "subst",
+                // interpolation
+                begin: "\\$",
+                end: /\W\}/
+              }
+            ]
+          },
+          hljs.QUOTE_STRING_MODE,
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE,
+          hljs.C_NUMBER_MODE,
+          {
+            className: "meta",
+            // compiler meta
+            begin: "@:",
+            end: "$"
+          },
+          {
+            className: "meta",
+            // compiler conditionals
+            begin: "#",
+            end: "$",
+            keywords: {
+              "meta-keyword": "if else elseif end error"
+            }
+          },
+          {
+            className: "type",
+            // function types
+            begin: ":[ 	]*",
+            end: "[^A-Za-z0-9_ 	\\->]",
+            excludeBegin: true,
+            excludeEnd: true,
+            relevance: 0
+          },
+          {
+            className: "type",
+            // types
+            begin: ":[ 	]*",
+            end: "\\W",
+            excludeBegin: true,
+            excludeEnd: true
+          },
+          {
+            className: "type",
+            // instantiation
+            begin: "new *",
+            end: "\\W",
+            excludeBegin: true,
+            excludeEnd: true
+          },
+          {
+            className: "class",
+            // enums
+            beginKeywords: "enum",
+            end: "\\{",
+            contains: [hljs.TITLE_MODE]
+          },
+          {
+            className: "class",
+            // abstracts
+            beginKeywords: "abstract",
+            end: "[\\{$]",
+            contains: [
+              {
+                className: "type",
+                begin: "\\(",
+                end: "\\)",
+                excludeBegin: true,
+                excludeEnd: true
+              },
+              {
+                className: "type",
+                begin: "from +",
+                end: "\\W",
+                excludeBegin: true,
+                excludeEnd: true
+              },
+              {
+                className: "type",
+                begin: "to +",
+                end: "\\W",
+                excludeBegin: true,
+                excludeEnd: true
+              },
+              hljs.TITLE_MODE
+            ],
+            keywords: {
+              keyword: "abstract from to"
+            }
+          },
+          {
+            className: "class",
+            // classes
+            begin: "\\b(class|interface) +",
+            end: "[\\{$]",
+            excludeEnd: true,
+            keywords: "class interface",
+            contains: [
+              {
+                className: "keyword",
+                begin: "\\b(extends|implements) +",
+                keywords: "extends implements",
+                contains: [
+                  {
+                    className: "type",
+                    begin: hljs.IDENT_RE,
+                    relevance: 0
+                  }
+                ]
+              },
+              hljs.TITLE_MODE
+            ]
+          },
+          {
+            className: "function",
+            beginKeywords: "function",
+            end: "\\(",
+            excludeEnd: true,
+            illegal: "\\S",
+            contains: [hljs.TITLE_MODE]
+          }
+        ],
+        illegal: /<\//
+      };
+    }
+    module.exports = haxe;
+  }
+});
+export default require_haxe();

package/dist/hcl-FFCI2DKU.mjs

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

package/dist/hlsl-Z3FZ4RZK.mjs

@@ -0,0 +1,9 @@
+import {
+  hlsl
+} from "./chunk-PHEYXK6C.mjs";
+import "./chunk-PEEMT7UZ.mjs";
+import "./chunk-XWTEQUC3.mjs";
+import "./chunk-XGB3TDIC.mjs";
+export {
+  hlsl as default
+};

package/dist/hoon-INKNRABL.mjs

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

package/dist/hpkp-GSNLXGTL.mjs

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