@anydigital/eleventy-bricks 1.0.0-alpha.19 → 1.0.0-alpha.20

package/README.md

@@ -25,6 +25,7 @@ export default function (eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricks, {
     mdAutoRawTags: true,
     mdAutoNl2br: true,
+    mdAutoLinkFavicons: true,
     siteData: true,
     filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat"],
   });
@@ -42,6 +43,7 @@ module.exports = function (eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricks, {
     mdAutoRawTags: true,
     mdAutoNl2br: true,
+    mdAutoLinkFavicons: true,
     siteData: true,
     filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat"],
   });
@@ -62,6 +64,7 @@ Import only the specific helpers you need without using the plugin:
 import {
   mdAutoRawTags,
   mdAutoNl2br,
+  mdAutoLinkFavicons,
   setAttrFilter,
   whereInFilter,
   mergeFilter,
@@ -74,6 +77,7 @@ import {
 export default function (eleventyConfig) {
   mdAutoRawTags(eleventyConfig);
   mdAutoNl2br(eleventyConfig);
+  mdAutoLinkFavicons(eleventyConfig);
   setAttrFilter(eleventyConfig);
   whereInFilter(eleventyConfig);
   mergeFilter(eleventyConfig);
@@ -92,6 +96,7 @@ export default function (eleventyConfig) {
 const {
   mdAutoRawTags,
   mdAutoNl2br,
+  mdAutoLinkFavicons,
   setAttrFilter,
   whereInFilter,
   mergeFilter,
@@ -104,6 +109,7 @@ const {
 module.exports = async function (eleventyConfig) {
   await mdAutoRawTags(eleventyConfig);
   await mdAutoNl2br(eleventyConfig);
+  await mdAutoLinkFavicons(eleventyConfig);
   await setAttrFilter(eleventyConfig);
   await whereInFilter(eleventyConfig);
   await mergeFilter(eleventyConfig);
@@ -122,12 +128,13 @@ module.exports = async function (eleventyConfig) {
 
 When using the plugin (Option 1), you can configure which helpers to enable:
 
-| Option          | Type            | Default | Description                                                      |
-| --------------- | --------------- | ------- | ---------------------------------------------------------------- |
-| `mdAutoRawTags` | boolean         | `false` | Enable the mdAutoRawTags preprocessor for Markdown files         |
-| `mdAutoNl2br`   | boolean         | `false` | Enable the mdAutoNl2br preprocessor to convert \n to `<br>` tags |
-| `siteData`      | boolean         | `false` | Enable site.year and site.prod global data                       |
-| `filters`       | array of string | `[]`    | Array of filter names to enable (see Available Filters section)  |
+| Option               | Type            | Default | Description                                                      |
+| -------------------- | --------------- | ------- | ---------------------------------------------------------------- |
+| `mdAutoRawTags`      | boolean         | `false` | Enable the mdAutoRawTags preprocessor for Markdown files         |
+| `mdAutoNl2br`        | boolean         | `false` | Enable the mdAutoNl2br preprocessor to convert \n to `<br>` tags |
+| `mdAutoLinkFavicons` | boolean         | `false` | Enable the mdAutoLinkFavicons transform to add favicons to links |
+| `siteData`           | boolean         | `false` | Enable site.year and site.prod global data                       |
+| `filters`            | array of string | `[]`    | Array of filter names to enable (see Available Filters section)  |
 
 **Available filter names for the `filters` array:**
 
@@ -144,6 +151,7 @@ When using the plugin (Option 1), you can configure which helpers to enable:
 eleventyConfig.addPlugin(eleventyBricks, {
   mdAutoRawTags: true,
   mdAutoNl2br: true,
+  mdAutoLinkFavicons: true,
   siteData: true,
   filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat"],
 });
@@ -224,6 +232,84 @@ Will render as:
 
 **Note:** This processes literal `\n` sequences (backslash followed by 'n'), not actual newline characters. Type `\n` in your source files where you want line breaks.
 
+### mdAutoLinkFavicons
+
+Automatically adds favicon images from Google's favicon service to links that display plain URLs or domain names. This transform processes all HTML output files and adds inline favicon images next to link text that appears to be a plain URL.
+
+**Why use this?**
+
+When you have links in your content that display raw URLs or domain names (like `https://example.com/page`), adding favicons provides a visual indicator of the external site. This transform automatically detects these plain-text URL links and enhances them with favicon images, making them more visually appealing and easier to recognize.
+
+**Usage:**
+
+1. Enable `mdAutoLinkFavicons` in your Eleventy config:
+
+```javascript
+import { mdAutoLinkFavicons } from "@anydigital/eleventy-bricks";
+
+export default function (eleventyConfig) {
+  mdAutoLinkFavicons(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { mdAutoLinkFavicons: true });
+}
+```
+
+**How it works:**
+
+The transform:
+
+1. Scans all HTML output files for `<a>` tags
+2. Checks if the link text appears to be a plain URL or domain
+3. Extracts the domain from the URL
+4. Removes the domain from the link text (keeping only the path)
+5. Adds a favicon image from Google's favicon service inline with the remaining text
+
+**Example:**
+
+Before transformation:
+
+```html
+<a href="https://github.com/anydigital/eleventy-bricks">https://github.com/anydigital/eleventy-bricks</a>
+```
+
+After transformation:
+
+```html
+<a href="https://github.com/anydigital/eleventy-bricks">
+  <i><img src="https://www.google.com/s2/favicons?domain=github.com&sz=32" /></i>
+  anydigital/eleventy-bricks
+</a>
+```
+
+**Rules:**
+
+- Only applies to links where the text looks like a plain URL (contains the domain or starts with `http://`/`https://`)
+- Removes the protocol and domain from the display text
+- Only applies if at least 3 characters remain after removing the domain (to avoid showing favicons for bare domain links)
+- Uses Google's favicon service at `https://www.google.com/s2/favicons?domain=DOMAIN&sz=32`
+- The favicon is wrapped in an `<i>` tag for easy styling
+
+**Styling:**
+
+You can style the favicon icons with CSS:
+
+```css
+/* Style the favicon wrapper */
+a i {
+  display: inline-block;
+  margin-right: 0.25em;
+}
+
+/* Style the favicon image */
+a i img {
+  width: 16px;
+  height: 16px;
+  vertical-align: middle;
+}
+```
+
+**Note:** This transform only processes HTML output files (those ending in `.html`). It does not modify the original content files.
+
 ### attr
 
 A filter that creates a new object with an overridden attribute value. This is useful for modifying data objects in templates without mutating the original.
@@ -781,6 +867,10 @@ The plugin also exports the following utility functions for advanced usage:
 
 - `transformAutoRaw(content)`: The transform function used by `mdAutoRawTags` preprocessor. Can be used programmatically to wrap Nunjucks syntax with raw tags.
 - `transformNl2br(content)`: The transform function used by `mdAutoNl2br` preprocessor. Can be used programmatically to convert `\n` sequences to `<br>` tags.
+- `isPlainUrlText(linkText, domain)`: Helper function that checks if link text looks like a plain URL or domain.
+- `cleanLinkText(linkText, domain)`: Helper function that cleans link text by removing protocol, domain, and leading slash.
+- `buildFaviconLink(attrs, domain, text)`: Helper function that builds HTML for a link with favicon.
+- `transformLink(match, attrs, url, linkText)`: The transform function used by `mdAutoLinkFavicons` that transforms a single link to include a favicon.
 - `merge(first, ...rest)`: The core merge function used by the `merge` filter. Can be used programmatically to merge arrays or objects.
 - `removeTag(html, tagName)`: The core function used by the `remove_tag` filter. Can be used programmatically to remove HTML tags from content.
 - `iff(trueValue, condition, falseValue)`: The core conditional function used by the `if` filter. Can be used programmatically as a ternary operator.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anydigital/eleventy-bricks",
-  "version": "1.0.0-alpha.19",
+  "version": "1.0.0-alpha.20",
   "description": "A collection of helpful utilities and filters for Eleventy (11ty)",
   "type": "module",
   "main": "./src/index.js",

package/src/eleventy.config.js

@@ -27,6 +27,7 @@ export default function (eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricksPlugin, {
     mdAutoNl2br: true,
     mdAutoRawTags: true,
+    mdAutoLinkFavicons: true,
     siteData: true,
     filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat"],
   });

package/src/index.js

@@ -1,8 +1,13 @@
 import {
   mdAutoRawTags,
   mdAutoNl2br,
+  mdAutoLinkFavicons,
   transformAutoRaw,
   transformNl2br,
+  isPlainUrlText,
+  cleanLinkText,
+  buildFaviconLink,
+  transformLink,
 } from "./markdown.js";
 import { setAttrFilter } from "./filters/attr.js";
 import { whereInFilter } from "./filters/where_in.js";
@@ -22,6 +27,7 @@ import { siteData } from "./siteData.js";
  * @param {Object} options - Plugin options
  * @param {boolean} options.mdAutoRawTags - Enable mdAutoRawTags preprocessor (default: false)
  * @param {boolean} options.mdAutoNl2br - Enable mdAutoNl2br for \n to <br> conversion (default: false)
+ * @param {boolean} options.mdAutoLinkFavicons - Enable mdAutoLinkFavicons to add favicons to plain text links (default: false)
  * @param {Array<string>} options.filters - Array of filter names to enable: 'attr', 'where_in', 'merge', 'remove_tag', 'if', 'attr_concat' (default: [])
  * @param {boolean} options.siteData - Enable site.year and site.prod global data (default: false)
  */
@@ -29,6 +35,7 @@ export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
   const plugins = {
     mdAutoRawTags,
     mdAutoNl2br,
+    mdAutoLinkFavicons,
     siteData,
   };
 
@@ -62,6 +69,7 @@ export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
 export {
   mdAutoRawTags,
   mdAutoNl2br,
+  mdAutoLinkFavicons,
   setAttrFilter,
   whereInFilter,
   mergeFilter,
@@ -72,4 +80,15 @@ export {
 };
 
 // Export transform/utility functions for advanced usage
-export { transformAutoRaw, transformNl2br, merge, removeTag, iff, attrConcat };
+export {
+  transformAutoRaw,
+  transformNl2br,
+  isPlainUrlText,
+  cleanLinkText,
+  buildFaviconLink,
+  transformLink,
+  merge,
+  removeTag,
+  iff,
+  attrConcat,
+};

package/src/markdown.js

@@ -1,9 +1,9 @@
 /**
  * Transform Nunjucks syntax in content by wrapping it with raw tags
- * 
+ *
  * This function wraps Nunjucks syntax ({{, }}, {%, %}) with {% raw %} tags
  * to prevent them from being processed by the template engine.
- * 
+ *
  * @param {string} content - The content to transform
  * @returns {string} The transformed content with Nunjucks syntax wrapped
  */
@@ -14,10 +14,10 @@ export function transformAutoRaw(content) {
 
 /**
  * mdAutoRawTags - Forbid Nunjucks processing in Markdown files
- * 
+ *
  * This preprocessor wraps Nunjucks syntax ({{, }}, {%, %}) with {% raw %} tags
  * to prevent them from being processed by the template engine in Markdown files.
- * 
+ *
  * @param {Object} eleventyConfig - The Eleventy configuration object
  */
 export function mdAutoRawTags(eleventyConfig) {
@@ -28,31 +28,119 @@ export function mdAutoRawTags(eleventyConfig) {
 
 /**
  * Transform \n sequences to <br> tags
- * 
+ *
  * This function converts literal \n sequences (double backslash + n) to HTML <br> tags.
  * It handles both double \n\n and single \n sequences, processing double ones first.
- * 
+ *
  * @param {string} content - The content to transform
  * @returns {string} The transformed content with \n converted to <br>
  */
 export function transformNl2br(content) {
   // Replace double \n\n first, then single \n to avoid double conversion
-  return content.replace(/\\n\\n/g, '<br>').replace(/\\n/g, '<br>');
+  return content.replace(/\\n\\n/g, "<br>").replace(/\\n/g, "<br>");
 }
 
 /**
  * mdAutoNl2br - Auto convert \n to <br> in markdown (especially tables)
- * 
+ *
  * This function amends the markdown library to automatically convert \n
  * to <br> tags in text content, which is particularly useful for line breaks
  * inside markdown tables where standard newlines don't work.
- * 
+ *
  * @param {Object} eleventyConfig - The Eleventy configuration object
  */
 export function mdAutoNl2br(eleventyConfig) {
-  eleventyConfig.amendLibrary("md", mdLib => {
+  eleventyConfig.amendLibrary("md", (mdLib) => {
     mdLib.renderer.rules.text = (tokens, idx) => {
       return transformNl2br(tokens[idx].content);
     };
   });
 }
+
+/**
+ * Check if link text looks like a plain URL or domain
+ *
+ * @param {string} linkText - The text content of the link
+ * @param {string} domain - The domain extracted from the URL
+ * @returns {boolean} True if the link text appears to be a plain URL
+ */
+export function isPlainUrlText(linkText, domain) {
+  return linkText.trim().includes(domain) || linkText.trim().match(/^https?:\/\//) !== null;
+}
+
+/**
+ * Clean link text by removing protocol, domain, and leading slash
+ *
+ * @param {string} linkText - The original link text
+ * @param {string} domain - The domain to remove
+ * @returns {string} The cleaned text
+ */
+export function cleanLinkText(linkText, domain) {
+  return linkText
+    .trim()
+    .replace(/^https?:\/\//, "")
+    .replace(domain, "")
+    .replace(/^\//, "");
+}
+
+/**
+ * Build HTML for a link with favicon
+ *
+ * @param {string} attrs - The link attributes (including href)
+ * @param {string} domain - The domain for the favicon
+ * @param {string} text - The text to display
+ * @returns {string} The HTML string
+ */
+export function buildFaviconLink(attrs, domain, text) {
+  return `<a ${attrs}><i><img src="https://www.google.com/s2/favicons?domain=${domain}&sz=32"></i>${text}</a>`;
+}
+
+/**
+ * Transform a single link to include a favicon
+ *
+ * @param {string} match - The full matched link HTML
+ * @param {string} attrs - The link attributes
+ * @param {string} url - The URL from the href attribute
+ * @param {string} linkText - The text content of the link
+ * @returns {string} The transformed link or original match if not applicable
+ */
+export function transformLink(match, attrs, url, linkText) {
+  try {
+    // Extract domain from URL
+    const urlObj = new URL(url, "http://dummy.com");
+    const domain = urlObj.hostname;
+
+    // Only add favicon if link text looks like a plain URL/domain
+    if (isPlainUrlText(linkText, domain)) {
+      // Remove domain from link text
+      const cleanedText = cleanLinkText(linkText, domain);
+
+      // Only apply if there are at least 2 letters remaining after domain
+      if (cleanedText.length > 2) {
+        return buildFaviconLink(attrs, domain, cleanedText);
+      }
+    }
+    return match;
+  } catch (e) {
+    // If URL parsing fails, return original match
+    return match;
+  }
+}
+
+/**
+ * mdAutoLinkFavicons - Add favicon images to plain text links
+ *
+ * This transform automatically adds favicon images from Google's favicon service
+ * to links that display plain URLs or domain names. It processes all HTML output
+ * files and adds inline favicon images next to the link text.
+ *
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function mdAutoLinkFavicons(eleventyConfig) {
+  eleventyConfig.addTransform("mdAutoLinkFavicons", function (content) {
+    if (this.page.outputPath && this.page.outputPath.endsWith(".html")) {
+      return content.replace(/<a\s+([^>]*href=["']([^"']+)["'][^>]*)>([^<]+)<\/a>/gi, transformLink);
+    }
+    return content;
+  });
+}

package/src/markdown.test.js

@@ -1,33 +1,36 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { transformAutoRaw, transformNl2br } from "./markdown.js";
+import {
+  transformAutoRaw,
+  transformNl2br,
+  isPlainUrlText,
+  cleanLinkText,
+  buildFaviconLink,
+  transformLink,
+} from "./markdown.js";
 
 describe("transformAutoRaw", () => {
   it("should wrap opening double curly braces with raw tags", () => {
     const input = "Use {{ variable }} to output.";
-    const expected =
-      "Use {% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %} to output.";
+    const expected = "Use {% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %} to output.";
     assert.equal(transformAutoRaw(input), expected);
   });
 
   it("should wrap closing double curly braces with raw tags", () => {
     const input = "{{ name }}";
-    const expected =
-      "{% raw %}{{{% endraw %} name {% raw %}}}{% endraw %}";
+    const expected = "{% raw %}{{{% endraw %} name {% raw %}}}{% endraw %}";
     assert.equal(transformAutoRaw(input), expected);
   });
 
   it("should wrap opening template tags with raw tags", () => {
     const input = "{% if condition %}";
-    const expected =
-      "{% raw %}{%{% endraw %} if condition {% raw %}%}{% endraw %}";
+    const expected = "{% raw %}{%{% endraw %} if condition {% raw %}%}{% endraw %}";
     assert.equal(transformAutoRaw(input), expected);
   });
 
   it("should wrap closing template tags with raw tags", () => {
     const input = "{% endif %}";
-    const expected =
-      "{% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
+    const expected = "{% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
     assert.equal(transformAutoRaw(input), expected);
   });
 
@@ -65,15 +68,13 @@ Some text
 
   it("should handle content with only Nunjucks syntax", () => {
     const input = "{{}}";
-    const expected =
-      "{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}";
     assert.equal(transformAutoRaw(input), expected);
   });
 
   it("should handle consecutive Nunjucks patterns", () => {
     const input = "{{{{}}}}";
-    const expected =
-      "{% raw %}{{{% endraw %}{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}{% raw %}}}{% endraw %}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}{% raw %}}}{% endraw %}";
     assert.equal(transformAutoRaw(input), expected);
   });
 
@@ -150,3 +151,223 @@ describe("transformNl2br", () => {
   });
 });
 
+describe("isPlainUrlText", () => {
+  it("should return true when linkText contains domain", () => {
+    assert.equal(isPlainUrlText("example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("https://example.com/path", "example.com"), true);
+    assert.equal(isPlainUrlText("Visit example.com for more", "example.com"), true);
+  });
+
+  it("should return true when linkText starts with http://", () => {
+    assert.equal(isPlainUrlText("http://example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("http://other.com/path", "other.com"), true);
+  });
+
+  it("should return true when linkText starts with https://", () => {
+    assert.equal(isPlainUrlText("https://example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("https://other.com/path", "other.com"), true);
+  });
+
+  it("should return false for custom link text without domain", () => {
+    assert.equal(isPlainUrlText("Click here", "example.com"), false);
+    assert.equal(isPlainUrlText("Read more", "example.com"), false);
+    assert.equal(isPlainUrlText("Documentation", "example.com"), false);
+  });
+
+  it("should handle whitespace in linkText", () => {
+    assert.equal(isPlainUrlText("  example.com  ", "example.com"), true);
+    assert.equal(isPlainUrlText("  https://example.com  ", "example.com"), true);
+  });
+
+  it("should return false for empty linkText", () => {
+    assert.equal(isPlainUrlText("", "example.com"), false);
+  });
+});
+
+describe("cleanLinkText", () => {
+  it("should remove protocol, domain, and leading slash", () => {
+    assert.equal(cleanLinkText("https://example.com/docs", "example.com"), "docs");
+    assert.equal(cleanLinkText("http://example.com/docs", "example.com"), "docs");
+    assert.equal(cleanLinkText("https://example.com/docs/guide", "example.com"), "docs/guide");
+  });
+
+  it("should handle links without protocol", () => {
+    assert.equal(cleanLinkText("example.com/docs", "example.com"), "docs");
+    assert.equal(cleanLinkText("example.com/path/to/page", "example.com"), "path/to/page");
+  });
+
+  it("should remove leading slash after domain removal", () => {
+    assert.equal(cleanLinkText("https://example.com/docs", "example.com"), "docs");
+    assert.equal(cleanLinkText("example.com/docs", "example.com"), "docs");
+  });
+
+  it("should return empty string for root domain", () => {
+    assert.equal(cleanLinkText("example.com/", "example.com"), "");
+    assert.equal(cleanLinkText("example.com", "example.com"), "");
+    assert.equal(cleanLinkText("https://example.com", "example.com"), "");
+  });
+
+  it("should handle whitespace", () => {
+    assert.equal(cleanLinkText("  https://example.com/docs  ", "example.com"), "docs");
+    assert.equal(cleanLinkText("\nhttps://example.com/docs\n", "example.com"), "docs");
+  });
+
+  it("should preserve path after domain", () => {
+    assert.equal(cleanLinkText("https://example.com/api/v1/docs", "example.com"), "api/v1/docs");
+  });
+
+  it("should handle query parameters", () => {
+    const result = cleanLinkText("https://example.com/search?q=test", "example.com");
+    assert.equal(result, "search?q=test");
+  });
+
+  it("should handle hash fragments", () => {
+    const result = cleanLinkText("https://example.com/page#section", "example.com");
+    assert.equal(result, "page#section");
+  });
+});
+
+describe("buildFaviconLink", () => {
+  it("should create correct HTML with favicon", () => {
+    const result = buildFaviconLink('href="https://example.com/docs"', "example.com", "docs");
+    assert.equal(
+      result,
+      '<a href="https://example.com/docs"><i><img src="https://www.google.com/s2/favicons?domain=example.com&sz=32"></i>docs</a>'
+    );
+  });
+
+  it("should handle complex attributes", () => {
+    const result = buildFaviconLink('href="https://example.com" class="link" target="_blank"', "example.com", "docs");
+    assert.equal(
+      result,
+      '<a href="https://example.com" class="link" target="_blank"><i><img src="https://www.google.com/s2/favicons?domain=example.com&sz=32"></i>docs</a>'
+    );
+  });
+
+  it("should use sz=32 parameter for favicon size", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "text");
+    assert.match(result, /sz=32/);
+  });
+
+  it("should wrap img in <i> tag", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "text");
+    assert.match(result, /<i><img[^>]*><\/i>/);
+  });
+
+  it("should handle different domains", () => {
+    const result = buildFaviconLink('href="https://github.com/repo"', "github.com", "repo");
+    assert.equal(
+      result,
+      '<a href="https://github.com/repo"><i><img src="https://www.google.com/s2/favicons?domain=github.com&sz=32"></i>repo</a>'
+    );
+  });
+
+  it("should preserve link text as provided", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "custom text");
+    assert.match(result, />custom text<\/a>$/);
+  });
+});
+
+describe("transformLink", () => {
+  it("should transform plain URL links with sufficient length", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">https://example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "https://example.com/docs"
+    );
+    assert.match(result, /<i><img src="https:\/\/www\.google\.com\/s2\/favicons\?domain=example\.com&sz=32"><\/i>docs/);
+  });
+
+  it("should not transform if cleaned text is too short (2 chars or less)", () => {
+    const match = '<a href="https://example.com/ab">https://example.com/ab</a>';
+    const result = transformLink(
+      match,
+      'href="https://example.com/ab"',
+      "https://example.com/ab",
+      "https://example.com/ab"
+    );
+    assert.equal(result, match);
+  });
+
+  it("should not transform custom link text without URL", () => {
+    const match = '<a href="https://example.com/docs">Click here</a>';
+    const result = transformLink(match, 'href="https://example.com/docs"', "https://example.com/docs", "Click here");
+    assert.equal(result, match);
+  });
+
+  it("should not transform root domain links", () => {
+    const match = '<a href="https://example.com">example.com</a>';
+    const result = transformLink(match, 'href="https://example.com"', "https://example.com", "example.com");
+    assert.equal(result, match);
+  });
+
+  it("should not transform links ending with slash only", () => {
+    const match = '<a href="https://example.com/">https://example.com/</a>';
+    const result = transformLink(match, 'href="https://example.com/"', "https://example.com/", "https://example.com/");
+    assert.equal(result, match);
+  });
+
+  it("should handle invalid URLs gracefully", () => {
+    const match = '<a href="not-a-url">not-a-url</a>';
+    const result = transformLink(match, 'href="not-a-url"', "not-a-url", "not-a-url");
+    assert.equal(result, match);
+  });
+
+  it("should work with http:// protocol", () => {
+    const result = transformLink(
+      '<a href="http://example.com/docs">http://example.com/docs</a>',
+      'href="http://example.com/docs"',
+      "http://example.com/docs",
+      "http://example.com/docs"
+    );
+    assert.match(result, /<i><img[^>]*><\/i>docs/);
+  });
+
+  it("should work with https:// protocol", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">https://example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "https://example.com/docs"
+    );
+    assert.match(result, /<i><img[^>]*><\/i>docs/);
+  });
+
+  it("should handle longer paths correctly", () => {
+    const result = transformLink(
+      '<a href="https://example.com/path/to/document">https://example.com/path/to/document</a>',
+      'href="https://example.com/path/to/document"',
+      "https://example.com/path/to/document",
+      "https://example.com/path/to/document"
+    );
+    assert.match(result, /<i><img[^>]*><\/i>path\/to\/document/);
+  });
+
+  it("should not transform when linkText doesn't look like URL", () => {
+    const match = '<a href="https://example.com/page">Read the documentation</a>';
+    const result = transformLink(
+      match,
+      'href="https://example.com/page"',
+      "https://example.com/page",
+      "Read the documentation"
+    );
+    assert.equal(result, match);
+  });
+
+  it("should transform when linkText contains domain even without protocol", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "example.com/docs"
+    );
+    assert.match(result, /<i><img[^>]*><\/i>docs/);
+  });
+
+  it("should handle malformed URLs by returning original match", () => {
+    const match = '<a href="ht!tp://bad-url">ht!tp://bad-url</a>';
+    const result = transformLink(match, 'href="ht!tp://bad-url"', "ht!tp://bad-url", "ht!tp://bad-url");
+    assert.equal(result, match);
+  });
+});