zeropoint-node 1.0.1 → 1.0.3

package/dist/laws/MetaphysicalLaw.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/laws/MetaphysicalLawRegistry.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetaphysicalLawRegistry = exports.LawOfCorrespondence = exports.LawOfUnity = void 0;
-class LawOfUnity {
-    constructor() {
-        this.name = 'LawOfUnity';
-        this.type = 'MetaphysicalLaw';
-        this.description = 'All things are one in the void';
-    }
-    apply(subject) {
-        if (subject && typeof subject.setUnity === 'function') {
-            subject.setUnity(true);
-        }
-        return subject;
-    }
-}
-exports.LawOfUnity = LawOfUnity;
-class LawOfCorrespondence {
-    constructor() {
-        this.name = 'LawOfCorrespondence';
-        this.type = 'MetaphysicalLaw';
-        this.description = 'As above, so below; as within, so without';
-    }
-    apply(subject) {
-        if (subject && typeof subject.setCorrespondence === 'function') {
-            subject.setCorrespondence(true);
-        }
-        return subject;
-    }
-}
-exports.LawOfCorrespondence = LawOfCorrespondence;
-class MetaphysicalLawRegistry {
-    constructor() {
-        this.laws = [];
-        this.initializeDefaultLaws();
-    }
-    initializeDefaultLaws() {
-        this.register(new LawOfUnity());
-        this.register(new LawOfCorrespondence());
-    }
-    static getInstance() {
-        if (!MetaphysicalLawRegistry.instance) {
-            MetaphysicalLawRegistry.instance = new MetaphysicalLawRegistry();
-        }
-        return MetaphysicalLawRegistry.instance;
-    }
-    static getAllLaws() {
-        return MetaphysicalLawRegistry.getInstance().getAllLaws();
-    }
-    register(law) {
-        this.laws.push(law);
-    }
-    getAllLaws() {
-        return [...this.laws];
-    }
-    getLawByName(name) {
-        return this.laws.find(law => law.name === name);
-    }
-    applyAll(subject) {
-        this.laws.forEach(law => {
-            law.apply(subject);
-        });
-    }
-    applyLaws(subject, lawNames) {
-        lawNames.forEach(name => {
-            const law = this.getLawByName(name);
-            if (law) {
-                law.apply(subject);
-            }
-        });
-    }
-    applyAllLaws(subject) {
-        this.applyAll(subject);
-    }
-    checkCompliance(subject) {
-        const violations = [];
-        let compliant = true;
-        this.laws.forEach(law => {
-            try {
-                law.apply(subject);
-            }
-            catch (error) {
-                violations.push(`${law.name}: ${error}`);
-                compliant = false;
-            }
-        });
-        return { compliant, violations };
-    }
-    analyzeLawInteractions() {
-        const interactions = this.laws.length * (this.laws.length - 1) / 2;
-        const complexity = this.laws.reduce((sum, law) => sum + law.name.length, 0);
-        return { interactions, complexity };
-    }
-    getLawStatistics() {
-        const types = {};
-        this.laws.forEach(law => {
-            const type = law.type || 'Unknown';
-            types[type] = (types[type] || 0) + 1;
-        });
-        return { total: this.laws.length, types };
-    }
-}
-exports.MetaphysicalLawRegistry = MetaphysicalLawRegistry;

package/dist/laws/hermeticLaws.js

