@helloao/tools 0.0.18 → 0.0.19

package/dist/types/parser/codex-parser.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { ParseTree } from './types.js';
+export declare const chapterHeadingSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chapter-heading">;
+    data: z.ZodObject<{
+        chapter: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        chapter: number;
+    }, {
+        chapter: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "chapter-heading";
+    data: {
+        chapter: number;
+    };
+}, {
+    type: "chapter-heading";
+    data: {
+        chapter: number;
+    };
+}>;
+export declare const verseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    bookCode: z.ZodOptional<z.ZodString>;
+    chapter: z.ZodOptional<z.ZodNumber>;
+    verse: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "text";
+    chapter?: number | undefined;
+    verse?: number | undefined;
+    bookCode?: string | undefined;
+}, {
+    id: string;
+    type: "text";
+    chapter?: number | undefined;
+    verse?: number | undefined;
+    bookCode?: string | undefined;
+}>;
+export declare const paratextSchema: z.ZodObject<{
+    type: z.ZodLiteral<"paratext">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "paratext";
+}, {
+    id: string;
+    type: "paratext";
+}>;
+export declare const metadataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"chapter-heading">;
+    data: z.ZodObject<{
+        chapter: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        chapter: number;
+    }, {
+        chapter: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "chapter-heading";
+    data: {
+        chapter: number;
+    };
+}, {
+    type: "chapter-heading";
+    data: {
+        chapter: number;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    bookCode: z.ZodOptional<z.ZodString>;
+    chapter: z.ZodOptional<z.ZodNumber>;
+    verse: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "text";
+    chapter?: number | undefined;
+    verse?: number | undefined;
+    bookCode?: string | undefined;
+}, {
+    id: string;
+    type: "text";
+    chapter?: number | undefined;
+    verse?: number | undefined;
+    bookCode?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"paratext">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "paratext";
+}, {
+    id: string;
+    type: "paratext";
+}>]>;
+export declare const codexSchema: z.ZodObject<{
+    cells: z.ZodArray<z.ZodObject<{
+        kind: z.ZodNumber;
+        languageId: z.ZodString;
+        value: z.ZodString;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: number;
+        value: string;
+        languageId: string;
+        metadata?: z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough"> | null | undefined;
+    }, {
+        kind: number;
+        value: string;
+        languageId: string;
+        metadata?: z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough"> | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    cells: {
+        kind: number;
+        value: string;
+        languageId: string;
+        metadata?: z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough"> | null | undefined;
+    }[];
+}, {
+    cells: {
+        kind: number;
+        value: string;
+        languageId: string;
+        metadata?: z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough"> | null | undefined;
+    }[];
+}>;
+/**
+ * Defines a parser for codex files.
+ */
+export declare class CodexParser {
+    private _noteCounter;
+    /**
+     * Parses the specified codex content.
+     *
+     * @param codex The codex content to parse.
+     * @returns The parse tree that was generated.
+     */
+    parse(codex: string): ParseTree;
+}
+//# sourceMappingURL=codex-parser.d.ts.map

package/dist/types/parser/commentary-csv-parser.d.ts

