@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-WBOMXAHO.mjs

@@ -0,0 +1,94 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/odin.js
+odin.displayName = "odin";
+odin.aliases = [];
+function odin(Prism) {
+  ;
+  (function(Prism2) {
+    var escapes = /\\(?:["'\\abefnrtv]|0[0-7]{2}|U[\dA-Fa-f]{6}|u[\dA-Fa-f]{4}|x[\dA-Fa-f]{2})/;
+    Prism2.languages.odin = {
+      /**
+       * The current implementation supports only 1 level of nesting.
+       *
+       * @author Michael Schmidt
+       * @author edukisto
+       */
+      comment: [
+        {
+          pattern: /\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:\*(?!\/)|[^*])*(?:\*\/|$))*(?:\*\/|$)/,
+          greedy: true
+        },
+        {
+          pattern: /#![^\n\r]*/,
+          greedy: true
+        },
+        {
+          pattern: /\/\/[^\n\r]*/,
+          greedy: true
+        }
+      ],
+      /**
+       * Should be found before strings because of '"'"- and '`'`-like sequences.
+       */
+      char: {
+        pattern: /'(?:\\(?:.|[0Uux][0-9A-Fa-f]{1,6})|[^\n\r'\\])'/,
+        greedy: true,
+        inside: {
+          symbol: escapes
+        }
+      },
+      string: [
+        {
+          pattern: /`[^`]*`/,
+          greedy: true
+        },
+        {
+          pattern: /"(?:\\.|[^\n\r"\\])*"/,
+          greedy: true,
+          inside: {
+            symbol: escapes
+          }
+        }
+      ],
+      directive: {
+        pattern: /#\w+/,
+        alias: "property"
+      },
+      number: /\b0(?:b[01_]+|d[\d_]+|h_*(?:(?:(?:[\dA-Fa-f]_*){8}){1,2}|(?:[\dA-Fa-f]_*){4})|o[0-7_]+|x[\dA-F_a-f]+|z[\dAB_ab]+)\b|(?:\b\d+(?:\.(?!\.)\d*)?|\B\.\d+)(?:[Ee][+-]?\d*)?[ijk]?(?!\w)/,
+      discard: {
+        pattern: /\b_\b/,
+        alias: "keyword"
+      },
+      "procedure-definition": {
+        pattern: /\b\w+(?=[ \t]*(?::\s*){2}proc\b)/,
+        alias: "function"
+      },
+      keyword: /\b(?:asm|auto_cast|bit_set|break|case|cast|context|continue|defer|distinct|do|dynamic|else|enum|fallthrough|for|foreign|if|import|in|map|matrix|not_in|or_else|or_return|package|proc|return|struct|switch|transmute|typeid|union|using|when|where)\b/,
+      /**
+       * false, nil, true can be used as procedure names. "_" and keywords can't.
+       */
+      "procedure-name": {
+        pattern: /\b\w+(?=[ \t]*\()/,
+        alias: "function"
+      },
+      boolean: /\b(?:false|nil|true)\b/,
+      "constant-parameter-sign": {
+        pattern: /\$/,
+        alias: "important"
+      },
+      undefined: {
+        pattern: /---/,
+        alias: "operator"
+      },
+      arrow: {
+        pattern: /->/,
+        alias: "punctuation"
+      },
+      operator: /\+\+|--|\.\.[<=]?|(?:&~|[-!*+/=~]|[%&<>|]{1,2})=?|[?^]/,
+      punctuation: /[(),.:;@\[\]{}]/
+    };
+  })(Prism);
+}
+
+export {
+  odin
+};

package/dist/chunk-WGBB3VIS.mjs

@@ -0,0 +1,30 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/actionscript.js
+actionscript.displayName = "actionscript";
+actionscript.aliases = [];
+function actionscript(Prism) {
+  Prism.register(javascript);
+  Prism.languages.actionscript = Prism.languages.extend("javascript", {
+    keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
+    operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
+  });
+  Prism.languages.actionscript["class-name"].alias = "function";
+  delete Prism.languages.actionscript["parameter"];
+  delete Prism.languages.actionscript["literal-property"];
+  if (Prism.languages.markup) {
+    Prism.languages.insertBefore("actionscript", "string", {
+      xml: {
+        pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
+        lookbehind: true,
+        inside: Prism.languages.markup
+      }
+    });
+  }
+}
+
+export {
+  actionscript
+};

package/dist/chunk-WHCEAVEY.mjs

@@ -0,0 +1,32 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/al.js
+al.displayName = "al";
+al.aliases = [];
+function al(Prism) {
+  Prism.languages.al = {
+    comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+    string: {
+      pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+      greedy: true
+    },
+    function: {
+      pattern: /(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
+      lookbehind: true
+    },
+    keyword: [
+      // keywords
+      /\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i,
+      // objects and metadata that are used like keywords
+      /\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
+    ],
+    number: /\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
+    boolean: /\b(?:false|true)\b/i,
+    variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
+    "class-name": /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
+    operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
+    punctuation: /[()\[\]{}:.;,]/
+  };
+}
+
+export {
+  al
+};

package/dist/chunk-WNEBUTWJ.mjs

@@ -0,0 +1,51 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/peoplecode.js
+peoplecode.displayName = "peoplecode";
+peoplecode.aliases = ["pcode"];
+function peoplecode(Prism) {
+  Prism.languages.peoplecode = {
+    comment: RegExp(
+      [
+        // C-style multiline comments
+        /\/\*[\s\S]*?\*\//.source,
+        // REM comments
+        /\bREM[^;]*;/.source,
+        // Nested <* *> comments
+        /<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
+        // /+ +/ comments
+        /\/\+[\s\S]*?\+\//.source
+      ].join("|")
+    ),
+    string: {
+      pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+      greedy: true
+    },
+    variable: /%\w+/,
+    "function-definition": {
+      pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+      lookbehind: true,
+      alias: "function"
+    },
+    "class-name": {
+      pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+      lookbehind: true,
+      inside: {
+        punctuation: /:/
+      }
+    },
+    keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
+    "operator-keyword": {
+      pattern: /\b(?:and|not|or)\b/i,
+      alias: "operator"
+    },
+    function: /[_a-z]\w*(?=\s*\()/i,
+    boolean: /\b(?:false|true)\b/i,
+    number: /\b\d+(?:\.\d+)?\b/,
+    operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
+    punctuation: /[:.;,()[\]]/
+  };
+  Prism.languages.pcode = Prism.languages.peoplecode;
+}
+
+export {
+  peoplecode
+};

package/dist/chunk-WV4ZTPWD.mjs

@@ -0,0 +1,146 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cooklang.js
+cooklang.displayName = "cooklang";
+cooklang.aliases = [];
+function cooklang(Prism) {
+  ;
+  (function(Prism2) {
+    var single_token_suffix = /(?:(?!\s)[\d$+<=a-zA-Z\x80-\uFFFF])+/.source;
+    var multi_token_infix = /[^{}@#]+/.source;
+    var multi_token_suffix = /\{[^}#@]*\}/.source;
+    var multi_token = multi_token_infix + multi_token_suffix;
+    var timer_units = /(?:h|hours|hrs|m|min|minutes)/.source;
+    var amount_group_impl = {
+      pattern: /\{[^{}]*\}/,
+      inside: {
+        amount: {
+          pattern: /([\{|])[^{}|*%]+/,
+          lookbehind: true,
+          alias: "number"
+        },
+        unit: {
+          pattern: /(%)[^}]+/,
+          lookbehind: true,
+          alias: "symbol"
+        },
+        "servings-scaler": {
+          pattern: /\*/,
+          alias: "operator"
+        },
+        "servings-alternative-separator": {
+          pattern: /\|/,
+          alias: "operator"
+        },
+        "unit-separator": {
+          pattern: /(?:%|(\*)%)/,
+          lookbehind: true,
+          alias: "operator"
+        },
+        punctuation: /[{}]/
+      }
+    };
+    Prism2.languages.cooklang = {
+      comment: {
+        // [- comment -]
+        // -- comment
+        pattern: /\[-[\s\S]*?-\]|--.*/,
+        greedy: true
+      },
+      meta: {
+        // >> key: value
+        pattern: />>.*:.*/,
+        inside: {
+          property: {
+            // key:
+            pattern: /(>>\s*)[^\s:](?:[^:]*[^\s:])?/,
+            lookbehind: true
+          }
+        }
+      },
+      "cookware-group": {
+        // #...{...}, #...
+        pattern: new RegExp(
+          "#(?:" + multi_token + "|" + single_token_suffix + ")"
+        ),
+        inside: {
+          cookware: {
+            pattern: new RegExp("(^#)(?:" + multi_token_infix + ")"),
+            lookbehind: true,
+            alias: "variable"
+          },
+          "cookware-keyword": {
+            pattern: /^#/,
+            alias: "keyword"
+          },
+          "quantity-group": {
+            pattern: new RegExp(/\{[^{}@#]*\}/),
+            inside: {
+              quantity: {
+                pattern: new RegExp(/(^\{)/.source + multi_token_infix),
+                lookbehind: true,
+                alias: "number"
+              },
+              punctuation: /[{}]/
+            }
+          }
+        }
+      },
+      "ingredient-group": {
+        // @...{...}, @...
+        pattern: new RegExp(
+          "@(?:" + multi_token + "|" + single_token_suffix + ")"
+        ),
+        inside: {
+          ingredient: {
+            pattern: new RegExp("(^@)(?:" + multi_token_infix + ")"),
+            lookbehind: true,
+            alias: "variable"
+          },
+          "ingredient-keyword": {
+            pattern: /^@/,
+            alias: "keyword"
+          },
+          "amount-group": amount_group_impl
+        }
+      },
+      "timer-group": {
+        // ~timer{...}
+        // eslint-disable-next-line regexp/sort-alternatives
+        pattern: /~(?!\s)[^@#~{}]*\{[^{}]*\}/,
+        inside: {
+          timer: {
+            pattern: /(^~)[^{]+/,
+            lookbehind: true,
+            alias: "variable"
+          },
+          "duration-group": {
+            // {...}
+            pattern: /\{[^{}]*\}/,
+            inside: {
+              punctuation: /[{}]/,
+              unit: {
+                pattern: new RegExp(
+                  /(%\s*)/.source + timer_units + /\b/.source
+                ),
+                lookbehind: true,
+                alias: "symbol"
+              },
+              operator: /%/,
+              duration: {
+                pattern: /\d+/,
+                alias: "number"
+              }
+            }
+          },
+          "timer-keyword": {
+            pattern: /^~/,
+            alias: "keyword"
+          }
+        }
+      }
+    };
+  })(Prism);
+}
+
+export {
+  cooklang
+};

package/dist/chunk-XBO4544D.mjs

@@ -0,0 +1,69 @@
+import {
+  csharp
+} from "./chunk-MZQNC4B2.mjs";
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/aspnet.js
+aspnet.displayName = "aspnet";
+aspnet.aliases = [];
+function aspnet(Prism) {
+  Prism.register(csharp);
+  Prism.register(markup);
+  Prism.languages.aspnet = Prism.languages.extend("markup", {
+    "page-directive": {
+      pattern: /<%\s*@.*%>/,
+      alias: "tag",
+      inside: {
+        "page-directive": {
+          pattern: /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
+          alias: "tag"
+        },
+        rest: Prism.languages.markup.tag.inside
+      }
+    },
+    directive: {
+      pattern: /<%.*%>/,
+      alias: "tag",
+      inside: {
+        directive: {
+          pattern: /<%\s*?[$=%#:]{0,2}|%>/,
+          alias: "tag"
+        },
+        rest: Prism.languages.csharp
+      }
+    }
+  });
+  Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+  Prism.languages.insertBefore(
+    "inside",
+    "punctuation",
+    {
+      directive: Prism.languages.aspnet["directive"]
+    },
+    Prism.languages.aspnet.tag.inside["attr-value"]
+  );
+  Prism.languages.insertBefore("aspnet", "comment", {
+    "asp-comment": {
+      pattern: /<%--[\s\S]*?--%>/,
+      alias: ["asp", "comment"]
+    }
+  });
+  Prism.languages.insertBefore(
+    "aspnet",
+    Prism.languages.javascript ? "script" : "tag",
+    {
+      "asp-script": {
+        pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
+        lookbehind: true,
+        alias: ["asp", "script"],
+        inside: Prism.languages.csharp || {}
+      }
+    }
+  );
+}
+
+export {
+  aspnet
+};

package/dist/chunk-XDDKTY2Y.mjs

@@ -0,0 +1,36 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dax.js
+dax.displayName = "dax";
+dax.aliases = [];
+function dax(Prism) {
+  Prism.languages.dax = {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
+      lookbehind: true
+    },
+    "data-field": {
+      pattern: /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
+      alias: "symbol"
+    },
+    measure: {
+      pattern: /\[[ \w\xA0-\uFFFF]+\]/,
+      alias: "constant"
+    },
+    string: {
+      pattern: /"(?:[^"]|"")*"(?!")/,
+      greedy: true
+    },
+    function: /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
+    keyword: /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
+    boolean: {
+      pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
+      alias: "constant"
+    },
+    number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
+    operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
+    punctuation: /[;\[\](){}`,.]/
+  };
+}
+
+export {
+  dax
+};

