playlist-data-engine 1.1.0

package/dist/core/features/FeatureValidator.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Feature Validator
+ *
+ * Validates class features and racial traits against strict schemas.
+ * Provides comprehensive validation for all feature properties including:
+ * - Required fields (id, name, description, etc.)
+ * - Valid enum values (class, race, type, source)
+ * - Value ranges (level 1-20)
+ * - Effects and prerequisites
+ * Uses shared AbilityConstants for code deduplication.
+ */
+/**
+ * Validation result interface
+ *
+ * Provides detailed feedback about validation failures.
+ */
+export interface ValidationResult {
+    /** Whether the item is valid */
+    valid: boolean;
+    /** Array of error messages (empty if valid) */
+    errors: string[];
+}
+/**
+ * Validation options for features and traits
+ *
+ * Provides additional context for validation, such as custom races/classes
+ * registered via ExtensionManager.
+ */
+export interface ValidationOptions {
+    /** Custom races registered via ExtensionManager */
+    customRaces?: string[];
+    /** Custom classes registered via ExtensionManager */
+    customClasses?: string[];
+}
+/**
+ * FeatureValidator - Validates class features and racial traits
+ *
+ * Provides strict validation to ensure custom features and traits
+ * meet all requirements before being registered with FeatureQuery.
+ */
+export declare class FeatureValidator {
+    /**
+     * Validate a class feature
+     *
+     * Checks all required fields, enum values, and data constraints.
+     *
+     * @param feature - The class feature to validate
+     * @param options - Optional validation context (e.g., custom races/classes)
+     * @returns Validation result with errors if any
+     */
+    static validateClassFeature(feature: unknown, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate a racial trait
+     *
+     * Checks all required fields, enum values, and data constraints.
+     *
+     * @param trait - The racial trait to validate
+     * @param options - Optional validation context (e.g., custom races)
+     * @returns Validation result with errors if any
+     */
+    static validateRacialTrait(trait: unknown, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate a feature effect
+     *
+     * @param effect - The effect to validate
+     * @returns Validation result with errors if any
+     */
+    static validateEffect(effect: unknown): ValidationResult;
+    /**
+     * Validate feature prerequisites
+     *
+     * @param prerequisites - The prerequisites to validate
+     * @param options - Optional validation context (e.g., custom races/classes)
+     * @returns Validation result with errors if any
+     */
+    static validatePrerequisites(prerequisites: unknown, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate an array of class features
+     *
+     * @param features - Array of class features to validate
+     * @returns Validation result with combined errors
+     */
+    static validateClassFeatures(features: unknown[]): ValidationResult;
+    /**
+     * Validate an array of racial traits
+     *
+     * @param traits - Array of racial traits to validate
+     * @returns Validation result with combined errors
+     */
+    static validateRacialTraits(traits: unknown[]): ValidationResult;
+    /**
+     * Check if a string is a valid ability score
+     *
+     * Re-exports the shared isValidAbility function for convenience.
+     *
+     * @param ability - The ability string to check
+     * @returns True if it's a valid ability
+     */
+    private static isAbility;
+    /**
+     * Check if a feature ID follows the correct naming convention
+     *
+     * Feature IDs should use lowercase_with_underscores format.
+     * Examples: 'barbarian_rage', 'elf_darkvision', 'fighter_action_surge'
+     *
+     * @param id - The feature ID to check
+     * @returns True if the ID format is valid
+     */
+    private static isValidFeatureId;
+}
+/**
+ * Helper function to validate a single class feature
+ *
+ * Convenience function for quick validation.
+ *
+ * @param feature - The class feature to validate
+ * @param options - Optional validation context (e.g., custom races/classes)
+ * @returns Validation result with errors if any
+ */
+export declare function validateClassFeature(feature: unknown, options?: ValidationOptions): ValidationResult;
+/**
+ * Helper function to validate a single racial trait
+ *
+ * Convenience function for quick validation.
+ *
+ * @param trait - The racial trait to validate
+ * @param options - Optional validation context (e.g., custom races)
+ * @returns Validation result with errors if any
+ */
+export declare function validateRacialTrait(trait: unknown, options?: ValidationOptions): ValidationResult;
+/**
+ * Helper function to validate an array of class features
+ *
+ * Convenience function for batch validation.
+ *
+ * @param features - Array of class features to validate
+ * @returns Validation result with combined errors
+ */
+export declare function validateClassFeatures(features: unknown[]): ValidationResult;
+/**
+ * Helper function to validate an array of racial traits
+ *
+ * Convenience function for batch validation.
+ *
+ * @param traits - Array of racial traits to validate
+ * @returns Validation result with combined errors
+ */
+export declare function validateRacialTraits(traits: unknown[]): ValidationResult;
+//# sourceMappingURL=FeatureValidator.d.ts.map

package/dist/core/features/FeatureValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureValidator.d.ts","sourceRoot":"","sources":["../../../src/core/features/FeatureValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC7B,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,+CAA+C;IAC/C,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAC9B,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AA2ED;;;;;GAKG;AACH,qBAAa,gBAAgB;IACzB;;;;;;;;OAQG;IACH,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,gBAAgB;IAyG5F;;;;;;;;OAQG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,gBAAgB;IAsGzF;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB;IA2DxD;;;;;;OAMG;IACH,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,gBAAgB;IAuInG;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,gBAAgB;IAuBnE;;;;;OAKG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,gBAAgB;IAuBhE;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAIxB;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAMlC;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,CAEpG;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,CAEjG;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAE3E;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAExE"}

package/dist/core/features/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Features module - Class features and racial traits system
+ *
+ * Provides extensible feature and trait management with validation.
+ */
+export type { FeatureEffectType, FeatureEffect, FeaturePrerequisite, FeatureType, FeatureSource, ClassFeature, RacialTrait, CharacterFeature, CharacterTrait, ValidationResult } from './FeatureTypes.js';
+export { FeatureQuery, getFeatureQuery } from './FeatureQuery.js';
+export { DEFAULT_CLASS_FEATURES, DEFAULT_RACIAL_TRAITS } from '../../constants/DefaultFeatures.js';
+export { FeatureEffectApplier } from './FeatureEffectApplier.js';
+export type { EffectApplicationResult } from '../types/Equipment.js';
+export { FeatureValidator, validateClassFeature, validateRacialTrait, validateClassFeatures, validateRacialTraits, type ValidationResult as FeatureValidationResult } from './FeatureValidator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/features/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/features/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACR,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGlE,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAGnG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAGjE,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAGrE,OAAO,EACH,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,gBAAgB,IAAI,uBAAuB,EACnD,MAAM,uBAAuB,CAAC"}

package/dist/core/generation/AbilityScoreCalculator.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Ability Score Calculator - Maps audio profile to ability scores
+ * Based on specs/001-core-engine/SPEC.md
+ */
+import type { AbilityScores } from '../types/Character.js';
+import type { AudioProfile } from '../types/AudioProfile.js';
+import type { SeededRNG } from '../../utils/random.js';
+/**
+ * Calculate D&D 5e ability scores and modifiers from audio characteristics
+ *
+ * NEW SYSTEM (v2):
+ * - Each frequency band (bass/mid/treble) is randomly assigned to 2 abilities
+ * - 50% random + 50% audio-influenced for each ability
+ * - One of each pair gets "spice" (combined with additional audio metrics)
+ * - One of each pair uses pure dominance value
+ *
+ * This ensures every song generates different stat distributions.
+ */
+export declare class AbilityScoreCalculator {
+    /**
+     * Get a spiced audio value for a frequency band
+     * Combines the dominance value with an additional metric for variety
+     */
+    private static getSpicedValue;
+    /**
+     * Create frequency-to-ability mappings using seeded RNG
+     * Each frequency (bass/mid/treble) gets assigned 2 unique abilities
+     */
+    private static createFrequencyMappings;
+    /**
+     * Calculate base ability scores (8-15) from audio profile frequencies
+     *
+     * NEW SYSTEM:
+     * - Randomly assigns bass/mid/treble to ability pairs (deterministic per seed)
+     * - 50% random + 50% audio for each score
+     * - One ability per pair gets "spiced" audio value
+     * - Result: 8-15 range (D&D 5e standard array range)
+     *
+     * @param {AudioProfile} audioProfile - Frequency analysis results
+     * @param {SeededRNG} rng - Seeded random number generator for reproducibility
+     * @returns {AbilityScores} Base scores (before racial bonuses), range 8-15
+     */
+    static calculateBaseScores(audioProfile: AudioProfile, rng: SeededRNG): AbilityScores;
+    /**
+     * Apply racial ability bonuses to base scores
+     *
+     * Each D&D 5e race provides +2 bonuses to specific abilities. This function
+     * applies those racial bonuses and ensures no ability exceeds the D&D maximum of 20.
+     *
+     * Supports both default D&D 5e races and custom races registered via ExtensionManager.
+     *
+     * @param {AbilityScores} baseScores - Base scores before racial bonuses
+     * @param {string} race - Selected character race (e.g., 'Human', 'Elf', 'Dwarf', or custom race)
+     * @returns {AbilityScores} Final scores with racial bonuses applied (capped at 20)
+     *
+     * @example
+     * // Default race
+     * const bonusedScores = AbilityScoreCalculator.applyRacialBonuses(baseScores, 'Elf');
+     * // For Elf: DEX +2, assuming baseScores.DEX was 14 → becomes 16
+     *
+     * // Custom race (if registered via ExtensionManager)
+     * const customScores = AbilityScoreCalculator.applyRacialBonuses(baseScores, 'Dragonkin');
+     */
+    static applyRacialBonuses(baseScores: AbilityScores, race: string): AbilityScores;
+    /**
+     * Calculate ability modifiers from ability scores
+     *
+     * D&D 5e modifiers are derived from ability scores using the formula:
+     * modifier = floor((score - 10) / 2)
+     *
+     * Example: Score 15 → modifier +2, Score 8 → modifier -1, Score 10 → modifier 0
+     *
+     * @param {AbilityScores} scores - Ability scores (3-20 range)
+     * @returns {AbilityScores} Modifiers used for d20 rolls and damage calculations
+     *
+     * @example
+     * const scores = { STR: 15, DEX: 14, CON: 13, INT: 12, WIS: 11, CHA: 10 };
+     * const modifiers = AbilityScoreCalculator.calculateModifiers(scores);
+     * console.log(`STR modifier: +${modifiers.STR}`);  // +2
+     */
+    static calculateModifiers(scores: AbilityScores): AbilityScores;
+}
+//# sourceMappingURL=AbilityScoreCalculator.d.ts.map

package/dist/core/generation/AbilityScoreCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbilityScoreCalculator.d.ts","sourceRoot":"","sources":["../../../src/core/generation/AbilityScoreCalculator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAcvD;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAC/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAuC7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA2BtC;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,GAAG,aAAa;IA2DrF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,kBAAkB,CAAC,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa;IAqBjF;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa;CAUlE"}

package/dist/core/generation/AppearanceGenerator.d.ts

@@ -0,0 +1,32 @@
+import type { Class } from '../types/Character.js';
+import type { AudioProfile } from '../types/AudioProfile.js';
+export interface CharacterAppearance {
+    body_type: 'slender' | 'athletic' | 'muscular' | 'stocky';
+    skin_tone: string;
+    hair_style: string;
+    hair_color: string;
+    eye_color: string;
+    facial_features: string[];
+    primary_color?: string;
+    secondary_color?: string;
+    accent_color?: string;
+    aura_color?: string;
+}
+export declare class AppearanceGenerator {
+    /**
+     * Generate character appearance from seed and audio profile
+     *
+     * Uses the ExtensionManager to get appearance options (defaults + custom)
+     * and WeightedSelector for spawn rate control.
+     */
+    static generate(seed: string, characterClass: Class, audioProfile: AudioProfile): CharacterAppearance;
+    /**
+     * Generate aura color for magical classes
+     */
+    private static generateAuraColor;
+    /**
+     * Adjust color brightness by a factor
+     */
+    private static adjustColorBrightness;
+}
+//# sourceMappingURL=AppearanceGenerator.d.ts.map

package/dist/core/generation/AppearanceGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppearanceGenerator.d.ts","sourceRoot":"","sources":["../../../src/core/generation/AppearanceGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAM7D,MAAM,WAAW,mBAAmB;IAEhC,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,CAAC;IAG1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAaD,qBAAa,mBAAmB;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CACX,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,KAAK,EACrB,YAAY,EAAE,YAAY,GAC3B,mBAAmB;IA4EtB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAuBhC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;CAkBvC"}

package/dist/core/generation/BeatConverter.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Beat Converter - Converts procedural generation output to ChartedBeatMap
+ *
+ * This class converts DifficultyVariant output (GeneratedBeat[]) to ChartedBeatMap
+ * format for compatibility with BeatStream and the existing beat map infrastructure.
+ *
+ * Part of the Pitch Detection & Button Mapping pipeline - Phase 2.7
+ *
+ * @example
+ * ```typescript
+ * const converter = new BeatConverter();
+ *
+ * const chartedBeatMap = converter.convertToChartedBeatMap(
+ *   variant,
+ *   unifiedBeatMap,
+ *   keyAssignments,
+ *   metadata
+ * );
+ * ```
+ */
+import type { UnifiedBeatMap } from '../types/BeatMap.js';
+import type { ChartedBeatMap, ChartConversionOptions, ChartMetadata } from '../types/ChartedBeatMap.js';
+import type { DifficultyVariant } from '../analysis/beat/DifficultyVariantGenerator.js';
+import type { ButtonMappingMetadata } from './ButtonMapper.js';
+import type { RhythmMetadata } from './RhythmGenerator.js';
+/**
+ * Converts procedural generation output (GeneratedBeat[]) to ChartedBeatMap
+ * for compatibility with BeatStream and the existing beat map infrastructure.
+ */
+export declare class BeatConverter {
+    /**
+     * Convert a DifficultyVariant to a ChartedBeatMap
+     *
+     * @param variant - The difficulty variant with VariantBeat[]
+     * @param unifiedBeatMap - The source UnifiedBeatMap for measure/beat info
+     * @param keyAssignments - Map of beat index to required key
+     * @param partialMetadata - Partial chart metadata
+     * @param mappingSources - Optional per-beat mapping source (beat index → 'pitch' | 'pattern')
+     * @param mappingPatternIds - Optional per-beat pattern IDs (beat index → pattern ID)
+     * @returns A ChartedBeatMap ready for BeatStream
+     */
+    convertToChartedBeatMap(variant: DifficultyVariant, unifiedBeatMap: UnifiedBeatMap, keyAssignments: Map<number, string>, partialMetadata: Partial<ChartMetadata>, mappingSources?: Map<number, 'pitch' | 'pattern'>, mappingPatternIds?: Map<number, string | undefined>): ChartedBeatMap;
+    /**
+     * Convert with full options object
+     *
+     * @param options - Conversion options
+     * @returns A ChartedBeatMap ready for BeatStream
+     */
+    convertWithOptions(variant: DifficultyVariant, options: ChartConversionOptions): ChartedBeatMap;
+    /**
+     * Convert a single VariantBeat to ChartedBeat
+     *
+     * @param beat - The VariantBeat to convert
+     * @param unifiedBeatMap - Source for measure/beat info
+     * @param key - The required key (if assigned)
+     * @param beatIndex - Index of this beat in the variant
+     * @param mappingSource - Whether this beat's key came from pitch or pattern
+     * @param patternId - ID of the pattern used (if mappingSource is 'pattern')
+     * @returns A ChartedBeat
+     */
+    private convertBeat;
+    /**
+     * Get the parent quarter note beat from UnifiedBeatMap
+     */
+    private getParentBeat;
+    /**
+     * Calculate beatInMeasure for a variant beat
+     *
+     * @param parentBeat - The parent quarter note beat
+     * @param gridPosition - Position within that quarter (0-3 for 16th, 0-2 for triplet)
+     * @param gridType - The grid type
+     * @returns Decimal beatInMeasure value
+     */
+    private calculateBeatInMeasure;
+    /**
+     * Determine if a beat was originally detected (vs generated)
+     *
+     * A beat is considered detected if:
+     * - It has no quantization error (wasn't moved), OR
+     * - It has a very small quantization error (< 10ms)
+     */
+    private isBeatDetected;
+    /**
+     * Map grid type to subdivision type
+     */
+    private mapGridToSubdivision;
+    /**
+     * Calculate confidence for a beat
+     *
+     * @param beat - The beat
+     * @param isDetected - Whether the beat was detected
+     * @returns Confidence value (0-1)
+     */
+    private calculateConfidence;
+    /**
+     * Build complete chart metadata
+     */
+    private buildChartMetadata;
+    /**
+     * Get unique keys used in the chart
+     */
+    private getUniqueKeys;
+    /**
+     * Get subdivision types used in the chart
+     */
+    private getSubdivisionTypesUsed;
+    /**
+     * Create default rhythm metadata summary
+     */
+    private createDefaultRhythmMetadata;
+    /**
+     * Create a ChartedBeatMap from mapped level result
+     *
+     * Convenience method that combines variant, beat map, and button mapping
+     *
+     * @param variant - The difficulty variant
+     * @param unifiedBeatMap - The unified beat map
+     * @param buttonMetadata - Button mapping metadata
+     * @param rhythmMetadata - Rhythm generation metadata
+     * @param keyAssignments - Per-beat key assignments (beat index → key)
+     * @param mappingSources - Per-beat mapping source (beat index → 'pitch' | 'pattern')
+     * @param mappingPatternIds - Per-beat pattern IDs (beat index → pattern ID)
+     * @returns A ChartedBeatMap ready for BeatStream
+     */
+    static fromMappedResult(variant: DifficultyVariant, unifiedBeatMap: UnifiedBeatMap, buttonMetadata: ButtonMappingMetadata, rhythmMetadata: RhythmMetadata, keyAssignments?: Map<number, string>, mappingSources?: Map<number, 'pitch' | 'pattern'>, mappingPatternIds?: Map<number, string | undefined>): ChartedBeatMap;
+}
+//# sourceMappingURL=BeatConverter.d.ts.map

package/dist/core/generation/BeatConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeatConverter.d.ts","sourceRoot":"","sources":["../../../src/core/generation/BeatConverter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAER,cAAc,EACd,sBAAsB,EACtB,aAAa,EAEhB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,KAAK,EACR,iBAAiB,EAGpB,MAAM,gDAAgD,CAAC;AAExD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAM3D;;;GAGG;AACH,qBAAa,aAAa;IAKtB;;;;;;;;;;OAUG;IACH,uBAAuB,CACnB,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,eAAe,EAAE,OAAO,CAAC,aAAa,CAAC,EACvC,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,EACjD,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACpD,cAAc;IA4CjB;;;;;OAKG;IACH,kBAAkB,CACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,sBAAsB,GAChC,cAAc;IA+CjB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,WAAW;IAkDnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA2B1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAcnC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,gBAAgB,CACnB,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,qBAAqB,EACrC,cAAc,EAAE,cAAc,EAC9B,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,EACjD,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACpD,cAAc;CA8CpB"}