mkdocs-wikilinks-plugin 0.1.0__py3-none-any.whl

mkdocs_ezlinks_plugin/file_mapper.py

@@ -0,0 +1,108 @@
+import posixpath
+from typing import List
+
+import pygtrie
+import mkdocs
+
+from .types import EzLinksOptions
+
+
+class FileMapper:
+    def __init__(
+            self,
+            options: EzLinksOptions,
+            root: str,
+            files: List[mkdocs.structure.pages.Page],
+            logger=None):
+        self.options = options
+        self.root = root
+        self.file_cache = {}
+        self.file_trie = pygtrie.StringTrie(separator='/')
+        self.logger = logger
+
+        # Drop any files outside of the root of the docs dir
+        self.files = [file for file in files if root in file.abs_src_path]
+
+        for file in self.files:
+            self._store_file(file.src_uri)
+            
+        # Reduce the dictionary to only search terms that are unique
+        self.file_cache = {k: v for (k, v) in self.file_cache.items() if len(v) == 1}
+
+    def _store_file(self, file_path):
+        # Treat paths as posix format, regardless of OS
+        file_path = file_path.replace('\\', '/')
+        # Store the pathwise reversed representation of the file with and
+        # without file extension.
+        search_exprs = [file_path, posixpath.splitext(file_path)[0]]
+        for search_expr in search_exprs:
+            # Store in fast file cache
+            file_name = posixpath.basename(search_expr)
+            if file_name not in self.file_cache:
+                self.file_cache[file_name] = [file_path]
+            else:
+                self.file_cache[file_name].append(file_path)
+
+            # Store in trie
+            components = list(search_expr.split('/'))
+            components.reverse()
+            self.file_trie['/'.join(components)] = file_path
+
+    def search(self, from_file: str, file_path: str):
+        abs_to = file_path
+        # Detect if it's an absolute link, then just return it directly
+        if abs_to.startswith('/'):
+            return posixpath.join(self.root, abs_to[1:])
+        else:
+            # Check if it is a direct link first
+            from_dir = posixpath.dirname(from_file)
+            if posixpath.exists(posixpath.join(self.root, from_dir, file_path)):
+                return posixpath.join(self.root, from_dir, file_path)
+
+            # It's an EzLink that must be searched
+            file_name = posixpath.basename(file_path)
+
+            # Check fast file cache first
+            if posixpath.basename(file_name) in self.file_cache:
+                abs_to = self.file_cache[file_name][0]
+            else:
+                search_for = list(file_path.split('/'))
+                search_for.reverse()
+                search_for = "/".join(search_for)
+
+                # If we have an _exact_ match in the trie, we don't need to search
+                if search_for in self.file_trie:
+                    abs_to = self.file_trie[search_for]
+                elif self.file_trie.has_subtrie(search_for):
+                    # If we don't have an exact match, but have a partial prefix
+                    values = self.file_trie.values(search_for)
+                    abs_to = values[0]
+                    has_ambiguity = len(values) > 1
+                    # If we have ambiguities, attempt to auto-disambiguate by performing
+                    # an iterative ascent of the link file's path. In this way, we should
+                    # be able to get the result closest to the file doing the linking
+                    if has_ambiguity:
+                        file_path = posixpath.dirname(from_file)
+                        components = file_path.split('/')
+                        components.reverse()
+                        for path_component in components:
+                            search_for += f"/{path_component}"
+                            if self.file_trie.has_subtrie(search_for) or search_for in self.file_trie:
+                                new_vals = self.file_trie.values(search_for)
+                                if len(new_vals) == 1:
+                                    abs_to = new_vals[0]
+                                    # We've resolved the ambiguity, so no need to warn
+                                    has_ambiguity = False
+                                    break
+
+                    if has_ambiguity:
+                        ambiguities = ""
+                        for idx, file in enumerate(values):
+                            active = "<--- (Selected)" if idx == 0 else ""
+                            ambiguities += f"  {idx}: {file} {active}\n"
+                        log_fn = self.logger.warning if self.options.warn_ambiguities else self.logger.debug
+                        log_fn(f"[EzLink] Link ambiguity detected.\n"
+                               f"File: '{from_file}'\n"
+                               f"Link: '{search_for}'\n"
+                               "Ambiguities:\n" + ambiguities)
+        return posixpath.join(self.root, abs_to)

