@mintlify/link-rot 3.0.5 → 3.0.6

package/LICENSE

@@ -0,0 +1,93 @@
+Copyright (c) 2022 Mintlify, Inc.
+
+Elastic License 2.0
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+_As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim._
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/dist/graph.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+import { ParsedPath } from 'path';
+declare enum PathType {
+    INTERNAL = "internal",
+    EXTERNAL = "external",
+    DATA = "data"
+}
+export declare enum Wrapper {
+    MD = "md",
+    SRC = "src",
+    HREF = "href",
+    CARD = "card"
+}
+export declare enum EdgeType {
+    CONTENT = "content",
+    NAVIGATION = "navigation"
+}
+/**
+ * An MdxPath is a path in an Mdx page. Contains all path-related information.
+ */
+export declare class MdxPath {
+    originalPath: string;
+    relativeDir: string;
+    filename: string;
+    wrapper?: Wrapper | undefined;
+    path: ParsedPath | URL;
+    pathType: PathType;
+    anchorLink?: string;
+    queryParams?: URLSearchParams;
+    static getPathType(url: string): PathType;
+    /**
+     * Generate all the computed fields in an MdxPath
+     */
+    private constructParsedPath;
+    constructor(originalPath: string, relativeDir?: string, filename?: string, wrapper?: Wrapper | undefined);
+    toString(): string;
+    getResolvedFiles(allFiles: string[], baseDir: string): string[];
+    resolvesTo(node: Node, allFiles: string[], baseDir: string): boolean;
+    static filterMapInternalPaths(paths: string[]): string[];
+}
+export declare class Node {
+    label: string;
+    paths: MdxPath[];
+    relativeDir: string;
+    filename: string;
+    edges: Edge[];
+    constructor(label: string, paths?: MdxPath[]);
+    toString(): string;
+    equals(other: Node): boolean;
+    addPath(originalPath: string, wrapper?: Wrapper): void;
+    addOutgoingEdge(edge: Edge): void;
+    getChildNodes(depth?: number): Node[];
+}
+export declare class Edge {
+    source: Node;
+    target: Node;
+    edgeType: EdgeType;
+    private count;
+    constructor(source: Node, target: Node, edgeType: EdgeType);
+    incrementCount(): void;
+    getCount(): number;
+    equals(other: Edge): boolean;
+}
+export declare class Graph {
+    baseDir: string;
+    private nodes;
+    private edges;
+    constructor(baseDir: string);
+    addNode(label: string): Node;
+    addNodes(labels: string[]): void;
+    addAliasNodes(): void;
+    getNode(label: string): Node;
+    private addEdge;
+    addEdgesBetweenNodes(): void;
+    getBrokenInternalLinks(): MdxPath[];
+    getAllInternalPaths(): string[];
+}
+export {};

package/dist/graph.js

