@mxmweb/rtext 1.6.14 → 1.6.16

package/prism-markup-BNGj0Tvm.js

@@ -1,173 +0,0 @@
-Prism.languages.markup = {
-  comment: {
-    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-    greedy: !0
-  },
-  prolog: {
-    pattern: /<\?[\s\S]+?\?>/,
-    greedy: !0
-  },
-  doctype: {
-    // https://www.w3.org/TR/xml/#NT-doctypedecl
-    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-    greedy: !0,
-    inside: {
-      "internal-subset": {
-        pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: null
-        // see below
-      },
-      string: {
-        pattern: /"[^"]*"|'[^']*'/,
-        greedy: !0
-      },
-      punctuation: /^<!|>$|[[\]]/,
-      "doctype-tag": /^DOCTYPE/i,
-      name: /[^\s<>'"]+/
-    }
-  },
-  cdata: {
-    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-    greedy: !0
-  },
-  tag: {
-    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-    greedy: !0,
-    inside: {
-      tag: {
-        pattern: /^<\/?[^\s>\/]+/,
-        inside: {
-          punctuation: /^<\/?/,
-          namespace: /^[^\s>\/:]+:/
-        }
-      },
-      "special-attr": [],
-      "attr-value": {
-        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-        inside: {
-          punctuation: [
-            {
-              pattern: /^=/,
-              alias: "attr-equals"
-            },
-            {
-              pattern: /^(\s*)["']|["']$/,
-              lookbehind: !0
-            }
-          ]
-        }
-      },
-      punctuation: /\/?>/,
-      "attr-name": {
-        pattern: /[^\s>\/]+/,
-        inside: {
-          namespace: /^[^\s>\/:]+:/
-        }
-      }
-    }
-  },
-  entity: [
-    {
-      pattern: /&[\da-z]{1,8};/i,
-      alias: "named-entity"
-    },
-    /&#x?[\da-f]{1,8};/i
-  ]
-};
-Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity;
-Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup;
-Prism.hooks.add("wrap", function(e) {
-  e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
-});
-Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
-  /**
-   * Adds an inlined language to markup.
-   *
-   * An example of an inlined language is CSS with `<style>` tags.
-   *
-   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
-   * case insensitive.
-   * @param {string} lang The language key.
-   * @example
-   * addInlined('style', 'css');
-   */
-  value: function(a, t) {
-    var s = {};
-    s["language-" + t] = {
-      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-      lookbehind: !0,
-      inside: Prism.languages[t]
-    }, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
-    var n = {
-      "included-cdata": {
-        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-        inside: s
-      }
-    };
-    n["language-" + t] = {
-      pattern: /[\s\S]+/,
-      inside: Prism.languages[t]
-    };
-    var i = {};
-    i[a] = {
-      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
-        return a;
-      }), "i"),
-      lookbehind: !0,
-      greedy: !0,
-      inside: n
-    }, Prism.languages.insertBefore("markup", "cdata", i);
-  }
-});
-Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
-  /**
-   * Adds an pattern to highlight languages embedded in HTML attributes.
-   *
-   * An example of an inlined language is CSS with `style` attributes.
-   *
-   * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
-   * case insensitive.
-   * @param {string} lang The language key.
-   * @example
-   * addAttribute('style', 'css');
-   */
-  value: function(e, a) {
-    Prism.languages.markup.tag.inside["special-attr"].push({
-      pattern: RegExp(
-        /(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-        "i"
-      ),
-      lookbehind: !0,
-      inside: {
-        "attr-name": /^[^\s=]+/,
-        "attr-value": {
-          pattern: /=[\s\S]+/,
-          inside: {
-            value: {
-              pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-              lookbehind: !0,
-              alias: [a, "language-" + a],
-              inside: Prism.languages[a]
-            },
-            punctuation: [
-              {
-                pattern: /^=/,
-                alias: "attr-equals"
-              },
-              /"|'/
-            ]
-          }
-        }
-      }
-    });
-  }
-});
-Prism.languages.html = Prism.languages.markup;
-Prism.languages.mathml = Prism.languages.markup;
-Prism.languages.svg = Prism.languages.markup;
-Prism.languages.xml = Prism.languages.extend("markup", {});
-Prism.languages.ssml = Prism.languages.xml;
-Prism.languages.atom = Prism.languages.xml;
-Prism.languages.rss = Prism.languages.xml;