mkdocs_ezlinks_plugin/plugin.py

@@ -0,0 +1,56 @@
+import logging
+from typing import List
+
+import mkdocs
+
+from .file_mapper import FileMapper
+from .replacer import EzLinksReplacer
+from .scanners.md_link_scanner import MdLinkScanner
+from .scanners.wiki_link_scanner import WikiLinkScanner
+from .scanners.reference_link_scanner import ReferenceLinkScanner
+from .types import EzLinksOptions
+
+LOGGER = logging.getLogger(f"mkdocs.plugins.{__name__}")
+
+
+class EzLinksPlugin(mkdocs.plugins.BasePlugin):
+    config_scheme = (
+        ('wikilinks',  mkdocs.config.config_options.Type(bool, default=True)),
+        ('warn_ambiguities', mkdocs.config.config_options.Type(bool, default=False)),
+        ('reference_links', mkdocs.config.config_options.Type(bool, default=False))
+    )
+
+    def init(self, config):
+        self.replacer = EzLinksReplacer(
+            root=config['docs_dir'],
+            file_map=self.file_mapper,
+            use_directory_urls=config['use_directory_urls'],
+            options=EzLinksOptions(**self.config),
+            logger=LOGGER
+        )
+
+        self.replacer.add_scanner(MdLinkScanner())
+        if self.config['wikilinks']:
+            self.replacer.add_scanner(WikiLinkScanner())
+        
+        if self.config['reference_links']:
+            self.replacer.add_scanner(ReferenceLinkScanner())
+
+        # Compile the regex once
+        self.replacer.compile()
+
+    # Build a fast lookup of all files (by file name)
+    def on_files(self, files: List[mkdocs.structure.files.File], config):
+        self.file_mapper = FileMapper(
+            options=EzLinksOptions(**self.config),
+            root=config['docs_dir'],
+            files=files,
+            logger=LOGGER
+        )
+
+        # After the file map has been built, initialize what we can that will
+        # remain static
+        self.init(config)
+
+    def on_page_markdown(self, markdown, page, config, **kwargs):
+        return self.replacer.replace(page.file.src_uri, markdown)

mkdocs_ezlinks_plugin/replacer.py

@@ -0,0 +1,89 @@
+import posixpath
+import re
+from typing import Match
+from urllib.parse import quote
+from .types import EzLinksOptions, BrokenLink
+from .scanners.base_link_scanner import BaseLinkScanner
+from .file_mapper import FileMapper
+
+
+class EzLinksReplacer:
+    def __init__(
+            self,
+            root: str,
+            file_map: FileMapper,
+            use_directory_urls: bool,
+            options: EzLinksOptions,
+            logger):
+        self.root = root
+        self.file_map = file_map
+        self.use_directory_urls = use_directory_urls
+        self.options = options
+        self.scanners = []
+        self.logger = logger
+
+    def add_scanner(self, scanner: BaseLinkScanner) -> None:
+        self.scanners.append(scanner)
+
+    def replace(self, path: str, markdown: str) -> str:
+        self.path = path
+
+        # Multi-Pattern search pattern, to capture  all link types at once
+        return re.sub(self.regex, self._do_replace, markdown)
+
+    # Compiles all scanner patterns as a multi-pattern search, with
+    # built in code fence skipping (individual link scanners don't
+    # have to worry about them.
+    def compile(self):
+        patterns = '|'.join([scanner.pattern() for scanner in self.scanners])
+        self.regex = re.compile(
+            fr'''
+            (?: # Attempt to match a code block
+                [`]{{3}}
+                (?:[\w\W]*?)
+                [`]{{3}}$
+            | # Match an inline code block
+                `[\w\W]*?`
+            )
+            | # Attempt to match any one of the subpatterns
+            (?:
+                {patterns}
+            )
+            ''', re.X | re.MULTILINE)
+
+    def _do_replace(self, match: Match) -> str:
+        abs_from = posixpath.dirname(posixpath.join(self.root, self.path))
+        try:
+            for scanner in self.scanners:
+                if scanner.match(match):
+                    link = scanner.extract(match)
+
+                    # Do some massaging of the extracted results
+                    if not link:
+                        raise BrokenLink(f"Could not extract link from '{match.group(0)}'")
+
+                    # Handle case of local page anchor
+                    if not link.target:
+                        if link.anchor:
+                            link.target = posixpath.join(self.root, self.path)
+                        else:
+                            raise BrokenLink(f"No target for link '{match.group(0)}'")
+                    else:
+                        # Otherwise, search for the target through the file map
+                        search_result = self.file_map.search(self.path, link.target)
+                        if not self.use_directory_urls:
+                            search_result = search_result + '.md' if '.' not in search_result else search_result
+
+                        if not search_result:
+                            raise BrokenLink(f"'{link.target}' not found.")
+                        link.target = search_result
+
+                    link.target = quote(posixpath.relpath(link.target, abs_from))
+                    return link.render()
+        except BrokenLink as ex:
+            # Log these out as Debug messages, as the regular mkdocs
+            # strict mode will log out broken links.
+            self.logger.debug(f"[EzLinks] {ex}")
+
+        # Fall through, return the original link unaltered, and let mkdocs handle it
+        return match.group(0)

