@restnfeel/agentc-starter-kit/dist/server.esm/node_modules/lop/lib/bottom-up.js

한국어 기업용 CMS 모듈 - Task Master AI와 함께 빠르게 웹사이트를 구현할 수 있는 재사용 가능한 컴포넌트 시스템

import { __exports as bottomUp } from '../../../_virtual/bottom-up.js';
import { __require as requireRules } from './rules.js';
import { __require as requireParsingResults } from './parsing-results.js';

var hasRequiredBottomUp;

function requireBottomUp () {
	if (hasRequiredBottomUp) return bottomUp;
	hasRequiredBottomUp = 1;
	(function (exports) {
		var rules = /*@__PURE__*/ requireRules();
		var results = /*@__PURE__*/ requireParsingResults();

		exports.parser = function(name, prefixRules, infixRuleBuilders) {
		    var self = {
		        rule: rule,
		        leftAssociative: leftAssociative,
		        rightAssociative: rightAssociative
		    };
		    
		    var infixRules = new InfixRules(infixRuleBuilders.map(createInfixRule));
		    var prefixRule = rules.firstOf(name, prefixRules);
		    
		    function createInfixRule(infixRuleBuilder) {
		        return {
		            name: infixRuleBuilder.name,
		            rule: lazyRule(infixRuleBuilder.ruleBuilder.bind(null, self))
		        };
		    }
		    
		    function rule() {
		        return createRule(infixRules);
		    }
		    
		    function leftAssociative(name) {
		        return createRule(infixRules.untilExclusive(name));
		    }
		    
		    function rightAssociative(name) {
		        return createRule(infixRules.untilInclusive(name));
		    }
		    
		    function createRule(infixRules) {
		        return apply.bind(null, infixRules);
		    }
		    
		    function apply(infixRules, tokens) {
		        var leftResult = prefixRule(tokens);
		        if (leftResult.isSuccess()) {
		            return infixRules.apply(leftResult);
		        } else {
		            return leftResult;
		        }
		    }
		    
		    return self;
		};

		function InfixRules(infixRules) {
		    function untilExclusive(name) {
		        return new InfixRules(infixRules.slice(0, ruleNames().indexOf(name)));
		    }
		    
		    function untilInclusive(name) {
		        return new InfixRules(infixRules.slice(0, ruleNames().indexOf(name) + 1));
		    }
		    
		    function ruleNames() {
		        return infixRules.map(function(rule) {
		            return rule.name;
		        });
		    }
		    
		    function apply(leftResult) {
		        var currentResult;
		        var source;
		        while (true) {
		            currentResult = applyToTokens(leftResult.remaining());
		            if (currentResult.isSuccess()) {
		                source = leftResult.source().to(currentResult.source());
		                leftResult = results.success(
		                    currentResult.value()(leftResult.value(), source),
		                    currentResult.remaining(),
		                    source
		                );
		            } else if (currentResult.isFailure()) {
		                return leftResult;
		            } else {
		                return currentResult;
		            }
		        }
		    }
		    
		    function applyToTokens(tokens) {
		        return rules.firstOf("infix", infixRules.map(function(infix) {
		            return infix.rule;
		        }))(tokens);
		    }
		    
		    return {
		        apply: apply,
		        untilExclusive: untilExclusive,
		        untilInclusive: untilInclusive
		    }
		}

		exports.infix = function(name, ruleBuilder) {
		    function map(func) {
		        return exports.infix(name, function(parser) {
		            var rule = ruleBuilder(parser);
		            return function(tokens) {
		                var result = rule(tokens);
		                return result.map(function(right) {
		                    return function(left, source) {
		                        return func(left, right, source);
		                    };
		                });
		            };
		        });
		    }
		    
		    return {
		        name: name,
		        ruleBuilder: ruleBuilder,
		        map: map
		    };
		};

		// TODO: move into a sensible place and remove duplication
		var lazyRule = function(ruleBuilder) {
		    var rule;
		    return function(input) {
		        if (!rule) {
		            rule = ruleBuilder();
		        }
		        return rule(input);
		    };
		}; 
	} (bottomUp));
	return bottomUp;
}

export { requireBottomUp as __require };
//# sourceMappingURL=bottom-up.js.map