@oneflowui/ui 0.5.0 → 0.5.2

package/dist/node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/markdown.js

@@ -1,216 +0,0 @@
-function v(s) {
-  const g = s.regex, t = {
-    begin: /<\/?[A-Za-z_]/,
-    end: ">",
-    subLanguage: "xml",
-    relevance: 0
-  }, l = {
-    begin: "^[-\\*]{3,}",
-    end: "$"
-  }, d = {
-    className: "code",
-    variants: [
-      // TODO: fix to allow these to work with sublanguage also
-      { begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*" },
-      { begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*" },
-      // needed to allow markdown as a sublanguage to work
-      {
-        begin: "```",
-        end: "```+[ ]*$"
-      },
-      {
-        begin: "~~~",
-        end: "~~~+[ ]*$"
-      },
-      { begin: "`.+?`" },
-      {
-        begin: "(?=^( {4}|\\t))",
-        // use contains to gobble up multiple lines to allow the block to be whatever size
-        // but only have a single open/close tag vs one per line
-        contains: [
-          {
-            begin: "^( {4}|\\t)",
-            end: "(\\n)$"
-          }
-        ],
-        relevance: 0
-      }
-    ]
-  }, b = {
-    className: "bullet",
-    begin: "^[ 	]*([*+-]|(\\d+\\.))(?=\\s+)",
-    end: "\\s+",
-    excludeEnd: !0
-  }, u = {
-    begin: /^\[[^\n]+\]:/,
-    returnBegin: !0,
-    contains: [
-      {
-        className: "symbol",
-        begin: /\[/,
-        end: /\]/,
-        excludeBegin: !0,
-        excludeEnd: !0
-      },
-      {
-        className: "link",
-        begin: /:\s*/,
-        end: /$/,
-        excludeBegin: !0
-      }
-    ]
-  }, E = /[A-Za-z][A-Za-z0-9+.-]*/, c = {
-    variants: [
-      // too much like nested array access in so many languages
-      // to have any real relevance
-      {
-        begin: /\[.+?\]\[.*?\]/,
-        relevance: 0
-      },
-      // popular internet URLs
-      {
-        begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
-        relevance: 2
-      },
-      {
-        begin: g.concat(/\[.+?\]\(/, E, /:\/\/.*?\)/),
-        relevance: 2
-      },
-      // relative urls
-      {
-        begin: /\[.+?\]\([./?&#].*?\)/,
-        relevance: 1
-      },
-      // whatever else, lower relevance (might not be a link at all)
-      {
-        begin: /\[.*?\]\(.*?\)/,
-        relevance: 0
-      }
-    ],
-    returnBegin: !0,
-    contains: [
-      {
-        // empty strings for alt or link text
-        match: /\[(?=\])/
-      },
-      {
-        className: "string",
-        relevance: 0,
-        begin: "\\[",
-        end: "\\]",
-        excludeBegin: !0,
-        returnEnd: !0
-      },
-      {
-        className: "link",
-        relevance: 0,
-        begin: "\\]\\(",
-        end: "\\)",
-        excludeBegin: !0,
-        excludeEnd: !0
-      },
-      {
-        className: "symbol",
-        relevance: 0,
-        begin: "\\]\\[",
-        end: "\\]",
-        excludeBegin: !0,
-        excludeEnd: !0
-      }
-    ]
-  }, n = {
-    className: "strong",
-    contains: [],
-    // defined later
-    variants: [
-      {
-        begin: /_{2}(?!\s)/,
-        end: /_{2}/
-      },
-      {
-        begin: /\*{2}(?!\s)/,
-        end: /\*{2}/
-      }
-    ]
-  }, a = {
-    className: "emphasis",
-    contains: [],
-    // defined later
-    variants: [
-      {
-        begin: /\*(?![*\s])/,
-        end: /\*/
-      },
-      {
-        begin: /_(?![_\s])/,
-        end: /_/,
-        relevance: 0
-      }
-    ]
-  }, i = s.inherit(n, { contains: [] }), o = s.inherit(a, { contains: [] });
-  n.contains.push(o), a.contains.push(i);
-  let e = [
-    t,
-    c
-  ];
-  return [
-    n,
-    a,
-    i,
-    o
-  ].forEach((r) => {
-    r.contains = r.contains.concat(e);
-  }), e = e.concat(n, a), {
-    name: "Markdown",
-    aliases: [
-      "md",
-      "mkdown",
-      "mkd"
-    ],
-    contains: [
-      {
-        className: "section",
-        variants: [
-          {
-            begin: "^#{1,6}",
-            end: "$",
-            contains: e
-          },
-          {
-            begin: "(?=^.+?\\n[=-]{2,}$)",
-            contains: [
-              { begin: "^[=-]*$" },
-              {
-                begin: "^",
-                end: "\\n",
-                contains: e
-              }
-            ]
-          }
-        ]
-      },
-      t,
-      b,
-      n,
-      a,
-      {
-        className: "quote",
-        begin: "^>\\s+",
-        contains: e,
-        end: "$"
-      },
-      d,
-      l,
-      c,
-      u,
-      {
-        //https://spec.commonmark.org/0.31.2/#entity-references
-        scope: "literal",
-        match: /&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/
-      }
-    ]
-  };
-}
-export {
-  v as default
-};

package/dist/node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/plaintext.js

@@ -1,13 +0,0 @@
-function e(t) {
-  return {
-    name: "Plain text",
-    aliases: [
-      "text",
-      "txt"
-    ],
-    disableAutodetect: !0
-  };
-}
-export {
-  e as default
-};

package/dist/node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/python.js

@@ -1,399 +0,0 @@
-function u(e) {
-  const g = e.regex, i = new RegExp("[\\p{XID_Start}_]\\p{XID_Continue}*", "u"), b = [
-    "and",
-    "as",
-    "assert",
-    "async",
-    "await",
-    "break",
-    "case",
-    "class",
-    "continue",
-    "def",
-    "del",
-    "elif",
-    "else",
-    "except",
-    "finally",
-    "for",
-    "from",
-    "global",
-    "if",
-    "import",
-    "in",
-    "is",
-    "lambda",
-    "match",
-    "nonlocal|10",
-    "not",
-    "or",
-    "pass",
-    "raise",
-    "return",
-    "try",
-    "while",
-    "with",
-    "yield"
-  ], r = {
-    $pattern: /[A-Za-z]\w+|__\w+__/,
-    keyword: b,
-    built_in: [
-      "__import__",
-      "abs",
-      "all",
-      "any",
-      "ascii",
-      "bin",
-      "bool",
-      "breakpoint",
-      "bytearray",
-      "bytes",
-      "callable",
-      "chr",
-      "classmethod",
-      "compile",
-      "complex",
-      "delattr",
-      "dict",
-      "dir",
-      "divmod",
-      "enumerate",
-      "eval",
-      "exec",
-      "filter",
-      "float",
-      "format",
-      "frozenset",
-      "getattr",
-      "globals",
-      "hasattr",
-      "hash",
-      "help",
-      "hex",
-      "id",
-      "input",
-      "int",
-      "isinstance",
-      "issubclass",
-      "iter",
-      "len",
-      "list",
-      "locals",
-      "map",
-      "max",
-      "memoryview",
-      "min",
-      "next",
-      "object",
-      "oct",
-      "open",
-      "ord",
-      "pow",
-      "print",
-      "property",
-      "range",
-      "repr",
-      "reversed",
-      "round",
-      "set",
-      "setattr",
-      "slice",
-      "sorted",
-      "staticmethod",
-      "str",
-      "sum",
-      "super",
-      "tuple",
-      "type",
-      "vars",
-      "zip"
-    ],
-    literal: [
-      "__debug__",
-      "Ellipsis",
-      "False",
-      "None",
-      "NotImplemented",
-      "True"
-    ],
-    type: [
-      "Any",
-      "Callable",
-      "Coroutine",
-      "Dict",
-      "List",
-      "Literal",
-      "Generic",
-      "Optional",
-      "Sequence",
-      "Set",
-      "Tuple",
-      "Type",
-      "Union"
-    ]
-  }, n = {
-    className: "meta",
-    begin: /^(>>>|\.\.\.) /
-  }, s = {
-    className: "subst",
-    begin: /\{/,
-    end: /\}/,
-    keywords: r,
-    illegal: /#/
-  }, o = {
-    begin: /\{\{/,
-    relevance: 0
-  }, c = {
-    className: "string",
-    contains: [e.BACKSLASH_ESCAPE],
-    variants: [
-      {
-        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
-        end: /'''/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          n
-        ],
-        relevance: 10
-      },
-      {
-        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
-        end: /"""/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          n
-        ],
-        relevance: 10
-      },
-      {
-        begin: /([fF][rR]|[rR][fF]|[fF])'''/,
-        end: /'''/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          n,
-          o,
-          s
-        ]
-      },
-      {
-        begin: /([fF][rR]|[rR][fF]|[fF])"""/,
-        end: /"""/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          n,
-          o,
-          s
-        ]
-      },
-      {
-        begin: /([uU]|[rR])'/,
-        end: /'/,
-        relevance: 10
-      },
-      {
-        begin: /([uU]|[rR])"/,
-        end: /"/,
-        relevance: 10
-      },
-      {
-        begin: /([bB]|[bB][rR]|[rR][bB])'/,
-        end: /'/
-      },
-      {
-        begin: /([bB]|[bB][rR]|[rR][bB])"/,
-        end: /"/
-      },
-      {
-        begin: /([fF][rR]|[rR][fF]|[fF])'/,
-        end: /'/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          o,
-          s
-        ]
-      },
-      {
-        begin: /([fF][rR]|[rR][fF]|[fF])"/,
-        end: /"/,
-        contains: [
-          e.BACKSLASH_ESCAPE,
-          o,
-          s
-        ]
-      },
-      e.APOS_STRING_MODE,
-      e.QUOTE_STRING_MODE
-    ]
-  }, t = "[0-9](_?[0-9])*", d = `(\\b(${t}))?\\.(${t})|\\b(${t})\\.`, a = `\\b|${b.join("|")}`, l = {
-    className: "number",
-    relevance: 0,
-    variants: [
-      // exponentfloat, pointfloat
-      // https://docs.python.org/3.9/reference/lexical_analysis.html#floating-point-literals
-      // optionally imaginary
-      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-      // Note: no leading \b because floats can start with a decimal point
-      // and we don't want to mishandle e.g. `fn(.5)`,
-      // no trailing \b for pointfloat because it can end with a decimal point
-      // and we don't want to mishandle e.g. `0..hex()`; this should be safe
-      // because both MUST contain a decimal point and so cannot be confused with
-      // the interior part of an identifier
-      {
-        begin: `(\\b(${t})|(${d}))[eE][+-]?(${t})[jJ]?(?=${a})`
-      },
-      {
-        begin: `(${d})[jJ]?`
-      },
-      // decinteger, bininteger, octinteger, hexinteger
-      // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
-      // optionally "long" in Python 2
-      // https://docs.python.org/2.7/reference/lexical_analysis.html#integer-and-long-integer-literals
-      // decinteger is optionally imaginary
-      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-      {
-        begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${a})`
-      },
-      {
-        begin: `\\b0[bB](_?[01])+[lL]?(?=${a})`
-      },
-      {
-        begin: `\\b0[oO](_?[0-7])+[lL]?(?=${a})`
-      },
-      {
-        begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${a})`
-      },
-      // imagnumber (digitpart-based)
-      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-      {
-        begin: `\\b(${t})[jJ](?=${a})`
-      }
-    ]
-  }, _ = {
-    className: "comment",
-    begin: g.lookahead(/# type:/),
-    end: /$/,
-    keywords: r,
-    contains: [
-      {
-        // prevent keywords from coloring `type`
-        begin: /# type:/
-      },
-      // comment within a datatype comment includes no keywords
-      {
-        begin: /#/,
-        end: /\b\B/,
-        endsWithParent: !0
-      }
-    ]
-  }, p = {
-    className: "params",
-    variants: [
-      // Exclude params in functions without params
-      {
-        className: "",
-        begin: /\(\s*\)/,
-        skip: !0
-      },
-      {
-        begin: /\(/,
-        end: /\)/,
-        excludeBegin: !0,
-        excludeEnd: !0,
-        keywords: r,
-        contains: [
-          "self",
-          n,
-          l,
-          c,
-          e.HASH_COMMENT_MODE
-        ]
-      }
-    ]
-  };
-  return s.contains = [
-    c,
-    l,
-    n
-  ], {
-    name: "Python",
-    aliases: [
-      "py",
-      "gyp",
-      "ipython"
-    ],
-    unicodeRegex: !0,
-    keywords: r,
-    illegal: /(<\/|\?)|=>/,
-    contains: [
-      n,
-      l,
-      {
-        // very common convention
-        scope: "variable.language",
-        match: /\bself\b/
-      },
-      {
-        // eat "if" prior to string so that it won't accidentally be
-        // labeled as an f-string
-        beginKeywords: "if",
-        relevance: 0
-      },
-      { match: /\bor\b/, scope: "keyword" },
-      c,
-      _,
-      e.HASH_COMMENT_MODE,
-      {
-        match: [
-          /\bdef/,
-          /\s+/,
-          i
-        ],
-        scope: {
-          1: "keyword",
-          3: "title.function"
-        },
-        contains: [p]
-      },
-      {
-        variants: [
-          {
-            match: [
-              /\bclass/,
-              /\s+/,
-              i,
-              /\s*/,
-              /\(\s*/,
-              i,
-              /\s*\)/
-            ]
-          },
-          {
-            match: [
-              /\bclass/,
-              /\s+/,
-              i
-            ]
-          }
-        ],
-        scope: {
-          1: "keyword",
-          3: "title.class",
-          6: "title.class.inherited"
-        }
-      },
-      {
-        className: "meta",
-        begin: /^[\t ]*@/,
-        end: /(?=#)|$/,
-        contains: [
-          l,
-          p,
-          c
-        ]
-      }
-    ]
-  };
-}
-export {
-  u as default
-};