document-ir 0.0.11 → 0.0.12

package/esm/DocumentThinningTransformer.d.ts

@@ -0,0 +1,16 @@
+import { ArrayCollapseTransformer } from "./index.js";
+import { BubbleNode, CardNode, ColumnsNode, DefinitionListNode, FigureImageNode, HighTechAlertNode, ImageNode, Node, NoteNode, QuoteNode, RedactedNode, StickerNode, VideoNode } from "./types.js";
+export declare class DocumentThinningTransformer extends ArrayCollapseTransformer {
+    protected sticker(node: StickerNode): Promise<Node | null>;
+    protected bubble(node: BubbleNode): Promise<Node | null>;
+    protected highTechAlert(node: HighTechAlertNode): Promise<Node | null>;
+    protected columns(node: ColumnsNode): Promise<Node | null>;
+    protected quote(node: QuoteNode): Promise<Node | null>;
+    protected image(node: ImageNode): Promise<Node | null>;
+    protected figureImage(node: FigureImageNode): Promise<Node | null>;
+    protected video(node: VideoNode): Promise<Node | null>;
+    protected definitionList(node: DefinitionListNode): Promise<Node | null>;
+    protected redacted(_node: RedactedNode): Promise<Node | null>;
+    protected note(node: NoteNode): Promise<Node | null>;
+    protected card(node: CardNode): Promise<Node | null>;
+}

package/esm/DocumentThinningTransformer.js

