kaabalah/dist/gematria/index.d.ts

The de-facto library for any esoteric calculations and tooling

import { a6 as NodeId, $ as LetterTypes, Z as TreeOfLife } from '../correspondence-model-DWXbAjC-.js';

/**
 * Extended master numbers used in gematria reduction.
 * Includes traditional master numbers (11, 22, 33, 44) and extended ones (55, 66, 77, 88, 99).
 */
declare const EXTENDED_MASTER_NUMBERS: readonly [11, 22, 33, 44, 55, 66, 77, 88, 99];
/**
 * Information about how a number was reduced, including all reduction steps
 * and any master number found in the reduction path.
 */
type ReductionInfo = {
    /** The original sum before any reduction */
    originalSum: number;
    /** All steps in the reduction path, e.g., [289, 19, 10, 1] */
    reductionSteps: number[];
    /** The final reduced value (1-9, or a master number if preserved) */
    finalValue: number;
    /** The master number found in the reduction path, if any */
    masterNumber?: number;
};
type ReverseGematriaOptions = {
    /** Target individuality (vowels sum) */
    targetVowels?: number;
    /** Target personality (consonants sum) */
    targetConsonants?: number;
    /** Target synthesis (total) */
    targetSynthesis?: number;
    /** Minimum letters (default: 1) */
    minLength?: number;
    /** Maximum letters (default: 8) */
    maxLength?: number;
    /** Maximum results (default: 100) */
    maxResults?: number;
    /** Include digraphs like PH, SH, etc. (default: true) */
    includeDigraphs?: boolean;
    /** Maximum times a single letter/digraph can repeat (e.g., 2 = "AAB" ok, "AAAB" filtered) */
    maxLetterRepeat?: number;
    /** Source text to derive results from */
    suggestionText?: string;
    /** How to use the suggestion text: "subsequence" preserves order, "anagram" allows reordering */
    suggestionMode?: "subsequence" | "anagram";
    /**
     * When true, target values match any step in the reduction path.
     * e.g., targetConsonants: 19 matches a result with consonantsSum: 289
     * because 289 reduces to [289, 19, 10, 1].
     * Default: true
     */
    matchReductionStep?: boolean;
    /**
     * Master numbers to preserve during reduction.
     * Default: [11, 22, 33, 44, 55, 66, 77, 88, 99]
     */
    masterNumbers?: number[];
};
type ReverseGematriaResult = {
    letters: string;
    letterDetails: LetterResult[];
    /** @deprecated Use vowels.originalSum instead */
    vowelsSum: number;
    /** @deprecated Use consonants.originalSum instead */
    consonantsSum: number;
    /** @deprecated Use synthesis.originalSum instead */
    synthesisSum: number;
    /** Reduction info for vowels (individuality) */
    vowels: ReductionInfo;
    /** Reduction info for consonants (personality) */
    consonants: ReductionInfo;
    /** Reduction info for synthesis (total) */
    synthesis: ReductionInfo;
};
type ReverseGematriaOutput = {
    results: ReverseGematriaResult[];
    hasMore: boolean;
    totalFound: number;
};
declare const DIGRAPHS: Set<string>;
type LetterResult = {
    latinLetterId: NodeId<LetterTypes.LATIN_LETTER>;
    value: number;
    hebrewLetterId: NodeId<LetterTypes.HEBREW_LETTER>;
    hebrewCharacter: string;
    isVowel: boolean;
};
type WordResult = {
    letters: LetterResult[];
    vowelsSum: number;
    consonantsSum: number;
    includedGematriaValues: Set<number>;
};
type GematriaState = {
    includedLetters: LetterResult[];
    vowelsSum: number;
    consonantsSum: number;
    includedGematriaValues: Set<number>;
};
type LetterPercentages = {
    percentageOfVowels: number;
    percentageOfConsonants: number;
    letters: Record<string, number>;
};
declare enum GematriaNumbersWithMeaning {
    One = 1,
    Two = 2,
    Three = 3,
    Four = 4,
    Five = 5,
    Six = 6,
    Seven = 7,
    Eight = 8,
    Nine = 9,
    Eleven = 11,
    TwentyTwo = 22,
    ThirtyThree = 33,
    FortyFour = 44
}
declare const INDIVIDUALITY_NUMBER_MEANINGS: Record<GematriaNumbersWithMeaning, string>;
declare const PERSONALITY_NUMBER_MEANINGS: Record<GematriaNumbersWithMeaning, string>;
declare const SYNTHESIS_NUMBER_MEANINGS: Record<GematriaNumbersWithMeaning, string>;

