markdown-magic 3.0.0 → 3.0.1

package/lib/utils/fs.js

@@ -9,23 +9,6 @@ const { readdir, stat, readFile } = fs
 
 const IS_HIDDEN_FILE = /(^|[\\\/])\.[^\\\/\.]/g
 
-// https://github.com/lukeed/escalade
-async function escalade(start, callback) {
-	let dir = resolve('.', start)
-	let tmp, stats = await stat(dir)
-
-	if (!stats.isDirectory()) {
-		dir = dirname(dir)
-	}
-
-	while (true) {
-		tmp = await callback(dir, await readdir(dir))
-		if (tmp) return resolve(dir, tmp)
-		dir = dirname(tmp = dir)
-		if (tmp === dir) break;
-	}
-}
-
 function isRegex(thing) {
   return (thing instanceof RegExp)
 }
@@ -57,6 +40,23 @@ async function findUp(start, fileName) {
   return file
 }
 
+// https://github.com/lukeed/escalade
+async function escalade(start, callback) {
+	let dir = resolve('.', start)
+	let tmp, stats = await stat(dir)
+
+	if (!stats.isDirectory()) {
+		dir = dirname(dir)
+	}
+
+	while (true) {
+		tmp = await callback(dir, await readdir(dir))
+		if (tmp) return resolve(dir, tmp)
+		dir = dirname(tmp = dir)
+		if (tmp === dir) break;
+	}
+}
+
 // https://github.com/lukeed/totalist
 async function totalist(dir, callback, pre='') {
 	dir = resolve('.', dir)
@@ -77,8 +77,10 @@ function combineRegexes(patterns = []) {
     } else if (typeof pat === 'string' && REGEX_REGEX.test(pat)) {
       const regexInfo = pat.match(REGEX_REGEX)
       console.log('regexInfo', regexInfo)
-      // escapeRegexString
-      return regexInfo[1]
+      if (regexInfo && regexInfo[1]) {
+        // escapeRegexString
+        return regexInfo[1]
+      }
     } else if (isGlob(pat)) {
       console.log('pat', pat)
       const result = globrex(pat, { globstar: true, extended: true })

package/lib/utils/fs.test.js

@@ -15,14 +15,14 @@ test('Finds file from file', async () => {
   const startDir = path.resolve(__dirname, '../index.js')
   const file = await findUp(startDir, 'README.md')
   assert.ok(file)
-  assert.equal(path.basename(file), 'README.md')
+  assert.equal(path.basename(file || ''), 'README.md')
 })
 
 test('Finds file from dir', async () => {
   const startDir = path.resolve(__dirname, '../')
   const file = await findUp(startDir, 'README.md')
   assert.ok(file)
-  assert.equal(path.basename(file), 'README.md')
+  assert.equal(path.basename(file || ''), 'README.md')
 })
 
 test('getFilePaths /\.test\.js?$/', async () => {
@@ -42,7 +42,6 @@ test('getFilePaths /\.test\.js?$/', async () => {
     'lib/block-parser.test.js',
     'lib/cli.test.js',
     'lib/index.test.js',
-    'lib/options-parser.test.js',
     'lib/utils/fs.test.js',
     "lib/utils/md/find-frontmatter.test.js",
     "lib/utils/md/md.test.js",
@@ -76,13 +75,13 @@ test('getFilePaths /\.mdx?$/, /\.test\.js?$/', async () => {
     'lib/block-parser.test.js',
     'lib/cli.test.js',
     'lib/index.test.js',
-    'lib/options-parser.test.js',
     'lib/utils/fs.test.js',
     "lib/utils/md/find-frontmatter.test.js",
     "lib/utils/md/md.test.js",
     "lib/utils/text.test.js",
     'test/errors.test.js',
     'test/fixtures/md/basic.md',
+    "test/fixtures/md/broken-inline.md",
     'test/fixtures/md/error-missing-transforms-two.md',
     'test/fixtures/md/error-missing-transforms.md',
     'test/fixtures/md/error-no-block-transform-defined.md',
@@ -153,7 +152,6 @@ test('getFilePaths glob', async () => {
     'lib/block-parser.test.js',
     'lib/cli.test.js',
     'lib/index.test.js',
-    'lib/options-parser.test.js',
     'lib/utils/fs.test.js',
     "lib/utils/md/find-frontmatter.test.js",
     "lib/utils/md/md.test.js",
@@ -161,6 +159,7 @@ test('getFilePaths glob', async () => {
     // 'misc/old-test/main.test.js',
     'test/errors.test.js',
     'test/fixtures/md/basic.md',
+    "test/fixtures/md/broken-inline.md",
     'test/fixtures/md/error-missing-transforms-two.md',
     'test/fixtures/md/error-missing-transforms.md',
     'test/fixtures/md/error-no-block-transform-defined.md',

package/lib/utils/logs.js

@@ -61,8 +61,13 @@ function log(type, msg, customPrefix, noLog) {
   console.log(logMsg)
 }
 
-function deepLog(myObject) {
-  console.log(util.inspect(myObject, false, null, true /* enable colors */))
+function deepLog(myObject, myObjectTwo) {
+  let obj = myObject
+  if (typeof myObject === 'string') {
+    obj = myObjectTwo
+    console.log(myObject)
+  }
+  console.log(util.inspect(obj, false, null, true /* enable colors */))
 }
 
 const success = log.bind(null, 'success')

package/lib/utils/md/filters.js

@@ -1,15 +1,15 @@
-
+const IMAGE_POSTFIX_REGEX = /\.(png|apng|jpe?g|gif|webp|svg|avif)$/
 const RELATIVE_LINK_REGEX = /^(?!(?:(?:https?|ftp):\/\/|data:))((?:\.\.?\/)*)*([\w\d\-_./?=#%:+&]+)/
 
 function onlyUnique(value, index, self) {
-  return self.indexOf(value) === index;
+  return self.indexOf(value) === index
 }
 
-function isImage(link) {
-  return link.match(/(png|jpe?g|gif|webp|svg)$/)
+function isImage(link = '') {
+  return link.match(IMAGE_POSTFIX_REGEX)
 }
 
-function isRelative(filepath) {
+function isRelative(filepath = '') {
   return RELATIVE_LINK_REGEX.test(filepath)
 }
 

package/lib/utils/md/find-code-blocks.js

@@ -8,13 +8,15 @@ const REMOVE_CODE_BLOCK_REGEX = /^(?:[A-Za-z \t]*)?(```(?:[A-Za-z]*)?\n(?:[\s\S]
 /**
  * Parse code blocks out of markdown
  * @param {string} block 
+ * @param {Object} opts 
  * @returns {Object}
  * @example
  * const { blocks, errors } = findCodeBlocks(content)
  * console.log('blocks', blocks)
  * console.log('errors', errors)
  */
-function findCodeBlocks(block, filePath = '') {
+function findCodeBlocks(block, opts = {}) {
+  const { filePath = '', includePositions } = opts
   let matches
   let errors = []
   let blocks = []
@@ -34,6 +36,17 @@ function findCodeBlocks(block, filePath = '') {
     console.log(content.trim())
     console.log('───────────────────────')
     /** */
+    const codeBlock = {}
+    if (includePositions) {
+      codeBlock.line = lineNumber
+      codeBlock.index = matches.index
+    }
+
+    if (syntax) {
+      codeBlock.syntax = syntax
+    }
+    
+    codeBlock.block = match
 
     /* Validate code blocks */
     if (prefix && prefix.match(/\S/)) {
@@ -57,13 +70,8 @@ function findCodeBlocks(block, filePath = '') {
     }
 
     if (!hasError) {
-      blocks.push({
-        line: lineNumber,
-        index: matches.index,
-        syntax: syntax || '',
-        block: match,
-        code: content.trim()
-      })
+      codeBlock.code = content.trim()
+      blocks.push(codeBlock)
     }
   }
 

package/lib/utils/md/find-frontmatter.js

@@ -1,11 +1,9 @@
 const matter = require('gray-matter')
-/* Match <!-- frontmatter --> */
-// https://regex101.com/r/Q9bBxC/1
+/* Match <!-- frontmatter --> https://regex101.com/r/Q9bBxC/1 */
 const HIDDEN_FRONTMATTER_REGEX = /^<!--+(?:\r\n|\r|\n)([\w\W]*?)--+>/g
 // const HIDDEN_FRONTMATTER_REGEX = /^<!--.*((.|\r?\n)*?.*-->)/g
 
-/* Match --- frontmatter --- */
-// https://regex101.com/r/d7eAw4/1
+/* Match --- frontmatter --- https://regex101.com/r/d7eAw4/1 */
 const FRONTMATTER_REGEX = /(^--+(?:\r\n|\r|\n)([\w\W]*?)--+)/
 // const FRONTMATTER_REGEX = /^---.*((.|\r?\n)*?.*---)/gm
 
@@ -22,7 +20,7 @@ function replaceConflictingContent(str) {
     .replace(/__CLOSE_COMMENT__/g, ' -->')
 }
 
-function findFrontmatterRaw(content = '') {
+function findFrontmatter(content = '') {
   const text = removeConflictingContent(content.trim())
   const hasFrontMatter = text.match(FRONTMATTER_REGEX)
   const hasHiddenFrontMatter = text.match(HIDDEN_FRONTMATTER_REGEX)
@@ -48,14 +46,14 @@ function findFrontmatterRaw(content = '') {
       .replace(/--+>/, `---`)
   }
   return {
-    rawFrontMatter: replaceConflictingContent(raw),
+    frontMatterRaw: replaceConflictingContent(raw),
     frontMatter: replaceConflictingContent(match),
     isHidden
   }
 }
 
-function findFrontmatter(text) {
-  const { frontMatter, rawFrontMatter } = findFrontmatterRaw(text)
+function parseFrontmatter(text) {
+  const { frontMatter, frontMatterRaw } = findFrontmatter(text)
   // console.log('frontMatter', frontMatter)
   let frontmatter = { data: {}, content: '' }
   /* Missing all frontmatter */
@@ -65,10 +63,10 @@ function findFrontmatter(text) {
   }
 
   let mdContent = text
-  if (rawFrontMatter) {
+  if (frontMatterRaw) {
     mdContent = text
     // Replace frontmatter brackets
-    .replace(rawFrontMatter, frontMatter)
+    .replace(frontMatterRaw, frontMatter)
     // Replace leading lines
     // .replace(/---+\s+\n/g, '---\n')
   }
@@ -77,18 +75,18 @@ function findFrontmatter(text) {
     frontmatter = matter(mdContent)
   } catch (err) {
     /* Add line numbers to output */
-    const formattedError = rawFrontMatter.split('\n').map((line, i) => {
+    const formattedError = frontMatterRaw.split('\n').map((line, i) => {
       return `${i + 1}. ${line}`
     })
     throw new Error(`Frontmatter error:\n${err.message}\n${formattedError.join('\n')}`)
   }
   // console.log('frontMatter', frontmatter)
-  return Object.assign(frontmatter, { rawFrontMatter })
+  return Object.assign(frontmatter, { frontMatterRaw })
 }
 
 module.exports = {
+  parseFrontmatter,
   findFrontmatter,
-  findFrontmatterRaw,
   HIDDEN_FRONTMATTER_REGEX,
   FRONTMATTER_REGEX
 }

package/lib/utils/md/find-frontmatter.test.js

@@ -3,13 +3,13 @@ const fs = require('fs')
 const { test } = require('uvu')
 const assert = require('uvu/assert')
 const { findLinks } = require('./find-links')
-const { findFrontmatter } = require('./find-frontmatter')
+const { parseFrontmatter } = require('./find-frontmatter')
 
 const FILE_PATH = path.join(__dirname, 'fixtures/file-with-frontmatter.md')
 const fileWithLinks = fs.readFileSync(FILE_PATH, 'utf-8')
 
 test('Find frontmatter', async () => {
-  const frontmatter = findFrontmatter(fileWithLinks, FILE_PATH)
+  const frontmatter = parseFrontmatter(fileWithLinks)
   console.log('frontmatter', frontmatter)
   assert.is(typeof frontmatter.data, 'object')
 })

package/lib/utils/md/find-html-tags.js

@@ -33,7 +33,7 @@ function findHtmlTags(mdContents) {
     var regexSingleTag = /<([a-zA-Z1-6]+)\b([^>]*)>*(?:>([\s\S]*?)<\/\1>|\s?\/?>)/
     for (var i = 0; i < htmlTags.length; i++) {
       // console.log('htmlTags[i]', htmlTags[i])
-      var tagMatches = regexSingleTag.exec(htmlTags[i])
+      var tagMatches = regexSingleTag.exec(htmlTags[i]) || []
       // console.log('tagMatches', tagMatches)
       var [ match, tag, props ] = tagMatches
       // console.log(`Tag #${i} ${tag}`)

package/lib/utils/md/find-images-md.js

@@ -0,0 +1,27 @@
+const { onlyUnique } = require('./filters')
+
+// https://regex101.com/r/u2DwY2/2/
+const MARKDOWN_IMAGE_REGEX = /!\[[^\]]*\]\((.*?)\s*("(?:.*[^"])")?\s*\)/g
+
+/**
+ * Get markdown style images from text
+ * @param {string} text
+ * @returns {string[]}
+ */
+function findMarkdownImages(text) {
+  let matches
+  let imageLinks = []
+  while ((matches = MARKDOWN_IMAGE_REGEX.exec(text)) !== null) {
+    if (matches.index === MARKDOWN_IMAGE_REGEX.lastIndex) {
+      MARKDOWN_IMAGE_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
+    }
+    const [ match, image, altText ] = matches
+    imageLinks.push(image)
+  }
+  return imageLinks.filter(onlyUnique)
+}
+
+module.exports = {
+  findMarkdownImages,
+  MARKDOWN_IMAGE_REGEX
+}

package/lib/utils/md/find-images.js

@@ -1,67 +1,72 @@
 const { onlyUnique, isImage, isRelative } = require('./filters')
-const { findLinks, findLiveLinks } = require('./find-links')
+const { findLinks, findAbsoluteLinks } = require('./find-links')
+const { findMarkdownImages, MARKDOWN_IMAGE_REGEX } = require('./find-images-md')
 
-// https://regex101.com/r/u2DwY2/2/
-const MARKDOWN_IMAGE_REGEX = /!\[[^\]]*\]\((.*?)\s*("(?:.*[^"])")?\s*\)/g
 // https://regex101.com/r/Uxgu3P/1
 const RELATIVE_IMAGES_REGEX = /(<img.*?src=['"])(?!(?:(?:https?|ftp):\/\/|data:))(\.?\/)?(.*?)(['"].*?\/?>)/gim
 
+/**
+ * @typedef {object} findImagesOpts
+ * @property {string[]} [links] - optional links to use to avoid re-parse
+ * @property {boolean} [unique=true] - ensure links unique
+ * @property {Record<string,any>} [frontmatter] - Frontmatter data
+ */
+
+/**
+ * @typedef {object} findImagesResult
+ * @property {string[]} all - All links
+ * @property {string[]} absolute - All absolute links
+ * @property {string[]} relative - All relative links
+ * @property {string[]} md - All md style links
+ */
+
 /**
  * Get image links from content
  * @param {string} content
- * @param {array} [links] - optional links to use to avoid re-parse
- * @returns {array}
+ * @param {findImagesOpts} [opts] - optional links to use to avoid re-parse
+ * @returns {findImagesResult}
  */
 function findImages(content = '', opts = {}) {
-  const { links, unique = true } = opts
-  const foundLinks = (links && Array.isArray(links)) ? links : findLinks(content).all
+  const { links, unique = true, frontmatter } = opts
+  let foundLinks = []
+  if (links && Array.isArray(links)) {
+    foundLinks = links
+  } else {
+    const results = findLinks(content, { frontmatter })
+    foundLinks = results.links.concat(results.images)
+  }
   const imageLinks = foundLinks.filter(isImage)
-  const mdLinks = findMarkdownImages(content)
-  const allImageLinks = imageLinks.concat(mdLinks)
+  const markdownLinks = findMarkdownImages(content)
+  const allImageLinks = imageLinks.concat(markdownLinks)
   const all = (!unique) ? allImageLinks : allImageLinks.filter(onlyUnique)
   return {
     all,
-    live: all.filter((link) => !isRelative(link)),
+    absolute: all.filter((link) => !isRelative(link)),
     relative: all.filter((link) => isRelative(link)),
-    md: mdLinks
+    md: markdownLinks
   }
 }
 
 /**
- * Get live url image links
+ * Get absolute url image links
  * @param {string} content
  * @param {array} [links] - optional links to use to avoid re-parse
  * @returns {array}
  */
- function findLiveImages(content = '', links) {
-  const foundLinks = (links && Array.isArray(links)) ? links : findLiveLinks(content)
-  const imageLinks = foundLinks.filter((link) => {
-    return link.match(/(png|jpe?g|gif|webp|svg)$/)
-  })
-  const mdLinks = findMarkdownImages(content)
-  const allImageLinks = imageLinks.concat(mdLinks)
+ function findAbsoluteImages(content = '', links) {
+  const foundLinks = (links && Array.isArray(links)) ? links : findAbsoluteLinks(content)
+  const imageLinks = foundLinks.filter(isImage)
+  const markdownLinks = findMarkdownImages(content)
+  const allImageLinks = imageLinks.concat(markdownLinks)
 
   return allImageLinks
     .filter(onlyUnique)
     .filter((link) => !isRelative(link))
 }
 
-function findMarkdownImages(text) {
-  let matches
-  let imageLinks = []
-  while ((matches = MARKDOWN_IMAGE_REGEX.exec(text)) !== null) {
-    if (matches.index === MARKDOWN_IMAGE_REGEX.lastIndex) {
-      MARKDOWN_IMAGE_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
-    }
-    const [ match, image, altText ] = matches
-    imageLinks.push(image)
-  }
-  return imageLinks.filter(onlyUnique)
-}
-
 /**
  * Get relative image links from content
- * @param {string} content
+ * @param {string} text
  * @returns {array}
  */
 function findRelativeImages(text) {
@@ -94,7 +99,7 @@ function findRelativeImgTags(block) {
 
 module.exports = {
   findImages,
-  findLiveImages,
+  findAbsoluteImages,
   findRelativeImages,
   findMarkdownImages,
   MARKDOWN_IMAGE_REGEX,

package/lib/utils/md/find-links.js

@@ -1,11 +1,17 @@
 const { onlyUnique, isImage, isRelative } = require('./filters')
+const { findMarkdownImages } = require('./find-images-md')
+// Alt https://github.com/MikeKovarik/link-extract
 
 // https://regex101.com/r/In5HtG/3
-const LIVE_LINKS_REGEX = /(?:['"(])((?:https?:\/\/)[\w\d\-_,./?=#%:+&]{3,})/gmi
+// const LIVE_LINKS_REGEX = /(?:['"(])((?:https?:\/\/)[\w\d\-_,./?=#%:+&]{3,})/gmi
+// https://regex101.com/r/In5HtG/4
+const LIVE_LINKS_REGEX = /['"(]((?:https?:\/\/)[\w\d\-_,./?=#%:+&]{3,})|<(\S*:\/\/\S*)>/gmi
 // https://regex101.com/r/Nywerx/3
 const RELATIVE_LINKS_REGEX = /(src|href|\()=?(['"/])(?!(?:(?:https?|ftp):\/\/|data:))(\.?\/)?([\w\d-_./,?=#%:+&]+)(?:['")])?/gim
 // https://regex101.com/r/u2DwY2/2/
 const MARKDOWN_IMAGE_REGEX = /!\[[^\]]*\]\((.*?)\s*("(?:.*[^"])")?\s*\)/g
+// https://regex101.com/r/UeQ049/2 <https://www.markdownguide.org>
+const ANGLE_LINKS = /(<)(\S*[@:]\S*)(>)/
 
 const LINK_PATTERN = /^https?:\/\//
 
@@ -18,43 +24,64 @@ function isRemote(link) {
 }
 
 /**
- * Finds all links in text relative or otherwise
- * @param {string} mdContents 
- * @returns 
+ * @typedef {object} findLinksOpts
+ * @property {Record<string,any>} [frontmatter] - Frontmatter data
+ * @property {boolean} [unique=true] - ensure links unique
  */
-function findLinks(text, opts = {}) {
-  const { unique = true } = opts
-  const live = findLiveLinks(text)
-  const relative = findRelativeLinks(text)
-  const normalLinks = live.concat(relative)
-  const mdImgLinks = findMarkdownImageLinks(text)
 
+/**
+* @typedef {object} findLinksResult
+* @property {string[]} links - All images
+* @property {string[]} images - All live image links
+*/
 
-  let frontmatterLinks = []
-  if (opts.frontmatter) {
-    frontmatterLinks = findLinksInFrontMatter(opts.frontmatter, findLinks)
-  }
-
-  const allLinks = normalLinks.concat(mdImgLinks).concat(frontmatterLinks)
-  const all = (!unique) ? allLinks : allLinks.filter(onlyUnique)
+/**
+ * Finds all links in text relative or otherwise
+ * @param {string} text 
+ * @param {findLinksOpts} opts 
+ * @returns {findLinksResult}
+ */
+function findLinks(text, opts = {}) {
+  const { unique = true, frontmatter } = opts
+
+  const absoluteLinks = findAbsoluteLinks(text)
+  // console.log('absoluteLinks', absoluteLinks)
+  const relativeLinks = findRelativeLinks(text)
+  // console.log('relativeLinks', relativeLinks)
+  const frontmatterLinks = (frontmatter) ? findLinksInFrontMatter(frontmatter) : []
+  // console.log('frontmatterLinks', frontmatterLinks)
+  const markdownImages = findMarkdownImages(text)
+  // console.log('markdownImages', markdownImages)
+  const foundLinks = frontmatterLinks
+    .concat(absoluteLinks)
+    .concat(relativeLinks)
+    .concat(markdownImages)
   
-  let images = mdImgLinks
-  let links = []
-  for (let i = 0; i < all.length; i++) {
-    const link = all[i]
-    if (isImage(link)) {
-      images.push(link)
+  const allLinks = (!unique) ? foundLinks : foundLinks.filter(onlyUnique)
+  
+  let _images = markdownImages
+  let _links = []
+  for (let i = 0; i < allLinks.length; i++) {
+    if (isImage(allLinks[i])) {
+      _images.push(allLinks[i])
     } else {
-      links.push(link)
+      _links.push(allLinks[i])
     }
   }
   // const allImages = normalLinks.filter((link) => isImage(link)).concat(mdLinks)
   // const links = normalLinks.filter((link) => !isImage(link))
-  const allImg = images.filter(onlyUnique)
-  const allLink = links.filter(onlyUnique).filter(function(el) {
-    return allImg.indexOf(el) < 0
+  const images = _images.filter(onlyUnique)
+  const links = _links.filter(onlyUnique).filter(function(el) {
+    return images.indexOf(el) < 0
   })
+
   return {
+    links,
+    images
+  }
+  /*
+    // Old return https://github.com/DavidWells/markdown-magic/blob/b148b4ad3876c4ea07371451d230a5e9cec57ce5/lib/utils/md/find-links.js#L32-L44
+    return {
     // all,
     // live,
     // relative,
@@ -70,6 +97,7 @@ function findLinks(text, opts = {}) {
       live: allImg.filter(isRemote)
     },
   }
+  */
 }
 
 function findMarkdownImageLinks(text) {
@@ -90,15 +118,15 @@ function findMarkdownImageLinks(text) {
  * @param {string} text
  * @returns 
  */
-function findLiveLinks(text) {
+function findAbsoluteLinks(text) {
   let matches
   let links = []
   while ((matches = LIVE_LINKS_REGEX.exec(text)) !== null) {
     if (matches.index === LIVE_LINKS_REGEX.lastIndex) {
       LIVE_LINKS_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
     }
-    const [ match, url ] = matches
-    links.push(url)
+    const [ match, url, bracketLink ] = matches
+    links.push(url || bracketLink)
   }
   return links.filter(onlyUnique)
 }
@@ -140,32 +168,22 @@ function findRelativeLinks(text) {
   return relLinks.filter(onlyUnique)
 }
 
-function findLinksInFrontMatter(data, linkFinder) {
+function findLinksInFrontMatter(data) {
   const yamlStrings = traverse(data)
+  // console.log('yamlStrings', yamlStrings)
   const linksInYml = yamlStrings.map((string) => {
     if (LINK_PATTERN.test(string)) {
       return [string]
     }
     // console.log('string', string)
-    return linkFinder(string)
+    const results = findLinks(string)
+    return results.links.concat(results.images)
   })
   .filter((x) => {
-    if (Array.isArray(x)) {
+    if (x && x.length) {
       return x.length
     }
-    if (x && x.all) {
-      return x.all.length
-    }
-    return true
-  })
-  .map((x) => {
-    if (typeof x === 'string') {
-      return x
-    }
-    if (typeof x === 'object' && x.all) {
-      return x.all
-    }
-    return x
+    return false
   })
   .flat()
   // console.log('linksInYml', linksInYml)
@@ -175,7 +193,7 @@ function findLinksInFrontMatter(data, linkFinder) {
 function traverse(x, arr = []) {
   if (typeof x === 'string') {
     arr.push(x)
-  } else if (isArray(x)) {
+  } else if (Array.isArray(x)) {
     traverseArray(x, arr)
   } else if ((typeof x === 'object') && (x !== null)) {
     traverseObject(x, arr)
@@ -183,20 +201,20 @@ function traverse(x, arr = []) {
   return arr
 }
 function traverseArray(arr, acc) {
-  arr.forEach((x) => traverse(x, acc))
+  for (let i = 0; i < arr.length; i++) {
+    traverse(arr[i], acc)
+  }
 }
 function traverseObject(obj, acc) {
   for (var key in obj) {
-    if (obj.hasOwnProperty(key)) traverse(obj[key], acc)
+    if (obj.hasOwnProperty(key)) {
+      traverse(obj[key], acc)
+    }
   }
 }
 
-function isArray(o) {
-  return Object.prototype.toString.call(o) === '[object Array]'
-}
-
 module.exports = {
   findLinks,
-  findLiveLinks,
+  findAbsoluteLinks,
   findRelativeLinks
 }

package/lib/utils/md/find-unmatched-html-tags.js

@@ -1,5 +1,4 @@
 const { getLineNumberFromMatch } = require('./utils')
-// const { voidTags } = require('../html-to-json/tags')
 
 // https://regex101.com/r/he9l06/2
 // http://xahlee.info/js/html5_non-closing_tag.html
@@ -28,6 +27,6 @@ function findUnmatchedHtmlTags(block, filePath) {
 }
 
 module.exports = {
+  CLOSE_TAG_REGEX,
   findUnmatchedHtmlTags,
-  CLOSE_TAG_REGEX
 }