@@ -0,0 +1,246 @@
+import { ArrayCollapseTransformer } from "./index.js";
+export class DocumentThinningTransformer extends ArrayCollapseTransformer {
+    async sticker(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content,
+        };
+    }
+    async bubble(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content,
+        };
+    }
+    async highTechAlert(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    async columns(node) {
+        const flattened = node.columns.flat();
+        if (flattened.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(flattened);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    async quote(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    image(node) {
+        return Promise.resolve({
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline image: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        });
+    }
+    async figureImage(node) {
+        const image = {
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline image: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        };
+        if (node.content) {
+            const content = await this.chooseChildren(node.content);
+            return {
+                type: "array",
+                content: [
+                    image,
+                    ...content,
+                ],
+            };
+        }
+        else {
+            return image;
+        }
+    }
+    async video(node) {
+        const video = {
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline video: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        };
+        if (node.content) {
+            const content = await this.chooseChildren(node.content);
+            return {
+                type: "array",
+                content: [
+                    video,
+                    ...content,
+                ],
+            };
+        }
+        else {
+            return video;
+        }
+    }
+    async definitionList(node) {
+        const content = [];
+        for (const d of node.content) {
+            const defContent = [];
+            const title = await this.chooseChildren(d.title);
+            if (title) {
+                for (const n of title) {
+                    defContent.push(n);
+                }
+            }
+            defContent.push({ type: "text", text: " " });
+            const abbreviation = await this.chooseChildren(d.abbreviation);
+            if (abbreviation) {
+                for (const n of abbreviation) {
+                    defContent.push(n);
+                }
+            }
+            if (d.content.length > 0 && d.content[0].type != "paragraph") {
+                defContent.push({ type: "text", text: " " });
+                const def = await this.chooseChildren(d.content);
+                if (def) {
+                    for (const n of def) {
+                        defContent.push(n);
+                    }
+                }
+            }
+            content.push({
+                type: "paragraph",
+                content: defContent,
+            });
+            if (d.content.length > 0 && d.content[0].type == "paragraph") {
+                const def = await this.chooseChildren(d.content);
+                if (def) {
+                    for (const n of def) {
+                        content.push(n);
+                    }
+                }
+            }
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    // deno-lint-ignore require-await
+    async redacted(_node) {
+        return null;
+    }
+    async note(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content: [
+                { type: "text", text: "Note: " },
+                ...content,
+            ],
+        };
+    }
+    async card(node) {
+        const content = [];
+        if (node.header) {
+            const title = await this.chooseChildren(node.header.title);
+            if (title.length > 0) {
+                content.push({
+                    type: "paragraph",
+                    content: title,
+                });
+            }
+        }
+        if (node.content) {
+            const card = await this.chooseChildren(node.content.content);
+            for (const c of card) {
+                content.push(c);
+            }
+        }
+        if (node.media) {
+            for (const media of node.media.content) {
+                const m = await this.choose(media);
+                if (m) {
+                    content.push(m);
+                }
+            }
+        }
+        if (node.attribution) {
+            const attribution = [];
+            if (node.attribution.title) {
+                const title = await this.chooseChildren(node.attribution.title);
+                for (const n of title) {
+                    content.push(n);
+                }
+            }
+            if (node.attribution.date) {
+                if (content.length > 0) {
+                    content.push({ type: "text", text: " " });
+                }
+                content.push({ type: "text", text: `${node.attribution.date}` });
+            }
+            if (attribution.length > 0) {
+                content.push({
+                    type: "paragraph",
+                    content: attribution,
+                });
+            }
+        }
+        return {
+            type: "array",
+            content: content,
+        };
+    }
+}

package/esm/WordCountTransformer.d.ts

@@ -0,0 +1,6 @@
+import { IdentityTransformer } from "./index.js";
+import { DocumentNode } from "./types.js";
+export declare class WordCounterTransformer extends IdentityTransformer {
+    constructor();
+    transform(node: DocumentNode): Promise<DocumentNode>;
+}

package/esm/WordCountTransformer.js

@@ -0,0 +1,83 @@
+import { DocumentThinningTransformer } from "./DocumentThinningTransformer.js";
+import { WordCounterVisitor } from "./WordCounterVisitor.js";
+import { IdentityTransformer, TextVisitor } from "./index.js";
+function convertHierarchy(parent) {
+    const docHierarchy = {
+        headerText: parent.header,
+        headerId: parent.headerId,
+        words: 0,
+        totalWords: 0,
+        children: [],
+    };
+    const visitor = new WordCounterVisitor();
+    for (const node of parent.nodes) {
+        visitor.visit(node);
+    }
+    docHierarchy.words = visitor.getCount();
+    docHierarchy.totalWords = docHierarchy.words;
+    for (const child of parent.children) {
+        const childHierarchy = convertHierarchy(child);
+        docHierarchy.children.push(childHierarchy);
+        docHierarchy.totalWords += childHierarchy.totalWords;
+    }
+    return docHierarchy;
+}
+export class WordCounterTransformer extends IdentityTransformer {
+    constructor() {
+        super();
+    }
+    async transform(node) {
+        // Isolate it
+        const jsonNode = JSON.parse(JSON.stringify(node));
+        const thinned = await new DocumentThinningTransformer().transform(jsonNode);
+        const stack = [];
+        const root = {
+            header: node.title,
+            headerId: "title",
+            nodes: [],
+            children: [],
+            depth: 1,
+        };
+        stack.push(root);
+        let depth = 1;
+        for (const node of thinned.content) {
+            if (node.type == "header") {
+                if (node.level == 1) {
+                    // never pop the root
+                    continue;
+                }
+                else if (node.level <= depth) {
+                    for (let i = stack.length - 1; i > 0; i--) {
+                        if (stack[i].depth >= node.level) {
+                            stack.pop();
+                        }
+                    }
+                }
+                const visitor = new TextVisitor();
+                visitor.visit(node);
+                const h = {
+                    header: visitor.getText(),
+                    depth: node.level,
+                    children: [],
+                    nodes: [],
+                };
+                if (node.htmlId) {
+                    h.headerId = node.htmlId;
+                }
+                stack[stack.length - 1].children.push(h);
+                stack.push(h);
+                depth = node.level;
+            }
+            else {
+                stack[stack.length - 1].nodes.push(node);
+            }
+        }
+        // The transformer does not actually walk through the document tree
+        // We just append a newly calculated hierarchy object
+        const doc = {
+            ...node,
+        };
+        doc.hierarchy = convertHierarchy(root);
+        return doc;
+    }
+}

package/esm/WordCounterVisitor.d.ts

@@ -0,0 +1,13 @@
+import { NodeVisitor } from "./index.js";
+import { DocumentNode, TextNode } from "./types.js";
+export declare class WordCounterVisitor extends NodeVisitor {
+    private count;
+    private texts;
+    constructor();
+    private countText;
+    protected beforeBlock(): void;
+    protected afterBlock(): void;
+    protected text(node: TextNode): void;
+    protected document(node: DocumentNode): void;
+    getCount(): number;
+}

package/esm/WordCounterVisitor.js

@@ -0,0 +1,43 @@
+import { NodeVisitor } from "./index.js";
+export class WordCounterVisitor extends NodeVisitor {
+    constructor() {
+        super();
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "texts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.count = 0;
+        this.texts = [];
+    }
+    countText() {
+        if (this.texts.length > 0) {
+            this.count += this.texts.join("").split(" ").length;
+            this.texts = [];
+        }
+    }
+    beforeBlock() {
+        this.countText();
+    }
+    afterBlock() {
+        this.countText();
+    }
+    text(node) {
+        this.texts.push(node.text);
+    }
+    document(node) {
+        super.document(node);
+        this.countText();
+    }
+    getCount() {
+        this.countText();
+        return this.count;
+    }
+}

package/esm/index.d.ts

@@ -6,3 +6,6 @@ export { WhitespaceTransformer } from "./WhitespaceTransformer.js";
 export { WhitespaceStretchingTransformer } from "./WhitespaceStretchingTransformer.js";
 export { NodeVisitor } from "./NodeVisitor.js";
 export { TextVisitor } from "./TextVisitor.js";
+export { WordCounterTransformer } from "./WordCountTransformer.js";
+export { WordCounterVisitor } from "./WordCounterVisitor.js";
+export { DocumentThinningTransformer } from "./DocumentThinningTransformer.js";

package/esm/index.js

@@ -6,3 +6,6 @@ export { WhitespaceTransformer } from "./WhitespaceTransformer.js";
 export { WhitespaceStretchingTransformer } from "./WhitespaceStretchingTransformer.js";
 export { NodeVisitor } from "./NodeVisitor.js";
 export { TextVisitor } from "./TextVisitor.js";
+export { WordCounterTransformer } from "./WordCountTransformer.js";
+export { WordCounterVisitor } from "./WordCounterVisitor.js";
+export { DocumentThinningTransformer } from "./DocumentThinningTransformer.js";

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/index.js",
   "main": "./script/index.js",
   "name": "document-ir",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Intermediate representation and transformers for documents",
   "license": "MIT",
   "repository": {

package/script/DocumentThinningTransformer.d.ts

@@ -0,0 +1,16 @@
+import { ArrayCollapseTransformer } from "./index.js";
+import { BubbleNode, CardNode, ColumnsNode, DefinitionListNode, FigureImageNode, HighTechAlertNode, ImageNode, Node, NoteNode, QuoteNode, RedactedNode, StickerNode, VideoNode } from "./types.js";
+export declare class DocumentThinningTransformer extends ArrayCollapseTransformer {
+    protected sticker(node: StickerNode): Promise<Node | null>;
+    protected bubble(node: BubbleNode): Promise<Node | null>;
+    protected highTechAlert(node: HighTechAlertNode): Promise<Node | null>;
+    protected columns(node: ColumnsNode): Promise<Node | null>;
+    protected quote(node: QuoteNode): Promise<Node | null>;
+    protected image(node: ImageNode): Promise<Node | null>;
+    protected figureImage(node: FigureImageNode): Promise<Node | null>;
+    protected video(node: VideoNode): Promise<Node | null>;
+    protected definitionList(node: DefinitionListNode): Promise<Node | null>;
+    protected redacted(_node: RedactedNode): Promise<Node | null>;
+    protected note(node: NoteNode): Promise<Node | null>;
+    protected card(node: CardNode): Promise<Node | null>;
+}

package/script/DocumentThinningTransformer.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentThinningTransformer = void 0;
+const index_js_1 = require("./index.js");
+class DocumentThinningTransformer extends index_js_1.ArrayCollapseTransformer {
+    async sticker(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content,
+        };
+    }
+    async bubble(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content,
+        };
+    }
+    async highTechAlert(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    async columns(node) {
+        const flattened = node.columns.flat();
+        if (flattened.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(flattened);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    async quote(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    image(node) {
+        return Promise.resolve({
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline image: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        });
+    }
+    async figureImage(node) {
+        const image = {
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline image: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        };
+        if (node.content) {
+            const content = await this.chooseChildren(node.content);
+            return {
+                type: "array",
+                content: [
+                    image,
+                    ...content,
+                ],
+            };
+        }
+        else {
+            return image;
+        }
+    }
+    async video(node) {
+        const video = {
+            type: "paragraph",
+            content: [{
+                    type: "text",
+                    text: "inline video: ",
+                }, {
+                    type: "text",
+                    text: node.alt,
+                }],
+        };
+        if (node.content) {
+            const content = await this.chooseChildren(node.content);
+            return {
+                type: "array",
+                content: [
+                    video,
+                    ...content,
+                ],
+            };
+        }
+        else {
+            return video;
+        }
+    }
+    async definitionList(node) {
+        const content = [];
+        for (const d of node.content) {
+            const defContent = [];
+            const title = await this.chooseChildren(d.title);
+            if (title) {
+                for (const n of title) {
+                    defContent.push(n);
+                }
+            }
+            defContent.push({ type: "text", text: " " });
+            const abbreviation = await this.chooseChildren(d.abbreviation);
+            if (abbreviation) {
+                for (const n of abbreviation) {
+                    defContent.push(n);
+                }
+            }
+            if (d.content.length > 0 && d.content[0].type != "paragraph") {
+                defContent.push({ type: "text", text: " " });
+                const def = await this.chooseChildren(d.content);
+                if (def) {
+                    for (const n of def) {
+                        defContent.push(n);
+                    }
+                }
+            }
+            content.push({
+                type: "paragraph",
+                content: defContent,
+            });
+            if (d.content.length > 0 && d.content[0].type == "paragraph") {
+                const def = await this.chooseChildren(d.content);
+                if (def) {
+                    for (const n of def) {
+                        content.push(n);
+                    }
+                }
+            }
+        }
+        return {
+            type: "array",
+            content,
+        };
+    }
+    // deno-lint-ignore require-await
+    async redacted(_node) {
+        return null;
+    }
+    async note(node) {
+        if (node.content.length == 0) {
+            return null;
+        }
+        const content = await this.chooseChildren(node.content);
+        if (!content) {
+            return null;
+        }
+        return {
+            type: "paragraph",
+            content: [
+                { type: "text", text: "Note: " },
+                ...content,
+            ],
+        };
+    }
+    async card(node) {
+        const content = [];
+        if (node.header) {
+            const title = await this.chooseChildren(node.header.title);
+            if (title.length > 0) {
+                content.push({
+                    type: "paragraph",
+                    content: title,
+                });
+            }
+        }
+        if (node.content) {
+            const card = await this.chooseChildren(node.content.content);
+            for (const c of card) {
+                content.push(c);
+            }
+        }
+        if (node.media) {
+            for (const media of node.media.content) {
+                const m = await this.choose(media);
+                if (m) {
+                    content.push(m);
+                }
+            }
+        }
+        if (node.attribution) {
+            const attribution = [];
+            if (node.attribution.title) {
+                const title = await this.chooseChildren(node.attribution.title);
+                for (const n of title) {
+                    content.push(n);
+                }
+            }
+            if (node.attribution.date) {
+                if (content.length > 0) {
+                    content.push({ type: "text", text: " " });
+                }
+                content.push({ type: "text", text: `${node.attribution.date}` });
+            }
+            if (attribution.length > 0) {
+                content.push({
+                    type: "paragraph",
+                    content: attribution,
+                });
+            }
+        }
+        return {
+            type: "array",
+            content: content,
+        };
+    }
+}
+exports.DocumentThinningTransformer = DocumentThinningTransformer;

package/script/WordCountTransformer.d.ts

@@ -0,0 +1,6 @@
+import { IdentityTransformer } from "./index.js";
+import { DocumentNode } from "./types.js";
+export declare class WordCounterTransformer extends IdentityTransformer {
+    constructor();
+    transform(node: DocumentNode): Promise<DocumentNode>;
+}

package/script/WordCountTransformer.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordCounterTransformer = void 0;
+const DocumentThinningTransformer_js_1 = require("./DocumentThinningTransformer.js");
+const WordCounterVisitor_js_1 = require("./WordCounterVisitor.js");
+const index_js_1 = require("./index.js");
+function convertHierarchy(parent) {
+    const docHierarchy = {
+        headerText: parent.header,
+        headerId: parent.headerId,
+        words: 0,
+        totalWords: 0,
+        children: [],
+    };
+    const visitor = new WordCounterVisitor_js_1.WordCounterVisitor();
+    for (const node of parent.nodes) {
+        visitor.visit(node);
+    }
+    docHierarchy.words = visitor.getCount();
+    docHierarchy.totalWords = docHierarchy.words;
+    for (const child of parent.children) {
+        const childHierarchy = convertHierarchy(child);
+        docHierarchy.children.push(childHierarchy);
+        docHierarchy.totalWords += childHierarchy.totalWords;
+    }
+    return docHierarchy;
+}
+class WordCounterTransformer extends index_js_1.IdentityTransformer {
+    constructor() {
+        super();
+    }
+    async transform(node) {
+        // Isolate it
+        const jsonNode = JSON.parse(JSON.stringify(node));
+        const thinned = await new DocumentThinningTransformer_js_1.DocumentThinningTransformer().transform(jsonNode);
+        const stack = [];
+        const root = {
+            header: node.title,
+            headerId: "title",
+            nodes: [],
+            children: [],
+            depth: 1,
+        };
+        stack.push(root);
+        let depth = 1;
+        for (const node of thinned.content) {
+            if (node.type == "header") {
+                if (node.level == 1) {
+                    // never pop the root
+                    continue;
+                }
+                else if (node.level <= depth) {
+                    for (let i = stack.length - 1; i > 0; i--) {
+                        if (stack[i].depth >= node.level) {
+                            stack.pop();
+                        }
+                    }
+                }
+                const visitor = new index_js_1.TextVisitor();
+                visitor.visit(node);
+                const h = {
+                    header: visitor.getText(),
+                    depth: node.level,
+                    children: [],
+                    nodes: [],
+                };
+                if (node.htmlId) {
+                    h.headerId = node.htmlId;
+                }
+                stack[stack.length - 1].children.push(h);
+                stack.push(h);
+                depth = node.level;
+            }
+            else {
+                stack[stack.length - 1].nodes.push(node);
+            }
+        }
+        // The transformer does not actually walk through the document tree
+        // We just append a newly calculated hierarchy object
+        const doc = {
+            ...node,
+        };
+        doc.hierarchy = convertHierarchy(root);
+        return doc;
+    }
+}
+exports.WordCounterTransformer = WordCounterTransformer;

package/script/WordCounterVisitor.d.ts

@@ -0,0 +1,13 @@
+import { NodeVisitor } from "./index.js";
+import { DocumentNode, TextNode } from "./types.js";
+export declare class WordCounterVisitor extends NodeVisitor {
+    private count;
+    private texts;
+    constructor();
+    private countText;
+    protected beforeBlock(): void;
+    protected afterBlock(): void;
+    protected text(node: TextNode): void;
+    protected document(node: DocumentNode): void;
+    getCount(): number;
+}

package/script/WordCounterVisitor.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordCounterVisitor = void 0;
+const index_js_1 = require("./index.js");
+class WordCounterVisitor extends index_js_1.NodeVisitor {
+    constructor() {
+        super();
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "texts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.count = 0;
+        this.texts = [];
+    }
+    countText() {
+        if (this.texts.length > 0) {
+            this.count += this.texts.join("").split(" ").length;
+            this.texts = [];
+        }
+    }
+    beforeBlock() {
+        this.countText();
+    }
+    afterBlock() {
+        this.countText();
+    }
+    text(node) {
+        this.texts.push(node.text);
+    }
+    document(node) {
+        super.document(node);
+        this.countText();
+    }
+    getCount() {
+        this.countText();
+        return this.count;
+    }
+}
+exports.WordCounterVisitor = WordCounterVisitor;

package/script/index.d.ts

@@ -6,3 +6,6 @@ export { WhitespaceTransformer } from "./WhitespaceTransformer.js";
 export { WhitespaceStretchingTransformer } from "./WhitespaceStretchingTransformer.js";
 export { NodeVisitor } from "./NodeVisitor.js";
 export { TextVisitor } from "./TextVisitor.js";
+export { WordCounterTransformer } from "./WordCountTransformer.js";
+export { WordCounterVisitor } from "./WordCounterVisitor.js";
+export { DocumentThinningTransformer } from "./DocumentThinningTransformer.js";

package/script/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextVisitor = exports.NodeVisitor = exports.WhitespaceStretchingTransformer = exports.WhitespaceTransformer = exports.TextCollapseTransformer = exports.IdentityTransformer = exports.ArrayCollapseTransformer = void 0;
+exports.DocumentThinningTransformer = exports.WordCounterVisitor = exports.WordCounterTransformer = exports.TextVisitor = exports.NodeVisitor = exports.WhitespaceStretchingTransformer = exports.WhitespaceTransformer = exports.TextCollapseTransformer = exports.IdentityTransformer = exports.ArrayCollapseTransformer = void 0;
 __exportStar(require("./types.js"), exports);
 var ArrayCollapseTransformer_js_1 = require("./ArrayCollapseTransformer.js");
 Object.defineProperty(exports, "ArrayCollapseTransformer", { enumerable: true, get: function () { return ArrayCollapseTransformer_js_1.ArrayCollapseTransformer; } });
@@ -30,3 +30,9 @@ var NodeVisitor_js_1 = require("./NodeVisitor.js");
 Object.defineProperty(exports, "NodeVisitor", { enumerable: true, get: function () { return NodeVisitor_js_1.NodeVisitor; } });
 var TextVisitor_js_1 = require("./TextVisitor.js");
 Object.defineProperty(exports, "TextVisitor", { enumerable: true, get: function () { return TextVisitor_js_1.TextVisitor; } });
+var WordCountTransformer_js_1 = require("./WordCountTransformer.js");
+Object.defineProperty(exports, "WordCounterTransformer", { enumerable: true, get: function () { return WordCountTransformer_js_1.WordCounterTransformer; } });
+var WordCounterVisitor_js_1 = require("./WordCounterVisitor.js");
+Object.defineProperty(exports, "WordCounterVisitor", { enumerable: true, get: function () { return WordCounterVisitor_js_1.WordCounterVisitor; } });
+var DocumentThinningTransformer_js_1 = require("./DocumentThinningTransformer.js");
+Object.defineProperty(exports, "DocumentThinningTransformer", { enumerable: true, get: function () { return DocumentThinningTransformer_js_1.DocumentThinningTransformer; } });