@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-IWQOYCRG.mjs

@@ -0,0 +1,65 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/powershell.js
+powershell.displayName = "powershell";
+powershell.aliases = [];
+function powershell(Prism) {
+  ;
+  (function(Prism2) {
+    var powershell2 = Prism2.languages.powershell = {
+      comment: [
+        {
+          pattern: /(^|[^`])<#[\s\S]*?#>/,
+          lookbehind: true
+        },
+        {
+          pattern: /(^|[^`])#.*/,
+          lookbehind: true
+        }
+      ],
+      string: [
+        {
+          pattern: /"(?:`[\s\S]|[^`"])*"/,
+          greedy: true,
+          inside: null
+          // see below
+        },
+        {
+          pattern: /'(?:[^']|'')*'/,
+          greedy: true
+        }
+      ],
+      // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+      // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+      namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+      boolean: /\$(?:false|true)\b/i,
+      variable: /\$\w+\b/,
+      // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+      // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+      // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+      function: [
+        /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i,
+        /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
+      ],
+      // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+      keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+      operator: {
+        pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+        lookbehind: true
+      },
+      punctuation: /[|{}[\];(),.]/
+    };
+    powershell2.string[0].inside = {
+      function: {
+        // Allow for one level of nesting
+        pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+        lookbehind: true,
+        inside: powershell2
+      },
+      boolean: powershell2.boolean,
+      variable: powershell2.variable
+    };
+  })(Prism);
+}
+
+export {
+  powershell
+};

package/dist/chunk-IY46OEJE.mjs

