@readme/markdown 11.7.1 → 11.7.3

package/dist/main.js

@@ -11,6 +11,332 @@
 return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
+/***/ 9762:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const modeAliases = {
+    aspx: 'asp',
+    bash: 'shell',
+    'c++': 'cplusplus',
+    'c#': 'csharp',
+    clj: 'clojure',
+    cljc: 'clojure',
+    cljx: 'clojure',
+    coffeescript: 'javascript',
+    cpp: 'cplusplus',
+    cql: 'sql',
+    cs: 'csharp',
+    docker: 'dockerfile',
+    ecmascript: 'javascript',
+    erl: 'erlang',
+    gql: 'graphql',
+    gradle: 'groovy',
+    handlebars: 'html',
+    hbs: 'html',
+    jl: 'julia',
+    jruby: 'ruby',
+    js: 'javascript',
+    kt: 'kotlin',
+    less: 'css',
+    macruby: 'ruby',
+    md: 'markdown',
+    ml: 'ocaml',
+    mssql: 'sql',
+    mysql: 'sql',
+    node: 'javascript',
+    'obj-c': 'objectivec',
+    'obj-c++': 'objectivecplusplus',
+    'objc++': 'objectivecplusplus',
+    objc: 'objectivec',
+    objcpp: 'objectivecplusplus',
+    objectivecpp: 'objectivecplusplus',
+    pgsql: 'sql',
+    pl: 'perl',
+    plsql: 'sql',
+    postgres: 'sql',
+    postgresql: 'sql',
+    ps1: 'powershell',
+    py: 'python',
+    rake: 'ruby',
+    rb: 'ruby',
+    rbx: 'ruby',
+    rs: 'rust',
+    sass: 'css',
+    scss: 'css',
+    sh: 'shell',
+    solidity: 'sol',
+    sqlite: 'sql',
+    styl: 'css',
+    stylus: 'css',
+    xhtml: 'html',
+    yml: 'yaml',
+    zsh: 'shell',
+};
+const canonical = (language) => {
+    if (language in modeAliases)
+        return modeAliases[language];
+    return language;
+};
+exports["default"] = canonical;
+
+
+/***/ }),
+
+/***/ 7900:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const canonical_1 = __importDefault(__webpack_require__(9762));
+const modes_1 = __webpack_require__(1412);
+const uppercase_1 = __importDefault(__webpack_require__(8892));
+exports["default"] = { uppercase: uppercase_1.default, canonical: canonical_1.default, modes: modes_1.modes, getMode: modes_1.getMode };
+
+
+/***/ }),
+
+/***/ 1412:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.modes = void 0;
+exports.getMode = getMode;
+// This is a mapping of languages that we support, but aren't directly loading the mode extension
+// Within `/src/codeMirror/index.jsx` and /src/codeEditor.index.jsx
+//
+// This list also includes a number of language aliases, as because of the way we're using
+// `CodeMirror.runMode` we can't take advantage of its known aliases in the mode extensions that
+// we're loading.
+//
+// There are 2 types of lookup, single and array. e.g. `html` needs to be rendered using
+// `htmlmixed`, but `java`, needs to be rendered using the `clike` mode.
+//
+exports.modes = {
+    asp: 'clike',
+    aspx: 'clike',
+    bash: 'shell',
+    c: 'clike',
+    'c#': ['clike', 'text/x-csharp'],
+    'c++': ['clike', 'text/x-c++src'],
+    clj: 'clojure',
+    cljc: 'clojure',
+    cljx: 'clojure',
+    coffeescript: 'javascript',
+    cplusplus: ['clike', 'text/x-c++src'],
+    cpp: ['clike', 'text/x-c++src'],
+    cql: ['sql', 'text/x-cassandra'],
+    cs: ['clike', 'text/x-csharp'],
+    csharp: ['clike', 'text/x-csharp'],
+    curl: 'shell',
+    d: 'd',
+    diff: 'diff',
+    ecmascript: 'javascript',
+    erl: 'erlang',
+    go: ['go', 'text/x-go'],
+    gradle: 'groovy',
+    gql: 'graphql',
+    handlebars: 'htmlmixed',
+    hbs: 'htmlmixed',
+    html: 'htmlmixed',
+    java: ['clike', 'text/x-java'],
+    jl: 'julia',
+    js: 'javascript',
+    jsx: 'jsx',
+    json: ['javascript', 'application/ld+json'],
+    jruby: 'ruby',
+    kotlin: ['clike', 'text/x-kotlin'],
+    kt: ['clike', 'text/x-kotlin'],
+    less: 'css',
+    liquid: 'htmlmixed',
+    lua: 'lua',
+    node: 'javascript',
+    macruby: 'ruby',
+    markdown: 'gfm',
+    ml: ['mllike', 'text/x-ocaml'],
+    mssql: ['sql', 'text/x-mssql'],
+    mysql: ['sql', 'text/x-mysql'],
+    objc: ['clike', 'text/x-objectivec'],
+    'objc++': ['clike', 'text/x-objectivec++'],
+    objcpp: ['clike', 'text/x-objectivec++'],
+    objectivec: ['clike', 'text/x-objectivec'],
+    objectivecpp: ['clike', 'text/x-objectivec++'],
+    objectivecplusplus: ['clike', 'text/x-objectivec++'],
+    ocaml: ['mllike', 'text/x-ocaml'],
+    php: ['php', 'text/x-php'],
+    pgsql: ['sql', 'text/x-pgsql'],
+    pl: 'perl',
+    plsql: ['sql', 'text/x-plsql'],
+    postgres: ['sql', 'text/x-pgsql'],
+    postgresql: ['sql', 'text/x-pgsql'],
+    ps1: 'powershell',
+    py: 'python',
+    r: 'r',
+    rake: 'ruby',
+    rb: 'ruby',
+    rbx: 'ruby',
+    rs: 'rust',
+    sass: 'css',
+    scala: ['clike', 'text/x-scala'],
+    scss: 'css',
+    sh: 'shell',
+    sol: 'solidity',
+    solidity: 'solidity',
+    sql: ['sql', 'text/x-sql'],
+    sqlite: ['sql', 'text/x-sqlite'],
+    styl: 'css',
+    stylus: 'css',
+    text: ['null', 'text/plain'],
+    ts: ['javascript', 'text/typescript'],
+    typescript: ['javascript', 'text/typescript'],
+    xhtml: 'htmlmixed',
+    yml: 'yaml',
+    zsh: 'shell',
+};
+function getMode(lang) {
+    let mode = lang;
+    if (mode in exports.modes) {
+        mode = exports.modes[mode];
+        if (Array.isArray(mode)) {
+            [, mode] = mode;
+        }
+    }
+    return mode;
+}
+
+
+/***/ }),
+
+/***/ 8892:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = uppercase;
+const codeTypes = {
+    asp: 'ASP.NET',
+    aspx: 'ASP.NET',
+    bash: 'Bash',
+    c: 'C',
+    'c#': 'C#',
+    'c++': 'C++',
+    coffeescript: 'CoffeeScript',
+    clj: 'Clojure',
+    cljc: 'Clojure',
+    cljx: 'Clojure',
+    clojure: 'Clojure',
+    cplusplus: 'C++',
+    cpp: 'C++',
+    cql: 'Cassandra',
+    cs: 'C#',
+    csharp: 'C#',
+    css: 'CSS',
+    curl: 'cURL',
+    d: 'D',
+    dart: 'Dart',
+    diff: 'Diff',
+    dockerfile: 'Dockerfile',
+    ecmascript: 'ECMAScript',
+    erl: 'Erlang',
+    erlang: 'Erlang',
+    go: 'Go',
+    gql: 'GraphQL',
+    gradle: 'Gradle',
+    graphql: 'GraphQL',
+    groovy: 'Groovy',
+    handlebars: 'Handlebars',
+    hbs: 'Handlebars',
+    haml: 'HAML',
+    haxe: 'Haxe',
+    html: 'HTML',
+    http: 'HTTP',
+    java: 'Java',
+    javascript: 'JavaScript',
+    jinja2: 'Jinja2',
+    jl: 'Julia',
+    jruby: 'JRuby',
+    js: 'JavaScript',
+    json: 'JSON',
+    jsx: 'JSX',
+    julia: 'Julia',
+    kotlin: 'Kotlin',
+    kt: 'Kotlin',
+    less: 'LESS',
+    liquid: 'Liquid',
+    lua: 'Lua',
+    macruby: 'MacRuby',
+    markdown: 'Markdown',
+    md: 'Markdown',
+    mermaid: 'Mermaid', // syntax highlighting not supported yet
+    ml: 'OCaml',
+    mssql: 'SQL Server',
+    mysql: 'MySQL',
+    node: 'Node',
+    objc: 'Objective-C',
+    'objc++': 'Objective-C++',
+    objcpp: 'Objective-C++',
+    objectivec: 'Objective-C',
+    objectivecpp: 'Objective-C++',
+    objectivecplusplus: 'Objective-C++',
+    ocaml: 'OCaml',
+    perl: 'Perl',
+    php: 'PHP',
+    pl: 'Perl',
+    pgsql: 'PL/pgSQL',
+    plsql: 'PL/SQL',
+    postgres: 'PostgreSQL',
+    postgresql: 'PostgreSQL',
+    powershell: 'PowerShell',
+    ps1: 'PowerShell',
+    python: 'Python',
+    py: 'Python',
+    r: 'R',
+    rake: 'Rake',
+    rb: 'Ruby',
+    rbx: 'Rubinius',
+    rs: 'Rust',
+    ruby: 'Ruby',
+    rust: 'Rust',
+    sass: 'Sass',
+    scala: 'Scala',
+    scss: 'SCSS',
+    sh: 'Shell',
+    shell: 'Shell',
+    smarty: 'Smarty',
+    solidity: 'Solidity',
+    sql: 'SQL',
+    sqlite: 'SQLite',
+    stylus: 'Stylus',
+    styl: 'Stylus',
+    swift: 'Swift',
+    text: 'Text',
+    toml: 'TOML',
+    twig: 'Twig',
+    typescript: 'TypeScript',
+    xhtml: 'XHTML',
+    xml: 'XML',
+    yaml: 'YAML',
+    yml: 'YAML',
+    zsh: 'Zsh',
+};
+function uppercase(language) {
+    if (language in codeTypes)
+        return codeTypes[language];
+    return language;
+}
+
+
+/***/ }),
+
 /***/ 9214:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