mkdocs_ezlinks_plugin/scanners/base_link_scanner.py

@@ -0,0 +1,17 @@
+from abc import ABCMeta, abstractmethod
+from typing import Pattern, Match
+from ..types import Link
+
+
+class BaseLinkScanner(metaclass=ABCMeta):
+    @abstractmethod
+    def pattern(self) -> str:
+        pass
+
+    @abstractmethod
+    def match(self, match: Match) -> bool:
+        pass
+
+    @abstractmethod
+    def extract(self, match: Match) -> Link:
+        pass

mkdocs_ezlinks_plugin/scanners/md_link_scanner.py

@@ -0,0 +1,53 @@
+import re
+from typing import Match
+
+from .base_link_scanner import BaseLinkScanner
+from ..types import Link, BrokenLink
+
+
+class MdLinkScanner(BaseLinkScanner):
+    def pattern(self) -> str:
+        # +------------------------------+
+        # | MD Link Regex Capture Groups |
+        # +-------------------------------------------------------------------------------------+
+        # | md_is_image      |  Contains ! when an image tag, or empty if not (check both)      |
+        # | md_alt_is_image  |  Contains ! when an image tag, or empty if not (check both)      |
+        # | md_text          |  Contains the Link Text between [md_text]                        |
+        # | md_protocol      |  Rejects match if link contains a protocol scheme (e.g. http)    |
+        # | md_target        |  Contains the full target of the Link (filename.md#anchor)       |
+        # | md_filename      |  Contains just the filename portion of the target (filename.md)  |
+        # | md_anchor        |  Contains the anchor, if present (e.g. `file.md#anchor`)         |
+        # | md_title         |  Contains the title, if present (e.g. `file.md "My Title"`)      |
+        # +-------------------------------------------------------------------------------------+
+        return r"""
+            (?:
+                (?P<md_is_image>\!?)\[\]
+                |
+                (?P<md_alt_is_image>\!?)
+                \[
+                    (?P<md_text>[^\]]+)
+                \]
+            )
+            \(
+                (?P<md_target>
+                    (?!(?P<md_protocol>[a-z][a-z0-9+\-.]*:\/\/))
+                    (?P<md_filename>\/?[^\#\ \)]*)?
+                    (?:\#(?P<md_anchor>[^\)\"]*)?)?
+                    (?:\ \"(?P<md_title>[^\"\)]*)\")?
+                )
+            \)
+            """
+
+    def match(self, match: Match) -> bool:
+        return bool(match.groupdict().get("md_target"))
+
+    def extract(self, match: Match) -> Link:
+        groups = match.groupdict()
+        image = groups.get("md_is_image") or groups.get("md_alt_is_image") or ""
+        return Link(
+            image=image,
+            text=groups.get("md_text") or "",
+            target=groups.get("md_filename") or "",
+            title=groups.get("md_title") or "",
+            anchor=groups.get("md_anchor") or "",
+        )

