text-runner-engine 7.1.0

package/dist/helpers/add-trailing-slash.js

@@ -0,0 +1,7 @@
+export function addTrailingSlash(text) {
+    if (text.endsWith("/")) {
+        return text;
+    }
+    return text + "/";
+}
+//# sourceMappingURL=add-trailing-slash.js.map

package/dist/helpers/index.d.ts

@@ -0,0 +1,16 @@
+export * from "../actions/name.js";
+export * from "./add-leading-dot-unless-empty.js";
+export * from "./add-leading-slash.js";
+export * from "./add-trailing-slash.js";
+export * from "./is-external-link.js";
+export * from "./is-link-to-anchor-in-other-file.js";
+export * from "./is-link-to-anchor-in-same-file.js";
+export * from "./is-mailto-link.js";
+export * from "./remove-double-slash.js";
+export * from "./remove-leading-slash.js";
+export * from "./remove-trailing-colon.js";
+export * from "./straighten-link.js";
+export * from "./trim-all-line-ends.js";
+export * from "./trim-extension.js";
+export * from "./unixify.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.js

@@ -0,0 +1,16 @@
+export * from "../actions/name.js";
+export * from "./add-leading-dot-unless-empty.js";
+export * from "./add-leading-slash.js";
+export * from "./add-trailing-slash.js";
+export * from "./is-external-link.js";
+export * from "./is-link-to-anchor-in-other-file.js";
+export * from "./is-link-to-anchor-in-same-file.js";
+export * from "./is-mailto-link.js";
+export * from "./remove-double-slash.js";
+export * from "./remove-leading-slash.js";
+export * from "./remove-trailing-colon.js";
+export * from "./straighten-link.js";
+export * from "./trim-all-line-ends.js";
+export * from "./trim-extension.js";
+export * from "./unixify.js";
+//# sourceMappingURL=index.js.map

package/dist/helpers/is-external-link.d.ts

@@ -0,0 +1,2 @@
+export declare function isExternalLink(target: string): boolean;
+//# sourceMappingURL=is-external-link.d.ts.map

package/dist/helpers/is-external-link.js

@@ -0,0 +1,5 @@
+import * as url from "url";
+export function isExternalLink(target) {
+    return target.startsWith("//") || !!url.parse(target).protocol;
+}
+//# sourceMappingURL=is-external-link.js.map

package/dist/helpers/is-link-to-anchor-in-other-file.d.ts

@@ -0,0 +1,2 @@
+export declare function isLinkToAnchorInOtherFile(target: string): boolean;
+//# sourceMappingURL=is-link-to-anchor-in-other-file.d.ts.map

package/dist/helpers/is-link-to-anchor-in-other-file.js

@@ -0,0 +1,4 @@
+export function isLinkToAnchorInOtherFile(target) {
+    return !target.startsWith("#") && !target.includes("://") && target.includes("#");
+}
+//# sourceMappingURL=is-link-to-anchor-in-other-file.js.map

package/dist/helpers/is-link-to-anchor-in-same-file.d.ts

@@ -0,0 +1,2 @@
+export declare function isLinkToAnchorInSameFile(target: string): boolean;
+//# sourceMappingURL=is-link-to-anchor-in-same-file.d.ts.map

package/dist/helpers/is-link-to-anchor-in-same-file.js

@@ -0,0 +1,4 @@
+export function isLinkToAnchorInSameFile(target) {
+    return target.startsWith("#");
+}
+//# sourceMappingURL=is-link-to-anchor-in-same-file.js.map

package/dist/helpers/is-mailto-link.d.ts

@@ -0,0 +1,2 @@
+export declare function isMailtoLink(target: string): boolean;
+//# sourceMappingURL=is-mailto-link.d.ts.map

package/dist/helpers/is-mailto-link.js

@@ -0,0 +1,4 @@
+export function isMailtoLink(target) {
+    return target.startsWith("mailto:");
+}
+//# sourceMappingURL=is-mailto-link.js.map

package/dist/helpers/remove-double-slash.d.ts

@@ -0,0 +1,3 @@
+/** Replaces multiple occurrences of '/' with a single slash */
+export declare function removeDoubleSlash(text: string): string;
+//# sourceMappingURL=remove-double-slash.d.ts.map

