@nldd/design-system 0.8.63 → 0.8.65

package/dist/components/prism-markup-DfJYPYHA.js

@@ -1,177 +0,0 @@
-Prism.languages.markup = {
-  "comment": {
-    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-    greedy: true
-  },
-  "prolog": {
-    pattern: /<\?[\s\S]+?\?>/,
-    greedy: true
-  },
-  "doctype": {
-    // https://www.w3.org/TR/xml/#NT-doctypedecl
-    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-    greedy: true,
-    inside: {
-      "internal-subset": {
-        pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-        lookbehind: true,
-        greedy: true,
-        inside: null
-        // see below
-      },
-      "string": {
-        pattern: /"[^"]*"|'[^']*'/,
-        greedy: true
-      },
-      "punctuation": /^<!|>$|[[\]]/,
-      "doctype-tag": /^DOCTYPE/i,
-      "name": /[^\s<>'"]+/
-    }
-  },
-  "cdata": {
-    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-    greedy: true
-  },
-  "tag": {
-    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-    greedy: true,
-    inside: {
-      "tag": {
-        pattern: /^<\/?[^\s>\/]+/,
-        inside: {
-          "punctuation": /^<\/?/,
-          "namespace": /^[^\s>\/:]+:/
-        }
-      },
-      "special-attr": [],
-      "attr-value": {
-        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-        inside: {
-          "punctuation": [
-            {
-              pattern: /^=/,
-              alias: "attr-equals"
-            },
-            {
-              pattern: /^(\s*)["']|["']$/,
-              lookbehind: true
-            }
-          ]
-        }
-      },
-      "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(env) {
-  if (env.type === "entity") {
-    env.attributes["title"] = env.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 addInlined(tagName, lang) {
-    var includedCdataInside = {};
-    includedCdataInside["language-" + lang] = {
-      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-      lookbehind: true,
-      inside: Prism.languages[lang]
-    };
-    includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
-    var inside = {
-      "included-cdata": {
-        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-        inside: includedCdataInside
-      }
-    };
-    inside["language-" + lang] = {
-      pattern: /[\s\S]+/,
-      inside: Prism.languages[lang]
-    };
-    var def = {};
-    def[tagName] = {
-      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
-        return tagName;
-      }), "i"),
-      lookbehind: true,
-      greedy: true,
-      inside
-    };
-    Prism.languages.insertBefore("markup", "cdata", def);
-  }
-});
-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(attrName, lang) {
-    Prism.languages.markup.tag.inside["special-attr"].push({
-      pattern: RegExp(
-        /(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-        "i"
-      ),
-      lookbehind: true,
-      inside: {
-        "attr-name": /^[^\s=]+/,
-        "attr-value": {
-          pattern: /=[\s\S]+/,
-          inside: {
-            "value": {
-              pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-              lookbehind: true,
-              alias: [lang, "language-" + lang],
-              inside: Prism.languages[lang]
-            },
-            "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/dist/components/prism-python-Tr_Ff1KJ.js

@@ -1,99 +0,0 @@
-import { g as getDefaultExportFromCjs } from "./index-BVaijKe_.js";
-function _mergeNamespaces(n, m) {
-  for (var i = 0; i < m.length; i++) {
-    const e = m[i];
-    if (typeof e !== "string" && !Array.isArray(e)) {
-      for (const k in e) {
-        if (k !== "default" && !(k in n)) {
-          const d = Object.getOwnPropertyDescriptor(e, k);
-          if (d) {
-            Object.defineProperty(n, k, d.get ? d : {
-              enumerable: true,
-              get: () => e[k]
-            });
-          }
-        }
-      }
-    }
-  }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
-}
-var prismPython$2 = {};
-var hasRequiredPrismPython;
-function requirePrismPython() {
-  if (hasRequiredPrismPython) return prismPython$2;
-  hasRequiredPrismPython = 1;
-  Prism.languages.python = {
-    "comment": {
-      pattern: /(^|[^\\])#.*/,
-      lookbehind: true,
-      greedy: true
-    },
-    "string-interpolation": {
-      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
-      greedy: true,
-      inside: {
-        "interpolation": {
-          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
-          lookbehind: true,
-          inside: {
-            "format-spec": {
-              pattern: /(:)[^:(){}]+(?=\}$)/,
-              lookbehind: true
-            },
-            "conversion-option": {
-              pattern: /![sra](?=[:}]$)/,
-              alias: "punctuation"
-            },
-            rest: null
-          }
-        },
-        "string": /[\s\S]+/
-      }
-    },
-    "triple-quoted-string": {
-      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
-      greedy: true,
-      alias: "string"
-    },
-    "string": {
-      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-      greedy: true
-    },
-    "function": {
-      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-      lookbehind: true
-    },
-    "class-name": {
-      pattern: /(\bclass\s+)\w+/i,
-      lookbehind: true
-    },
-    "decorator": {
-      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
-      lookbehind: true,
-      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;
-  return prismPython$2;
-}
-var prismPythonExports = requirePrismPython();
-const prismPython = /* @__PURE__ */ getDefaultExportFromCjs(prismPythonExports);
-const prismPython$1 = /* @__PURE__ */ _mergeNamespaces({
-  __proto__: null,
-  default: prismPython
-}, [prismPythonExports]);
-export {
-  prismPython$1 as p
-};

package/dist/components/prism-rust-CxUpjfK5.js

@@ -1,157 +0,0 @@
-import { g as getDefaultExportFromCjs } from "./index-BVaijKe_.js";
-function _mergeNamespaces(n, m) {
-  for (var i = 0; i < m.length; i++) {
-    const e = m[i];
-    if (typeof e !== "string" && !Array.isArray(e)) {
-      for (const k in e) {
-        if (k !== "default" && !(k in n)) {
-          const d = Object.getOwnPropertyDescriptor(e, k);
-          if (d) {
-            Object.defineProperty(n, k, d.get ? d : {
-              enumerable: true,
-              get: () => e[k]
-            });
-          }
-        }
-      }
-    }
-  }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
-}
-var prismRust$2 = {};
-var hasRequiredPrismRust;
-function requirePrismRust() {
-  if (hasRequiredPrismRust) return prismRust$2;
-  hasRequiredPrismRust = 1;
-  (function(Prism2) {
-    var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
-    for (var i = 0; i < 2; i++) {
-      multilineComment = multilineComment.replace(/<self>/g, function() {
-        return multilineComment;
-      });
-    }
-    multilineComment = multilineComment.replace(/<self>/g, function() {
-      return /[^\s\S]/.source;
-    });
-    Prism2.languages.rust = {
-      "comment": [
-        {
-          pattern: RegExp(/(^|[^\\])/.source + multilineComment),
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: true,
-          greedy: true
-        }
-      ],
-      "string": {
-        pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
-        greedy: true
-      },
-      "char": {
-        pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
-        greedy: true
-      },
-      "attribute": {
-        pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
-        greedy: true,
-        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: true,
-        greedy: true,
-        inside: {
-          "closure-punctuation": {
-            pattern: /^\||\|$/,
-            alias: "punctuation"
-          },
-          rest: null
-          // see below
-        }
-      },
-      "lifetime-annotation": {
-        pattern: /'\w+/,
-        alias: "symbol"
-      },
-      "fragment-specifier": {
-        pattern: /(\$\w+:)[a-z]+/,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      "variable": /\$\w+/,
-      "function-definition": {
-        pattern: /(\bfn\s+)\w+/,
-        lookbehind: true,
-        alias: "function"
-      },
-      "type-definition": {
-        pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
-        lookbehind: true,
-        alias: "class-name"
-      },
-      "module-declaration": [
-        {
-          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
-          lookbehind: true,
-          alias: "namespace"
-        },
-        {
-          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
-          lookbehind: true,
-          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": /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
-    };
-    Prism2.languages.rust["closure-params"].inside.rest = Prism2.languages.rust;
-    Prism2.languages.rust["attribute"].inside["string"] = Prism2.languages.rust["string"];
-  })(Prism);
-  return prismRust$2;
-}
-var prismRustExports = requirePrismRust();
-const prismRust = /* @__PURE__ */ getDefaultExportFromCjs(prismRustExports);
-const prismRust$1 = /* @__PURE__ */ _mergeNamespaces({
-  __proto__: null,
-  default: prismRust
-}, [prismRustExports]);
-export {
-  prismRust$1 as p
-};

package/dist/components/prism-sql-BGqCBMyJ.js

@@ -1,33 +0,0 @@
-Prism.languages.sql = {
-  "comment": {
-    pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
-    lookbehind: true
-  },
-  "variable": [
-    {
-      pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
-      greedy: true
-    },
-    /@[\w.$]+/
-  ],
-  "string": {
-    pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
-    greedy: true,
-    lookbehind: true
-  },
-  "identifier": {
-    pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
-    greedy: true,
-    lookbehind: true,
-    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/dist/components/prism-toml-Ubdq-a5x.js

@@ -1,45 +0,0 @@
-(function(Prism2) {
-  var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
-  function insertKey(pattern) {
-    return pattern.replace(/__/g, function() {
-      return key;
-    });
-  }
-  Prism2.languages.toml = {
-    "comment": {
-      pattern: /#.*/,
-      greedy: true
-    },
-    "table": {
-      pattern: RegExp(insertKey(/(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source), "m"),
-      lookbehind: true,
-      greedy: true,
-      alias: "class-name"
-    },
-    "key": {
-      pattern: RegExp(insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source), "m"),
-      lookbehind: true,
-      greedy: true,
-      alias: "property"
-    },
-    "string": {
-      pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
-      greedy: true
-    },
-    "date": [
-      {
-        // Offset Date-Time, Local Date-Time, Local Date
-        pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
-        alias: "number"
-      },
-      {
-        // Local Time
-        pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
-        alias: "number"
-      }
-    ],
-    "number": /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
-    "boolean": /\b(?:false|true)\b/,
-    "punctuation": /[.,=[\]{}]/
-  };
-})(Prism);

package/dist/components/prism-typescript-zaF4YQWN.js

@@ -1,87 +0,0 @@
-import { g as getDefaultExportFromCjs } from "./index-BVaijKe_.js";
-function _mergeNamespaces(n, m) {
-  for (var i = 0; i < m.length; i++) {
-    const e = m[i];
-    if (typeof e !== "string" && !Array.isArray(e)) {
-      for (const k in e) {
-        if (k !== "default" && !(k in n)) {
-          const d = Object.getOwnPropertyDescriptor(e, k);
-          if (d) {
-            Object.defineProperty(n, k, d.get ? d : {
-              enumerable: true,
-              get: () => e[k]
-            });
-          }
-        }
-      }
-    }
-  }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
-}
-var prismTypescript$2 = {};
-var hasRequiredPrismTypescript;
-function requirePrismTypescript() {
-  if (hasRequiredPrismTypescript) return prismTypescript$2;
-  hasRequiredPrismTypescript = 1;
-  (function(Prism2) {
-    Prism2.languages.typescript = Prism2.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: true,
-        greedy: true,
-        inside: null
-        // see below
-      },
-      "builtin": /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-    });
-    Prism2.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 Prism2.languages.typescript["parameter"];
-    delete Prism2.languages.typescript["literal-property"];
-    var typeInside = Prism2.languages.extend("typescript", {});
-    delete typeInside["class-name"];
-    Prism2.languages.typescript["class-name"].inside = typeInside;
-    Prism2.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: true,
-        inside: {
-          "function": /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-          "generic": {
-            pattern: /<[\s\S]+/,
-            // everything after the first <
-            alias: "class-name",
-            inside: typeInside
-          }
-        }
-      }
-    });
-    Prism2.languages.ts = Prism2.languages.typescript;
-  })(Prism);
-  return prismTypescript$2;
-}
-var prismTypescriptExports = requirePrismTypescript();
-const prismTypescript = /* @__PURE__ */ getDefaultExportFromCjs(prismTypescriptExports);
-const prismTypescript$1 = /* @__PURE__ */ _mergeNamespaces({
-  __proto__: null,
-  default: prismTypescript
-}, [prismTypescriptExports]);
-export {
-  prismTypescript$1 as p
-};

package/dist/components/prism-yaml-DO0f9pf6.js

@@ -1,71 +0,0 @@
-(function(Prism2) {
-  var anchorOrAlias = /[*&][^\s[\]{},]+/;
-  var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
-  var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
-  var plainKey = /(?:[^\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;
-  });
-  var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
-  function createValuePattern(value, flags) {
-    flags = (flags || "").replace(/m/g, "") + "m";
-    var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
-      return properties;
-    }).replace(/<<value>>/g, function() {
-      return value;
-    });
-    return RegExp(pattern, flags);
-  }
-  Prism2.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 properties;
-      })),
-      lookbehind: true,
-      alias: "string"
-    },
-    "comment": /#.*/,
-    "key": {
-      pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
-        return properties;
-      }).replace(/<<key>>/g, function() {
-        return "(?:" + plainKey + "|" + string + ")";
-      })),
-      lookbehind: true,
-      greedy: true,
-      alias: "atrule"
-    },
-    "directive": {
-      pattern: /(^[ \t]*)%.+/m,
-      lookbehind: true,
-      alias: "important"
-    },
-    "datetime": {
-      pattern: createValuePattern(/\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: true,
-      alias: "number"
-    },
-    "boolean": {
-      pattern: createValuePattern(/false|true/.source, "i"),
-      lookbehind: true,
-      alias: "important"
-    },
-    "null": {
-      pattern: createValuePattern(/null|~/.source, "i"),
-      lookbehind: true,
-      alias: "important"
-    },
-    "string": {
-      pattern: createValuePattern(string),
-      lookbehind: true,
-      greedy: true
-    },
-    "number": {
-      pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
-      lookbehind: true
-    },
-    "tag": tag,
-    "important": anchorOrAlias,
-    "punctuation": /---|[:[\]{}\-,|>?]|\.\.\./
-  };
-  Prism2.languages.yml = Prism2.languages.yaml;
-})(Prism);