@@ -8620,7 +8946,7 @@ module.exports = { nanoid, customAlphabet }
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 /******/ 	
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;
@@ -8974,6 +9300,7 @@ let syntaxHighlighter;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 let canonicalLanguage = lang => '';
 if (typeof window !== 'undefined') {
+    // @ts-expect-error this library does not have any types defined
     Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 3966, 23)).then(module => {
         syntaxHighlighter = module.default;
         canonicalLanguage = module.canonical;
@@ -9017,13 +9344,15 @@ const Code = (props) => {
 };
 /* harmony default export */ const components_Code = (Code);
 
-// EXTERNAL MODULE: external "@readme/syntax-highlighter"
-var syntax_highlighter_ = __webpack_require__(3966);
+// EXTERNAL MODULE: ./node_modules/@readme/syntax-highlighter/dist-utils/index.js
+var dist_utils = __webpack_require__(7900);
+var dist_utils_default = /*#__PURE__*/__webpack_require__.n(dist_utils);
 ;// ./components/CodeTabs/index.tsx
 
 
 
 let mermaid;
+const { uppercase } = (dist_utils_default());
 const CodeTabs = (props) => {
     const { children } = props;
     const theme = (0,external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.useContext)(Theme);
@@ -9061,7 +9390,7 @@ const CodeTabs = (props) => {
         external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("div", { className: "CodeTabs-toolbar" }, (Array.isArray(children) ? children : [children]).map((pre, i) => {
             const { meta, lang } = pre.props.children.props;
             /* istanbul ignore next */
-            return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("button", { key: i, onClick: e => handleClick(e, i), type: "button", value: lang }, meta || `${!lang ? 'Text' : (0,syntax_highlighter_.uppercase)(lang)}`));
+            return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("button", { key: i, onClick: e => handleClick(e, i), type: "button", value: lang }, meta || `${!lang ? 'Text' : uppercase(lang)}`));
         })),
         external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("div", { className: "CodeTabs-inner" }, children)));
 };