declare const data_DIGRAPHS: typeof DIGRAPHS;
declare const data_EXTENDED_MASTER_NUMBERS: typeof EXTENDED_MASTER_NUMBERS;
type data_GematriaNumbersWithMeaning = GematriaNumbersWithMeaning;
declare const data_GematriaNumbersWithMeaning: typeof GematriaNumbersWithMeaning;
type data_GematriaState = GematriaState;
declare const data_INDIVIDUALITY_NUMBER_MEANINGS: typeof INDIVIDUALITY_NUMBER_MEANINGS;
type data_LetterPercentages = LetterPercentages;
type data_LetterResult = LetterResult;
declare const data_PERSONALITY_NUMBER_MEANINGS: typeof PERSONALITY_NUMBER_MEANINGS;
type data_ReductionInfo = ReductionInfo;
type data_ReverseGematriaOptions = ReverseGematriaOptions;
type data_ReverseGematriaOutput = ReverseGematriaOutput;
type data_ReverseGematriaResult = ReverseGematriaResult;
declare const data_SYNTHESIS_NUMBER_MEANINGS: typeof SYNTHESIS_NUMBER_MEANINGS;
type data_WordResult = WordResult;
declare namespace data {
  export { data_DIGRAPHS as DIGRAPHS, data_EXTENDED_MASTER_NUMBERS as EXTENDED_MASTER_NUMBERS, data_GematriaNumbersWithMeaning as GematriaNumbersWithMeaning, type data_GematriaState as GematriaState, data_INDIVIDUALITY_NUMBER_MEANINGS as INDIVIDUALITY_NUMBER_MEANINGS, type data_LetterPercentages as LetterPercentages, type data_LetterResult as LetterResult, data_PERSONALITY_NUMBER_MEANINGS as PERSONALITY_NUMBER_MEANINGS, type data_ReductionInfo as ReductionInfo, type data_ReverseGematriaOptions as ReverseGematriaOptions, type data_ReverseGematriaOutput as ReverseGematriaOutput, type data_ReverseGematriaResult as ReverseGematriaResult, data_SYNTHESIS_NUMBER_MEANINGS as SYNTHESIS_NUMBER_MEANINGS, type data_WordResult as WordResult };
}

/**
 * Reverse gematria - find letter combinations that match target values
 */
declare const reverseGematria: (options: ReverseGematriaOptions, tree?: TreeOfLife) => ReverseGematriaOutput;
declare const calculateGematria: (phrase: string, options?: {
    missing?: boolean;
    percentages?: boolean;
}, tree?: TreeOfLife) => {
    vowels: {
        originalSum: number;
        reductionSteps: number[];
        finalValue: number;
    };
    consonants: {
        originalSum: number;
        reductionSteps: number[];
        finalValue: number;
    };
    synthesis: {
        originalSum: number;
        reductionSteps: number[];
        finalValue: number;
    };
    includedLetters: LetterResult[];
    missingGematriaValues: {
        value: number;
        hebrewLetterId: NodeId<LetterTypes.HEBREW_LETTER>;
        whenEnding: boolean;
    }[] | undefined;
    letterPercentages: LetterPercentages | undefined;
};

export { data as GematriaData, calculateGematria, reverseGematria };