@kong-ui-public/monaco-editor 0.1.1 → 0.1.2-pr.2609.2ce4f4787.0

package/dist/pug-B1847F4G.js

@@ -0,0 +1,408 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var e = {
+  comments: {
+    lineComment: "//"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: '"', close: '"', notIn: ["string", "comment"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: "{", close: "}", notIn: ["string", "comment"] },
+    { open: "[", close: "]", notIn: ["string", "comment"] },
+    { open: "(", close: ")", notIn: ["string", "comment"] }
+  ],
+  folding: {
+    offSide: !0
+  }
+}, t = {
+  defaultToken: "",
+  tokenPostfix: ".pug",
+  ignoreCase: !0,
+  brackets: [
+    { token: "delimiter.curly", open: "{", close: "}" },
+    { token: "delimiter.array", open: "[", close: "]" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" }
+  ],
+  keywords: [
+    "append",
+    "block",
+    "case",
+    "default",
+    "doctype",
+    "each",
+    "else",
+    "extends",
+    "for",
+    "if",
+    "in",
+    "include",
+    "mixin",
+    "typeof",
+    "unless",
+    "var",
+    "when"
+  ],
+  tags: [
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "base",
+    "basefont",
+    "bdi",
+    "bdo",
+    "blockquote",
+    "body",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "command",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hgroup",
+    "hr",
+    "html",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "keygen",
+    "kbd",
+    "label",
+    "li",
+    "link",
+    "map",
+    "mark",
+    "menu",
+    "meta",
+    "meter",
+    "nav",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "pre",
+    "progress",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "small",
+    "source",
+    "span",
+    "strike",
+    "strong",
+    "style",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "title",
+    "tr",
+    "tracks",
+    "tt",
+    "u",
+    "ul",
+    "video",
+    "wbr"
+  ],
+  // we include these common regular expressions
+  symbols: /[\+\-\*\%\&\|\!\=\/\.\,\:]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  tokenizer: {
+    root: [
+      // Tag or a keyword at start
+      [
+        /^(\s*)([a-zA-Z_-][\w-]*)/,
+        {
+          cases: {
+            "$2@tags": {
+              cases: {
+                "@eos": ["", "tag"],
+                "@default": ["", { token: "tag", next: "@tag.$1" }]
+              }
+            },
+            "$2@keywords": ["", { token: "keyword.$2" }],
+            "@default": ["", ""]
+          }
+        }
+      ],
+      // id
+      [
+        /^(\s*)(#[a-zA-Z_-][\w-]*)/,
+        {
+          cases: {
+            "@eos": ["", "tag.id"],
+            "@default": ["", { token: "tag.id", next: "@tag.$1" }]
+          }
+        }
+      ],
+      // class
+      [
+        /^(\s*)(\.[a-zA-Z_-][\w-]*)/,
+        {
+          cases: {
+            "@eos": ["", "tag.class"],
+            "@default": ["", { token: "tag.class", next: "@tag.$1" }]
+          }
+        }
+      ],
+      // plain text with pipe
+      [/^(\s*)(\|.*)$/, ""],
+      { include: "@whitespace" },
+      // keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": ""
+          }
+        }
+      ],
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/\d+/, "number"],
+      // strings:
+      [/"/, "string", '@string."'],
+      [/'/, "string", "@string.'"]
+    ],
+    tag: [
+      [/(\.)(\s*$)/, [{ token: "delimiter", next: "@blockText.$S2." }, ""]],
+      [/\s+/, { token: "", next: "@simpleText" }],
+      // id
+      [
+        /#[a-zA-Z_-][\w-]*/,
+        {
+          cases: {
+            "@eos": { token: "tag.id", next: "@pop" },
+            "@default": "tag.id"
+          }
+        }
+      ],
+      // class
+      [
+        /\.[a-zA-Z_-][\w-]*/,
+        {
+          cases: {
+            "@eos": { token: "tag.class", next: "@pop" },
+            "@default": "tag.class"
+          }
+        }
+      ],
+      // attributes
+      [/\(/, { token: "delimiter.parenthesis", next: "@attributeList" }]
+    ],
+    simpleText: [
+      [/[^#]+$/, { token: "", next: "@popall" }],
+      [/[^#]+/, { token: "" }],
+      // interpolation
+      [
+        /(#{)([^}]*)(})/,
+        {
+          cases: {
+            "@eos": [
+              "interpolation.delimiter",
+              "interpolation",
+              {
+                token: "interpolation.delimiter",
+                next: "@popall"
+              }
+            ],
+            "@default": ["interpolation.delimiter", "interpolation", "interpolation.delimiter"]
+          }
+        }
+      ],
+      [/#$/, { token: "", next: "@popall" }],
+      [/#/, ""]
+    ],
+    attributeList: [
+      [/\s+/, ""],
+      [
+        /(\w+)(\s*=\s*)("|')/,
+        ["attribute.name", "delimiter", { token: "attribute.value", next: "@value.$3" }]
+      ],
+      [/\w+/, "attribute.name"],
+      [
+        /,/,
+        {
+          cases: {
+            "@eos": {
+              token: "attribute.delimiter",
+              next: "@popall"
+            },
+            "@default": "attribute.delimiter"
+          }
+        }
+      ],
+      [/\)$/, { token: "delimiter.parenthesis", next: "@popall" }],
+      [/\)/, { token: "delimiter.parenthesis", next: "@pop" }]
+    ],
+    whitespace: [
+      [/^(\s*)(\/\/.*)$/, { token: "comment", next: "@blockText.$1.comment" }],
+      [/[ \t\r\n]+/, ""],
+      [/<!--/, { token: "comment", next: "@comment" }]
+    ],
+    blockText: [
+      [
+        /^\s+.*$/,
+        {
+          cases: {
+            "($S2\\s+.*$)": { token: "$S3" },
+            "@default": { token: "@rematch", next: "@popall" }
+          }
+        }
+      ],
+      [/./, { token: "@rematch", next: "@popall" }]
+    ],
+    comment: [
+      [/[^<\-]+/, "comment.content"],
+      [/-->/, { token: "comment", next: "@pop" }],
+      [/<!--/, "comment.content.invalid"],
+      [/[<\-]/, "comment.content"]
+    ],
+    string: [
+      [
+        /[^\\"'#]+/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ],
+      [
+        /@escapes/,
+        {
+          cases: {
+            "@eos": { token: "string.escape", next: "@popall" },
+            "@default": "string.escape"
+          }
+        }
+      ],
+      [
+        /\\./,
+        {
+          cases: {
+            "@eos": {
+              token: "string.escape.invalid",
+              next: "@popall"
+            },
+            "@default": "string.escape.invalid"
+          }
+        }
+      ],
+      // interpolation
+      [/(#{)([^}]*)(})/, ["interpolation.delimiter", "interpolation", "interpolation.delimiter"]],
+      [/#/, "string"],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": { token: "string" }
+          }
+        }
+      ]
+    ],
+    // Almost identical to above, except for escapes and the output token
+    value: [
+      [
+        /[^\\"']+/,
+        {
+          cases: {
+            "@eos": { token: "attribute.value", next: "@popall" },
+            "@default": "attribute.value"
+          }
+        }
+      ],
+      [
+        /\\./,
+        {
+          cases: {
+            "@eos": { token: "attribute.value", next: "@popall" },
+            "@default": "attribute.value"
+          }
+        }
+      ],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "attribute.value", next: "@pop" },
+            "@default": { token: "attribute.value" }
+          }
+        }
+      ]
+    ]
+  }
+};
+export {
+  e as conf,
+  t as language
+};

package/dist/python-CGI_fE8F.js

@@ -0,0 +1,307 @@
+import { m as o } from "./editor.main-BVWEsGeM.js";
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var a = Object.defineProperty, l = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, c = Object.prototype.hasOwnProperty, g = (t, e, n, s) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let r of p(e))
+      !c.call(t, r) && r !== n && a(t, r, { get: () => e[r], enumerable: !(s = l(e, r)) || s.enumerable });
+  return t;
+}, d = (t, e, n) => (g(t, e, "default"), n), i = {};
+d(i, o);
+var m = {
+  comments: {
+    lineComment: "#",
+    blockComment: ["'''", "'''"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  onEnterRules: [
+    {
+      beforeText: new RegExp(
+        "^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async|match|case).*?:\\s*$"
+      ),
+      action: { indentAction: i.languages.IndentAction.Indent }
+    }
+  ],
+  folding: {
+    offSide: !0,
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+}, f = {
+  defaultToken: "",
+  tokenPostfix: ".python",
+  keywords: [
+    // This section is the result of running
+    // `import keyword; for k in sorted(keyword.kwlist + keyword.softkwlist): print("  '" + k + "',")`
+    // in a Python REPL,
+    // though note that the output from Python 3 is not a strict superset of the
+    // output from Python 2.
+    "False",
+    // promoted to keyword.kwlist in Python 3
+    "None",
+    // promoted to keyword.kwlist in Python 3
+    "True",
+    // promoted to keyword.kwlist in Python 3
+    "_",
+    // new in Python 3.10
+    "and",
+    "as",
+    "assert",
+    "async",
+    // new in Python 3
+    "await",
+    // new in Python 3
+    "break",
+    "case",
+    // new in Python 3.10
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "exec",
+    // Python 2, but not 3.
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "match",
+    // new in Python 3.10
+    "nonlocal",
+    // new in Python 3
+    "not",
+    "or",
+    "pass",
+    "print",
+    // Python 2, but not 3.
+    "raise",
+    "return",
+    "try",
+    "type",
+    // new in Python 3.12
+    "while",
+    "with",
+    "yield",
+    "int",
+    "float",
+    "long",
+    "complex",
+    "hex",
+    "abs",
+    "all",
+    "any",
+    "apply",
+    "basestring",
+    "bin",
+    "bool",
+    "buffer",
+    "bytearray",
+    "callable",
+    "chr",
+    "classmethod",
+    "cmp",
+    "coerce",
+    "compile",
+    "complex",
+    "delattr",
+    "dict",
+    "dir",
+    "divmod",
+    "enumerate",
+    "eval",
+    "execfile",
+    "file",
+    "filter",
+    "format",
+    "frozenset",
+    "getattr",
+    "globals",
+    "hasattr",
+    "hash",
+    "help",
+    "id",
+    "input",
+    "intern",
+    "isinstance",
+    "issubclass",
+    "iter",
+    "len",
+    "locals",
+    "list",
+    "map",
+    "max",
+    "memoryview",
+    "min",
+    "next",
+    "object",
+    "oct",
+    "open",
+    "ord",
+    "pow",
+    "print",
+    "property",
+    "reversed",
+    "range",
+    "raw_input",
+    "reduce",
+    "reload",
+    "repr",
+    "reversed",
+    "round",
+    "self",
+    "set",
+    "setattr",
+    "slice",
+    "sorted",
+    "staticmethod",
+    "str",
+    "sum",
+    "super",
+    "tuple",
+    "type",
+    "unichr",
+    "unicode",
+    "vars",
+    "xrange",
+    "zip",
+    "__dict__",
+    "__methods__",
+    "__members__",
+    "__class__",
+    "__bases__",
+    "__name__",
+    "__mro__",
+    "__subclasses__",
+    "__init__",
+    "__import__"
+  ],
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.bracket" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      { include: "@numbers" },
+      { include: "@strings" },
+      [/[,:;]/, "delimiter"],
+      [/[{}\[\]()]/, "@brackets"],
+      [/@[a-zA-Z_]\w*/, "tag"],
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "identifier"
+          }
+        }
+      ]
+    ],
+    // Deal with white space, including single and multi-line comments
+    whitespace: [
+      [/\s+/, "white"],
+      [/(^#.*$)/, "comment"],
+      [/'''/, "string", "@endDocString"],
+      [/"""/, "string", "@endDblDocString"]
+    ],
+    endDocString: [
+      [/[^']+/, "string"],
+      [/\\'/, "string"],
+      [/'''/, "string", "@popall"],
+      [/'/, "string"]
+    ],
+    endDblDocString: [
+      [/[^"]+/, "string"],
+      [/\\"/, "string"],
+      [/"""/, "string", "@popall"],
+      [/"/, "string"]
+    ],
+    // Recognize hex, negatives, decimals, imaginaries, longs, and scientific notation
+    numbers: [
+      [/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, "number.hex"],
+      [/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, "number"]
+    ],
+    // Recognize strings, including those broken across lines with \ (but not without)
+    strings: [
+      [/'$/, "string.escape", "@popall"],
+      [/f'{1,3}/, "string.escape", "@fStringBody"],
+      [/'/, "string.escape", "@stringBody"],
+      [/"$/, "string.escape", "@popall"],
+      [/f"{1,3}/, "string.escape", "@fDblStringBody"],
+      [/"/, "string.escape", "@dblStringBody"]
+    ],
+    fStringBody: [
+      [/[^\\'\{\}]+$/, "string", "@popall"],
+      [/[^\\'\{\}]+/, "string"],
+      [/\{[^\}':!=]+/, "identifier", "@fStringDetail"],
+      [/\\./, "string"],
+      [/'/, "string.escape", "@popall"],
+      [/\\$/, "string"]
+    ],
+    stringBody: [
+      [/[^\\']+$/, "string", "@popall"],
+      [/[^\\']+/, "string"],
+      [/\\./, "string"],
+      [/'/, "string.escape", "@popall"],
+      [/\\$/, "string"]
+    ],
+    fDblStringBody: [
+      [/[^\\"\{\}]+$/, "string", "@popall"],
+      [/[^\\"\{\}]+/, "string"],
+      [/\{[^\}':!=]+/, "identifier", "@fStringDetail"],
+      [/\\./, "string"],
+      [/"/, "string.escape", "@popall"],
+      [/\\$/, "string"]
+    ],
+    dblStringBody: [
+      [/[^\\"]+$/, "string", "@popall"],
+      [/[^\\"]+/, "string"],
+      [/\\./, "string"],
+      [/"/, "string.escape", "@popall"],
+      [/\\$/, "string"]
+    ],
+    fStringDetail: [
+      [/[:][^}]+/, "string"],
+      [/[!][ars]/, "string"],
+      // only !a, !r, !s are supported by f-strings: https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals
+      [/=/, "string"],
+      [/\}/, "identifier", "@pop"]
+    ]
+  }
+};
+export {
+  m as conf,
+  f as language
+};