@@ -1,311 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allHermeticLaws = exports.LawOfMentalism = exports.LawOfGender = exports.LawOfCauseAndEffect = exports.LawOfRhythm = exports.LawOfPolarity = exports.LawOfVibration = exports.LawOfCorrespondence = exports.LawOfUnity = void 0;
-/**
- * The Law of Unity - All is One
- * Everything is fundamentally unified and interconnected
- */
-class LawOfUnity {
-    constructor() {
-        this.name = 'Unity';
-        this.description = 'All is One; everything is fundamentally unified';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add unity properties
-            subject.isUnified = true;
-            subject.unityLevel = this.calculateUnityLevel(subject);
-            subject.interconnections = this.identifyInterconnections(subject);
-        }
-        return subject;
-    }
-    calculateUnityLevel(subject) {
-        const complexity = JSON.stringify(subject).length;
-        return Math.min(complexity / 50, 1); // Normalized unity level
-    }
-    identifyInterconnections(subject) {
-        return [
-            { type: 'consciousness', strength: 0.9 },
-            { type: 'energy', strength: 0.8 },
-            { type: 'information', strength: 0.7 },
-            { type: 'matter', strength: 0.6 }
-        ];
-    }
-}
-exports.LawOfUnity = LawOfUnity;
-/**
- * The Law of Correspondence - As above, so below
- * Patterns repeat at all scales; the microcosm reflects the macrocosm
- */
-class LawOfCorrespondence {
-    constructor() {
-        this.name = 'Correspondence';
-        this.description = 'As above, so below; patterns repeat at all scales';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add correspondence properties
-            subject.isFractal = true;
-            subject.scaleLevels = this.calculateScaleLevels(subject);
-            subject.correspondences = this.findCorrespondences(subject);
-        }
-        return subject;
-    }
-    calculateScaleLevels(subject) {
-        const levels = ['microcosm', 'mesocosm', 'macrocosm'];
-        return levels.map((level, index) => ({
-            level,
-            scale: Math.pow(10, index - 1),
-            strength: 0.8 - index * 0.1
-        }));
-    }
-    findCorrespondences(subject) {
-        return [
-            { type: 'geometric', pattern: 'sacred_geometry', strength: 0.9 },
-            { type: 'mathematical', pattern: 'golden_ratio', strength: 0.8 },
-            { type: 'consciousness', pattern: 'awareness_levels', strength: 0.7 }
-        ];
-    }
-}
-exports.LawOfCorrespondence = LawOfCorrespondence;
-/**
- * The Law of Vibration - Everything vibrates at its own frequency
- * All matter, energy, and consciousness exists in a state of vibration
- */
-class LawOfVibration {
-    constructor() {
-        this.name = 'Vibration';
-        this.description = 'Everything vibrates at its own frequency';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add vibrational frequency to objects
-            subject.vibrationalFrequency = this.calculateFrequency(subject);
-            subject.resonanceHarmonics = this.calculateHarmonics(subject);
-        }
-        return subject;
-    }
-    calculateFrequency(subject) {
-        // Calculate frequency based on object properties
-        const hash = JSON.stringify(subject).length;
-        return Math.abs(Math.sin(hash) * 1000) + 1; // Base frequency
-    }
-    calculateHarmonics(subject) {
-        const baseFreq = this.calculateFrequency(subject);
-        return [baseFreq, baseFreq * 2, baseFreq * 3, baseFreq * 5, baseFreq * 8]; // Golden ratio harmonics
-    }
-}
-exports.LawOfVibration = LawOfVibration;
-/**
- * The Law of Polarity - Everything has its opposite
- * All dualities are extremes of the same thing
- */
-class LawOfPolarity {
-    constructor() {
-        this.name = 'Polarity';
-        this.description = 'Everything has its opposite; all dualities are extremes of the same thing';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add polarity awareness
-            subject.polarity = this.determinePolarity(subject);
-            subject.opposite = this.findOpposite(subject);
-            subject.unityPoint = this.findUnityPoint(subject);
-        }
-        return subject;
-    }
-    determinePolarity(subject) {
-        const hash = JSON.stringify(subject).length;
-        if (hash % 3 === 0)
-            return 'positive';
-        if (hash % 3 === 1)
-            return 'negative';
-        return 'neutral';
-    }
-    findOpposite(subject) {
-        // Create opposite by inverting properties
-        const opposite = { ...subject };
-        for (const key in opposite) {
-            if (typeof opposite[key] === 'number') {
-                opposite[key] = -opposite[key];
-            }
-            else if (typeof opposite[key] === 'boolean') {
-                opposite[key] = !opposite[key];
-            }
-        }
-        return opposite;
-    }
-    findUnityPoint(subject) {
-        // Find the point where opposites meet
-        return {
-            ...subject,
-            unity: true,
-            transcendsPolarity: true
-        };
-    }
-}
-exports.LawOfPolarity = LawOfPolarity;
-/**
- * The Law of Rhythm - Everything flows in cycles
- * All things rise and fall in natural rhythms
- */
-class LawOfRhythm {
-    constructor() {
-        this.name = 'Rhythm';
-        this.description = 'Everything flows in cycles; all things rise and fall in natural rhythms';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add rhythmic properties
-            subject.rhythm = this.calculateRhythm(subject);
-            subject.cyclePhase = this.getCurrentPhase(subject);
-            subject.nextCycle = this.predictNextCycle(subject);
-        }
-        return subject;
-    }
-    calculateRhythm(subject) {
-        const hash = JSON.stringify(subject).length;
-        return {
-            period: Math.abs(Math.sin(hash)) * 100 + 10,
-            amplitude: Math.abs(Math.cos(hash)) * 50 + 5,
-            phase: (hash % 360) * Math.PI / 180
-        };
-    }
-    getCurrentPhase(subject) {
-        const time = Date.now();
-        const rhythm = this.calculateRhythm(subject);
-        return (time / rhythm.period) % (2 * Math.PI);
-    }
-    predictNextCycle(subject) {
-        const rhythm = this.calculateRhythm(subject);
-        const currentPhase = this.getCurrentPhase(subject);
-        return Date.now() + (2 * Math.PI - currentPhase) * rhythm.period;
-    }
-}
-exports.LawOfRhythm = LawOfRhythm;
-/**
- * The Law of Cause and Effect - Every cause has its effect
- * Nothing happens by chance; all is governed by universal law
- */
-class LawOfCauseAndEffect {
-    constructor() {
-        this.name = 'Cause and Effect';
-        this.description = 'Every cause has its effect; nothing happens by chance';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add causal relationships
-            subject.causes = this.identifyCauses(subject);
-            subject.effects = this.predictEffects(subject);
-            subject.karmicBalance = this.calculateKarmicBalance(subject);
-        }
-        return subject;
-    }
-    identifyCauses(subject) {
-        // Identify what led to this subject's existence
-        return [
-            { type: 'creation', source: 'consciousness', strength: 0.8 },
-            { type: 'influence', source: 'environment', strength: 0.6 },
-            { type: 'intention', source: 'will', strength: 0.9 }
-        ];
-    }
-    predictEffects(subject) {
-        // Predict what this subject will cause
-        return [
-            { type: 'resonance', target: 'similar_entities', probability: 0.7 },
-            { type: 'transformation', target: 'environment', probability: 0.5 },
-            { type: 'evolution', target: 'consciousness', probability: 0.9 }
-        ];
-    }
-    calculateKarmicBalance(subject) {
-        const hash = JSON.stringify(subject).length;
-        return Math.sin(hash) * 0.5 + 0.5; // Balance between 0 and 1
-    }
-}
-exports.LawOfCauseAndEffect = LawOfCauseAndEffect;
-/**
- * The Law of Gender - Everything has masculine and feminine principles
- * All creation requires the interaction of both principles
- */
-class LawOfGender {
-    constructor() {
-        this.name = 'Gender';
-        this.description = 'Everything has masculine and feminine principles; all creation requires both';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add gender principles
-            subject.masculinePrinciple = this.identifyMasculinePrinciple(subject);
-            subject.femininePrinciple = this.identifyFemininePrinciple(subject);
-            subject.creativeBalance = this.calculateCreativeBalance(subject);
-        }
-        return subject;
-    }
-    identifyMasculinePrinciple(subject) {
-        return {
-            type: 'masculine',
-            qualities: ['active', 'expressive', 'structured', 'focused'],
-            strength: 0.7
-        };
-    }
-    identifyFemininePrinciple(subject) {
-        return {
-            type: 'feminine',
-            qualities: ['receptive', 'intuitive', 'flowing', 'nurturing'],
-            strength: 0.6
-        };
-    }
-    calculateCreativeBalance(subject) {
-        const masculine = this.identifyMasculinePrinciple(subject).strength;
-        const feminine = this.identifyFemininePrinciple(subject).strength;
-        return Math.min(masculine, feminine) / Math.max(masculine, feminine);
-    }
-}
-exports.LawOfGender = LawOfGender;
-/**
- * The Law of Mentalism - All is mind
- * The universe is mental in nature; all is consciousness
- */
-class LawOfMentalism {
-    constructor() {
-        this.name = 'Mentalism';
-        this.description = 'All is mind; the universe is mental in nature';
-    }
-    apply(subject, context) {
-        if (typeof subject === 'object' && subject !== null) {
-            // Add mental/consciousness properties
-            subject.consciousnessLevel = this.calculateConsciousnessLevel(subject);
-            subject.mentalNature = this.identifyMentalNature(subject);
-            subject.thoughtForms = this.generateThoughtForms(subject);
-        }
-        return subject;
-    }
-    calculateConsciousnessLevel(subject) {
-        const complexity = JSON.stringify(subject).length;
-        return Math.min(complexity / 100, 1); // Normalized consciousness level
-    }
-    identifyMentalNature(subject) {
-        const hash = JSON.stringify(subject).length;
-        const types = ['thought', 'emotion', 'intuition', 'will', 'imagination'];
-        return types[hash % types.length];
-    }
-    generateThoughtForms(subject) {
-        return [
-            { type: 'archetype', form: 'universal_pattern', strength: 0.8 },
-            { type: 'symbol', form: 'sacred_geometry', strength: 0.9 },
-            { type: 'concept', form: 'metaphysical_principle', strength: 0.7 }
-        ];
-    }
-}
-exports.LawOfMentalism = LawOfMentalism;
-// Export all laws for easy access
-exports.allHermeticLaws = [
-    new LawOfUnity(),
-    new LawOfCorrespondence(),
-    new LawOfVibration(),
-    new LawOfPolarity(),
-    new LawOfRhythm(),
-    new LawOfCauseAndEffect(),
-    new LawOfGender(),
-    new LawOfMentalism()
-];