@photonix/basic 1.5.1 → 1.6.0

package/dist/chunk-CFGQLYKY.mjs

@@ -0,0 +1,64 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/django.js
+django.displayName = "django";
+django.aliases = ["jinja2"];
+function django(Prism) {
+  Prism.register(markupTemplating);
+  (function(Prism2) {
+    Prism2.languages.django = {
+      comment: /^\{#[\s\S]*?#\}$/,
+      tag: {
+        pattern: /(^\{%[+-]?\s*)\w+/,
+        lookbehind: true,
+        alias: "keyword"
+      },
+      delimiter: {
+        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+        alias: "punctuation"
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      filter: {
+        pattern: /(\|)\w+/,
+        lookbehind: true,
+        alias: "function"
+      },
+      test: {
+        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+        lookbehind: true,
+        alias: "function"
+      },
+      function: /\b[a-z_]\w+(?=\s*\()/i,
+      keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+      number: /\b\d+(?:\.\d+)?\b/,
+      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+      variable: /\b\w+\b/,
+      punctuation: /[{}[\](),.:;]/
+    };
+    var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
+    var markupTemplating2 = Prism2.languages["markup-templating"];
+    Prism2.hooks.add("before-tokenize", function(env) {
+      markupTemplating2.buildPlaceholders(env, "django", pattern);
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      markupTemplating2.tokenizePlaceholders(env, "django");
+    });
+    Prism2.languages.jinja2 = Prism2.languages.django;
+    Prism2.hooks.add("before-tokenize", function(env) {
+      markupTemplating2.buildPlaceholders(env, "jinja2", pattern);
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      markupTemplating2.tokenizePlaceholders(env, "jinja2");
+    });
+  })(Prism);
+}
+
+export {
+  django
+};

package/dist/chunk-CINMPZYC.mjs

@@ -0,0 +1,96 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pascaligo.js
+pascaligo.displayName = "pascaligo";
+pascaligo.aliases = [];
+function pascaligo(Prism) {
+  ;
+  (function(Prism2) {
+    var braces = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source;
+    var type = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(
+      /<braces>/g,
+      function() {
+        return braces;
+      }
+    );
+    var pascaligo2 = Prism2.languages.pascaligo = {
+      comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+      string: {
+        pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+        greedy: true
+      },
+      "class-name": [
+        {
+          pattern: RegExp(
+            /(\btype\s+\w+\s+is\s+)<type>/.source.replace(
+              /<type>/g,
+              function() {
+                return type;
+              }
+            ),
+            "i"
+          ),
+          lookbehind: true,
+          inside: null
+          // see below
+        },
+        {
+          pattern: RegExp(
+            /<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+              return type;
+            }),
+            "i"
+          ),
+          inside: null
+          // see below
+        },
+        {
+          pattern: RegExp(
+            /(:\s*)<type>/.source.replace(/<type>/g, function() {
+              return type;
+            })
+          ),
+          lookbehind: true,
+          inside: null
+          // see below
+        }
+      ],
+      keyword: {
+        pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
+        lookbehind: true
+      },
+      boolean: {
+        pattern: /(^|[^&])\b(?:False|True)\b/i,
+        lookbehind: true
+      },
+      builtin: {
+        pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+        lookbehind: true
+      },
+      function: /\b\w+(?=\s*\()/,
+      number: [
+        // Hexadecimal, octal and binary
+        /%[01]+|&[0-7]+|\$[a-f\d]+/i,
+        // Decimal
+        /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i
+      ],
+      operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
+      punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
+    };
+    var classNameInside = [
+      "comment",
+      "keyword",
+      "builtin",
+      "operator",
+      "punctuation"
+    ].reduce(function(accum, key) {
+      accum[key] = pascaligo2[key];
+      return accum;
+    }, {});
+    pascaligo2["class-name"].forEach(function(p) {
+      p.inside = classNameInside;
+    });
+  })(Prism);
+}
+
+export {
+  pascaligo
+};

package/dist/chunk-CSAKARE4.mjs

@@ -0,0 +1,54 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jolie.js
+jolie.displayName = "jolie";
+jolie.aliases = [];
+function jolie(Prism) {
+  Prism.register(clike);
+  Prism.languages.jolie = Prism.languages.extend("clike", {
+    string: {
+      pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    "class-name": {
+      pattern: /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/,
+      lookbehind: true
+    },
+    keyword: /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/,
+    function: /\b[a-z_]\w*(?=[ \t]*[@(])/i,
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i,
+    operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/,
+    punctuation: /[()[\]{},;.:]/,
+    builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/
+  });
+  Prism.languages.insertBefore("jolie", "keyword", {
+    aggregates: {
+      pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
+      lookbehind: true,
+      inside: {
+        keyword: /\bwith\b/,
+        "class-name": /\w+/,
+        punctuation: /,/
+      }
+    },
+    redirects: {
+      pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/,
+      lookbehind: true,
+      inside: {
+        punctuation: /,/,
+        "class-name": /\w+/,
+        operator: /=>/
+      }
+    },
+    property: {
+      pattern: /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/
+    }
+  });
+}
+
+export {
+  jolie
+};

package/dist/chunk-CWHMZ45M.mjs

@@ -0,0 +1,96 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/vala.js
+vala.displayName = "vala";
+vala.aliases = [];
+function vala(Prism) {
+  Prism.register(clike);
+  Prism.languages.vala = Prism.languages.extend("clike", {
+    // Classes copied from prism-csharp
+    "class-name": [
+      {
+        // (Foo bar, Bar baz)
+        pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      {
+        // [Foo]
+        pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      {
+        // class Foo : Bar
+        pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      {
+        // class Foo
+        pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    ],
+    keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
+    function: /\b\w+(?=\s*\()/,
+    number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
+    operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
+    punctuation: /[{}[\];(),.:]/,
+    constant: /\b[A-Z0-9_]+\b/
+  });
+  Prism.languages.insertBefore("vala", "string", {
+    "raw-string": {
+      pattern: /"""[\s\S]*?"""/,
+      greedy: true,
+      alias: "string"
+    },
+    "template-string": {
+      pattern: /@"[\s\S]*?"/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
+          inside: {
+            delimiter: {
+              pattern: /^\$\(?|\)$/,
+              alias: "punctuation"
+            },
+            rest: Prism.languages.vala
+          }
+        },
+        string: /[\s\S]+/
+      }
+    }
+  });
+  Prism.languages.insertBefore("vala", "keyword", {
+    regex: {
+      pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
+      greedy: true,
+      inside: {
+        "regex-source": {
+          pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+          lookbehind: true,
+          alias: "language-regex",
+          inside: Prism.languages.regex
+        },
+        "regex-delimiter": /^\//,
+        "regex-flags": /^[a-z]+$/
+      }
+    }
+  });
+}
+
+export {
+  vala
+};

package/dist/chunk-D4LIYE2K.mjs

@@ -0,0 +1,72 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dhall.js
+dhall.displayName = "dhall";
+dhall.aliases = [];
+function dhall(Prism) {
+  Prism.languages.dhall = {
+    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+    // The multi-line pattern is essentially this:
+    //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+    comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+    string: {
+      pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /\$\{[^{}]*\}/,
+          inside: {
+            expression: {
+              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+              lookbehind: true,
+              alias: "language-dhall",
+              inside: null
+              // see blow
+            },
+            punctuation: /\$\{|\}/
+          }
+        }
+      }
+    },
+    label: {
+      pattern: /`[^`]*`/,
+      greedy: true
+    },
+    url: {
+      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+      pattern: /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+      greedy: true
+    },
+    env: {
+      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+      pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+      greedy: true,
+      inside: {
+        function: /^env/,
+        operator: /^:/,
+        variable: /[\s\S]+/
+      }
+    },
+    hash: {
+      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+      pattern: /\bsha256:[\da-fA-F]{64}\b/,
+      inside: {
+        function: /sha256/,
+        operator: /:/,
+        number: /[\da-fA-F]{64}/
+      }
+    },
+    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+    keyword: /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+    builtin: /\b(?:None|Some)\b/,
+    boolean: /\b(?:False|True)\b/,
+    number: /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+    operator: /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+    punctuation: /\.\.|[{}\[\](),./]/,
+    // we'll just assume that every capital word left is a type name
+    "class-name": /\b[A-Z]\w*\b/
+  };
+  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside = Prism.languages.dhall;
+}
+
+export {
+  dhall
+};

package/dist/chunk-DDRA5FGA.mjs

@@ -0,0 +1,56 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/apacheconf.js
+apacheconf.displayName = "apacheconf";
+apacheconf.aliases = [];
+function apacheconf(Prism) {
+  Prism.languages.apacheconf = {
+    comment: /#.*/,
+    "directive-inline": {
+      pattern: /(^[\t ]*)\b(?:AcceptFilter|AcceptPathInfo|AccessFileName|Action|Add(?:Alt|AltByEncoding|AltByType|Charset|DefaultCharset|Description|Encoding|Handler|Icon|IconByEncoding|IconByType|InputFilter|Language|ModuleInfo|OutputFilter|OutputFilterByType|Type)|Alias|AliasMatch|Allow(?:CONNECT|EncodedSlashes|Methods|Override|OverrideList)?|Anonymous(?:_LogEmail|_MustGiveEmail|_NoUserID|_VerifyEmail)?|AsyncRequestWorkerFactor|Auth(?:BasicAuthoritative|BasicFake|BasicProvider|BasicUseDigestAlgorithm|DBDUserPWQuery|DBDUserRealmQuery|DBMGroupFile|DBMType|DBMUserFile|Digest(?:Algorithm|Domain|NonceLifetime|Provider|Qop|ShmemSize)|Form(?:Authoritative|Body|DisableNoStore|FakeBasicAuth|Location|LoginRequiredLocation|LoginSuccessLocation|LogoutLocation|Method|Mimetype|Password|Provider|SitePassphrase|Size|Username)|GroupFile|LDAP(?:AuthorizePrefix|BindAuthoritative|BindDN|BindPassword|CharsetConfig|CompareAsUser|CompareDNOnServer|DereferenceAliases|GroupAttribute|GroupAttributeIsDN|InitialBindAsUser|InitialBindPattern|MaxSubGroupDepth|RemoteUserAttribute|RemoteUserIsDN|SearchAsUser|SubGroupAttribute|SubGroupClass|Url)|Merging|Name|nCache(?:Context|Enable|ProvideFor|SOCache|Timeout)|nzFcgiCheckAuthnProvider|nzFcgiDefineProvider|Type|UserFile|zDBDLoginToReferer|zDBDQuery|zDBDRedirectQuery|zDBMType|zSendForbiddenOnFailure)|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|Cache(?:DefaultExpire|DetailHeader|DirLength|DirLevels|Disable|Enable|File|Header|IgnoreCacheControl|IgnoreHeaders|IgnoreNoLastMod|IgnoreQueryString|IgnoreURLSessionIdentifiers|KeyBaseURL|LastModifiedFactor|Lock|LockMaxAge|LockPath|MaxExpire|MaxFileSize|MinExpire|MinFileSize|NegotiatedDocs|QuickHandler|ReadSize|ReadTime|Root|Socache(?:MaxSize|MaxTime|MinTime|ReadSize|ReadTime)?|StaleOnError|StoreExpired|StoreNoStore|StorePrivate)|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|Deflate(?:BufferSize|CompressionLevel|FilterNote|InflateLimitRequestBody|InflateRatio(?:Burst|Limit)|MemLevel|WindowSize)|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|Heartbeat(?:Address|Listen|MaxServers|Storage)|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|Index(?:HeadInsert|Ignore|IgnoreReset|Options|OrderDefault|StyleSheet)|InputSed|ISAPI(?:AppendLogToErrors|AppendLogToQuery|CacheFile|FakeAsync|LogNotSupported|ReadAheadBuffer)|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAP(?:CacheEntries|CacheTTL|ConnectionPoolTTL|ConnectionTimeout|LibraryDebug|OpCacheEntries|OpCacheTTL|ReferralHopLimit|Referrals|Retries|RetryDelay|SharedCacheFile|SharedCacheSize|Timeout|TrustedClientCert|TrustedGlobalCert|TrustedMode|VerifyServerCert)|Limit(?:InternalRecursion|Request(?:Body|Fields|FieldSize|Line)|XMLRequestBody)|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|Lua(?:Hook(?:AccessChecker|AuthChecker|CheckUserID|Fixups|InsertFilter|Log|MapToStorage|TranslateName|TypeChecker)|Inherit|InputFilter|MapHandler|OutputFilter|PackageCPath|PackagePath|QuickHandler|Root|Scope)|Max(?:ConnectionsPerChild|KeepAliveRequests|MemFree|RangeOverlaps|RangeReversals|Ranges|RequestWorkers|SpareServers|SpareThreads|Threads)|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|Proxy(?:AddHeaders|BadHeader|Block|Domain|ErrorOverride|ExpressDBMFile|ExpressDBMType|ExpressEnable|FtpDirCharset|FtpEscapeWildcards|FtpListOnWildcard|HTML(?:BufSize|CharsetOut|DocType|Enable|Events|Extended|Fixups|Interp|Links|Meta|StripComments|URLMap)|IOBufferSize|MaxForwards|Pass(?:Inherit|InterpolateEnv|Match|Reverse|ReverseCookieDomain|ReverseCookiePath)?|PreserveHost|ReceiveBufferSize|Remote|RemoteMatch|Requests|SCGIInternalRedirect|SCGISendfile|Set|SourceAddress|Status|Timeout|Via)|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIP(?:Header|InternalProxy|InternalProxyList|ProxiesHeader|TrustedProxy|TrustedProxyList)|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|Rewrite(?:Base|Cond|Engine|Map|Options|Rule)|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script(?:Alias|AliasMatch|InterpreterSource|Log|LogBuffer|LogLength|Sock)?|SecureListen|SeeRequestTail|SendBufferSize|Server(?:Admin|Alias|Limit|Name|Path|Root|Signature|Tokens)|Session(?:Cookie(?:Name|Name2|Remove)|Crypto(?:Cipher|Driver|Passphrase|PassphraseFile)|DBD(?:CookieName|CookieName2|CookieRemove|DeleteLabel|InsertLabel|PerUser|SelectLabel|UpdateLabel)|Env|Exclude|Header|Include|MaxAge)?|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSL(?:CACertificateFile|CACertificatePath|CADNRequestFile|CADNRequestPath|CARevocationCheck|CARevocationFile|CARevocationPath|CertificateChainFile|CertificateFile|CertificateKeyFile|CipherSuite|Compression|CryptoDevice|Engine|FIPS|HonorCipherOrder|InsecureRenegotiation|OCSP(?:DefaultResponder|Enable|OverrideResponder|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|UseRequestNonce)|OpenSSLConfCmd|Options|PassPhraseDialog|Protocol|Proxy(?:CACertificateFile|CACertificatePath|CARevocation(?:Check|File|Path)|CheckPeer(?:CN|Expire|Name)|CipherSuite|Engine|MachineCertificate(?:ChainFile|File|Path)|Protocol|Verify|VerifyDepth)|RandomSeed|RenegBufferSize|Require|RequireSSL|Session(?:Cache|CacheTimeout|TicketKeyFile|Tickets)|SRPUnknownUserSeed|SRPVerifierFile|Stapling(?:Cache|ErrorCacheTimeout|FakeTryLater|ForceURL|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|ReturnResponderErrors|StandardCacheTimeout)|StrictSNIVHostCheck|UserName|UseStapling|VerifyClient|VerifyDepth)|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|Virtual(?:DocumentRoot|ScriptAlias)(?:IP)?|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/im,
+      lookbehind: true,
+      alias: "property"
+    },
+    "directive-block": {
+      pattern: /<\/?\b(?:Auth[nz]ProviderAlias|Directory|DirectoryMatch|Else|ElseIf|Files|FilesMatch|If|IfDefine|IfModule|IfVersion|Limit|LimitExcept|Location|LocationMatch|Macro|Proxy|Require(?:All|Any|None)|VirtualHost)\b.*>/i,
+      inside: {
+        "directive-block": {
+          pattern: /^<\/?\w+/,
+          inside: {
+            punctuation: /^<\/?/
+          },
+          alias: "tag"
+        },
+        "directive-block-parameter": {
+          pattern: /.*[^>]/,
+          inside: {
+            punctuation: /:/,
+            string: {
+              pattern: /("|').*\1/,
+              inside: {
+                variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+              }
+            }
+          },
+          alias: "attr-value"
+        },
+        punctuation: />/
+      },
+      alias: "tag"
+    },
+    "directive-flags": {
+      pattern: /\[(?:[\w=],?)+\]/,
+      alias: "keyword"
+    },
+    string: {
+      pattern: /("|').*\1/,
+      inside: {
+        variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+      }
+    },
+    variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/,
+    regex: /\^?.*\$|\^.*\$?/
+  };
+}
+
+export {
+  apacheconf
+};

package/dist/chunk-DFNMTLAN.mjs

@@ -0,0 +1,112 @@
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markup-templating.js
+markupTemplating.displayName = "markup-templating";
+markupTemplating.aliases = [];
+function markupTemplating(Prism) {
+  Prism.register(markup);
+  (function(Prism2) {
+    function getPlaceholder(language, index) {
+      return "___" + language.toUpperCase() + index + "___";
+    }
+    Object.defineProperties(Prism2.languages["markup-templating"] = {}, {
+      buildPlaceholders: {
+        /**
+         * Tokenize all inline templating expressions matching `placeholderPattern`.
+         *
+         * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+         * `true` will be replaced.
+         *
+         * @param {object} env The environment of the `before-tokenize` hook.
+         * @param {string} language The language id.
+         * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+         * @param {(match: string) => boolean} [replaceFilter]
+         */
+        value: function(env, language, placeholderPattern, replaceFilter) {
+          if (env.language !== language) {
+            return;
+          }
+          var tokenStack = env.tokenStack = [];
+          env.code = env.code.replace(placeholderPattern, function(match) {
+            if (typeof replaceFilter === "function" && !replaceFilter(match)) {
+              return match;
+            }
+            var i = tokenStack.length;
+            var placeholder;
+            while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
+              ++i;
+            }
+            tokenStack[i] = match;
+            return placeholder;
+          });
+          env.grammar = Prism2.languages.markup;
+        }
+      },
+      tokenizePlaceholders: {
+        /**
+         * Replace placeholders with proper tokens after tokenizing.
+         *
+         * @param {object} env The environment of the `after-tokenize` hook.
+         * @param {string} language The language id.
+         */
+        value: function(env, language) {
+          if (env.language !== language || !env.tokenStack) {
+            return;
+          }
+          env.grammar = Prism2.languages[language];
+          var j = 0;
+          var keys = Object.keys(env.tokenStack);
+          function walkTokens(tokens) {
+            for (var i = 0; i < tokens.length; i++) {
+              if (j >= keys.length) {
+                break;
+              }
+              var token = tokens[i];
+              if (typeof token === "string" || token.content && typeof token.content === "string") {
+                var k = keys[j];
+                var t = env.tokenStack[k];
+                var s = typeof token === "string" ? token : token.content;
+                var placeholder = getPlaceholder(language, k);
+                var index = s.indexOf(placeholder);
+                if (index > -1) {
+                  ++j;
+                  var before = s.substring(0, index);
+                  var middle = new Prism2.Token(
+                    language,
+                    Prism2.tokenize(t, env.grammar),
+                    "language-" + language,
+                    t
+                  );
+                  var after = s.substring(index + placeholder.length);
+                  var replacement = [];
+                  if (before) {
+                    replacement.push.apply(replacement, walkTokens([before]));
+                  }
+                  replacement.push(middle);
+                  if (after) {
+                    replacement.push.apply(replacement, walkTokens([after]));
+                  }
+                  if (typeof token === "string") {
+                    tokens.splice.apply(tokens, [i, 1].concat(replacement));
+                  } else {
+                    token.content = replacement;
+                  }
+                }
+              } else if (token.content) {
+                walkTokens(token.content);
+              }
+            }
+            return tokens;
+          }
+          walkTokens(env.tokens);
+        }
+      }
+    });
+  })(Prism);
+}
+
+export {
+  markupTemplating
+};

package/dist/chunk-DGMXWFCL.mjs

@@ -0,0 +1,57 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/lolcode.js
+lolcode.displayName = "lolcode";
+lolcode.aliases = [];
+function lolcode(Prism) {
+  Prism.languages.lolcode = {
+    comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+    string: {
+      pattern: /"(?::.|[^":])*"/,
+      inside: {
+        variable: /:\{[^}]+\}/,
+        symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+      },
+      greedy: true
+    },
+    number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+    symbol: {
+      pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+      lookbehind: true,
+      inside: {
+        keyword: /A(?=\s)/
+      }
+    },
+    label: {
+      pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+      lookbehind: true,
+      alias: "string"
+    },
+    function: {
+      pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+      lookbehind: true
+    },
+    keyword: [
+      {
+        pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
+        lookbehind: true
+      },
+      /'Z(?=\s|,|$)/
+    ],
+    boolean: {
+      pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+      lookbehind: true
+    },
+    variable: {
+      pattern: /(^|\s)IT(?=\s|,|$)/,
+      lookbehind: true
+    },
+    operator: {
+      pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+      lookbehind: true
+    },
+    punctuation: /\.{3}|…|,|!/
+  };
+}
+
+export {
+  lolcode
+};

package/dist/chunk-DQTMP7BS.mjs

@@ -0,0 +1,59 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/q.js
+q.displayName = "q";
+q.aliases = [];
+function q(Prism) {
+  Prism.languages.q = {
+    string: /"(?:\\.|[^"\\\r\n])*"/,
+    comment: [
+      // From http://code.kx.com/wiki/Reference/Slash:
+      // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.
+      {
+        pattern: /([\t )\]}])\/.*/,
+        lookbehind: true,
+        greedy: true
+      },
+      // From http://code.kx.com/wiki/Reference/Slash:
+      // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.
+      // A / on a line by itself begins a multiline comment which is terminated by the next \ on a line by itself.
+      // If a / is not matched by a \, the multiline comment is unterminated and continues to end of file.
+      // The / and \ must be the first char on the line, but may be followed by any amount of whitespace.
+      {
+        pattern: /(^|\r?\n|\r)\/[\t ]*(?:(?:\r?\n|\r)(?:.*(?:\r?\n|\r(?!\n)))*?(?:\\(?=[\t ]*(?:\r?\n|\r))|$)|\S.*)/,
+        lookbehind: true,
+        greedy: true
+      },
+      // From http://code.kx.com/wiki/Reference/Slash:
+      // A \ on a line by itself with no preceding matching / will comment to end of file.
+      {
+        pattern: /^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
+        greedy: true
+      },
+      {
+        pattern: /^#!.+/m,
+        greedy: true
+      }
+    ],
+    symbol: /`(?::\S+|[\w.]*)/,
+    datetime: {
+      pattern: /0N[mdzuvt]|0W[dtz]|\d{4}\.\d\d(?:m|\.\d\d(?:T(?:\d\d(?::\d\d(?::\d\d(?:[.:]\d\d\d)?)?)?)?)?[dz]?)|\d\d:\d\d(?::\d\d(?:[.:]\d\d\d)?)?[uvt]?/,
+      alias: "number"
+    },
+    // The negative look-ahead prevents bad highlighting
+    // of verbs 0: and 1:
+    number: /\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\da-fA-F]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?[hjfeb]?)/,
+    keyword: /\\\w+\b|\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\b/,
+    adverb: {
+      pattern: /['\/\\]:?|\beach\b/,
+      alias: "function"
+    },
+    verb: {
+      pattern: /(?:\B\.\B|\b[01]:|<[=>]?|>=?|[:+\-*%,!?~=|$&#@^]):?|\b_\b:?/,
+      alias: "operator"
+    },
+    punctuation: /[(){}\[\];.]/
+  };
+}
+
+export {
+  q
+};