simple-customize-markdown-converter 1.0.7 → 1.2.0

package/dist/renderers/react/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactRenderer = void 0;
+const react_1 = __importDefault(require("react"));
+const Handlers = __importStar(require("./handler"));
+class ReactRenderer {
+    constructor(footnoteResolver, options = {}) {
+        this.strategies = new Map();
+        this.footnoteResolver = footnoteResolver;
+        this.options = options;
+        this.registerDefaultStrategies();
+    }
+    registerDefaultStrategies() {
+        const listDefaultStrategy = [
+            Handlers.DocumentHandler,
+            Handlers.ParagraphHandler,
+            Handlers.HeaderHandler,
+            Handlers.CodeBlockHandler,
+            Handlers.QuoteHandler,
+            Handlers.BoldHandler,
+            Handlers.ItalicHandler,
+            Handlers.StrikethroughHandler,
+            Handlers.InlineCodeHandler,
+            Handlers.LinkHandler,
+            Handlers.ImageHandler,
+            Handlers.ListHandler,
+            Handlers.ListItemHandler,
+            Handlers.TaskItemHandler,
+            Handlers.TableHandler,
+            Handlers.TextHandler,
+            Handlers.HorizontalLineHandler,
+            Handlers.HTMLBlockHandler,
+            Handlers.HTMLInlineHandler,
+            Handlers.FootnoteRefHandler
+        ];
+        listDefaultStrategy.forEach(s => this.strategies.set(s.type, s));
+    }
+    render(node) {
+        const userRenderer = this.options.renderOptions?.elements?.[node.type];
+        const children = (node.children || []).map(child => this.render(child));
+        if (userRenderer) {
+            return userRenderer(node, children);
+        }
+        const strategy = this.strategies.get(node.type);
+        if (strategy) {
+            return strategy.render(node, children, this);
+        }
+        return children.join("");
+    }
+    renderFootnotes() {
+        if (this.footnoteResolver.isResolverValid()) {
+            const used = this.footnoteResolver.getUsedRef();
+            if (used.length === 0)
+                return null;
+            const items = used.map((id, i) => {
+                const def = this.footnoteResolver.getDef(id) ?? "";
+                const idx = i + 1;
+                return react_1.default.createElement("li", { id: `fn:${idx}` }, react_1.default.createElement("p", null, def + " ", react_1.default.createElement("a", { href: `#fnref:${idx}`, className: "footnote-backref" }, "↩")));
+            });
+            return react_1.default.createElement("section", { className: "footnotes" }, react_1.default.createElement("ol", null, ...items));
+        }
+        else
+            return null;
+    }
+    renderTable(node, children) {
+        if (node.type === "Table" && node.rows) {
+            const header = node.rows.filter(row => row.isHeader);
+            const body = node.rows.filter(row => !row.isHeader);
+            const renderRows = (row, rowIndex) => {
+                return react_1.default.createElement("tr", { key: rowIndex }, row.cells.map((cell, cellIndex) => {
+                    const tag = row.isHeader ? "th" : "td";
+                    return react_1.default.createElement(tag, { key: cellIndex, style: { textAlign: cell.align } }, ...cell.children.map(c => this.render(c)));
+                }));
+            };
+            const tHead = header.length
+                ? react_1.default.createElement("thead", null, header.map((row, i) => renderRows(row, i)))
+                : null;
+            const tBody = body.length
+                ? react_1.default.createElement("tbody", null, body.map((row, i) => renderRows(row, i)))
+                : null;
+            return react_1.default.createElement("table", null, tHead, tBody);
+        }
+        else
+            return react_1.default.createElement("p", null, ...children);
+    }
+}
+exports.ReactRenderer = ReactRenderer;

package/dist/renderers/react.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from "react";
+import { FootnoteResolver } from "../core/resolver";
+import { Node } from "../types/node";
+import { MarkdownReactOptions } from "../types/options";
+export default class ReactRenderer {
+    options: MarkdownReactOptions;
+    footNoteResolver: FootnoteResolver;
+    constructor(footNoteResolver: FootnoteResolver, options: MarkdownReactOptions);
+    /**
+     * Render a Node (AST) to a ReactNode according renderer options
+     *
+     * @param node - The abstract syntax tree (AST) from the Parser
+     * @returns The ReactNode representing the rendered Markdown element.
+     */
+    render<K extends Node["type"]>(node: Extract<Node, {
+        type: K;
+    }>): ReactNode;
+    /**
+     * Select the appropriate rendering handler for a specific node type
+     * @param type - The type of AST Note
+     * @returns A function take a node and its children to procude a ReactNode.
+     */
+    private handleRender;
+    private renderTable;
+    private renderFootnotes;
+}

