@mxmweb/rtext 1.6.14 → 1.6.16

package/prism-ruby-DcAmdHPZ.js

@@ -1,195 +0,0 @@
-import { g as l } from "./lib_enter-e1LoilHd.js";
-function d(e, r) {
-  for (var n = 0; n < r.length; n++) {
-    const t = r[n];
-    if (typeof t != "string" && !Array.isArray(t)) {
-      for (const i in t)
-        if (i !== "default" && !(i in e)) {
-          const s = Object.getOwnPropertyDescriptor(t, i);
-          s && Object.defineProperty(e, i, s.get ? s : {
-            enumerable: !0,
-            get: () => t[i]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
-}
-var a = {}, o;
-function g() {
-  return o || (o = 1, (function(e) {
-    e.languages.ruby = e.languages.extend("clike", {
-      comment: {
-        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
-        greedy: !0
-      },
-      "class-name": {
-        pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
-        lookbehind: !0,
-        inside: {
-          punctuation: /[.\\]/
-        }
-      },
-      keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
-      operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
-      punctuation: /[(){}[\].,;]/
-    }), e.languages.insertBefore("ruby", "operator", {
-      "double-colon": {
-        pattern: /::/,
-        alias: "punctuation"
-      }
-    });
-    var r = {
-      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
-      lookbehind: !0,
-      inside: {
-        content: {
-          pattern: /^(#\{)[\s\S]+(?=\}$)/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        },
-        delimiter: {
-          pattern: /^#\{|\}$/,
-          alias: "punctuation"
-        }
-      }
-    };
-    delete e.languages.ruby.function;
-    var n = "(?:" + [
-      /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-      /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
-      /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
-      /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
-      /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
-    ].join("|") + ")", t = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
-    e.languages.insertBefore("ruby", "keyword", {
-      "regex-literal": [
-        {
-          pattern: RegExp(/%r/.source + n + /[egimnosux]{0,6}/.source),
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            regex: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
-          lookbehind: !0,
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            regex: /[\s\S]+/
-          }
-        }
-      ],
-      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
-      symbol: [
-        {
-          pattern: RegExp(/(^|[^:]):/.source + t),
-          lookbehind: !0,
-          greedy: !0
-        },
-        {
-          pattern: RegExp(/([\r\n{(,][ \t]*)/.source + t + /(?=:(?!:))/.source),
-          lookbehind: !0,
-          greedy: !0
-        }
-      ],
-      "method-definition": {
-        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
-        lookbehind: !0,
-        inside: {
-          function: /\b\w+$/,
-          keyword: /^self\b/,
-          "class-name": /^\w+/,
-          punctuation: /\./
-        }
-      }
-    }), e.languages.insertBefore("ruby", "string", {
-      "string-literal": [
-        {
-          pattern: RegExp(/%[qQiIwWs]?/.source + n),
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: !0,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?/
-              }
-            },
-            interpolation: r,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: !0,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?'|'$/
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      ],
-      "command-literal": [
-        {
-          pattern: RegExp(/%x/.source + n),
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        },
-        {
-          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
-          greedy: !0,
-          inside: {
-            interpolation: r,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        }
-      ]
-    }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
-      builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
-      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
-    }), e.languages.rb = e.languages.ruby;
-  })(Prism)), a;
-}
-var u = g();
-const p = /* @__PURE__ */ l(u), b = /* @__PURE__ */ d({
-  __proto__: null,
-  default: p
-}, [u]);
-export {
-  b as p
-};

package/prism-rust-CuWIv8B8.js

@@ -1,144 +0,0 @@
-import { g as l } from "./lib_enter-e1LoilHd.js";
-function p(e, t) {
-  for (var r = 0; r < t.length; r++) {
-    const a = t[r];
-    if (typeof a != "string" && !Array.isArray(a)) {
-      for (const n in a)
-        if (n !== "default" && !(n in e)) {
-          const s = Object.getOwnPropertyDescriptor(a, n);
-          s && Object.defineProperty(e, n, s.get ? s : {
-            enumerable: !0,
-            get: () => a[n]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
-}
-var i = {}, u;
-function c() {
-  return u || (u = 1, (function(e) {
-    for (var t = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, r = 0; r < 2; r++)
-      t = t.replace(/<self>/g, function() {
-        return t;
-      });
-    t = t.replace(/<self>/g, function() {
-      return /[^\s\S]/.source;
-    }), e.languages.rust = {
-      comment: [
-        {
-          pattern: RegExp(/(^|[^\\])/.source + t),
-          lookbehind: !0,
-          greedy: !0
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: !0,
-          greedy: !0
-        }
-      ],
-      string: {
-        pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
-        greedy: !0
-      },
-      char: {
-        pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
-        greedy: !0
-      },
-      attribute: {
-        pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
-        greedy: !0,
-        alias: "attr-name",
-        inside: {
-          string: null
-          // see below
-        }
-      },
-      // Closure params should not be confused with bitwise OR |
-      "closure-params": {
-        pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          "closure-punctuation": {
-            pattern: /^\||\|$/,
-            alias: "punctuation"
-          },
-          rest: null
-          // see below
-        }
-      },
-      "lifetime-annotation": {
-        pattern: /'\w+/,
-        alias: "symbol"
-      },
-      "fragment-specifier": {
-        pattern: /(\$\w+:)[a-z]+/,
-        lookbehind: !0,
-        alias: "punctuation"
-      },
-      variable: /\$\w+/,
-      "function-definition": {
-        pattern: /(\bfn\s+)\w+/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "type-definition": {
-        pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
-        lookbehind: !0,
-        alias: "class-name"
-      },
-      "module-declaration": [
-        {
-          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
-          lookbehind: !0,
-          alias: "namespace"
-        },
-        {
-          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
-          lookbehind: !0,
-          alias: "namespace",
-          inside: {
-            punctuation: /::/
-          }
-        }
-      ],
-      keyword: [
-        // https://github.com/rust-lang/reference/blob/master/src/keywords.md
-        /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
-        // primitives and str
-        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
-        /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
-      ],
-      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
-      // and Rust's naming conventions recommend snake_case anyway.
-      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
-      function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
-      macro: {
-        pattern: /\b\w+!/,
-        alias: "property"
-      },
-      constant: /\b[A-Z_][A-Z_\d]+\b/,
-      "class-name": /\b[A-Z]\w*\b/,
-      namespace: {
-        pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
-        inside: {
-          punctuation: /::/
-        }
-      },
-      // Hex, oct, bin, dec numbers with visual separators and type suffix
-      number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
-      boolean: /\b(?:false|true)\b/,
-      punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
-      operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
-    }, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
-  })(Prism)), i;
-}
-var o = c();
-const d = /* @__PURE__ */ l(o), f = /* @__PURE__ */ p({
-  __proto__: null,
-  default: d
-}, [o]);
-export {
-  f as p
-};

package/prism-sql-8Y2-THrf.js

@@ -1,33 +0,0 @@
-Prism.languages.sql = {
-  comment: {
-    pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
-    lookbehind: !0
-  },
-  variable: [
-    {
-      pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
-      greedy: !0
-    },
-    /@[\w.$]+/
-  ],
-  string: {
-    pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
-    greedy: !0,
-    lookbehind: !0
-  },
-  identifier: {
-    pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
-    greedy: !0,
-    lookbehind: !0,
-    inside: {
-      punctuation: /^`|`$/
-    }
-  },
-  function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
-  // Should we highlight user defined functions too?
-  keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
-  boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
-  number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
-  operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
-  punctuation: /[;[\]()`,.]/
-};

package/prism-swift-CeDyTyXT.js

@@ -1,113 +0,0 @@
-Prism.languages.swift = {
-  comment: {
-    // Nested comments are supported up to 2 levels
-    pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  "string-literal": [
-    // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
-    {
-      pattern: RegExp(
-        /(^|[^"#])/.source + "(?:" + /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
-      ),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        interpolation: {
-          pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
-          lookbehind: !0,
-          inside: null
-          // see below
-        },
-        "interpolation-punctuation": {
-          pattern: /^\)|\\\($/,
-          alias: "punctuation"
-        },
-        punctuation: /\\(?=[\r\n])/,
-        string: /[\s\S]+/
-      }
-    },
-    {
-      pattern: RegExp(
-        /(^|[^"#])(#+)/.source + "(?:" + /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
-      ),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        interpolation: {
-          pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
-          lookbehind: !0,
-          inside: null
-          // see below
-        },
-        "interpolation-punctuation": {
-          pattern: /^\)|\\#+\($/,
-          alias: "punctuation"
-        },
-        string: /[\s\S]+/
-      }
-    }
-  ],
-  directive: {
-    // directives with conditions
-    pattern: RegExp(
-      /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
-    ),
-    alias: "property",
-    inside: {
-      "directive-name": /^#\w+/,
-      boolean: /\b(?:false|true)\b/,
-      number: /\b\d+(?:\.\d+)*\b/,
-      operator: /!|&&|\|\||[<>]=?/,
-      punctuation: /[(),]/
-    }
-  },
-  literal: {
-    pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
-    alias: "constant"
-  },
-  "other-directive": {
-    pattern: /#\w+\b/,
-    alias: "property"
-  },
-  attribute: {
-    pattern: /@\w+/,
-    alias: "atrule"
-  },
-  "function-definition": {
-    pattern: /(\bfunc\s+)\w+/,
-    lookbehind: !0,
-    alias: "function"
-  },
-  label: {
-    // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
-    pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
-    lookbehind: !0,
-    alias: "important"
-  },
-  keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
-  boolean: /\b(?:false|true)\b/,
-  nil: {
-    pattern: /\bnil\b/,
-    alias: "constant"
-  },
-  "short-argument": /\$\d+\b/,
-  omit: {
-    pattern: /\b_\b/,
-    alias: "keyword"
-  },
-  number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
-  // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
-  "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
-  function: /\b[a-z_]\w*(?=\s*\()/i,
-  constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
-  // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
-  // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
-  // This regex only supports ASCII operators.
-  operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
-  punctuation: /[{}[\]();,.:\\]/
-};
-Prism.languages.swift["string-literal"].forEach(function(e) {
-  e.inside.interpolation.inside = Prism.languages.swift;
-});

package/prism-tsx-D_jjxt3I.js

@@ -1,6 +0,0 @@
-(function(e) {
-  var a = e.util.clone(e.languages.typescript);
-  e.languages.tsx = e.languages.extend("jsx", a), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"];
-  var t = e.languages.tsx.tag;
-  t.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + t.pattern.source + ")", t.pattern.flags), t.lookbehind = !0;
-})(Prism);

package/prism-typescript-DSWPRTnC.js

@@ -1,73 +0,0 @@
-import { g as c } from "./lib_enter-e1LoilHd.js";
-function u(e, t) {
-  for (var n = 0; n < t.length; n++) {
-    const r = t[n];
-    if (typeof r != "string" && !Array.isArray(r)) {
-      for (const s in r)
-        if (s !== "default" && !(s in e)) {
-          const a = Object.getOwnPropertyDescriptor(r, s);
-          a && Object.defineProperty(e, s, a.get ? a : {
-            enumerable: !0,
-            get: () => r[s]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
-}
-var i = {}, p;
-function l() {
-  return p || (p = 1, (function(e) {
-    e.languages.typescript = e.languages.extend("javascript", {
-      "class-name": {
-        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: null
-        // see below
-      },
-      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-    }), e.languages.typescript.keyword.push(
-      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
-      // keywords that have to be followed by an identifier
-      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
-      // This is for `import type *, {}`
-      /\btype\b(?=\s*(?:[\{*]|$))/
-    ), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
-    var t = e.languages.extend("typescript", {});
-    delete t["class-name"], e.languages.typescript["class-name"].inside = t, e.languages.insertBefore("typescript", "function", {
-      decorator: {
-        pattern: /@[$\w\xA0-\uFFFF]+/,
-        inside: {
-          at: {
-            pattern: /^@/,
-            alias: "operator"
-          },
-          function: /^[\s\S]+/
-        }
-      },
-      "generic-function": {
-        // e.g. foo<T extends "bar" | "baz">( ...
-        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
-        greedy: !0,
-        inside: {
-          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            // everything after the first <
-            alias: "class-name",
-            inside: t
-          }
-        }
-      }
-    }), e.languages.ts = e.languages.typescript;
-  })(Prism)), i;
-}
-var o = l();
-const g = /* @__PURE__ */ c(o), F = /* @__PURE__ */ u({
-  __proto__: null,
-  default: g
-}, [o]);
-export {
-  F as p
-};

package/prism-yaml-DwdKlmeG.js

@@ -1,66 +0,0 @@
-(function(r) {
-  var t = /[*&][^\s[\]{},]+/, n = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, a = "(?:" + n.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + n.source + ")?)", d = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
-    return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
-  }), o = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
-  function e(i, u) {
-    u = (u || "").replace(/m/g, "") + "m";
-    var p = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
-      return a;
-    }).replace(/<<value>>/g, function() {
-      return i;
-    });
-    return RegExp(p, u);
-  }
-  r.languages.yaml = {
-    scalar: {
-      pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
-        return a;
-      })),
-      lookbehind: !0,
-      alias: "string"
-    },
-    comment: /#.*/,
-    key: {
-      pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
-        return a;
-      }).replace(/<<key>>/g, function() {
-        return "(?:" + d + "|" + o + ")";
-      })),
-      lookbehind: !0,
-      greedy: !0,
-      alias: "atrule"
-    },
-    directive: {
-      pattern: /(^[ \t]*)%.+/m,
-      lookbehind: !0,
-      alias: "important"
-    },
-    datetime: {
-      pattern: e(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
-      lookbehind: !0,
-      alias: "number"
-    },
-    boolean: {
-      pattern: e(/false|true/.source, "i"),
-      lookbehind: !0,
-      alias: "important"
-    },
-    null: {
-      pattern: e(/null|~/.source, "i"),
-      lookbehind: !0,
-      alias: "important"
-    },
-    string: {
-      pattern: e(o),
-      lookbehind: !0,
-      greedy: !0
-    },
-    number: {
-      pattern: e(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
-      lookbehind: !0
-    },
-    tag: n,
-    important: t,
-    punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
-  }, r.languages.yml = r.languages.yaml;
-})(Prism);