@@ -0,0 +1,306 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/mongodb.js
+mongodb.displayName = "mongodb";
+mongodb.aliases = [];
+function mongodb(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    var operators = [
+      // query and projection
+      "$eq",
+      "$gt",
+      "$gte",
+      "$in",
+      "$lt",
+      "$lte",
+      "$ne",
+      "$nin",
+      "$and",
+      "$not",
+      "$nor",
+      "$or",
+      "$exists",
+      "$type",
+      "$expr",
+      "$jsonSchema",
+      "$mod",
+      "$regex",
+      "$text",
+      "$where",
+      "$geoIntersects",
+      "$geoWithin",
+      "$near",
+      "$nearSphere",
+      "$all",
+      "$elemMatch",
+      "$size",
+      "$bitsAllClear",
+      "$bitsAllSet",
+      "$bitsAnyClear",
+      "$bitsAnySet",
+      "$comment",
+      "$elemMatch",
+      "$meta",
+      "$slice",
+      // update
+      "$currentDate",
+      "$inc",
+      "$min",
+      "$max",
+      "$mul",
+      "$rename",
+      "$set",
+      "$setOnInsert",
+      "$unset",
+      "$addToSet",
+      "$pop",
+      "$pull",
+      "$push",
+      "$pullAll",
+      "$each",
+      "$position",
+      "$slice",
+      "$sort",
+      "$bit",
+      // aggregation pipeline stages
+      "$addFields",
+      "$bucket",
+      "$bucketAuto",
+      "$collStats",
+      "$count",
+      "$currentOp",
+      "$facet",
+      "$geoNear",
+      "$graphLookup",
+      "$group",
+      "$indexStats",
+      "$limit",
+      "$listLocalSessions",
+      "$listSessions",
+      "$lookup",
+      "$match",
+      "$merge",
+      "$out",
+      "$planCacheStats",
+      "$project",
+      "$redact",
+      "$replaceRoot",
+      "$replaceWith",
+      "$sample",
+      "$set",
+      "$skip",
+      "$sort",
+      "$sortByCount",
+      "$unionWith",
+      "$unset",
+      "$unwind",
+      "$setWindowFields",
+      // aggregation pipeline operators
+      "$abs",
+      "$accumulator",
+      "$acos",
+      "$acosh",
+      "$add",
+      "$addToSet",
+      "$allElementsTrue",
+      "$and",
+      "$anyElementTrue",
+      "$arrayElemAt",
+      "$arrayToObject",
+      "$asin",
+      "$asinh",
+      "$atan",
+      "$atan2",
+      "$atanh",
+      "$avg",
+      "$binarySize",
+      "$bsonSize",
+      "$ceil",
+      "$cmp",
+      "$concat",
+      "$concatArrays",
+      "$cond",
+      "$convert",
+      "$cos",
+      "$dateFromParts",
+      "$dateToParts",
+      "$dateFromString",
+      "$dateToString",
+      "$dayOfMonth",
+      "$dayOfWeek",
+      "$dayOfYear",
+      "$degreesToRadians",
+      "$divide",
+      "$eq",
+      "$exp",
+      "$filter",
+      "$first",
+      "$floor",
+      "$function",
+      "$gt",
+      "$gte",
+      "$hour",
+      "$ifNull",
+      "$in",
+      "$indexOfArray",
+      "$indexOfBytes",
+      "$indexOfCP",
+      "$isArray",
+      "$isNumber",
+      "$isoDayOfWeek",
+      "$isoWeek",
+      "$isoWeekYear",
+      "$last",
+      "$last",
+      "$let",
+      "$literal",
+      "$ln",
+      "$log",
+      "$log10",
+      "$lt",
+      "$lte",
+      "$ltrim",
+      "$map",
+      "$max",
+      "$mergeObjects",
+      "$meta",
+      "$min",
+      "$millisecond",
+      "$minute",
+      "$mod",
+      "$month",
+      "$multiply",
+      "$ne",
+      "$not",
+      "$objectToArray",
+      "$or",
+      "$pow",
+      "$push",
+      "$radiansToDegrees",
+      "$range",
+      "$reduce",
+      "$regexFind",
+      "$regexFindAll",
+      "$regexMatch",
+      "$replaceOne",
+      "$replaceAll",
+      "$reverseArray",
+      "$round",
+      "$rtrim",
+      "$second",
+      "$setDifference",
+      "$setEquals",
+      "$setIntersection",
+      "$setIsSubset",
+      "$setUnion",
+      "$size",
+      "$sin",
+      "$slice",
+      "$split",
+      "$sqrt",
+      "$stdDevPop",
+      "$stdDevSamp",
+      "$strcasecmp",
+      "$strLenBytes",
+      "$strLenCP",
+      "$substr",
+      "$substrBytes",
+      "$substrCP",
+      "$subtract",
+      "$sum",
+      "$switch",
+      "$tan",
+      "$toBool",
+      "$toDate",
+      "$toDecimal",
+      "$toDouble",
+      "$toInt",
+      "$toLong",
+      "$toObjectId",
+      "$toString",
+      "$toLower",
+      "$toUpper",
+      "$trim",
+      "$trunc",
+      "$type",
+      "$week",
+      "$year",
+      "$zip",
+      "$count",
+      "$dateAdd",
+      "$dateDiff",
+      "$dateSubtract",
+      "$dateTrunc",
+      "$getField",
+      "$rand",
+      "$sampleRate",
+      "$setField",
+      "$unsetField",
+      // aggregation pipeline query modifiers
+      "$comment",
+      "$explain",
+      "$hint",
+      "$max",
+      "$maxTimeMS",
+      "$min",
+      "$orderby",
+      "$query",
+      "$returnKey",
+      "$showDiskLoc",
+      "$natural"
+    ];
+    var builtinFunctions = [
+      "ObjectId",
+      "Code",
+      "BinData",
+      "DBRef",
+      "Timestamp",
+      "NumberLong",
+      "NumberDecimal",
+      "MaxKey",
+      "MinKey",
+      "RegExp",
+      "ISODate",
+      "UUID"
+    ];
+    operators = operators.map(function(operator) {
+      return operator.replace("$", "\\$");
+    });
+    var operatorsSource = "(?:" + operators.join("|") + ")\\b";
+    Prism2.languages.mongodb = Prism2.languages.extend("javascript", {});
+    Prism2.languages.insertBefore("mongodb", "string", {
+      property: {
+        pattern: /(?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)(?=\s*:)/,
+        greedy: true,
+        inside: {
+          keyword: RegExp(`^(['"])?` + operatorsSource + "(?:\\1)?$")
+        }
+      }
+    });
+    Prism2.languages.mongodb.string.inside = {
+      url: {
+        // url pattern
+        pattern: /https?:\/\/[-\w@:%.+~#=]{1,256}\.[a-z0-9()]{1,6}\b[-\w()@:%+.~#?&/=]*/i,
+        greedy: true
+      },
+      entity: {
+        // ipv4
+        pattern: /\b(?:(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d\d?|2[0-4]\d|25[0-5])\b/,
+        greedy: true
+      }
+    };
+    Prism2.languages.insertBefore("mongodb", "constant", {
+      builtin: {
+        pattern: RegExp("\\b(?:" + builtinFunctions.join("|") + ")\\b"),
+        alias: "keyword"
+      }
+    });
+  })(Prism);
+}
+
+export {
+  mongodb
+};

package/dist/chunk-IZR4QWR2.mjs