mkdocs_ezlinks_plugin/scanners/reference_link_scanner.py

@@ -0,0 +1,42 @@
+from typing import Pattern, Match
+from .base_link_scanner import BaseLinkScanner
+from ..types import Link
+
+
+class ReferenceLinkScanner(BaseLinkScanner):
+    def pattern(self) -> str:
+        # +--------------------------------------+
+        # | Reference Link Regex Capture Groups  |
+        # +--------------------------------------+
+        # | Example: [text]: url "title"         |
+        # |                                      |
+        # |  text: Required                      |
+        # |   url: Required                      |
+        # | title: Optional, up to one newline   |
+        # +--------------------------------------+
+        return r"""
+        (?:
+        \[
+            (?P<ref_text>[^\]]+)
+        \]
+        )\:\ 
+        (?!(?P<ref_protocol>[a-z][a-z0-9+\-.]*:\/\/))
+        (?P<ref_target>\/?[^\#\ \)(\r\n|\r|\n)]*)?
+        (?:\#(?P<ref_anchor> [^\(\ ]*)?)?
+        (?:(\r\n|\r|\n)?)?(?P<ref_title>\ ?\"[^(\r\n|\r|\n)\"]*\")?
+        """
+
+    def match(self, match: Match) -> bool:
+        return bool(
+            match.groupdict().get("ref_text") and match.groupdict().get("ref_target")
+        )
+
+    def extract(self, match: Match) -> Link:
+        groups = match.groupdict()
+        return Link(
+            image=False,
+            text=groups.get("ref_text") or "",
+            target=groups.get("ref_target") or "",
+            title=groups.get("ref_title") or "",
+            anchor=groups.get("ref_anchor") or "",
+        )

mkdocs_ezlinks_plugin/scanners/wiki_link_scanner.py

@@ -0,0 +1,55 @@
+import re
+from typing import Pattern, Match
+
+from .base_link_scanner import BaseLinkScanner
+from ..types import Link, BrokenLink
+
+
+class WikiLinkScanner(BaseLinkScanner):
+    def pattern(self) -> str:
+        # +--------------------------------+
+        # | Wiki Link Regex Capture Groups |
+        # +------------------------------------------------------------------------------------+
+        # | wiki_is_image |  Contains ! when an image tag, or empty if not                     |
+        # | wiki_link     |  Contains the Link Text between [[ wiki_link ]]                    |
+        # | wiki_anchor   |  Contains the anchor, if present (e.g. file.md#anchor -> 'anchor') |
+        # | wiki_text     |  Contains the text of the link.                                    |
+        # +------------------------------------------------------------------------------------+
+        return r"""
+            (?P<wiki_is_image>[\!]?)
+            \[\[
+                (?P<wiki_link>[^#\|\]]*?)
+                (?:\#(?P<wiki_anchor>[^\|\]]+)?)?
+                (?:\|(?P<wiki_text>[^\]]+)?)?
+            \]\]
+            """
+
+    def match(self, match: Match) -> bool:
+        groups = match.groupdict()
+        return groups.get("wiki_link") or groups.get("wiki_anchor")
+
+    def extract(self, match: Match) -> Link:
+        groups = match.groupdict()
+
+        image = groups.get("wiki_is_image") or ""
+        link = groups.get("wiki_link") or ""
+        anchor = groups.get("wiki_anchor") or ""
+        text = groups.get("wiki_text") or link or anchor
+
+        if not (link or text or anchor):
+            raise BrokenLink(
+                f"Could not extract required field `wiki_link` from {match.group(0)}"
+            )
+
+        if anchor:
+            anchor = self._slugify(anchor)
+
+        return Link(image=image, text=text, target=link, title=text, anchor=anchor)
+
+    def _slugify(self, link: str) -> str:
+        # Convert to lowercase
+        slug = link.lower()
+        # Convert all spaces to '-'
+        slug = re.sub(r"\ ", r"-", slug)
+        # Convert all unsupported characters to ''
+        return slug