package/dist/chunk-XGB3TDIC.mjs

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunk-XJC57WO7.mjs

@@ -0,0 +1,73 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/groovy.js
+groovy.displayName = "groovy";
+groovy.aliases = [];
+function groovy(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    var interpolation = {
+      pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/,
+      lookbehind: true,
+      inside: {
+        "interpolation-punctuation": {
+          pattern: /^\$\{?|\}$/,
+          alias: "punctuation"
+        },
+        expression: {
+          pattern: /[\s\S]+/,
+          inside: null
+          // see below
+        }
+      }
+    };
+    Prism2.languages.groovy = Prism2.languages.extend("clike", {
+      string: {
+        // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+        pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/,
+        greedy: true
+      },
+      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+        lookbehind: true
+      },
+      punctuation: /\.+|[{}[\];(),:$]/
+    });
+    Prism2.languages.insertBefore("groovy", "string", {
+      shebang: {
+        pattern: /#!.+/,
+        alias: "comment",
+        greedy: true
+      },
+      "interpolation-string": {
+        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+        // simple division (see JS regex), so find a fix maybe?
+        pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+        greedy: true,
+        inside: {
+          interpolation,
+          string: /[\s\S]+/
+        }
+      }
+    });
+    Prism2.languages.insertBefore("groovy", "punctuation", {
+      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+    });
+    Prism2.languages.insertBefore("groovy", "function", {
+      annotation: {
+        pattern: /(^|[^.])@\w+/,
+        lookbehind: true,
+        alias: "punctuation"
+      }
+    });
+    interpolation.inside.expression.inside = Prism2.languages.groovy;
+  })(Prism);
+}
+
+export {
+  groovy
+};