@@ -0,0 +1,74 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/haskell.js
+haskell.displayName = "haskell";
+haskell.aliases = ["hs"];
+function haskell(Prism) {
+  Prism.languages.haskell = {
+    comment: {
+      pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+      lookbehind: true
+    },
+    char: {
+      pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+      alias: "string"
+    },
+    string: {
+      pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+      greedy: true
+    },
+    keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
+    "import-statement": {
+      // The imported or hidden names are not included in this import
+      // statement. This is because we want to highlight those exactly like
+      // we do for the names in the program.
+      pattern: /(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+      lookbehind: true,
+      inside: {
+        keyword: /\b(?:as|hiding|import|qualified)\b/,
+        punctuation: /\./
+      }
+    },
+    // These are builtin variables only. Constructors are highlighted later as a constant.
+    builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+    // decimal integers and floating point numbers | octal integers | hexadecimal integers
+    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+    operator: [
+      {
+        // infix operator
+        pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+        greedy: true
+      },
+      {
+        // function composition
+        pattern: /(\s)\.(?=\s)/,
+        lookbehind: true
+      },
+      // Most of this is needed because of the meaning of a single '.'.
+      // If it stands alone freely, it is the function composition.
+      // It may also be a separator between a module name and an identifier => no
+      // operator. If it comes together with other special characters it is an
+      // operator too.
+      //
+      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
+      /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+    ],
+    // In Haskell, nearly everything is a variable, do not highlight these.
+    hvariable: {
+      pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    constant: {
+      pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    punctuation: /[{}[\];(),.:]/
+  };
+  Prism.languages.hs = Prism.languages.haskell;
+}
+
+export {
+  haskell
+};

package/dist/chunk-IZV2OCAF.mjs

@@ -0,0 +1,64 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/abnf.js
+abnf.displayName = "abnf";
+abnf.aliases = [];
+function abnf(Prism) {
+  ;
+  (function(Prism2) {
+    var coreRules = "(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)";
+    Prism2.languages.abnf = {
+      comment: /;.*/,
+      string: {
+        pattern: /(?:%[is])?"[^"\n\r]*"/,
+        greedy: true,
+        inside: {
+          punctuation: /^%[is]/
+        }
+      },
+      range: {
+        pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
+        alias: "number"
+      },
+      terminal: {
+        pattern: /%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
+        alias: "number"
+      },
+      repetition: {
+        pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
+        lookbehind: true,
+        alias: "operator"
+      },
+      definition: {
+        pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
+        lookbehind: true,
+        alias: "keyword",
+        inside: {
+          punctuation: /<|>/
+        }
+      },
+      "core-rule": {
+        pattern: RegExp(
+          "(?:(^|[^<\\w-])" + coreRules + "|<" + coreRules + ">)(?![\\w-])",
+          "i"
+        ),
+        lookbehind: true,
+        alias: ["rule", "constant"],
+        inside: {
+          punctuation: /<|>/
+        }
+      },
+      rule: {
+        pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
+        lookbehind: true,
+        inside: {
+          punctuation: /<|>/
+        }
+      },
+      operator: /=\/?|\//,
+      punctuation: /[()\[\]]/
+    };
+  })(Prism);
+}
+
+export {
+  abnf
+};

package/dist/chunk-JJWMOWER.mjs

@@ -0,0 +1,70 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sml.js
+sml.displayName = "sml";
+sml.aliases = ["smlnj"];
+function sml(Prism) {
+  ;
+  (function(Prism2) {
+    var keywords = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+    Prism2.languages.sml = {
+      // allow one level of nesting
+      comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+      string: {
+        pattern: /#?"(?:[^"\\]|\\.)*"/,
+        greedy: true
+      },
+      "class-name": [
+        {
+          // This is only an approximation since the real grammar is context-free
+          //
+          // Why the main loop so complex?
+          // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+          // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+          // followed by a long identifier.
+          pattern: RegExp(
+            /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+              return /\s*(?:[*,]|->)/.source;
+            }).replace(/<TERMINAL>/g, function() {
+              return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+            }).replace(/<LONG-ID>/g, function() {
+              return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+            }).replace(/<KEYWORD>/g, function() {
+              return keywords.source;
+            }),
+            "i"
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: null
+          // see below
+        },
+        {
+          pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+          lookbehind: true
+        }
+      ],
+      function: {
+        pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+        lookbehind: true
+      },
+      keyword: keywords,
+      variable: {
+        pattern: /(^|[^\w'])'[\w']*/,
+        lookbehind: true
+      },
+      number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+      word: {
+        pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+        alias: "constant"
+      },
+      boolean: /\b(?:false|true)\b/i,
+      operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+      punctuation: /[(){}\[\].:,;]/
+    };
+    Prism2.languages.sml["class-name"][0].inside = Prism2.languages.sml;
+    Prism2.languages.smlnj = Prism2.languages.sml;
+  })(Prism);
+}
+
+export {
+  sml
+};