package/dist/helpers/remove-double-slash.js

@@ -0,0 +1,6 @@
+const doubleSlashRE = /\/+/g;
+/** Replaces multiple occurrences of '/' with a single slash */
+export function removeDoubleSlash(text) {
+    return text.replace(doubleSlashRE, "/");
+}
+//# sourceMappingURL=remove-double-slash.js.map

package/dist/helpers/remove-leading-slash.d.ts

@@ -0,0 +1,2 @@
+export declare function removeLeadingSlash(text: string): string;
+//# sourceMappingURL=remove-leading-slash.d.ts.map

package/dist/helpers/remove-leading-slash.js

@@ -0,0 +1,7 @@
+export function removeLeadingSlash(text) {
+    if (!text.startsWith("/") && !text.startsWith("\\")) {
+        return text;
+    }
+    return text.slice(1);
+}
+//# sourceMappingURL=remove-leading-slash.js.map

package/dist/helpers/remove-trailing-colon.d.ts

@@ -0,0 +1,2 @@
+export declare function removeTrailingColon(text: string): string;
+//# sourceMappingURL=remove-trailing-colon.d.ts.map

package/dist/helpers/remove-trailing-colon.js

@@ -0,0 +1,9 @@
+export function removeTrailingColon(text) {
+    if (text.endsWith(":")) {
+        return text.substring(0, text.length - 1);
+    }
+    else {
+        return text;
+    }
+}
+//# sourceMappingURL=remove-trailing-colon.js.map

package/dist/helpers/straighten-link.d.ts

@@ -0,0 +1,3 @@
+/** Removes intermediate directory expressions from the given link */
+export declare function straightenLink(link: string): string;
+//# sourceMappingURL=straighten-link.d.ts.map

package/dist/helpers/straighten-link.js

@@ -0,0 +1,15 @@
+const replaceDoubleSlashRE = /\/\//g;
+const replaceDotRE = /\/\.\//;
+const replaceDotDotRE = /\/[^/]+\/\.\.\//;
+/** Removes intermediate directory expressions from the given link */
+export function straightenLink(link) {
+    let result = link.replace(replaceDoubleSlashRE, "/");
+    while (result.includes("/./")) {
+        result = result.replace(replaceDotRE, "/");
+    }
+    while (replaceDotDotRE.test(result)) {
+        result = result.replace(replaceDotDotRE, "/");
+    }
+    return result;
+}
+//# sourceMappingURL=straighten-link.js.map

package/dist/helpers/trim-all-line-ends.d.ts

@@ -0,0 +1,3 @@
+/** Removes all whitespace at the end of each line in the given multi-line string */
+export declare function trimAllLineEnds(text: string): string;
+//# sourceMappingURL=trim-all-line-ends.d.ts.map

package/dist/helpers/trim-all-line-ends.js

@@ -0,0 +1,5 @@
+/** Removes all whitespace at the end of each line in the given multi-line string */
+export function trimAllLineEnds(text) {
+    return text.replace(/[ ]+$/gm, "");
+}
+//# sourceMappingURL=trim-all-line-ends.js.map

package/dist/helpers/trim-extension.d.ts

@@ -0,0 +1,2 @@
+export declare function trimExtension(filePath: string): string;
+//# sourceMappingURL=trim-extension.d.ts.map

package/dist/helpers/trim-extension.js

@@ -0,0 +1,5 @@
+import * as path from "path";
+export function trimExtension(filePath) {
+    return path.join(path.dirname(filePath), path.basename(filePath, path.extname(filePath)));
+}
+//# sourceMappingURL=trim-extension.js.map

package/dist/helpers/unixify.d.ts

@@ -0,0 +1,3 @@
+/** Converts the given Windows path into a Unix path */
+export declare function unixify(text: string): string;
+//# sourceMappingURL=unixify.d.ts.map

package/dist/helpers/unixify.js

@@ -0,0 +1,6 @@
+const re = /\\/g;
+/** Converts the given Windows path into a Unix path */
+export function unixify(text) {
+    return text.replace(re, "/");
+}
+//# sourceMappingURL=unixify.js.map

