@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-N7SPE4RG.mjs

@@ -1,54 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/mel.js
-mel.displayName = "mel";
-mel.aliases = [];
-function mel(Prism) {
-  Prism.languages.mel = {
-    comment: {
-      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
-      greedy: true
-    },
-    code: {
-      pattern: /`(?:\\.|[^\\`])*`/,
-      greedy: true,
-      alias: "italic",
-      inside: {
-        delimiter: {
-          pattern: /^`|`$/,
-          alias: "punctuation"
-        },
-        statement: {
-          pattern: /[\s\S]+/,
-          inside: null
-          // see below
-        }
-      }
-    },
-    string: {
-      pattern: /"(?:\\.|[^\\"\r\n])*"/,
-      greedy: true
-    },
-    variable: /\$\w+/,
-    number: /\b0x[\da-fA-F]+\b|\b\d+(?:\.\d*)?|\B\.\d+/,
-    flag: {
-      pattern: /-[^\d\W]\w*/,
-      alias: "operator"
-    },
-    keyword: /\b(?:break|case|continue|default|do|else|float|for|global|if|in|int|matrix|proc|return|string|switch|vector|while)\b/,
-    function: {
-      pattern: /((?:^|[{;])[ \t]*)[a-z_]\w*\b(?!\s*(?:\.(?!\.)|[[{=]))|\b[a-z_]\w*(?=[ \t]*\()/im,
-      lookbehind: true,
-      greedy: true
-    },
-    "tensor-punctuation": {
-      pattern: /<<|>>/,
-      alias: "punctuation"
-    },
-    operator: /\+[+=]?|-[-=]?|&&|\|\||[<>]=?|[*\/!=]=?|[%^]/,
-    punctuation: /[.,:;?\[\](){}]/
-  };
-  Prism.languages.mel["code"].inside["statement"].inside = Prism.languages.mel;
-}
-
-export {
-  mel
-};

package/dist/chunk-N7SQ2N6J.mjs

@@ -1,53 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/protobuf.js
-protobuf.displayName = "protobuf";
-protobuf.aliases = [];
-function protobuf(Prism) {
-  Prism.register(clike);
-  (function(Prism2) {
-    var builtinTypes = /\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\b/;
-    Prism2.languages.protobuf = Prism2.languages.extend("clike", {
-      "class-name": [
-        {
-          pattern: /(\b(?:enum|extend|message|service)\s+)[A-Za-z_]\w*(?=\s*\{)/,
-          lookbehind: true
-        },
-        {
-          pattern: /(\b(?:rpc\s+\w+|returns)\s*\(\s*(?:stream\s+)?)\.?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?=\s*\))/,
-          lookbehind: true
-        }
-      ],
-      keyword: /\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\s+\w)|service|stream|syntax|to)\b(?!\s*=\s*\d)/,
-      function: /\b[a-z_]\w*(?=\s*\()/i
-    });
-    Prism2.languages.insertBefore("protobuf", "operator", {
-      map: {
-        pattern: /\bmap<\s*[\w.]+\s*,\s*[\w.]+\s*>(?=\s+[a-z_]\w*\s*[=;])/i,
-        alias: "class-name",
-        inside: {
-          punctuation: /[<>.,]/,
-          builtin: builtinTypes
-        }
-      },
-      builtin: builtinTypes,
-      "positional-class-name": {
-        pattern: /(?:\b|\B\.)[a-z_]\w*(?:\.[a-z_]\w*)*(?=\s+[a-z_]\w*\s*[=;])/i,
-        alias: "class-name",
-        inside: {
-          punctuation: /\./
-        }
-      },
-      annotation: {
-        pattern: /(\[\s*)[a-z_]\w*(?=\s*=)/i,
-        lookbehind: true
-      }
-    });
-  })(Prism);
-}
-
-export {
-  protobuf
-};

package/dist/chunk-NHRQUFUX.mjs

@@ -1,77 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javadoclike.js
-javadoclike.displayName = "javadoclike";
-javadoclike.aliases = [];
-function javadoclike(Prism) {
-  ;
-  (function(Prism2) {
-    var javaDocLike = Prism2.languages.javadoclike = {
-      parameter: {
-        pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
-        lookbehind: true
-      },
-      keyword: {
-        // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.
-        // @word, {@word}
-        pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
-        lookbehind: true
-      },
-      punctuation: /[{}]/
-    };
-    function docCommentSupport(lang, callback) {
-      var tokenName = "doc-comment";
-      var grammar = Prism2.languages[lang];
-      if (!grammar) {
-        return;
-      }
-      var token = grammar[tokenName];
-      if (!token) {
-        var definition = {};
-        definition[tokenName] = {
-          pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
-          lookbehind: true,
-          alias: "comment"
-        };
-        grammar = Prism2.languages.insertBefore(lang, "comment", definition);
-        token = grammar[tokenName];
-      }
-      if (token instanceof RegExp) {
-        token = grammar[tokenName] = {
-          pattern: token
-        };
-      }
-      if (Array.isArray(token)) {
-        for (var i = 0, l = token.length; i < l; i++) {
-          if (token[i] instanceof RegExp) {
-            token[i] = {
-              pattern: token[i]
-            };
-          }
-          callback(token[i]);
-        }
-      } else {
-        callback(token);
-      }
-    }
-    function addSupport(languages, docLanguage) {
-      if (typeof languages === "string") {
-        languages = [languages];
-      }
-      languages.forEach(function(lang) {
-        docCommentSupport(lang, function(pattern) {
-          if (!pattern.inside) {
-            pattern.inside = {};
-          }
-          pattern.inside.rest = docLanguage;
-        });
-      });
-    }
-    Object.defineProperty(javaDocLike, "addSupport", {
-      value: addSupport
-    });
-    javaDocLike.addSupport(["java", "javascript", "php"], javaDocLike);
-  })(Prism);
-}
-
-export {
-  javadoclike
-};

package/dist/chunk-NL4TFHYH.mjs

@@ -1,90 +0,0 @@
-import {
-  php
-} from "./chunk-4PP7IENX.mjs";
-import {
-  markupTemplating
-} from "./chunk-DFNMTLAN.mjs";
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/latte.js
-latte.displayName = "latte";
-latte.aliases = [];
-function latte(Prism) {
-  Prism.register(clike);
-  Prism.register(markupTemplating);
-  Prism.register(php);
-  (function(Prism2) {
-    Prism2.languages.latte = {
-      comment: /^\{\*[\s\S]*/,
-      "latte-tag": {
-        // https://latte.nette.org/en/tags
-        pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
-        lookbehind: true,
-        alias: "important"
-      },
-      delimiter: {
-        pattern: /^\{\/?|\}$/,
-        alias: "punctuation"
-      },
-      php: {
-        pattern: /\S(?:[\s\S]*\S)?/,
-        alias: "language-php",
-        inside: Prism2.languages.php
-      }
-    };
-    var markupLatte = Prism2.languages.extend("markup", {});
-    Prism2.languages.insertBefore(
-      "inside",
-      "attr-value",
-      {
-        "n-attr": {
-          pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/,
-          inside: {
-            "attr-name": {
-              pattern: /^[^\s=]+/,
-              alias: "important"
-            },
-            "attr-value": {
-              pattern: /=[\s\S]+/,
-              inside: {
-                punctuation: [
-                  /^=/,
-                  {
-                    pattern: /^(\s*)["']|["']$/,
-                    lookbehind: true
-                  }
-                ],
-                php: {
-                  pattern: /\S(?:[\s\S]*\S)?/,
-                  inside: Prism2.languages.php
-                }
-              }
-            }
-          }
-        }
-      },
-      markupLatte.tag
-    );
-    Prism2.hooks.add("before-tokenize", function(env) {
-      if (env.language !== "latte") {
-        return;
-      }
-      var lattePattern = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
-      Prism2.languages["markup-templating"].buildPlaceholders(
-        env,
-        "latte",
-        lattePattern
-      );
-      env.grammar = markupLatte;
-    });
-    Prism2.hooks.add("after-tokenize", function(env) {
-      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "latte");
-    });
-  })(Prism);
-}
-
-export {
-  latte
-};

package/dist/chunk-NS3BWBKW.mjs

@@ -1,129 +0,0 @@
-import {
-  markupTemplating
-} from "./chunk-DFNMTLAN.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ftl.js
-ftl.displayName = "ftl";
-ftl.aliases = [];
-function ftl(Prism) {
-  Prism.register(markupTemplating);
-  (function(Prism2) {
-    var FTL_EXPR = /[^<()"']|\((?:<expr>)*\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/.source;
-    for (var i = 0; i < 2; i++) {
-      FTL_EXPR = FTL_EXPR.replace(/<expr>/g, function() {
-        return FTL_EXPR;
-      });
-    }
-    FTL_EXPR = FTL_EXPR.replace(/<expr>/g, /[^\s\S]/.source);
-    var ftl2 = {
-      comment: /<#--[\s\S]*?-->/,
-      string: [
-        {
-          // raw string
-          pattern: /\br("|')(?:(?!\1)[^\\]|\\.)*\1/,
-          greedy: true
-        },
-        {
-          pattern: RegExp(
-            /("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:(?!\})(?:<expr>))*\})*\1/.source.replace(
-              /<expr>/g,
-              function() {
-                return FTL_EXPR;
-              }
-            )
-          ),
-          greedy: true,
-          inside: {
-            interpolation: {
-              pattern: RegExp(
-                /((?:^|[^\\])(?:\\\\)*)\$\{(?:(?!\})(?:<expr>))*\}/.source.replace(
-                  /<expr>/g,
-                  function() {
-                    return FTL_EXPR;
-                  }
-                )
-              ),
-              lookbehind: true,
-              inside: {
-                "interpolation-punctuation": {
-                  pattern: /^\$\{|\}$/,
-                  alias: "punctuation"
-                },
-                rest: null
-              }
-            }
-          }
-        }
-      ],
-      keyword: /\b(?:as)\b/,
-      boolean: /\b(?:false|true)\b/,
-      "builtin-function": {
-        pattern: /((?:^|[^?])\?\s*)\w+/,
-        lookbehind: true,
-        alias: "function"
-      },
-      function: /\b\w+(?=\s*\()/,
-      number: /\b\d+(?:\.\d+)?\b/,
-      operator: /\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/,
-      punctuation: /[,;.:()[\]{}]/
-    };
-    ftl2.string[1].inside.interpolation.inside.rest = ftl2;
-    Prism2.languages.ftl = {
-      "ftl-comment": {
-        // the pattern is shortened to be more efficient
-        pattern: /^<#--[\s\S]*/,
-        alias: "comment"
-      },
-      "ftl-directive": {
-        pattern: /^<[\s\S]+>$/,
-        inside: {
-          directive: {
-            pattern: /(^<\/?)[#@][a-z]\w*/i,
-            lookbehind: true,
-            alias: "keyword"
-          },
-          punctuation: /^<\/?|\/?>$/,
-          content: {
-            pattern: /\s*\S[\s\S]*/,
-            alias: "ftl",
-            inside: ftl2
-          }
-        }
-      },
-      "ftl-interpolation": {
-        pattern: /^\$\{[\s\S]*\}$/,
-        inside: {
-          punctuation: /^\$\{|\}$/,
-          content: {
-            pattern: /\s*\S[\s\S]*/,
-            alias: "ftl",
-            inside: ftl2
-          }
-        }
-      }
-    };
-    Prism2.hooks.add("before-tokenize", function(env) {
-      var pattern = RegExp(
-        /<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(
-          /<expr>/g,
-          function() {
-            return FTL_EXPR;
-          }
-        ),
-        "gi"
-      );
-      Prism2.languages["markup-templating"].buildPlaceholders(
-        env,
-        "ftl",
-        pattern
-      );
-    });
-    Prism2.hooks.add("after-tokenize", function(env) {
-      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "ftl");
-    });
-  })(Prism);
-}
-
-export {
-  ftl
-};