@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/ruby-BhyE9auN.js

@@ -0,0 +1,193 @@
+var ruby_1;
+var hasRequiredRuby;
+function requireRuby() {
+  if (hasRequiredRuby) return ruby_1;
+  hasRequiredRuby = 1;
+  ruby_1 = ruby;
+  ruby.displayName = "ruby";
+  ruby.aliases = ["rb"];
+  function ruby(Prism) {
+    (function(Prism2) {
+      Prism2.languages.ruby = Prism2.languages.extend("clike", {
+        comment: {
+          pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+          lookbehind: true,
+          inside: {
+            punctuation: /[.\\]/
+          }
+        },
+        keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+        operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+        punctuation: /[(){}[\].,;]/
+      });
+      Prism2.languages.insertBefore("ruby", "operator", {
+        "double-colon": {
+          pattern: /::/,
+          alias: "punctuation"
+        }
+      });
+      var interpolation = {
+        pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+        lookbehind: true,
+        inside: {
+          content: {
+            pattern: /^(#\{)[\s\S]+(?=\}$)/,
+            lookbehind: true,
+            inside: Prism2.languages.ruby
+          },
+          delimiter: {
+            pattern: /^#\{|\}$/,
+            alias: "punctuation"
+          }
+        }
+      };
+      delete Prism2.languages.ruby.function;
+      var percentExpression = "(?:" + [
+        /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+        /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+        /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+        /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+        /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+      ].join("|") + ")";
+      var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+      Prism2.languages.insertBefore("ruby", "keyword", {
+        "regex-literal": [
+          {
+            pattern: RegExp(
+              /%r/.source + percentExpression + /[egimnosux]{0,6}/.source
+            ),
+            greedy: true,
+            inside: {
+              interpolation,
+              regex: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              interpolation,
+              regex: /[\s\S]+/
+            }
+          }
+        ],
+        variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+        symbol: [
+          {
+            pattern: RegExp(/(^|[^:]):/.source + symbolName),
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: RegExp(
+              /([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source
+            ),
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        "method-definition": {
+          pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+          lookbehind: true,
+          inside: {
+            function: /\b\w+$/,
+            keyword: /^self\b/,
+            "class-name": /^\w+/,
+            punctuation: /\./
+          }
+        }
+      });
+      Prism2.languages.insertBefore("ruby", "string", {
+        "string-literal": [
+          {
+            pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
+            greedy: true,
+            inside: {
+              interpolation,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+            greedy: true,
+            inside: {
+              interpolation,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+            alias: "heredoc-string",
+            greedy: true,
+            inside: {
+              delimiter: {
+                pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+                inside: {
+                  symbol: /\b\w+/,
+                  punctuation: /^<<[-~]?/
+                }
+              },
+              interpolation,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+            alias: "heredoc-string",
+            greedy: true,
+            inside: {
+              delimiter: {
+                pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+                inside: {
+                  symbol: /\b\w+/,
+                  punctuation: /^<<[-~]?'|'$/
+                }
+              },
+              string: /[\s\S]+/
+            }
+          }
+        ],
+        "command-literal": [
+          {
+            pattern: RegExp(/%x/.source + percentExpression),
+            greedy: true,
+            inside: {
+              interpolation,
+              command: {
+                pattern: /[\s\S]+/,
+                alias: "string"
+              }
+            }
+          },
+          {
+            pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+            greedy: true,
+            inside: {
+              interpolation,
+              command: {
+                pattern: /[\s\S]+/,
+                alias: "string"
+              }
+            }
+          }
+        ]
+      });
+      delete Prism2.languages.ruby.string;
+      Prism2.languages.insertBefore("ruby", "number", {
+        builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+        constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+      });
+      Prism2.languages.rb = Prism2.languages.ruby;
+    })(Prism);
+  }
+  return ruby_1;
+}
+export {
+  requireRuby as r
+};
+//# sourceMappingURL=ruby-BhyE9auN.js.map

package/dist/ruby-BhyE9auN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby-BhyE9auN.js","sources":["../node_modules/refractor/lang/ruby.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ruby\nruby.displayName = 'ruby'\nruby.aliases = ['rb']\nfunction ruby(Prism) {\n  /**\n   * Original by Samuel Flores\n   *\n   * Adds the following new token classes:\n   *     constant, builtin, variable, symbol, regex\n   */\n  ;(function (Prism) {\n    Prism.languages.ruby = Prism.languages.extend('clike', {\n      comment: {\n        pattern: /#.*|^=begin\\s[\\s\\S]*?^=end/m,\n        greedy: true\n      },\n      'class-name': {\n        pattern:\n          /(\\b(?:class|module)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+|\\b[A-Z_]\\w*(?=\\s*\\.\\s*new\\b)/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[.\\\\]/\n        }\n      },\n      keyword:\n        /\\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\\b/,\n      operator:\n        /\\.{2,3}|&\\.|===|<?=>|[!=]?~|(?:&&|\\|\\||<<|>>|\\*\\*|[+\\-*/%<>!^&|=])=?|[?:]/,\n      punctuation: /[(){}[\\].,;]/\n    })\n    Prism.languages.insertBefore('ruby', 'operator', {\n      'double-colon': {\n        pattern: /::/,\n        alias: 'punctuation'\n      }\n    })\n    var interpolation = {\n      pattern: /((?:^|[^\\\\])(?:\\\\{2})*)#\\{(?:[^{}]|\\{[^{}]*\\})*\\}/,\n      lookbehind: true,\n      inside: {\n        content: {\n          pattern: /^(#\\{)[\\s\\S]+(?=\\}$)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        delimiter: {\n          pattern: /^#\\{|\\}$/,\n          alias: 'punctuation'\n        }\n      }\n    }\n    delete Prism.languages.ruby.function\n    var percentExpression =\n      '(?:' +\n      [\n        /([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source,\n        /\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)/.source,\n        /\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}/.source,\n        /\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]/.source,\n        /<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>/.source\n      ].join('|') +\n      ')'\n    var symbolName =\n      /(?:\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)/\n        .source\n    Prism.languages.insertBefore('ruby', 'keyword', {\n      'regex-literal': [\n        {\n          pattern: RegExp(\n            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source\n          ),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            regex: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern:\n            /(^|[^/])\\/(?!\\/)(?:\\[[^\\r\\n\\]]+\\]|\\\\.|[^[/\\\\\\r\\n])+\\/[egimnosux]{0,6}(?=\\s*(?:$|[\\r\\n,.;})#]))/,\n          lookbehind: true,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            regex: /[\\s\\S]+/\n          }\n        }\n      ],\n      variable: /[@$]+[a-zA-Z_]\\w*(?:[?!]|\\b)/,\n      symbol: [\n        {\n          pattern: RegExp(/(^|[^:]):/.source + symbolName),\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: RegExp(\n            /([\\r\\n{(,][ \\t]*)/.source + symbolName + /(?=:(?!:))/.source\n          ),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'method-definition': {\n        pattern: /(\\bdef\\s+)\\w+(?:\\s*\\.\\s*\\w+)?/,\n        lookbehind: true,\n        inside: {\n          function: /\\b\\w+$/,\n          keyword: /^self\\b/,\n          'class-name': /^\\w+/,\n          punctuation: /\\./\n        }\n      }\n    })\n    Prism.languages.insertBefore('ruby', 'string', {\n      'string-literal': [\n        {\n          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern:\n            /(\"|')(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\#\\r\\n])*\\1/,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern: /<<[-~]?([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n          alias: 'heredoc-string',\n          greedy: true,\n          inside: {\n            delimiter: {\n              pattern: /^<<[-~]?[a-z_]\\w*|\\b[a-z_]\\w*$/i,\n              inside: {\n                symbol: /\\b\\w+/,\n                punctuation: /^<<[-~]?/\n              }\n            },\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern: /<<[-~]?'([a-z_]\\w*)'[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n          alias: 'heredoc-string',\n          greedy: true,\n          inside: {\n            delimiter: {\n              pattern: /^<<[-~]?'[a-z_]\\w*'|\\b[a-z_]\\w*$/i,\n              inside: {\n                symbol: /\\b\\w+/,\n                punctuation: /^<<[-~]?'|'$/\n              }\n            },\n            string: /[\\s\\S]+/\n          }\n        }\n      ],\n      'command-literal': [\n        {\n          pattern: RegExp(/%x/.source + percentExpression),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            command: {\n              pattern: /[\\s\\S]+/,\n              alias: 'string'\n            }\n          }\n        },\n        {\n          pattern: /`(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|[^\\\\`#\\r\\n])*`/,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            command: {\n              pattern: /[\\s\\S]+/,\n              alias: 'string'\n            }\n          }\n        }\n      ]\n    })\n    delete Prism.languages.ruby.string\n    Prism.languages.insertBefore('ruby', 'number', {\n      builtin:\n        /\\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\\b/,\n      constant: /\\b[A-Z][A-Z0-9_]*(?:[?!]|\\b)/\n    })\n    Prism.languages.rb = Prism.languages.ruby\n  })(Prism)\n}\n"],"names":["Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/ruby-DU9_tFYO.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireRuby } from "./ruby-BhyE9auN.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 rubyExports = requireRuby();
+const ruby = /* @__PURE__ */ getDefaultExportFromCjs(rubyExports);
+const ruby$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: ruby
+}, [rubyExports]);
+export {
+  ruby$1 as r
+};
+//# sourceMappingURL=ruby-DU9_tFYO.js.map

package/dist/ruby-DU9_tFYO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby-DU9_tFYO.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/rust-DKq7JDkC.js

@@ -0,0 +1,163 @@
+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 rust_1;
+var hasRequiredRust;
+function requireRust() {
+  if (hasRequiredRust) return rust_1;
+  hasRequiredRust = 1;
+  rust_1 = rust2;
+  rust2.displayName = "rust";
+  rust2.aliases = [];
+  function rust2(Prism) {
+    (function(Prism2) {
+      var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
+      for (var i = 0; i < 2; i++) {
+        multilineComment = multilineComment.replace(/<self>/g, function() {
+          return multilineComment;
+        });
+      }
+      multilineComment = multilineComment.replace(/<self>/g, function() {
+        return /[^\s\S]/.source;
+      });
+      Prism2.languages.rust = {
+        comment: [
+          {
+            pattern: RegExp(/(^|[^\\])/.source + multilineComment),
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+          greedy: true
+        },
+        char: {
+          pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+          greedy: true
+        },
+        attribute: {
+          pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+          greedy: true,
+          alias: "attr-name",
+          inside: {
+            string: null
+            // see below
+          }
+        },
+        // Closure params should not be confused with bitwise OR |
+        "closure-params": {
+          pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            "closure-punctuation": {
+              pattern: /^\||\|$/,
+              alias: "punctuation"
+            },
+            rest: null
+            // see below
+          }
+        },
+        "lifetime-annotation": {
+          pattern: /'\w+/,
+          alias: "symbol"
+        },
+        "fragment-specifier": {
+          pattern: /(\$\w+:)[a-z]+/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        variable: /\$\w+/,
+        "function-definition": {
+          pattern: /(\bfn\s+)\w+/,
+          lookbehind: true,
+          alias: "function"
+        },
+        "type-definition": {
+          pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+          lookbehind: true,
+          alias: "class-name"
+        },
+        "module-declaration": [
+          {
+            pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+            lookbehind: true,
+            alias: "namespace"
+          },
+          {
+            pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+            lookbehind: true,
+            alias: "namespace",
+            inside: {
+              punctuation: /::/
+            }
+          }
+        ],
+        keyword: [
+          // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+          /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+          // primitives and str
+          // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+          /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
+        ],
+        // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+        // and Rust's naming conventions recommend snake_case anyway.
+        // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+        function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+        macro: {
+          pattern: /\b\w+!/,
+          alias: "property"
+        },
+        constant: /\b[A-Z_][A-Z_\d]+\b/,
+        "class-name": /\b[A-Z]\w*\b/,
+        namespace: {
+          pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+          inside: {
+            punctuation: /::/
+          }
+        },
+        // Hex, oct, bin, dec numbers with visual separators and type suffix
+        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+        boolean: /\b(?:false|true)\b/,
+        punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+        operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+      };
+      Prism2.languages.rust["closure-params"].inside.rest = Prism2.languages.rust;
+      Prism2.languages.rust["attribute"].inside["string"] = Prism2.languages.rust["string"];
+    })(Prism);
+  }
+  return rust_1;
+}
+var rustExports = requireRust();
+const rust = /* @__PURE__ */ getDefaultExportFromCjs(rustExports);
+const rust$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: rust
+}, [rustExports]);
+export {
+  rust$1 as r
+};
+//# sourceMappingURL=rust-DKq7JDkC.js.map

package/dist/rust-DKq7JDkC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-DKq7JDkC.js","sources":["../node_modules/refractor/lang/rust.js"],"sourcesContent":["'use strict'\n\nmodule.exports = rust\nrust.displayName = 'rust'\nrust.aliases = []\nfunction rust(Prism) {\n  ;(function (Prism) {\n    var multilineComment = /\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\//.source\n    for (var i = 0; i < 2; i++) {\n      // support 4 levels of nested comments\n      multilineComment = multilineComment.replace(/<self>/g, function () {\n        return multilineComment\n      })\n    }\n    multilineComment = multilineComment.replace(/<self>/g, function () {\n      return /[^\\s\\S]/.source\n    })\n    Prism.languages.rust = {\n      comment: [\n        {\n          pattern: RegExp(/(^|[^\\\\])/.source + multilineComment),\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: /(^|[^\\\\:])\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      string: {\n        pattern: /b?\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|b?r(#*)\"(?:[^\"]|\"(?!\\1))*\"\\1/,\n        greedy: true\n      },\n      char: {\n        pattern:\n          /b?'(?:\\\\(?:x[0-7][\\da-fA-F]|u\\{(?:[\\da-fA-F]_*){1,6}\\}|.)|[^\\\\\\r\\n\\t'])'/,\n        greedy: true\n      },\n      attribute: {\n        pattern: /#!?\\[(?:[^\\[\\]\"]|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")*\\]/,\n        greedy: true,\n        alias: 'attr-name',\n        inside: {\n          string: null // see below\n        }\n      },\n      // Closure params should not be confused with bitwise OR |\n      'closure-params': {\n        pattern: /([=(,:]\\s*|\\bmove\\s*)\\|[^|]*\\||\\|[^|]*\\|(?=\\s*(?:\\{|->))/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          'closure-punctuation': {\n            pattern: /^\\||\\|$/,\n            alias: 'punctuation'\n          },\n          rest: null // see below\n        }\n      },\n      'lifetime-annotation': {\n        pattern: /'\\w+/,\n        alias: 'symbol'\n      },\n      'fragment-specifier': {\n        pattern: /(\\$\\w+:)[a-z]+/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      variable: /\\$\\w+/,\n      'function-definition': {\n        pattern: /(\\bfn\\s+)\\w+/,\n        lookbehind: true,\n        alias: 'function'\n      },\n      'type-definition': {\n        pattern: /(\\b(?:enum|struct|trait|type|union)\\s+)\\w+/,\n        lookbehind: true,\n        alias: 'class-name'\n      },\n      'module-declaration': [\n        {\n          pattern: /(\\b(?:crate|mod)\\s+)[a-z][a-z_\\d]*/,\n          lookbehind: true,\n          alias: 'namespace'\n        },\n        {\n          pattern:\n            /(\\b(?:crate|self|super)\\s*)::\\s*[a-z][a-z_\\d]*\\b(?:\\s*::(?:\\s*[a-z][a-z_\\d]*\\s*::)*)?/,\n          lookbehind: true,\n          alias: 'namespace',\n          inside: {\n            punctuation: /::/\n          }\n        }\n      ],\n      keyword: [\n        // https://github.com/rust-lang/reference/blob/master/src/keywords.md\n        /\\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\\b/, // primitives and str\n        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html\n        /\\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\\b/\n      ],\n      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives\n      // and Rust's naming conventions recommend snake_case anyway.\n      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html\n      function: /\\b[a-z_]\\w*(?=\\s*(?:::\\s*<|\\())/,\n      macro: {\n        pattern: /\\b\\w+!/,\n        alias: 'property'\n      },\n      constant: /\\b[A-Z_][A-Z_\\d]+\\b/,\n      'class-name': /\\b[A-Z]\\w*\\b/,\n      namespace: {\n        pattern: /(?:\\b[a-z][a-z_\\d]*\\s*::\\s*)*\\b[a-z][a-z_\\d]*\\s*::(?!\\s*<)/,\n        inside: {\n          punctuation: /::/\n        }\n      },\n      // Hex, oct, bin, dec numbers with visual separators and type suffix\n      number:\n        /\\b(?:0x[\\dA-Fa-f](?:_?[\\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\\d(?:_?\\d)*)?\\.)?\\d(?:_?\\d)*(?:[Ee][+-]?\\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      punctuation: /->|\\.\\.=|\\.{1,3}|::|[{}[\\];(),:]/,\n      operator: /[-+*\\/%!^]=?|=[=>]?|&[&=]?|\\|[|=]?|<<?=?|>>?=?|[@?]/\n    }\n    Prism.languages.rust['closure-params'].inside.rest = Prism.languages.rust\n    Prism.languages.rust['attribute'].inside['string'] =\n      Prism.languages.rust['string']\n  })(Prism)\n}\n"],"names":["rust","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AACjB,UAAI,mBAAmB,8CAA8C;AACrE,eAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAE1B,2BAAmB,iBAAiB,QAAQ,WAAW,WAAY;AACjE,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AACI,yBAAmB,iBAAiB,QAAQ,WAAW,WAAY;AACjE,eAAO,UAAU;AAAA,MACvB,CAAK;AACD,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP;AAAA,YACE,SAAS,OAAO,YAAY,SAAS,gBAAgB;AAAA,YACrD,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,MAAM;AAAA,UACJ,SACE;AAAA,UACF,QAAQ;AAAA;QAEV,WAAW;AAAA,UACT,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,QAAQ;AAAA;AAAA;;;QAIZ,kBAAkB;AAAA,UAChB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,uBAAuB;AAAA,cACrB,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAM;AAAA;AAAA;;QAGV,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,OAAO;AAAA;QAET,sBAAsB;AAAA,UACpB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,UAAU;AAAA,QACV,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,mBAAmB;AAAA,UACjB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,sBAAsB;AAAA,UACpB;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,aAAa;AAAA;;;QAInB,SAAS;AAAA;AAAA,UAEP;AAAA;AAAA;AAAA,UAEA;AAAA;;;;QAKF,UAAU;AAAA,QACV,OAAO;AAAA,UACL,SAAS;AAAA,UACT,OAAO;AAAA;QAET,UAAU;AAAA,QACV,cAAc;AAAA,QACd,WAAW;AAAA,UACT,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA;;;QAIjB,QACE;AAAA,QACF,SAAS;AAAA,QACT,aAAa;AAAA,QACb,UAAU;AAAA;AAEZ,MAAAA,OAAM,UAAU,KAAK,gBAAgB,EAAE,OAAO,OAAOA,OAAM,UAAU;AACrE,MAAAA,OAAM,UAAU,KAAK,WAAW,EAAE,OAAO,QAAQ,IAC/CA,OAAM,UAAU,KAAK,QAAQ;AAAA,IACnC,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}