solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/lexer.js

@@ -1,10 +1,10 @@
-export { Lexer, LexerState, buildTokenLookup, sharedLexer } from './chunk-HWSZJQCI.js';
-import './chunk-KVILKGMS.js';
-export { ExpressionLexer, LexerToken } from './chunk-XVWCOTR6.js';
-export { TokenTypes, registerAllTokenTypes, registerTokenType, tokenTypeId, tokenTypeName } from './chunk-RIN643A3.js';
-import './chunk-GOLDJNMZ.js';
-export { knownUnits } from './chunk-LIPPNDBE.js';
-import './chunk-4MG4XKO2.js';
+export { Lexer, LexerState, buildTokenLookup, sharedLexer } from './chunk-2CS6OMZK.js';
+import './chunk-AJA6LUI7.js';
+export { ExpressionLexer, LexerToken } from './chunk-SFQWJMKT.js';
+export { TokenTypes, registerAllTokenTypes, registerTokenType, tokenTypeId, tokenTypeName } from './chunk-GPPLSM2Z.js';
+import './chunk-XBTEO4OB.js';
+export { knownUnits } from './chunk-M5E34VG5.js';
+import './chunk-PCPX42KL.js';
 import './chunk-6RDSQURE.js';
 import './chunk-YLJ4XMA6.js';
 //# sourceMappingURL=lexer.js.map

package/dist/normalizer.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
 require('./chunk-NGBBNL4K.cjs');
-var chunkEBSPLUW4_cjs = require('./chunk-EBSPLUW4.cjs');
-require('./chunk-NMD5VRN4.cjs');
-require('./chunk-GW32KPCU.cjs');
-require('./chunk-3YNVWKR2.cjs');
-require('./chunk-EHAHVROS.cjs');
-require('./chunk-53B6KDDJ.cjs');
+var chunkAHCLWAM5_cjs = require('./chunk-AHCLWAM5.cjs');
+require('./chunk-M4F66R4O.cjs');
+require('./chunk-R24DI24X.cjs');
+require('./chunk-OUHT5Z36.cjs');
+require('./chunk-CLVQBF5C.cjs');
+require('./chunk-MBNQVDVC.cjs');
 require('./chunk-M4N5GA5Z.cjs');
 require('./chunk-B7LXJ6LC.cjs');
 
@@ -14,27 +14,27 @@ require('./chunk-B7LXJ6LC.cjs');
 
 Object.defineProperty(exports, "BUILTIN_PHRASES", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.BUILTIN_PHRASES; }
+  get: function () { return chunkAHCLWAM5_cjs.BUILTIN_PHRASES; }
 });
 Object.defineProperty(exports, "PhraseTrie", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.PhraseTrie; }
+  get: function () { return chunkAHCLWAM5_cjs.PhraseTrie; }
 });
 Object.defineProperty(exports, "TokenNormalizer", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.TokenNormalizer; }
+  get: function () { return chunkAHCLWAM5_cjs.TokenNormalizer; }
 });
 Object.defineProperty(exports, "createBuiltinNormalizerRules", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.createBuiltinNormalizerRules; }
+  get: function () { return chunkAHCLWAM5_cjs.createBuiltinNormalizerRules; }
 });
 Object.defineProperty(exports, "createFusedToken", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.createFusedToken; }
+  get: function () { return chunkAHCLWAM5_cjs.createFusedToken; }
 });
 Object.defineProperty(exports, "implicitMultiplyRule", {
   enumerable: true,
-  get: function () { return chunkEBSPLUW4_cjs.implicitMultiplyRule; }
+  get: function () { return chunkAHCLWAM5_cjs.implicitMultiplyRule; }
 });
 //# sourceMappingURL=normalizer.cjs.map
 //# sourceMappingURL=normalizer.cjs.map

package/dist/normalizer.d.cts