package/prism-php-Cq3Hq1Wv.js

@@ -1,347 +0,0 @@
-import { g as c } from "./lib_enter-e1LoilHd.js";
-function f(e, r) {
-  for (var n = 0; n < r.length; n++) {
-    const t = r[n];
-    if (typeof t != "string" && !Array.isArray(t)) {
-      for (const a in t)
-        if (a !== "default" && !(a in e)) {
-          const i = Object.getOwnPropertyDescriptor(t, a);
-          i && Object.defineProperty(e, a, i.get ? i : {
-            enumerable: !0,
-            get: () => t[a]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
-}
-var u = {}, d;
-function g() {
-  return d || (d = 1, (function(e) {
-    var r = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, n = [
-      {
-        pattern: /\b(?:false|true)\b/i,
-        alias: "boolean"
-      },
-      {
-        pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
-        greedy: !0,
-        lookbehind: !0
-      },
-      {
-        pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
-        greedy: !0,
-        lookbehind: !0
-      },
-      /\b(?:null)\b/i,
-      /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
-    ], t = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, a = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, i = /[{}\[\](),:;]/;
-    e.languages.php = {
-      delimiter: {
-        pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
-        alias: "important"
-      },
-      comment: r,
-      variable: /\$+(?:\w+\b|(?=\{))/,
-      package: {
-        pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /\\/
-        }
-      },
-      "class-name-definition": {
-        pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
-        lookbehind: !0,
-        alias: "class-name"
-      },
-      "function-definition": {
-        pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
-        lookbehind: !0,
-        alias: "function"
-      },
-      keyword: [
-        {
-          pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
-          alias: "type-casting",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
-          alias: "type-hint",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
-          alias: "return-type",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
-          alias: "type-declaration",
-          greedy: !0
-        },
-        {
-          pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
-          alias: "type-declaration",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b(?:parent|self|static)(?=\s*::)/i,
-          alias: "static-context",
-          greedy: !0
-        },
-        {
-          // yield from
-          pattern: /(\byield\s+)from\b/i,
-          lookbehind: !0
-        },
-        // `class` is always a keyword unlike other keywords
-        /\bclass\b/i,
-        {
-          // https://www.php.net/manual/en/reserved.keywords.php
-          //
-          // keywords cannot be preceded by "->"
-          // the complex lookbehind means `(?<!(?:->|::)\s*)`
-          pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
-          lookbehind: !0
-        }
-      ],
-      "argument-name": {
-        pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
-        lookbehind: !0
-      },
-      "class-name": [
-        {
-          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
-          greedy: !0
-        },
-        {
-          pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /\b[a-z_]\w*(?=\s*\$)/i,
-          alias: "type-declaration",
-          greedy: !0
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-          alias: ["class-name-fully-qualified", "type-declaration"],
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /\b[a-z_]\w*(?=\s*::)/i,
-          alias: "static-context",
-          greedy: !0
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
-          alias: ["class-name-fully-qualified", "static-context"],
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
-          alias: "type-hint",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-          alias: ["class-name-fully-qualified", "type-hint"],
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
-          alias: "return-type",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-          alias: ["class-name-fully-qualified", "return-type"],
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        }
-      ],
-      constant: n,
-      function: {
-        pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /\\/
-        }
-      },
-      property: {
-        pattern: /(->\s*)\w+/,
-        lookbehind: !0
-      },
-      number: t,
-      operator: a,
-      punctuation: i
-    };
-    var l = {
-      pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
-      lookbehind: !0,
-      inside: e.languages.php
-    }, o = [
-      {
-        pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
-        alias: "nowdoc-string",
-        greedy: !0,
-        inside: {
-          delimiter: {
-            pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
-            alias: "symbol",
-            inside: {
-              punctuation: /^<<<'?|[';]$/
-            }
-          }
-        }
-      },
-      {
-        pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
-        alias: "heredoc-string",
-        greedy: !0,
-        inside: {
-          delimiter: {
-            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
-            alias: "symbol",
-            inside: {
-              punctuation: /^<<<"?|[";]$/
-            }
-          },
-          interpolation: l
-        }
-      },
-      {
-        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
-        alias: "backtick-quoted-string",
-        greedy: !0
-      },
-      {
-        pattern: /'(?:\\[\s\S]|[^\\'])*'/,
-        alias: "single-quoted-string",
-        greedy: !0
-      },
-      {
-        pattern: /"(?:\\[\s\S]|[^\\"])*"/,
-        alias: "double-quoted-string",
-        greedy: !0,
-        inside: {
-          interpolation: l
-        }
-      }
-    ];
-    e.languages.insertBefore("php", "variable", {
-      string: o,
-      attribute: {
-        pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
-        greedy: !0,
-        inside: {
-          "attribute-content": {
-            pattern: /^(#\[)[\s\S]+(?=\]$)/,
-            lookbehind: !0,
-            // inside can appear subset of php
-            inside: {
-              comment: r,
-              string: o,
-              "attribute-class-name": [
-                {
-                  pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
-                  alias: "class-name",
-                  greedy: !0,
-                  lookbehind: !0
-                },
-                {
-                  pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
-                  alias: [
-                    "class-name",
-                    "class-name-fully-qualified"
-                  ],
-                  greedy: !0,
-                  lookbehind: !0,
-                  inside: {
-                    punctuation: /\\/
-                  }
-                }
-              ],
-              constant: n,
-              number: t,
-              operator: a,
-              punctuation: i
-            }
-          },
-          delimiter: {
-            pattern: /^#\[|\]$/,
-            alias: "punctuation"
-          }
-        }
-      }
-    }), e.hooks.add("before-tokenize", function(s) {
-      if (/<\?/.test(s.code)) {
-        var p = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
-        e.languages["markup-templating"].buildPlaceholders(s, "php", p);
-      }
-    }), e.hooks.add("after-tokenize", function(s) {
-      e.languages["markup-templating"].tokenizePlaceholders(s, "php");
-    });
-  })(Prism)), u;
-}
-var b = g();
-const y = /* @__PURE__ */ c(b), m = /* @__PURE__ */ f({
-  __proto__: null,
-  default: y
-}, [b]);
-export {
-  m as p
-};

