@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/haskell-JxV6F6a2.js

@@ -0,0 +1,81 @@
+var haskell_1;
+var hasRequiredHaskell;
+function requireHaskell() {
+  if (hasRequiredHaskell) return haskell_1;
+  hasRequiredHaskell = 1;
+  haskell_1 = haskell;
+  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;
+  }
+  return haskell_1;
+}
+export {
+  requireHaskell as r
+};
+//# sourceMappingURL=haskell-JxV6F6a2.js.map

package/dist/haskell-JxV6F6a2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haskell-JxV6F6a2.js","sources":["../node_modules/refractor/lang/haskell.js"],"sourcesContent":["'use strict'\n\nmodule.exports = haskell\nhaskell.displayName = 'haskell'\nhaskell.aliases = ['hs']\nfunction haskell(Prism) {\n  Prism.languages.haskell = {\n    comment: {\n      pattern:\n        /(^|[^-!#$%*+=?&@|~.:<>^\\\\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\\\\/].*|$)|\\{-[\\s\\S]*?-\\})/m,\n      lookbehind: true\n    },\n    char: {\n      pattern:\n        /'(?:[^\\\\']|\\\\(?:[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]+))'/,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\(?:\\S|\\s+\\\\))*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b/,\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+(?:qualified\\s+)?(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*(?:\\s+as\\s+(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*)?(?:\\s+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import|qualified)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\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/,\n    // decimal integers and floating point numbers | octal integers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0o[0-7]+|0x[0-9a-f]+)\\b/i,\n    operator: [\n      {\n        // infix operator\n        pattern: /`(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*`/,\n        greedy: true\n      },\n      {\n        // function composition\n        pattern: /(\\s)\\.(?=\\s)/,\n        lookbehind: true\n      }, // Most of this is needed because of the meaning of a single '.'.\n      // If it stands alone freely, it is the function composition.\n      // It may also be a separator between a module name and an identifier => no\n      // operator. If it comes together with other special characters it is an\n      // operator too.\n      //\n      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\\\\/]+/ without /\\./.\n      /[-!#$%*+=?&@|~:<>^\\\\\\/][-!#$%*+=?&@|~.:<>^\\\\\\/]*|\\.[-!#$%*+=?&@|~.:<>^\\\\\\/]+/\n    ],\n    // In Haskell, nearly everything is a variable, do not highlight these.\n    hvariable: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    constant: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[A-Z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.hs = Prism.languages.haskell\n}\n"],"names":[],"mappings":";;;;;AAEA,cAAiB;AACjB,UAAQ,cAAc;AACtB,UAAQ,UAAU,CAAC,IAAI;AACvB,WAAS,QAAQ,OAAO;AACtB,UAAM,UAAU,UAAU;AAAA,MACxB,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA;MAEd,MAAM;AAAA,QACJ,SACE;AAAA,QACF,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,oBAAoB;AAAA;AAAA;AAAA;AAAA,QAIlB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,aAAa;AAAA;;;MAIjB,SACE;AAAA;AAAA,MAEF,QAAQ;AAAA,MACR,UAAU;AAAA,QACR;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;;;;;;;QAQd;AAAA;;MAGF,WAAW;AAAA,QACT,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,aAAa;AAAA;AAEf,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;","x_google_ignoreList":[0]}

package/dist/haxe-BQPNsaSA.js

@@ -0,0 +1,117 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var haxe_1;
+var hasRequiredHaxe;
+function requireHaxe() {
+  if (hasRequiredHaxe) return haxe_1;
+  hasRequiredHaxe = 1;
+  haxe_1 = haxe2;
+  haxe2.displayName = "haxe";
+  haxe2.aliases = [];
+  function haxe2(Prism) {
+    Prism.languages.haxe = Prism.languages.extend("clike", {
+      string: {
+        // Strings can be multi-line
+        pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+        greedy: true
+      },
+      "class-name": [
+        {
+          pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+          lookbehind: true
+        },
+        // based on naming convention
+        /\b[A-Z]\w*/
+      ],
+      // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+      keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+        greedy: true
+      },
+      operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+    });
+    Prism.languages.insertBefore("haxe", "string", {
+      "string-interpolation": {
+        pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
+            lookbehind: true,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{?|\}$/,
+                alias: "punctuation"
+              },
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: Prism.languages.haxe
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    });
+    Prism.languages.insertBefore("haxe", "class-name", {
+      regex: {
+        pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+        greedy: true,
+        inside: {
+          "regex-flags": /\b[a-z]+$/,
+          "regex-source": {
+            pattern: /^(~\/)[\s\S]+(?=\/$)/,
+            lookbehind: true,
+            alias: "language-regex",
+            inside: Prism.languages.regex
+          },
+          "regex-delimiter": /^~\/|\/$/
+        }
+      }
+    });
+    Prism.languages.insertBefore("haxe", "keyword", {
+      preprocessor: {
+        pattern: /#(?:else|elseif|end|if)\b.*/,
+        alias: "property"
+      },
+      metadata: {
+        pattern: /@:?[\w.]+/,
+        alias: "symbol"
+      },
+      reification: {
+        pattern: /\$(?:\w+|(?=\{))/,
+        alias: "important"
+      }
+    });
+  }
+  return haxe_1;
+}
+var haxeExports = requireHaxe();
+const haxe = /* @__PURE__ */ getDefaultExportFromCjs(haxeExports);
+const haxe$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: haxe
+}, [haxeExports]);
+export {
+  haxe$1 as h
+};
+//# sourceMappingURL=haxe-BQPNsaSA.js.map

package/dist/haxe-BQPNsaSA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haxe-BQPNsaSA.js","sources":["../node_modules/refractor/lang/haxe.js"],"sourcesContent":["'use strict'\n\nmodule.exports = haxe\nhaxe.displayName = 'haxe'\nhaxe.aliases = []\nfunction haxe(Prism) {\n  Prism.languages.haxe = Prism.languages.extend('clike', {\n    string: {\n      // Strings can be multi-line\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    'class-name': [\n      {\n        pattern:\n          /(\\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\\s+)[A-Z_]\\w*/,\n        lookbehind: true\n      }, // based on naming convention\n      /\\b[A-Z]\\w*/\n    ],\n    // The final look-ahead prevents highlighting of keywords if expressions such as \"haxe.macro.Expr\"\n    keyword:\n      /\\bthis\\b|\\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\\.)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:<[^<>]*>\\s*)?\\()/i,\n      greedy: true\n    },\n    operator: /\\.{3}|\\+\\+|--|&&|\\|\\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/\n  })\n  Prism.languages.insertBefore('haxe', 'string', {\n    'string-interpolation': {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^\\\\])\\$(?:\\w+|\\{[^{}]+\\})/,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{?|\\}$/,\n              alias: 'punctuation'\n            },\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.haxe\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'class-name', {\n    regex: {\n      pattern: /~\\/(?:[^\\/\\\\\\r\\n]|\\\\.)+\\/[a-z]*/,\n      greedy: true,\n      inside: {\n        'regex-flags': /\\b[a-z]+$/,\n        'regex-source': {\n          pattern: /^(~\\/)[\\s\\S]+(?=\\/$)/,\n          lookbehind: true,\n          alias: 'language-regex',\n          inside: Prism.languages.regex\n        },\n        'regex-delimiter': /^~\\/|\\/$/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'keyword', {\n    preprocessor: {\n      pattern: /#(?:else|elseif|end|if)\\b.*/,\n      alias: 'property'\n    },\n    metadata: {\n      pattern: /@:?[\\w.]+/,\n      alias: 'symbol'\n    },\n    reification: {\n      pattern: /\\$(?:\\w+|(?=\\{))/,\n      alias: 'important'\n    }\n  })\n}\n"],"names":["haxe"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,SAAS;AAAA,MACrD,QAAQ;AAAA;AAAA,QAEN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,cAAc;AAAA,QACZ;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;;QAEd;AAAA;;MAGF,SACE;AAAA,MACF,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,UAAU;AAAA,MAC7C,wBAAwB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,6BAA6B;AAAA,gBAC3B,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,YAAY;AAAA,gBACV,SAAS;AAAA,gBACT,QAAQ,MAAM,UAAU;AAAA;;;UAI9B,QAAQ;AAAA;;IAGhB,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,cAAc;AAAA,MACjD,OAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA,UACf,gBAAgB;AAAA,YACd,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA,YACP,QAAQ,MAAM,UAAU;AAAA;UAE1B,mBAAmB;AAAA;;IAG3B,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,WAAW;AAAA,MAC9C,cAAc;AAAA,QACZ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,QACR,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA,QACX,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/hcl-BFcSNAbz.js

@@ -0,0 +1,102 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var hcl_1;
+var hasRequiredHcl;
+function requireHcl() {
+  if (hasRequiredHcl) return hcl_1;
+  hasRequiredHcl = 1;
+  hcl_1 = hcl2;
+  hcl2.displayName = "hcl";
+  hcl2.aliases = [];
+  function hcl2(Prism) {
+    Prism.languages.hcl = {
+      comment: /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
+      heredoc: {
+        pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
+        greedy: true,
+        alias: "string"
+      },
+      keyword: [
+        {
+          pattern: /(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,
+          inside: {
+            type: {
+              pattern: /(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,
+              lookbehind: true,
+              alias: "variable"
+            }
+          }
+        },
+        {
+          pattern: /(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,
+          inside: {
+            type: {
+              pattern: /(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
+              lookbehind: true,
+              alias: "variable"
+            }
+          }
+        },
+        /[\w-]+(?=\s+\{)/
+      ],
+      property: [/[-\w\.]+(?=\s*=(?!=))/, /"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/],
+      string: {
+        pattern: /"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,
+            lookbehind: true,
+            inside: {
+              type: {
+                pattern: /(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,
+                lookbehind: true,
+                alias: "variable"
+              },
+              keyword: /\b(?:count|data|local|module|path|self|terraform|var)\b/i,
+              function: /\w+(?=\()/,
+              string: {
+                pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+                greedy: true
+              },
+              number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+              punctuation: /[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/
+            }
+          }
+        }
+      },
+      number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+      boolean: /\b(?:false|true)\b/i,
+      punctuation: /[=\[\]{}]/
+    };
+  }
+  return hcl_1;
+}
+var hclExports = requireHcl();
+const hcl = /* @__PURE__ */ getDefaultExportFromCjs(hclExports);
+const hcl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: hcl
+}, [hclExports]);
+export {
+  hcl$1 as h
+};
+//# sourceMappingURL=hcl-BFcSNAbz.js.map

package/dist/hcl-BFcSNAbz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl-BFcSNAbz.js","sources":["../node_modules/refractor/lang/hcl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hcl\nhcl.displayName = 'hcl'\nhcl.aliases = []\nfunction hcl(Prism) {\n  Prism.languages.hcl = {\n    comment: /(?:\\/\\/|#).*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    heredoc: {\n      pattern: /<<-?(\\w+\\b)[\\s\\S]*?^[ \\t]*\\1/m,\n      greedy: true,\n      alias: 'string'\n    },\n    keyword: [\n      {\n        pattern:\n          /(?:data|resource)\\s+(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")(?=\\s+\"[\\w-]+\"\\s+\\{)/i,\n        inside: {\n          type: {\n            pattern: /(resource|data|\\s+)(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      {\n        pattern:\n          /(?:backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+(?=\\{)/i,\n        inside: {\n          type: {\n            pattern:\n              /(backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      /[\\w-]+(?=\\s+\\{)/\n    ],\n    property: [/[-\\w\\.]+(?=\\s*=(?!=))/, /\"(?:\\\\[\\s\\S]|[^\\\\\"])+\"(?=\\s*[:=])/],\n    string: {\n      pattern:\n        /\"(?:[^\\\\$\"]|\\\\[\\s\\S]|\\$(?:(?=\")|\\$+(?!\\$)|[^\"${])|\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\})*\"/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^$])\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\}/,\n          lookbehind: true,\n          inside: {\n            type: {\n              pattern:\n                /(\\b(?:count|data|local|module|path|self|terraform|var)\\b\\.)[\\w\\*]+/i,\n              lookbehind: true,\n              alias: 'variable'\n            },\n            keyword: /\\b(?:count|data|local|module|path|self|terraform|var)\\b/i,\n            function: /\\w+(?=\\()/,\n            string: {\n              pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n              greedy: true\n            },\n            number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n            punctuation: /[!\\$#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~?:]/\n          }\n        }\n      }\n    },\n    number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    punctuation: /[=\\[\\]{}]/\n  }\n}\n"],"names":["hcl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,MACT,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,SAAS;AAAA,QACP;AAAA,UACE,SACE;AAAA,UACF,QAAQ;AAAA,YACN,MAAM;AAAA,cACJ,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;;;QAIb;AAAA,UACE,SACE;AAAA,UACF,QAAQ;AAAA,YACN,MAAM;AAAA,cACJ,SACE;AAAA,cACF,YAAY;AAAA,cACZ,OAAO;AAAA;;;QAIb;AAAA;MAEF,UAAU,CAAC,yBAAyB,mCAAmC;AAAA,MACvE,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,MAAM;AAAA,gBACJ,SACE;AAAA,gBACF,YAAY;AAAA,gBACZ,OAAO;AAAA;cAET,SAAS;AAAA,cACT,UAAU;AAAA,cACV,QAAQ;AAAA,gBACN,SAAS;AAAA,gBACT,QAAQ;AAAA;cAEV,QAAQ;AAAA,cACR,aAAa;AAAA;;;;MAKrB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/hlsl-CWAVevgo.js

@@ -0,0 +1,64 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireC } from "./c-BM9zQzkN.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var hlsl_1;
+var hasRequiredHlsl;
+function requireHlsl() {
+  if (hasRequiredHlsl) return hlsl_1;
+  hasRequiredHlsl = 1;
+  var refractorC = requireC();
+  hlsl_1 = hlsl2;
+  hlsl2.displayName = "hlsl";
+  hlsl2.aliases = [];
+  function hlsl2(Prism) {
+    Prism.register(refractorC);
+    Prism.languages.hlsl = Prism.languages.extend("c", {
+      // Regarding keywords and class names:
+      // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words
+      "class-name": [
+        Prism.languages.c["class-name"],
+        /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/
+      ],
+      keyword: [
+        // HLSL keyword
+        /\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,
+        // scalar, vector, and matrix types
+        /\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/
+      ],
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers
+      number: /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
+      boolean: /\b(?:false|true)\b/
+    });
+  }
+  return hlsl_1;
+}
+var hlslExports = requireHlsl();
+const hlsl = /* @__PURE__ */ getDefaultExportFromCjs(hlslExports);
+const hlsl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: hlsl
+}, [hlslExports]);
+export {
+  hlsl$1 as h
+};
+//# sourceMappingURL=hlsl-CWAVevgo.js.map

package/dist/hlsl-CWAVevgo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hlsl-CWAVevgo.js","sources":["../node_modules/refractor/lang/hlsl.js"],"sourcesContent":["'use strict'\nvar refractorC = require('./c.js')\nmodule.exports = hlsl\nhlsl.displayName = 'hlsl'\nhlsl.aliases = []\nfunction hlsl(Prism) {\n  Prism.register(refractorC)\n  Prism.languages.hlsl = Prism.languages.extend('c', {\n    // Regarding keywords and class names:\n    // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words\n    'class-name': [\n      Prism.languages.c['class-name'],\n      /\\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\\b/\n    ],\n    keyword: [\n      // HLSL keyword\n      /\\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\\b/, // scalar, vector, and matrix types\n      /\\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\\b/\n    ],\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers\n    number:\n      /(?:(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?|\\b0x[\\da-fA-F]+)[fFhHlLuU]?\\b/,\n    boolean: /\\b(?:false|true)\\b/\n  })\n}\n"],"names":["require$$0","hlsl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,aAAaA,SAAA;AACjB,WAAiBC;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,SAAS,UAAU;AACzB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA,MAKjD,cAAc;AAAA,QACZ,MAAM,UAAU,EAAE,YAAY;AAAA,QAC9B;AAAA;MAEF,SAAS;AAAA;AAAA,QAEP;AAAA;AAAA,QACA;AAAA;;MAGF,QACE;AAAA,MACF,SAAS;AAAA,IACb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/hoon-DD1GwSyQ.js

@@ -0,0 +1,56 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var hoon_1;
+var hasRequiredHoon;
+function requireHoon() {
+  if (hasRequiredHoon) return hoon_1;
+  hasRequiredHoon = 1;
+  hoon_1 = hoon2;
+  hoon2.displayName = "hoon";
+  hoon2.aliases = [];
+  function hoon2(Prism) {
+    Prism.languages.hoon = {
+      comment: {
+        pattern: /::.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: true
+      },
+      constant: /%(?:\.[ny]|[\w-]+)/,
+      "class-name": /@(?:[a-z0-9-]*[a-z0-9])?|\*/i,
+      function: /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,
+      keyword: /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/
+    };
+  }
+  return hoon_1;
+}
+var hoonExports = requireHoon();
+const hoon = /* @__PURE__ */ getDefaultExportFromCjs(hoonExports);
+const hoon$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: hoon
+}, [hoonExports]);
+export {
+  hoon$1 as h
+};
+//# sourceMappingURL=hoon-DD1GwSyQ.js.map

package/dist/hoon-DD1GwSyQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hoon-DD1GwSyQ.js","sources":["../node_modules/refractor/lang/hoon.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hoon\nhoon.displayName = 'hoon'\nhoon.aliases = []\nfunction hoon(Prism) {\n  Prism.languages.hoon = {\n    comment: {\n      pattern: /::.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"[^\"]*\"|'[^']*'/,\n      greedy: true\n    },\n    constant: /%(?:\\.[ny]|[\\w-]+)/,\n    'class-name': /@(?:[a-z0-9-]*[a-z0-9])?|\\*/i,\n    function: /(?:\\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,\n    keyword:\n      /\\.[\\^\\+\\*=\\?]|![><:\\.=\\?!]|=[>|:,\\.\\-\\^<+;/~\\*\\?]|\\?[>|:\\.\\-\\^<\\+&~=@!]|\\|[\\$_%:\\.\\-\\^~\\*=@\\?]|\\+[|\\$\\+\\*]|:[_\\-\\^\\+~\\*]|%[_:\\.\\-\\^\\+~\\*=]|\\^[|:\\.\\-\\+&~\\*=\\?]|\\$[|_%:<>\\-\\^&~@=\\?]|;[:<\\+;\\/~\\*=]|~[>|\\$_%<\\+\\/&=\\?!]|--|==/\n  }\n}\n"],"names":["hoon"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,cAAc;AAAA,MACd,UAAU;AAAA,MACV,SACE;AAAA;EAEN;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/hpkp-BXgITrts.js

@@ -0,0 +1,50 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var hpkp_1;
+var hasRequiredHpkp;
+function requireHpkp() {
+  if (hasRequiredHpkp) return hpkp_1;
+  hasRequiredHpkp = 1;
+  hpkp_1 = hpkp2;
+  hpkp2.displayName = "hpkp";
+  hpkp2.aliases = [];
+  function hpkp2(Prism) {
+    Prism.languages.hpkp = {
+      directive: {
+        pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
+        alias: "property"
+      },
+      operator: /=/,
+      punctuation: /;/
+    };
+  }
+  return hpkp_1;
+}
+var hpkpExports = requireHpkp();
+const hpkp = /* @__PURE__ */ getDefaultExportFromCjs(hpkpExports);
+const hpkp$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: hpkp
+}, [hpkpExports]);
+export {
+  hpkp$1 as h
+};
+//# sourceMappingURL=hpkp-BXgITrts.js.map

package/dist/hpkp-BXgITrts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hpkp-BXgITrts.js","sources":["../node_modules/refractor/lang/hpkp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hpkp\nhpkp.displayName = 'hpkp'\nhpkp.aliases = []\nfunction hpkp(Prism) {\n  /**\n   * Original by Scott Helme.\n   *\n   * Reference: https://scotthelme.co.uk/hpkp-cheat-sheet/\n   */\n  Prism.languages.hpkp = {\n    directive: {\n      pattern:\n        /\\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\\s;=]|$)/i,\n      alias: 'property'\n    },\n    operator: /=/,\n    punctuation: /;/\n  }\n}\n"],"names":["hpkp"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAMnB,UAAM,UAAU,OAAO;AAAA,MACrB,WAAW;AAAA,QACT,SACE;AAAA,QACF,OAAO;AAAA;MAET,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/hsts-CvhvgkPH.js

@@ -0,0 +1,50 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var hsts_1;
+var hasRequiredHsts;
+function requireHsts() {
+  if (hasRequiredHsts) return hsts_1;
+  hasRequiredHsts = 1;
+  hsts_1 = hsts2;
+  hsts2.displayName = "hsts";
+  hsts2.aliases = [];
+  function hsts2(Prism) {
+    Prism.languages.hsts = {
+      directive: {
+        pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,
+        alias: "property"
+      },
+      operator: /=/,
+      punctuation: /;/
+    };
+  }
+  return hsts_1;
+}
+var hstsExports = requireHsts();
+const hsts = /* @__PURE__ */ getDefaultExportFromCjs(hstsExports);
+const hsts$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: hsts
+}, [hstsExports]);
+export {
+  hsts$1 as h
+};
+//# sourceMappingURL=hsts-CvhvgkPH.js.map

package/dist/hsts-CvhvgkPH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hsts-CvhvgkPH.js","sources":["../node_modules/refractor/lang/hsts.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hsts\nhsts.displayName = 'hsts'\nhsts.aliases = []\nfunction hsts(Prism) {\n  /**\n   * Original by Scott Helme.\n   *\n   * Reference: https://scotthelme.co.uk/hsts-cheat-sheet/\n   */\n  Prism.languages.hsts = {\n    directive: {\n      pattern: /\\b(?:includeSubDomains|max-age|preload)(?=[\\s;=]|$)/i,\n      alias: 'property'\n    },\n    operator: /=/,\n    punctuation: /;/\n  }\n}\n"],"names":["hsts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAMnB,UAAM,UAAU,OAAO;AAAA,MACrB,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}