@fangzhongya/vue-archive 0.0.2 → 0.0.3-2

package/dist/es/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/languages/ruby.js

@@ -1,423 +0,0 @@
-var ruby_1;
-var hasRequiredRuby;
-function requireRuby() {
-  if (hasRequiredRuby)
-    return ruby_1;
-  hasRequiredRuby = 1;
-  function ruby(hljs) {
-    const regex = hljs.regex;
-    const RUBY_METHOD_RE = "([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)";
-    const CLASS_NAME_RE = regex.either(
-      /\b([A-Z]+[a-z0-9]+)+/,
-      // ends in caps
-      /\b([A-Z]+[a-z0-9]+)+[A-Z]+/
-    );
-    const CLASS_NAME_WITH_NAMESPACE_RE = regex.concat(CLASS_NAME_RE, /(::\w+)*/);
-    const PSEUDO_KWS = [
-      "include",
-      "extend",
-      "prepend",
-      "public",
-      "private",
-      "protected",
-      "raise",
-      "throw"
-    ];
-    const RUBY_KEYWORDS = {
-      "variable.constant": [
-        "__FILE__",
-        "__LINE__",
-        "__ENCODING__"
-      ],
-      "variable.language": [
-        "self",
-        "super"
-      ],
-      keyword: [
-        "alias",
-        "and",
-        "begin",
-        "BEGIN",
-        "break",
-        "case",
-        "class",
-        "defined",
-        "do",
-        "else",
-        "elsif",
-        "end",
-        "END",
-        "ensure",
-        "for",
-        "if",
-        "in",
-        "module",
-        "next",
-        "not",
-        "or",
-        "redo",
-        "require",
-        "rescue",
-        "retry",
-        "return",
-        "then",
-        "undef",
-        "unless",
-        "until",
-        "when",
-        "while",
-        "yield",
-        ...PSEUDO_KWS
-      ],
-      built_in: [
-        "proc",
-        "lambda",
-        "attr_accessor",
-        "attr_reader",
-        "attr_writer",
-        "define_method",
-        "private_constant",
-        "module_function"
-      ],
-      literal: [
-        "true",
-        "false",
-        "nil"
-      ]
-    };
-    const YARDOCTAG = {
-      className: "doctag",
-      begin: "@[A-Za-z]+"
-    };
-    const IRB_OBJECT = {
-      begin: "#<",
-      end: ">"
-    };
-    const COMMENT_MODES = [
-      hljs.COMMENT(
-        "#",
-        "$",
-        { contains: [YARDOCTAG] }
-      ),
-      hljs.COMMENT(
-        "^=begin",
-        "^=end",
-        {
-          contains: [YARDOCTAG],
-          relevance: 10
-        }
-      ),
-      hljs.COMMENT("^__END__", hljs.MATCH_NOTHING_RE)
-    ];
-    const SUBST = {
-      className: "subst",
-      begin: /#\{/,
-      end: /\}/,
-      keywords: RUBY_KEYWORDS
-    };
-    const STRING = {
-      className: "string",
-      contains: [
-        hljs.BACKSLASH_ESCAPE,
-        SUBST
-      ],
-      variants: [
-        {
-          begin: /'/,
-          end: /'/
-        },
-        {
-          begin: /"/,
-          end: /"/
-        },
-        {
-          begin: /`/,
-          end: /`/
-        },
-        {
-          begin: /%[qQwWx]?\(/,
-          end: /\)/
-        },
-        {
-          begin: /%[qQwWx]?\[/,
-          end: /\]/
-        },
-        {
-          begin: /%[qQwWx]?\{/,
-          end: /\}/
-        },
-        {
-          begin: /%[qQwWx]?</,
-          end: />/
-        },
-        {
-          begin: /%[qQwWx]?\//,
-          end: /\//
-        },
-        {
-          begin: /%[qQwWx]?%/,
-          end: /%/
-        },
-        {
-          begin: /%[qQwWx]?-/,
-          end: /-/
-        },
-        {
-          begin: /%[qQwWx]?\|/,
-          end: /\|/
-        },
-        // in the following expressions, \B in the beginning suppresses recognition of ?-sequences
-        // where ? is the last character of a preceding identifier, as in: `func?4`
-        { begin: /\B\?(\\\d{1,3})/ },
-        { begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/ },
-        { begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/ },
-        { begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/ },
-        { begin: /\B\?\\(c|C-)[\x20-\x7e]/ },
-        { begin: /\B\?\\?\S/ },
-        // heredocs
-        {
-          // this guard makes sure that we have an entire heredoc and not a false
-          // positive (auto-detect, etc.)
-          begin: regex.concat(
-            /<<[-~]?'?/,
-            regex.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)
-          ),
-          contains: [
-            hljs.END_SAME_AS_BEGIN({
-              begin: /(\w+)/,
-              end: /(\w+)/,
-              contains: [
-                hljs.BACKSLASH_ESCAPE,
-                SUBST
-              ]
-            })
-          ]
-        }
-      ]
-    };
-    const decimal = "[1-9](_?[0-9])*|0";
-    const digits = "[0-9](_?[0-9])*";
-    const NUMBER = {
-      className: "number",
-      relevance: 0,
-      variants: [
-        // decimal integer/float, optionally exponential or rational, optionally imaginary
-        { begin: `\\b(${decimal})(\\.(${digits}))?([eE][+-]?(${digits})|r)?i?\\b` },
-        // explicit decimal/binary/octal/hexadecimal integer,
-        // optionally rational and/or imaginary
-        { begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b" },
-        { begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b" },
-        { begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b" },
-        { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b" },
-        // 0-prefixed implicit octal integer, optionally rational and/or imaginary
-        { begin: "\\b0(_?[0-7])+r?i?\\b" }
-      ]
-    };
-    const PARAMS = {
-      variants: [
-        {
-          match: /\(\)/
-        },
-        {
-          className: "params",
-          begin: /\(/,
-          end: /(?=\))/,
-          excludeBegin: true,
-          endsParent: true,
-          keywords: RUBY_KEYWORDS
-        }
-      ]
-    };
-    const INCLUDE_EXTEND = {
-      match: [
-        /(include|extend)\s+/,
-        CLASS_NAME_WITH_NAMESPACE_RE
-      ],
-      scope: {
-        2: "title.class"
-      },
-      keywords: RUBY_KEYWORDS
-    };
-    const CLASS_DEFINITION = {
-      variants: [
-        {
-          match: [
-            /class\s+/,
-            CLASS_NAME_WITH_NAMESPACE_RE,
-            /\s+<\s+/,
-            CLASS_NAME_WITH_NAMESPACE_RE
-          ]
-        },
-        {
-          match: [
-            /\b(class|module)\s+/,
-            CLASS_NAME_WITH_NAMESPACE_RE
-          ]
-        }
-      ],
-      scope: {
-        2: "title.class",
-        4: "title.class.inherited"
-      },
-      keywords: RUBY_KEYWORDS
-    };
-    const UPPER_CASE_CONSTANT = {
-      relevance: 0,
-      match: /\b[A-Z][A-Z_0-9]+\b/,
-      className: "variable.constant"
-    };
-    const METHOD_DEFINITION = {
-      match: [
-        /def/,
-        /\s+/,
-        RUBY_METHOD_RE
-      ],
-      scope: {
-        1: "keyword",
-        3: "title.function"
-      },
-      contains: [
-        PARAMS
-      ]
-    };
-    const OBJECT_CREATION = {
-      relevance: 0,
-      match: [
-        CLASS_NAME_WITH_NAMESPACE_RE,
-        /\.new[. (]/
-      ],
-      scope: {
-        1: "title.class"
-      }
-    };
-    const CLASS_REFERENCE = {
-      relevance: 0,
-      match: CLASS_NAME_RE,
-      scope: "title.class"
-    };
-    const RUBY_DEFAULT_CONTAINS = [
-      STRING,
-      CLASS_DEFINITION,
-      INCLUDE_EXTEND,
-      OBJECT_CREATION,
-      UPPER_CASE_CONSTANT,
-      CLASS_REFERENCE,
-      METHOD_DEFINITION,
-      {
-        // swallow namespace qualifiers before symbols
-        begin: hljs.IDENT_RE + "::"
-      },
-      {
-        className: "symbol",
-        begin: hljs.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
-        relevance: 0
-      },
-      {
-        className: "symbol",
-        begin: ":(?!\\s)",
-        contains: [
-          STRING,
-          { begin: RUBY_METHOD_RE }
-        ],
-        relevance: 0
-      },
-      NUMBER,
-      {
-        // negative-look forward attempts to prevent false matches like:
-        // @ident@ or $ident$ that might indicate this is not ruby at all
-        className: "variable",
-        begin: `(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])`
-      },
-      {
-        className: "params",
-        begin: /\|/,
-        end: /\|/,
-        excludeBegin: true,
-        excludeEnd: true,
-        relevance: 0,
-        // this could be a lot of things (in other languages) other than params
-        keywords: RUBY_KEYWORDS
-      },
-      {
-        // regexp container
-        begin: "(" + hljs.RE_STARTERS_RE + "|unless)\\s*",
-        keywords: "unless",
-        contains: [
-          {
-            className: "regexp",
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              SUBST
-            ],
-            illegal: /\n/,
-            variants: [
-              {
-                begin: "/",
-                end: "/[a-z]*"
-              },
-              {
-                begin: /%r\{/,
-                end: /\}[a-z]*/
-              },
-              {
-                begin: "%r\\(",
-                end: "\\)[a-z]*"
-              },
-              {
-                begin: "%r!",
-                end: "![a-z]*"
-              },
-              {
-                begin: "%r\\[",
-                end: "\\][a-z]*"
-              }
-            ]
-          }
-        ].concat(IRB_OBJECT, COMMENT_MODES),
-        relevance: 0
-      }
-    ].concat(IRB_OBJECT, COMMENT_MODES);
-    SUBST.contains = RUBY_DEFAULT_CONTAINS;
-    PARAMS.contains = RUBY_DEFAULT_CONTAINS;
-    const SIMPLE_PROMPT = "[>?]>";
-    const DEFAULT_PROMPT = "[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]";
-    const RVM_PROMPT = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>";
-    const IRB_DEFAULT = [
-      {
-        begin: /^\s*=>/,
-        starts: {
-          end: "$",
-          contains: RUBY_DEFAULT_CONTAINS
-        }
-      },
-      {
-        className: "meta.prompt",
-        begin: "^(" + SIMPLE_PROMPT + "|" + DEFAULT_PROMPT + "|" + RVM_PROMPT + ")(?=[ ])",
-        starts: {
-          end: "$",
-          keywords: RUBY_KEYWORDS,
-          contains: RUBY_DEFAULT_CONTAINS
-        }
-      }
-    ];
-    COMMENT_MODES.unshift(IRB_OBJECT);
-    return {
-      name: "Ruby",
-      aliases: [
-        "rb",
-        "gemspec",
-        "podspec",
-        "thor",
-        "irb"
-      ],
-      keywords: RUBY_KEYWORDS,
-      illegal: /\/\*/,
-      contains: [hljs.SHEBANG({ binary: "ruby" })].concat(IRB_DEFAULT).concat(COMMENT_MODES).concat(RUBY_DEFAULT_CONTAINS)
-    };
-  }
-  ruby_1 = ruby;
-  return ruby_1;
-}
-export {
-  requireRuby as __require
-};

package/dist/es/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/languages/rust.js

@@ -1,305 +0,0 @@
-var rust_1;
-var hasRequiredRust;
-function requireRust() {
-  if (hasRequiredRust)
-    return rust_1;
-  hasRequiredRust = 1;
-  function rust(hljs) {
-    const regex = hljs.regex;
-    const FUNCTION_INVOKE = {
-      className: "title.function.invoke",
-      relevance: 0,
-      begin: regex.concat(
-        /\b/,
-        /(?!let\b)/,
-        hljs.IDENT_RE,
-        regex.lookahead(/\s*\(/)
-      )
-    };
-    const NUMBER_SUFFIX = "([ui](8|16|32|64|128|size)|f(32|64))?";
-    const KEYWORDS = [
-      "abstract",
-      "as",
-      "async",
-      "await",
-      "become",
-      "box",
-      "break",
-      "const",
-      "continue",
-      "crate",
-      "do",
-      "dyn",
-      "else",
-      "enum",
-      "extern",
-      "false",
-      "final",
-      "fn",
-      "for",
-      "if",
-      "impl",
-      "in",
-      "let",
-      "loop",
-      "macro",
-      "match",
-      "mod",
-      "move",
-      "mut",
-      "override",
-      "priv",
-      "pub",
-      "ref",
-      "return",
-      "self",
-      "Self",
-      "static",
-      "struct",
-      "super",
-      "trait",
-      "true",
-      "try",
-      "type",
-      "typeof",
-      "unsafe",
-      "unsized",
-      "use",
-      "virtual",
-      "where",
-      "while",
-      "yield"
-    ];
-    const LITERALS = [
-      "true",
-      "false",
-      "Some",
-      "None",
-      "Ok",
-      "Err"
-    ];
-    const BUILTINS = [
-      // functions
-      "drop ",
-      // traits
-      "Copy",
-      "Send",
-      "Sized",
-      "Sync",
-      "Drop",
-      "Fn",
-      "FnMut",
-      "FnOnce",
-      "ToOwned",
-      "Clone",
-      "Debug",
-      "PartialEq",
-      "PartialOrd",
-      "Eq",
-      "Ord",
-      "AsRef",
-      "AsMut",
-      "Into",
-      "From",
-      "Default",
-      "Iterator",
-      "Extend",
-      "IntoIterator",
-      "DoubleEndedIterator",
-      "ExactSizeIterator",
-      "SliceConcatExt",
-      "ToString",
-      // macros
-      "assert!",
-      "assert_eq!",
-      "bitflags!",
-      "bytes!",
-      "cfg!",
-      "col!",
-      "concat!",
-      "concat_idents!",
-      "debug_assert!",
-      "debug_assert_eq!",
-      "env!",
-      "panic!",
-      "file!",
-      "format!",
-      "format_args!",
-      "include_bytes!",
-      "include_str!",
-      "line!",
-      "local_data_key!",
-      "module_path!",
-      "option_env!",
-      "print!",
-      "println!",
-      "select!",
-      "stringify!",
-      "try!",
-      "unimplemented!",
-      "unreachable!",
-      "vec!",
-      "write!",
-      "writeln!",
-      "macro_rules!",
-      "assert_ne!",
-      "debug_assert_ne!"
-    ];
-    const TYPES = [
-      "i8",
-      "i16",
-      "i32",
-      "i64",
-      "i128",
-      "isize",
-      "u8",
-      "u16",
-      "u32",
-      "u64",
-      "u128",
-      "usize",
-      "f32",
-      "f64",
-      "str",
-      "char",
-      "bool",
-      "Box",
-      "Option",
-      "Result",
-      "String",
-      "Vec"
-    ];
-    return {
-      name: "Rust",
-      aliases: ["rs"],
-      keywords: {
-        $pattern: hljs.IDENT_RE + "!?",
-        type: TYPES,
-        keyword: KEYWORDS,
-        literal: LITERALS,
-        built_in: BUILTINS
-      },
-      illegal: "</",
-      contains: [
-        hljs.C_LINE_COMMENT_MODE,
-        hljs.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
-        hljs.inherit(hljs.QUOTE_STRING_MODE, {
-          begin: /b?"/,
-          illegal: null
-        }),
-        {
-          className: "string",
-          variants: [
-            { begin: /b?r(#*)"(.|\n)*?"\1(?!#)/ },
-            { begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/ }
-          ]
-        },
-        {
-          className: "symbol",
-          begin: /'[a-zA-Z_][a-zA-Z0-9_]*/
-        },
-        {
-          className: "number",
-          variants: [
-            { begin: "\\b0b([01_]+)" + NUMBER_SUFFIX },
-            { begin: "\\b0o([0-7_]+)" + NUMBER_SUFFIX },
-            { begin: "\\b0x([A-Fa-f0-9_]+)" + NUMBER_SUFFIX },
-            { begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)" + NUMBER_SUFFIX }
-          ],
-          relevance: 0
-        },
-        {
-          begin: [
-            /fn/,
-            /\s+/,
-            hljs.UNDERSCORE_IDENT_RE
-          ],
-          className: {
-            1: "keyword",
-            3: "title.function"
-          }
-        },
-        {
-          className: "meta",
-          begin: "#!?\\[",
-          end: "\\]",
-          contains: [
-            {
-              className: "string",
-              begin: /"/,
-              end: /"/
-            }
-          ]
-        },
-        {
-          begin: [
-            /let/,
-            /\s+/,
-            /(?:mut\s+)?/,
-            hljs.UNDERSCORE_IDENT_RE
-          ],
-          className: {
-            1: "keyword",
-            3: "keyword",
-            4: "variable"
-          }
-        },
-        // must come before impl/for rule later
-        {
-          begin: [
-            /for/,
-            /\s+/,
-            hljs.UNDERSCORE_IDENT_RE,
-            /\s+/,
-            /in/
-          ],
-          className: {
-            1: "keyword",
-            3: "variable",
-            5: "keyword"
-          }
-        },
-        {
-          begin: [
-            /type/,
-            /\s+/,
-            hljs.UNDERSCORE_IDENT_RE
-          ],
-          className: {
-            1: "keyword",
-            3: "title.class"
-          }
-        },
-        {
-          begin: [
-            /(?:trait|enum|struct|union|impl|for)/,
-            /\s+/,
-            hljs.UNDERSCORE_IDENT_RE
-          ],
-          className: {
-            1: "keyword",
-            3: "title.class"
-          }
-        },
-        {
-          begin: hljs.IDENT_RE + "::",
-          keywords: {
-            keyword: "Self",
-            built_in: BUILTINS,
-            type: TYPES
-          }
-        },
-        {
-          className: "punctuation",
-          begin: "->"
-        },
-        FUNCTION_INVOKE
-      ]
-    };
-  }
-  rust_1 = rust;
-  return rust_1;
-}
-export {
-  requireRust as __require
-};