var p, b;
function x() {
  if (b)
    return p;
  b = 1, p = n, n.displayName = "lisp", n.aliases = [];
  function n(m) {
    (function(t) {
      function d(u) {
        return RegExp(/(\()/.source + "(?:" + u + ")" + /(?=[\s\)])/.source);
      }
      function c(u) {
        return RegExp(/([\s([])/.source + "(?:" + u + ")" + /(?=[\s)])/.source);
      }
      var e = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source, k = "&" + e, a = "(\\()", v = "(?=\\))", g = "(?=\\s)", s = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source, r = {
        // Three or four semicolons are considered a heading.
        // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
        heading: {
          pattern: /;;;.*/,
          alias: ["comment", "title"]
        },
        comment: /;.*/,
        string: {
          pattern: /"(?:[^"\\]|\\.)*"/,
          greedy: !0,
          inside: {
            argument: /[-A-Z]+(?=[.,\s])/,
            symbol: RegExp("`" + e + "'")
          }
        },
        "quoted-symbol": {
          pattern: RegExp("#?'" + e),
          alias: ["variable", "symbol"]
        },
        "lisp-property": {
          pattern: RegExp(":" + e),
          alias: "property"
        },
        splice: {
          pattern: RegExp(",@?" + e),
          alias: ["symbol", "variable"]
        },
        keyword: [{
          pattern: RegExp(a + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + g),
          lookbehind: !0
        }, {
          pattern: RegExp(a + "(?:append|by|collect|concat|do|finally|for|in|return)" + g),
          lookbehind: !0
        }],
        declare: {
          pattern: d(/declare/.source),
          lookbehind: !0,
          alias: "keyword"
        },
        interactive: {
          pattern: d(/interactive/.source),
          lookbehind: !0,
          alias: "keyword"
        },
        boolean: {
          pattern: c(/nil|t/.source),
          lookbehind: !0
        },
        number: {
          pattern: c(/[-+]?\d+(?:\.\d*)?/.source),
          lookbehind: !0
        },
        defvar: {
          pattern: RegExp(a + "def(?:const|custom|group|var)\\s+" + e),
          lookbehind: !0,
          inside: {
            keyword: /^def[a-z]+/,
            variable: RegExp(e)
          }
        },
        defun: {
          pattern: RegExp(a + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + e + /\s+\(/.source + s + /\)/.source),
          lookbehind: !0,
          greedy: !0,
          inside: {
            keyword: /^(?:cl-)?def\S+/,
            // See below, this property needs to be defined later so that it can
            // reference the language object.
            arguments: null,
            function: {
              pattern: RegExp("(^\\s)" + e),
              lookbehind: !0
            },
            punctuation: /[()]/
          }
        },
        lambda: {
          pattern: RegExp(a + "lambda\\s+\\(\\s*(?:&?" + e + "(?:\\s+&?" + e + ")*\\s*)?\\)"),
          lookbehind: !0,
          greedy: !0,
          inside: {
            keyword: /^lambda/,
            // See below, this property needs to be defined later so that it can
            // reference the language object.
            arguments: null,
            punctuation: /[()]/
          }
        },
        car: {
          pattern: RegExp(a + e),
          lookbehind: !0
        },
        punctuation: [
          // open paren, brackets, and close paren
          /(?:['`,]?\(|[)\[\]])/,
          // cons
          {
            pattern: /(\s)\.(?=\s)/,
            lookbehind: !0
          }
        ]
      }, o = {
        "lisp-marker": RegExp(k),
        varform: {
          pattern: RegExp(/\(/.source + e + /\s+(?=\S)/.source + s + /\)/.source),
          inside: r
        },
        argument: {
          pattern: RegExp(/(^|[\s(])/.source + e),
          lookbehind: !0,
          alias: "variable"
        },
        rest: r
      }, i = "\\S+(?:\\s+\\S+)*", l = {
        pattern: RegExp(a + s + v),
        lookbehind: !0,
        inside: {
          "rest-vars": {
            pattern: RegExp("&(?:body|rest)\\s+" + i),
            inside: o
          },
          "other-marker-vars": {
            pattern: RegExp("&(?:aux|optional)\\s+" + i),
            inside: o
          },
          keys: {
            pattern: RegExp("&key\\s+" + i + "(?:\\s+&allow-other-keys)?"),
            inside: o
          },
          argument: {
            pattern: RegExp(e),
            alias: "variable"
          },
          punctuation: /[()]/
        }
      };
      r.lambda.inside.arguments = l, r.defun.inside.arguments = t.util.clone(l), r.defun.inside.arguments.inside.sublist = l, t.languages.lisp = r, t.languages.elisp = r, t.languages.emacs = r, t.languages["emacs-lisp"] = r;
    })(m);
  }
  return p;
}
export {
  x as __require
};
