LibAcc: 0.8509=97/114, ProjAcc: 1.0000=0/0, Missing: 232
Module: src/optimizer
𝓟147{require}(𝓛8743{String}).install()
let 𝓟1933{falafel} = 𝓟147{require}(𝓛8743{String});
function 𝓟1934{optimize} (𝓟1935{javascript_str}: 𝓛[ty]10051{String}): (𝓟1936: 𝓛[ty]10051{String})
{
let 𝓟1937{current_length}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟1935{javascript_str}.length,𝓛8745{Number});
while (𝓛1{<UNKNOWN>}(𝓟1935{javascript_str}.length,𝓟1937{current_length}))
{
𝓟1937{current_length} ⟵ 𝓟1935{javascript_str}.length;
let 𝓟1938{current}: [miss]𝓛[ty]10051{String} = 𝓟1935{javascript_str};
𝓟1935{javascript_str} ⟵ 𝓟1944{simplify}(𝓟1995{parentIsObjectCheckRemoval}(𝓟1970{clauseRepetitionElimination}(𝓟1985{childParentAnnihilation}(𝓟1955{pruneBooleanLiterals}(𝓟1935{javascript_str})))));
}
return 𝓟1936 = 𝓟1938{current}
}
function 𝓟1939{optimizeAndTrim} (𝓟1940{javascript_str}: 𝓛[ty]10051{String}): (𝓟1941: 𝓛[ty]10051{String})
{
let 𝓟1942{optimized}: [miss]𝓛[ty]10051{String} = 𝓟1934{optimize}(𝓟1940{javascript_str});
𝓟1942{optimized} ⟵ 𝓟1942{optimized}.replace(𝓛8748{RegExp},𝓛8743{String});
𝓟1942{optimized} ⟵ 𝓟1942{optimized}.replace(𝓛8748{RegExp},𝓛8743{String});
return 𝓟1941 = 𝓟1942{optimized}
}
let 𝓟1943{simplifyMemory}: 𝓛[ty]8642{Object} = {};
function 𝓟1944{simplify} (𝓟1945{javascript_str}: 𝓛[ty]10051{String}): (𝓟1946: 𝓛[ty]10051{String})
{
if (𝓟1943{simplifyMemory}.access(𝓟1945{javascript_str}))
{
return 𝓟1946 = 𝓟1943{simplifyMemory}.access(𝓟1945{javascript_str})
}
function 𝓟1947{$Lambda8} (𝓟1948{node}): (𝓟1949: [miss]𝓛[ty]10033{Void})
{
𝓟1948{node}.precedence ⟵ 𝓛8745{Number};
if (𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟1948{node}.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1948{node}.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1948{node}.type,𝓛8743{String})))
{
𝓟1948{node}.precedence ⟵ 𝓟2026{js_precedence}(𝓟1948{node}.operator);
let 𝓟1950{LHS}: [OOV]any;
let 𝓟1951{RHS}: [OOV]any;
if (𝓛12596{GreaterThanEqualsToken}(𝓟1948{node}.left.precedence,𝓟1948{node}.precedence))
{
𝓟1950{LHS} ⟵ 𝓟1948{node}.left.source();
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟1948{node}.left.precedence,𝓟1948{node}.precedence))
{
𝓟1950{LHS} ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1948{node}.left.source()),𝓛8743{String});
}
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1948{node}.right.precedence,𝓟1948{node}.precedence),𝓟2022{isCommunicativeUniquePrecedence}(𝓟1948{node}.operator)))
{
𝓟1951{RHS} ⟵ 𝓟1948{node}.right.source();
}
else
{
if (𝓛12595{GreaterThanToken}(𝓟1948{node}.right.precedence,𝓟1948{node}.precedence))
{
𝓟1951{RHS} ⟵ 𝓟1948{node}.right.source();
}
else
{
if (𝓛12582{LessThanEqualsToken}(𝓟1948{node}.right.precedence,𝓟1948{node}.precedence))
{
𝓟1951{RHS} ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1948{node}.right.source()),𝓛8743{String});
}
}
}
𝓟1948{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟1950{LHS},𝓟1948{node}.operator),𝓟1951{RHS}))
}
}
let 𝓟1952{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟1947{$Lambda8};
let 𝓟1953{result} = 𝓟1933{falafel}(𝓟1945{javascript_str}.toString(),{},𝓟1952{simplify_fn}).toString();
𝓟1943{simplifyMemory}.access(𝓟1945{javascript_str}) ⟵ 𝓟1953{result};
return 𝓟1946 = 𝓟1953{result}
}
let 𝓟1954{pruneBooleanLiteralsMemory}: 𝓛[ty]8642{Object} = {};
function 𝓟1955{pruneBooleanLiterals} (𝓟1956{javascript_str}: 𝓛[ty]10051{String}): (𝓟1957: 𝓛[ty]10051{String})
{
if (𝓟1954{pruneBooleanLiteralsMemory}.access(𝓟1956{javascript_str}))
{
return 𝓟1957 = 𝓟1954{pruneBooleanLiteralsMemory}.access(𝓟1956{javascript_str})
}
function 𝓟1958{$Lambda9} (𝓟1959{node}): (𝓟1960: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟1959{node}.type,𝓛8743{String}))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1959{node}.argument.type,𝓛8743{String})))
{
𝓟1959{node}.update(𝓛12569{ExclamationToken}(𝓟1959{node}.argument.value))
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟1959{node}.type,𝓛8743{String}))
{
function 𝓟1961{$Lambda10} (𝓟1962{val}): (𝓟1963: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟1963 = 𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.left.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1959{node}.left.value,𝓟1962{val}))
}
𝓟1959{node}.left.is ⟵ 𝓟1961{$Lambda10};
function 𝓟1964{$Lambda11} (𝓟1965{val}): (𝓟1966: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟1966 = 𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.right.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1959{node}.right.value,𝓟1965{val}))
}
𝓟1959{node}.right.is ⟵ 𝓟1964{$Lambda11};
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1959{node}.right.source()),𝓛8743{String}))
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1959{node}.left.source()),𝓛8743{String}))
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛8743{String})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.left.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1959{node}.right.source()),𝓛8743{String}))
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1959{node}.operator,𝓛8743{String}),𝓟1959{node}.right.is(𝓛8744{Boolean})))
{
𝓟1959{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1959{node}.left.source()),𝓛8743{String}))
}
}
}
}
}
}
}
}
}
}
}
}
}
let 𝓟1967{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟1958{$Lambda9};
let 𝓟1968{result} = 𝓟1933{falafel}(𝓟1956{javascript_str}.toString(),{},𝓟1967{simplify_fn}).toString();
𝓟1954{pruneBooleanLiteralsMemory}.access(𝓟1956{javascript_str}) ⟵ 𝓟1968{result};
return 𝓟1957 = 𝓟1968{result}
}
let 𝓟1969{clauseRepetitionEliminationMemory}: 𝓛[ty]8642{Object} = {};
function 𝓟1970{clauseRepetitionElimination} (𝓟1971{javascript_str}: 𝓛[ty]10051{String}): (𝓟1972: 𝓛[ty]10051{String})
{
if (𝓟1969{clauseRepetitionEliminationMemory}.access(𝓟1971{javascript_str}))
{
return 𝓟1972 = 𝓟1969{clauseRepetitionEliminationMemory}.access(𝓟1971{javascript_str})
}
function 𝓟1973{$Lambda12} (𝓟1974{node}): (𝓟1975: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟1974{node}.type,𝓛8743{String}))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1974{node}.parent.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1974{node}.parent.operator,𝓟1974{node}.operator)))
{
}
else
{
let 𝓟1976{operator} = 𝓟1974{node}.operator;
let 𝓟1977{clauses}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟1978{logical} = 𝓟1974{node};
while (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1978{logical}.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1978{logical}.operator,𝓟1976{operator})))
{
𝓟1979{clauses}.push(𝓟1978{logical}.right.source())
𝓟1978{logical} ⟵ 𝓟1978{logical}.left;
}
𝓟1979{clauses}.push(𝓟1978{logical}.source())
let 𝓟1979{clauses}: [miss]𝓛[ty]8670{Array} = 𝓟1979{clauses}.reverse();
{
let 𝓟1980{primaryClause}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟1980{primaryClause},𝓟1979{clauses}.length))
{
{
{
let 𝓟1981{repeatClause}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟1980{primaryClause},𝓛8745{Number});
while (𝓛1{<UNKNOWN>}(𝓟1981{repeatClause},𝓟1979{clauses}.length))
{
{
if (𝓛12599{EqualsEqualsToken}(𝓟1979{clauses}.access(𝓟1980{primaryClause}),𝓟1979{clauses}.access(𝓟1981{repeatClause})))
{
𝓟1979{clauses}.splice(𝓟1981{repeatClause},𝓛8745{Number})
𝓛12614{POST_MinusMinusToken}(𝓟1981{repeatClause})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟1981{repeatClause})
}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟1980{primaryClause})
}
}
𝓟1974{node}.update(𝓟1944{simplify}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1979{clauses}.join(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟1976{operator}),𝓛8743{String}))),𝓛8743{String})))
}
}
}
let 𝓟1982{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟1973{$Lambda12};
let 𝓟1983{result} = 𝓟1933{falafel}(𝓟1971{javascript_str}.toString(),{},𝓟1982{simplify_fn}).toString();
𝓟1969{clauseRepetitionEliminationMemory}.access(𝓟1971{javascript_str}) ⟵ 𝓟1983{result};
return 𝓟1972 = 𝓟1983{result}
}
let 𝓟1984{childParentAnnihilationMemory}: 𝓛[ty]8642{Object} = {};
function 𝓟1985{childParentAnnihilation} (𝓟1986{javascript_str}: 𝓛[ty]10051{String}): (𝓟1987: 𝓛[ty]10051{String})
{
if (𝓟1984{childParentAnnihilationMemory}.access(𝓟1986{javascript_str}))
{
return 𝓟1987 = 𝓟1984{childParentAnnihilationMemory}.access(𝓟1986{javascript_str})
}
function 𝓟1988{$Lambda13} (𝓟1989{node}): (𝓟1990: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1989{node}.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.arguments.length,𝓛8745{Number})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.property.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.property.name,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.object.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.object.callee.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.object.callee.property.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟1989{node}.object.callee.object.callee.property.name,𝓛8743{String})))
{
𝓟1989{node}.object.update(𝓟1989{node}.object.callee.object.callee.object.source())
}
}
let 𝓟1991{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟1988{$Lambda13};
let 𝓟1992{result} = 𝓟1933{falafel}(𝓟1986{javascript_str}.toString(),{},𝓟1991{simplify_fn}).toString();
𝓟1984{childParentAnnihilationMemory}.access(𝓟1986{javascript_str}) ⟵ 𝓟1992{result};
return 𝓟1987 = 𝓟1992{result}
}
let 𝓟1993{parentIsObjectCheckRemovalMemory}: 𝓛[ty]8642{Object} = {};
let 𝓟1994{parent_pattern}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
function 𝓟1995{parentIsObjectCheckRemoval} (𝓟1996{javascript_str}: 𝓛[ty]10051{String}): (𝓟1997: [OOV]any)
{
if (𝓟1993{parentIsObjectCheckRemovalMemory}.access(𝓟1996{javascript_str}))
{
return 𝓟1997 = 𝓟1993{parentIsObjectCheckRemovalMemory}.access(𝓟1996{javascript_str})
}
function 𝓟1998{$Lambda14} (𝓟1999{node}): (𝓟2000: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟1999{node}.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟1999{node}.operator,𝓛8743{String})))
{
let 𝓟2001{match}: [OOV]𝓛[ty]8682{RegExpExecArray} = 𝓟1994{parent_pattern}.exec(𝓟1999{node}.source());
if (𝓛12592{AmpersandAmpersandToken}(𝓛12637{ExclamationEqualsToken}(𝓟2001{match},𝓛12643{undefined}),𝓛12599{EqualsEqualsToken}(𝓟2001{match}.access(𝓛8745{Number}),𝓟2001{match}.access(𝓛8745{Number}))))
{
𝓟1999{node}.update(𝓛8743{String})
}
}
}
let 𝓟2002{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟1998{$Lambda14};
let 𝓟2003{result} = 𝓟1933{falafel}(𝓟1996{javascript_str}.toString(),{},𝓟2002{simplify_fn}).toString();
𝓟1993{parentIsObjectCheckRemovalMemory}.access(𝓟1996{javascript_str}) ⟵ 𝓟2003{result};
return 𝓟1997 = 𝓟2003{result}
}
let 𝓟2004{singleQuoteRegex}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp}.CONSTRUCTOR(𝓛8743{String},𝓛8743{String});
function 𝓟2005{escapeSingleQuotes} (𝓟2006{string_literal}: 𝓛[ty]10051{String}): (𝓟2007: 𝓛[ty]10051{String})
{
𝓟2006{string_literal} ⟵ 𝓟2006{string_literal}.replace(𝓟2004{singleQuoteRegex},𝓛8743{String});
return 𝓟2007 = 𝓟2006{string_literal}
}
let 𝓟2008{escapeRegex}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp}.CONSTRUCTOR(𝓛8743{String},𝓛8743{String});
function 𝓟2009{escapeEscapes} (𝓟2010{string_literal}: 𝓛[ty]10051{String}): (𝓟2011: 𝓛[ty]10051{String})
{
𝓟2010{string_literal} ⟵ 𝓟2010{string_literal}.replace(𝓟2008{escapeRegex},𝓛8743{String});
return 𝓟2011 = 𝓟2010{string_literal}
}
function 𝓟2012{sanitizeQuotes} (𝓟2013{javascript_str}: (𝓛[ty]8635{Date} ≠ 𝓛[ty]10051{String})): (𝓟2014: [OOV]any)
{
function 𝓟2015{$Lambda15} (𝓟2016{node}): (𝓟2017: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2016{node}.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2016{node}.raw.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
𝓟2016{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2005{escapeSingleQuotes}(𝓟2016{node}.value)),𝓛8743{String}))
}
}
}
let 𝓟2018{simplify_fn}: [miss]𝓛[ty]8696{Function} = 𝓟2015{$Lambda15};
return 𝓟2014 = 𝓟1933{falafel}(𝓟2013{javascript_str}.toString(),{},𝓟2018{simplify_fn}).toString()
}
function 𝓟2019{$Lambda16} (𝓟2020{token}: 𝓛[ty]10051{String}): (𝓟2021: 𝓛[ty]8666{Boolean})
{
𝓛12577{$Switch}(𝓟2020{token})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2021 = 𝓛8744{Boolean}
return 𝓟2021 = 𝓛8744{Boolean}
}
let 𝓟2022{isCommunicativeUniquePrecedence}: [miss]𝓛[ty]8696{Function} = 𝓟2019{$Lambda16};
function 𝓟2023{$Lambda17} (𝓟2024{token}: 𝓛[ty]10051{String}): (𝓟2025: 𝓛[ty]8655{Number})
{
𝓛12577{$Switch}(𝓟2024{token})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
𝓛12634{$Case}(𝓛8743{String})
return 𝓟2025 = 𝓛8745{Number}
return 𝓟2025 = 𝓛8745{Number}
}
let 𝓟2026{js_precedence}: [miss]𝓛[ty]8696{Function} = 𝓟2023{$Lambda17};
Module: src/expression
𝓟147{require}(𝓛8743{String}).install()
let 𝓟2027{falafel} = 𝓟147{require}(𝓛8743{String});
let 𝓟2028{XRegExp} = 𝓟147{require}(𝓛8743{String}).XRegExp;
const 𝓟2029{DECLARATION_FORMAT} = 𝓟2028{XRegExp}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String});
function 𝓟2030{CONSTRUCTOR} (𝓟2031{declaration}: 𝓛[ty]10051{String},𝓟2032{expression}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟[ty]2046{Function})
{
const 𝓟[ty]2046{Function};
const 𝓟[ty]2046{Function};
let 𝓟2036{match} = 𝓟2028{XRegExp}.exec(𝓟2031{declaration},𝓟2029{DECLARATION_FORMAT});
let 𝓟2037{params} = 𝓟2028{XRegExp}.split(𝓟2036{match}.paramlist,𝓛8748{RegExp});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟2037{params}.length,𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2037{params}.access(𝓛8745{Number}),𝓛8743{String})))
{
𝓟2037{params} ⟵ 𝓛8757{Array}();
}
𝓟[ty]2046{Function}.identifier ⟵ 𝓟2036{match}.name;
𝓟[ty]2046{Function}.signature ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2036{match}.name,𝓛8743{String}),𝓟2037{params}.length),𝓛8743{String});
𝓟[ty]2046{Function}.parameter_map ⟵ 𝓟2037{params};
𝓟[ty]2046{Function}.expression ⟵ 𝓟2094{parseUser}(𝓟2032{expression});
}
function 𝓟2038{parse} (𝓟2039{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2040: [OOV]𝓟[ty]2046{Function})
{
let 𝓟2041{fun}: [OOV]𝓟[ty]2046{Function};
function 𝓟2042{$Lambda2} (𝓟2043{key}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2044{val}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2045: [miss]𝓛[ty]10033{Void})
{
𝓟2041{fun} ⟵ 𝓟2030{CONSTRUCTOR}(𝓟2043{key}.asString().value,𝓟2044{val}.coerceString());
}
𝓟2039{json}.asObject().forEach(𝓟2042{$Lambda2})
return 𝓟2040 = 𝓟2041{fun}
}
class 𝓟[ty]2046{Function}{
𝓟2048{identifier}: 𝓛[ty]10051{String};
𝓟2049{signature}: 𝓛[ty]10051{String};
𝓟2050{parameter_map}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object});
𝓟2051{expression}: [OOV]𝓟[ty]2097{Expression};
}
function 𝓟2052{CONSTRUCTOR} (): (𝓟[ty]2064{Functions})
{
const 𝓟[ty]2064{Functions};
const 𝓟[ty]2064{Functions};
}
function 𝓟2056{parse} (𝓟2057{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2058: [OOV]𝓟[ty]2064{Functions})
{
let 𝓟2059{functions}: [OOV]𝓟[ty]2064{Functions} = 𝓟2052{CONSTRUCTOR}();
if (𝓛12599{EqualsEqualsToken}(𝓟2057{json},𝓛12643{undefined}))
{
return 𝓟2058 = 𝓟2059{functions}
}
function 𝓟2060{$Lambda3} (𝓟2061{val}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2062: [miss]𝓛[ty]10033{Void})
{
let 𝓟2063{fun}: [OOV]𝓟[ty]2046{Function} = 𝓟2038{parse}(𝓟2061{val});
𝓟2059{functions}.access(𝓟2063{fun}.identifier) ⟵ 𝓟2063{fun};
}
𝓟2057{json}.asArray().forEach(𝓟2060{$Lambda3})
return 𝓟2058 = 𝓟2059{functions}
}
class 𝓟[ty]2064{Functions}{
}
function 𝓟2066{CONSTRUCTOR} (): (𝓟[ty]2070{Symbols})
{
const 𝓟[ty]2070{Symbols};
const 𝓟[ty]2070{Symbols};
𝓟[ty]2070{Symbols}.variables ⟵ {};
𝓟[ty]2070{Symbols}.functions ⟵ {};
}
class 𝓟[ty]2070{Symbols}{
𝓟2072{functions}: 𝓛[ty]8642{Object};
𝓟2073{variables}: 𝓛[ty]8642{Object};
function 𝓟2074{clone} (): (𝓟2075: [OOV]𝓟[ty]2070{Symbols})
{
let 𝓟2076{clone}: [OOV]𝓟[ty]2070{Symbols} = 𝓟2066{CONSTRUCTOR}();
{
let 𝓟2077{p}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2070{Symbols}.functions);
while (𝓛8744{Boolean})
{
𝓟2076{clone}.functions.access(𝓟2077{p}) ⟵ 𝓟[ty]2070{Symbols}.functions.access(𝓟2077{p});
}
}
{
let 𝓟2078{v}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2070{Symbols}.variables);
while (𝓛8744{Boolean})
{
𝓟2076{clone}.variables.access(𝓟2078{v}) ⟵ 𝓟[ty]2070{Symbols}.variables.access(𝓟2078{v});
}
}
return 𝓟2075 = 𝓟2076{clone}
}
function 𝓟2079{loadFunction} (𝓟2080{functions}: [OOV]𝓟[ty]2064{Functions}): (𝓟2081: [miss]𝓛[ty]10033{Void})
{
{
let 𝓟2082{identifier}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2080{functions});
while (𝓛8744{Boolean})
{
𝓟[ty]2070{Symbols}.functions.access(𝓟2082{identifier}) ⟵ 𝓟2080{functions}.access(𝓟2082{identifier});
}
}
}
}
const 𝓟2083{FALSE}: [OOV]𝓟[ty]2097{Expression} = 𝓟2085{CONSTRUCTOR}(𝓛8743{String},𝓛12643{undefined});
const 𝓟2084{TRUE}: [OOV]𝓟[ty]2097{Expression} = 𝓟2085{CONSTRUCTOR}(𝓛8743{String},𝓛12643{undefined});
function 𝓟2085{CONSTRUCTOR} (𝓟2086{raw}: 𝓛[ty]10051{String},𝓟2087{source}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟[ty]2097{Expression})
{
const 𝓟[ty]2097{Expression};
const 𝓟[ty]2097{Expression};
𝓟[ty]2097{Expression}.raw ⟵ 𝓟2086{raw};
𝓟[ty]2097{Expression}.source ⟵ 𝓟2087{source};
}
function 𝓟2091{parse} (𝓟2092{raw}: 𝓛[ty]10051{String}): (𝓟2093: [OOV]𝓟[ty]2097{Expression})
{
return 𝓟2093 = 𝓟2085{CONSTRUCTOR}(𝓟2092{raw},𝓛12643{undefined})
}
function 𝓟2094{parseUser} (𝓟2095{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2096: [OOV]𝓟[ty]2097{Expression})
{
return 𝓟2096 = 𝓟2085{CONSTRUCTOR}(𝓟2482{optimizer}.sanitizeQuotes(𝓟2095{json}.value),𝓟2095{json})
}
class 𝓟[ty]2097{Expression}{
𝓟2099{raw}: 𝓛[ty]10051{String};
𝓟2100{source}: [OOV]𝓛[ty]2{<UNKNOWN>};
function 𝓟2101{rewriteForChild} (): (𝓟2102: 𝓛[ty]10051{String})
{
function 𝓟2103{$Lambda4} (𝓟2104{node}): (𝓟2105: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2104{node}.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2104{node}.name,𝓛8743{String}))
{
𝓟2104{node}.update(𝓛8743{String})
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2104{node}.name,𝓛8743{String}))
{
𝓟2104{node}.update(𝓛8743{String})
}
}
}
}
let 𝓟2106{falafel_visitor}: [miss]𝓛[ty]8696{Function} = 𝓟2103{$Lambda4};
return 𝓟2102 = 𝓟2027{falafel}(𝓟[ty]2097{Expression}.raw,{},𝓟2106{falafel_visitor}).toString()
}
function 𝓟2107{rewriteForParent} (𝓟2108{child_name}): (𝓟2109: 𝓛[ty]10051{String})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2108{child_name}.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
return 𝓟2109 = 𝓛8743{String}
}
if (𝓛12599{EqualsEqualsToken}(𝓟2108{child_name}.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
return 𝓟2109 = 𝓛8743{String}
}
function 𝓟2110{$Lambda5} (𝓟2111{node}): (𝓟2112: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2111{node}.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2111{node}.name,𝓛8743{String}))
{
𝓟2111{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2108{child_name}),𝓛8743{String}))
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2111{node}.name,𝓛8743{String}))
{
𝓟2111{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2108{child_name}),𝓛8743{String}))
}
}
}
}
let 𝓟2113{falafel_visitor}: [miss]𝓛[ty]8696{Function} = 𝓟2110{$Lambda5};
return 𝓟2109 = 𝓟2027{falafel}(𝓟[ty]2097{Expression}.raw,{},𝓟2113{falafel_visitor}).toString() as 𝓛[ty]10051{String}
}
function 𝓟2114{expandFunctions} (𝓟2115{symbols}: [OOV]𝓟[ty]2070{Symbols}): (𝓟2116: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]10051{String}))
{
let 𝓟2117{self}: [OOV]𝓟[ty]2097{Expression} = 𝓟[ty]2097{Expression};
function 𝓟2118{$Lambda6} (𝓟2119{node}): (𝓟2120: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2119{node}.type,𝓛8743{String}))
{
if (𝓟2115{symbols}.functions.access(𝓟2119{node}.name))
{
𝓟2119{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓟2115{symbols}.variables.access(𝓟2119{node}.name))
{
𝓟2119{node}.update(𝓟2115{symbols}.variables.access(𝓟2119{node}.name).source())
𝓟2119{node}.expr_type ⟵ 𝓟2115{symbols}.variables.access(𝓟2119{node}.name).expr_type;
}
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2119{node}.type,𝓛8743{String}))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2119{node}.callee.expr_type,𝓛8743{String}))
{
let 𝓟2121{fun}: [OOV]𝓟[ty]2046{Function} = 𝓟2115{symbols}.functions.access(𝓟2119{node}.callee.name);
let 𝓟2122{function_symbols}: [OOV]𝓟[ty]2070{Symbols} = 𝓟2115{symbols}.clone();
let 𝓟2123{params} = 𝓟2119{node}.arguments;
{
let 𝓟2124{p_index}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2123{params});
while (𝓛8744{Boolean})
{
let 𝓟2125{p_node} = 𝓟2123{params}.access(𝓟2124{p_index});
let 𝓟2126{local_name} = 𝓟2121{fun}.parameter_map.access(𝓟2124{p_index});
𝓟2122{function_symbols}.variables.access(𝓟2126{local_name}) ⟵ 𝓟2125{p_node};
}
}
let 𝓟2127{expansion}: [miss]𝓛[ty]10051{String} = 𝓟2121{fun}.expression.expandFunctions(𝓟2122{function_symbols});
𝓟2119{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2127{expansion}),𝓛8743{String}))
𝓟2119{node}.expr_type ⟵ 𝓛8743{String};
}
}
}
}
let 𝓟2128{falafel_visitor}: [miss]𝓛[ty]8696{Function} = 𝓟2118{$Lambda6};
let 𝓟2129{code}: 𝓛[ty]10051{String} = 𝓟2027{falafel}(𝓟[ty]2097{Expression}.raw,{},𝓟2128{falafel_visitor}).toString();
return 𝓟2116 = 𝓟2482{optimizer}.simplify(𝓟2129{code})
}
function 𝓟2130{generate} (𝓟2131{symbols}: [OOV]𝓟[ty]2070{Symbols}): (𝓟2132: 𝓛[ty]10051{String})
{
let 𝓟2133{self}: [OOV]𝓟[ty]2097{Expression} = 𝓟[ty]2097{Expression};
function 𝓟2134{$Lambda7} (𝓟2135{node}): (𝓟2136: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.update(𝓛8743{String})
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.update(𝓛8743{String})
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓟2131{symbols}.functions.access(𝓟2135{node}.name))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓟2131{symbols}.variables.access(𝓟2135{node}.name))
{
let 𝓟2137{label} = 𝓟2135{node}.name;
𝓟2135{node}.update(𝓟2131{symbols}.variables.access(𝓟2135{node}.name).source())
𝓟2135{node}.expr_type ⟵ 𝓟2131{symbols}.variables.access(𝓟2135{node}.name).expr_type;
𝓟2135{node}.label ⟵ 𝓟2137{label};
}
}
}
}
}
}
}
}
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟2135{node}.value),𝓛8743{String}),𝓛1{<UNKNOWN>}(𝓟2135{node}.value,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟2135{node}.raw.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.object.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛12643{undefined};
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.expr_type,𝓛8743{String}))
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.source()),𝓛8743{String}))
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.expr_type,𝓛8743{String}))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟2135{node}.property.label,𝓛12569{ExclamationToken}(𝓟2148{isArraySyntaxMemberExpression}(𝓟2135{node}))))
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.label),𝓛8743{String}))
}
else
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.source()),𝓛8743{String}))
}
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.source()),𝓛8743{String}))
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
}
}
}
}
}
}
}
}
}
}
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.expr_type,𝓛8743{String}))
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.source()),𝓛8743{String}))
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.expr_type,𝓛8743{String}))
{
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2135{node}.object.source(),𝓛8743{String}),𝓟2135{node}.property.source()),𝓛8743{String}))
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
}
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.object.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.object.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.type,𝓛8743{String}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.property.name,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
}
}
}
}
}
}
}
}
}
}
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.expr_type,𝓛12643{undefined}))
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2135{node}.object.expr_type),𝓛8743{String}),𝓟2135{node}.property.expr_type)).source(𝓟2133{self}.source).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.callee.expr_type,𝓛8743{String}))
{
let 𝓟2138{fun}: [OOV]𝓟[ty]2046{Function} = 𝓟2131{symbols}.functions.access(𝓟2135{node}.callee.name);
let 𝓟2139{function_symbols}: [OOV]𝓟[ty]2070{Symbols} = 𝓟2131{symbols}.clone();
let 𝓟2140{params} = 𝓟2135{node}.arguments;
{
let 𝓟2141{p_index}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2140{params});
while (𝓛8744{Boolean})
{
let 𝓟2142{p_node} = 𝓟2140{params}.access(𝓟2141{p_index});
let 𝓟2143{local_name} = 𝓟2138{fun}.parameter_map.access(𝓟2141{p_index});
𝓟2139{function_symbols}.variables.access(𝓟2143{local_name}) ⟵ 𝓟2142{p_node};
}
}
let 𝓟2144{expansion}: [miss]𝓛[ty]10051{String} = 𝓟2138{fun}.expression.generate(𝓟2139{function_symbols});
𝓟2135{node}.update(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2144{expansion}),𝓛8743{String}))
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟2135{node}.callee.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟2135{node}.callee.property.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟2135{node}.callee.property.name,𝓛8743{String})))
{
𝓟2481{error}.message(𝓛8743{String}).source(𝓟2133{self}.source).on(𝓛8749{Error}.CONSTRUCTOR())
}
else
{
let 𝓟2145{uncoerced}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12637{ExclamationEqualsToken}(𝓟2135{node}.callee.property,𝓛12643{undefined}),𝓛12596{GreaterThanEqualsToken}(𝓟2145{uncoerced}.indexOf(𝓟2135{node}.callee.property.name),𝓛8745{Number})))
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2135{node}.source()),𝓛8743{String})).source(𝓟2133{self}.source).on(𝓛8749{Error}.CONSTRUCTOR())
}
else
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2135{node}.callee.expr_type),𝓛8743{String})).source(𝓟2133{self}.source).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
}
}
}
}
}
}
}
}
}
else
{
if (𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}),𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String})),𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String})))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.left.expr_type,𝓛8743{String}))
{
𝓟2135{node}.left.update(𝓛12641{PlusToken}(𝓟2135{node}.left.source(),𝓛8743{String}))
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟2135{node}.right.expr_type,𝓛8743{String}))
{
𝓟2135{node}.right.update(𝓛12641{PlusToken}(𝓟2135{node}.right.source(),𝓛8743{String}))
}
𝓟2135{node}.expr_type ⟵ 𝓛8743{String};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
𝓟2135{node}.expr_type ⟵ 𝓟2135{node}.argument.expr_type;
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2135{node}.type,𝓛8743{String}))
{
}
else
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛8743{String},𝓟2135{node}.type)).source(𝓟2133{self}.source).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
}
}
}
}
}
}
}
}
let 𝓟2146{falafel_visitor}: [miss]𝓛[ty]8696{Function} = 𝓟2134{$Lambda7};
let 𝓟2147{code}: 𝓛[ty]10051{String} = 𝓟2027{falafel}(𝓟[ty]2097{Expression}.raw,{},𝓟2146{falafel_visitor}).toString();
return 𝓟2132 = (𝓟2483{globals}.optimize ? 𝓟2482{optimizer}.optimizeAndTrim(𝓟2147{code}) : 𝓟2482{optimizer}.simplify(𝓟2147{code})
}
}
function 𝓟2148{isArraySyntaxMemberExpression} (𝓟2149{node}): (𝓟2150: 𝓛[ty]8666{Boolean})
{
return 𝓟2150 = 𝓛12599{EqualsEqualsToken}(𝓟2149{node}.source().slice(𝓟2149{node}.object.source().length).trim().charAt(𝓛8745{Number}),𝓛8743{String})
}
Module: src/java/java
𝓟147{require}(𝓛8743{String}).install()
let 𝓟2151{TARGET}: 𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟2152{DEBUG}: 𝓛[ty]8666{Boolean};
function 𝓟2153{generate} (𝓟2154{model}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2155{debug}: 𝓛[ty]8666{Boolean}): (𝓟2156: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2151{TARGET})
𝓟2152{DEBUG} ⟵ 𝓟2155{debug};
let 𝓟2157{lines}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
𝓟2158{generate_class}(𝓟2154{model}.schema.root,𝓟2157{lines})
𝓟1393{writeFile}(𝓟2151{TARGET},𝓟2157{lines}.join(𝓛8743{String}))
}
function 𝓟2158{generate_class} (𝓟2159{schema}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2160{output}: 𝓛[ty]8670{Array}): (𝓟2161: [miss]𝓛[ty]10033{Void})
{
if (𝓟2152{DEBUG})
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2159{schema})
}
let 𝓟2162{lines}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
}
Module: src/schema
𝓟147{require}(𝓛8743{String}).install()
let 𝓟2163{debug_metaschema_validation}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
function 𝓟2164{annotate} (𝓟2165{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2166: [miss]𝓛[ty]10033{Void})
{
𝓟2165{model}.schema.root ⟵ 𝓟2257{annotate_schema}(𝓟2165{model}.schema.json,𝓛12643{undefined},𝓛12643{undefined},𝓟2295{CONSTRUCTOR}(),𝓟2165{model});
}
function 𝓟2167{pushDownConstraints} (𝓟2168{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2169: [miss]𝓛[ty]10033{Void})
{
𝓟2168{model}.schema.root.pushDownConstraints(𝓟2168{model}.functions,𝓛12643{undefined})
}
function 𝓟2170{pullUpConstraints} (𝓟2171{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2172: [miss]𝓛[ty]10033{Void})
{
𝓟2171{model}.schema.root.pullUpConstraints(𝓟2171{model}.functions,𝓛8743{String})
}
function 𝓟2173{combineACL} (𝓟2174{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2175: [miss]𝓛[ty]10033{Void})
{
𝓟2174{model}.schema.root.combineACL(𝓟2174{model}.functions,𝓟2174{model}.access,𝓛8757{Array}())
}
function 𝓟2176{generateRules} (𝓟2177{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2178: [miss]𝓛[ty]10051{String})
{
let 𝓟2179{buffer}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓛8743{String})
let 𝓟2180{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Symbols.CONSTRUCTOR();
𝓟2180{symbols}.loadFunction(𝓟2177{model}.functions)
𝓟2177{model}.schema.root.generate(𝓟2180{symbols},𝓛8743{String},𝓟2179{buffer},𝓛8744{Boolean})
𝓛1{<UNKNOWN>}(𝓛8743{String})
let 𝓟2181{code}: 𝓛[ty]10051{String} = 𝓛1{<UNKNOWN>}(𝓛8743{String});
return 𝓟2178 = 𝓟2181{code}
}
const 𝓟2182{KEY_PATTERN}: 𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟2183{CONSTRUCTOR} (𝓟2184{node}: [OOV]any): (𝓟[ty]2188{SchemaNode})
{
const 𝓟[ty]2188{SchemaNode};
const 𝓟[ty]2188{SchemaNode};
𝓟[ty]2188{SchemaNode}.properties ⟵ {};
𝓟[ty]2188{SchemaNode}.node ⟵ 𝓟2184{node};
}
class 𝓟[ty]2188{SchemaNode}{
𝓟2190{read}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2191{examples}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2192{indexOn}: 𝓛[ty]8670{Array};
𝓟2193{properties}: 𝓛[ty]8642{Object};
𝓟2194{additionalProperties}: 𝓛[ty]8666{Boolean};
𝓟2195{nonexamples}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2196{constraint}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2197{node}: [OOV]any;
𝓟2198{type}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String});
𝓟2199{write}: [OOV]𝓛[ty]2{<UNKNOWN>};
function 𝓟2220{pullUpConstraints} (𝓟2221{functions}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2222{child_name}): (𝓟2223: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]10051{String}))
{
if (𝓟[ty]2188{SchemaNode}.isLeaf())
{
return 𝓟2223 = 𝓟[ty]2188{SchemaNode}.constraint.rewriteForParent(𝓟2222{child_name})
}
let 𝓟2224{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Symbols.CONSTRUCTOR();
𝓟2224{symbols}.loadFunction(𝓟2221{functions})
let 𝓟2225{children_clauses}: 𝓛[ty]10051{String} = 𝓟[ty]2188{SchemaNode}.constraint.expandFunctions(𝓟2224{symbols});
{
let 𝓟2226{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2188{SchemaNode}.properties);
while (𝓛8744{Boolean})
{
𝓟2225{children_clauses} ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2225{children_clauses}),𝓛8743{String}),𝓟[ty]2188{SchemaNode}.properties.access(𝓟2226{property}).pullUpConstraints(𝓟2221{functions},𝓟2226{property})),𝓛8743{String});
}
}
𝓟[ty]2188{SchemaNode}.constraint ⟵ 𝓟2486{expression}.Expression.parse(𝓟2225{children_clauses});
return 𝓟2223 = 𝓟[ty]2188{SchemaNode}.constraint.rewriteForParent(𝓟2222{child_name})
}
function 𝓟2200{isLeaf} (): (𝓟2201: 𝓛[ty]8666{Boolean})
{
return 𝓟2201 = 𝓛12599{EqualsEqualsToken}(𝓛8741{Object}.keys(𝓟[ty]2188{SchemaNode}.properties).length,𝓛8745{Number})
}
function 𝓟2239{getWildchild} (): (𝓟2240: 𝓛[ty]10051{String})
{
return 𝓟2240 = 𝓟2332{getWildchild}(𝓟[ty]2188{SchemaNode}.node).value
}
function 𝓟2202{generate} (𝓟2203{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2204{prefix}: 𝓛[ty]10051{String},𝓟2205{buffer}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟2206{use_validation}: 𝓛[ty]8666{Boolean}): (𝓟2207: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
if (𝓛12595{GreaterThanToken}(𝓟[ty]2188{SchemaNode}.indexOn.length,𝓛8745{Number}))
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}),𝓟[ty]2188{SchemaNode}.indexOn.join(𝓛8743{String})),𝓛8743{String}))
}
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}))
𝓛1{<UNKNOWN>}(𝓟2482{optimizer}.escapeEscapes(𝓟[ty]2188{SchemaNode}.write.generate(𝓟2203{symbols})))
𝓛1{<UNKNOWN>}(𝓛8743{String})
if (𝓟2206{use_validation})
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}))
𝓛1{<UNKNOWN>}(𝓟2482{optimizer}.escapeEscapes(𝓟[ty]2188{SchemaNode}.write.generate(𝓟2203{symbols})))
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}))
𝓛1{<UNKNOWN>}(𝓟2482{optimizer}.escapeEscapes(𝓟[ty]2188{SchemaNode}.read.generate(𝓟2203{symbols})))
𝓛1{<UNKNOWN>}(𝓛8743{String})
let 𝓟2208{comma_in_properties}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
{
let 𝓟2209{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2188{SchemaNode}.properties);
while (𝓛8744{Boolean})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2209{property}.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
let 𝓟2210{name}: [miss]𝓛[ty]10051{String} = 𝓟2209{property}.substr(𝓛8745{Number});
let 𝓟2211{use_validation_child}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
}
else
{
let 𝓟2212{name}: [miss]𝓛[ty]10051{String} = 𝓟2209{property};
let 𝓟2213{use_validation_child}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
}
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}),𝓟2340{name}),𝓛8743{String}))
𝓟[ty]2188{SchemaNode}.properties.access(𝓟2209{property}).generate(𝓟2203{symbols},𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}),𝓟2205{buffer},𝓟2213{use_validation_child})
𝓛1{<UNKNOWN>}()
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟2208{comma_in_properties} ⟵ 𝓛8744{Boolean};
}
}
if (𝓛12569{ExclamationToken}(𝓟[ty]2188{SchemaNode}.additionalProperties))
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓟2204{prefix},𝓛8743{String}))
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟2208{comma_in_properties} ⟵ 𝓛8744{Boolean};
}
if (𝓟2208{comma_in_properties})
{
𝓛1{<UNKNOWN>}()
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
else
{
𝓛1{<UNKNOWN>}()
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
𝓛1{<UNKNOWN>}(𝓟2204{prefix})
𝓛1{<UNKNOWN>}(𝓛8743{String})
return 𝓟2207 = 𝓟2205{buffer}
}
function 𝓟2227{combineACL} (𝓟2228{functions}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2229{acl}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2230{location}: 𝓛[ty]8670{Array}): (𝓟2231: [miss]𝓛[ty]10033{Void})
{
let 𝓟2232{write}: 𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟2233{read}: 𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟2234{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Symbols.CONSTRUCTOR();
𝓟2234{symbols}.loadFunction(𝓟2228{functions})
{
let 𝓟2235{idx}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2229{acl});
while (𝓛8744{Boolean})
{
let 𝓟2236{entry}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2229{acl}.access(𝓟2235{idx});
if (𝓟2236{entry}.match(𝓟2230{location}))
{
𝓟2232{write} ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2232{write}),𝓛8743{String}),𝓟2236{entry}.getWriteFor(𝓟2234{symbols},𝓟2230{location}).raw),𝓛8743{String});
𝓟2233{read} ⟵ 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2233{read}),𝓛8743{String}),𝓟2236{entry}.getReadFor(𝓟2234{symbols},𝓟2230{location}).raw),𝓛8743{String});
}
}
}
𝓟[ty]2188{SchemaNode}.write ⟵ 𝓟2486{expression}.Expression.parse(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟[ty]2188{SchemaNode}.constraint.raw),𝓛8743{String}),𝓟2232{write}),𝓛8743{String}));
𝓟[ty]2188{SchemaNode}.read ⟵ 𝓟2486{expression}.Expression.parse(𝓟2233{read});
{
let 𝓟2237{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2188{SchemaNode}.properties);
while (𝓛8744{Boolean})
{
let 𝓟2238{child_location}: 𝓛[ty]8670{Array} = 𝓟2230{location}.concat(𝓟2237{property} as 𝓛[ty]10051{String});
𝓟[ty]2188{SchemaNode}.properties.access(𝓟2237{property}).combineACL(𝓟2228{functions},𝓟2229{acl},𝓟2238{child_location})
}
}
}
function 𝓟2214{pushDownConstraints} (𝓟2215{functions}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2216{inherited_clause}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2217: [miss]𝓛[ty]10033{Void})
{
let 𝓟2218{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Symbols.CONSTRUCTOR();
𝓟2218{symbols}.loadFunction(𝓟2215{functions})
if (𝓛12637{ExclamationEqualsToken}(𝓟2216{inherited_clause},𝓛12643{undefined}))
{
𝓟[ty]2188{SchemaNode}.constraint ⟵ 𝓟2486{expression}.Expression.parse(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2216{inherited_clause}.rewriteForChild()),𝓛8743{String}),𝓟[ty]2188{SchemaNode}.constraint.expandFunctions(𝓟2218{symbols})),𝓛8743{String}));
}
{
let 𝓟2219{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2188{SchemaNode}.properties);
while (𝓛8744{Boolean})
{
𝓟[ty]2188{SchemaNode}.properties.access(𝓟2219{property}).pushDownConstraints(𝓟2215{functions},𝓟[ty]2188{SchemaNode}.constraint)
}
}
}
}
function 𝓟2241{CONSTRUCTOR} (): (𝓟[ty]2249{MetaSchema})
{
const 𝓟[ty]2249{MetaSchema};
const 𝓟[ty]2249{MetaSchema};
}
function 𝓟2245{parse} (𝓟2246{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2247: [OOV]𝓟[ty]2249{MetaSchema})
{
let 𝓟2248{result}: [OOV]𝓟[ty]2249{MetaSchema} = 𝓟2241{CONSTRUCTOR}();
𝓟2248{result}.validator ⟵ 𝓟2246{json}.getOrThrow(𝓛8743{String},𝓛8743{String});
𝓟2248{result}.compile ⟵ 𝓛8742{Function}.CONSTRUCTOR(𝓛8743{String},𝓟2246{json}.getOrThrow(𝓛8743{String},𝓛8743{String}).asString().value) as (𝓟[ty]2304{SchemaAPI})->𝓛[ty]10033{Void};
return 𝓟2247 = 𝓟2248{result}
}
class 𝓟[ty]2249{MetaSchema}{
𝓟2251{validator}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2252{compile}: 𝓛[ty]8696{Function};
function 𝓟2253{validate} (𝓟2254{data}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2255: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean}))
{
if (𝓟2163{debug_metaschema_validation})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2254{data}.toJSON())
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟[ty]2249{MetaSchema}.validator.toJSON())
}
let 𝓟2256{valid} = 𝓟2489{tv4}.validate(𝓟2254{data}.toJSON(),𝓟[ty]2249{MetaSchema}.validator.toJSON(),𝓛8744{Boolean},𝓛8744{Boolean});
if (𝓛12569{ExclamationToken}(𝓟2256{valid}))
{
𝓟2481{error}.validation(𝓟2254{data},𝓟[ty]2249{MetaSchema}.validator,𝓛8743{String},𝓛8743{String},𝓟2489{tv4}.error).source(𝓟2254{data}).on(𝓛8749{Error}.CONSTRUCTOR())
}
else
{
if (𝓟2163{debug_metaschema_validation})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
}
if (𝓛12637{ExclamationEqualsToken}(𝓟2489{tv4}.getMissingUris().length,𝓛8745{Number}))
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛8743{String},𝓟2489{tv4}.getMissingUris())).source(𝓟2254{data}).on(𝓛8749{Error}.CONSTRUCTOR())
}
return 𝓟2255 = 𝓟2256{valid}
}
}
function 𝓟2257{annotate_schema} (𝓟2258{node}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2259{parent}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2260{key}: 𝓛[ty]10051{String},𝓟2261{api}: [OOV]𝓟[ty]2304{SchemaAPI},𝓟2262{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2263: [OOV]𝓟[ty]2188{SchemaNode})
{
if (𝓟2258{node}.has(𝓛8743{String}))
{
𝓟2258{node} ⟵ 𝓟2284{fetchRef}(𝓟2258{node}.getOrThrow(𝓛8743{String},𝓛8743{String}).coerceString().value,𝓟2262{model});
if (𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟2260{key}.indexOf(𝓛8743{String}),𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2260{key}.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
𝓟2259{parent}.asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓟2260{key},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number})),𝓟2258{node})
}
else
{
𝓟2259{parent}.asObject().getOrThrow(𝓛8743{String},𝓛12641{PlusToken}(𝓛8743{String},𝓟2260{key})).asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓟2260{key},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number})),𝓟2258{node})
}
}
let 𝓟2264{annotation}: [OOV]𝓟[ty]2188{SchemaNode} = 𝓟2183{CONSTRUCTOR}(𝓟2258{node});
if (𝓟2258{node}.has(𝓛8743{String}))
{
function 𝓟2265{$Lambda18} (𝓟2266{name}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2267{child}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2268: [miss]𝓛[ty]10033{Void})
{
if (𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟2266{name}.value.indexOf(𝓛8743{String}),𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2266{name}.value.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
𝓟2481{error}.message(𝓛8743{String}).source(𝓟2266{name}).on(𝓛8749{Error}.CONSTRUCTOR())
}
𝓟2264{annotation}.properties.access(𝓟2266{name}.value) ⟵ 𝓟2257{annotate_schema}(𝓟2267{child},𝓟2258{node},𝓟2266{name}.getString(),𝓟2261{api},𝓟2262{model});
}
𝓟2258{node}.getOrThrow(𝓛8743{String},𝓛8743{String}).asObject().forEach(𝓟2265{$Lambda18})
}
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2258{node}.toJSON())
}
if (𝓟2332{getWildchild}(𝓟2258{node}))
{
let 𝓟2269{wildname} = 𝓟2332{getWildchild}(𝓟2258{node}).value;
let 𝓟2270{wildkey} = 𝓟2332{getWildchild}(𝓟2258{node});
𝓟2264{annotation}.properties.access(𝓟2269{wildname}) ⟵ 𝓟2257{annotate_schema}(𝓟2258{node}.getOrThrow(𝓟2269{wildname},𝓛8743{String}),𝓟2258{node},𝓟2269{wildname},𝓟2261{api},𝓟2262{model});
let 𝓟2271{patternProperties} = 𝓟2480{Json}.JObject.CONSTRUCTOR();
𝓟2258{node}.asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓛8743{String},𝓟2270{wildkey}.start.position,𝓟2270{wildkey}.end.position),𝓟2271{patternProperties})
𝓟2271{patternProperties}.put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓟2182{KEY_PATTERN},𝓛8745{Number},𝓛8745{Number}),𝓟2258{node}.getOrThrow(𝓟2269{wildname},𝓛8743{String}))
}
𝓟2261{api}.setContext(𝓟2258{node},𝓟2259{parent},𝓟2264{annotation},𝓟2262{model})
𝓟2264{annotation}.type ⟵ (𝓟2258{node}.has(𝓛8743{String}) ? 𝓟2258{node}.getOrThrow(𝓛8743{String},𝓛8743{String}).asString().value : 𝓛8743{String};
if (𝓛12569{ExclamationToken}(𝓟2258{node}.has(𝓛8743{String})))
{
𝓟2258{node}.asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓛8743{String},𝓛8745{Number},𝓛8745{Number}),𝓟2480{Json}.JString.CONSTRUCTOR(𝓛8743{String},𝓛8745{Number},𝓛8745{Number}))
}
𝓟2264{annotation}.additionalProperties ⟵ (𝓟2258{node}.has(𝓛8743{String}) ? 𝓟2258{node}.getOrThrow(𝓛8743{String},𝓛8743{String}).asBoolean().value : 𝓛8744{Boolean};
𝓟2264{annotation}.examples ⟵ (𝓟2258{node}.has(𝓛8743{String}) ? 𝓟2258{node}.asObject().getOrThrow(𝓛8743{String},𝓛8743{String}).asArray() : 𝓟2480{Json}.JArray.CONSTRUCTOR();
𝓟2264{annotation}.nonexamples ⟵ (𝓟2258{node}.has(𝓛8743{String}) ? 𝓟2258{node}.asObject().getOrThrow(𝓛8743{String},𝓛8743{String}).asArray() : 𝓟2480{Json}.JArray.CONSTRUCTOR();
𝓟2264{annotation}.indexOn ⟵ 𝓛8757{Array}();
if (𝓟2258{node}.has(𝓛8743{String}))
{
let 𝓟2272{index}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2258{node}.asObject().getOrThrow(𝓛8743{String},𝓛8743{String});
if (𝓛12599{EqualsEqualsToken}(𝓟2272{index}.type,𝓟2480{Json}.JType.JString))
{
𝓟2264{annotation}.indexOn ⟵ 𝓛8757{Array}(𝓟2272{index}.asString().value);
}
else
{
function 𝓟2273{$Lambda19} (𝓟2274{val}): (𝓟2275: [miss]𝓛[ty]10033{Void})
{
𝓟2264{annotation}.indexOn.push(𝓟2274{val}.asString().value)
}
𝓟2272{index}.asArray().forEach(𝓟2273{$Lambda19})
}
}
if (𝓛12637{ExclamationEqualsToken}(𝓟2261{api}.metaschema.access(𝓟2264{annotation}.type),𝓛12643{undefined}))
{
if (𝓟2261{api}.metaschema.access(𝓟2264{annotation}.type).validate(𝓟2258{node}))
{
𝓟2261{api}.metaschema.access(𝓟2264{annotation}.type).compile(𝓟2261{api})
}
else
{
𝓟2481{error}.validation(𝓟2258{node},𝓟2261{api}.metaschema.access(𝓟2264{annotation}.type).validator,𝓛8743{String},𝓛8743{String},𝓟2489{tv4}.error).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
else
{
𝓟2481{error}.source(𝓟2258{node}).message(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2264{annotation}.type),𝓛8743{String})).on(𝓛8749{Error}.CONSTRUCTOR())
}
𝓟2264{annotation}.constraint ⟵ 𝓟2486{expression}.Expression.parseUser(𝓟2258{node}.asObject().getOrThrow(𝓛8743{String},𝓛8743{String}).coerceString());
function 𝓟2276{$Lambda20} (𝓟2277{example}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2278: [miss]𝓛[ty]10033{Void})
{
let 𝓟2279{valid} = 𝓟2489{tv4}.validate(𝓟2277{example}.toJSON(),𝓟2258{node}.toJSON(),𝓛8744{Boolean},𝓛8744{Boolean});
if (𝓛12569{ExclamationToken}(𝓟2279{valid}))
{
𝓟2481{error}.validation(𝓟2277{example},𝓟2258{node},𝓛8743{String},𝓛8743{String},𝓟2489{tv4}.error).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
𝓟2264{annotation}.examples.forEach(𝓟2276{$Lambda20})
function 𝓟2280{$Lambda21} (𝓟2281{nonexample}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2282: [miss]𝓛[ty]10033{Void})
{
let 𝓟2283{valid} = 𝓟2489{tv4}.validate(𝓟2281{nonexample}.toJSON(),𝓟2258{node}.toJSON(),𝓛8744{Boolean},𝓛8744{Boolean});
if (𝓟2283{valid})
{
𝓟2481{error}.message(𝓛8743{String}).source(𝓟2281{nonexample}).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
𝓟2264{annotation}.nonexamples.forEach(𝓟2280{$Lambda21})
return 𝓟2263 = 𝓟2264{annotation}
}
function 𝓟2284{fetchRef} (𝓟2285{url}: 𝓛[ty]10051{String},𝓟2286{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2287: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2288{baseUrl}: [miss]𝓛[ty]10051{String} = 𝓟2285{url};
let 𝓟2289{fragment}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓛12616{MinusToken}(𝓛8745{Number})))
{
𝓟2289{fragment} ⟵ 𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓛8745{Number}));
𝓟2288{baseUrl} ⟵ 𝓛1{<UNKNOWN>}(𝓛8745{Number},𝓛1{<UNKNOWN>}(𝓛8743{String}));
}
let 𝓟2290{pointerPath}: [miss]𝓛[ty]10051{String} = 𝓛8726{decodeURIComponent}(𝓟2289{fragment});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟2290{pointerPath}.charAt(𝓛8745{Number}),𝓛8743{String}))
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛8743{String},𝓟2285{url})).on(𝓛8749{Error}.CONSTRUCTOR())
}
let 𝓟2291{parts}: [miss]𝓛[ty]8670{Array} = 𝓟2290{pointerPath}.split(𝓛8743{String}).slice(𝓛8745{Number});
let 𝓟2292{schema}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2286{model}.schema.json;
{
let 𝓟2293{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟2293{i},𝓟2291{parts}.length))
{
{
let 𝓟2294{component}: 𝓛[ty]10051{String} = 𝓟2291{parts}.access(𝓟2293{i}).replace(𝓛8748{RegExp},𝓛8743{String}).replace(𝓛8748{RegExp},𝓛8743{String});
𝓟2292{schema} ⟵ 𝓟2292{schema}.getOrThrow(𝓟2294{component},𝓛8757{Array}(𝓛8756{JSON}.stringify(𝓟2292{schema}.toJSON()),𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2294{component}),𝓛8743{String}),𝓟2290{pointerPath})).join(𝓛8743{String}));
}
𝓛12556{POST_PlusPlusToken}(𝓟2293{i})
}
}
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2285{url}),𝓛8743{String}),𝓛8756{JSON}.stringify(𝓟2292{schema}.toJSON())))
}
return 𝓟2287 = 𝓟2292{schema}
}
function 𝓟2295{CONSTRUCTOR} (): (𝓟[ty]2304{SchemaAPI})
{
const 𝓟[ty]2304{SchemaAPI};
const 𝓟[ty]2304{SchemaAPI};
𝓟[ty]2304{SchemaAPI}.metaschema ⟵ {};
let 𝓟2299{files}: [miss]𝓛[ty]8670{Array} = 𝓟1290{readdirSync}(𝓛12641{PlusToken}(𝓟2488{blaze}.root,𝓛8743{String}));
{
let 𝓟2300{i}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2299{files});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟2299{files}.hasOwnProperty(𝓟2300{i})))
{
}
let 𝓟2301{path}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟2488{blaze}.root,𝓛8743{String}),𝓛8743{String}),𝓟2299{files}.access(𝓟2300{i}));
let 𝓟2302{metaschema_def} = 𝓟2488{blaze}.load_yaml(𝓟2301{path});
let 𝓟2303{typename}: 𝓛[ty]10051{String} = 𝓟2302{metaschema_def}.getOrThrow(𝓛8743{String},𝓛12641{PlusToken}(𝓛8743{String},𝓟2301{path})).asString().value;
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2303{typename}),𝓛8743{String}),𝓟2301{path}))
𝓟[ty]2304{SchemaAPI}.metaschema.access(𝓟2303{typename}) ⟵ 𝓟2245{parse}(𝓟2302{metaschema_def});
}
}
}
class 𝓟[ty]2304{SchemaAPI}{
𝓟2306{parent}: [OOV]any;
𝓟2307{model}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2308{link}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2309{annotationInProgress}: [OOV]𝓟[ty]2188{SchemaNode};
𝓟2310{node}: [OOV]any;
𝓟2311{metaschema}: 𝓛[ty]8642{Object};
function 𝓟2321{addProperty} (𝓟2322{name}: 𝓛[ty]10051{String},𝓟2323{json}: [OOV]any): (𝓟2324: 𝓛[ty]10033{Void})
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
𝓟[ty]2304{SchemaAPI}.node.access(𝓟2322{name}) ⟵ 𝓟2323{json};
let 𝓟2325{extra_annotator}: [OOV]𝓟[ty]2304{SchemaAPI} = 𝓟2295{CONSTRUCTOR}();
𝓟2325{extra_annotator}.setContext(𝓟2323{json},𝓟[ty]2304{SchemaAPI}.node,𝓟[ty]2304{SchemaAPI}.annotationInProgress,𝓟[ty]2304{SchemaAPI}.model)
𝓟[ty]2304{SchemaAPI}.annotationInProgress.properties.access(𝓟2322{name}) ⟵ 𝓟2257{annotate_schema}(𝓟2323{json},𝓟[ty]2304{SchemaAPI}.node,𝓟2322{name},𝓟2325{extra_annotator},𝓟[ty]2304{SchemaAPI}.model);
}
function 𝓟2330{getWildchild} (): (𝓟2331: 𝓛[ty]10051{String})
{
return 𝓟2331 = 𝓟2332{getWildchild}(𝓟[ty]2304{SchemaAPI}.node).value
}
function 𝓟2326{getField} (𝓟2327{name}: 𝓛[ty]10051{String},𝓟2328{type}: 𝓛[ty]10051{String}): (𝓟2329: [OOV]any)
{
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2327{name},𝓛8743{String},𝓟[ty]2304{SchemaAPI}.node.access(𝓟2327{name}),𝓟[ty]2304{SchemaAPI}.node)
}
if (𝓛12599{EqualsEqualsToken}(𝓟[ty]2304{SchemaAPI}.node.access(𝓟2327{name}),𝓛12643{undefined}))
{
return 𝓟2329 = 𝓛12643{undefined}
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟2328{type},𝓛12643{undefined}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2328{type},𝓛8743{String}))
{
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓟2327{name},𝓛8743{String}).asArray().toJSON
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2328{type},𝓛8743{String}))
{
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓟2327{name},𝓛8743{String}).asObject().toJSON
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2328{type},𝓛8743{String}))
{
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓟2327{name},𝓛8743{String}).asString().toJSON
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2328{type},𝓛8743{String}))
{
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓟2327{name},𝓛8743{String}).asBoolean().toJSON
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟2328{type},𝓛8743{String}))
{
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓟2327{name},𝓛8743{String}).asNumber().toJSON
}
else
{
𝓟2481{error}.message(𝓛12641{PlusToken}(𝓛8743{String},𝓟2328{type})).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
}
}
}
}
return 𝓟2329 = 𝓟[ty]2304{SchemaAPI}.node.access(𝓟2327{name})
}
function 𝓟2312{setContext} (𝓟2313{node}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2314{parent}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2315{annotationInProgress}: [OOV]𝓟[ty]2188{SchemaNode},𝓟2316{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2317: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]2304{SchemaAPI}.link ⟵ 𝓟2313{node};
𝓟[ty]2304{SchemaAPI}.node ⟵ 𝓟[ty]2304{SchemaAPI}.link.toJSON();
𝓟[ty]2304{SchemaAPI}.parent ⟵ (𝓛12599{EqualsEqualsToken}(𝓟2314{parent},𝓛12643{undefined}) ? 𝓛12643{undefined} : 𝓟2314{parent}.toJSON();
𝓟[ty]2304{SchemaAPI}.annotationInProgress ⟵ 𝓟2315{annotationInProgress};
𝓟[ty]2304{SchemaAPI}.model ⟵ 𝓟2316{model};
}
function 𝓟2318{addConstraint} (𝓟2319{expression}: 𝓛[ty]10051{String}): (𝓟2320: 𝓛[ty]10033{Void})
{
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2319{expression}))
}
𝓟[ty]2304{SchemaAPI}.link.asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓛8743{String},𝓛8745{Number},𝓛8745{Number}),𝓟2480{Json}.JString.CONSTRUCTOR(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟[ty]2304{SchemaAPI}.link.getOrThrow(𝓛8743{String},𝓛8743{String}).coerceString().value),𝓛8743{String}),𝓟2319{expression}),𝓛8743{String}),𝓛8745{Number},𝓛8745{Number}))
}
}
function 𝓟2332{getWildchild} (𝓟2333{node}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2334: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2335{wildchild}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12643{undefined};
function 𝓟2336{$Lambda22} (𝓟2337{keyword}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2338{child}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2339: [miss]𝓛[ty]10033{Void})
{
let 𝓟2340{name}: 𝓛[ty]10051{String} = 𝓟2337{keyword}.value;
if (𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟2340{name}.indexOf(𝓛8743{String}),𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2340{name}.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
if (𝓛12599{EqualsEqualsToken}(𝓟2335{wildchild},𝓛12643{undefined}))
{
𝓟2335{wildchild} ⟵ 𝓟2337{keyword};
}
else
{
𝓟2481{error}.message(𝓛8743{String}).source(𝓟2333{node}).on(𝓛8749{Error}.CONSTRUCTOR())
}
}
}
𝓟2333{node}.asObject().forEach(𝓟2336{$Lambda22})
return 𝓟2334 = 𝓟2335{wildchild}
}
Module: src/blaze
𝓟147{require}(𝓛8743{String}).install()
let 𝓟2341{debug}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
function 𝓟2342{load_yaml} (𝓟2343{filepath}: 𝓛[ty]10051{String}): (𝓟2344: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2345{yaml_text}: [miss]𝓛[ty]10051{String} = 𝓟1383{readFileSync}(𝓟2343{filepath},{encoding: 𝓛8743{String}}).toString();
return 𝓟2344 = 𝓟2480{Json}.parse_yaml(𝓟2345{yaml_text})
}
function 𝓟2346{load_json} (𝓟2347{filepath}: 𝓛[ty]10051{String}): (𝓟2348: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2349{json_text}: [miss]𝓛[ty]10051{String} = 𝓟1383{readFileSync}(𝓟2347{filepath},{encoding: 𝓛8743{String}}).toString();
return 𝓟2348 = 𝓟2480{Json}.parse(𝓟2349{json_text})
}
function 𝓟2350{load_yaml_collection} (𝓟2351{filepath}: 𝓛[ty]10051{String},𝓟2352{cb}: 𝓛[ty]8696{Function}): (𝓟2353: 𝓛[ty]10033{Void})
{
let 𝓟2354{yaml_text}: [miss]𝓛[ty]10051{String} = 𝓟1383{readFileSync}(𝓟2351{filepath},{encoding: 𝓛8743{String}}).toString();
𝓟2480{Json}.parse_yaml_collection(𝓟2354{yaml_text},𝓟2352{cb})
}
let 𝓟2355{root}: 𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟1492{dirname}(𝓟1250{realpathSync}(𝓟122{__filename})),𝓛8743{String});
let 𝓟2356{rules_schema}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2342{load_yaml}(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String}));
function 𝓟2357{validate_rules} (𝓟2358{rules}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2359: 𝓛[ty]8666{Boolean})
{
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓛12552{this}.load_yaml(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String})).toJSON())
𝓟2489{tv4}.addSchema(𝓛8743{String},𝓟1383{readFileSync}(𝓛12641{PlusToken}(𝓟2355{root},𝓛8743{String}),{encoding: 𝓛8743{String}}).toString())
let 𝓟2360{valid}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean}) = 𝓟2489{tv4}.validate(𝓟2358{rules}.toJSON(),𝓛12552{this}.rules_schema.toJSON(),𝓛8744{Boolean},𝓛8744{Boolean});
if (𝓛12569{ExclamationToken}(𝓟2360{valid}))
{
𝓟2481{error}.validation(𝓟2358{rules},𝓛12552{this}.rules_schema,𝓛8743{String},𝓛8743{String},𝓟2489{tv4}.error).source(𝓟2358{rules}.lookup(𝓟2489{tv4}.error.dataPath.split(𝓛8743{String}))).on(𝓛8749{Error}.CONSTRUCTOR())
}
if (𝓛12637{ExclamationEqualsToken}(𝓟2489{tv4}.getMissingUris().length,𝓛8745{Number}))
{
𝓟2481{error}.missingURI(𝓟2489{tv4}.getMissingUris()).on(𝓛8749{Error}.CONSTRUCTOR())
}
return 𝓟2359 = 𝓟2360{valid}
}
function 𝓟2361{CONSTRUCTOR} (𝓟2362{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟[ty]2369{SchemaRoot})
{
const 𝓟[ty]2369{SchemaRoot};
const 𝓟[ty]2369{SchemaRoot};
𝓟[ty]2369{SchemaRoot}.json ⟵ 𝓟2362{json};
}
function 𝓟2366{parse} (𝓟2367{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2368: [OOV]𝓟[ty]2369{SchemaRoot})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2367{json},𝓛12643{undefined}))
{
𝓟2367{json} ⟵ 𝓟2480{Json}.JObject.CONSTRUCTOR();
}
return 𝓟2368 = 𝓟2361{CONSTRUCTOR}(𝓟2367{json})
}
class 𝓟[ty]2369{SchemaRoot}{
𝓟2371{json}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2372{root}: [OOV]𝓛[ty]2{<UNKNOWN>};
}
function 𝓟2373{CONSTRUCTOR} (): (𝓟[ty]2381{AccessEntry})
{
const 𝓟[ty]2381{AccessEntry};
const 𝓟[ty]2381{AccessEntry};
𝓟[ty]2381{AccessEntry}.write ⟵ 𝓟2486{expression}.Expression.FALSE;
𝓟[ty]2381{AccessEntry}.read ⟵ 𝓟2486{expression}.Expression.FALSE;
}
function 𝓟2377{parse} (𝓟2378{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2379: [OOV]𝓟[ty]2381{AccessEntry})
{
let 𝓟2380{accessEntry}: [OOV]𝓟[ty]2381{AccessEntry} = 𝓟2373{CONSTRUCTOR}();
𝓟2380{accessEntry}.location ⟵ 𝓟2378{json}.getOrThrow(𝓛8743{String},𝓛8743{String}).asString().value.split(𝓛8743{String});
while (𝓛12559{EqualsEqualsEqualsToken}(𝓟2380{accessEntry}.location.access(𝓛8745{Number}),𝓛8743{String}))
{
𝓟2380{accessEntry}.location.shift()
}
if (𝓛12599{EqualsEqualsToken}(𝓟2380{accessEntry}.location.access(𝓛12616{MinusToken}(𝓟2380{accessEntry}.location.length,𝓛8745{Number})),𝓛8743{String}))
{
𝓟2380{accessEntry}.location.pop()
}
if (𝓟2378{json}.has(𝓛8743{String}))
{
𝓟2380{accessEntry}.read ⟵ 𝓟2486{expression}.Expression.parseUser(𝓟2378{json}.getOrThrow(𝓛8743{String},𝓛8743{String}).coerceString());
}
if (𝓟2378{json}.has(𝓛8743{String}))
{
𝓟2380{accessEntry}.write ⟵ 𝓟2486{expression}.Expression.parseUser(𝓟2378{json}.getOrThrow(𝓛8743{String},𝓛8743{String}).coerceString());
}
return 𝓟2379 = 𝓟2380{accessEntry}
}
class 𝓟[ty]2381{AccessEntry}{
𝓟2383{location}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟2384{read}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2385{write}: [OOV]𝓛[ty]2{<UNKNOWN>};
function 𝓟2390{isChildOf} (𝓟2391{location}: 𝓛[ty]8670{Array}): (𝓟2392: 𝓛[ty]8666{Boolean})
{
if (𝓛12582{LessThanEqualsToken}(𝓟[ty]2381{AccessEntry}.location.length,𝓟2391{location}.length))
{
return 𝓟2392 = 𝓛8744{Boolean}
}
{
let 𝓟2393{idx}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟2391{location});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]2381{AccessEntry}.matchSegment(𝓟[ty]2381{AccessEntry}.location.access(𝓟2393{idx}),𝓟2391{location}.access(𝓟2393{idx}))))
{
return 𝓟2392 = 𝓛8744{Boolean}
}
}
}
return 𝓟2392 = 𝓛8744{Boolean}
}
function 𝓟2405{getWriteFor} (𝓟2406{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2407{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2408: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2409{base_write}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Expression.parse(𝓟[ty]2381{AccessEntry}.write.expandFunctions(𝓟2406{symbols}));
{
let 𝓟2410{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟2410{i},𝓛12616{MinusToken}(𝓛1{<UNKNOWN>},𝓟[ty]2381{AccessEntry}.location.length)))
{
{
𝓟2409{base_write} ⟵ 𝓟2486{expression}.Expression.parse(𝓟2409{base_write}.rewriteForChild());
}
𝓛12556{POST_PlusPlusToken}(𝓟2410{i})
}
}
return 𝓟2408 = 𝓟2409{base_write}
}
function 𝓟2394{matchSegment} (𝓟2395{rule_segment}: 𝓛[ty]10051{String},𝓟2396{path_segment}): (𝓟2397: 𝓛[ty]8666{Boolean})
{
if (𝓛12599{EqualsEqualsToken}(𝓟2395{rule_segment}.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
𝓟2395{rule_segment} ⟵ 𝓟2395{rule_segment}.substr(𝓛8745{Number});
}
if (𝓛12599{EqualsEqualsToken}(𝓟2396{path_segment}.indexOf(𝓛8743{String}),𝓛8745{Number}))
{
𝓟2396{path_segment} ⟵ 𝓟2396{path_segment}.substr(𝓛8745{Number});
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12599{EqualsEqualsToken}(𝓟2395{rule_segment}.indexOf(𝓛8743{String}),𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2396{path_segment}.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
return 𝓟2397 = 𝓛8744{Boolean}
}
return 𝓟2397 = 𝓛12599{EqualsEqualsToken}(𝓟2395{rule_segment},𝓟2396{path_segment})
}
function 𝓟2398{getReadFor} (𝓟2399{symbols}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2400{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2401: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟2402{base_read}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2486{expression}.Expression.parse(𝓟[ty]2381{AccessEntry}.read.expandFunctions(𝓟2399{symbols}));
{
let 𝓟2403{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟2403{i},𝓛12616{MinusToken}(𝓛1{<UNKNOWN>},𝓟[ty]2381{AccessEntry}.location.length)))
{
{
let 𝓟2404{rewrite}: [miss]𝓛[ty]10051{String} = 𝓟2402{base_read}.rewriteForChild();
𝓟2402{base_read} ⟵ 𝓟2486{expression}.Expression.parse(𝓟2404{rewrite});
}
𝓛12556{POST_PlusPlusToken}(𝓟2403{i})
}
}
return 𝓟2401 = 𝓟2402{base_read}
}
function 𝓟2386{match} (𝓟2387{location}: 𝓛[ty]8670{Array}): (𝓟2388: 𝓛[ty]8666{Boolean})
{
if (𝓛12595{GreaterThanToken}(𝓟[ty]2381{AccessEntry}.location.length,𝓟2387{location}.length))
{
return 𝓟2388 = 𝓛8744{Boolean}
}
{
let 𝓟2389{idx}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]2381{AccessEntry}.location);
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]2381{AccessEntry}.matchSegment(𝓟[ty]2381{AccessEntry}.location.access(𝓟2389{idx}),𝓟2387{location}.access(𝓟2389{idx}))))
{
return 𝓟2388 = 𝓛8744{Boolean}
}
}
}
return 𝓟2388 = 𝓛8744{Boolean}
}
}
function 𝓟2411{CONSTRUCTOR} (): (𝓟[ty]2431{Access})
{
const 𝓟[ty]2431{Access};
const 𝓟[ty]2431{Access};
}
function 𝓟2415{parse} (𝓟2416{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2417: [OOV]𝓟[ty]2431{Access})
{
let 𝓟2418{access}: [OOV]𝓟[ty]2431{Access} = 𝓟2411{CONSTRUCTOR}();
if (𝓛12599{EqualsEqualsToken}(𝓟2416{json},𝓛12643{undefined}))
{
return 𝓟2417 = 𝓟2418{access}
}
function 𝓟2419{$Lambda0} (𝓟2420{entry}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2421{id}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟2422: [miss]𝓛[ty]10033{Void})
{
let 𝓟2423{accessEntry}: [OOV]𝓟[ty]2381{AccessEntry} = 𝓟2377{parse}(𝓟2420{entry});
𝓟2418{access}.access(𝓟2421{id}) ⟵ 𝓟2423{accessEntry};
}
𝓟2416{json}.asArray().forEachIndexed(𝓟2419{$Lambda0})
return 𝓟2417 = 𝓟2418{access}
}
function 𝓟2424{getChildren} (𝓟2425{self}: [OOV]𝓟[ty]2431{Access},𝓟2426{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2427: 𝓛[ty]8670{Array})
{
let 𝓟2428{children}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟2429{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛12637{ExclamationEqualsToken}(𝓟2425{self}.access(𝓟2429{i}),𝓛12643{undefined}))
{
{
let 𝓟2430{rule}: [OOV]𝓟[ty]2381{AccessEntry} = 𝓟2425{self}.access(𝓟2429{i});
if (𝓟2430{rule}.isChildOf(𝓟2426{path}))
{
𝓟2428{children}.push(𝓟2430{rule})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟2429{i})
}
}
return 𝓟2427 = 𝓟2428{children}
}
class 𝓟[ty]2431{Access}{
}
function 𝓟2433{CONSTRUCTOR} (): (𝓟[ty]2441{Rules})
{
const 𝓟[ty]2441{Rules};
const 𝓟[ty]2441{Rules};
𝓟[ty]2441{Rules}.code ⟵ 𝓛12643{undefined};
}
function 𝓟2437{parse} (𝓟2438{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2439: [OOV]𝓟[ty]2441{Rules})
{
let 𝓟2440{rules}: [OOV]𝓟[ty]2441{Rules} = 𝓟2433{CONSTRUCTOR}();
𝓟2440{rules}.functions ⟵ 𝓟2486{expression}.Functions.parse(𝓟2438{json}.getOrNull(𝓛8743{String}));
𝓟2440{rules}.schema ⟵ 𝓟2366{parse}(𝓟2438{json}.getOrNull(𝓛8743{String}));
𝓟2440{rules}.access ⟵ 𝓟2415{parse}(𝓟2438{json}.getOrWarn(𝓛8743{String},𝓛8743{String}));
return 𝓟2439 = 𝓟2440{rules}
}
class 𝓟[ty]2441{Rules}{
𝓟2443{functions}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟2444{schema}: [OOV]𝓟[ty]2369{SchemaRoot};
𝓟2445{access}: [OOV]𝓟[ty]2431{Access};
𝓟2446{code}: 𝓛[ty]10051{String};
function 𝓟2447{inflateSchema} (): (𝓟2448: 𝓛[ty]10033{Void})
{
𝓟[ty]2441{Rules}.inflateSchemaRecursive(𝓟[ty]2441{Rules}.schema.json.asObject(),𝓛8757{Array}(),{})
}
function 𝓟2449{inflateSchemaRecursive} (𝓟2450{json}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2451{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟2452{memoization}: 𝓛[ty]8642{Object}): (𝓟2453: 𝓛[ty]10033{Void})
{
if (𝓟2452{memoization}.access(𝓟1455{join}(𝓛8743{String})))
{
}
else
{
𝓟2452{memoization}.access(𝓟1455{join}(𝓛8743{String})) ⟵ 𝓛8744{Boolean};
}
let 𝓟2454{children}: [miss]𝓛[ty]8670{Array} = 𝓟2424{getChildren}(𝓟[ty]2441{Rules}.access,𝓟2451{path});
function 𝓟2455{$Lambda1} (𝓟2456{child}: [OOV]𝓟[ty]2381{AccessEntry}): (𝓟2457: [miss]𝓛[ty]10033{Void})
{
let 𝓟2458{childSegment}: [miss]𝓛[ty]10051{String} = 𝓟2456{child}.location.access(𝓛1{<UNKNOWN>});
let 𝓟2459{schemaChild} = 𝓛12643{undefined};
if (𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟2458{childSegment}.indexOf(𝓛8743{String}),𝓛8745{Number}),𝓛12599{EqualsEqualsToken}(𝓟2458{childSegment}.indexOf(𝓛8743{String}),𝓛8745{Number})))
{
let 𝓟2460{wildKey} = 𝓟2484{schema}.getWildchild(𝓟2450{json});
if (𝓛12599{EqualsEqualsToken}(𝓟2460{wildKey},𝓛12643{undefined}))
{
𝓟2459{schemaChild} ⟵ 𝓟2480{Json}.JObject.CONSTRUCTOR();
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2456{child}.location.join(𝓛8743{String})),𝓛8743{String}))
𝓟2450{json}.put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓟2458{childSegment},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number})),𝓟2459{schemaChild})
}
else
{
𝓟2459{schemaChild} ⟵ 𝓟2450{json}.getOrThrow(𝓟2460{wildKey}.getString(),𝓛8743{String});
}
}
else
{
let 𝓟2461{properties} = 𝓟2450{json}.getOrNull(𝓛8743{String});
if (𝓛12599{EqualsEqualsToken}(𝓟2461{properties},𝓛12643{undefined}))
{
𝓟2461{properties} ⟵ 𝓟2480{Json}.JObject.CONSTRUCTOR();
𝓟2450{json}.put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓛8743{String},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number})),𝓟2461{properties})
}
𝓟2459{schemaChild} ⟵ 𝓟2461{properties}.asObject().getOrNull(𝓟2458{childSegment});
if (𝓛12599{EqualsEqualsToken}(𝓟2459{schemaChild},𝓛12643{undefined}))
{
𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓟2456{child}.location.join(𝓛8743{String})),𝓛8743{String}))
𝓟2459{schemaChild} ⟵ 𝓟2480{Json}.JObject.CONSTRUCTOR();
𝓟2461{properties}.asObject().put(𝓟2480{Json}.JString.CONSTRUCTOR(𝓟2458{childSegment},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number})),𝓟2459{schemaChild})
}
}
𝓟[ty]2441{Rules}.inflateSchemaRecursive(𝓟2459{schemaChild},𝓟2456{child}.location.slice(𝓛8745{Number},𝓛12641{PlusToken}(𝓛1{<UNKNOWN>},𝓛8745{Number})),𝓟2452{memoization})
}
𝓟2454{children}.map(𝓟2455{$Lambda1},𝓟[ty]2441{Rules})
}
}
Module: src/globals
let 𝓟2462{optimize}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
let 𝓟2463{debug}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
Module: src/compiler
𝓟147{require}(𝓛8743{String}).install()
function 𝓟2464{compileJSON} (𝓟2465{json}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟2466: [OOV]𝓛[ty]2{<UNKNOWN>})
{
{
let 𝓟2467{ok}: [miss]𝓛[ty]8666{Boolean} = 𝓟2488{blaze}.validate_rules(𝓟2465{json});
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓛8756{JSON}.stringify(𝓟2465{json}.toJSON()))
}
let 𝓟2468{model}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2488{blaze}.Rules.parse(𝓟2465{json}.asObject());
𝓟2468{model}.inflateSchema()
𝓟2484{schema}.annotate(𝓟2468{model})
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2468{model}.schema.root)
}
𝓟2484{schema}.pushDownConstraints(𝓟2468{model})
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2468{model}.schema.root)
}
𝓟2484{schema}.pullUpConstraints(𝓟2468{model})
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2468{model}.schema.root)
}
𝓟2484{schema}.combineACL(𝓟2468{model})
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2468{model}.schema.root)
}
let 𝓟2469{code}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String}) = 𝓟2484{schema}.generateRules(𝓟2468{model});
if (𝓟2483{globals}.debug)
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓟2469{code})
}
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟1398{writeFileSync}(𝓛8743{String},𝓟2469{code})
𝓟2468{model}.code ⟵ 𝓟2469{code};
return 𝓟2466 = 𝓟2468{model}
}
}
function 𝓟2470{compile} (𝓟2471{path}: 𝓛[ty]10051{String},𝓟2472{debug}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8666{Boolean})): (𝓟2473: [OOV]𝓛[ty]2{<UNKNOWN>})
{
𝓟2483{globals}.debug ⟵ 𝓟2472{debug};
if (𝓛12599{EqualsEqualsToken}(𝓛1{<UNKNOWN>}(𝓛12616{MinusToken}(𝓛1{<UNKNOWN>},𝓛8745{Number})),𝓛8743{String}))
{
let 𝓟2474{json}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2488{blaze}.load_json(𝓟2471{path});
}
else
{
let 𝓟2475{json}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2488{blaze}.load_yaml(𝓟2471{path});
}
return 𝓟2473 = 𝓟2464{compileJSON}(𝓟2475{json})
}
Module: src/cli
𝓟147{require}(𝓛8743{String}).install()
let 𝓟2476{configured_optimist} = 𝓟147{require}(𝓛8743{String}).usage(𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}).join(𝓛8743{String})).boolean(𝓛8743{String}).describe(𝓛8743{String},𝓛8743{String}).boolean(𝓛8743{String});
let 𝓟2477{argv} = 𝓟2476{configured_optimist}.argv;
let 𝓟2478{file} = 𝓟2477{argv}._.access(𝓛8745{Number});
if (𝓟2478{file})
{
if (𝓟2477{argv}.access(𝓛8743{String}))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2477{argv})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2478{file})
let 𝓟2479{model}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟2491{compiler}.compile(𝓟2478{file},𝓟2477{argv}.access(𝓛8743{String}));
if (𝓟2477{argv}.access(𝓛8743{String}))
{
𝓟147{require}(𝓛8743{String}).generate(𝓟2479{model},𝓟2477{argv}.access(𝓛8743{String}))
}
}
else
{
𝓟2476{configured_optimist}.showHelp()
}