document-ir 0.0.6

package/esm/NodeVisitor.d.ts

@@ -0,0 +1,53 @@
+import { ArrayNode, BlockNode, BlockQuoteNode, BoldNode, BreakNode, BubbleNode, CardNode, CenterNode, CodeNode, ColumnsNode, DefinitionListNode, DefinitionNode, DefinitionReferenceNode, DocumentNode, EmbedNode, EmojiNode, FigureCaptionNode, FigureImageNode, FigureNode, FormattedTextNode, HeaderNode, HighTechAlertNode, HorizontalRuleNode, ImageNode, ItalicNode, LinkNode, ListNode, Node, NoteNode, ParagraphNode, QuoteNode, RedactedNode, RegionNode, ScriptNode, SecretNode, SmallerNode, SocialNode, StickerNode, StrikeThroughNode, TableNode, TextNode, UnderlineNode, VideoNode, WarningNode } from "./types.js";
+export declare class NodeVisitor {
+    protected beforeBlock(): void;
+    protected afterBlock(): void;
+    protected beforeInline(): void;
+    protected afterInline(): void;
+    protected chooseChildren(nodes: Node[]): void;
+    protected block(node: BlockNode): void;
+    protected blockQuote(node: BlockQuoteNode): void;
+    protected bold(node: BoldNode): void;
+    protected break_(_node: BreakNode): void;
+    protected bubble(node: BubbleNode): void;
+    protected center(node: CenterNode): void;
+    protected code(node: CodeNode): void;
+    protected columns(node: ColumnsNode): void;
+    protected definition(node: DefinitionNode): void;
+    protected definitionList(node: DefinitionListNode): void;
+    protected definitionReference(node: DefinitionReferenceNode): void;
+    protected embed(_node: EmbedNode): void;
+    protected emoji(_node: EmojiNode): void;
+    protected figure(node: FigureNode): void;
+    protected figureCaption(node: FigureCaptionNode): void;
+    protected figureImage(node: FigureImageNode): void;
+    protected formattedText(_node: FormattedTextNode): void;
+    protected header(node: HeaderNode): void;
+    protected highTechAlert(node: HighTechAlertNode): void;
+    protected horizontalRule(_node: HorizontalRuleNode): void;
+    protected image(_node: ImageNode): void;
+    protected italic(node: ItalicNode): void;
+    protected link(node: LinkNode): void;
+    protected array(node: ArrayNode): void;
+    protected note(node: NoteNode): void;
+    protected list(node: ListNode): void;
+    protected paragraph(node: ParagraphNode): void;
+    protected quote(node: QuoteNode): void;
+    protected redacted(node: RedactedNode): void;
+    protected region(node: RegionNode): void;
+    protected script(_node: ScriptNode): void;
+    protected secret(node: SecretNode): void;
+    protected smaller(node: SmallerNode): void;
+    protected sticker(node: StickerNode): void;
+    protected strikeThrough(node: StrikeThroughNode): void;
+    protected text(_node: TextNode): void;
+    protected table(node: TableNode): void;
+    protected social(_node: SocialNode): void;
+    protected underline(node: UnderlineNode): void;
+    protected video(node: VideoNode): void;
+    protected warning(node: WarningNode): void;
+    protected card(node: CardNode): void;
+    protected choose(node: Node): void;
+    protected document(node: DocumentNode): void;
+    visit(node: DocumentNode | Node): void;
+}

package/esm/NodeVisitor.js

