{"version":3,"sources":["jsdelivr-header.js","/npm/markdown-it-prism@3.0.1/build/index.js"],"names":[],"mappings":"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","file":"/npm/markdown-it-prism@3.0.1/build/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/markdown-it-prism@3.0.1/build/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = markdownItPrism;\nvar _prismjs = _interopRequireDefault(require(\"prismjs\"));\nvar _components = _interopRequireDefault(require(\"prismjs/components/\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nfunction _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(r) { if (Array.isArray(r)) return r; }\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nconst SPECIFIED_LANGUAGE_META_KEY = 'de.joshuagleitze.markdown-it-prism.specifiedLanguage';\nconst DEFAULTS = {\n  highlightInlineCode: false,\n  plugins: [],\n  init: () => {\n    // do nothing by default\n  },\n  defaultLanguageForUnknown: undefined,\n  defaultLanguageForUnspecified: undefined,\n  defaultLanguage: undefined\n};\n\n/**\n * Loads the provided `lang` into prism.\n *\n * @param lang\n *        Code of the language to load.\n * @return The Prism language object for the provided {@code lang} code. {@code undefined} if the language is not known to Prism.\n */\nfunction loadPrismLang(lang) {\n  if (!lang) return undefined;\n  let langObject = _prismjs.default.languages[lang];\n  if (langObject === undefined) {\n    (0, _components.default)([lang]);\n    langObject = _prismjs.default.languages[lang];\n  }\n  return langObject;\n}\n\n/**\n * Loads the provided Prism plugin.\n * @param name\n *        Name of the plugin to load.\n * @throws {Error} If there is no plugin with the provided `name`.\n */\nfunction loadPrismPlugin(name) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    require(`prismjs/plugins/${name}/prism-${name}`);\n  } catch (cause) {\n    throw new Error(`Cannot load Prism plugin \"${name}\". Please check the spelling.`, {\n      cause\n    });\n  }\n}\n\n/**\n * Select the language to use for highlighting, based on the provided options and the specified language.\n *\n * @param options\n *        The options that were used to initialise the plugin.\n * @param lang\n *        Code of the language to highlight the text in.\n * @return The name of the language to use and the Prism language object for that language.\n */\nfunction selectLanguage(options, lang) {\n  let langToUse = lang;\n  if (langToUse === '' && options.defaultLanguageForUnspecified !== undefined) {\n    langToUse = options.defaultLanguageForUnspecified;\n  }\n  let prismLang = loadPrismLang(langToUse);\n  if (prismLang === undefined && options.defaultLanguageForUnknown !== undefined) {\n    langToUse = options.defaultLanguageForUnknown;\n    prismLang = loadPrismLang(langToUse);\n  }\n  return [langToUse, prismLang];\n}\n\n/**\n * Highlights the provided text using Prism.\n *\n * @param markdownit\n *        The markdown-it instance.\n * @param options\n *        The options that have been used to initialise the plugin.\n * @param text\n *        The text to highlight.\n * @param lang\n *        Code of the language to highlight the text in.\n * @return If Prism knows the language that {@link selectLanguage} returns for `lang`, the `text` highlighted for that language. Otherwise, `text`\n *  html-escaped.\n */\nfunction highlight(markdownit, options, text, lang) {\n  return highlightWithSelectedLanguage(markdownit, options, text, selectLanguage(options, lang));\n}\n\n/**\n * Highlights the provided text using Prism.\n *\n * @param markdownit\n *        The markdown-it instance.\n * @param options\n *        The options that have been used to initialise the plugin.\n * @param text\n *        The text to highlight.\n * @param lang\n *        The selected Prism language to use for highlighting.\n * @return If Prism knows the language that {@link selectLanguage} returns for `lang`, the `text` highlighted for that language. Otherwise, `text`\n *  html-escaped.\n */\nfunction highlightWithSelectedLanguage(markdownit, options, text, [langToUse, prismLang]) {\n  return prismLang ? _prismjs.default.highlight(text, prismLang, langToUse) : markdownit.utils.escapeHtml(text);\n}\n\n/**\n * Construct the class name for the provided `lang`.\n *\n * @param markdownit\n *        The markdown-it instance.\n * @param lang\n *        The selected language.\n * @return the class to use for `lang`.\n */\nfunction languageClass(markdownit, lang) {\n  return markdownit.options.langPrefix + lang;\n}\n\n/**\n * A {@link RuleCore} that searches for and extracts language specifications on inline code tokens.\n */\nfunction inlineCodeLanguageRule(state) {\n  var _iterator = _createForOfIteratorHelper(state.tokens),\n    _step;\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      const inlineToken = _step.value;\n      if (inlineToken.type === 'inline' && inlineToken.children !== null) {\n        var _iterator2 = _createForOfIteratorHelper(inlineToken.children.entries()),\n          _step2;\n        try {\n          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n            const _step2$value = _slicedToArray(_step2.value, 2),\n              index = _step2$value[0],\n              token = _step2$value[1];\n            if (token.type === 'code_inline' && index + 1 < inlineToken.children.length) {\n              extractInlineCodeSpecifiedLanguage(token, inlineToken.children[index + 1]);\n            }\n          }\n        } catch (err) {\n          _iterator2.e(err);\n        } finally {\n          _iterator2.f();\n        }\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n\n/**\n * Searches for a language specification after an inline code token (e.g. ``{language=cpp}). If present, extracts the language, sets\n * it on `inlineCodeToken`’s meta, and removes the specification.\n *\n * @param inlineCodeToken\n *  The inline code token for which to extract the language.\n * @param followingToken\n *    The token immediately following the `inlineCodeToken`.\n */\nfunction extractInlineCodeSpecifiedLanguage(inlineCodeToken, followingToken) {\n  const languageSpecificationMatch = followingToken.content.match(/^\\{((?:[^\\s}]+\\s)*)language=([^\\s}]+)((?:\\s[^\\s}]+)*)}/);\n  if (languageSpecificationMatch !== null) {\n    inlineCodeToken.meta = _objectSpread(_objectSpread({}, inlineCodeToken.meta), {}, {\n      [SPECIFIED_LANGUAGE_META_KEY]: languageSpecificationMatch[2]\n    });\n    followingToken.content = followingToken.content.slice(languageSpecificationMatch[0].length);\n    if (languageSpecificationMatch[1] || languageSpecificationMatch[3]) {\n      followingToken.content = `{${languageSpecificationMatch[1] || ''}${(languageSpecificationMatch[3] || ' ').slice(1)}}${followingToken.content}`;\n    }\n  }\n}\n\n/**\n * Patch the `<pre>` and `<code>` tags produced by the `existingRule` for fenced code blocks.\n *\n * @param markdownit\n *        The markdown-it instance.\n * @param options\n *        The options that have been used to initialise the plugin.\n * @param existingRule\n *        The previously configured render rule for fenced code blocks.\n */\nfunction applyCodeAttributes(markdownit, options, existingRule) {\n  return (tokens, idx, renderOptions, env, self) => {\n    const fenceToken = tokens[idx];\n    const info = fenceToken.info ? markdownit.utils.unescapeAll(fenceToken.info).trim() : '';\n    const lang = info.split(/(\\s+)/g)[0];\n    const _selectLanguage = selectLanguage(options, lang),\n      _selectLanguage2 = _slicedToArray(_selectLanguage, 1),\n      langToUse = _selectLanguage2[0];\n    if (!langToUse) {\n      return existingRule(tokens, idx, renderOptions, env, self);\n    } else {\n      fenceToken.info = langToUse;\n      const existingResult = existingRule(tokens, idx, renderOptions, env, self);\n      const langClass = languageClass(markdownit, markdownit.utils.escapeHtml(langToUse));\n      return existingResult.replace(/<((?:pre|code)[^>]*?)(?:\\s+class=\"([^\"]*)\"([^>]*))?>/g, (match, tagStart, existingClasses, tagEnd) => existingClasses !== null && existingClasses !== void 0 && existingClasses.includes(langClass) ? match : `<${tagStart} class=\"${existingClasses ? `${existingClasses} ` : ''}${langClass}\"${tagEnd || ''}>`);\n    }\n  };\n}\n\n/**\n * Renders inline code tokens by highlighting them with Prism.\n *\n * @param markdownit\n *        The markdown-it instance.\n * @param options\n *        The options that have been used to initialise the plugin.\n * @param existingRule\n *        The previously configured render rule for inline code.\n */\nfunction renderInlineCode(markdownit, options, existingRule) {\n  return (tokens, idx, renderOptions, env, self) => {\n    const inlineCodeToken = tokens[idx];\n    const specifiedLanguage = inlineCodeToken.meta ? inlineCodeToken.meta[SPECIFIED_LANGUAGE_META_KEY] || '' : '';\n    const _selectLanguage3 = selectLanguage(options, specifiedLanguage),\n      _selectLanguage4 = _slicedToArray(_selectLanguage3, 2),\n      langToUse = _selectLanguage4[0],\n      prismLang = _selectLanguage4[1];\n    if (!langToUse) {\n      return existingRule(tokens, idx, renderOptions, env, self);\n    } else {\n      const highlighted = highlightWithSelectedLanguage(markdownit, options, inlineCodeToken.content, [langToUse, prismLang]);\n      inlineCodeToken.attrJoin('class', languageClass(markdownit, langToUse));\n      return `<code${self.renderAttrs(inlineCodeToken)}>${highlighted}</code>`;\n    }\n  };\n}\n\n/**\n * Checks whether an option represents a valid Prism language\n *\n * @param options\n *        The options that have been used to initialise the plugin.\n * @param optionName\n *        The key of the option inside {@code options} that shall be checked.\n * @throws {Error} If the option is not set to a valid Prism language.\n */\nfunction checkLanguageOption(options, optionName) {\n  const language = options[optionName];\n  if (language !== undefined && loadPrismLang(language) === undefined) {\n    throw new Error(`Bad option ${optionName}: There is no Prism language '${language}'.`);\n  }\n}\n\n/**\n * ‘the most basic rule to render a token’ (https://github.com/markdown-it/markdown-it/blob/master/docs/examples/renderer_rules.md)\n */\nfunction renderFallback(tokens, idx, options, env, self) {\n  return self.renderToken(tokens, idx, options);\n}\n\n/**\n * Initialisation function of the plugin. This function is not called directly by clients, but is rather provided\n * to MarkdownIt’s {@link MarkdownIt.use} function.\n *\n * @param markdownit\n *        The markdown it instance the plugin is being registered to.\n * @param useroptions\n *        The options this plugin is being initialised with.\n */\nfunction markdownItPrism(markdownit, useroptions) {\n  const options = Object.assign({}, DEFAULTS, useroptions);\n  checkLanguageOption(options, 'defaultLanguage');\n  checkLanguageOption(options, 'defaultLanguageForUnknown');\n  checkLanguageOption(options, 'defaultLanguageForUnspecified');\n  options.defaultLanguageForUnknown = options.defaultLanguageForUnknown || options.defaultLanguage;\n  options.defaultLanguageForUnspecified = options.defaultLanguageForUnspecified || options.defaultLanguage;\n  options.plugins.forEach(loadPrismPlugin);\n  options.init(_prismjs.default);\n\n  // register ourselves as highlighter\n  markdownit.options.highlight = (text, lang) => highlight(markdownit, options, text, lang);\n  markdownit.renderer.rules.fence = applyCodeAttributes(markdownit, options, markdownit.renderer.rules.fence || renderFallback);\n  if (options.highlightInlineCode) {\n    markdownit.core.ruler.after('inline', 'prism_inline_code_language', inlineCodeLanguageRule);\n    markdownit.renderer.rules.code_inline = renderInlineCode(markdownit, options, markdownit.renderer.rules.code_inline || renderFallback);\n  }\n}\nmodule.exports = exports.default;\nmodule.exports.default = exports.default;"]}