@@ -1,212 +1,6 @@
-import { T as Token } from './Token-0jpvUdPY.cjs';
-import { T as TokenFusion, N as NormalizerRule, a as NormalizerMatch } from './NormalizerRule-BrVoVjmP.cjs';
-
-/**
- * TokenNormalizer, post-lexer token normalization pass.
- *
- * ## Purpose
- * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw
- * token stream produced by the {@link ExpressionLexer}. This keeps the lexer
- * slim and focused on single-token production, while multi-token pattern
- * matching (phrases, implicit operators, domain merges) lives here.
- *
- * ## What rules can do
- * - **Phrase fusion**: Merge consecutive words into compound tokens
- *   (e.g., `IDENT + ... + IDENT` → `CARET`)
- * - **Implicit operator insertion**: Insert missing operators between tokens
- *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)
- * - **Domain-specific transformations**: Coalesce item names, currency pairs,
- *   percentage syntax, etc.
- *
- * ## Architecture
- * Providers register NormalizerRules alongside Parselets and OpCode handlers
- * via {@link IEnginePackage.normalizerRules}. The normalizer applies them
- * greedily left-to-right in multiple passes with safety limits.
- *
- * @module TokenNormalizer
- */
-
-/**
- * Configuration options for the normalization pass.
- *
- * These control safety limits and diagnostic callbacks. The defaults
- * are chosen to be generous enough for any realistic expression while
- * preventing runaway token expansion from recursive rules.
- */
-interface NormalizerOptions {
-    /**
-     * Maximum number of full passes over the token stream before bailing out.
-     * Prevents infinite loops from recursive rule chains.
-     * @default 100
-     */
-    maxPasses?: number;
-    /**
-     * Maximum number of tokens allowed after normalization.
-     * If exceeded, an Error is thrown rather than passing a bloated stream
-     * to the parser.
-     * @default 10000
-     */
-    maxTokens?: number;
-    /**
-     * Callback invoked for each fusion event during normalization.
-     * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.
-     * When `undefined`, fusions are still tracked internally but no callbacks fire.
-     */
-    onFusion?: (fusion: TokenFusion) => void;
-}
-/**
- * Creates a new normalized token from fused source tokens.
- *
- * The fused token inherits position information (offset, line, column)
- * from the first source token, which preserves source-map accuracy
- * for error messages and diagnostic highlighting.
- *
- * @param type         - The new token type (e.g., "CARET", "TIMES_BY")
- * @param text         - The combined text representation (e.g., "to the power of")
- * @param sourceTokens - The original tokens being fused (at least 2)
- * @returns A new {@link LexerToken} with the fused type and combined text
- */
-declare function createFusedToken(type: string, text: string, sourceTokens: Token[]): Token;
-/**
- * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.
- *
- * ## Lifecycle
- * 1. **Registration**: Rules are added via {@link register} and sorted by priority
- * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right
- * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules
- *
- * ## Normalization algorithm
- * The normalizer uses a greedy left-to-right multi-pass algorithm:
- * - At each token position, rules are tried in priority order (highest first)
- * - When a rule matches, matched tokens are consumed and replaced
- * - Processing continues from the replacement position
- * - Multiple passes handle cascading matches (one rule's output triggers another)
- * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops
- *
- * @example
- * ```ts
- * const normalizer = new TokenNormalizer();
- * normalizer.register(phraseRule);       // "to the power of" → CARET
- * normalizer.register(implicitMultRule); // "2 x" → "2 * x"
- * const normalized = normalizer.normalize(rawTokens);
- * ```
- */
-declare class TokenNormalizer {
-    /** Registered rules, unsorted, the source of truth. */
-    private rules;
-    /**
-     * Priority-sorted copy of {@link rules}, rebuilt lazily on the next
-     * {@link normalize} call after a mutation. Rules are registered once at
-     * engine/package-registration time and essentially never change during a
-     * session, but normalize() runs on every keystroke-driven evaluation, an
-     * earlier version re-sorted a fresh copy of `rules` on every single call,
-     * which meant every keystroke paid for an allocation + sort of a list that
-     * had usually not changed since the last one. `null` means "stale, rebuild
-     * on next use"; {@link register}/{@link unregister}/{@link clear} all
-     * invalidate it.
-     */
-    private sortedRulesCache;
-    /**
-     * Phrase trie for single-pass multi-word phrase fusion.
-     * Tried at each token position BEFORE other rules, the trie walk
-     * is O(depth) vs O(R × W) for separate rule matching.
-     */
-    private phraseTrie;
-    /** Merged options with defaults applied. */
-    private options;
-    /**
-     * @param options - Configuration overrides for safety limits and diagnostic callbacks
-     */
-    constructor(options?: NormalizerOptions);
-    /**
-     * Register a normalization rule.
-     *
-     * Rules are sorted by priority (descending) on each {@link normalize} call.
-     * Multiple rules can share the same priority, they are tried in registration
-     * order when priorities are equal.
-     *
-     * @param rule - The rule to register
-     */
-    register(rule: NormalizerRule): void;
-    /**
-     * Unregister a normalization rule by its {@link NormalizerRule.name | name}.
-     *
-     * If multiple rules share the same name, all are removed. This is safe to
-     * call with a name that doesn't match any rule, it simply has no effect.
-     *
-     * @param ruleName - The name of the rule to remove
-     */
-    unregister(ruleName: string): void;
-    /**
-     * Remove all registered rules, resetting the normalizer to its initial state.
-     * Also clears the phrase trie.
-     */
-    clear(): void;
-    /**
-     * Priority-sorted view of {@link rules} (descending priority; registration
-     * order preserved for ties, since {@link Array.prototype.sort} is stable).
-     * Cached until the next mutation. See {@link sortedRulesCache}.
-     */
-    private getSortedRules;
-    /**
-     * Get the number of currently registered rules (excludes phrase trie entries).
-     */
-    get ruleCount(): number;
-    /**
-     * Register a multi-word phrase for fusion into a single compound token.
-     *
-     * This is the preferred way to add phrase patterns. It inserts into the
-     * internal {@link PhraseTrie}, which collapses all phrase rules into a
-     * single O(depth) trie walk per position, no separate rule scanning.
-     *
-     * @param phrase    - Multi-word phrase (e.g., "to the power of", "abyssal whip")
-     * @param tokenType - Target token type after fusion (e.g., "CARET", "ITEM")
-     */
-    addPhrase(phrase: string, tokenType: string): void;
-    /**
-     * Check whether a word can start any registered phrase.
-     *
-     * Used by {@link implicitMultiplyRule} to suppress `*` insertion
-     * before phrase-starting identifiers (e.g., "2 power of 3" → `2 ^ 3`,
-     * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.
-     */
-    /**
-     * Get all registered phrases and their target token types.
-     *
-     * Exposes the full phrase trie structure for diagnostic rendering
-     * in the playground's NormalizerTab. Returns ALL registered phrases,
-     * not just the ones that matched in the last evaluation.
-     */
-    getPhrases(): Record<string, string>;
-    canStartPhrase(word: string): boolean;
-    /**
-     * Normalize a token stream by applying all registered rules.
-     *
-     * ## Algorithm
-     * Applies rules greedily left-to-right in multiple passes:
-     * 1. Sort rules by priority (descending)
-     * 2. Walk the token stream left to right
-     * 3. At each position, try rules in priority order
-     * 4. On match: consume matched tokens, insert replacements, restart from insert point
-     * 5. On no match: pass token through unchanged
-     * 6. Repeat until a full pass produces no changes, or maxPasses is reached
-     *
-     * ## Fusion tracking
-     * When a rule consumes more tokens than it produces, the normalizer calls
-     * `onFusion` with a {@link TokenFusion} record for diagnostic collection.
-     * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.
-     *
-     * ## Safety
-     * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},
-     * an Error is thrown to prevent memory exhaustion from runaway rule expansion.
-     *
-     * @param tokens   - Raw tokens from the lexer
-     * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})
-     * @returns Normalized tokens ready for parsing
-     * @throws {Error} If the normalized token count exceeds maxTokens
-     */
-    normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[];
-}
+import { N as NormalizerMatch, a as NormalizerRule } from './TokenNormalizer-DGVa24Q-.cjs';
+export { b as NormalizerOptions, T as TokenFusion, c as TokenNormalizer, d as createFusedToken } from './TokenNormalizer-DGVa24Q-.cjs';
+import { T as Token } from './Token-BzG5G4ja.cjs';
 
 /**
  * PhraseTrie, optimized word-level trie for multi-word phrase fusion.
@@ -361,4 +155,4 @@ declare function createBuiltinNormalizerRules(): NormalizerRule[];
  */
 declare const BUILTIN_PHRASES: Record<string, string>;
 