mkdocs_ezlinks_plugin/types.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+
+
+class BrokenLink(Exception):
+    #Ignore these
+    pass
+
+
+@dataclass
+class Link:
+    """Dataclass to hold the contents required to form a complete Link."""
+
+    image: bool
+    text: str
+    target: str
+    anchor: str
+    title: str
+
+    # Render as a complete MD compatible link
+    def render(self):
+        img = "!" if self.image else ""
+        anchor = f"#{self.anchor}" if self.anchor else ""
+        title = f' "{self.title}"' if self.title else ""
+
+        return f"{img}[{self.text}]({self.target}{anchor}{title})"
+
+
+@dataclass
+class EzLinksOptions:
+    """Dataclass to hold typed options from the configuration."""
+
+    wikilinks: bool
+    warn_ambiguities: bool
+    reference_links: bool

mkdocs_wikilinks_plugin-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Mick Orbik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mkdocs_wikilinks_plugin-0.1.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.1
+Name: mkdocs-wikilinks-plugin
+Version: 0.1.0
+Summary: A mkdocs plugin that makes linking to other documents easy.
+Home-page: https://github.com/carloslab-ai/mkdocs-wikilinks-plugin
+Author: Carlos
+Author-email: carlos.truong.dev@gmail.com
+License: MIT
+Keywords: mkdocs,wikilinks,ezlinks,obsidian,roam
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mkdocs
+Requires-Dist: pygtrie==2.*
+Requires-Dist: dataclasses>=0.7; python_version < "3.7.0"
+
+*Fork*  
+To install this fork :   
+`pip install mkdocs-ezlinked-plugin`  
+
+# mkdocs-ezlinks-plugin
+
+![](logo.png)
+
+Plugin for mkdocs which enables easier linking between pages.
+
+This plugin was written in order to provide an up-to-date and
+feature complete plugin for easily referencing documents
+with a variety of features:
+
+* Optimized file name lookup
+* Code Block Preservation
+* File name linking (e.g. `[Text](file#anchor "title")`)
+* Absolute paths (e.g. `[Text](/link/to/file.md)`)
+* WikiLinks support (e.g. `[[Link#anchor|Link Title]]`)
+* Reference Link support (e.g. `[foo]: bar/ "Foo Title"`)
+
+# Install
+```
+pip install mkdocs-ezlinks-plugin
+```
+
+Edit your mkdocs configuration file to enable the plugin:
+```
+plugins:
+  - search
+  - ezlinks
+```
+> **NOTE**  
+>   If you have no plugins entry in your config file yet, you'll likely also want to add the search plugin. MkDocs enables it by default if there is no plugins entry set, but now you have to enable it explicitly.
+
+# Release Log
+
+## Release 0.1.14
+This is a bugfix release.
+
+Issues addressed:
+  * GH issue #35, `Links between deeply nested subfolders fails.`
+    Dev @Mara-Li reported an issue with wikilinks between deeply nested subfolders failing due to an incorrectly
+    rendered relative link to the file.
+
+  * An unreported Windows usage issue
+    It's possible this bug existed for quite some time. Basically, on Windows, there was disagreement between the
+    path separators used at different points in the file mapping and searching process. This unifies it to store
+    and search for paths only with the `/` delimiter instead of the OS defined separator.
+
+
+## Release 0.1.13
+Adds support for Reference Link parsing. This is to support certain Foam editors, which generate [Reference Links](https://spec.commonmark.org/0.29/#reference-link).
+
+Issues Addressed:
+  * GH Issue #31, `Add support for reference link definitions`. Allows compatibility with certain Foam editors which generate Reference Links.
+
+## Release 0.1.12
+This is a bugfix release.
+
+Issues addressed:
+  * GH issue #25, `Absolute links not using http:// or https:// are treated as relative`.
+    Dev @robbcrg (thanks!) reported that links with protocol schemes other than those two should also be treated as
+    absolute links. The regex will exclude any link from a conformant protocol scheme from being converted using EzLinks.
+
+  * GH Issue #27, `Dictionary file cache is not being leveraged`.
+    An inverted comparison led to the fast file cache lookup never really being exercised. Now, if a filename is unique, it will find it in the fast file cache first, saving a more expensive full trie lookup.
+
+## Release 0.1.11
+This is a bugfix release. The prior release switched from a dictionary lookup to a prefix trie lookup strategy, which allowed for better disambiguation between links, but is more expensive. The bug was that, even if a link was direct, it would trigger a full trie search. Now, direct links
+are checked and returned directly if the file exists.
+
+Additionally, a slight performance improvement was made where, in the case that a filename is unique to the entire site, it will rely on a fast dictionary lookup instead of a trie lookup.
+
+# Configuration Options
+```
+plugins:
+    - search
+    - ezlinks:
+        warn_ambiguities: {true|false}
+        wikilinks: {true|false}
+        reference_links: {true|false}
+```
+## warn_ambiguities
+Determines whether to warn when an abmiguous link is encountered. An ambiguous link is one that would have more than one possible targets. For example, if you had the following document setup:
+
+```
++ folder1/
+  +-- index.md
++ folder2/
+  +-- index.md
+```
+
+If you had any links that targeted `index.md`, EzLinks is not able to determine _which_ of the instances of `index.md` to target, thus it is ambiguous.
+
+### Disambiguating links
+By default, EzLinks will attempt to resolve the ambiguity automatically. It does this by searching for the file closest to the file that is linking (with respect to the folder hierarchy).
+
+```
++ guide/
+  + test.md
+  + getting_started/
+      + index.md
++ tutorials/
+  - test.md
+  + getting_started/
+      + index.md
+  + more_advanced/
+      + index.md
+```
+If you placed a link inside `guide/getting_started/index.md` such as `[Test](test)`, the resulting link has ambiguity, but in the default case, the `guide/test.md` file is _closer_ than the `tutorials/test.md`, therefore, it will select that file.
+
+In the circumstance above, it would be possible to disambiguate _which_ `test.md` by including the containing folder, e.g. `guide/test.md` or `tutorials/test.md`. Note: This also works in conjunction with extension-less targets, e.g. `guide/test` and `tutorials/test`.
+
+This disambiguation can continue with as many parent directories are specified, for instance `folder1/subfolder1/subfolder2/test.md`, specifying as many path components as necessary to fully disambiguate the links.
+
+This method of disambiguation is supported by each of the supported link formats (MD links, wiki/roamlinks). For instance, you can use `[[folder1/index|Link Title]]` and `[[folder2/index.md]]`.
+
+## wikilinks
+Determines whether to scan for wikilinks or not (See [WikiLink Support](#wikilink-support)).
+> **NOTE**  
+>  This plugin feature does not function well when the 'wikilinks' markdown extension is enabled. This plugin's functionality should replace the need for enabling said extension.
+
+## reference_links
+Determins whether to scan for Reference Links or not (See [Reference Links](https://spec.commonmark.org/0.29/#reference-link), e.g. `[foo]: /bar "Foo Bar"`)
+
+# Features
+## Filename Links
+Given a layout such as
+```
+- index.md
+- folder/
+  +-- filename.md
+  +-- image.png
+```
+
+The following links will result in the following translations,
+
+|Link|Translation|
+|----|-----------|
+| `[Link Text](filename)` | `[Link Text](folder/filename.md)`|
+| `[Link Text](filename#Anchor)` | `[Link Text](folder/filename.md#Anchor)`|
+| `[Link Text](filename.md)` | `[Link Text](folder/filename.md)`|
+| `[Link Text](filename.md#Anchor)` | `[Link Text](folder/filename.md#Anchor)` |
+| `![Image Alt Text](image)` | `![Image Alt Text](folder/image.png)` |
+| `![Image Alt Text](image.png)` | `![Image Alt Text](folder/image.png)` |
+| `![Image Alt Test](image "Image Title")` | `![Image Alt Text](folder/image.png "Image Title")` |
+
+
+## Absolute Links
+Given a layout such as
+```
+- static/
+  +-- image.png
+- folder/
+  +-- document.md
+- index.md
+```
+Given that we are entering the links into the `folder/document.md` file,
+
+|Link|Translation|
+|----|-----------|
+| `![Link Text](/static/image.png)` | `![Link Text](../static/image.png)` |
+
+# WikiLink Support
+Given a layout such as
+```
+- folder1/
+  +-- main.md
+- folder2/
+  +-- page-name.md
+- images/
+  +-- puppy.png
+```
+and these links are entered in `folder1/main.md`, this is how wikilinks will be translated
+
+|Link|Translation|
+|----|-----------|
+| `[[Page Name]]` | `[Page Name](../folder2/page-name.md)` |
+| `![[Puppy]]` | `![Puppy](../images/puppy.png)` | `[[Page Name#Section Heading]]` | `[Page Name](../relative/path/to/page-name.md#section-heading)` |
+| `[[Page Name\|Link Text]]` | `[Link Text](../folder2/page-name.md)` |
+| `[[Page Name#Section Heading\|Link Text]]` | `[Link Text](../folder2/page-name.md#section-heading)` |
+
+# Attribution
+This work is highly inspired from the following plugins:
+  - [mkdocs-autolinks-plugin](https://github.com/midnightprioriem/mkdocs-autolinks-plugin/)
+  - [mkdocs-roamlinks-plugin](https://github.com/Jackiexiao/mkdocs-roamlinks-plugin)
+  - [mkdocs-abs-rel-plugin](https://github.com/sander76/mkdocs-abs-rel-plugin)
+
+  I have combined some the features of these plugins, fixed several existing bugs, and am adding features in order to
+  provide a cohesive, up-to-date, and maintained solution for the mkdocs community.

mkdocs_wikilinks_plugin-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mkdocs_ezlinks_plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mkdocs_ezlinks_plugin/file_mapper.py,sha256=95s8b7WmH0Yj7dUEEsbw1zmI6IUeLtmhqKNf8U2Ntjc,4865
+mkdocs_ezlinks_plugin/plugin.py,sha256=V5Ch6cmLGqBpKw8ckdVWAAOnKEXR4fejaxDC_5T1zQg,1921
+mkdocs_ezlinks_plugin/replacer.py,sha256=llSpPD_EWo0-MARSYRo_pOaAug9dwwvkvOVRpA6M7JA,3412
+mkdocs_ezlinks_plugin/types.py,sha256=j0devK-Fl-IWOmRonEWNQ1SFgBJXIG0BzoEDrHLac9I,737
+mkdocs_ezlinks_plugin/scanners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mkdocs_ezlinks_plugin/scanners/base_link_scanner.py,sha256=zHn496tkvJNfLQ6Q4CCCR-W4qVAY3_pHXikbOgeldRs,362
+mkdocs_ezlinks_plugin/scanners/md_link_scanner.py,sha256=jzlwKC67Nn2461zG88ByGjfQHDvmflc5Bm0hrg3zuhA,2316
+mkdocs_ezlinks_plugin/scanners/reference_link_scanner.py,sha256=8twH0QETx6Zj1iUV8YUgPOetmOPcqepk5-RJPFgvaSc,1466
+mkdocs_ezlinks_plugin/scanners/wiki_link_scanner.py,sha256=hgf_skV0unz-00pbqUf54qo4whwxVnkA91v-vmAn3ZA,2118
+mkdocs_wikilinks_plugin-0.1.0.dist-info/LICENSE,sha256=moLBUL6d6yHy1m8G5xb0obEQq6nB_BVXY1V3NPo6l2Q,1067
+mkdocs_wikilinks_plugin-0.1.0.dist-info/METADATA,sha256=X-GUjxwAnHxZFCeVOZFHD3dVDmMIY9mK8I1qTHtvc5k,8590
+mkdocs_wikilinks_plugin-0.1.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+mkdocs_wikilinks_plugin-0.1.0.dist-info/entry_points.txt,sha256=ieCaPCi59TMrpwzH6ydAtzrqe9Cp2CcftcxYzhO7XE0,70
+mkdocs_wikilinks_plugin-0.1.0.dist-info/top_level.txt,sha256=3D2Vwzw60-FXxJ9CxUQrlEkOxwQR3zt10EglqyGuAYg,22
+mkdocs_wikilinks_plugin-0.1.0.dist-info/RECORD,,

mkdocs_wikilinks_plugin-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mkdocs_wikilinks_plugin-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[mkdocs.plugins]
+ezlinks = mkdocs_ezlinks_plugin.plugin:EzLinksPlugin

mkdocs_wikilinks_plugin-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mkdocs_ezlinks_plugin