package/dist/renderers/react.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+class ReactRenderer {
+    constructor(footNoteResolver, options) {
+        this.footNoteResolver = footNoteResolver;
+        this.options = options;
+    }
+    /**
+     * Render a Node (AST) to a ReactNode according renderer options
+     *
+     * @param node - The abstract syntax tree (AST) from the Parser
+     * @returns The ReactNode representing the rendered Markdown element.
+     */
+    render(node) {
+        //Get proper handler type
+        const handler = this.handleRender(node.type);
+        //If node have children, recursive to handle all node's children
+        const children = "children" in node ? node.children.map((ele) => this.render(ele)) : [];
+        return handler(node, children);
+    }
+    /**
+     * Select the appropriate rendering handler for a specific node type
+     * @param type - The type of AST Note
+     * @returns A function take a node and its children to procude a ReactNode.
+     */
+    handleRender(type) {
+        const defaultRender = {
+            //Base structural nodes
+            Document: (_node, children) => react_1.default.createElement(react_1.default.Fragment, null, ...children, this.renderFootnotes()),
+            Paragraph: (_node, children) => react_1.default.createElement("p", null, ...children),
+            //Container nodes
+            CodeBlock: (node) => react_1.default.createElement("pre", null, react_1.default.createElement("code", { className: `lang-${node.lang}` }, node.content)),
+            Header: (node, children) => react_1.default.createElement(`h${node.level}`, { style: { borderBottom: node.level <= 2 ? "1px solid #d1d9e0b3" : undefined } }, ...children),
+            Quote: (_node, children) => react_1.default.createElement("blockquote", { style: { margin: "0", padding: "0 1em", color: "#59636e", borderLeft: ".25em solid #d1d9e0" } }, ...children),
+            //For list nodes
+            List: (node, children) => node.ordered ?
+                react_1.default.createElement("ol", null, ...children) :
+                react_1.default.createElement("ul", null, ...children),
+            ListItem: (_node, children) => react_1.default.createElement("li", null, ...children),
+            TaskItem: (node, children) => react_1.default.createElement("li", null, react_1.default.createElement("input", {
+                type: "checkbox",
+                disabled: true,
+                checked: !!node.checked,
+                readOnly: true
+            }), ...children),
+            //Styling nodes
+            Bold: (_node, children) => react_1.default.createElement("strong", null, ...children),
+            Italic: (_node, children) => react_1.default.createElement("em", null, ...children),
+            Strikethrough: (_node, children) => react_1.default.createElement("s", null, ...children),
+            InlineCode: (node) => react_1.default.createElement("code", null, node.content),
+            //Media nodes
+            Link: (node) => react_1.default.createElement("a", {
+                href: node.href,
+                //Security reason
+                target: "_blank",
+                rel: "noopener"
+            }, node.text),
+            Image: (node) => react_1.default.createElement("img", {
+                src: node.src,
+                alt: node.alt,
+            }, null),
+            //Leaf nodes
+            HorizontalLine: (_node) => react_1.default.createElement("hr"),
+            Text: (node) => node.value || "",
+            //For table nodes
+            Table: (node, children) => this.renderTable(node, children),
+            //For HTML
+            HTMLBlock: (node) => this.options.converterOptions?.allowDangerousHtml
+                ? react_1.default.createElement("div", { dangerouslySetInnerHTML: { __html: node.value } })
+                : react_1.default.createElement("code", null, node.value),
+            HTMLInline: (node) => this.options.converterOptions?.allowDangerousHtml
+                ? react_1.default.createElement("span", { dangerouslySetInnerHTML: { __html: node.value } })
+                : react_1.default.createElement("code", null, node.value),
+            //For footnote
+            FootnoteRef: (node) => {
+                const idx = this.footNoteResolver.getUsedRefById(node.id);
+                return react_1.default.createElement("sup", { id: `fnref:${idx}` }, react_1.default.createElement("a", { href: `#fn:${idx}`, className: "footnote-ref" }, `[${idx}]`));
+            }
+        };
+        return (this.options.renderOptions?.elements?.[type] ?? defaultRender[type]);
+    }
+    renderTable(node, children) {
+        if (node.type === "Table") {
+            const header = node.rows.filter(row => row.isHeader);
+            const body = node.rows.filter(row => !row.isHeader);
+            const renderRows = (row, rowIndex) => {
+                return react_1.default.createElement("tr", { key: rowIndex }, row.cells.map((cell, cellIndex) => {
+                    const tag = row.isHeader ? "th" : "td";
+                    return react_1.default.createElement(tag, { key: cellIndex, style: { textAlign: cell.align } }, ...cell.children.map(c => this.render(c)));
+                }));
+            };
+            const tHead = header.length
+                ? react_1.default.createElement("thead", null, header.map((row, i) => renderRows(row, i)))
+                : null;
+            const tBody = body.length
+                ? react_1.default.createElement("tbody", null, body.map((row, i) => renderRows(row, i)))
+                : null;
+            return react_1.default.createElement("table", null, tHead, tBody);
+        }
+        else
+            return react_1.default.createElement("p", null, ...children);
+    }
+    renderFootnotes() {
+        if (this.footNoteResolver.isResolverValid()) {
+            const used = this.footNoteResolver.getUsedRef();
+            if (used.length === 0)
+                return null;
+            const items = used.map((id, i) => {
+                const def = this.footNoteResolver.getDef(id) ?? "";
+                const idx = i + 1;
+                return react_1.default.createElement("li", { id: `fn:${idx}` }, react_1.default.createElement("p", null, def + " ", react_1.default.createElement("a", { href: `#fnref:${idx}`, className: "footnote-backref" }, "↩")));
+            });
+            return react_1.default.createElement("section", { className: "footnotes" }, react_1.default.createElement("ol", null, ...items));
+        }
+        else
+            return null;
+    }
+}
+exports.default = ReactRenderer;

