@balena/abstract-sql-compiler 10.6.3-build-tests-update-66ee93652310d4add5b0c8c09843dc052d796f5e-1 → 11.0.0-build-11-x-9f16483079cd561a9fdaa741cd830c2c5eb2065a-1

package/out/AbstractSQLRules2SQL.js

@@ -1,17 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkMinArgs = exports.checkArgs = exports.getAbstractSqlQuery = exports.isAbstractSqlQuery = exports.isNotNullable = exports.isDurationValue = exports.isJSONValue = exports.isArrayValue = exports.isDateValue = exports.isBooleanValue = exports.isNumericValue = exports.isTextValue = exports.comparisons = void 0;
-exports.AbstractSQLRules2SQL = AbstractSQLRules2SQL;
-const sbvr_types_1 = __importDefault(require("@balena/sbvr-types"));
-const AbstractSQLCompiler_1 = require("./AbstractSQLCompiler");
+import $sbvrTypes from '@balena/sbvr-types';
+const { default: sbvrTypes } = $sbvrTypes;
+import { isFieldTypeNode } from './AbstractSQLCompiler.js';
 let fieldOrderings = [];
 let fieldOrderingsLookup = {};
 let engine = "postgres" /* Engines.postgres */;
 let noBinds = false;
-exports.comparisons = {
+export const comparisons = {
     Equals: ' = ',
     GreaterThan: ' > ',
     GreaterThanOrEqual: ' >= ',
@@ -25,12 +19,12 @@ const escapeField = (field) => field === '*' ? '*' : `"${field}"`;
 const AnyValue = (args, indent) => {
     const [type, ...rest] = args;
     for (const matcher of [
-        exports.isJSONValue,
-        exports.isDateValue,
-        exports.isTextValue,
-        exports.isNumericValue,
-        exports.isBooleanValue,
-        exports.isDurationValue,
+        isJSONValue,
+        isDateValue,
+        isTextValue,
+        isNumericValue,
+        isBooleanValue,
+        isDurationValue,
     ]) {
         if (matcher(type)) {
             return typeRules[type](rest, indent);
@@ -69,7 +63,7 @@ const MatchValue = (matcher) => (args, indent) => {
     }
     return UnknownValue(args, indent);
 };
-const isTextValue = (type) => {
+export const isTextValue = (type) => {
     return (type === 'Text' ||
         type === 'EmbeddedText' ||
         type === 'Concatenate' ||
@@ -83,9 +77,8 @@ const isTextValue = (type) => {
         type === 'Right' ||
         type === 'EscapeForLike');
 };
-exports.isTextValue = isTextValue;
-const TextValue = MatchValue(exports.isTextValue);
-const isNumericValue = (type) => {
+const TextValue = MatchValue(isTextValue);
+export const isNumericValue = (type) => {
     return (type === 'Number' ||
         type === 'Real' ||
         type === 'Integer' ||
@@ -113,9 +106,8 @@ const isNumericValue = (type) => {
         type === 'Sum' ||
         type === 'SubtractDateDate');
 };
-exports.isNumericValue = isNumericValue;
-const NumericValue = MatchValue(exports.isNumericValue);
-const isBooleanValue = (type) => {
+const NumericValue = MatchValue(isNumericValue);
+export const isBooleanValue = (type) => {
     return (type === 'Boolean' ||
         type === 'Not' ||
         type === 'And' ||
@@ -137,9 +129,8 @@ const isBooleanValue = (type) => {
         type === 'StartsWith' ||
         type === 'EqualsAny');
 };
-exports.isBooleanValue = isBooleanValue;
-const BooleanValue = MatchValue(exports.isBooleanValue);
-const isDateValue = (type) => {
+const BooleanValue = MatchValue(isBooleanValue);
+export const isDateValue = (type) => {
     return (type === 'Date' ||
         type === 'ToDate' ||
         type === 'ToTime' ||
@@ -151,24 +142,20 @@ const isDateValue = (type) => {
         type === 'SubtractDateDuration' ||
         type === 'SubtractDateNumber');
 };
-exports.isDateValue = isDateValue;
-const DateValue = MatchValue(exports.isDateValue);
-const isArrayValue = (type) => {
+const DateValue = MatchValue(isDateValue);
+export const isArrayValue = (type) => {
     return type === 'TextArray';
 };
-exports.isArrayValue = isArrayValue;
-const isJSONValue = (type) => {
+export const isJSONValue = (type) => {
     return type === 'AggregateJSON' || type === 'ToJSON';
 };
-exports.isJSONValue = isJSONValue;
-const JSONValue = MatchValue(exports.isJSONValue);
-const isDurationValue = (type) => {
+const JSONValue = MatchValue(isJSONValue);
+export const isDurationValue = (type) => {
     return type === 'Duration';
 };
-exports.isDurationValue = isDurationValue;
-const DurationValue = MatchValue(exports.isDurationValue);
+const DurationValue = MatchValue(isDurationValue);
 const Field = (args, indent) => {
-    if ((0, AbstractSQLCompiler_1.isFieldTypeNode)(args)) {
+    if (isFieldTypeNode(args)) {
         const [type, ...rest] = args;
         return typeRules[type](rest, indent);
     }
@@ -176,7 +163,7 @@ const Field = (args, indent) => {
         throw new SyntaxError(`Invalid field type: ${args[0]}`);
     }
 };
-const isNotNullable = (node) => {
+export const isNotNullable = (node) => {
     switch (node[0]) {
         case 'EmbeddedText':
         case 'Boolean':
@@ -196,14 +183,13 @@ const isNotNullable = (node) => {
         case 'NotExists':
             return true;
         case 'Coalesce':
-            return node.slice(1).some((n) => (0, exports.isNotNullable)(n));
+            return node.slice(1).some((n) => isNotNullable(n));
         case 'Not':
-            return (0, exports.isNotNullable)(node[1]);
+            return isNotNullable(node[1]);
     }
     return false;
 };
-exports.isNotNullable = isNotNullable;
-const isAtomicNode = (n) => (0, AbstractSQLCompiler_1.isFieldTypeNode)(n) ||
+const isAtomicNode = (n) => isFieldTypeNode(n) ||
     n[0] === 'Bind' ||
     n[0] === 'Null' ||
     n[0] === 'Value' ||
@@ -213,8 +199,8 @@ const isAtomicNode = (n) => (0, AbstractSQLCompiler_1.isFieldTypeNode)(n) ||
     n[0] === 'Integer' ||
     n[0] === 'Boolean';
 const isNotDistinctFrom = (args, indent) => {
-    const a = (0, exports.getAbstractSqlQuery)(args, 0);
-    const b = (0, exports.getAbstractSqlQuery)(args, 1);
+    const a = getAbstractSqlQuery(args, 0);
+    const b = getAbstractSqlQuery(args, 1);
     let aSql = AnyValue(a, indent);
     let bSql = AnyValue(b, indent);
     // We can omit the parens if the value is a atomic type node, for slightly smaller/more readable sql
@@ -225,8 +211,8 @@ const isNotDistinctFrom = (args, indent) => {
         bSql = `(${bSql})`;
     }
     if (engine === "postgres" /* Engines.postgres */) {
-        const aIsNotNullable = (0, exports.isNotNullable)(a);
-        const bIsNotNullable = (0, exports.isNotNullable)(b);
+        const aIsNotNullable = isNotNullable(a);
+        const bIsNotNullable = isNotNullable(b);
         if (aIsNotNullable && bIsNotNullable) {
             return `${aSql} = ${bSql}`;
         }
@@ -252,29 +238,27 @@ const isNotDistinctFrom = (args, indent) => {
         throw new SyntaxError(`IsDistinctFrom/IsNotDistinctFrom not supported on: ${engine}`);
     }
 };
-const isAbstractSqlQuery = (x) => {
+export const isAbstractSqlQuery = (x) => {
     return Array.isArray(x);
 };
-exports.isAbstractSqlQuery = isAbstractSqlQuery;
-const getAbstractSqlQuery = (args, index) => {
+export const getAbstractSqlQuery = (args, index) => {
     const abstractSqlQuery = args[index];
-    if (!(0, exports.isAbstractSqlQuery)(abstractSqlQuery)) {
+    if (!isAbstractSqlQuery(abstractSqlQuery)) {
         throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof abstractSqlQuery}`);
     }
     return abstractSqlQuery;
 };
-exports.getAbstractSqlQuery = getAbstractSqlQuery;
 const Comparison = (comparison) => {
     return (args, indent) => {
-        (0, exports.checkArgs)(comparison, args, 2);
+        checkArgs(comparison, args, 2);
         const a = precedenceSafeOpValue(comparison, AnyValue, args, 0, indent);
         const b = precedenceSafeOpValue(comparison, AnyValue, args, 1, indent);
-        return a + exports.comparisons[comparison] + b;
+        return a + comparisons[comparison] + b;
     };
 };
 const NumberMatch = (type) => {
     return (args) => {
-        (0, exports.checkArgs)(type, args, 1);
+        checkArgs(type, args, 1);
         const n = args[0];
         if (typeof n !== 'number') {
             throw new SyntaxError(`${type} expected number but got ${typeof n}`);
@@ -307,15 +291,15 @@ const JoinMatch = (joinType) => {
         if (args.length !== 1 && args.length !== 2) {
             throw new SyntaxError(`"${joinType}" requires 1/2 arg(s)`);
         }
-        const from = MaybeAlias((0, exports.getAbstractSqlQuery)(args, 0), indent, FromMatch);
+        const from = MaybeAlias(getAbstractSqlQuery(args, 0), indent, FromMatch);
         if (args.length === 1) {
             return sqlJoinType + from;
         }
-        const [type, ...rest] = (0, exports.getAbstractSqlQuery)(args, 1);
+        const [type, ...rest] = getAbstractSqlQuery(args, 1);
         switch (type) {
             case 'On': {
-                (0, exports.checkArgs)('On', rest, 1);
-                const ruleBody = BooleanValue((0, exports.getAbstractSqlQuery)(rest, 0), NestedIndent(indent));
+                checkArgs('On', rest, 1);
+                const ruleBody = BooleanValue(getAbstractSqlQuery(rest, 0), NestedIndent(indent));
                 return sqlJoinType + from + ' ON ' + ruleBody;
             }
             default:
@@ -340,20 +324,20 @@ const mathOperatorNodeTypes = new Set([
     'SubtractDateNumber',
 ]);
 const precedenceSafeOpValue = (parentNodeType, valueMatchFn, args, index, indent) => {
-    const operandAbstractSql = (0, exports.getAbstractSqlQuery)(args, index);
+    const operandAbstractSql = getAbstractSqlQuery(args, index);
     const valueExpr = valueMatchFn(operandAbstractSql, indent);
     const [childNodeType] = operandAbstractSql;
     if ((mathOperatorNodeTypes.has(parentNodeType) &&
         mathOperatorNodeTypes.has(childNodeType)) ||
         // We need parenthesis for chained boolean comparisons, otherwise PostgreSQL complains.
-        (parentNodeType in exports.comparisons && childNodeType in exports.comparisons)) {
+        (parentNodeType in comparisons && childNodeType in comparisons)) {
         return `(${valueExpr})`;
     }
     return valueExpr;
 };
 const MathOp = (type) => {
     return (args, indent) => {
-        (0, exports.checkArgs)(type, args, 2);
+        checkArgs(type, args, 2);
         const a = precedenceSafeOpValue(type, NumericValue, args, 0, indent);
         const b = precedenceSafeOpValue(type, NumericValue, args, 1, indent);
         return `${a} ${mathOps[type]} ${b}`;
@@ -390,8 +374,8 @@ const dateFormats = {
 };
 const ExtractNumericDatePart = (type) => {
     return (args, indent) => {
-        (0, exports.checkArgs)(type, args, 1);
-        const date = DateValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs(type, args, 1);
+        const date = DateValue(getAbstractSqlQuery(args, 0), indent);
         if (engine === "websql" /* Engines.websql */) {
             return websqlDateFormats[type](date);
         }
@@ -401,7 +385,7 @@ const ExtractNumericDatePart = (type) => {
     };
 };
 const Text = (args) => {
-    (0, exports.checkArgs)('Text', args, 1);
+    checkArgs('Text', args, 1);
     if (noBinds) {
         return `'${args[0]}'`;
     }
@@ -409,20 +393,18 @@ const Text = (args) => {
         return AddBind(['Text', args[0]]);
     }
 };
-const checkArgs = (matchName, args, num) => {
+export const checkArgs = (matchName, args, num) => {
     if (args.length !== num) {
         throw new SyntaxError(`"${matchName}" requires ${num} arg(s)`);
     }
 };
-exports.checkArgs = checkArgs;
-const checkMinArgs = (matchName, args, num) => {
+export const checkMinArgs = (matchName, args, num) => {
     if (args.length < num) {
         throw new SyntaxError(`"${matchName}" requires at least ${num} arg(s)`);
     }
 };
-exports.checkMinArgs = checkMinArgs;
 const AddDateNumber = (args, indent) => {
-    (0, exports.checkArgs)('AddDateNumber', args, 2);
+    checkArgs('AddDateNumber', args, 2);
     const a = precedenceSafeOpValue('AddDateNumber', DateValue, args, 0, indent);
     const b = precedenceSafeOpValue('AddDateNumber', NumericValue, args, 1, indent);
     if (engine === "postgres" /* Engines.postgres */) {
@@ -436,7 +418,7 @@ const AddDateNumber = (args, indent) => {
     }
 };
 const AddDateDuration = (args, indent) => {
-    (0, exports.checkArgs)('AddDateDuration', args, 2);
+    checkArgs('AddDateDuration', args, 2);
     const a = precedenceSafeOpValue('AddDateDuration', DateValue, args, 0, indent);
     const b = precedenceSafeOpValue('AddDateDuration', DurationValue, args, 1, indent);
     if (engine === "postgres" /* Engines.postgres */) {
@@ -450,7 +432,7 @@ const AddDateDuration = (args, indent) => {
     }
 };
 const SubtractDateDuration = (args, indent) => {
-    (0, exports.checkArgs)('SubtractDateDuration', args, 2);
+    checkArgs('SubtractDateDuration', args, 2);
     const a = precedenceSafeOpValue('SubtractDateDuration', DateValue, args, 0, indent);
     const b = precedenceSafeOpValue('SubtractDateDuration', DurationValue, args, 1, indent);
     if (engine === "postgres" /* Engines.postgres */) {
@@ -464,7 +446,7 @@ const SubtractDateDuration = (args, indent) => {
     }
 };
 const SubtractDateNumber = (args, indent) => {
-    (0, exports.checkArgs)('SubtractDateNumber', args, 2);
+    checkArgs('SubtractDateNumber', args, 2);
     const a = precedenceSafeOpValue('SubtractDateNumber', DateValue, args, 0, indent);
     const b = precedenceSafeOpValue('SubtractDateNumber', NumericValue, args, 1, indent);
     if (engine === "postgres" /* Engines.postgres */) {
@@ -478,7 +460,7 @@ const SubtractDateNumber = (args, indent) => {
     }
 };
 const SubtractDateDate = (args, indent) => {
-    (0, exports.checkArgs)('SubtractDateDate', args, 2);
+    checkArgs('SubtractDateDate', args, 2);
     const a = precedenceSafeOpValue('SubtractDateDate', DateValue, args, 0, indent);
     const b = precedenceSafeOpValue('SubtractDateDate', DateValue, args, 1, indent);
     if (engine === "postgres" /* Engines.postgres */) {
@@ -532,7 +514,7 @@ const FromMatch = (args, indent) => {
             return '(' + nestedindent + query + indent + ')';
         }
         case 'Table': {
-            (0, exports.checkArgs)('Table', rest, 1);
+            checkArgs('Table', rest, 1);
             const [table] = rest;
             if (typeof table !== 'string') {
                 throw new SyntaxError('`Table` table must be a string');
@@ -547,8 +529,8 @@ const MaybeAlias = (args, indent, matchFn) => {
     const [type, ...rest] = args;
     switch (type) {
         case 'Alias': {
-            (0, exports.checkArgs)('Alias', rest, 2);
-            const field = matchFn((0, exports.getAbstractSqlQuery)(rest, 0), indent);
+            checkArgs('Alias', rest, 2);
+            const field = matchFn(getAbstractSqlQuery(rest, 0), indent);
             return `${field} AS "${rest[1]}"`;
         }
         default:
@@ -580,10 +562,10 @@ const AddBind = (bind) => {
 };
 const typeRules = {
     UnionQuery: (args, indent) => {
-        (0, exports.checkMinArgs)('UnionQuery', args, 2);
+        checkMinArgs('UnionQuery', args, 2);
         return args
             .map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             const [type, ...rest] = arg;
@@ -610,7 +592,7 @@ const typeRules = {
             Offset: '',
         };
         for (const arg of args) {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError('`SelectQuery` args must all be arrays');
             }
             const [type, ...rest] = arg;
@@ -665,15 +647,15 @@ const typeRules = {
             groups.Offset);
     },
     Select: (args, indent) => {
-        (0, exports.checkArgs)('Select', args, 1);
-        args = (0, exports.getAbstractSqlQuery)(args, 0);
+        checkArgs('Select', args, 1);
+        args = getAbstractSqlQuery(args, 0);
         if (args.length === 0) {
             // Empty select fields are converted to `SELECT 1`
             return '1';
         }
         return args
             .map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return MaybeAlias(arg, indent, SelectMatch);
@@ -681,21 +663,21 @@ const typeRules = {
             .join(', ');
     },
     From: (args, indent) => {
-        (0, exports.checkArgs)('From', args, 1);
-        return MaybeAlias((0, exports.getAbstractSqlQuery)(args, 0), indent, FromMatch);
+        checkArgs('From', args, 1);
+        return MaybeAlias(getAbstractSqlQuery(args, 0), indent, FromMatch);
     },
     Join: JoinMatch('Join'),
     LeftJoin: JoinMatch('LeftJoin'),
     RightJoin: JoinMatch('RightJoin'),
     FullJoin: JoinMatch('FullJoin'),
     CrossJoin: (args, indent) => {
-        (0, exports.checkArgs)('CrossJoin', args, 1);
-        const from = MaybeAlias((0, exports.getAbstractSqlQuery)(args, 0), indent, FromMatch);
+        checkArgs('CrossJoin', args, 1);
+        const from = MaybeAlias(getAbstractSqlQuery(args, 0), indent, FromMatch);
         return `CROSS JOIN ${from}`;
     },
     Where: (args, indent) => {
-        (0, exports.checkArgs)('Where', args, 1);
-        const boolNode = (0, exports.getAbstractSqlQuery)(args, 0);
+        checkArgs('Where', args, 1);
+        const boolNode = getAbstractSqlQuery(args, 0);
         if (boolNode[0] === 'Boolean') {
             // This is designed to avoid cases of `WHERE 0`/`WHERE 1` which are invalid, ideally
             // we need to convert booleans to always use true/false but that's a major change
@@ -705,61 +687,61 @@ const typeRules = {
         return 'WHERE ' + ruleBody;
     },
     GroupBy: (args, indent) => {
-        (0, exports.checkArgs)('GroupBy', args, 1);
-        const groups = (0, exports.getAbstractSqlQuery)(args, 0);
-        (0, exports.checkMinArgs)('GroupBy groups', groups, 1);
+        checkArgs('GroupBy', args, 1);
+        const groups = getAbstractSqlQuery(args, 0);
+        checkMinArgs('GroupBy groups', groups, 1);
         return ('GROUP BY ' +
             groups.map((arg) => AnyValue(arg, indent)).join(', '));
     },
     Having: (args, indent) => {
-        (0, exports.checkArgs)('Having', args, 1);
-        const havingBody = BooleanValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Having', args, 1);
+        const havingBody = BooleanValue(getAbstractSqlQuery(args, 0), indent);
         return `HAVING ${havingBody}`;
     },
     OrderBy: (args, indent) => {
-        (0, exports.checkMinArgs)('OrderBy', args, 1);
+        checkMinArgs('OrderBy', args, 1);
         return ('ORDER BY ' +
             args
                 .map((arg) => {
-                (0, exports.checkMinArgs)('OrderBy ordering', arg, 2);
+                checkMinArgs('OrderBy ordering', arg, 2);
                 const order = arg[0];
                 if (order !== 'ASC' && order !== 'DESC') {
                     throw new SyntaxError(`Can only order by "ASC" or "DESC"`);
                 }
-                const value = AnyValue((0, exports.getAbstractSqlQuery)(arg, 1), indent);
+                const value = AnyValue(getAbstractSqlQuery(arg, 1), indent);
                 return `${value} ${order}`;
             })
                 .join(',' + NestedIndent(indent)));
     },
     Limit: (args, indent) => {
-        (0, exports.checkArgs)('Limit', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Limit', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `LIMIT ${num}`;
     },
     Offset: (args, indent) => {
-        (0, exports.checkArgs)('Offset', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Offset', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `OFFSET ${num}`;
     },
     Count: (args) => {
-        (0, exports.checkArgs)('Count', args, 1);
+        checkArgs('Count', args, 1);
         if (args[0] !== '*') {
             throw new SyntaxError('"Count" only supports "*"');
         }
         return 'COUNT(*)';
     },
     Average: (args, indent) => {
-        (0, exports.checkArgs)('Average', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Average', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `AVG(${num})`;
     },
     Sum: (args, indent) => {
-        (0, exports.checkArgs)('Sum', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Sum', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `SUM(${num})`;
     },
     Field: (args) => {
-        (0, exports.checkArgs)('Field', args, 1);
+        checkArgs('Field', args, 1);
         const [field] = args;
         if (typeof field !== 'string') {
             throw new SyntaxError('`Field` field must be a string');
@@ -767,7 +749,7 @@ const typeRules = {
         return escapeField(field);
     },
     ReferencedField: (args) => {
-        (0, exports.checkArgs)('ReferencedField', args, 2);
+        checkArgs('ReferencedField', args, 2);
         const [table, field] = args;
         if (typeof table !== 'string') {
             throw new SyntaxError('`ReferencedField` table must be a string');
@@ -778,14 +760,14 @@ const typeRules = {
         return `"${table}".${escapeField(field)}`;
     },
     Cast: (args, indent) => {
-        (0, exports.checkArgs)('Cast', args, 2);
-        const value = AnyValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Cast', args, 2);
+        const value = AnyValue(getAbstractSqlQuery(args, 0), indent);
         const typeName = args[1];
-        if (!sbvr_types_1.default[typeName]?.types[engine]) {
+        if (!sbvrTypes[typeName]?.types[engine]) {
             throw new SyntaxError(`Invalid cast type: ${typeName}`);
         }
         let type;
-        const dbType = sbvr_types_1.default[typeName].types[engine];
+        const dbType = sbvrTypes[typeName].types[engine];
         if (typeof dbType === 'function') {
             type = dbType.castType;
         }
@@ -810,7 +792,7 @@ const typeRules = {
     Integer: NumberMatch('Integer'),
     // eslint-disable-next-line id-denylist
     Boolean: (args) => {
-        (0, exports.checkArgs)('Boolean', args, 1);
+        checkArgs('Boolean', args, 1);
         const b = args[0];
         if (typeof b !== 'boolean') {
             throw new SyntaxError(`Boolean expected boolean but got ${typeof b}`);
@@ -818,12 +800,12 @@ const typeRules = {
         return b ? 'TRUE' : 'FALSE';
     },
     EmbeddedText: (args) => {
-        (0, exports.checkArgs)('EmbeddedText', args, 1);
+        checkArgs('EmbeddedText', args, 1);
         return `'${args[0]}'`;
     },
     TextArray: (args, indent) => {
         const values = args.map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return TextValue(arg, indent);
@@ -833,29 +815,29 @@ const typeRules = {
             : 'CAST(ARRAY[] as TEXT[])';
     },
     Null: (args) => {
-        (0, exports.checkArgs)('Null', args, 0);
+        checkArgs('Null', args, 0);
         return 'NULL';
     },
     CurrentTimestamp: (args) => {
-        (0, exports.checkArgs)('CurrentTimestamp', args, 0);
+        checkArgs('CurrentTimestamp', args, 0);
         return 'CURRENT_TIMESTAMP';
     },
     CurrentDate: (args) => {
-        (0, exports.checkArgs)('CurrentDate', args, 0);
+        checkArgs('CurrentDate', args, 0);
         return 'CURRENT_DATE';
     },
     AggregateJSON: (args, indent) => {
-        (0, exports.checkArgs)('AggregateJSON', args, 1);
+        checkArgs('AggregateJSON', args, 1);
         if (engine !== "postgres" /* Engines.postgres */) {
             throw new SyntaxError('AggregateJSON not supported on: ' + engine);
         }
-        const field = Field((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        const field = Field(getAbstractSqlQuery(args, 0), indent);
         return `COALESCE(JSON_AGG(${field}), '[]')`;
     },
     Equals: Comparison('Equals'),
     EqualsAny: (args, indent) => {
-        (0, exports.checkArgs)('EqualsAny', args, 2);
-        return `${AnyValue((0, exports.getAbstractSqlQuery)(args, 0), indent)} = ANY(${AnyValue((0, exports.getAbstractSqlQuery)(args, 1), indent)})`;
+        checkArgs('EqualsAny', args, 2);
+        return `${AnyValue(getAbstractSqlQuery(args, 0), indent)} = ANY(${AnyValue(getAbstractSqlQuery(args, 1), indent)})`;
     },
     GreaterThan: Comparison('GreaterThan'),
     GreaterThanOrEqual: Comparison('GreaterThanOrEqual'),
@@ -864,18 +846,18 @@ const typeRules = {
     NotEquals: Comparison('NotEquals'),
     Like: Comparison('Like'),
     IsNotDistinctFrom: (args, indent) => {
-        (0, exports.checkArgs)('IsNotDistinctFrom', args, 2);
+        checkArgs('IsNotDistinctFrom', args, 2);
         return isNotDistinctFrom(args, indent);
     },
     IsDistinctFrom: (args, indent) => {
-        (0, exports.checkArgs)('IsDistinctFrom', args, 2);
+        checkArgs('IsDistinctFrom', args, 2);
         return 'NOT(' + isNotDistinctFrom(args, indent) + ')';
     },
     Between: (args, indent) => {
-        (0, exports.checkArgs)('Between', args, 3);
-        const v = AnyValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const a = AnyValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
-        const b = AnyValue((0, exports.getAbstractSqlQuery)(args, 2), indent);
+        checkArgs('Between', args, 3);
+        const v = AnyValue(getAbstractSqlQuery(args, 0), indent);
+        const a = AnyValue(getAbstractSqlQuery(args, 1), indent);
+        const b = AnyValue(getAbstractSqlQuery(args, 2), indent);
         return `${v} BETWEEN ${a} AND (${b})`;
     },
     Add: MathOp('Add'),
@@ -897,8 +879,8 @@ const typeRules = {
     Second: ExtractNumericDatePart('Second'),
     Fractionalseconds: ExtractNumericDatePart('Fractionalseconds'),
     Totalseconds: (args, indent) => {
-        (0, exports.checkArgs)('Totalseconds', args, 1);
-        const duration = DurationValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Totalseconds', args, 1);
+        const duration = DurationValue(getAbstractSqlQuery(args, 0), indent);
         if (engine === "postgres" /* Engines.postgres */) {
             return `EXTRACT(EPOCH FROM ${duration})`;
         }
@@ -910,9 +892,9 @@ const typeRules = {
         }
     },
     Concatenate: (args, indent) => {
-        (0, exports.checkMinArgs)('Concatenate', args, 1);
+        checkMinArgs('Concatenate', args, 1);
         const comparators = args.map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return TextValue(arg, indent);
@@ -925,9 +907,9 @@ const typeRules = {
         }
     },
     ConcatenateWithSeparator: (args, indent) => {
-        (0, exports.checkMinArgs)('ConcatenateWithSeparator', args, 2);
+        checkMinArgs('ConcatenateWithSeparator', args, 2);
         const textParts = args.map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return TextValue(arg, indent);
@@ -938,24 +920,24 @@ const typeRules = {
         return `CONCAT_WS(${textParts.join(', ')})`;
     },
     Replace: (args, indent) => {
-        (0, exports.checkArgs)('Replace', args, 3);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const find = TextValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
-        const replacement = TextValue((0, exports.getAbstractSqlQuery)(args, 2), indent);
+        checkArgs('Replace', args, 3);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
+        const find = TextValue(getAbstractSqlQuery(args, 1), indent);
+        const replacement = TextValue(getAbstractSqlQuery(args, 2), indent);
         return `REPLACE(${str}, ${find}, ${replacement})`;
     },
     ExtractJSONPathAsText: (args, indent) => {
-        (0, exports.checkMinArgs)('ExtractJSONPathAsText', args, 1);
+        checkMinArgs('ExtractJSONPathAsText', args, 1);
         if (engine !== "postgres" /* Engines.postgres */) {
             throw new SyntaxError('ExtractJSONPathAsText not supported on: ' + engine);
         }
-        const json = JSONValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const path = TextValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
+        const json = JSONValue(getAbstractSqlQuery(args, 0), indent);
+        const path = TextValue(getAbstractSqlQuery(args, 1), indent);
         return `${json} #>> ${path}`;
     },
     CharacterLength: (args, indent) => {
-        (0, exports.checkArgs)('CharacterLength', args, 1);
-        const text = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('CharacterLength', args, 1);
+        const text = TextValue(getAbstractSqlQuery(args, 0), indent);
         if (engine === "mysql" /* Engines.mysql */) {
             return `CHAR_LENGTH(${text})`;
         }
@@ -964,9 +946,9 @@ const typeRules = {
         }
     },
     StrPos: (args, indent) => {
-        (0, exports.checkArgs)('StrPos', args, 2);
-        const haystack = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const needle = TextValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
+        checkArgs('StrPos', args, 2);
+        const haystack = TextValue(getAbstractSqlQuery(args, 0), indent);
+        const needle = TextValue(getAbstractSqlQuery(args, 1), indent);
         if (engine === "postgres" /* Engines.postgres */) {
             return `STRPOS(${haystack}, ${needle})`;
         }
@@ -975,9 +957,9 @@ const typeRules = {
         }
     },
     StartsWith: (args, indent) => {
-        (0, exports.checkArgs)('StartsWith', args, 2);
-        const haystack = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const needle = TextValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
+        checkArgs('StartsWith', args, 2);
+        const haystack = TextValue(getAbstractSqlQuery(args, 0), indent);
+        const needle = TextValue(getAbstractSqlQuery(args, 1), indent);
         if (engine === "postgres" /* Engines.postgres */) {
             return `STARTS_WITH(${haystack}, ${needle})`;
         }
@@ -989,10 +971,10 @@ const typeRules = {
         }
     },
     Substring: (args, indent) => {
-        (0, exports.checkMinArgs)('Substring', args, 2);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkMinArgs('Substring', args, 2);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
         const nums = args.slice(1).map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return NumericValue(arg, indent);
@@ -1000,9 +982,9 @@ const typeRules = {
         return `SUBSTRING(${[str, ...nums].join(', ')})`;
     },
     Right: (args, indent) => {
-        (0, exports.checkArgs)('Right', args, 2);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const n = NumericValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
+        checkArgs('Right', args, 2);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
+        const n = NumericValue(getAbstractSqlQuery(args, 1), indent);
         if (engine === "websql" /* Engines.websql */) {
             return `SUBSTRING(${str}, -${n})`;
         }
@@ -1011,51 +993,51 @@ const typeRules = {
         }
     },
     Lower: (args, indent) => {
-        (0, exports.checkArgs)('Lower', args, 1);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Lower', args, 1);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
         return `LOWER(${str})`;
     },
     Upper: (args, indent) => {
-        (0, exports.checkArgs)('Upper', args, 1);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Upper', args, 1);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
         return `UPPER(${str})`;
     },
     Trim: (args, indent) => {
-        (0, exports.checkArgs)('Trim', args, 1);
-        const str = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Trim', args, 1);
+        const str = TextValue(getAbstractSqlQuery(args, 0), indent);
         return `TRIM(${str})`;
     },
     Round: (args, indent) => {
-        (0, exports.checkArgs)('Round', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Round', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `ROUND(${num})`;
     },
     Floor: (args, indent) => {
-        (0, exports.checkArgs)('Floor', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Floor', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `FLOOR(${num})`;
     },
     Ceiling: (args, indent) => {
-        (0, exports.checkArgs)('Ceiling', args, 1);
-        const num = NumericValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('Ceiling', args, 1);
+        const num = NumericValue(getAbstractSqlQuery(args, 0), indent);
         return `CEILING(${num})`;
     },
     ToDate: (args, indent) => {
-        (0, exports.checkArgs)('ToDate', args, 1);
-        const date = DateValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('ToDate', args, 1);
+        const date = DateValue(getAbstractSqlQuery(args, 0), indent);
         return `DATE(${date})`;
     },
     DateTrunc: (args, indent) => {
-        (0, exports.checkMinArgs)('DateTrunc', args, 2);
-        const precision = TextValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const date = DateValue((0, exports.getAbstractSqlQuery)(args, 1), indent);
+        checkMinArgs('DateTrunc', args, 2);
+        const precision = TextValue(getAbstractSqlQuery(args, 0), indent);
+        const date = DateValue(getAbstractSqlQuery(args, 1), indent);
         // Postgres generated timestamps have a microseconds precision
         // these timestamps will fail on comparisons: eq, ne, gt, lt with
         // js timestamps that have only milliseconds precision
         // thus supporting for truncating to a given precision
         if (engine === "postgres" /* Engines.postgres */) {
             const timeZone = args.length === 3
-                ? TextValue((0, exports.getAbstractSqlQuery)(args, 2), indent)
+                ? TextValue(getAbstractSqlQuery(args, 2), indent)
                 : undefined;
             return timeZone
                 ? `DATE_TRUNC(${precision}, ${date}, ${timeZone})`
@@ -1073,8 +1055,8 @@ const typeRules = {
         }
     },
     ToTime: (args, indent) => {
-        (0, exports.checkArgs)('ToTime', args, 1);
-        const date = DateValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkArgs('ToTime', args, 1);
+        const date = DateValue(getAbstractSqlQuery(args, 0), indent);
         if (engine === "postgres" /* Engines.postgres */) {
             return `CAST(${date} AS TIME)`;
         }
@@ -1083,26 +1065,26 @@ const typeRules = {
         }
     },
     ToJSON: (args, indent) => {
-        (0, exports.checkMinArgs)('ToJSON', args, 1);
+        checkMinArgs('ToJSON', args, 1);
         if (engine !== "postgres" /* Engines.postgres */) {
             throw new SyntaxError('ToJSON not supported on: ' + engine);
         }
-        const value = AnyValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        const value = AnyValue(getAbstractSqlQuery(args, 0), indent);
         return `TO_JSON(${value})`;
     },
     Any: (args, indent) => {
-        (0, exports.checkArgs)('Any', args, 2);
+        checkArgs('Any', args, 2);
         if (engine !== "postgres" /* Engines.postgres */) {
             throw new SyntaxError('Any not supported on: ' + engine);
         }
-        const value = AnyValue((0, exports.getAbstractSqlQuery)(args, 0), indent);
-        const innerType = sbvr_types_1.default[args[1]].types[engine];
+        const value = AnyValue(getAbstractSqlQuery(args, 0), indent);
+        const innerType = sbvrTypes[args[1]].types[engine];
         return `ANY(CAST(${value} AS ${innerType}[]))`;
     },
     Coalesce: (args, indent) => {
-        (0, exports.checkMinArgs)('Coalesce', args, 2);
+        checkMinArgs('Coalesce', args, 2);
         const comparators = args.map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return AnyValue(arg, indent);
@@ -1110,27 +1092,27 @@ const typeRules = {
         return 'COALESCE(' + comparators.join(', ') + ')';
     },
     Case: (args, indent) => {
-        (0, exports.checkMinArgs)('Case', args, 1);
+        checkMinArgs('Case', args, 1);
         const nestedIndent = NestedIndent(indent);
         const clauses = args
             .map((arg, index) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             const [type, ...rest] = arg;
             switch (type) {
                 case 'When': {
-                    (0, exports.checkArgs)('When', rest, 2);
-                    const matches = BooleanValue((0, exports.getAbstractSqlQuery)(rest, 0), NestedIndent(nestedIndent));
-                    const resultValue = AnyValue((0, exports.getAbstractSqlQuery)(rest, 1), nestedIndent);
+                    checkArgs('When', rest, 2);
+                    const matches = BooleanValue(getAbstractSqlQuery(rest, 0), NestedIndent(nestedIndent));
+                    const resultValue = AnyValue(getAbstractSqlQuery(rest, 1), nestedIndent);
                     return 'WHEN ' + matches + ' THEN ' + resultValue;
                 }
                 case 'Else':
                     if (index !== args.length - 1) {
                         throw new SyntaxError('Else must be the last element of a Case');
                     }
-                    (0, exports.checkArgs)('Else', rest, 1);
-                    return ('ELSE ' + AnyValue((0, exports.getAbstractSqlQuery)(rest, 0), nestedIndent));
+                    checkArgs('Else', rest, 1);
+                    return ('ELSE ' + AnyValue(getAbstractSqlQuery(rest, 0), nestedIndent));
                 default:
                     throw new SyntaxError('Case can only contain When/Else');
             }
@@ -1139,10 +1121,10 @@ const typeRules = {
         return 'CASE' + nestedIndent + clauses + indent + 'END';
     },
     And: (args, indent) => {
-        (0, exports.checkMinArgs)('And', args, 2);
+        checkMinArgs('And', args, 2);
         return args
             .map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return BooleanValue(arg, indent);
@@ -1150,11 +1132,11 @@ const typeRules = {
             .join(indent + 'AND ');
     },
     Or: (args, indent) => {
-        (0, exports.checkMinArgs)('Or', args, 2);
+        checkMinArgs('Or', args, 2);
         return ('(' +
             args
                 .map((arg) => {
-                if (!(0, exports.isAbstractSqlQuery)(arg)) {
+                if (!isAbstractSqlQuery(arg)) {
                     throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
                 }
                 return BooleanValue(arg, indent);
@@ -1163,17 +1145,17 @@ const typeRules = {
             ')');
     },
     Bind: (args) => {
-        (0, exports.checkArgs)('Bind', args, 1);
+        checkArgs('Bind', args, 1);
         const bind = args[0];
         return AddBind(['Bind', bind]);
     },
     Text,
     Date: (args) => {
-        (0, exports.checkArgs)('Date', args, 1);
+        checkArgs('Date', args, 1);
         return AddBind(['Date', args[0]]);
     },
     Duration: (args) => {
-        (0, exports.checkArgs)('Duration', args, 1);
+        checkArgs('Duration', args, 1);
         if (engine === "websql" /* Engines.websql */) {
             throw new SyntaxError('Durations not supported on: ' + engine);
         }
@@ -1203,8 +1185,8 @@ const typeRules = {
             (engine === "mysql" /* Engines.mysql */ ? ' DAY_MICROSECOND' : ''));
     },
     Exists: (args, indent) => {
-        (0, exports.checkArgs)('Exists', args, 1);
-        const arg = (0, exports.getAbstractSqlQuery)(args, 0);
+        checkArgs('Exists', args, 1);
+        const arg = getAbstractSqlQuery(args, 0);
         const [type, ...rest] = arg;
         switch (type) {
             case 'SelectQuery':
@@ -1218,8 +1200,8 @@ const typeRules = {
         }
     },
     NotExists: (args, indent) => {
-        (0, exports.checkArgs)('NotExists', args, 1);
-        const arg = (0, exports.getAbstractSqlQuery)(args, 0);
+        checkArgs('NotExists', args, 1);
+        const arg = getAbstractSqlQuery(args, 0);
         const [type, ...rest] = arg;
         switch (type) {
             case 'SelectQuery':
@@ -1233,16 +1215,16 @@ const typeRules = {
         }
     },
     Not: (args, indent) => {
-        (0, exports.checkArgs)('Not', args, 1);
+        checkArgs('Not', args, 1);
         const nestedIndent = NestedIndent(indent);
-        const bool = BooleanValue((0, exports.getAbstractSqlQuery)(args, 0), nestedIndent);
+        const bool = BooleanValue(getAbstractSqlQuery(args, 0), nestedIndent);
         return 'NOT (' + nestedIndent + bool + indent + ')';
     },
     In: (args, indent) => {
-        (0, exports.checkMinArgs)('In', args, 2);
-        const field = Field((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkMinArgs('In', args, 2);
+        const field = Field(getAbstractSqlQuery(args, 0), indent);
         const vals = args.slice(1).map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return AnyValue(arg, indent);
@@ -1250,10 +1232,10 @@ const typeRules = {
         return field + ' IN (' + vals.join(', ') + ')';
     },
     NotIn: (args, indent) => {
-        (0, exports.checkMinArgs)('NotIn', args, 2);
-        const field = Field((0, exports.getAbstractSqlQuery)(args, 0), indent);
+        checkMinArgs('NotIn', args, 2);
+        const field = Field(getAbstractSqlQuery(args, 0), indent);
         const vals = args.slice(1).map((arg) => {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError(`Expected AbstractSqlQuery array but got ${typeof arg}`);
             }
             return AnyValue(arg, indent);
@@ -1265,7 +1247,7 @@ const typeRules = {
         let fields = [];
         let values = [];
         for (const arg of args) {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError('`InsertQuery` args must all be arrays');
             }
             const [type, ...rest] = arg;
@@ -1274,14 +1256,14 @@ const typeRules = {
                     if (fields.length !== 0) {
                         throw new SyntaxError(`'InsertQuery' can only accept one '${type}'`);
                     }
-                    (0, exports.checkMinArgs)('Update fields', rest, 1);
-                    fields = (0, exports.getAbstractSqlQuery)(rest, 0).map(escapeField);
+                    checkMinArgs('Update fields', rest, 1);
+                    fields = getAbstractSqlQuery(rest, 0).map(escapeField);
                     break;
                 case 'Values': {
                     if (values.length !== 0) {
                         throw new SyntaxError(`'InsertQuery' can only accept one '${type}'`);
                     }
-                    const valuesArray = (0, exports.getAbstractSqlQuery)(rest, 0);
+                    const valuesArray = getAbstractSqlQuery(rest, 0);
                     if (valuesArray.length > 0) {
                         const [valuesType, ...valuesRest] = valuesArray;
                         switch (valuesType) {
@@ -1327,7 +1309,7 @@ const typeRules = {
         let values = [];
         let where = '';
         for (const arg of args) {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError('`UpdateQuery` args must all be arrays');
             }
             const [type, ...rest] = arg;
@@ -1336,16 +1318,16 @@ const typeRules = {
                     if (fields.length !== 0) {
                         throw new SyntaxError(`'UpdateQuery' can only accept one '${type}'`);
                     }
-                    (0, exports.checkMinArgs)('Update fields', rest, 1);
-                    fields = (0, exports.getAbstractSqlQuery)(rest, 0).map(escapeField);
+                    checkMinArgs('Update fields', rest, 1);
+                    fields = getAbstractSqlQuery(rest, 0).map(escapeField);
                     break;
                 case 'Values': {
                     if (values.length !== 0) {
                         throw new SyntaxError(`'UpdateQuery' can only accept one '${type}'`);
                     }
-                    (0, exports.checkArgs)('Update values', rest, 1);
-                    const valuesArray = (0, exports.getAbstractSqlQuery)(rest, 0);
-                    (0, exports.checkMinArgs)('Update values array', valuesArray, 1);
+                    checkArgs('Update values', rest, 1);
+                    const valuesArray = getAbstractSqlQuery(rest, 0);
+                    checkMinArgs('Update values array', valuesArray, 1);
                     values = valuesArray.map((v) => Value(v, indent));
                     break;
                 }
@@ -1377,7 +1359,7 @@ const typeRules = {
         const tables = [];
         let where = '';
         for (const arg of args) {
-            if (!(0, exports.isAbstractSqlQuery)(arg)) {
+            if (!isAbstractSqlQuery(arg)) {
                 throw new SyntaxError('`DeleteQuery` args must all be arrays');
             }
             const [type, ...rest] = arg;
@@ -1398,8 +1380,8 @@ const typeRules = {
         return 'DELETE FROM ' + tables.join(', ') + where;
     },
     EscapeForLike: (args, indent) => {
-        (0, exports.checkArgs)('EscapeForLike', args, 1);
-        const textTypeNode = (0, exports.getAbstractSqlQuery)(args, 0);
+        checkArgs('EscapeForLike', args, 1);
+        const textTypeNode = getAbstractSqlQuery(args, 0);
         return typeRules.Replace([
             [
                 'Replace',
@@ -1426,7 +1408,7 @@ const toSqlResult = (query) => {
         bindings: fieldOrderings,
     };
 };
-function AbstractSQLRules2SQL(abstractSQL, $engine, $noBinds = false) {
+export function AbstractSQLRules2SQL(abstractSQL, $engine, $noBinds = false) {
     engine = $engine;
     noBinds = $noBinds;
     fieldOrderings = [];
@@ -1443,9 +1425,9 @@ function AbstractSQLRules2SQL(abstractSQL, $engine, $noBinds = false) {
             return toSqlResult(query);
         }
         case 'UpsertQuery': {
-            (0, exports.checkArgs)('UpsertQuery', rest, 2);
-            const insertQuery = (0, exports.getAbstractSqlQuery)(rest, 0);
-            const updateQuery = (0, exports.getAbstractSqlQuery)(rest, 1);
+            checkArgs('UpsertQuery', rest, 2);
+            const insertQuery = getAbstractSqlQuery(rest, 0);
+            const updateQuery = getAbstractSqlQuery(rest, 1);
             if (insertQuery[0] !== 'InsertQuery' ||
                 updateQuery[0] !== 'UpdateQuery') {
                 throw new SyntaxError('UpsertQuery must have [InsertQuery, UpdateQuery] provided');