package/prism-python-CP37PFZv.js

@@ -1,89 +0,0 @@
-import { g as p } from "./lib_enter-e1LoilHd.js";
-function u(r, a) {
-  for (var n = 0; n < a.length; n++) {
-    const e = a[n];
-    if (typeof e != "string" && !Array.isArray(e)) {
-      for (const t in e)
-        if (t !== "default" && !(t in r)) {
-          const i = Object.getOwnPropertyDescriptor(e, t);
-          i && Object.defineProperty(r, t, i.get ? i : {
-            enumerable: !0,
-            get: () => e[t]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
-}
-var o = {}, s;
-function d() {
-  return s || (s = 1, Prism.languages.python = {
-    comment: {
-      pattern: /(^|[^\\])#.*/,
-      lookbehind: !0,
-      greedy: !0
-    },
-    "string-interpolation": {
-      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
-      greedy: !0,
-      inside: {
-        interpolation: {
-          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
-          lookbehind: !0,
-          inside: {
-            "format-spec": {
-              pattern: /(:)[^:(){}]+(?=\}$)/,
-              lookbehind: !0
-            },
-            "conversion-option": {
-              pattern: /![sra](?=[:}]$)/,
-              alias: "punctuation"
-            },
-            rest: null
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "triple-quoted-string": {
-      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
-      greedy: !0,
-      alias: "string"
-    },
-    string: {
-      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-      greedy: !0
-    },
-    function: {
-      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-      lookbehind: !0
-    },
-    "class-name": {
-      pattern: /(\bclass\s+)\w+/i,
-      lookbehind: !0
-    },
-    decorator: {
-      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
-      lookbehind: !0,
-      alias: ["annotation", "punctuation"],
-      inside: {
-        punctuation: /\./
-      }
-    },
-    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
-    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
-    boolean: /\b(?:False|None|True)\b/,
-    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
-    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-    punctuation: /[{}[\];(),.:]/
-  }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python), o;
-}
-var l = d();
-const c = /* @__PURE__ */ p(l), m = /* @__PURE__ */ u({
-  __proto__: null,
-  default: c
-}, [l]);
-export {
-  m as p
-};