@@ -0,0 +1,12 @@
+import { CommentaryParseTree } from './types';
+export interface CsvLine {
+    book: string;
+    chapter: string;
+    verse: string;
+    commentaries: string;
+}
+export declare class CommentaryCsvParser {
+    parse(data: string): CommentaryParseTree;
+    parseLines(data: CsvLine[]): CommentaryParseTree;
+}
+//# sourceMappingURL=commentary-csv-parser.d.ts.map

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

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './usfm-parser.js';
+export * from './usx-parser.js';
+export * from './codex-parser.js';
+export * from './commentary-csv-parser.js';
+import * as iterators from './iterators.js';
+export { iterators };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/parser/iterators.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Defines an interface that represents an iterator that can be rewound.
+ */
+export interface RewindableIterator<T> extends IterableIterator<T> {
+    /**
+     * Rewinds the iterator by the specified number of elements.
+     * @param number The number of elements to rewind.
+     */
+    rewind(number: number): void;
+}
+/**
+ * Defines a class that implements an iterator that can be rewound.
+ */
+export declare class Rewindable<T> implements RewindableIterator<T> {
+    buffer: T[];
+    private _bufferSize;
+    private _position;
+    private _iterator;
+    constructor(iterator: IterableIterator<T>, bufferSize?: number);
+    rewind(number: number): void;
+    [Symbol.iterator](): IterableIterator<T>;
+    next(...args: [] | [undefined]): IteratorResult<T, any>;
+    return?(value?: any): IteratorResult<T, any>;
+    throw?(e?: any): IteratorResult<T, any>;
+}
+export declare function debug(label: string, iterator: IterableIterator<any>): Generator<any, void, unknown>;
+/**
+ * Creates a new rewindable iterator from the given iterator.
+ * @param iterator The iterator.
+ * @param bufferSize The size of the buffer.
+ */
+export declare function rewindable<T>(iterator: IterableIterator<T>, bufferSize?: number): Rewindable<T>;
+/**
+ * Gets the char element that is the parent of the given node.
+ * @param node The node.
+ */
+export declare function parentChar(node: Node): Element | null;
+/**
+ * Gets the note element that is the parent of the given node.
+ * @param node The node.
+ */
+export declare function parentNote(node: Node): Element | null;
+/**
+ * Gets the parent node that matches the given filter.
+ * @param node The node to start the search from.
+ * @param filter The filter that should be used.
+ */
+export declare function matchingParent(node: Node, filter: (node: Node) => boolean): Node | null;
+/**
+ * Determines if the given node is a child of the parent node.
+ * @param node The node to test.
+ * @param parent The parent.
+ * @returns
+ */
+export declare function isParent(node: Node, parent: Node): boolean;
+/**
+ * Iterates through all of the nodes in the tree in a depth-first traversal.
+ * @param node The node to start the traversal from.
+ */
+export declare function iterateAll(node: Node): RewindableIterator<Node>;
+export declare function iterateUntil<T>(iterator: IterableIterator<T>, predicate: (value: T) => boolean): IterableIterator<T>;
+/**
+ * Iterates only the elements in the iterator.
+ * @param iterator The iterator that should be used.
+ */
+export declare function elements(iterator: IterableIterator<Node>): IterableIterator<Element>;
+/**
+ * Iterates only the children of the given node in the iterator.
+ * @param iterator The iterator that should be used.
+ * @param parent The parent node.
+ */
+export declare function children(iterator: RewindableIterator<Node>, parent: Node): IterableIterator<Node>;
+/**
+ * Wraps the given iterable in a generator that will prevent consumers from calling return() on the iterator.
+ * @param iterable The iterable.
+ */
+export declare function uncompletable<T>(iterable: IterableIterator<T>): IterableIterator<T>;
+/**
+ * Converts the given iterable into an async iterable.
+ * @param input The input iterable.
+ */
+export declare function toAsyncIterable<T>(input: Iterable<T>): AsyncIterable<T>;
+/**
+ * Batches items from the given iterator.
+ * @param input The input iterator.
+ * @param batchSize The size of each batch.
+ */
+export declare function batch<T>(input: Iterable<T>, batchSize: number): Iterable<T[]>;
+//# sourceMappingURL=iterators.d.ts.map

package/dist/types/parser/tyndale-xml-parser.d.ts

@@ -0,0 +1,8 @@
+import { CommentaryParseTree } from './types';
+export declare class TyndaleXmlParser {
+    private _domParser;
+    constructor(domParser: DOMParser);
+    parse(xml: string): CommentaryParseTree;
+}
+export declare function toKebabCase(camelCase: string): string;
+//# sourceMappingURL=tyndale-xml-parser.d.ts.map

package/dist/types/parser/types.d.ts