package/dist/link-targets/find.d.ts

@@ -0,0 +1,4 @@
+import * as ast from "../ast/index.js";
+import { List } from "./list.js";
+export declare function find(nodeLists: ast.NodeList[]): List;
+//# sourceMappingURL=find.d.ts.map

package/dist/link-targets/find.js

@@ -0,0 +1,9 @@
+import { List } from "./list.js";
+export function find(nodeLists) {
+    const linkTargetList = new List();
+    for (const nodeList of nodeLists) {
+        linkTargetList.addNodeList(nodeList);
+    }
+    return linkTargetList;
+}
+//# sourceMappingURL=find.js.map

package/dist/link-targets/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./find.js";
+export * from "./list.js";
+/**
+ * Target is a position in a Markdown file that links can point to:
+ * headers or anchors
+ */
+export interface Target {
+    readonly level?: number;
+    readonly name: string;
+    readonly text?: string;
+    readonly type: Types;
+}
+/** types of link targets */
+export type Types = "anchor" | "heading";
+//# sourceMappingURL=index.d.ts.map

package/dist/link-targets/index.js

@@ -0,0 +1,3 @@
+export * from "./find.js";
+export * from "./list.js";
+//# sourceMappingURL=index.js.map

package/dist/link-targets/list.d.ts