package/dist/types/options/converterOptions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * General option for the render process.
+ * These rules define high-level behavior for render process.
+ */
+export type ConvertOption = {
+    /**
+     * Allow raw HTML rendered in the Markdown input.
+     * When false (default), HTML tags are escaped for security
+     */
+    allowDangerousHtml: boolean;
+};

package/dist/types/options/converterOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/options/index.d.ts

@@ -0,0 +1,10 @@
+import { ConvertOption } from "./converterOptions";
+import { RenderOption } from './renderOptions';
+/**
+ * General option for rendering Markdown into HTML strings
+ * @template TOutput - Output type after rendered
+ */
+export interface MarkdownOptions<TOutput> {
+    renderOptions?: RenderOption<TOutput>;
+    converterOptions?: ConvertOption;
+}

package/dist/types/options/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/options/reactRenderOptions.d.ts

@@ -0,0 +1,50 @@
+import { Node } from "../node";
+/**
+ * Function type for rendering an AST node to a ReactNode.
+ *
+ * @template T - A subtype of `Node` corresponding to the render node
+ * @param node - The AST node to render
+ * @param children - An array of rendered `ReactNode` from the node's children
+ * @returns A `React.ReactNode` representation of the node
+ */
+type ReactNodeRenderer<T extends Node = Node> = (node: T, children: React.ReactNode[]) => React.ReactNode;
+/**
+ * A mapping of AST node types to custom render functions.
+ *
+ * - The key is a `Node["type"]` string literal (e.g. `"Header"`, `"Paragraph"`)
+ * - The value is a function `ReactNodeRenderer` function:
+ *      - `node` is a `Node` with its attribute depending on its `type`.
+ *      (e.g. `"Header"` nodes include `level`, `"CodeBlock"` nodes include `lang` and `content`, etc)
+ *      - `children` is the array of rendered `ReactNode` of its children.
+ */
+export type ReactRenderElements = {
+    [K in Node["type"]]?: ReactNodeRenderer<Extract<Node, {
+        type: K;
+    }>>;
+};
+/**
+ * Options to customize how AST nodes are renderes into ReactNode elements
+ *
+ * @property elements - Optional custom rendered for one or more node types
+ *
+ * @example
+ * ```tsx
+ * // Using JSX (Recommended for most users)
+ * const renderOptions: ReactRenderOption = {
+ *  elements: {
+ *    Paragraph: (_node, children) => <p className="paragraph">{children}</p>,
+ *    Bold: (_node, children) => <strong className="bold-text">{children}</strong>,
+ *  }
+ * }
+ * // Or using React.createElement (Common in library core or without JSX)
+ * const renderOptions: ReactRenderOption = {
+ *  elements: {
+ *    Bold: (_node, children) => React.createElement("b", { className: "bold" }, ...children),
+ *   }
+ * }
+ * ```
+ */
+export type ReactRenderOption = {
+    elements?: ReactRenderElements;
+};
+export {};

package/dist/types/options/reactRenderOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/options/renderOptions.d.ts