@@ -82659,59 +82988,16 @@ const lib_s = create_h_createH(node_modules_property_information_svg, 'g', svg_c
 
 
 
-
-const isCalloutNode = (node) => {
-    if (!node || typeof node !== 'object')
-        return false;
-    const { type, name, tagName, data, properties } = node;
-    if (type === 'mdxJsxFlowElement' && name === 'Callout') {
-        return true;
-    }
-    if (type !== 'element')
-        return false;
-    if (tagName === 'Callout')
-        return true;
-    if (typeof data === 'object' && data && 'hName' in data) {
-        const { hName } = data;
-        if (hName === 'Callout')
-            return true;
-    }
-    if (tagName !== 'blockquote')
-        return false;
-    if (!properties || typeof properties !== 'object')
-        return false;
-    const { className } = properties;
-    if (!className)
-        return false;
-    if (Array.isArray(className)) {
-        return className.some(cls => typeof cls === 'string' && cls.startsWith('callout'));
-    }
-    if (typeof className === 'string') {
-        return className.includes('callout');
-    }
-    return false;
-};
+/*
+ * A rehype plugin to generate a flat list of top-level headings or jsx flow
+ * elements.
+ */
 const rehypeToc = ({ components = {} }) => {
     return (tree) => {
         if (hasNamedExport(tree, 'toc'))
             return;
-        const headings = [];
-        visit(tree, (node, _index, parent) => {
-            if (isCalloutNode(node)) {
-                return SKIP;
-            }
-            const insideCallout = parent ? isCalloutNode(parent) : false;
-            if (insideCallout) {
-                return undefined;
-            }
-            if (node.type === 'element' && ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(node.tagName)) {
-                headings.push(node);
-            }
-            if (node.type === 'mdxJsxFlowElement' && node.name && node.name in components) {
-                headings.push(node);
-            }
-            return undefined;
-        });
+        const headings = tree.children.filter(child => (child.type === 'element' && ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(child.tagName)) ||
+            (child.type === 'mdxJsxFlowElement' && child.name in components));
         tree.children.unshift({
             type: 'mdxjsEsm',
             data: {
@@ -82743,6 +83029,10 @@ const rehypeToc = ({ components = {} }) => {
 };
 const MAX_DEPTH = 2;
 const getDepth = (el) => parseInt(el.tagName?.match(/^h(\d)/)[1], 10);
+/*
+ * `tocToHast` consumes the list generated by `rehypeToc` and produces a hast
+ * of nested lists to be rendered as a table of contents.
+ */
 const tocToHast = (headings = []) => {
     const min = Math.min(...headings.map(getDepth));
     const ast = hastscript_lib_h('ul');
@@ -82766,17 +83056,19 @@ const tocToHast = (headings = []) => {
     });
     return ast;
 };
+/*
+ * `tocHastToMdx` is a utility for combining `TocList`s of a root document and
+ * any child components it may have. Once combined it will generate a markdown
+ * doc representing a table of contents.
+ */
 const tocHastToMdx = (toc, components) => {
-    const tree = { type: 'root', children: toc };
-    visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
-        const subToc = components[node.name] || [];
-        parent.children.splice(index, 1, ...subToc);
+    if (typeof toc === 'undefined')
+        return '';
+    const injected = toc.flatMap(node => {
+        return node.type === 'mdxJsxFlowElement' && node.name in components ? components[node.name] || [] : node;
     });
-    const tocHast = tocToHast(tree.children);
-    // @ts-expect-error: tocHast is extending Element, but to please mdx we need
-    // to cast it to Root. But I think there's something wrong with our
-    // RootContentMap type.
-    return lib_mdx(tocHast, { hast: true });
+    const tocHast = tocToHast(injected);
+    return lib_mdx({ type: 'root', children: [tocHast] }, { hast: true });
 };
 
 ;// ./lib/compile.ts