conlangers-suite-test 1.0.6

package/dist/escape_mapper.d.ts

@@ -0,0 +1,11 @@
+declare class Escape_Mapper {
+    private map;
+    counter: number;
+    constructor();
+    escape_backslash_pairs(input: string): string;
+    escape_special_chars(input: string): string;
+    escape_named_escape(input: string): string;
+    restore_escaped_chars(input: string): string;
+    restore_preserve_escaped_chars(input: string): string;
+}
+export default Escape_Mapper;

package/dist/generata/supra_builder.d.ts

@@ -0,0 +1,14 @@
+import Logger from "../logger";
+export declare class Supra_Builder {
+    private logger;
+    private weights;
+    private letters;
+    id_counter: number;
+    constructor(logger: Logger);
+    process_string(input: string, wordshape_line_num: number): string;
+    extract_letters_and_weights(input: string): [string[], (number | "s")[]];
+    replace_letter_and_clean(input: string, target_ID: number): string;
+    get_weights(): Record<number, number | "s">;
+    get_letters(): Record<number, string>;
+}
+export default Supra_Builder;

package/dist/generata/word_builder.d.ts

@@ -0,0 +1,23 @@
+import Word from "../word";
+import Escape_Mapper from "../escape_mapper";
+import Supra_Builder from "./supra_builder";
+import type { Output_Mode } from "../utils/types";
+declare class Word_Builder {
+    private escape_mapper;
+    private supra_builder;
+    private categories;
+    private wordshapes;
+    private category_distribution;
+    private optionals_weight;
+    constructor(escape_mapper: Escape_Mapper, supra_builder: Supra_Builder, categories: Map<string, {
+        graphemes: string[];
+        weights: number[];
+    }>, wordshapes: {
+        items: string[];
+        weights: number[];
+    }, category_distribution: string, optionals_weight: number, output_mode: Output_Mode);
+    make_word(): Word;
+    resolve_wordshape_sets(input_list: string, distribution: string, optionals_weight: number): string;
+    extract_value_and_weight(input_list: string[], default_distribution: string): [string[], number[]];
+}
+export default Word_Builder;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { vocabug, nesca } from "./main";
+declare const the_conlangers_suite: {
+    vocabug: typeof vocabug;
+    nesca: typeof nesca;
+};
+export default the_conlangers_suite;

package/dist/logger.d.ts