-export { BUILTIN_PHRASES, NormalizerMatch, type NormalizerOptions, NormalizerRule, PhraseTrie, TokenFusion, TokenNormalizer, createBuiltinNormalizerRules, createFusedToken, implicitMultiplyRule };
+export { BUILTIN_PHRASES, NormalizerMatch, NormalizerRule, PhraseTrie, createBuiltinNormalizerRules, implicitMultiplyRule };

package/dist/normalizer.d.ts

@@ -1,212 +1,6 @@
-import { T as Token } from './Token-0jpvUdPY.js';
-import { T as TokenFusion, N as NormalizerRule, a as NormalizerMatch } from './NormalizerRule-CEjf1FyD.js';
-
-/**
- * TokenNormalizer, post-lexer token normalization pass.
- *
- * ## Purpose
- * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw
- * token stream produced by the {@link ExpressionLexer}. This keeps the lexer
- * slim and focused on single-token production, while multi-token pattern
- * matching (phrases, implicit operators, domain merges) lives here.
- *
- * ## What rules can do
- * - **Phrase fusion**: Merge consecutive words into compound tokens
- *   (e.g., `IDENT + ... + IDENT` → `CARET`)
- * - **Implicit operator insertion**: Insert missing operators between tokens
- *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)
- * - **Domain-specific transformations**: Coalesce item names, currency pairs,
- *   percentage syntax, etc.
- *
- * ## Architecture
- * Providers register NormalizerRules alongside Parselets and OpCode handlers
- * via {@link IEnginePackage.normalizerRules}. The normalizer applies them
- * greedily left-to-right in multiple passes with safety limits.
- *
- * @module TokenNormalizer
- */
-
-/**
- * Configuration options for the normalization pass.
- *
- * These control safety limits and diagnostic callbacks. The defaults
- * are chosen to be generous enough for any realistic expression while
- * preventing runaway token expansion from recursive rules.
- */
-interface NormalizerOptions {
-    /**
-     * Maximum number of full passes over the token stream before bailing out.
-     * Prevents infinite loops from recursive rule chains.
-     * @default 100
-     */
-    maxPasses?: number;
-    /**
-     * Maximum number of tokens allowed after normalization.
-     * If exceeded, an Error is thrown rather than passing a bloated stream
-     * to the parser.
-     * @default 10000
-     */
-    maxTokens?: number;
-    /**
-     * Callback invoked for each fusion event during normalization.
-     * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.
-     * When `undefined`, fusions are still tracked internally but no callbacks fire.
-     */
-    onFusion?: (fusion: TokenFusion) => void;
-}
-/**
- * Creates a new normalized token from fused source tokens.
- *
- * The fused token inherits position information (offset, line, column)
- * from the first source token, which preserves source-map accuracy
- * for error messages and diagnostic highlighting.
- *
- * @param type         - The new token type (e.g., "CARET", "TIMES_BY")
- * @param text         - The combined text representation (e.g., "to the power of")
- * @param sourceTokens - The original tokens being fused (at least 2)
- * @returns A new {@link LexerToken} with the fused type and combined text
- */
-declare function createFusedToken(type: string, text: string, sourceTokens: Token[]): Token;
-/**
- * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.
- *
- * ## Lifecycle
- * 1. **Registration**: Rules are added via {@link register} and sorted by priority
- * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right
- * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules
- *
- * ## Normalization algorithm
- * The normalizer uses a greedy left-to-right multi-pass algorithm:
- * - At each token position, rules are tried in priority order (highest first)
- * - When a rule matches, matched tokens are consumed and replaced
- * - Processing continues from the replacement position
- * - Multiple passes handle cascading matches (one rule's output triggers another)
- * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops
- *
- * @example
- * ```ts
- * const normalizer = new TokenNormalizer();
- * normalizer.register(phraseRule);       // "to the power of" → CARET
- * normalizer.register(implicitMultRule); // "2 x" → "2 * x"
- * const normalized = normalizer.normalize(rawTokens);
- * ```
- */
-declare class TokenNormalizer {
-    /** Registered rules, unsorted, the source of truth. */
-    private rules;
-    /**
-     * Priority-sorted copy of {@link rules}, rebuilt lazily on the next
-     * {@link normalize} call after a mutation. Rules are registered once at
-     * engine/package-registration time and essentially never change during a
-     * session, but normalize() runs on every keystroke-driven evaluation, an
-     * earlier version re-sorted a fresh copy of `rules` on every single call,
-     * which meant every keystroke paid for an allocation + sort of a list that
-     * had usually not changed since the last one. `null` means "stale, rebuild
-     * on next use"; {@link register}/{@link unregister}/{@link clear} all
-     * invalidate it.
-     */
-    private sortedRulesCache;
-    /**
-     * Phrase trie for single-pass multi-word phrase fusion.
-     * Tried at each token position BEFORE other rules, the trie walk
-     * is O(depth) vs O(R × W) for separate rule matching.
-     */
-    private phraseTrie;
-    /** Merged options with defaults applied. */
-    private options;
-    /**
-     * @param options - Configuration overrides for safety limits and diagnostic callbacks
-     */
-    constructor(options?: NormalizerOptions);
-    /**
-     * Register a normalization rule.
-     *
-     * Rules are sorted by priority (descending) on each {@link normalize} call.
-     * Multiple rules can share the same priority, they are tried in registration
-     * order when priorities are equal.
-     *
-     * @param rule - The rule to register
-     */
-    register(rule: NormalizerRule): void;
-    /**
-     * Unregister a normalization rule by its {@link NormalizerRule.name | name}.
-     *
-     * If multiple rules share the same name, all are removed. This is safe to
-     * call with a name that doesn't match any rule, it simply has no effect.
-     *
-     * @param ruleName - The name of the rule to remove
-     */
-    unregister(ruleName: string): void;
-    /**
-     * Remove all registered rules, resetting the normalizer to its initial state.
-     * Also clears the phrase trie.
-     */
-    clear(): void;
-    /**
-     * Priority-sorted view of {@link rules} (descending priority; registration
-     * order preserved for ties, since {@link Array.prototype.sort} is stable).
-     * Cached until the next mutation. See {@link sortedRulesCache}.
-     */
-    private getSortedRules;
-    /**
-     * Get the number of currently registered rules (excludes phrase trie entries).
-     */
-    get ruleCount(): number;
-    /**
-     * Register a multi-word phrase for fusion into a single compound token.
-     *
-     * This is the preferred way to add phrase patterns. It inserts into the
-     * internal {@link PhraseTrie}, which collapses all phrase rules into a
-     * single O(depth) trie walk per position, no separate rule scanning.
-     *
-     * @param phrase    - Multi-word phrase (e.g., "to the power of", "abyssal whip")
-     * @param tokenType - Target token type after fusion (e.g., "CARET", "ITEM")
-     */
-    addPhrase(phrase: string, tokenType: string): void;
-    /**
-     * Check whether a word can start any registered phrase.
-     *
-     * Used by {@link implicitMultiplyRule} to suppress `*` insertion
-     * before phrase-starting identifiers (e.g., "2 power of 3" → `2 ^ 3`,
-     * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.
-     */
-    /**
-     * Get all registered phrases and their target token types.
-     *
-     * Exposes the full phrase trie structure for diagnostic rendering
-     * in the playground's NormalizerTab. Returns ALL registered phrases,
-     * not just the ones that matched in the last evaluation.
-     */
-    getPhrases(): Record<string, string>;
-    canStartPhrase(word: string): boolean;
-    /**
-     * Normalize a token stream by applying all registered rules.
-     *
-     * ## Algorithm
-     * Applies rules greedily left-to-right in multiple passes:
-     * 1. Sort rules by priority (descending)
-     * 2. Walk the token stream left to right
-     * 3. At each position, try rules in priority order
-     * 4. On match: consume matched tokens, insert replacements, restart from insert point
-     * 5. On no match: pass token through unchanged
-     * 6. Repeat until a full pass produces no changes, or maxPasses is reached
-     *
-     * ## Fusion tracking
-     * When a rule consumes more tokens than it produces, the normalizer calls
-     * `onFusion` with a {@link TokenFusion} record for diagnostic collection.
-     * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.
-     *
-     * ## Safety
-     * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},
-     * an Error is thrown to prevent memory exhaustion from runaway rule expansion.
-     *
-     * @param tokens   - Raw tokens from the lexer
-     * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})
-     * @returns Normalized tokens ready for parsing
-     * @throws {Error} If the normalized token count exceeds maxTokens
-     */
-    normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[];
-}
+import { N as NormalizerMatch, a as NormalizerRule } from './TokenNormalizer-t_GotBxr.js';
+export { b as NormalizerOptions, T as TokenFusion, c as TokenNormalizer, d as createFusedToken } from './TokenNormalizer-t_GotBxr.js';
+import { T as Token } from './Token-BzG5G4ja.js';
 
 /**
  * PhraseTrie, optimized word-level trie for multi-word phrase fusion.
@@ -361,4 +155,4 @@ declare function createBuiltinNormalizerRules(): NormalizerRule[];
  */
 declare const BUILTIN_PHRASES: Record<string, string>;
 
