laif-ds 0.2.85 → 0.2.87

package/dist/node_modules/prismjs/components/prism-markdown.js

@@ -1,301 +0,0 @@
-"use client";
-(function(e) {
-  var f = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
-  function d(n) {
-    return n = n.replace(/<inner>/g, function() {
-      return f;
-    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + n + ")");
-  }
-  var g = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, p = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
-    return g;
-  }), c = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
-  e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
-    "front-matter-block": {
-      pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        punctuation: /^---|---$/,
-        "front-matter": {
-          pattern: /\S+(?:\s+\S+)*/,
-          alias: ["yaml", "language-yaml"],
-          inside: e.languages.yaml
-        }
-      }
-    },
-    blockquote: {
-      // > ...
-      pattern: /^>(?:[\t ]*>)*/m,
-      alias: "punctuation"
-    },
-    table: {
-      pattern: RegExp("^" + p + c + "(?:" + p + ")*", "m"),
-      inside: {
-        "table-data-rows": {
-          pattern: RegExp("^(" + p + c + ")(?:" + p + ")*$"),
-          lookbehind: !0,
-          inside: {
-            "table-data": {
-              pattern: RegExp(g),
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        },
-        "table-line": {
-          pattern: RegExp("^(" + p + ")" + c + "$"),
-          lookbehind: !0,
-          inside: {
-            punctuation: /\||:?-{3,}:?/
-          }
-        },
-        "table-header-row": {
-          pattern: RegExp("^" + p + "$"),
-          inside: {
-            "table-header": {
-              pattern: RegExp(g),
-              alias: "important",
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        }
-      }
-    },
-    code: [
-      {
-        // Prefixed by 4 spaces or 1 tab and preceded by an empty line
-        pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      {
-        // ```optional language
-        // code block
-        // ```
-        pattern: /^```[\s\S]*?^```$/m,
-        greedy: !0,
-        inside: {
-          "code-block": {
-            pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
-            lookbehind: !0
-          },
-          "code-language": {
-            pattern: /^(```).+/,
-            lookbehind: !0
-          },
-          punctuation: /```/
-        }
-      }
-    ],
-    title: [
-      {
-        // title 1
-        // =======
-        // title 2
-        // -------
-        pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
-        alias: "important",
-        inside: {
-          punctuation: /==+$|--+$/
-        }
-      },
-      {
-        // # title 1
-        // ###### title 6
-        pattern: /(^\s*)#.+/m,
-        lookbehind: !0,
-        alias: "important",
-        inside: {
-          punctuation: /^#+|#+$/
-        }
-      }
-    ],
-    hr: {
-      // ***
-      // ---
-      // * * *
-      // -----------
-      pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    list: {
-      // * item
-      // + item
-      // - item
-      // 1. item
-      pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    "url-reference": {
-      // [id]: http://example.com "Optional title"
-      // [id]: http://example.com 'Optional title'
-      // [id]: http://example.com (Optional title)
-      // [id]: <http://example.com> "Optional title"
-      pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
-      inside: {
-        variable: {
-          pattern: /^(!?\[)[^\]]+/,
-          lookbehind: !0
-        },
-        string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
-        punctuation: /^[\[\]!:]|[<>]/
-      },
-      alias: "url"
-    },
-    bold: {
-      // **strong**
-      // __strong__
-      // allow one nested instance of italic text using the same delimiter
-      pattern: d(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^..)[\s\S]+(?=..$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /\*\*|__/
-      }
-    },
-    italic: {
-      // *em*
-      // _em_
-      // allow one nested instance of bold text using the same delimiter
-      pattern: d(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^.)[\s\S]+(?=.$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /[*_]/
-      }
-    },
-    strike: {
-      // ~~strike through~~
-      // ~strike~
-      // eslint-disable-next-line regexp/strict
-      pattern: d(/(~~?)(?:(?!~)<inner>)+\2/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^~~?)[\s\S]+(?=\1$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /~~?/
-      }
-    },
-    "code-snippet": {
-      // `code`
-      // ``code``
-      pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
-      lookbehind: !0,
-      greedy: !0,
-      alias: ["code", "keyword"]
-    },
-    url: {
-      // [example](http://example.com "Optional title")
-      // [example][id]
-      // [example] [id]
-      pattern: d(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        operator: /^!/,
-        content: {
-          pattern: /(^\[)[^\]]+(?=\])/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        variable: {
-          pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
-          lookbehind: !0
-        },
-        url: {
-          pattern: /(^\]\()[^\s)]+/,
-          lookbehind: !0
-        },
-        string: {
-          pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
-          lookbehind: !0
-        }
-      }
-    }
-  }), ["url", "bold", "italic", "strike"].forEach(function(n) {
-    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(t) {
-      n !== t && (e.languages.markdown[n].inside.content.inside[t] = e.languages.markdown[t]);
-    });
-  }), e.hooks.add("after-tokenize", function(n) {
-    if (n.language !== "markdown" && n.language !== "md")
-      return;
-    function t(i) {
-      if (!(!i || typeof i == "string"))
-        for (var r = 0, u = i.length; r < u; r++) {
-          var o = i[r];
-          if (o.type !== "code") {
-            t(o.content);
-            continue;
-          }
-          var l = o.content[1], a = o.content[3];
-          if (l && a && l.type === "code-language" && a.type === "code-block" && typeof l.content == "string") {
-            var s = l.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
-            s = (/[a-z][\w-]*/i.exec(s) || [""])[0].toLowerCase();
-            var b = "language-" + s;
-            a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, b] : a.alias.push(b) : a.alias = [b];
-          }
-        }
-    }
-    t(n.tokens);
-  }), e.hooks.add("wrap", function(n) {
-    if (n.type === "code-block") {
-      for (var t = "", i = 0, r = n.classes.length; i < r; i++) {
-        var u = n.classes[i], o = /language-(.+)/.exec(u);
-        if (o) {
-          t = o[1];
-          break;
-        }
-      }
-      var l = e.languages[t];
-      if (l)
-        n.content = e.highlight(m(n.content), l, t);
-      else if (t && t !== "none" && e.plugins.autoloader) {
-        var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
-        n.attributes.id = a, e.plugins.autoloader.loadLanguages(t, function() {
-          var s = document.getElementById(a);
-          s && (s.innerHTML = e.highlight(s.textContent, e.languages[t], t));
-        });
-      }
-    }
-  });
-  var h = RegExp(e.languages.markup.tag.pattern.source, "gi"), k = {
-    amp: "&",
-    lt: "<",
-    gt: ">",
-    quot: '"'
-  }, _ = String.fromCodePoint || String.fromCharCode;
-  function m(n) {
-    var t = n.replace(h, "");
-    return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(i, r) {
-      if (r = r.toLowerCase(), r[0] === "#") {
-        var u;
-        return r[1] === "x" ? u = parseInt(r.slice(2), 16) : u = Number(r.slice(1)), _(u);
-      } else {
-        var o = k[r];
-        return o || i;
-      }
-    }), t;
-  }
-  e.languages.md = e.languages.markdown;
-})(Prism);

package/dist/node_modules/prismjs/components/prism-markup.js

@@ -1,174 +0,0 @@
-"use client";
-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/dist/node_modules/prismjs/components/prism-objectivec.js

@@ -1,11 +0,0 @@
-"use client";
-Prism.languages.objectivec = Prism.languages.extend("c", {
-  string: {
-    pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-    greedy: !0
-  },
-  keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
-  operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
-});
-delete Prism.languages.objectivec["class-name"];
-Prism.languages.objc = Prism.languages.objectivec;

package/dist/node_modules/prismjs/components/prism-powershell.js

@@ -1,56 +0,0 @@
-"use client";
-(function(r) {
-  var e = r.languages.powershell = {
-    comment: [
-      {
-        pattern: /(^|[^`])<#[\s\S]*?#>/,
-        lookbehind: !0
-      },
-      {
-        pattern: /(^|[^`])#.*/,
-        lookbehind: !0
-      }
-    ],
-    string: [
-      {
-        pattern: /"(?:`[\s\S]|[^`"])*"/,
-        greedy: !0,
-        inside: null
-        // see below
-      },
-      {
-        pattern: /'(?:[^']|'')*'/,
-        greedy: !0
-      }
-    ],
-    // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
-    // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
-    namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
-    boolean: /\$(?:false|true)\b/i,
-    variable: /\$\w+\b/,
-    // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
-    // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
-    // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
-    function: [
-      /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i,
-      /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
-    ],
-    // per http://technet.microsoft.com/en-us/library/hh847744.aspx
-    keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
-    operator: {
-      pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
-      lookbehind: !0
-    },
-    punctuation: /[|{}[\];(),.]/
-  };
-  e.string[0].inside = {
-    function: {
-      // Allow for one level of nesting
-      pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
-      lookbehind: !0,
-      inside: e
-    },
-    boolean: e.boolean,
-    variable: e.variable
-  };
-})(Prism);

package/dist/node_modules/prismjs/components/prism-python.js

@@ -1,69 +0,0 @@
-"use client";
-import { __exports as e } from "../../../_virtual/prism-python2.js";
-var t;
-function n() {
-  return t ? e : (t = 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, e);
-}
-export {
-  n as __require
-};