@oneflowui/ui 0.4.2 → 0.4.3

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

@@ -0,0 +1,216 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,399 @@
+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
+};