zeropoint-node 1.0.0 → 1.0.1

package/dist/laws/MetaphysicalLaw.js

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

package/dist/laws/MetaphysicalLawRegistry.js

@@ -0,0 +1,103 @@
+"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

@@ -0,0 +1,311 @@
+"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()
+];