@@ -0,0 +1,18 @@
+import * as ast from "../ast/index.js";
+import * as files from "../filesystem/index.js";
+import { Target, Types } from "./index.js";
+export declare class List {
+    readonly targets: Record<string, Target[]>;
+    constructor();
+    addAnchor(node: ast.Node): void;
+    addHeading(node: ast.Node, nodeList: ast.NodeList): void;
+    addLinkTarget(file: files.FullFilePath, type: Types, name: string): void;
+    addNodeList(nodeList: ast.NodeList): void;
+    anchorType(file: files.FullFilePath, name: string): string;
+    getAnchor(file: files.FullFilePath, name: string): null | Target;
+    /** provides all the anchors for the given file */
+    getAnchors(file: files.FullFilePath): string[];
+    hasAnchor(file: files.FullFilePath, name: string): boolean;
+    hasFile(filePath: files.FullFilePath): boolean;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/link-targets/list.js

@@ -0,0 +1,74 @@
+import { targetURL } from "./target-url.js";
+export class List {
+    constructor() {
+        this.targets = {};
+    }
+    addAnchor(node) {
+        if (node.attributes.href !== undefined) {
+            return;
+        }
+        if (!node.attributes.name) {
+            return;
+        }
+        this.addLinkTarget(node.location.file, "anchor", node.attributes.name);
+    }
+    addHeading(node, nodeList) {
+        const content = nodeList.textInNode(node);
+        if (!content) {
+            return;
+        }
+        this.addLinkTarget(node.location.file, "heading", content);
+    }
+    addLinkTarget(file, type, name) {
+        const key = file.platformified();
+        this.targets[key] = this.targets[key] || [];
+        this.targets[key].push({ name: targetURL(name), type });
+    }
+    addNodeList(nodeList) {
+        for (const node of nodeList) {
+            const key = node.location.file.platformified();
+            this.targets[key] = this.targets[key] || [];
+            if (node.type === "anchor_open") {
+                this.addAnchor(node);
+            }
+            else if (/h[1-6]_open/.test(node.type)) {
+                this.addHeading(node, nodeList);
+            }
+        }
+    }
+    // Returns the type of the given anchor
+    // with the given name in the given file
+    anchorType(file, name) {
+        const anchorsForFile = this.targets[file.platformified()];
+        if (!anchorsForFile) {
+            // TODO: make UserError
+            throw new Error(`no anchors in file ${file.platformified()}`);
+        }
+        const anchor = anchorsForFile.find(linkTarget => linkTarget.name === name);
+        if (!anchor) {
+            // TODO: make UserError
+            throw new Error(`no anchor '${name}' in file '${file.platformified()}'`);
+        }
+        return anchor.type;
+    }
+    getAnchor(file, name) {
+        for (const target of this.targets[file.platformified()] || []) {
+            if (target.name === name) {
+                return target;
+            }
+        }
+        return null;
+    }
+    /** provides all the anchors for the given file */
+    getAnchors(file) {
+        return (this.targets[file.platformified()] || []).map(target => target.name);
+    }
+    hasAnchor(file, name) {
+        return this.getAnchor(file, name) != null;
+    }
+    // Returns whether this link target list knows about the given file
+    hasFile(filePath) {
+        return this.targets[filePath.platformified()] != null;
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/link-targets/target-url.d.ts

@@ -0,0 +1,2 @@
+export declare function targetURL(targetName: string): string;
+//# sourceMappingURL=target-url.d.ts.map

package/dist/link-targets/target-url.js

@@ -0,0 +1,8 @@
+// @ts-expect-error: no types available
+import anchor from "anchor-markdown-header";
+export function targetURL(targetName) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const link = anchor(targetName, "github.com");
+    return link.substring(link.indexOf("#") + 1, link.indexOf(")"));
+}
+//# sourceMappingURL=target-url.js.map

package/dist/parsers/html/html-parser.d.ts

@@ -0,0 +1,28 @@
+import * as parse5 from "parse5";
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+import { TagMapper } from "../tag-mapper.js";
+/** Parser converts HTML5 source into the standardized AST format. */
+export declare class Parser {
+    private readonly tagMapper;
+    constructor(tagMapper: TagMapper);
+    /**
+     * Parse returns the standard AST for the given HTML text.
+     */
+    parse(text: string, startingLocation: files.Location): ast.NodeList;
+    /** returns the subtree of the given HTML AST whose root node has the given name */
+    private findNodeWithName;
+    /** returns whether the given HTML node is an empty text node */
+    private isEmptyTextNode;
+    /** converts the given HTML AST node into the standard format */
+    private standardizeNode;
+    /** converts the given HTML tag with open and closing tag into the standard format */
+    private standardizeOpenCloseTag;
+    /** converts the given HTML standalone node into the standard format */
+    private standardizeStandaloneNode;
+    /** converts the given HTML text node into the standard format */
+    private standardizeTextNode;
+}
+/** converts the given HTML AST node attributes into the standard AST format */
+export declare function standardizeHTMLAttributes(attrs: parse5.Token.Attribute[]): ast.NodeAttributes;
+//# sourceMappingURL=html-parser.d.ts.map

package/dist/parsers/html/html-parser.js

@@ -0,0 +1,153 @@
+import * as parse5 from "parse5";
+import * as util from "util";
+import * as ast from "../../ast/index.js";
+/** Parser converts HTML5 source into the standardized AST format. */
+export class Parser {
+    constructor(tagMapper) {
+        this.tagMapper = tagMapper;
+    }
+    /**
+     * Parse returns the standard AST for the given HTML text.
+     */
+    parse(text, startingLocation) {
+        const htmlDoc = parse5.parse(text, { sourceCodeLocationInfo: true });
+        const htmlNode = this.findNodeWithName(htmlDoc.childNodes, "html");
+        const bodyNode = this.findNodeWithName(htmlNode.childNodes, "body");
+        const result = new ast.NodeList();
+        for (const childNode of bodyNode.childNodes) {
+            result.push(...this.standardizeNode(childNode, startingLocation.withLine(startingLocation.line)));
+        }
+        return result;
+    }
+    /** returns the subtree of the given HTML AST whose root node has the given name */
+    findNodeWithName(nodes, name) {
+        for (const node of nodes) {
+            if (node.nodeName === name) {
+                if (!instanceOfElement(node)) {
+                    throw new Error("Expected parse5.Element");
+                }
+                return node;
+            }
+        }
+        throw new Error(`child node '${name}' not found in AST: ${util.inspect(nodes, false, Infinity)}`);
+    }
+    /** returns whether the given HTML node is an empty text node */
+    isEmptyTextNode(node) {
+        return instanceOfTextNode(node) && node.value.trim() === "";
+    }
+    /** converts the given HTML AST node into the standard format */
+    standardizeNode(node, startingLocation) {
+        if (this.isEmptyTextNode(node)) {
+            return new ast.NodeList();
+        }
+        if (instanceOfTextNode(node)) {
+            return this.standardizeTextNode(node, startingLocation);
+        }
+        if (!instanceOfElement(node)) {
+            throw new Error("unknown tree node: " + util.inspect(node, false, Infinity));
+        }
+        if (this.tagMapper.isStandaloneTag(node.nodeName)) {
+            return this.standardizeStandaloneNode(node, startingLocation);
+        }
+        return this.standardizeOpenCloseTag(node, startingLocation);
+    }
+    /** converts the given HTML tag with open and closing tag into the standard format */
+    standardizeOpenCloseTag(node, startingLocation) {
+        const result = new ast.NodeList();
+        const attributes = standardizeHTMLAttributes(node.attrs);
+        // store the opening node
+        let startLine = startingLocation.line;
+        if (node.sourceCodeLocation) {
+            startLine += node.sourceCodeLocation.startLine - 1;
+        }
+        else {
+            const parentNode = node.parentNode;
+            if (parentNode == null) {
+                throw new Error(`node "${node} has no parent`);
+            }
+            if (parentNode.sourceCodeLocation) {
+                startLine += parentNode.sourceCodeLocation.startLine;
+            }
+        }
+        result.push(new ast.Node({
+            attributes,
+            content: "",
+            location: startingLocation.withLine(startLine),
+            tag: node.tagName,
+            type: this.tagMapper.openingTypeForTag(node.tagName, attributes)
+        }));
+        // store the child nodes in between the opening and closing node
+        for (const childNode of node.childNodes) {
+            const standardizedChildNodes = this.standardizeNode(childNode, startingLocation);
+            result.push(...standardizedChildNodes);
+        }
+        // store the closing node
+        let endLine;
+        if (node.sourceCodeLocation) {
+            endLine = node.sourceCodeLocation.endLine + startingLocation.line - 1;
+        }
+        else if (node.parentNode && instanceOfElement(node.parentNode) && node.parentNode.sourceCodeLocation) {
+            endLine = node.parentNode.sourceCodeLocation.endLine + startingLocation.line - 1;
+        }
+        else {
+            throw new Error(`cannot determine end line for node ${node}`);
+        }
+        if (!node.sourceCodeLocation || (node.sourceCodeLocation && node.sourceCodeLocation.endTag)) {
+            const tag = ("/" + node.tagName);
+            result.push(new ast.Node({
+                attributes: {},
+                content: "",
+                location: startingLocation.withLine(endLine),
+                tag,
+                type: this.tagMapper.typeForTag(tag, attributes)
+            }));
+        }
+        return result;
+    }
+    /** converts the given HTML standalone node into the standard format */
+    standardizeStandaloneNode(node, startingLocation) {
+        var _a;
+        const result = new ast.NodeList();
+        const attributes = standardizeHTMLAttributes(node.attrs);
+        result.push(new ast.Node({
+            attributes,
+            content: "",
+            location: startingLocation.withLine((((_a = node.sourceCodeLocation) === null || _a === void 0 ? void 0 : _a.startLine) || 0) + startingLocation.line - 1),
+            tag: node.tagName,
+            type: this.tagMapper.typeForTag(node.tagName, attributes)
+        }));
+        return result;
+    }
+    /** converts the given HTML text node into the standard format */
+    standardizeTextNode(node, startingLocation) {
+        var _a, _b;
+        const result = new ast.NodeList();
+        if (node.value !== "\n") {
+            result.push(new ast.Node({
+                attributes: {},
+                content: node.value.trim(),
+                location: startingLocation.withLine(((_b = (_a = node.sourceCodeLocation) === null || _a === void 0 ? void 0 : _a.startLine) !== null && _b !== void 0 ? _b : 0) + startingLocation.line - 1),
+                tag: "",
+                type: "text"
+            }));
+        }
+        return result;
+    }
+}
+/** converts the given HTML AST node attributes into the standard AST format */
+export function standardizeHTMLAttributes(attrs) {
+    const result = {};
+    if (attrs) {
+        for (const attr of attrs) {
+            result[attr.name] = attr.value;
+        }
+    }
+    return result;
+}
+function instanceOfElement(object) {
+    return !!object.nodeName && !!object.tagName && !!object.attrs;
+}
+function instanceOfTextNode(object) {
+    return object.nodeName === "#text";
+}
+//# sourceMappingURL=html-parser.js.map

package/dist/parsers/html/index.d.ts

@@ -0,0 +1,2 @@
+export { Parser } from "./html-parser.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/html/index.js

@@ -0,0 +1,2 @@
+export { Parser } from "./html-parser.js";
+//# sourceMappingURL=index.js.map

package/dist/parsers/html/parse-html-files.d.ts

@@ -0,0 +1,6 @@
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+import { TagMapper } from "../tag-mapper.js";
+/** returns the standard AST for the HTML files with the given paths */
+export declare function parseHTMLFiles(filenames: files.FullFilePath[], sourceDir: files.SourceDir, tagMapper: TagMapper): Promise<ast.NodeList[]>;
+//# sourceMappingURL=parse-html-files.d.ts.map

package/dist/parsers/html/parse-html-files.js

@@ -0,0 +1,16 @@
+import { promises as fs } from "fs";
+import * as files from "../../filesystem/index.js";
+import { Parser } from "./html-parser.js";
+/** returns the standard AST for the HTML files with the given paths */
+export async function parseHTMLFiles(filenames, sourceDir, tagMapper) {
+    const result = [];
+    const parser = new Parser(tagMapper);
+    for (const filename of filenames) {
+        const content = await fs.readFile(sourceDir.joinFullFile(filename).platformified(), {
+            encoding: "utf8"
+        });
+        result.push(parser.parse(content, new files.Location(sourceDir, filename, 1)));
+    }
+    return Promise.all(result);
+}
+//# sourceMappingURL=parse-html-files.js.map

package/dist/parsers/index.d.ts

@@ -0,0 +1,3 @@
+export * as html from "./html/index.js";
+export * as markdown from "./markdown/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/index.js

@@ -0,0 +1,3 @@
+export * as html from "./html/index.js";
+export * as markdown from "./markdown/index.js";
+//# sourceMappingURL=index.js.map

package/dist/parsers/markdown/closing-tag-parser.d.ts

@@ -0,0 +1,13 @@
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+import { TagMapper } from "../tag-mapper.js";
+/** ClosingTagParser parses HTML blocks containing just a closing tag. */
+export declare class ClosingTagParser {
+    private readonly closingTagRE;
+    private readonly tagMapper;
+    constructor(tagMapper: TagMapper);
+    /** Returns whether the given tag is a closing tag */
+    isClosingTag(tag: string): boolean;
+    parse(tag: string, location: files.Location): ast.NodeList;
+}
+//# sourceMappingURL=closing-tag-parser.d.ts.map

package/dist/parsers/markdown/closing-tag-parser.js

@@ -0,0 +1,29 @@
+import * as ast from "../../ast/index.js";
+/** ClosingTagParser parses HTML blocks containing just a closing tag. */
+export class ClosingTagParser {
+    constructor(tagMapper) {
+        this.closingTagRE = /^\s*<[ ]*(\/[ ]*\w+)[ ]*>\s*$/;
+        this.tagMapper = tagMapper;
+    }
+    /** Returns whether the given tag is a closing tag */
+    isClosingTag(tag) {
+        return this.closingTagRE.test(tag);
+    }
+    parse(tag, location) {
+        const match = this.closingTagRE.exec(tag);
+        if (!match) {
+            throw new Error(`no tag parsed in ${tag}`);
+        }
+        const tagName = match[1].replace(/ /g, "");
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: {},
+            content: "",
+            location,
+            tag: tagName,
+            type: this.tagMapper.typeForTag(tagName, {})
+        }));
+        return result;
+    }
+}
+//# sourceMappingURL=closing-tag-parser.js.map

package/dist/parsers/markdown/index.d.ts

@@ -0,0 +1,3 @@
+export { MarkdownParser } from "./md-parser.js";
+export * from "./parse.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/markdown/index.js

@@ -0,0 +1,3 @@
+export { MarkdownParser } from "./md-parser.js";
+export * from "./parse.js";
+//# sourceMappingURL=index.js.map