@wener/utils 1.1.48 → 1.1.50

package/lib/schema/typebox/gen/codegen/expression/compiler.js

@@ -1,364 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-expression
-
-The MIT License (MIT)
-
-Copyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/ import { Hash } from '@sinclair/typebox/value';
-var MemberAccessor;
-// --------------------------------------------------------------------------
-// PropertyFormatter
-// --------------------------------------------------------------------------
-(function(MemberAccessor) {
-    function DollarSign(code) {
-        return code === 36;
-    }
-    function Underscore(code) {
-        return code === 95;
-    }
-    function Numeric(code) {
-        return code >= 48 && code <= 57;
-    }
-    function Alpha(code) {
-        return code >= 65 && code <= 90 || code >= 97 && code <= 122;
-    }
-    function IsDot(propertyName) {
-        if (propertyName.length === 0) return false;
-        {
-            const code = propertyName.charCodeAt(0);
-            if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
-                return false;
-            }
-        }
-        for(let i = 1; i < propertyName.length; i++){
-            const code = propertyName.charCodeAt(i);
-            if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    MemberAccessor.IsDot = IsDot;
-})(MemberAccessor || (MemberAccessor = {}));
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-export class UnknownExpressionError extends Error {
-    expression;
-    constructor(expression){
-        super('Unknown Expression Detected');
-        this.expression = expression;
-    }
-}
-export class ReferencedExpressionNotFound extends Error {
-    expression;
-    constructor(expression){
-        super('Referenced Expression Not Found');
-        this.expression = expression;
-    }
-}
-// --------------------------------------------------------------------------
-// ExpressionCheck
-// --------------------------------------------------------------------------
-export class ExpressionCheck {
-    check;
-    locals;
-    code;
-    constructor(check, locals, code){
-        this.check = check;
-        this.locals = locals;
-        this.code = code;
-    }
-    Code() {
-        return this.code;
-    }
-    Check(value) {
-        return this.check(value);
-    }
-    Locals() {
-        return this.locals;
-    }
-}
-export var ExpressionCompiler;
-(function(ExpressionCompiler) {
-    function And(expression, value) {
-        return `(${expression.expr.map((expression)=>Visit(expression, `${value}`)).join(' && ')})`;
-    }
-    function Call(expression, value) {
-        return Visit(expression.expr, `${value}.${expression.target}(...${SetExtern(expression.parameters)})`);
-    }
-    function ElementsDistinct(expression, value) {
-        return `((array) => { const set = new Set(); for (const value of array) { const hash = __hash(value); if (set.has(hash)) return false; set.add(hash) } return true })(${value})`;
-    }
-    function Elements(expression, value) {
-        return `${value}.every((value) => ${Visit(expression.expr, 'value')})`;
-    }
-    function Equals(expression, value) {
-        return typeof expression.value === 'string' ? `${value} === '${expression.value}'` : `${value} === ${expression.value}`;
-    }
-    function False(expression, value) {
-        return `false`;
-    }
-    function Function(expression, value) {
-        return `${SetExtern(expression.callback)}(${value})`;
-    }
-    function GreaterThan(expression, value) {
-        return `${value} > ${expression.value}`;
-    }
-    function GreaterThanEqual(expression, value) {
-        return `${value} >= ${expression.value}`;
-    }
-    function IfThenElse(expression, value) {
-        return `(${Visit(expression.if, `${value}`)}) ? (${Visit(expression.then, `${value}`)}) : (${Visit(expression.else, `${value}`)})`;
-    }
-    function Index(expression, value) {
-        return Visit(expression.expr, `${value}[${expression.index}]`);
-    }
-    function InstanceOf(expression, value) {
-        return `${value} instanceof ${expression.value}`;
-    }
-    function IsArray(expression, value) {
-        return `Array.isArray(${value})`;
-    }
-    function IsFinite(expression, value) {
-        return `Number.isFinite(${value})`;
-    }
-    function IsInteger(expression, value) {
-        return `Number.isInteger(${value})`;
-    }
-    function IsNaN(expression, value) {
-        return `Number.isNaN(${value})`;
-    }
-    function IsSafeInteger(expression, value) {
-        return `${value} === undefined`;
-    }
-    function IsUndefined(expression, value) {
-        return `Number.isSafeInteger(${value})`;
-    }
-    function LessThan(expression, value) {
-        return `${value} < ${expression.value}`;
-    }
-    function LessThanEqual(expression, value) {
-        return `${value} <= ${expression.value}`;
-    }
-    function MultipleOf(expression, value) {
-        return `${value} % ${expression.value} === 0`;
-    }
-    function Not(expression, value) {
-        return `!(${Visit(expression.expr, value)})`;
-    }
-    function Or(expression, value) {
-        return `(${expression.expr.map((expression)=>Visit(expression, `${value}`)).join(' || ')})`;
-    }
-    function PropertiesExclude(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).every((key) => !${SetExtern(expression.keys)}.includes(key) ? ${Visit(expression.expr, `${value}[key]`)} : true)`;
-    }
-    function PropetiesExcludePattern(expression, value) {
-        const local = SetLocal(`new RegExp(/${expression.pattern}/)`);
-        return `Object.getOwnPropertyNames(${value}).every((key) => !${local}.test(key) ? ${Visit(expression.expr, `${value}[key]`)} : true)`;
-    }
-    function PropertiesInclude(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).every((key) => ${SetExtern(expression.keys)}.includes(key) ? ${Visit(expression.expr, `${value}[key]`)} : true)`;
-    }
-    function PropertiesIncludePattern(expression, value) {
-        const local = SetLocal(`new RegExp(/${expression.pattern}/)`);
-        return `Object.getOwnPropertyNames(${value}).every((key) => ${local}.test(key) ? ${Visit(expression.expr, `${value}[key]`)} : true)`;
-    }
-    function PropertiesLength(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).length === ${expression.value}`;
-    }
-    function PropertiesMaximum(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).length <= ${expression.value}`;
-    }
-    function PropertiesMinimum(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).length >= ${expression.value}`;
-    }
-    function Properties(expression, value) {
-        return `Object.getOwnPropertyNames(${value}).every((key) => ${Visit(expression.expr, `${value}[key]`)})`;
-    }
-    function PropertyKeys(expression, value) {
-        const keys = expression.keys.map((key)=>`'${key}'`).join(', ');
-        return `((value) => { const keys = Object.getOwnPropertyNames(value); return [${keys}].every((key) => keys.includes(key)); })(${value})`;
-    }
-    function Property(expression, value) {
-        return MemberAccessor.IsDot(expression.key) ? Visit(expression.expr, `${value}.${expression.key}`) : Visit(expression.expr, `${value}['${expression.key}']`);
-    }
-    function IsPattern(expression, value) {
-        const local = SetLocal(`new RegExp(/${expression.pattern}/)`);
-        return `${local}.test(${value})`;
-    }
-    function Ref(expression, value) {
-        if (!reference_map.has(expression.$ref)) throw new ReferencedExpressionNotFound(expression);
-        // Ref: All referenced expressions are hoisted into their own functions. We track a dictionary of
-        // function names and compiled expressions here which is later emitted when generating the module.
-        // If the function doesn't exist, build and just return the check_T() call.
-        if (!function_map.has(expression.$ref)) {
-            function_map.set(expression.$ref, ''); // terminate recursion
-            const reference = reference_map.get(expression.$ref);
-            function_map.set(expression.$ref, Visit(reference, 'value'));
-        }
-        return `check_${expression.$ref}(${value})`;
-    }
-    function True(expression, value) {
-        return `true`;
-    }
-    function TypeOf(expression, value) {
-        return `typeof ${value} === '${expression.value}'`;
-    }
-    function Visit(expression, value) {
-        // Root and Recursive: All expressions with $ids are hoisted into their own functions. Here we check
-        // if we have observed the $id before, and if not, generate the function and return check_T(). This
-        // only occurs for discovered references which are typical of recursive expressions, but may also
-        // include the Root expression if it has been specified with an $id.
-        if (expression.$id !== undefined && !reference_map.has(expression.$id)) {
-            reference_map.set(expression.$id, expression);
-            const reference = reference_map.get(expression.$id);
-            function_map.set(expression.$id, Visit(reference, 'value'));
-            return `check_${expression.$id}(${value})`;
-        }
-        switch(expression.type){
-            case 'And':
-                return And(expression, value);
-            case 'Call':
-                return Call(expression, value);
-            case 'ElementsDistinct':
-                return ElementsDistinct(expression, value);
-            case 'Elements':
-                return Elements(expression, value);
-            case 'Equals':
-                return Equals(expression, value);
-            case 'False':
-                return False(expression, value);
-            case 'Function':
-                return Function(expression, value);
-            case 'GreaterThanEqual':
-                return GreaterThanEqual(expression, value);
-            case 'GreaterThan':
-                return GreaterThan(expression, value);
-            case 'IfThenElse':
-                return IfThenElse(expression, value);
-            case 'InstanceOf':
-                return InstanceOf(expression, value);
-            case 'Index':
-                return Index(expression, value);
-            case 'IsArray':
-                return IsArray(expression, value);
-            case 'IsFinite':
-                return IsFinite(expression, value);
-            case 'IsInteger':
-                return IsInteger(expression, value);
-            case 'IsNaN':
-                return IsNaN(expression, value);
-            case 'IsPattern':
-                return IsPattern(expression, value);
-            case 'IsSafeInteger':
-                return IsSafeInteger(expression, value);
-            case 'IsUndefined':
-                return IsUndefined(expression, value);
-            case 'LessThan':
-                return LessThan(expression, value);
-            case 'LessThanEqual':
-                return LessThanEqual(expression, value);
-            case 'MultipleOf':
-                return MultipleOf(expression, value);
-            case 'Not':
-                return Not(expression, value);
-            case 'Or':
-                return Or(expression, value);
-            case 'PropertiesInclude':
-                return PropertiesInclude(expression, value);
-            case 'PropertiesIncludePattern':
-                return PropertiesIncludePattern(expression, value);
-            case 'PropertiesExclude':
-                return PropertiesExclude(expression, value);
-            case 'PropertiesExcludePattern':
-                return PropetiesExcludePattern(expression, value);
-            case 'PropertiesLength':
-                return PropertiesLength(expression, value);
-            case 'PropertiesMaximum':
-                return PropertiesMaximum(expression, value);
-            case 'PropertiesMinimum':
-                return PropertiesMinimum(expression, value);
-            case 'Properties':
-                return Properties(expression, value);
-            case 'PropertyKeys':
-                return PropertyKeys(expression, value);
-            case 'Property':
-                return Property(expression, value);
-            case 'Ref':
-                return Ref(expression, value);
-            case 'True':
-                return True(expression, value);
-            case 'TypeOf':
-                return TypeOf(expression, value);
-            default:
-                throw new UnknownExpressionError(expression);
-        }
-    }
-    // -------------------------------------------------------
-    // Compiler State
-    // -------------------------------------------------------
-    function SetLocal(code) {
-        const key = `local_${local_map.size}`;
-        local_map.set(key, code);
-        return key;
-    }
-    function SetExtern(value) {
-        const key = `extern_${extern_map.size}`;
-        extern_map.set(key, value);
-        return key;
-    }
-    const reference_map = new Map();
-    const function_map = new Map();
-    const extern_map = new Map();
-    const local_map = new Map();
-    function Compile(expression, references = []) {
-        reference_map.clear();
-        function_map.clear();
-        extern_map.clear();
-        local_map.clear();
-        for (const reference of references){
-            if (reference.$id === undefined) continue;
-            reference_map.set(reference.$id, reference);
-        }
-        const root = `return function check(value) { return ${Visit(expression, 'value')} }`;
-        const funcs = [
-            ...function_map.entries()
-        ].map(([key, body])=>`function check_${key}(value) { return ${body} }`);
-        const locals = [
-            ...local_map.entries()
-        ].map(([key, code])=>`const ${key} = ${code}`);
-        const check_module = [
-            ...locals,
-            ...funcs,
-            root
-        ].join('\n');
-        // generate bootstrap
-        const bootstrap = new globalThis.Function('__hash', ...extern_map.keys(), check_module);
-        const check = bootstrap((value)=>Hash(value), ...extern_map.values());
-        return new ExpressionCheck(check, new Map(extern_map), check_module);
-    }
-    /** Compiles an expression and associated references to target V8 hidden class optimizations */ ExpressionCompiler.Compile = Compile;
-})(ExpressionCompiler || (ExpressionCompiler = {}));
-
-//# sourceMappingURL=compiler.js.map

package/lib/schema/typebox/gen/codegen/expression/compiler.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/expression/compiler.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-expression\n\nThe MIT License (MIT)\n\nCopyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\nimport { Hash } from '@sinclair/typebox/value';\nimport * as Expr from './expression';\n\n// --------------------------------------------------------------------------\n// PropertyFormatter\n// --------------------------------------------------------------------------\n\nnamespace MemberAccessor {\n  function DollarSign(code: number) {\n    return code === 36;\n  }\n  function Underscore(code: number) {\n    return code === 95;\n  }\n  function Numeric(code: number) {\n    return code >= 48 && code <= 57;\n  }\n  function Alpha(code: number) {\n    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);\n  }\n  export function IsDot(propertyName: string) {\n    if (propertyName.length === 0) return false;\n    {\n      const code = propertyName.charCodeAt(0);\n      if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {\n        return false;\n      }\n    }\n    for (let i = 1; i < propertyName.length; i++) {\n      const code = propertyName.charCodeAt(i);\n      if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n// --------------------------------------------------------------------------\n// Errors\n// --------------------------------------------------------------------------\n\nexport class UnknownExpressionError extends Error {\n  constructor(public readonly expression: unknown) {\n    super('Unknown Expression Detected');\n  }\n}\nexport class ReferencedExpressionNotFound extends Error {\n  constructor(public readonly expression: unknown) {\n    super('Referenced Expression Not Found');\n  }\n}\n// --------------------------------------------------------------------------\n// ExpressionCheck\n// --------------------------------------------------------------------------\n\nexport class ExpressionCheck {\n  constructor(\n    private readonly check: (value: unknown) => boolean,\n    private readonly locals: Map<string, unknown>,\n    private readonly code: string,\n  ) {}\n  public Code(): string {\n    return this.code;\n  }\n  public Check(value: unknown): boolean {\n    return this.check(value);\n  }\n  public Locals(): Map<string, unknown> {\n    return this.locals;\n  }\n}\n\n// --------------------------------------------------------------------------\n// ExpressionCheckCompiler\n// --------------------------------------------------------------------------\n\nexport namespace ExpressionCompiler {\n  function And(expression: Expr.AndExpression, value: string): string {\n    return `(${expression.expr.map((expression) => Visit(expression, `${value}`)).join(' && ')})`;\n  }\n  function Call(expression: Expr.CallExpression, value: string): string {\n    return Visit(expression.expr, `${value}.${expression.target}(...${SetExtern(expression.parameters)})`);\n  }\n  function ElementsDistinct(expression: Expr.ElementsDistinctExpression, value: string): string {\n    return `((array) => { const set = new Set(); for (const value of array) { const hash = __hash(value); if (set.has(hash)) return false; set.add(hash) } return true })(${value})`;\n  }\n  function Elements(expression: Expr.ElementsExpression, value: string): string {\n    return `${value}.every((value) => ${Visit(expression.expr, 'value')})`;\n  }\n  function Equals(expression: Expr.EqualsExpression, value: string): string {\n    return typeof expression.value === 'string'\n      ? `${value} === '${expression.value}'`\n      : `${value} === ${expression.value}`;\n  }\n  function False(expression: Expr.FalseExpression, value: string): string {\n    return `false`;\n  }\n  function Function(expression: Expr.FunctionExpression, value: string): string {\n    return `${SetExtern(expression.callback)}(${value})`;\n  }\n  function GreaterThan(expression: Expr.GreaterThanExpression, value: string): string {\n    return `${value} > ${expression.value}`;\n  }\n  function GreaterThanEqual(expression: Expr.GreaterThanEqualExpression, value: string): string {\n    return `${value} >= ${expression.value}`;\n  }\n  function IfThenElse(expression: Expr.IfThenElseExpression, value: string): string {\n    return `(${Visit(expression.if, `${value}`)}) ? (${Visit(expression.then, `${value}`)}) : (${Visit(\n      expression.else,\n      `${value}`,\n    )})`;\n  }\n  function Index(expression: Expr.IndexExpression, value: string): string {\n    return Visit(expression.expr, `${value}[${expression.index}]`);\n  }\n  function InstanceOf(expression: Expr.InstanceOfExpression, value: string): string {\n    return `${value} instanceof ${expression.value}`;\n  }\n  function IsArray(expression: Expr.IsArrayExpression, value: string): string {\n    return `Array.isArray(${value})`;\n  }\n  function IsFinite(expression: Expr.IsFiniteExpression, value: string): string {\n    return `Number.isFinite(${value})`;\n  }\n  function IsInteger(expression: Expr.IsIntegerExpression, value: string): string {\n    return `Number.isInteger(${value})`;\n  }\n  function IsNaN(expression: Expr.IsNaNExpression, value: string): string {\n    return `Number.isNaN(${value})`;\n  }\n  function IsSafeInteger(expression: Expr.IsSafeIntegerExpression, value: string): string {\n    return `${value} === undefined`;\n  }\n  function IsUndefined(expression: Expr.IsUndefinedExpression, value: string): string {\n    return `Number.isSafeInteger(${value})`;\n  }\n  function LessThan(expression: Expr.LessThanExpression, value: string): string {\n    return `${value} < ${expression.value}`;\n  }\n  function LessThanEqual(expression: Expr.LessThanEqualExpression, value: string): string {\n    return `${value} <= ${expression.value}`;\n  }\n  function MultipleOf(expression: Expr.MultipleOfExpression, value: string): string {\n    return `${value} % ${expression.value} === 0`;\n  }\n  function Not(expression: Expr.NotExpression, value: string): string {\n    return `!(${Visit(expression.expr, value)})`;\n  }\n  function Or(expression: Expr.OrExpression, value: string): string {\n    return `(${expression.expr.map((expression) => Visit(expression, `${value}`)).join(' || ')})`;\n  }\n  function PropertiesExclude(expression: Expr.PropertiesExcludeExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).every((key) => !${SetExtern(expression.keys)}.includes(key) ? ${Visit(\n      expression.expr,\n      `${value}[key]`,\n    )} : true)`;\n  }\n  function PropetiesExcludePattern(expression: Expr.PropertiesExcludePatternExpression, value: string): string {\n    const local = SetLocal(`new RegExp(/${expression.pattern}/)`);\n    return `Object.getOwnPropertyNames(${value}).every((key) => !${local}.test(key) ? ${Visit(\n      expression.expr,\n      `${value}[key]`,\n    )} : true)`;\n  }\n  function PropertiesInclude(expression: Expr.PropertiesIncludeExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).every((key) => ${SetExtern(expression.keys)}.includes(key) ? ${Visit(\n      expression.expr,\n      `${value}[key]`,\n    )} : true)`;\n  }\n  function PropertiesIncludePattern(expression: Expr.PropertiesIncludePatternExpression, value: string): string {\n    const local = SetLocal(`new RegExp(/${expression.pattern}/)`);\n    return `Object.getOwnPropertyNames(${value}).every((key) => ${local}.test(key) ? ${Visit(\n      expression.expr,\n      `${value}[key]`,\n    )} : true)`;\n  }\n  function PropertiesLength(expression: Expr.PropertiesLengthExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).length === ${expression.value}`;\n  }\n  function PropertiesMaximum(expression: Expr.PropertiesMaximumExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).length <= ${expression.value}`;\n  }\n  function PropertiesMinimum(expression: Expr.PropertiesMinimumExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).length >= ${expression.value}`;\n  }\n  function Properties(expression: Expr.PropertiesExpression, value: string): string {\n    return `Object.getOwnPropertyNames(${value}).every((key) => ${Visit(expression.expr, `${value}[key]`)})`;\n  }\n  function PropertyKeys(expression: Expr.PropertyKeysExpression, value: string): string {\n    const keys = expression.keys.map((key) => `'${key}'`).join(', ');\n    return `((value) => { const keys = Object.getOwnPropertyNames(value); return [${keys}].every((key) => keys.includes(key)); })(${value})`;\n  }\n  function Property(expression: Expr.PropertyExpression, value: string): string {\n    return MemberAccessor.IsDot(expression.key)\n      ? Visit(expression.expr, `${value}.${expression.key}`)\n      : Visit(expression.expr, `${value}['${expression.key}']`);\n  }\n  function IsPattern(expression: Expr.IsPatternExpression, value: string): string {\n    const local = SetLocal(`new RegExp(/${expression.pattern}/)`);\n    return `${local}.test(${value})`;\n  }\n  function Ref(expression: Expr.RefExpression, value: string): string {\n    if (!reference_map.has(expression.$ref)) throw new ReferencedExpressionNotFound(expression);\n    // Ref: All referenced expressions are hoisted into their own functions. We track a dictionary of\n    // function names and compiled expressions here which is later emitted when generating the module.\n    // If the function doesn't exist, build and just return the check_T() call.\n    if (!function_map.has(expression.$ref)) {\n      function_map.set(expression.$ref, ''); // terminate recursion\n      const reference = reference_map.get(expression.$ref)!;\n      function_map.set(expression.$ref, Visit(reference, 'value'));\n    }\n    return `check_${expression.$ref}(${value})`;\n  }\n  function True(expression: Expr.TrueExpression, value: string): string {\n    return `true`;\n  }\n  function TypeOf(expression: Expr.TypeOfExpression, value: string): string {\n    return `typeof ${value} === '${expression.value}'`;\n  }\n  function Visit(expression: Expr.Expression, value: string): string {\n    // Root and Recursive: All expressions with $ids are hoisted into their own functions. Here we check\n    // if we have observed the $id before, and if not, generate the function and return check_T(). This\n    // only occurs for discovered references which are typical of recursive expressions, but may also\n    // include the Root expression if it has been specified with an $id.\n    if (expression.$id !== undefined && !reference_map.has(expression.$id)) {\n      reference_map.set(expression.$id, expression);\n      const reference = reference_map.get(expression.$id)!;\n      function_map.set(expression.$id, Visit(reference, 'value'));\n      return `check_${expression.$id}(${value})`;\n    }\n    switch (expression.type) {\n      case 'And':\n        return And(expression, value);\n      case 'Call':\n        return Call(expression, value);\n      case 'ElementsDistinct':\n        return ElementsDistinct(expression, value);\n      case 'Elements':\n        return Elements(expression, value);\n      case 'Equals':\n        return Equals(expression, value);\n      case 'False':\n        return False(expression, value);\n      case 'Function':\n        return Function(expression, value);\n      case 'GreaterThanEqual':\n        return GreaterThanEqual(expression, value);\n      case 'GreaterThan':\n        return GreaterThan(expression, value);\n      case 'IfThenElse':\n        return IfThenElse(expression, value);\n      case 'InstanceOf':\n        return InstanceOf(expression, value);\n      case 'Index':\n        return Index(expression, value);\n      case 'IsArray':\n        return IsArray(expression, value);\n      case 'IsFinite':\n        return IsFinite(expression, value);\n      case 'IsInteger':\n        return IsInteger(expression, value);\n      case 'IsNaN':\n        return IsNaN(expression, value);\n      case 'IsPattern':\n        return IsPattern(expression, value);\n      case 'IsSafeInteger':\n        return IsSafeInteger(expression, value);\n      case 'IsUndefined':\n        return IsUndefined(expression, value);\n      case 'LessThan':\n        return LessThan(expression, value);\n      case 'LessThanEqual':\n        return LessThanEqual(expression, value);\n      case 'MultipleOf':\n        return MultipleOf(expression, value);\n      case 'Not':\n        return Not(expression, value);\n      case 'Or':\n        return Or(expression, value);\n      case 'PropertiesInclude':\n        return PropertiesInclude(expression, value);\n      case 'PropertiesIncludePattern':\n        return PropertiesIncludePattern(expression, value);\n      case 'PropertiesExclude':\n        return PropertiesExclude(expression, value);\n      case 'PropertiesExcludePattern':\n        return PropetiesExcludePattern(expression, value);\n      case 'PropertiesLength':\n        return PropertiesLength(expression, value);\n      case 'PropertiesMaximum':\n        return PropertiesMaximum(expression, value);\n      case 'PropertiesMinimum':\n        return PropertiesMinimum(expression, value);\n      case 'Properties':\n        return Properties(expression, value);\n      case 'PropertyKeys':\n        return PropertyKeys(expression, value);\n      case 'Property':\n        return Property(expression, value);\n      case 'Ref':\n        return Ref(expression, value);\n      case 'True':\n        return True(expression, value);\n      case 'TypeOf':\n        return TypeOf(expression, value);\n      default:\n        throw new UnknownExpressionError(expression);\n    }\n  }\n\n  // -------------------------------------------------------\n  // Compiler State\n  // -------------------------------------------------------\n  function SetLocal(code: string): string {\n    const key = `local_${local_map.size}`;\n    local_map.set(key, code);\n    return key;\n  }\n  function SetExtern(value: unknown): string {\n    const key = `extern_${extern_map.size}`;\n    extern_map.set(key, value);\n    return key;\n  }\n  const reference_map = new Map<string, Expr.Expression>();\n  const function_map = new Map<string, string>();\n  const extern_map = new Map<string, unknown>();\n  const local_map = new Map<string, unknown>();\n\n  /** Compiles an expression and associated references to target V8 hidden class optimizations */\n  export function Compile(expression: Expr.Expression, references: Expr.Expression[] = []): ExpressionCheck {\n    reference_map.clear();\n    function_map.clear();\n    extern_map.clear();\n    local_map.clear();\n    for (const reference of references) {\n      if (reference.$id === undefined) continue;\n      reference_map.set(reference.$id, reference);\n    }\n    const root = `return function check(value) { return ${Visit(expression, 'value')} }`;\n    const funcs = [...function_map.entries()].map(([key, body]) => `function check_${key}(value) { return ${body} }`);\n    const locals = [...local_map.entries()].map(([key, code]) => `const ${key} = ${code}`);\n    const check_module = [...locals, ...funcs, root].join('\\n');\n    // generate bootstrap\n    const bootstrap = new globalThis.Function('__hash', ...extern_map.keys(), check_module);\n    const check = bootstrap((value: unknown) => Hash(value), ...extern_map.values());\n    return new ExpressionCheck(check, new Map(extern_map), check_module);\n  }\n}\n"],"names":["Hash","MemberAccessor","DollarSign","code","Underscore","Numeric","Alpha","IsDot","propertyName","length","charCodeAt","i","UnknownExpressionError","Error","constructor","expression","ReferencedExpressionNotFound","ExpressionCheck","check","locals","Code","Check","value","Locals","ExpressionCompiler","And","expr","map","Visit","join","Call","target","SetExtern","parameters","ElementsDistinct","Elements","Equals","False","Function","callback","GreaterThan","GreaterThanEqual","IfThenElse","if","then","else","Index","index","InstanceOf","IsArray","IsFinite","IsInteger","IsNaN","IsSafeInteger","IsUndefined","LessThan","LessThanEqual","MultipleOf","Not","Or","PropertiesExclude","keys","PropetiesExcludePattern","local","SetLocal","pattern","PropertiesInclude","PropertiesIncludePattern","PropertiesLength","PropertiesMaximum","PropertiesMinimum","Properties","PropertyKeys","key","Property","IsPattern","Ref","reference_map","has","$ref","function_map","set","reference","get","True","TypeOf","$id","undefined","type","local_map","size","extern_map","Map","Compile","references","clear","root","funcs","entries","body","check_module","bootstrap","globalThis","values"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}