package/dist/chunk-XQCU5DYI.mjs

@@ -0,0 +1,72 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/git.js
+git.displayName = "git";
+git.aliases = [];
+function git(Prism) {
+  Prism.languages.git = {
+    /*
+     * A simple one line comment like in a git status command
+     * For instance:
+     * $ git status
+     * # On branch infinite-scroll
+     * # Your branch and 'origin/sharedBranches/frontendTeam/infinite-scroll' have diverged,
+     * # and have 1 and 2 different commits each, respectively.
+     * nothing to commit (working directory clean)
+     */
+    comment: /^#.*/m,
+    /*
+     * Regexp to match the changed lines in a git diff output. Check the example below.
+     */
+    deleted: /^[-–].*/m,
+    inserted: /^\+.*/m,
+    /*
+     * a string (double and simple quote)
+     */
+    string: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+    /*
+     * a git command. It starts with a random prompt finishing by a $, then "git" then some other parameters
+     * For instance:
+     * $ git add file.txt
+     */
+    command: {
+      pattern: /^.*\$ git .*$/m,
+      inside: {
+        /*
+         * A git command can contain a parameter starting by a single or a double dash followed by a string
+         * For instance:
+         * $ git diff --cached
+         * $ git log -p
+         */
+        parameter: /\s--?\w+/
+      }
+    },
+    /*
+     * Coordinates displayed in a git diff command
+     * For instance:
+     * $ git diff
+     * diff --git file.txt file.txt
+     * index 6214953..1d54a52 100644
+     * --- file.txt
+     * +++ file.txt
+     * @@ -1 +1,2 @@
+     * -Here's my tetx file
+     * +Here's my text file
+     * +And this is the second line
+     */
+    coord: /^@@.*@@$/m,
+    /*
+     * Match a "commit [SHA1]" line in a git log output.
+     * For instance:
+     * $ git log
+     * commit a11a14ef7e26f2ca62d4b35eac455ce636d0dc09
+     * Author: lgiraudel
+     * Date:   Mon Feb 17 11:18:34 2014 +0100
+     *
+     *     Add of a new line
+     */
+    "commit-sha1": /^commit \w{40}$/m
+  };
+}
+
+export {
+  git
+};