-export { BUILTIN_PHRASES, NormalizerMatch, type NormalizerOptions, NormalizerRule, PhraseTrie, TokenFusion, TokenNormalizer, createBuiltinNormalizerRules, createFusedToken, implicitMultiplyRule };
+export { BUILTIN_PHRASES, NormalizerMatch, NormalizerRule, PhraseTrie, createBuiltinNormalizerRules, implicitMultiplyRule };

package/dist/normalizer.js

@@ -1,10 +1,10 @@
 import './chunk-2RWAXT6O.js';
-export { BUILTIN_PHRASES, PhraseTrie, TokenNormalizer, createBuiltinNormalizerRules, createFusedToken, implicitMultiplyRule } from './chunk-64W6GLLZ.js';
-import './chunk-XVWCOTR6.js';
-import './chunk-RIN643A3.js';
-import './chunk-GOLDJNMZ.js';
-import './chunk-LIPPNDBE.js';
-import './chunk-4MG4XKO2.js';
+export { BUILTIN_PHRASES, PhraseTrie, TokenNormalizer, createBuiltinNormalizerRules, createFusedToken, implicitMultiplyRule } from './chunk-OFXOTECC.js';
+import './chunk-SFQWJMKT.js';
+import './chunk-GPPLSM2Z.js';
+import './chunk-XBTEO4OB.js';
+import './chunk-M5E34VG5.js';
+import './chunk-PCPX42KL.js';
 import './chunk-6RDSQURE.js';
 import './chunk-YLJ4XMA6.js';
 //# sourceMappingURL=normalizer.js.map