@@ -0,0 +1,45 @@
+declare class Logger {
+    errors: string[];
+    warnings: string[];
+    infos: string[];
+    diagnostics: string[];
+    payload: string;
+    constructor();
+    Uncaught_Error: {
+        new (original: Error): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    uncaught_error(original: Error): void;
+    private extract_location;
+    Validation_Error: {
+        new (message: string): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    validation_error(message: string, line_num?: number | null): never;
+    warn(warn: string, line_num?: number | null): void;
+    info(info: string): void;
+    diagnostic(diagnostic: string): void;
+    set_payload(payload: string): void;
+    create_log(): {
+        payload: string;
+        errors: string[];
+        warnings: string[];
+        infos: string[];
+        diagnostics: string[];
+    };
+}
+export default Logger;

package/dist/main.d.ts

@@ -0,0 +1,22 @@
+import type { Output_Mode } from "./utils/types";
+import type { Log } from "./utils/types";
+type Vocabug_Options = {
+    file: string;
+    num_of_words?: number | string;
+    output_mode?: Output_Mode;
+    remove_duplicates?: boolean;
+    force_word_limit?: boolean;
+    sort_words?: boolean;
+    output_divider?: string;
+};
+type Nesca_Options = {
+    file: string;
+    input_words: string;
+    output_mode?: Output_Mode;
+    sort_words?: boolean;
+    input_divider?: string;
+    output_divider?: string;
+};
+export declare function vocabug({ file, num_of_words, output_mode, remove_duplicates, force_word_limit, sort_words, output_divider, }: Vocabug_Options): Log;
+export declare function nesca({ file, input_words, output_mode, input_divider, output_divider, sort_words, }: Nesca_Options): Log;
+export {};

package/dist/parser.d.ts

@@ -0,0 +1,79 @@
+import type Escape_Mapper from "./escape_mapper";
+import type lettercase_mapper from "./transforma/lettercase_mapper";
+import Logger from "./logger";
+import type { App, Schema } from "./utils/types";
+import { Output_Mode, Distribution, Directive, Transform_Pending } from "./utils/types";
+import type Chance_Mapper from "./transforma/chance_mapper";
+declare class Parser {
+    private logger;
+    private escape_mapper;
+    lettercase_mapper: lettercase_mapper;
+    chance_mapper: Chance_Mapper;
+    num_of_words: number;
+    output_mode: Output_Mode;
+    remove_duplicates: boolean;
+    force_word_limit: boolean;
+    sort_words: boolean;
+    input_divider: string;
+    output_divider: string;
+    directive: Directive;
+    disable_directive: "p" | boolean;
+    directive_name: string;
+    category_distribution: Distribution;
+    category_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>;
+    units: Map<string, {
+        content: string;
+        line_num: number;
+    }>;
+    optionals_weight: number;
+    wordshape_distribution: Distribution;
+    wordshape_pending: {
+        content: string;
+        line_num: number;
+    };
+    feature_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>;
+    schema_input: Schema;
+    schema_output: Schema;
+    stages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[];
+    substages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[];
+    graphemes: string[];
+    syllable_boundaries: string[];
+    graphemes_pending: string;
+    alphabet: string[];
+    invisible: string[];
+    private file_line_num;
+    private app;
+    private current_stage_name;
+    constructor(logger: Logger, app: App, escape_mapper: Escape_Mapper, lettercase_mapper: lettercase_mapper, chance_mapper: Chance_Mapper, num_of_words_string: number | string, output_mode: Output_Mode, sort_words: boolean, remove_duplicates: boolean, force_word_limit: boolean, input_divider: string, output_divider: string);
+    private get_line;
+    parse_file(file: string): void;
+    push_transform_to_stage(transform: Transform_Pending): void;
+    get_cat_seg_fea(input: string, mode: "category" | "unit" | "feature"): [string, string, boolean];
+    private parse_distribution;
+    private validate_unit;
+    private parse_decorator;
+    private parse_directive;
+    private valid_words_brackets;
+    private parse_clusterfield;
+    private parse_routine;
+    private get_transform;
+    private get_schema;
+    private get_environment;
+    private validate_environment;
+    private parse_featurefield;
+    private parse_lettercasefield;
+    private valid_transform_brackets;
+}
+export default Parser;

package/dist/resolvers/canon_graphemes_resolver.d.ts

@@ -0,0 +1,14 @@
+import type Escape_Mapper from "../escape_mapper";
+import Logger from "../logger";
+import type { Associateme_Mapper } from "../utils/types";
+declare class Canon_Graphemes_Resolver {
+    private logger;
+    private escape_mapper;
+    private graphemes_pending;
+    graphemes: string[];
+    associateme_mapper: Associateme_Mapper;
+    constructor(logger: Logger, escape_mapper: Escape_Mapper, graphemes_pending: string);
+    resolve_canon_graphemes(): void;
+    resolve_associatemes(): void;
+}
+export default Canon_Graphemes_Resolver;

package/dist/resolvers/category_resolver.d.ts

@@ -0,0 +1,26 @@
+import type Escape_Mapper from "../escape_mapper";
+import Logger from "../logger";
+import type { Output_Mode } from "../utils/types";
+declare class Category_Resolver {
+    private logger;
+    private escape_mapper;
+    private output_mode;
+    category_distribution: string;
+    private category_pending;
+    categories: Map<string, {
+        graphemes: string[];
+        weights: number[];
+    }>;
+    trans_categories: Map<string, string[]>;
+    constructor(logger: Logger, output_mode: Output_Mode, escape_mapper: Escape_Mapper, category_distribution: string, category_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>);
+    private get_trans_categories;
+    resolve_categories(): void;
+    private valid_category_brackets;
+    private valid_category_weights;
+    private resolve_nested_categories;
+    show_debug(): void;
+}
+export default Category_Resolver;

package/dist/resolvers/feature_resolver.d.ts

@@ -0,0 +1,23 @@
+import type Escape_Mapper from "../escape_mapper";
+import Logger from "../logger";
+import type { Output_Mode } from "../utils/types";
+declare class Feature_Resolver {
+    private logger;
+    private escape_mapper;
+    private output_mode;
+    feature_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>;
+    features: Map<string, {
+        graphemes: string[];
+    }>;
+    graphemes: string[];
+    constructor(logger: Logger, output_mode: Output_Mode, escape_mapper: Escape_Mapper, feature_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>, graphemes: string[]);
+    resolve_features(): void;
+    show_debug(): void;
+}
+export default Feature_Resolver;

package/dist/resolvers/generation_resolver.d.ts

@@ -0,0 +1,34 @@
+import Logger from "../logger";
+import Supra_Builder from "../generata/supra_builder";
+import type { Distribution, Output_Mode } from "../utils/types";
+declare class Generation_Resolver {
+    private logger;
+    supra_builder: Supra_Builder;
+    private output_mode;
+    optionals_weight: number;
+    units: Map<string, {
+        content: string;
+        line_num: number;
+    }>;
+    wordshape_distribution: string;
+    private wordshape_pending;
+    wordshapes: {
+        items: string[];
+        weights: number[];
+    };
+    constructor(logger: Logger, output_mode: Output_Mode, supra_builder: Supra_Builder, wordshape_distribution: Distribution, units: Map<string, {
+        content: string;
+        line_num: number;
+    }>, wordshape_pending: {
+        content: string;
+        line_num: number;
+    }, optionals_weight: number);
+    private set_wordshapes;
+    private valid_words_brackets;
+    private extract_wordshape_value_and_weight;
+    private valid_words_weights;
+    private expand_wordshape_units;
+    private expand_units;
+    show_debug(): void;
+}
+export default Generation_Resolver;

package/dist/resolvers/nesca_grammar_stream.d.ts

@@ -0,0 +1,15 @@
+import Logger from "../logger.js";
+import Escape_Mapper from "../escape_mapper.js";
+import type { Token } from "../utils/types.js";
+import type { Token_Stream_Mode, Associateme_Mapper } from "../utils/types.js";
+declare class Nesca_Grammar_Stream {
+    logger: Logger;
+    graphemes: string[];
+    associateme_mapper: Associateme_Mapper;
+    private escape_mapper;
+    constructor(logger: Logger, graphemes: string[], associateme_mapper: Associateme_Mapper, escape_mapper: Escape_Mapper);
+    main_parser(stream: string, mode: Token_Stream_Mode, line_num: number): Token[];
+    cluster_parser(stream: string, mode: Token_Stream_Mode, line_num: number): Token[];
+    find_base_location(mapper: Associateme_Mapper, grapheme: string): [number, number] | null;
+}
+export default Nesca_Grammar_Stream;

package/dist/resolvers/trans_category_resolver.d.ts

@@ -0,0 +1,15 @@
+import Logger from "../logger";
+import type { Output_Mode } from "../utils/types";
+declare class Category_Resolver {
+    private logger;
+    private output_mode;
+    private category_pending;
+    trans_categories: Map<string, string[]>;
+    constructor(logger: Logger, output_mode: Output_Mode, category_pending: Map<string, {
+        content: string;
+        line_num: number;
+    }>);
+    private resolve_categories;
+    show_debug(): void;
+}
+export default Category_Resolver;

package/dist/resolvers/transform_resolver.d.ts

@@ -0,0 +1,63 @@
+import Logger from "../logger";
+import Nesca_Grammar_Stream from "./nesca_grammar_stream";
+import type { Token, Output_Mode, Transform, Transform_Pending } from "../utils/types";
+declare class Transform_Resolver {
+    private logger;
+    private output_mode;
+    nesca_grammar_stream: Nesca_Grammar_Stream;
+    categories: Map<string, string[]>;
+    stages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[];
+    stages: {
+        transforms: Transform[];
+        name: string;
+    }[];
+    substages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[];
+    substages: {
+        transforms: Transform[];
+        name: string;
+    }[];
+    syllable_boundaries: string[];
+    features: Map<string, {
+        graphemes: string[];
+    }>;
+    private line_num;
+    constructor(logger: Logger, output_mode: Output_Mode, nesca_grmmar_stream: Nesca_Grammar_Stream, categories: Map<string, string[]>, stages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[], substages_pending: {
+        transforms_pending: Transform_Pending[];
+        name: string;
+    }[], features: Map<string, {
+        graphemes: string[];
+    }>, syllable_boundaries: string[]);
+    resolve_stages(): void;
+    resolve_transforms(transform_pending: Transform_Pending[]): Transform[];
+    environment_helper(input: string): [string, string];
+    split_top_level(str: string): string[];
+    check_grammar_rules(str: string): void;
+    expand_chunk(chunk: string): string[];
+    resolve_alt_opt(input: string): string[][];
+    getTransformLengths<T>(target: T[][], result: T[][]): T[][];
+    categories_into_transform(input: string): string;
+    features_into_transform(stream: string): string;
+    private check_bracket_context;
+    private find_matching_bracket;
+    get_graphemes_from_matrix(feature_matrix: string): string;
+    normaliseTransformLength(target: string[][], result: string[][]): {
+        target_array: string[][];
+        result_array: string[][];
+    };
+    valid_transform_brackets(str: string): boolean;
+    valid_environment(input: string): boolean;
+    valid_cat_fea(stream: string): string;
+    format_tokens(seq: Token[]): string;
+    get_cluser_field_graphemes(input: string, mode: "RESULT" | "TARGET"): Token[][];
+    show_debug(): void;
+}
+export default Transform_Resolver;

package/dist/text_builder.d.ts

@@ -0,0 +1,31 @@
+import Word from "./word";
+import Logger from "./logger";
+import type { Output_Mode } from "./utils/types";
+import Lettercase_Mapper from "./transforma/lettercase_mapper";
+declare class Text_Builder {
+    private logger;
+    private lettercase_mapper;
+    private build_start;
+    private num_of_words;
+    private output_mode;
+    private remove_duplicates;
+    private force_word_limit;
+    private sort_words;
+    private output_divider;
+    private alphabet;
+    private invisible;
+    terminated: boolean;
+    private words;
+    private num_of_duplicates;
+    private num_of_rejects;
+    private num_of_duds;
+    private upper_gen_limit;
+    constructor(logger: Logger, lettercase_mapper: Lettercase_Mapper, build_start: number, num_of_words: number, remove_duplicates: boolean, force_word_limit: boolean, output_mode: Output_Mode, output_divider: string, sort_words: boolean, alphabet: string[], invisible: string[]);
+    add_word(word: Word): void;
+    create_record(): void;
+    make_text(): string;
+    paragraphify(words: string[]): string;
+    random_end_punctuation(): string;
+    show_debug(): void;
+}
+export default Text_Builder;

package/dist/transforma/carryover_associator.d.ts

@@ -0,0 +1,11 @@
+import type { Association, Associateme_Mapper } from "../utils/types";
+declare class Carryover_Associator {
+    private caryover_list;
+    constructor();
+    set_item(entry_id: number, variant_id: number): void;
+    get_result_associateme(association: Association, associateme_mapper: Associateme_Mapper): string | null;
+    private find_first_item;
+    private remove_first_item;
+    find_grapheme(entry_id: number, base_id: number, variant_id: number, associateme_mapper: Associateme_Mapper): string | null;
+}
+export default Carryover_Associator;

package/dist/transforma/chance_mapper.d.ts

@@ -0,0 +1,15 @@
+declare class Chance_Mapper {
+    chances: {
+        id: number;
+        percent: number;
+        rolled: boolean | null;
+    }[];
+    check_parsing: boolean;
+    constructor();
+    add_chance(percent: number): void;
+    get_is_success(id: number): boolean | null;
+    reset(): void;
+    roll_all(): {};
+    get_last_chance(): number | null;
+}
+export default Chance_Mapper;

package/dist/transforma/greek.d.ts

@@ -0,0 +1,2 @@
+export declare function latin_to_greek(input: string): string;
+export declare function greek_to_latin(input: string): string;

package/dist/transforma/hangul.d.ts

@@ -0,0 +1,3 @@
+declare function latin_to_hangul(input: string): string;
+declare function hangul_to_latin(input: string): string;
+export { hangul_to_latin, latin_to_hangul };

package/dist/transforma/lettercase_mapper.d.ts

@@ -0,0 +1,12 @@
+declare class lettercase_mapper {
+    private map;
+    private reverse_map;
+    constructor();
+    create_map(new_map: Map<string, string>): void;
+    private tokenise;
+    capitalise(word: string): string;
+    decapitalise(word: string): string;
+    to_uppercase(word: string): string;
+    to_lowercase(word: string): string;
+}
+export default lettercase_mapper;

package/dist/transforma/reference_mapper.d.ts

@@ -0,0 +1,14 @@
+declare class Reference_Mapper {
+    private map;
+    capture_stream_index: number | null;
+    capture_stream: never[];
+    is_capturing_sequence: boolean;
+    constructor();
+    reset_capture_stream_index(): void;
+    set_capture_stream_index(index: number): void;
+    capture_reference(key: string, stream: string[]): void;
+    get_captured_reference(key: string): string[];
+    clone(): Reference_Mapper;
+    absorb(other: Reference_Mapper): void;
+}
+export default Reference_Mapper;

package/dist/transforma/transformer.d.ts

@@ -0,0 +1,66 @@
+import Word from "../word";
+import Logger from "../logger";
+import type { Token, Output_Mode, Transform, Associateme_Mapper, Routine } from "../utils/types";
+import Reference_Mapper from "./reference_mapper";
+import Lettercase_Mapper from "./lettercase_mapper";
+import Carryover_Associator from "./carryover_associator";
+import Chance_Mapper from "./chance_mapper";
+type Match_Result = {
+    start: number;
+    end: number;
+    matched: string[];
+};
+type Replacement = {
+    index_span: number;
+    length_span: number;
+    target_stream: string[];
+    replacement_stream: string[];
+    matched_conditions: string[];
+};
+declare class Transformer {
+    logger: Logger;
+    stages: {
+        transforms: Transform[];
+        name: string;
+    }[];
+    substages: {
+        transforms: Transform[];
+        name: string;
+    }[];
+    graphemes: string[];
+    lettercase_mapper: Lettercase_Mapper;
+    chance_mapper: Chance_Mapper;
+    private syllable_boundaries;
+    private debug;
+    private associateme_mapper;
+    constructor(logger: Logger, graphemes: string[], lettercase_mapper: Lettercase_Mapper, chance_mapper: Chance_Mapper, syllable_boundaries: string[], stages: {
+        transforms: Transform[];
+        name: string;
+    }[], substages: {
+        transforms: Transform[];
+        name: string;
+    }[], output_mode: Output_Mode, associateme_mapper: Associateme_Mapper);
+    run_routine(routine: Routine, word: Word, word_stream: string[], line_num: number): string[];
+    target_to_word_match(word_tokens: string[], raw_target: Token[], reference_mapper: Reference_Mapper, carryover_associator: Carryover_Associator): [number, number, string[]];
+    result_former(raw_result: Token[], target_stream: string[], reference_mapper: Reference_Mapper, carryover_associator: Carryover_Associator): string[];
+    resolve_association(mapper: Associateme_Mapper, grapheme: string): {
+        entry_id: number;
+        base_id: number;
+        variant_id: number;
+    } | null;
+    get_variant_id_for_base(mapper: Associateme_Mapper, entry_id: number, base_id: number, grapheme: string): number | null;
+    match_pattern_at(stream: string[], pattern: Token[], start: number, reference_mapper: Reference_Mapper, carryover_associator: Carryover_Associator | null, max_end?: number, target_stream?: string[]): Match_Result | null;
+    environment_match(word_stream: string[], target_stream: string[], startIdx: number, raw_target: string[], before: Token[], after: Token[], reference_mapper: Reference_Mapper): [boolean, string];
+    replacementa(word_stream: string[], replacements: Replacement[], word: Word, exceptions: {
+        before: Token[];
+        after: Token[];
+    }[], line_num: number): string[];
+    apply_transform(word: Word, word_stream: string[], transform: Transform): string[];
+    do_transforms(word: Word, transforms: Transform[]): Word;
+    do_stages(word: Word): Word;
+    get_variant_id(mapper: Associateme_Mapper, grapheme: string, baseToken: {
+        entry_id: number;
+        base_id: number;
+    }): number | null;
+}
+export default Transformer;

package/dist/transforma/xsampa.d.ts

@@ -0,0 +1,3 @@
+declare function xsampa_to_ipa(input: string): string;
+declare function ipa_to_xsampa(ipa_in: string): string;
+export { xsampa_to_ipa, ipa_to_xsampa };

package/dist/utils/picker_utilities.d.ts

@@ -0,0 +1,4 @@
+declare function weighted_random_pick(items: string[], weights: number[]): string;
+declare function supra_weighted_random_pick(items: string[], weights: (number | "s")[]): string;
+declare function get_distribution(n: number, default_distribution: string): number[];
+export { weighted_random_pick, get_distribution, supra_weighted_random_pick };