@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-IWQOYCRG.mjs

@@ -1,65 +0,0 @@
-// ../../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

@@ -1,306 +0,0 @@
-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

@@ -1,74 +0,0 @@
-// ../../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

@@ -1,64 +0,0 @@
-// ../../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

@@ -1,70 +0,0 @@
-// ../../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
-};