@@ -0,0 +1,86 @@
+import { ASTNode } from '../parser';
+/**
+ * A strategy function type for rendering a specific AST node.
+ * @template TOutput - The resulting type after rendered.
+ * @template TNode - The specific `ASTNode` processed.
+ *
+ * @param node - The `ASTNode` object containing its properties.
+ * @param children - An array of already rendered `TOutput` of this node's childrens.
+ * @returns The rendered result for the given node.
+ *
+ * @since v.1.2.0 - Introduced `GenericNodeRenderer` for defining `RenderElement`
+ */
+type GenericNodeRenderer<TOutput, TNode extends ASTNode = ASTNode> = (node: TNode, children: TOutput[]) => TOutput;
+/**
+ * A mapping of `ASTNode` types to their coressponding rendering functions.
+ * @template TOutput - The target output type of the renderer.
+ */
+export type GenericRenderElements<TOutput> = {
+    [K in ASTNode["type"]]?: GenericNodeRenderer<TOutput, ASTNode>;
+} & {
+    [key: string]: GenericNodeRenderer<TOutput, any> | undefined;
+};
+/**
+ * Options for customizing the rendering process for a specific output type.
+ * @template TOutput - The output type.
+ */
+export interface RenderOption<TOutput> {
+    elements?: GenericRenderElements<TOutput>;
+}
+/**
+ * An utilities type alias for render `ASTNode` to `HTML string`
+ * Equivalent to `GenericRenderElements<string>`.
+ * @alias DefaultRenderElements
+ */
+export type DefaultRenderElements = GenericRenderElements<string>;
+/**
+ * An utilities type alias for render `ASTNode` to `React.ReactNode`
+ * Equivalent to `GenericRenderElements<React.ReactNode>`.
+ * @alias ReactRenderElements
+ */
+export type ReactRenderElements = GenericRenderElements<React.ReactNode>;
+/**
+ * Options to customize how AST nodes are renderes into HTML
+ * @deprecated Use {@link RenderOption<string>} for generic support.
+ *
+ * @property elements - Optional custom rendered for one or more node types
+ * @example
+ * ```ts
+ * const renderOptions: RenderOption = {
+ *   elements: {
+ *     Paragraph: (_node, children) => `<div class="paragraph">${children.join("")}</div>`,
+ *     Bold: (_node, children) => `<b class="bold-text">${children.join("")}</b>`,
+ *   }
+ * }
+ * ```
+ *
+ */
+export type DefaultRenderOption = {
+    elements?: DefaultRenderElements;
+};
+/**
+ * Options to customize how AST nodes are renderes into ReactNode elements
+ * @deprecated Use {@link RenderOption<React.ReactNode>} for generic support.
+ *
+ * @property elements - Optional custom rendered for one or more node types
+ * @example
+ * ```tsx
+ * // Using JSX (Recommended for most users)
+ * const renderOptions: ReactRenderOption = {
+ *  elements: {
+ *    Paragraph: (_node, children) => <p className="paragraph">{children}</p>,
+ *    Bold: (_node, children) => <strong className="bold-text">{children}</strong>,
+ *  }
+ * }
+ * // Or using React.createElement (Common in library core or without JSX)
+ * const renderOptions: ReactRenderOption = {
+ *  elements: {
+ *    Bold: (_node, children) => React.createElement("b", { className: "bold" }, ...children),
+ *   }
+ * }
+ * ```
+ */
+export type ReactRenderOption = {
+    elements?: ReactRenderElements;
+};
+export {};

package/dist/types/options/renderOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/parser.d.ts