@@ -0,0 +1,302 @@
+import { getFileListWithDirectories } from '@mintlify/prebuild';
+import { existsSync } from 'fs';
+import isAbsoluteUrl from 'is-absolute-url';
+import { parse, join, resolve, relative, dirname, basename } from 'path';
+import { sep as WINDOWS_SEPARATOR } from 'path/win32';
+import { getLinkPaths, normalizeDir } from './prebuild.js';
+var PathType;
+(function (PathType) {
+    PathType["INTERNAL"] = "internal";
+    PathType["EXTERNAL"] = "external";
+    PathType["DATA"] = "data";
+})(PathType || (PathType = {}));
+export var Wrapper;
+(function (Wrapper) {
+    Wrapper["MD"] = "md";
+    Wrapper["SRC"] = "src";
+    Wrapper["HREF"] = "href";
+    Wrapper["CARD"] = "card";
+})(Wrapper || (Wrapper = {}));
+export var EdgeType;
+(function (EdgeType) {
+    EdgeType["CONTENT"] = "content";
+    EdgeType["NAVIGATION"] = "navigation";
+})(EdgeType || (EdgeType = {}));
+/**
+ * An MdxPath is a path in an Mdx page. Contains all path-related information.
+ */
+export class MdxPath {
+    originalPath;
+    relativeDir;
+    filename;
+    wrapper;
+    path;
+    pathType;
+    anchorLink; // #anchor
+    queryParams; // ?query=param
+    static getPathType(url) {
+        let pathType;
+        if (isAbsoluteUrl(url)) {
+            pathType = PathType.EXTERNAL;
+        }
+        else if (url.startsWith('data:')) {
+            pathType = PathType.DATA;
+        }
+        else {
+            pathType = PathType.INTERNAL;
+        }
+        return pathType;
+    }
+    /**
+     * Generate all the computed fields in an MdxPath
+     */
+    constructParsedPath() {
+        const pathType = MdxPath.getPathType(this.originalPath);
+        let urlPath;
+        let path;
+        if (pathType === PathType.INTERNAL) {
+            let normalizedPath = this.originalPath.replaceAll(WINDOWS_SEPARATOR, '/');
+            if (normalizedPath.startsWith('.')) {
+                // also include paths that start with "..", etc.
+                normalizedPath = relative('.', resolve(this.relativeDir, normalizedPath));
+                // TODO path starts with .. if path resolves to file system outside of mintlify project
+            }
+            // remove leading slash
+            normalizedPath = normalizedPath.startsWith('/') ? normalizedPath.slice(1) : normalizedPath;
+            // resolve relative path
+            // add arbitrary protocol to parse as URL and isolate pathname
+            urlPath = new URL(`mintlify:${normalizedPath}`);
+            normalizedPath = urlPath.pathname;
+            // remove trailing slash
+            if (normalizedPath.endsWith('/')) {
+                normalizedPath = normalizedPath.slice(0, -1);
+                urlPath.pathname = normalizedPath;
+            }
+            // if path is "", then path points to same page
+            if (normalizedPath === '') {
+                normalizedPath = join(this.relativeDir, this.filename);
+                urlPath.pathname = normalizedPath;
+            }
+            path = parse(normalizedPath);
+        }
+        else {
+            urlPath = new URL(this.originalPath);
+            path = urlPath;
+        }
+        const anchorLink = urlPath.hash || undefined;
+        const queryParams = urlPath.searchParams || undefined;
+        return { path, pathType, anchorLink, queryParams };
+    }
+    constructor(originalPath, relativeDir = '', filename = '', wrapper) {
+        this.originalPath = originalPath;
+        this.relativeDir = relativeDir;
+        this.filename = filename;
+        this.wrapper = wrapper;
+        this.relativeDir = normalizeDir(relativeDir);
+        const { path, pathType, anchorLink, queryParams } = this.constructParsedPath();
+        this.path = path;
+        this.pathType = pathType;
+        this.anchorLink = anchorLink;
+        this.queryParams = queryParams;
+    }
+    toString() {
+        if (this.pathType === PathType.INTERNAL) {
+            const parsedPath = this.path;
+            return join(parsedPath.dir, parsedPath.base);
+        }
+        return this.path.toString();
+    }
+    getResolvedFiles(allFiles, baseDir) {
+        if (this.pathType !== PathType.INTERNAL)
+            return [];
+        const parsedPath = this.path;
+        const resolvedFiles = [];
+        if (existsSync(resolve(baseDir, this.toString()))) {
+            resolvedFiles.push(join(parsedPath.dir, parsedPath.base));
+        }
+        // there is at most one file corresponding to the node
+        if (parsedPath.ext) {
+            return resolvedFiles;
+        }
+        // there may be multiple files/folders corresponding to the node
+        for (const file of allFiles) {
+            const fileWithoutLeadingSlash = file.startsWith('/') ? file.slice(1) : file;
+            const parsedFilePath = parse(fileWithoutLeadingSlash);
+            if (parsedFilePath.dir === parsedPath.dir && parsedFilePath.name === parsedPath.name) {
+                resolvedFiles.push(fileWithoutLeadingSlash);
+            }
+        }
+        return resolvedFiles;
+    }
+    resolvesTo(node, allFiles, baseDir) {
+        if (this.pathType !== PathType.INTERNAL)
+            return false;
+        if (this.toString() === node.toString())
+            return true;
+        if (this.getResolvedFiles(allFiles, baseDir).includes(node.toString()))
+            return true;
+        return false;
+    }
+    static filterMapInternalPaths(paths) {
+        return paths
+            .map((path) => new MdxPath(path))
+            .filter(({ pathType }) => pathType === PathType.INTERNAL)
+            .map((path) => path.toString());
+    }
+}
+/*
+ * A node is a representation of a page
+ * One node can contain multiple MdxPaths (corresponding to internal/external links in the page)
+ */
+export class Node {
+    label;
+    paths;
+    relativeDir;
+    filename;
+    edges = [];
+    constructor(label, paths = []) {
+        this.label = label;
+        this.paths = paths;
+        this.relativeDir = normalizeDir(dirname(label));
+        this.filename = basename(label);
+        this.label = join(this.relativeDir, this.filename);
+    }
+    toString() {
+        return this.label;
+    }
+    equals(other) {
+        return this.label === other.label;
+    }
+    addPath(originalPath, wrapper) {
+        const path = new MdxPath(originalPath, this.relativeDir, this.filename, wrapper);
+        this.paths.push(path);
+    }
+    addOutgoingEdge(edge) {
+        const existingEdge = this.edges.find((e) => e.equals(edge));
+        if (existingEdge) {
+            existingEdge.incrementCount();
+        }
+        else {
+            this.edges.push(edge);
+        }
+    }
+    getChildNodes(depth = 1) {
+        const children = [];
+        for (const edge of this.edges) {
+            const child = edge.target;
+            children.push(child);
+            if (depth > 1) {
+                children.push(...child.getChildNodes(depth - 1));
+            }
+        }
+        return children;
+    }
+}
+export class Edge {
+    source;
+    target;
+    edgeType;
+    count = 0;
+    constructor(source, target, edgeType) {
+        this.source = source;
+        this.target = target;
+        this.edgeType = edgeType;
+        this.count++;
+    }
+    incrementCount() {
+        this.count++;
+    }
+    getCount() {
+        return this.count;
+    }
+    equals(other) {
+        // directionality of edge matters
+        return (this.source.equals(other.source) &&
+            this.target.equals(other.target) &&
+            this.edgeType === other.edgeType);
+    }
+}
+export class Graph {
+    baseDir;
+    nodes = {};
+    edges = [];
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.baseDir = resolve(baseDir);
+    }
+    addNode(label) {
+        if (this.nodes[label])
+            return this.nodes[label];
+        this.nodes[label] = new Node(label);
+        return this.nodes[label];
+    }
+    addNodes(labels) {
+        for (const label of labels) {
+            this.addNode(label);
+        }
+    }
+    /*
+     * Aliases are additional paths that are valid due to redirects
+     */
+    addAliasNodes() {
+        // TODO move aliases computation to mint config package, since it'll depend on version
+        // for now this is a hacky implementation
+        const aliases = MdxPath.filterMapInternalPaths(getFileListWithDirectories(this.baseDir));
+        this.addNodes(aliases);
+    }
+    getNode(label) {
+        return this.nodes[label];
+    }
+    addEdge(source, target, edgeType = EdgeType.CONTENT) {
+        const newEdge = new Edge(source, target, edgeType);
+        const existingEdge = this.edges.find((edge) => {
+            if (edge.equals(newEdge)) {
+                edge.incrementCount();
+                return true;
+            }
+            return false;
+        });
+        if (existingEdge)
+            return existingEdge;
+        this.edges.push(newEdge);
+        return newEdge;
+    }
+    addEdgesBetweenNodes() {
+        const allFiles = getLinkPaths(this.baseDir);
+        for (const node of Object.values(this.nodes)) {
+            for (const path of node.paths) {
+                if (path.pathType === PathType.INTERNAL) {
+                    const targetNode = Object.values(this.nodes).find((otherNode) => path.resolvesTo(otherNode, allFiles, this.baseDir));
+                    if (targetNode) {
+                        const edge = this.addEdge(node, targetNode);
+                        node.addOutgoingEdge(edge);
+                    }
+                    else {
+                    }
+                }
+            }
+        }
+    }
+    getBrokenInternalLinks() {
+        const brokenLinks = [];
+        const allFiles = getLinkPaths(this.baseDir);
+        for (const node of Object.values(this.nodes)) {
+            for (const path of node.paths) {
+                if (path.pathType === PathType.INTERNAL) {
+                    const targetNode = Object.values(this.nodes).find((otherNode) => path.resolvesTo(otherNode, allFiles, this.baseDir));
+                    if (!targetNode) {
+                        brokenLinks.push(path);
+                    }
+                }
+            }
+        }
+        return brokenLinks;
+    }
+    // DEBUGGING
+    getAllInternalPaths() {
+        return Object.values(this.nodes)
+            .flatMap((node) => node.paths)
+            .filter((path) => path.pathType === PathType.INTERNAL)
+            .map((path) => path.originalPath + ' => ' + path.toString());
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export { getUsedInternalLinksInPage, getUsedInternalLinksInSite, } from "./static-checking/getUsedInternalLinks.js";
-export { getValidInternalLinks } from "./static-checking/getValidInternalLinks.js";
-export { getBrokenInternalLinks } from "./static-checking/getBrokenInternalLinks.js";
-export { renameFileAndUpdateLinksInContent } from "./link-renaming/renameFileAndUpdateLinksInContent.js";
+export { getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/index.js

@@ -1,4 +1,2 @@
-export { getUsedInternalLinksInPage, getUsedInternalLinksInSite, } from "./static-checking/getUsedInternalLinks.js";
-export { getValidInternalLinks } from "./static-checking/getValidInternalLinks.js";
-export { getBrokenInternalLinks } from "./static-checking/getBrokenInternalLinks.js";
-export { renameFileAndUpdateLinksInContent } from "./link-renaming/renameFileAndUpdateLinksInContent.js";
+export { getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/link-renaming/renameFileAndUpdateLinksInContent.d.ts

@@ -1,7 +1,7 @@
 /**
  * Renames a link in the file system. If the link is a directory, all links within the directory will be renamed as well.
- * @param existingDir - The existing directory or file to rename
- * @param newDirName - The new directory or file name
+ * @param oldFilePath - The existing directory or file to rename
+ * @param newFilePath - The new directory or file name
  * @param force
  */
-export declare const renameFileAndUpdateLinksInContent: (existingDir: string, newDirName: string, force?: boolean) => Promise<void>;
+export declare const renameFilesAndUpdateLinksInContent: (oldFilePathString: string, newFilePathString: string, force?: boolean) => Promise<void>;

package/dist/link-renaming/renameFileAndUpdateLinksInContent.js

@@ -1,47 +1,51 @@
-import { existsSync, lstatSync, renameSync } from "fs";
-import { normalize, parse } from "path";
-import renameInternalLinksInPage from "./renameInternalLinksInPage.js";
-import { isValidPage, removeFileExtension, getPagePaths } from "../prebuild.js";
+import { existsSync, renameSync } from 'fs';
+import path from 'path';
+import { removeFileExtension, getPagePaths, addLeadingSlash } from '../prebuild.js';
+import renameInternalLinksInPage from './renameInternalLinksInPage.js';
 /**
  * Renames a link in the file system. If the link is a directory, all links within the directory will be renamed as well.
- * @param existingDir - The existing directory or file to rename
- * @param newDirName - The new directory or file name
+ * @param oldFilePath - The existing directory or file to rename
+ * @param newFilePath - The new directory or file name
  * @param force
  */
-export const renameFileAndUpdateLinksInContent = async (existingDir, newDirName, force = false) => {
-    existingDir = normalize(existingDir);
-    newDirName = normalize(newDirName);
-    const existingDirParsed = parse(existingDir);
-    const newDirParsed = parse(newDirName);
-    if (!existsSync(existingDir)) {
-        throw new Error("File or folder does not exist at " + existingDir);
+export const renameFilesAndUpdateLinksInContent = async (oldFilePathString, newFilePathString, force = false) => {
+    const oldFilePath = path.parse(path.normalize(oldFilePathString));
+    const newFilePath = path.parse(path.normalize(newFilePathString));
+    if (oldFilePath.dir === newFilePath.dir && oldFilePath.base === newFilePath.base) {
+        throw new Error('The old and new file paths are the same.');
     }
-    if (!force && existsSync(newDirName)) {
-        throw new Error("File or folder exists at " + newDirName + ". Use --force to overwrite.");
-    }
-    const isDirectory = lstatSync(existingDir).isDirectory();
-    if (!isDirectory) {
-        if (!isValidPage(existingDirParsed)) {
-            throw new Error("File to rename must be an MDX or Markdown file.");
+    else if (!force && oldFilePath.ext !== newFilePath.ext) {
+        if (force) {
+            console.log('Warning: the file extensions are not the same.');
+        }
+        else {
+            throw new Error('The file extensions are not the same. Use the --force flag to override.');
         }
-        if (!isValidPage(newDirParsed)) {
-            throw new Error("New file name must be an MDX or Markdown file.");
+    }
+    // if the file or directory hasn't already been manually renamed, rename it
+    if (existsSync(oldFilePathString)) {
+        if (!force && existsSync(newFilePathString)) {
+            throw new Error('The new file path already exists. Use the --force flag to overwrite it.');
         }
+        renameSync(oldFilePathString, newFilePathString);
+        console.log(`Renamed ${oldFilePathString} to ${newFilePathString}.`);
     }
-    renameSync(existingDir, newDirName);
-    console.log(`Renamed ${existingDir} to ${newDirName}.`);
-    const existingLink = removeFileExtension(existingDirParsed);
-    const newLink = removeFileExtension(newDirParsed);
+    else if (!force) {
+        throw new Error('The old file path does not exist. Use the --force flag to skip the file system renaming.');
+    }
+    const oldLink = addLeadingSlash(removeFileExtension(oldFilePath));
+    const newLink = addLeadingSlash(removeFileExtension(newFilePath));
     const pagesInDirectory = getPagePaths(process.cwd());
     const renameLinkPromises = [];
-    pagesInDirectory.forEach((filePath) => {
+    for await (const filePath of pagesInDirectory) {
         renameLinkPromises.push((async () => {
-            const numRenamedLinks = await renameInternalLinksInPage(filePath, existingLink, newLink);
+            const numRenamedLinks = await renameInternalLinksInPage(path.join(process.cwd(), filePath), oldLink, newLink);
             if (numRenamedLinks > 0) {
                 console.log(`Renamed ${numRenamedLinks} link(s) in ${filePath}`);
             }
         })());
-    });
+    }
     await Promise.all(renameLinkPromises);
     return;
 };
+// renameFilesAndUpdateLinksInContent('/test/A.mdx', '/test/hello.mdx');

package/dist/link-renaming/renameInternalLinksInPage.d.ts

@@ -1,2 +1,2 @@
-declare const renameInternalLinksInPage: (filePath: string, existingLink: string, newLink: string) => Promise<number>;
+declare const renameInternalLinksInPage: (filePath: string, oldLink: string, newLink: string) => Promise<number>;
 export default renameInternalLinksInPage;

package/dist/link-renaming/renameInternalLinksInPage.js

@@ -1,16 +1,15 @@
 /**
  * @typedef {import('remark-mdx')}
  */
-import fs from "fs-extra";
-import { normalize } from "path";
-import { remark } from "remark";
-import remarkFrontmatter from "remark-frontmatter";
-import remarkGfm from "remark-gfm";
-import remarkMdx from "remark-mdx";
-import { visit } from "unist-util-visit";
+import fs from 'fs-extra';
+import { normalize } from 'path';
+import { remark } from 'remark';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkGfm from 'remark-gfm';
+import remarkMdx from 'remark-mdx';
+import { visit } from 'unist-util-visit';
 /**
- * Go through fileContent and replace all links that match existingLink with
- * newLink
+ * Go through fileContent and replace all links that match existingLink with newLink
  */
 const getContentWithRenamedInternalLinks = async (fileContent, existingLink, newLink) => {
     let numRenamedLinks = 0;
@@ -18,9 +17,7 @@ const getContentWithRenamedInternalLinks = async (fileContent, existingLink, new
         return (tree) => {
             visit(tree, (node) => {
                 // ![]() format
-                if (node.type === "link" &&
-                    node.url &&
-                    normalize(node.url) === existingLink) {
+                if (node.type === 'link' && node.url && normalize(node.url) === existingLink) {
                     node.url = newLink;
                     numRenamedLinks++;
                 }
@@ -31,7 +28,7 @@ const getContentWithRenamedInternalLinks = async (fileContent, existingLink, new
     const file = await remark()
         .use(remarkMdx)
         .use(remarkGfm)
-        .use(remarkFrontmatter, ["yaml", "toml"])
+        .use(remarkFrontmatter, ['yaml', 'toml'])
         .use(remarkMdxReplaceLinks)
         .process(fileContent);
     return {
@@ -39,11 +36,11 @@ const getContentWithRenamedInternalLinks = async (fileContent, existingLink, new
         newContent: String(file),
     };
 };
-const renameInternalLinksInPage = async (filePath, existingLink, newLink) => {
+const renameInternalLinksInPage = async (filePath, oldLink, newLink) => {
     const fileContent = fs.readFileSync(filePath).toString();
-    const { numRenamedLinks, newContent } = await getContentWithRenamedInternalLinks(fileContent, existingLink, newLink);
+    const { numRenamedLinks, newContent } = await getContentWithRenamedInternalLinks(fileContent, oldLink, newLink);
     fs.outputFileSync(filePath, newContent, {
-        flag: "w",
+        flag: 'w',
     });
     return numRenamedLinks;
 };

package/dist/prebuild.d.ts

@@ -1,15 +1,21 @@
 /// <reference types="node" />
-import path, { ParsedPath } from "path";
+import path, { ParsedPath } from 'path';
 export declare const isNotNodeModule: (filePath: ParsedPath) => boolean;
 export declare const isValidPage: (filePath: ParsedPath) => boolean;
 export declare const isValidMedia: (filePath: ParsedPath) => boolean;
 export declare const isValidLink: (filePath: ParsedPath) => boolean;
+export declare const normalizeFilePath: (filePath: string) => path.ParsedPath;
 export declare const normalizeFilePaths: (fileList: string[]) => path.ParsedPath[];
-export declare const filterNodeModules: (fileList: string[]) => path.ParsedPath[];
+export declare const filterNotNodeModules: (fileList: string[]) => path.ParsedPath[];
 export declare const filterPages: (fileList: string[]) => path.ParsedPath[];
 export declare const filterMedia: (fileList: string[]) => path.ParsedPath[];
 export declare const filterLinks: (fileList: string[]) => path.ParsedPath[];
 export declare const getFullPath: (filePath: ParsedPath) => string;
 export declare const removeFileExtension: (filePath: ParsedPath) => string;
-export declare const removeLeadingSlash: (filePathString: string) => string;
+export declare const addLeadingSlash: (filePathString: string) => string;
+export declare const removeSelectors: (filePathString: string) => string;
 export declare const getPagePaths: (dirName: string) => string[];
+export declare const getMediaPaths: (dirName: string) => string[];
+export declare const getLinkPaths: (dirName: string) => string[];
+export declare const normalizeDir: (dir: string) => string;
+export declare const removeLeadingSlash: (filePathString: string) => string;