@@ -0,0 +1,369 @@
+export class NodeVisitor {
+    beforeBlock() {
+    }
+    afterBlock() {
+    }
+    beforeInline() {
+    }
+    afterInline() {
+    }
+    chooseChildren(nodes) {
+        for (const child of nodes) {
+            this.choose(child);
+        }
+    }
+    block(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    blockQuote(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    bold(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    break_(_node) {
+        this.beforeBlock();
+        this.afterBlock();
+    }
+    bubble(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    center(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    code(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    columns(node) {
+        for (const column of node.columns) {
+            this.beforeBlock();
+            this.chooseChildren(column);
+            this.afterBlock();
+        }
+    }
+    definition(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.abbreviation);
+        this.afterBlock();
+        this.beforeBlock();
+        this.chooseChildren(node.title);
+        this.afterBlock();
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    definitionList(node) {
+        this.beforeBlock();
+        for (const child of node.content) {
+            this.definition(child);
+        }
+        this.afterBlock();
+    }
+    definitionReference(node) {
+        this.beforeInline();
+        this.chooseChildren(node.definition.abbreviation);
+        this.afterInline();
+        this.chooseChildren(node.content);
+    }
+    embed(_node) {
+    }
+    emoji(_node) {
+    }
+    figure(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    figureCaption(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    figureImage(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    formattedText(_node) {
+    }
+    header(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    highTechAlert(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+        this.beforeBlock();
+        this.chooseChildren(node.warning);
+        this.afterBlock();
+    }
+    horizontalRule(_node) {
+    }
+    image(_node) {
+    }
+    italic(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    link(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    array(node) {
+        this.chooseChildren(node.content);
+    }
+    note(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    list(node) {
+        for (const item of node.content) {
+            this.beforeBlock();
+            this.chooseChildren(item.content);
+            this.afterBlock();
+        }
+    }
+    paragraph(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    quote(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    redacted(node) {
+        if (node.style == "block") {
+            this.beforeBlock();
+        }
+        else {
+            this.beforeInline();
+        }
+        this.chooseChildren(node.content);
+        if (node.style == "block") {
+            this.afterBlock();
+        }
+        else {
+            this.afterInline();
+        }
+    }
+    region(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    script(_node) {
+    }
+    secret(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    smaller(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    sticker(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    strikeThrough(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    text(_node) {
+    }
+    table(node) {
+        for (const row of node.content) {
+            for (const cell of row) {
+                this.beforeBlock();
+                this.chooseChildren(cell.content);
+                this.afterBlock();
+            }
+        }
+    }
+    social(_node) {
+    }
+    underline(node) {
+        this.beforeInline();
+        this.chooseChildren(node.content);
+        this.afterInline();
+    }
+    video(node) {
+        this.beforeBlock();
+        node.content && this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    warning(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+    }
+    card(node) {
+        if (node.content) {
+            this.beforeBlock();
+            this.chooseChildren(node.content.content);
+            this.afterBlock();
+        }
+        if (node.attribution) {
+            if (node.attribution.title) {
+                this.beforeBlock();
+                const _title = this.chooseChildren(node.attribution.title);
+                this.afterBlock();
+            }
+        }
+        if (node.header) {
+            this.beforeBlock();
+            this.chooseChildren(node.header.title);
+            this.afterBlock();
+        }
+        if (node.media) {
+            for (const mediaNode of node.media.content) {
+                this.beforeBlock();
+                this.choose(mediaNode);
+                this.afterBlock();
+            }
+        }
+    }
+    choose(node) {
+        if (!node || !node.type) {
+            throw new Error(`Unexpected node, no type: ${JSON.stringify(node)}`);
+        }
+        try {
+            switch (node.type) {
+                case "block":
+                    return this.block(node);
+                case "block-quote":
+                    return this.blockQuote(node);
+                case "bold":
+                    return this.bold(node);
+                case "break":
+                    return this.break_(node);
+                case "bubble":
+                    return this.bubble(node);
+                case "card":
+                    return this.card(node);
+                case "center":
+                    return this.center(node);
+                case "code":
+                    return this.code(node);
+                case "columns":
+                    return this.columns(node);
+                case "definition":
+                    return this.definition(node);
+                case "definition-list":
+                    return this.definitionList(node);
+                case "definition-reference":
+                    return this.definitionReference(node);
+                case "embed":
+                    return this.embed(node);
+                case "emoji":
+                    return this.emoji(node);
+                case "figure":
+                    return this.figure(node);
+                case "figure-caption":
+                    return this.figureCaption(node);
+                case "figure-image":
+                    return this.figureImage(node);
+                case "formatted-text":
+                    return this.formattedText(node);
+                case "header":
+                    return this.header(node);
+                case "high-tech-alert":
+                    return this.highTechAlert(node);
+                case "horizontal-rule":
+                    return this.horizontalRule(node);
+                case "image":
+                    return this.image(node);
+                case "italic":
+                    return this.italic(node);
+                case "link":
+                    return this.link(node);
+                case "array":
+                    return this.array(node);
+                case "note":
+                    return this.note(node);
+                case "list":
+                    return this.list(node);
+                case "paragraph":
+                    return this.paragraph(node);
+                case "quote":
+                    return this.quote(node);
+                case "redacted":
+                    return this.redacted(node);
+                case "region":
+                    return this.region(node);
+                case "script":
+                    return this.script(node);
+                case "secret":
+                    return this.secret(node);
+                case "smaller":
+                    return this.smaller(node);
+                case "sticker":
+                    return this.sticker(node);
+                case "strike-through":
+                    return this.strikeThrough(node);
+                case "table":
+                    return this.table(node);
+                case "text":
+                    return this.text(node);
+                case "toot":
+                case "tweet":
+                case "vimeo":
+                case "youtube":
+                    return this.social(node);
+                case "underline":
+                    return this.underline(node);
+                case "video":
+                    return this.video(node);
+                case "warning":
+                    return this.warning(node);
+            }
+        }
+        catch (e) {
+            console.log(`Got exception while processing node: ${JSON.stringify(node)}`);
+            throw e;
+        }
+        //@ts-ignore Fall through
+        console.error(`Unsupported type ${node.type}`);
+    }
+    document(node) {
+        this.beforeBlock();
+        this.chooseChildren(node.content);
+        this.afterBlock();
+        this.beforeBlock();
+        if (node.definitions) {
+            this.chooseChildren(node.definitions);
+        }
+        this.afterBlock();
+    }
+    visit(node) {
+        if (node.type == "document") {
+            this.document(node);
+        }
+        else {
+            this.choose(node);
+        }
+    }
+}

package/esm/TextCollapseTransformer.d.ts

@@ -0,0 +1,5 @@
+import { IdentityTransformer } from "./IdentityTransformer.js";
+import { Node } from "./types.js";
+export declare class TextCollapseTransformer extends IdentityTransformer {
+    protected chooseChildren(nodes: Node[]): Promise<Node[]>;
+}

package/esm/TextCollapseTransformer.js

@@ -0,0 +1,36 @@
+import { IdentityTransformer } from "./IdentityTransformer.js";
+export class TextCollapseTransformer extends IdentityTransformer {
+    async chooseChildren(nodes) {
+        const children = await super.chooseChildren(nodes);
+        const results = [];
+        let lastText = null;
+        for (const child of children) {
+            if (child.type == "text") {
+                if (lastText != null) {
+                    lastText = `${lastText}${child.text}`;
+                }
+                else {
+                    lastText = child.text;
+                }
+            }
+            else {
+                if (lastText != null) {
+                    results.push({
+                        type: "text",
+                        text: lastText,
+                    });
+                    lastText = null;
+                }
+                results.push(child);
+            }
+        }
+        if (lastText != null) {
+            results.push({
+                type: "text",
+                text: lastText,
+            });
+            lastText = null;
+        }
+        return results;
+    }
+}

package/esm/TextCollapseTransformer_test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/TextVisitor.d.ts

@@ -0,0 +1,12 @@
+import { EmojiNode, FigureImageNode, ImageNode, TextNode, VideoNode } from "./types.js";
+import { NodeVisitor } from "./NodeVisitor.js";
+export declare class TextVisitor extends NodeVisitor {
+    private textList;
+    constructor();
+    protected text(node: TextNode): void;
+    protected video(node: VideoNode): void;
+    protected image(node: ImageNode): void;
+    protected emoji(node: EmojiNode): void;
+    protected figureImage(node: FigureImageNode): void;
+    getText(): string;
+}

package/esm/TextVisitor.js

@@ -0,0 +1,36 @@
+import { NodeVisitor } from "./NodeVisitor.js";
+export class TextVisitor extends NodeVisitor {
+    constructor() {
+        super();
+        Object.defineProperty(this, "textList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.textList = [];
+    }
+    text(node) {
+        this.textList.push(node.text);
+        super.text(node);
+    }
+    video(node) {
+        this.textList.push(node.alt);
+        super.video(node);
+    }
+    image(node) {
+        this.textList.push(node.alt);
+        super.image(node);
+    }
+    emoji(node) {
+        this.textList.push(node.alt);
+        super.emoji(node);
+    }
+    figureImage(node) {
+        this.textList.push(node.alt);
+        super.figureImage(node);
+    }
+    getText() {
+        return this.textList.join("");
+    }
+}

package/esm/TextVisitor_test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/WhitespaceStretchingTransformer.d.ts

@@ -0,0 +1,26 @@
+import { IdentityTransformer } from "./IdentityTransformer.js";
+import { DocumentNode, Node, TextNode } from "./types.js";
+interface BlockInfo {
+    type: '_block';
+    content: WhiteSpaceContainer[];
+    parent: BlockInfo | InlineInfo | null;
+}
+interface InlineInfo {
+    type: '_inline';
+    content: WhiteSpaceContainer[];
+    parent: BlockInfo | InlineInfo | null;
+}
+type WhiteSpaceContainer = BlockInfo | InlineInfo | TextNode;
+export declare class WhitespaceStretchingTransformer extends IdentityTransformer {
+    private root;
+    private cursor;
+    constructor();
+    protected beforeBlock(): Promise<void>;
+    protected afterBlock(): Promise<void>;
+    protected beforeInline(): Promise<void>;
+    protected afterInline(): Promise<void>;
+    protected reviewBlock(block: BlockInfo): void;
+    protected text(node: TextNode): Promise<Node | null>;
+    transform(node: DocumentNode): Promise<DocumentNode>;
+}
+export {};

package/esm/WhitespaceStretchingTransformer.js

@@ -0,0 +1,119 @@
+import { IdentityTransformer } from "./IdentityTransformer.js";
+export class WhitespaceStretchingTransformer extends IdentityTransformer {
+    constructor() {
+        super();
+        Object.defineProperty(this, "root", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cursor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.root = {
+            type: '_block',
+            content: [],
+            parent: null
+        };
+        this.cursor = this.root;
+    }
+    // deno-lint-ignore require-await
+    async beforeBlock() {
+        const parent = this.cursor;
+        const block = {
+            type: '_block',
+            content: [],
+            parent
+        };
+        parent.content.push(block);
+        this.cursor = block;
+    }
+    // deno-lint-ignore require-await
+    async afterBlock() {
+        if (this.cursor.parent) {
+            this.cursor = this.cursor.parent;
+        }
+    }
+    // deno-lint-ignore require-await
+    async beforeInline() {
+        const parent = this.cursor;
+        const inline = {
+            type: '_inline',
+            content: [],
+            parent
+        };
+        parent.content.push(inline);
+        this.cursor = inline;
+    }
+    // deno-lint-ignore require-await
+    async afterInline() {
+        if (this.cursor.parent) {
+            this.cursor = this.cursor.parent;
+        }
+    }
+    reviewBlock(block) {
+        const nodes = [];
+        const visit = (r, level) => {
+            if (r.type == 'text') {
+                nodes.push({
+                    node: r,
+                    level
+                });
+            }
+            else if (r.type == '_block') {
+                this.reviewBlock(r);
+                nodes.push({ node: null, level });
+            }
+            else {
+                for (const node of r.content) {
+                    visit(node, level + 1);
+                }
+            }
+        };
+        for (const node of block.content) {
+            visit(node, 0);
+        }
+        for (let i = 0; i < nodes.length; i++) {
+            const first = nodes[i];
+            const second = i + 1 < nodes.length ? nodes[i + 1] : { node: null, level: 0 };
+            // No use acting on a dead node
+            if (!first.node || !second.node) {
+                continue;
+            }
+            // Interesting things only happen on differing levels
+            if (first.level == second.level) {
+                continue;
+            }
+            if (first.level < second.level) {
+                if (second.node.text.startsWith(' ')) {
+                    second.node.text = second.node.text.slice(1);
+                    first.node.text += ' ';
+                }
+            }
+            else if (first.level > second.level) {
+                if (first.node.text.endsWith(' ')) {
+                    first.node.text = first.node.text.slice(0, -1);
+                    second.node.text = ` ${second.node.text}`;
+                }
+            }
+        }
+    }
+    // deno-lint-ignore require-await
+    async text(node) {
+        const replacement = {
+            type: 'text',
+            text: `${node.text}`
+        };
+        this.cursor.content.push(replacement);
+        return replacement;
+    }
+    async transform(node) {
+        const result = await super.transform(node);
+        this.reviewBlock(this.root);
+        return result;
+    }
+}

package/esm/WhitespaceStretchingTransformer_test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/WhitespaceTransformer.d.ts

@@ -0,0 +1,12 @@
+import { IdentityTransformer } from "./IdentityTransformer.js";
+import { DocumentNode, Node, TextNode } from "./types.js";
+export declare class WhitespaceTransformer extends IdentityTransformer {
+    private stripWhitespace;
+    private lastText;
+    constructor();
+    protected text(node: TextNode): Promise<Node | null>;
+    private stripLastText;
+    protected beforeBlock(): Promise<void>;
+    protected afterBlock(): Promise<void>;
+    transform(node: DocumentNode): Promise<DocumentNode>;
+}