@@ -0,0 +1,204 @@
+import { VerseRef } from '../utils.js';
+/**
+ * The parse tree that is gathered.
+ */
+export interface ParseTree {
+    type: 'root';
+    /**
+     * The ID of the parse tree.
+     */
+    id?: string;
+    /**
+     * The header that was associated with the tree.
+     */
+    header?: string;
+    /**
+     * The major title that was associated with the tree.
+     */
+    title?: string;
+    /**
+     * The list of chapters for the tree.
+     */
+    content: (Heading | Chapter)[];
+    /**
+     * The list of messages that were generated during parsing.
+     */
+    parseMessages?: ParseMessage[];
+}
+export interface ParseMessage {
+    type: 'warning' | 'error';
+    message: string;
+}
+export interface Heading {
+    type: 'heading';
+    content: string[];
+}
+export type ChapterContent = Heading | Verse | HebrewSubtitle | LineBreak;
+export type VerseContent = string | FootnoteReference | Text;
+/**
+ * Defines an interface that represents a chapter.
+ */
+export interface Chapter {
+    type: 'chapter';
+    number: number;
+    /**
+     * The contents of the chapter.
+     */
+    content: ChapterContent[];
+    /**
+     * The list of footnotes for the chapter.
+     */
+    footnotes: Footnote[];
+}
+/**
+ * Defines an interface that represents a hebrew subtitle.
+ */
+export interface HebrewSubtitle {
+    type: 'hebrew_subtitle';
+    /**
+     * The contents of the subtitle.
+     */
+    content: (string | Text | FootnoteReference)[];
+}
+/**
+ * Defines an interface that represents a verse.
+ */
+export interface Verse {
+    type: 'verse';
+    number: number;
+    /**
+     * The contents of the verse.
+     */
+    content: (string | Text | InlineHeading | InlineLineBreak | FootnoteReference)[];
+}
+/**
+ * Defines an interface that represents text that has some markup attributes applied to it.
+ */
+export interface Text {
+    /**
+     * The text that is contained.
+     */
+    text: string;
+    /**
+     * Whether the text represents a poem.
+     * The number indicates the level of indent.
+     */
+    poem?: number;
+    /**
+     * Whether the text contains the words of Jesus.
+     */
+    wordsOfJesus?: boolean;
+    /**
+     * Whether the text is descriptive.
+     *
+     * This is only used for "hebrew subtitles" that are included inside the verse markers.
+     */
+    descriptive?: boolean;
+}
+/**
+ * Defines an interface that represents a heading that is embedded in a verse.
+ */
+export interface InlineHeading {
+    /**
+     * The text of the heading.
+     */
+    heading: string;
+}
+/**
+ * Defines an interface that represents a line break that is embedded in a verse.
+ */
+export interface InlineLineBreak {
+    lineBreak: true;
+}
+export interface FootnoteReference {
+    /**
+     * The ID of the note that is referenced.
+     */
+    noteId: number;
+}
+export interface Footnote {
+    noteId: number;
+    /**
+     * The text of the footnote.
+     */
+    text: string;
+    /**
+     * The caller that should be used for the footnote.
+     * For footnotes, a "caller" is the character that is used in the text to reference to footnote.
+     *
+     * For example, in the text:
+     * Hello (a) World
+     *
+     * ----
+     * (a) This is a footnote.
+     *
+     * The "(a)" is the caller.
+     *
+     * If "+", then the caller should be autogenerated.
+     * If null, then the caller should be empty.
+     * If a string, then the caller should be that string.
+     */
+    caller: '+' | string | null;
+    /**
+     * The verse reference for the footnote.
+     */
+    reference?: {
+        chapter: number;
+        verse: number;
+    };
+}
+export interface LineBreak {
+    type: 'line_break';
+}
+/**
+ * The parse tree that is gathered.
+ */
+export interface CommentaryParseTree {
+    type: 'commentary/root';
+    /**
+     * The books that are contained in the commentary.
+     */
+    books: CommentaryBookNode[];
+    /**
+     * The profiles that are contained in the commentary.
+     */
+    profiles?: CommentaryProfileNode[];
+}
+export interface CommentaryBookNode {
+    type: 'book';
+    book: string;
+    introduction: string | null;
+    introductionSummary?: string | null;
+    chapters: CommentaryChapterNode[];
+}
+export interface CommentaryProfileNode {
+    /**
+     * The ID of the profile.
+     * Used to identify the profile within a commentary.
+     */
+    id: string;
+    /**
+     * The subject(s) of the profile.
+     */
+    subject: string;
+    /**
+     * The Bible reference that the profile is associated with.
+     */
+    reference: VerseRef | null;
+    /**
+     * The content of the profile.
+     */
+    content: string[];
+}
+export interface CommentaryChapterNode {
+    type: 'chapter';
+    number: number;
+    introduction: string | null;
+    verses: CommentaryVerseNode[];
+}
+export interface CommentaryVerseNode {
+    type: 'verse';
+    number: number;
+    content: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/parser/usfm-parser.d.ts

@@ -0,0 +1,135 @@
+import { ParseTree } from './types.js';
+/**
+ * Defines a class that can tokenize a stream of characters into tokens.
+ */
+export declare class UsfmTokenizer {
+    private _input;
+    private _index;
+    private _start;
+    private get _tokenLength();
+    /**
+     * Converts the given input into a list of tokens.
+     * @param input The input that should be tokenized.
+     */
+    tokenize(input: string): SimpleToken[];
+    private _parseTokens;
+    private _parseToken;
+}
+export interface UsfmParseOptions {
+    paragraphs: Set<string>;
+}
+/**
+ * Defines a USFM Parser.
+ */
+export declare class UsfmParser {
+    private _poem;
+    private _wordsOfJesus;
+    tokenize(input: string): Token[];
+    parse(input: string): ParseTree;
+    renderMarkdown(tree: ParseTree): string;
+    private _hasAttribute;
+    private _text;
+    private _throwError;
+}
+/**
+ * Determines if the given character is a digit.
+ * @param char The character.
+ */
+export declare function isDigit(char: string): boolean;
+/**
+ * Determines if the given character is considered whitespace.
+ * @param char The character.
+ */
+export declare function isWhitespace(char: string): boolean;
+export declare function t(loc: SourceLocation, kind: T): SimpleToken;
+/**
+ * Creates a new source location.
+ * @param start The start of the location.
+ * @param end The end of the location.
+ */
+export declare function loc(start: number, end: number): SourceLocation;
+/**
+ * Creates a new marker token.
+ * @param loc The location for the token.
+ * @param command The command that the token contains.
+ * @param number The number that the marker contains.
+ * @param type The type of the marker.
+ */
+export declare function marker(loc: SourceLocation, command: string, number?: number | null, type?: MarkerToken['type']): MarkerToken;
+/**
+ * Creates a new word token.
+ * @param loc The location for the token.
+ * @param word The word contained by the token.
+ */
+export declare function word(loc: SourceLocation, word: string): WordToken;
+export declare function whitespace(loc: SourceLocation, whitespace: string): WhitespaceToken;
+export type T = Token['kind'];
+/**
+ * Defines a simple token.
+ */
+export interface SimpleToken {
+    kind: T;
+    loc: SourceLocation;
+}
+export type Token = MarkerToken | WordToken | WhitespaceToken;
+/**
+ * Defines an interface for a USFM marker node.
+ * That is, the syntax for a marker.
+ */
+export interface MarkerToken {
+    kind: 'marker';
+    /**
+     * The command that the marker represents.
+     * This is generally the name of the marker (like "p" or "v" for paragraph and verse markers)
+     */
+    command: string;
+    /**
+     * The number that the marker contains.
+     * Null if no number was specified.
+     */
+    number: number | null;
+    /**
+     * Whether the marker represents a start or an end.
+     */
+    type: 'start' | 'end';
+    /**
+     * The location of the node.
+     */
+    loc: SourceLocation;
+}
+/**
+ * Defines an interface for a Whitespace node.
+ */
+export interface WhitespaceToken {
+    kind: 'whitespace';
+    /**
+     * The whitespace contained by the node.
+     */
+    whitespace: string;
+    /**
+     * The location of the node.
+     */
+    loc: SourceLocation;
+}
+/**
+ * Defines an interface for a word token.
+ */
+export interface WordToken {
+    kind: 'word';
+    /**
+     * The word contained by the token.
+     */
+    word: string;
+    /**
+     * The location of the word.
+     */
+    loc: SourceLocation;
+}
+/**
+ * The source location of the node.
+ */
+export interface SourceLocation {
+    start: number;
+    end: number;
+}
+//# sourceMappingURL=usfm-parser.d.ts.map

package/dist/types/parser/usx-parser.d.ts

@@ -0,0 +1,37 @@
+import { Chapter, ChapterContent, FootnoteReference, ParseTree, Verse, Text, HebrewSubtitle, InlineLineBreak } from './types.js';
+import { RewindableIterator } from './iterators.js';
+/**
+ * The version of the parser.
+ * Used to determine whether input files need to be re-parsed.
+ */
+export declare const PARSER_VERSION = "2";
+/**
+ * Defines a class that is able to parse USX content.
+ */
+export declare class USXParser {
+    private _domParser;
+    private _noteCounter;
+    private _messages;
+    private _lastVerse;
+    private _currentChapter;
+    private _bookId;
+    constructor(domParser: DOMParser);
+    /**
+     * Parses the specified USX content.
+     *
+     * @param usx The USX content to parse.
+     * @returns The parse tree that was generated.
+     */
+    parse(usx: string): ParseTree;
+    iterateRootContent(usxElement: Element): Generator<ParseTree['content'][0]>;
+    iterateChapterContent(chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<ChapterContent>;
+    iterateVerseContent(chapter: Chapter, verse: Verse, nodes: RewindableIterator<Node>): IterableIterator<string | FootnoteReference | Text | InlineLineBreak>;
+    parseVerse(element: Element, chapter: Chapter, nodes: RewindableIterator<Node>): Verse;
+    parseHebrewSubtitle(para: Element, chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<HebrewSubtitle | Verse>;
+    iterateHebrewSubtitleContent(element: Element, chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<Verse | string | Text | FootnoteReference | InlineLineBreak>;
+    iterateNodeTextContent(nodes: RewindableIterator<Node>, node: Node, chapter: Chapter, verse?: Verse): IterableIterator<string | Text | FootnoteReference | InlineLineBreak>;
+    iterateCharContent(char: Element): IterableIterator<string | Text>;
+    iterateNote(nodes: RewindableIterator<Node>, node: Element, chapter: Chapter, verse?: Verse): IterableIterator<FootnoteReference>;
+    iterateChar(nodes: RewindableIterator<Node>, node: Element): IterableIterator<string | Text>;
+}
+//# sourceMappingURL=usx-parser.d.ts.map

package/dist/types/utils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Normalizes the given language code into a ISO 639 code.
+ * @param language The language code to normalize.
+ */
+export declare function normalizeLanguage(language: string): string;
+/**
+ * Gets the ID of the translation.
+ * @param translation The translation to get the ID for.
+ */
+export declare function getTranslationId(translationId: string): string;
+export declare function isEmptyOrWhitespace(str: string | null | undefined): boolean;
+export declare function getFirstNonEmpty<T extends string>(...values: T[]): T;
+export interface VerseRef {
+    book: string;
+    chapter: number;
+    verse: number;
+    /**
+     * The rest of the content of the verse.
+     */
+    content?: string;
+    /**
+     * The chapter that the verse reference ends at.
+     */
+    endChapter?: number;
+    /**
+     * The verse that the verse reference ends at.
+     */
+    endVerse?: number;
+}
+/**
+ * Parses the given verse reference.
+ * Formatted like "GEN 1:1".
+ *
+ * @param text The reference to parse.
+ */
+export declare function parseVerseReference(text: string): VerseRef | null;
+/**
+ * Gets the ID of the given book.
+ * Returns null if the ID could not be found.
+ * @param book The name/ID of the book.
+ */
+export declare function getBookId(book: string): string | null;
+/**
+ * A brief list of verses which may appear in some older translations
+ * but are not present in more modern translations.
+ */
+export declare const KNOWN_SKIPPED_VERSES: Set<string>;
+//# sourceMappingURL=utils.d.ts.map