@@ -0,0 +1,132 @@
+import { IParser } from '../core/parser/index';
+import { Token } from './token';
+/**
+ * AST (Abstract Syntax Tree) node definition.
+ *
+ * Each node represents a Markdown construct and some special nodes (Document, Paragraph).
+ * Some nodes are containers (have `children`), while others are leaf nodes (contain text).
+ *
+ * Variants:
+ * - Document: Root node, contains all other nodes.
+ * - Paragraph: A block of text, contain inline nodes.
+ * - Header: A header with given `level` (1-6)
+ * - Bold: Bold text
+ * - Italic: Italic text
+ * - Strikethrough: Strilethrough text
+ * - InlineCode: Inline code snippet, with it's `content`
+ * - Quote: A quote block
+ * - CodeBlock: A code block, with it's `lang` and `content`
+ * - List: A list, with it's level and children
+ * - ListItem: An item of a list, with it's children
+ * - TaskItem: An item for tasklist, with it's checked state
+ * - Link: A link, with it's `text` and `href`
+ * - Image: An image, with it's `src` and `alt`
+ * - HorizontalLine: A horizontal line
+ * - Text: Raw text content.
+ * - Table: A table, with it's rows
+ * - HTMLBlock: A HTML block element, with it's `value`
+ * - HTMLInline: An inline HTML element, with it's `value`
+ * - FootnoteRef: A refernce with it's `id`
+ *
+ * {@link ASTNode} for each variant's attribute listed detail
+ */
+export type DefaultNodeType = "Document" | "Paragraph" | "Header" | "Bold" | "Italic" | "Strikethrough" | "InlineCode" | "CodeBlock" | "Quote" | "List" | "ListItem" | "TaskItem" | "Link" | "Image" | "HorizontalLine" | "Text" | "Table" | "HTMLBlock" | "HTMLInline" | "FootnoteRef";
+export type NodeType = DefaultNodeType | (string & {});
+export interface TableCell {
+    align: "left" | "center" | "right";
+    children: ASTNode[];
+}
+export interface TableRow {
+    isHeader: boolean;
+    cells: TableCell[];
+}
+/**
+ * AST (Abstract Syntax Tree) node definition. It representing all possible Markdown constructs and its possible properties.
+ *
+ * Use the `type` property to determine which other properties are available.
+ */
+export interface ASTNode {
+    /**
+     * The type of the node, determining its structure and purpose.
+     * @see {@link DefaultNodeType} for standard types.
+     */
+    type: NodeType;
+    /**
+     * Nested nodes within this container.
+     * Applicable for: `Document`, `Paragraph`, `Header`, `Bold`, `Italic`, `Strikethrough`, `Quote`, `List`, `ListItem`, `TaskItem`.
+     */
+    children?: ASTNode[];
+    /**
+     * Raw string content.
+     * Applicable for: `Text` (the plain text), `HTMLBlock` & `HTMLInline` (the raw HTML code).
+     */
+    value?: string;
+    /**
+     * The internal content of a code element.
+     * Applicable for: `InlineCode`, `CodeBlock`.
+     */
+    content?: string;
+    /**
+     * The level of importance/depth.
+     * Applicable for: `Header` (1-6).
+     */
+    level?: number;
+    /**
+     * Programming language identifier for syntax highlighting.
+     * Applicable for: `CodeBlock` (e.g., "javascript", "python").
+     */
+    lang?: string;
+    /**
+     * URL or path for external resources.
+     * Applicable for: `Link` (destination), `Image` (source).
+     */
+    href?: string;
+    /**
+     * The clickable text label for a link.
+     * Applicable for: `Link`.
+     */
+    text?: string;
+    /**
+     * Source URL of an image.
+     * Applicable for: `Image`.
+     */
+    src?: string;
+    /**
+     * Alternative text for accessibility.
+     * Applicable for: `Image`.
+     */
+    alt?: string;
+    /**
+     * Indicates if a list is numbered (true) or bulleted (false).
+     * Applicable for: `List`.
+     */
+    ordered?: boolean;
+    /**
+     * The completion status of a task.
+     * Applicable for: `TaskItem`.
+     */
+    checked?: boolean;
+    /**
+     * Array of rows defining the table structure.
+     * Applicable for: `Table`.
+     */
+    rows?: TableRow[];
+    /**
+     * Unique identifier for referencing.
+     * Applicable for: `FootnoteRef`.
+     */
+    id?: string;
+    /**
+     * Allows custom properties for extensions or plugin-specific data.
+     */
+    [key: string]: any;
+}
+/**
+ * A Strategy pattern for handle parsing process for each Token.
+ * @property type - Strategy's type
+ * @property execute - A function handle parsing a `Token` to `ASTNode`
+ */
+export interface ParsingStrategy {
+    type: string;
+    execute: (parser: IParser, token: Token) => ASTNode | ASTNode[] | void;
+}

package/dist/types/parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/renderer.d.ts

@@ -0,0 +1,12 @@
+import { IRenderer } from "../renderers";
+import { ASTNode } from "./parser";
+/**
+ * A Strategy pattern for handle parsing process for each ASTNode.
+ * @template TOutput - Output result after rendered by `render` property.
+ * @property type - Strategy's type
+ * @property execute - A function handle rendering a `ASTNode` to `TOutput`
+ */
+export interface RenderStrategy<TOutput> {
+    type: string;
+    render: (node: ASTNode, children: TOutput[], context: IRenderer<TOutput>) => TOutput;
+}

package/dist/types/renderer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });