pantsdown 1.0.1

package/src/types.ts

@@ -0,0 +1,183 @@
+type BaseToken = {
+    type: string;
+    raw: string;
+    text?: string;
+};
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface Tokens extends Record<string, BaseToken> {
+    Space: {
+        type: "space";
+        raw: string;
+    };
+    Code: {
+        type: "code";
+        raw: string;
+        text: string;
+        codeBlockStyle?: "indented";
+        lang?: string | undefined;
+    };
+    Heading: {
+        type: "heading";
+        raw: string;
+        text: string;
+        depth: number;
+        tokens: Token[];
+    };
+    Table: {
+        type: "table";
+        raw: string;
+        align: ("center" | "left" | "right" | null)[];
+        header: Tokens["TableCell"][];
+        rows: Tokens["TableCell"][][];
+    };
+    TableCell: {
+        type: "tablecell";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    };
+    Hr: {
+        type: "hr";
+        raw: string;
+    };
+    Blockquote: {
+        type: "blockquote";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    };
+    List: {
+        type: "list";
+        raw: string;
+        ordered: boolean;
+        start: number | "";
+        loose: boolean;
+        items: Tokens["ListItem"][];
+    };
+    ListItem: {
+        type: "list_item";
+        raw: string;
+        text: string;
+        task: boolean;
+        checked?: boolean | undefined;
+        loose: boolean;
+        tokens: Token[];
+    };
+    Paragraph: {
+        type: "paragraph";
+        raw: string;
+        text: string;
+        pre?: boolean | undefined;
+        tokens: Token[];
+    };
+    HTML: {
+        type: "html";
+        raw: string;
+        text: string;
+        pre: boolean;
+        block: boolean;
+    };
+    Text: {
+        type: "text";
+        raw: string;
+        text: string;
+        tokens?: Token[];
+    };
+    Def: {
+        type: "def";
+        raw: string;
+        tag: string;
+        href: string;
+        title: string;
+    };
+    Escape: {
+        type: "escape";
+        raw: string;
+        text: string;
+    };
+    Tag: {
+        type: "text" | "html";
+        raw: string;
+        text: string;
+        inLink: boolean;
+        inRawBlock: boolean;
+        block: boolean;
+    };
+    Link: {
+        type: "link";
+        raw: string;
+        text: string;
+        href: string;
+        title: string | null;
+        tokens: Token[];
+    };
+    Image: {
+        type: "image";
+        raw: string;
+        text: string;
+        href: string;
+        title: string | null;
+    };
+    Strong: {
+        type: "strong";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    };
+    Em: {
+        type: "em";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    };
+    Codespan: {
+        type: "codespan";
+        raw: string;
+        text: string;
+    };
+    Br: {
+        type: "br";
+        raw: string;
+    };
+    Del: {
+        type: "del";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    };
+}
+
+export type Token =
+    | Tokens["Space"]
+    | Tokens["Code"]
+    | Tokens["Heading"]
+    | Tokens["Table"]
+    | Tokens["TableCell"]
+    | Tokens["Hr"]
+    | Tokens["Blockquote"]
+    | Tokens["List"]
+    | Tokens["ListItem"]
+    | Tokens["Paragraph"]
+    | Tokens["HTML"]
+    | Tokens["Text"]
+    | Tokens["Def"]
+    | Tokens["Escape"]
+    | Tokens["Tag"]
+    | Tokens["Link"]
+    | Tokens["Image"]
+    | Tokens["Strong"]
+    | Tokens["Em"]
+    | Tokens["Codespan"]
+    | Tokens["Br"]
+    | Tokens["Del"];
+
+export type Links = Record<string, { href: string; title: string }>;
+
+export type RendererProps = {
+    /**
+     * url prefix. Must start and end with "/"
+     * example: "/__localimage__/"
+     */
+    localImageUrlPrefix: string;
+};

package/src/utils.ts

@@ -0,0 +1,231 @@
+import { type Lexer } from "./lexer.ts";
+import { type Tokens } from "./types.ts";
+
+/**
+ * Helpers
+ */
+const escapeTest = /[&<>"']/;
+const escapeReplace = new RegExp(escapeTest.source, "g");
+const escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+const escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g");
+const escapeReplacements: Record<string, string> = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+const getEscapeReplacement = (ch: string) => escapeReplacements[ch]!;
+
+export function escape(html: string, encode?: boolean) {
+    if (encode) {
+        if (escapeTest.test(html)) {
+            return html.replace(escapeReplace, getEscapeReplacement);
+        }
+    } else {
+        if (escapeTestNoEncode.test(html)) {
+            return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+        }
+    }
+
+    return html;
+}
+
+export function fixHtmlLocalImageHref(html: string, localImageUrlPrefix: string): string {
+    return html.replace(
+        /<img\s+([^>]*?)src\s*=\s*(["'])([^\2>]+?)\2([^>]*)>/gm,
+        (_m, g1, _g2, g3: string, g4) => {
+            const href = fixLocalImageHref(g3, localImageUrlPrefix);
+            return `<img ${g1}src="${href}"${g4}>`;
+        },
+    );
+}
+
+export function fixLocalImageHref(href: string, localImageUrlPrefix: string): string {
+    const reIsAbsolute = /^[\w+]+:\/\//;
+    const dummyUrl = "http://__dummy__";
+    const dummyBaseUrl = new URL(localImageUrlPrefix, dummyUrl);
+    const dummyUrlLength = dummyUrl.length + (localImageUrlPrefix.startsWith("/") ? 0 : 1);
+
+    if (reIsAbsolute.test(href)) {
+        // the URL is absolute, do not touch it
+        return href;
+    }
+
+    if (href.startsWith("/")) {
+        // the URL is from root
+        return href;
+    }
+
+    try {
+        const temp = new URL(href, dummyBaseUrl).href;
+        return temp.slice(dummyUrlLength);
+    } catch (e) {
+        return href;
+    }
+}
+
+export function cleanUrl(href: string) {
+    try {
+        href = encodeURI(href).replace(/%25/g, "%");
+    } catch (e) {
+        return null;
+    }
+    return href;
+}
+
+export const noopTest = { exec: () => null };
+
+export function splitCells(tableRow: string, count?: number) {
+    // ensure that every cell-delimiting pipe has a space
+    // before it to distinguish it from an escaped pipe
+    const row = tableRow.replace(/\|/g, (_match, offset: number, str: string) => {
+            let escaped = false;
+            let curr = offset;
+            while (--curr >= 0 && str[curr] === "\\") escaped = !escaped;
+            if (escaped) {
+                // odd number of slashes means | is escaped
+                // so we leave it alone
+                return "|";
+            } else {
+                // add space before unescaped |
+                return " |";
+            }
+        }),
+        cells = row.split(/ \|/);
+
+    // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+    if (!cells[0]?.trim()) {
+        cells.shift();
+    }
+    if (cells.length > 0 && !cells[cells.length - 1]?.trim()) {
+        cells.pop();
+    }
+
+    if (count) {
+        if (cells.length > count) {
+            cells.splice(count);
+        } else {
+            while (cells.length < count) cells.push("");
+        }
+    }
+
+    for (let i = 0, len = cells.length; i < len; i++) {
+        // leading or trailing whitespace is ignored per the gfm spec
+        cells[i] = cells[i]!.trim().replace(/\\\|/g, "|");
+    }
+    return cells;
+}
+
+/**
+ * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+ * /c*$/ is vulnerable to REDOS.
+ *
+ * @param str
+ * @param c
+ * @param invert Remove suffix of non-c chars instead. Default falsey.
+ */
+export function rtrim(str: string, c: string, invert?: boolean) {
+    const l = str.length;
+    if (l === 0) {
+        return "";
+    }
+
+    // Length of suffix matching the invert condition.
+    let suffLen = 0;
+
+    // Step left until we fail to match the invert condition.
+    while (suffLen < l) {
+        const currChar = str.charAt(l - suffLen - 1);
+        if (currChar === c && !invert) {
+            suffLen++;
+        } else if (currChar !== c && invert) {
+            suffLen++;
+        } else {
+            break;
+        }
+    }
+
+    return str.slice(0, l - suffLen);
+}
+
+export function findClosingBracket(str: string, b: string) {
+    if (!b[1] || !str.includes(b[1])) {
+        return -1;
+    }
+
+    let level = 0;
+    for (let i = 0, len = str.length; i < len; i++) {
+        if (str[i] === "\\") {
+            i++;
+        } else if (str[i] === b[0]) {
+            level++;
+        } else if (str[i] === b[1]) {
+            level--;
+            if (level < 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+export function outputLink(
+    cap: string[],
+    link: Pick<Tokens["Link"], "href" | "title">,
+    raw: string,
+    lexer: Lexer,
+): Tokens["Link"] | Tokens["Image"] {
+    const href = link.href;
+    const title = link.title ? escape(link.title) : null;
+    const text = cap[1]?.replace(/\\([\[\]])/g, "$1") ?? "";
+
+    if (cap[0]?.charAt(0) !== "!") {
+        lexer.state.inLink = true;
+        const token: Tokens["Link"] = {
+            type: "link",
+            raw,
+            href,
+            title,
+            text,
+            tokens: lexer.inlineTokens(text),
+        };
+        lexer.state.inLink = false;
+        return token;
+    }
+    return {
+        type: "image",
+        raw,
+        href,
+        title,
+        text: escape(text),
+    };
+}
+
+export function indentCodeCompensation(raw: string, text: string) {
+    const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+    if (matchIndentToCode === null) {
+        return text;
+    }
+
+    const indentToCode = matchIndentToCode[1];
+
+    return text
+        .split("\n")
+        .map((node) => {
+            const matchIndentInNode = node.match(/^\s+/);
+            if (matchIndentInNode === null) {
+                return node;
+            }
+
+            const [indentInNode] = matchIndentInNode;
+
+            if (indentToCode && indentInNode.length >= indentToCode.length) {
+                return node.slice(indentToCode.length);
+            }
+
+            return node;
+        })
+        .join("\n");
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "ESNext",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "moduleDetection": "force",
+    "types": ["bun-types"],
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "composite": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+
+    // strict: https://github.com/tsconfig/bases/blob/main/bases/strictest.json
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "isolatedModules": true,
+    "checkJs": true,
+    "esModuleInterop": true
+  }
+}