@abaplint/runtime 2.13.92 → 2.13.94

package/build/src/builtin/_extremum.d.ts

@@ -0,0 +1,9 @@
+import { DecFloat34, Float, Integer, Integer8, Packed } from "../types";
+import { INumeric } from "../types/_numeric";
+export type ExtremumArgument = number | INumeric | undefined;
+/** nmax( ) and nmin( ): the result has the calculation type of the arguments,
+ * as an arithmetic expression would determine it - decfloat34 before f before
+ * p before int8 before i. So nmin( val1 = i1 val2 = i2 ) is an i, which DO
+ * nmin( ... ) TIMES and every other integer position rely on, and a p result
+ * keeps the most decimals of its arguments. */
+export declare function extremum(args: ExtremumArgument[], isBetter: (candidate: number, best: number) => boolean): Float | Integer8 | Integer | DecFloat34 | Packed;

package/build/src/builtin/_extremum.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extremum = extremum;
+const _parse_1 = require("../operators/_parse");
+const types_1 = require("../types");
+// the calculation types in the order an arithmetic expression ranks them
+const INT = 0;
+const INT8 = 1;
+const PACKED = 2;
+const FLOAT = 3;
+const DECFLOAT = 4;
+/** nmax( ) and nmin( ): the result has the calculation type of the arguments,
+ * as an arithmetic expression would determine it - decfloat34 before f before
+ * p before int8 before i. So nmin( val1 = i1 val2 = i2 ) is an i, which DO
+ * nmin( ... ) TIMES and every other integer position rely on, and a p result
+ * keeps the most decimals of its arguments. */
+function extremum(args, isBetter) {
+    let best = undefined;
+    let bestValue = 0;
+    let type = INT;
+    let decimals = 0;
+    for (let arg of args) {
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg instanceof types_1.FieldSymbol) {
+            arg = arg.getPointer();
+        }
+        if (arg instanceof types_1.DecFloat34) {
+            type = Math.max(type, DECFLOAT);
+        }
+        else if (arg instanceof types_1.Float) {
+            type = Math.max(type, FLOAT);
+        }
+        else if (arg instanceof types_1.Packed) {
+            type = Math.max(type, PACKED);
+            decimals = Math.max(decimals, arg.getDecimals());
+        }
+        else if (arg instanceof types_1.Integer8) {
+            type = Math.max(type, INT8);
+        }
+        else if (arg instanceof types_1.Integer || (typeof arg === "number" && Number.isInteger(arg))) {
+            // i, the lowest type
+        }
+        else {
+            // character-like and other arguments, as before: f
+            type = Math.max(type, FLOAT);
+        }
+        const value = (0, _parse_1.parse)(arg);
+        if (best === undefined || isBetter(value, bestValue)) {
+            best = arg;
+            bestValue = value;
+        }
+    }
+    switch (type) {
+        case DECFLOAT:
+            return new types_1.DecFloat34().set(bestValue);
+        case FLOAT:
+            return new types_1.Float().set(bestValue);
+        case PACKED:
+            if (best instanceof types_1.Packed) {
+                // through the digits, not through a binary float
+                return new types_1.Packed({ length: 16, decimals }).set(best.toFixed(best.getDecimals()));
+            }
+            return new types_1.Packed({ length: 16, decimals }).set(bestValue);
+        case INT8:
+            if (best instanceof types_1.Integer8) {
+                return new types_1.Integer8().set(best.get());
+            }
+            return new types_1.Integer8().set(bestValue);
+        default:
+            return new types_1.Integer().set(bestValue);
+    }
+}
+//# sourceMappingURL=_extremum.js.map

package/build/src/builtin/escape.d.ts

@@ -1,7 +1,7 @@
-import { String } from "../types";
+import { FieldSymbol, String } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
 export declare function escape(input: {
-    val: ICharacter | string;
+    val: ICharacter | FieldSymbol | string;
     format: INumeric | number;
 }): String;

package/build/src/builtin/escape.js

@@ -3,8 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.escape = escape;
 const types_1 = require("../types");
 const _position_1 = require("./_position");
+const JSON_SHORT = {
+    "\\": "\\\\",
+    "\"": "\\\"",
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f",
+    "\r": "\\r",
+};
+// backslash, quote, and \b \t \n \f \r by their short forms; the other control
+// characters below U+0020 as \u00XX in upper case hex; U+007F and non-ASCII unchanged
+function escapeJsonCharacter(char) {
+    return JSON_SHORT[char] ?? "\\u" + char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0");
+}
 function escape(input) {
-    let val = typeof input.val === "string" ? input.val : input.val.get();
+    let source;
+    if (input.val instanceof types_1.FieldSymbol) {
+        const pointer = input.val.getPointer();
+        if (pointer === undefined) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        source = pointer;
+    }
+    else {
+        source = input.val;
+    }
+    // a c operand counts without its trailing blanks, as in the other string functions
+    let val = typeof source === "string" ? source
+        : source instanceof types_1.Character ? source.getTrimEnd() : source.get();
     const format = (0, _position_1.position)(input.format);
     // todo, optimize/cache regexes
     switch (format) {
@@ -34,9 +61,7 @@ function escape(input) {
             val = val.replace(/'/g, "\\'");
             break;
         case 24: // e_json_string
-            val = val.replace(/\\/g, "\\\\");
-            val = val.replace(/"/g, "\\\"");
-            val = val.replace(/\n/g, "\\n");
+            val = val.replace(/[\\"\u0000-\u001F]/g, escapeJsonCharacter);
             break;
         default:
         // todo, runtime error

package/build/src/builtin/nmax.d.ts

@@ -1,5 +1,4 @@
 import { INumeric } from "../types/_numeric";
-import { Float } from "../types";
 export interface INmaxInput {
     val1: number | INumeric;
     val2: number | INumeric;
@@ -11,4 +10,4 @@ export interface INmaxInput {
     val8?: number | INumeric;
     val9?: number | INumeric;
 }
-export declare function nmax(input: INmaxInput): Float;
+export declare function nmax(input: INmaxInput): import("../types").Float | import("../types").Integer8 | import("../types").Integer | import("../types").DecFloat34 | import("../types").Packed;

package/build/src/builtin/nmax.js

@@ -1,34 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nmax = nmax;
-const _parse_1 = require("../operators/_parse");
-const types_1 = require("../types");
+const _extremum_1 = require("./_extremum");
 function nmax(input) {
-    const values = [];
-    values.push((0, _parse_1.parse)(input.val1));
-    values.push((0, _parse_1.parse)(input.val2));
-    if (input.val3) {
-        values.push((0, _parse_1.parse)(input.val3));
-    }
-    if (input.val4) {
-        values.push((0, _parse_1.parse)(input.val4));
-    }
-    if (input.val5) {
-        values.push((0, _parse_1.parse)(input.val5));
-    }
-    if (input.val6) {
-        values.push((0, _parse_1.parse)(input.val6));
-    }
-    if (input.val7) {
-        values.push((0, _parse_1.parse)(input.val7));
-    }
-    if (input.val8) {
-        values.push((0, _parse_1.parse)(input.val8));
-    }
-    if (input.val9) {
-        values.push((0, _parse_1.parse)(input.val9));
-    }
-    values.sort((a, b) => (b - a));
-    return new types_1.Float().set(values[0]);
+    return (0, _extremum_1.extremum)([input.val1, input.val2, input.val3, input.val4, input.val5,
+        input.val6, input.val7, input.val8, input.val9], (candidate, best) => candidate > best);
 }
 //# sourceMappingURL=nmax.js.map

package/build/src/builtin/nmin.d.ts

@@ -1,5 +1,4 @@
 import { INumeric } from "../types/_numeric";
-import { Float } from "../types";
 export interface INminInput {
     val1: number | INumeric;
     val2: number | INumeric;
@@ -11,4 +10,4 @@ export interface INminInput {
     val8?: number | INumeric;
     val9?: number | INumeric;
 }
-export declare function nmin(input: INminInput): Float;
+export declare function nmin(input: INminInput): import("../types").Float | import("../types").Integer8 | import("../types").Integer | import("../types").DecFloat34 | import("../types").Packed;

package/build/src/builtin/nmin.js

@@ -1,34 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nmin = nmin;
-const _parse_1 = require("../operators/_parse");
-const types_1 = require("../types");
+const _extremum_1 = require("./_extremum");
 function nmin(input) {
-    const values = [];
-    values.push((0, _parse_1.parse)(input.val1));
-    values.push((0, _parse_1.parse)(input.val2));
-    if (input.val3) {
-        values.push((0, _parse_1.parse)(input.val3));
-    }
-    if (input.val4) {
-        values.push((0, _parse_1.parse)(input.val4));
-    }
-    if (input.val5) {
-        values.push((0, _parse_1.parse)(input.val5));
-    }
-    if (input.val6) {
-        values.push((0, _parse_1.parse)(input.val6));
-    }
-    if (input.val7) {
-        values.push((0, _parse_1.parse)(input.val7));
-    }
-    if (input.val8) {
-        values.push((0, _parse_1.parse)(input.val8));
-    }
-    if (input.val9) {
-        values.push((0, _parse_1.parse)(input.val9));
-    }
-    values.sort((a, b) => (a - b));
-    return new types_1.Float().set(values[0]);
+    return (0, _extremum_1.extremum)([input.val1, input.val2, input.val3, input.val4, input.val5,
+        input.val6, input.val7, input.val8, input.val9], (candidate, best) => candidate < best);
 }
 //# sourceMappingURL=nmin.js.map

package/build/src/builtin/round.d.ts

@@ -1,8 +1,17 @@
-import { Float } from "../types";
+import { DecFloat34 } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
+type Input = INumeric | ICharacter | string | number;
+/** round( val = arg {dec = n}|{prec = n} [mode = m] )
+ *
+ * The argument is converted to decfloat34 and rounded as a decimal number, so
+ * round( val = '2.675' dec = 2 ) is 2.68 - not 2.67, which is what scaling the
+ * nearest binary float would give. A binary float argument brings its full
+ * binary expansion along, the way converting f to decfloat34 does. */
 export declare function round(input: {
-    val: ICharacter | string;
-    dec: INumeric | number;
-    mode?: INumeric | number;
-}): Float;
+    val: Input;
+    dec?: Input;
+    prec?: Input;
+    mode?: Input;
+}): DecFloat34;
+export {};

package/build/src/builtin/round.js

@@ -3,39 +3,87 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.round = round;
 const _parse_1 = require("../operators/_parse");
 const types_1 = require("../types");
+// the rounding modes of CL_ABAP_MATH, the decNumber enumeration
+const ROUND_CEILING = 0;
+const ROUND_UP = 1;
+const ROUND_HALF_UP = 2;
+const ROUND_HALF_EVEN = 3;
+const ROUND_HALF_DOWN = 4;
+const ROUND_DOWN = 5;
+const ROUND_FLOOR = 6;
+/** round( val = arg {dec = n}|{prec = n} [mode = m] )
+ *
+ * The argument is converted to decfloat34 and rounded as a decimal number, so
+ * round( val = '2.675' dec = 2 ) is 2.68 - not 2.67, which is what scaling the
+ * nearest binary float would give. A binary float argument brings its full
+ * binary expansion along, the way converting f to decfloat34 does. */
 function round(input) {
-    let mode = input.mode;
-    if (mode === undefined) {
-        mode = 2;
+    const mode = input.mode === undefined ? ROUND_HALF_UP : (0, _parse_1.parse)(input.mode);
+    let arg = input.val;
+    if (arg instanceof types_1.FieldSymbol) {
+        arg = arg.getPointer();
     }
-    else if (typeof mode !== "number") {
-        mode = mode?.get();
+    const val = (0, _parse_1.parse)(arg);
+    const text = arg instanceof types_1.Float ? val.toPrecision(34) : String(val);
+    const match = /^(-?)(\d*)\.?(\d*)(?:e([+-]?\d+))?$/i.exec(text);
+    if (match === null || !Number.isFinite(val)) {
+        return new types_1.DecFloat34().set(val);
     }
-    const val = (0, _parse_1.parse)(input.val);
-    const dec = (0, _parse_1.parse)(input.dec);
-    if (dec !== 0) {
-        throw new Error("round(), todo, handle decimals");
+    const negative = match[1] === "-";
+    const digits = BigInt((match[2] + match[3]).replace(/^0+/, "") || "0");
+    // the value is digits * 10^exponent
+    const exponent = parseInt(match[4] || "0", 10) - match[3].length;
+    let dec;
+    if (input.prec !== undefined) {
+        const prec = (0, _parse_1.parse)(input.prec);
+        if (prec <= 0) {
+            throw new Error("CX_SY_ARITHMETIC_ERROR, round( ) prec must be positive");
+        }
+        // position of the most significant digit
+        const top = digits.toString().length - 1 + exponent;
+        dec = prec - 1 - top;
     }
-    const ret = new types_1.Float();
+    else {
+        dec = input.dec === undefined ? 0 : (0, _parse_1.parse)(input.dec);
+    }
+    const drop = -exponent - dec;
+    if (drop <= 0 || digits === 0n) {
+        return new types_1.DecFloat34().set(val);
+    }
+    const divisor = 10n ** BigInt(drop);
+    let kept = digits / divisor;
+    const rest = digits % divisor;
+    // compare the dropped part with one half of the last kept digit
+    const half = rest * 2n === divisor ? 0 : (rest * 2n > divisor ? 1 : -1);
+    let away;
     switch (mode) {
-        case 1:
-            ret.set(Math.ceil(val));
+        case ROUND_CEILING:
+            away = rest > 0n && negative === false;
+            break;
+        case ROUND_UP:
+            away = rest > 0n;
             break;
-        case 2:
-            ret.set(Math.round(val));
+        case ROUND_HALF_UP:
+            away = half >= 0;
             break;
-        case 4:
-            ret.set(-Math.round(-val));
+        case ROUND_HALF_EVEN:
+            away = half > 0 || (half === 0 && kept % 2n === 1n);
             break;
-        case 5:
-            ret.set(Math.trunc(val));
+        case ROUND_HALF_DOWN:
+            away = half > 0;
             break;
-        case 6:
-            ret.set(Math.floor(val));
+        case ROUND_DOWN:
+            away = false;
+            break;
+        case ROUND_FLOOR:
+            away = rest > 0n && negative === true;
             break;
         default:
             throw new Error("round(), unknown mode: " + mode);
     }
-    return ret;
+    if (away) {
+        kept += 1n;
+    }
+    return new types_1.DecFloat34().set(Number((negative ? "-" : "") + kept.toString() + "e" + (-dec)));
 }
 //# sourceMappingURL=round.js.map

package/build/src/compare/eq.js

@@ -4,7 +4,6 @@ exports.eq = eq;
 /* eslint-disable max-len */
 const types_1 = require("../types");
 const _parse_1 = require("../operators/_parse");
-const initial_1 = require("./initial");
 function compareTables(left, right) {
     const leftArray = left.array();
     const rightArray = right.array();
@@ -35,6 +34,14 @@ function compareStructures(left, right) {
     }
     return true;
 }
+// two x fields of different lengths: the shorter one is padded with 00 on the
+// right, so x'AB' = x'AB00'
+function eqHexPadded(left, right) {
+    const l = left.get();
+    const r = right.get();
+    const length = Math.max(l.length, r.length);
+    return l.padEnd(length, "0") === r.padEnd(length, "0");
+}
 // module locals instead of the imported bindings, as the CommonJS re-export
 // getters add overhead on every access in the hot path below
 const IntegerC = types_1.Integer;
@@ -107,7 +114,7 @@ function eq(left, right) {
         }
         else if (leftConstructor === HexC || leftConstructor === HexUInt8C) {
             if (left.getLength() !== right.getLength()) {
-                return (0, initial_1.initial)(left) && (0, initial_1.initial)(right);
+                return eqHexPadded(left, right);
             }
             return left.get() === right.get();
         }
@@ -211,7 +218,7 @@ function eq(left, right) {
         if (left instanceof types_1.Hex || left instanceof types_1.HexUInt8) {
             // @ts-ignore
             if (right.getLength && right.getLength() !== left.getLength()) {
-                return (0, initial_1.initial)(left) && (0, initial_1.initial)(right);
+                return eqHexPadded(left, right);
             }
             return right.get() === left.get();
         }
@@ -340,6 +347,16 @@ function eq(left, right) {
     else if (right instanceof types_1.Float && typeof l === "number") {
         r = right.getRaw();
     }
+    else if ((right instanceof types_1.Float || right instanceof types_1.DecFloat34) && typeof l === "string") {
+        // a character-like operand is compared as a number: get( ) of a float
+        // writes 1,4800000000000000E+02, which no text compares equal with
+        r = right.getRaw();
+        l = Number(l);
+    }
+    else if (left instanceof types_1.DecFloat34 && typeof r === "string") {
+        l = left.getRaw();
+        r = Number(r);
+    }
     else if (left instanceof types_1.Float) {
         if (typeof r === "number") {
             l = left.getRaw();

package/build/src/compare/gt.js

@@ -112,8 +112,14 @@ function gt(left, right) {
 }
 ///////////////////////////////////////////////////////////////////
 function gt_with_hex(left, right) {
-    const left_hex = get_hex_from_parameter(left);
-    const right_hex = get_hex_from_parameter(right);
+    let left_hex = get_hex_from_parameter(left);
+    let right_hex = get_hex_from_parameter(right);
+    if ((left instanceof types_1.Hex || left instanceof types_1.HexUInt8) && (right instanceof types_1.Hex || right instanceof types_1.HexUInt8)) {
+        // two x fields of different lengths: the shorter one is padded with 00 on the right
+        const length = Math.max(left_hex.length, right_hex.length);
+        left_hex = left_hex.padEnd(length, "0");
+        right_hex = right_hex.padEnd(length, "0");
+    }
     return left_hex > right_hex;
 }
 function get_hex_from_parameter(comparison_part) {

package/build/src/compare/in.d.ts

@@ -1,4 +1,6 @@
 import { Table } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
-export declare function compareIn(left: number | string | ICharacter | INumeric, right: Table): boolean;
+type Operand = number | string | ICharacter | INumeric;
+export declare function compareIn(left: Operand, right: Table): boolean;
+export {};

package/build/src/compare/in.js

@@ -3,32 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareIn = compareIn;
 const cp_1 = require("./cp");
 const eq_1 = require("./eq");
+const ge_1 = require("./ge");
+const gt_1 = require("./gt");
+const le_1 = require("./le");
+const lt_1 = require("./lt");
 const ne_1 = require("./ne");
-function compareIn(left, right) {
-    if (right.array().length === 0) {
-        return true;
+function matches(left, option, low, high) {
+    switch (option) {
+        case "EQ": return (0, eq_1.eq)(left, low);
+        case "NE": return (0, ne_1.ne)(left, low);
+        case "GT": return (0, gt_1.gt)(left, low);
+        case "GE": return (0, ge_1.ge)(left, low);
+        case "LT": return (0, lt_1.lt)(left, low);
+        case "LE": return (0, le_1.le)(left, low);
+        case "BT": return (0, ge_1.ge)(left, low) && (0, le_1.le)(left, high);
+        case "NB": return !((0, ge_1.ge)(left, low) && (0, le_1.le)(left, high));
+        case "CP": return (0, cp_1.cp)(left, low);
+        case "NP": return !(0, cp_1.cp)(left, low);
+        default: throw new Error("compareIn, unknown option " + option);
     }
+}
+// A value is in a range table when some I row admits it, or there is no I
+// row at all, and no E row admits it. An empty table admits everything.
+function compareIn(left, right) {
+    let included = false;
+    let hasInclude = false;
     for (const row of right.array()) {
-        if ((0, eq_1.eq)(row.get()["sign"], "I") && (0, eq_1.eq)(row.get()["option"], "EQ")) {
-            if ((0, eq_1.eq)(row.get()["low"], left)) {
-                return true;
-            }
-        }
-        else if ((0, eq_1.eq)(row.get()["sign"], "E") && (0, eq_1.eq)(row.get()["option"], "EQ")) {
-            if ((0, ne_1.ne)(row.get()["low"], left)) {
-                return true;
-            }
+        const r = row.get();
+        const sign = r["sign"].get().toString().toUpperCase().trim();
+        const option = r["option"].get().toString().toUpperCase().trim();
+        const hit = matches(left, option, r["low"], r["high"]);
+        if (sign === "I") {
+            hasInclude = true;
+            included = included || hit;
         }
-        else if ((0, eq_1.eq)(row.get()["sign"], "I") && (0, eq_1.eq)(row.get()["option"], "CP")) {
-            if ((0, cp_1.cp)(left, row.get()["low"])) {
-                return true;
+        else if (sign === "E") {
+            if (hit) {
+                return false;
             }
         }
         else {
-            console.dir(row);
-            throw new Error("compareIn todo");
+            throw new Error("compareIn, unknown sign " + sign);
         }
     }
-    return false;
+    return hasInclude === false || included;
 }
 //# sourceMappingURL=in.js.map

package/build/src/expand_in.js

@@ -1,42 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandIN = expandIN;
+function toSQLValue(value) {
+    if (typeof value === "number") {
+        return value.toString();
+    }
+    return `'` + String(value ?? "").replace(/'/g, "''") + "'";
+}
+// one row of a ranges table as a condition that is true when the row matches
+function rowCondition(field, sign, option, low, high) {
+    const lowValue = toSQLValue(low);
+    switch (option) {
+        case "EQ":
+            return `${field} = ${lowValue}`;
+        case "NE":
+            return `${field} <> ${lowValue}`;
+        case "GT":
+            return `${field} > ${lowValue}`;
+        case "GE":
+            return `${field} >= ${lowValue}`;
+        case "LT":
+            return `${field} < ${lowValue}`;
+        case "LE":
+            return `${field} <= ${lowValue}`;
+        case "BT":
+            return `(${field} >= ${lowValue} AND ${field} <= ${toSQLValue(high)})`;
+        case "NB":
+            return `NOT (${field} >= ${lowValue} AND ${field} <= ${toSQLValue(high)})`;
+        case "CP":
+        case "NP":
+            {
+                if (sign !== "I" || option !== "CP") {
+                    // the pattern rules come with a separate change; until then only I CP, as before
+                    throw new Error(`IN, ${sign} ${option} not supported`);
+                }
+                const like = `${field} LIKE '` + String(low ?? "").trimEnd().replace(/'/g, "''").replace(/\*/g, "%") + "'";
+                return option === "CP" ? like : `NOT ${like}`;
+            }
+        default:
+            throw new Error(`IN, ${sign} ${option} not supported`);
+    }
+}
 // note: must always return an expression, never return empty string
 // https://www.sqlite.org/lang_select.html
+// The rows with SIGN I are ORed, AND NOT the OR of the rows with SIGN E; a
+// table with E rows only excludes them from everything.
 function expandIN(fieldName, table) {
-    let ret = "";
     if (table.array().length === 0) {
         // " NOT IN ()" does not work on postgres
         // LIKE '%' does not work in snowflake with RTRIM collation
-        ret = `true`;
+        return `true`;
     }
-    else {
-        ret = `(`;
-        const values = [];
-        fieldName = fieldName.replace("~", `"."`);
-        for (const row of table.array()) {
-            const val = `'` + row.get().low?.get().replace(/'/g, "''") + "'";
-            if (row.get().sign?.get() === "I" && row.get().option?.get() === "EQ") {
-                values.push(`"${fieldName}" = ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "NE") {
-                values.push(`"${fieldName}" <> ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "GE") {
-                values.push(`"${fieldName}" >= ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "LE") {
-                values.push(`"${fieldName}" <= ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "CP") {
-                values.push(`"${fieldName}" LIKE '` + row.get().low?.get().trimEnd().replace(/'/g, "''").replace(/\*/g, "%") + "'");
-            }
-            else {
-                throw new Error(`IN, ${row.get().sign?.get()} ${row.get().option?.get()} not supported`);
-            }
+    const field = `"${fieldName.replace("~", `"."`)}"`;
+    const include = [];
+    const exclude = [];
+    for (const row of table.array()) {
+        const sign = row.get().sign?.get();
+        const option = row.get().option?.get();
+        if (sign !== "I" && sign !== "E") {
+            throw new Error(`IN, ${sign} ${option} not supported`);
+        }
+        const cond = rowCondition(field, sign, option, row.get().low?.get(), row.get().high?.get());
+        if (sign === "I") {
+            include.push(cond);
         }
-        ret += values.join(" OR ") + ")";
+        else {
+            exclude.push(cond);
+        }
+    }
+    const parts = [];
+    if (include.length > 0) {
+        parts.push("(" + include.join(" OR ") + ")");
+    }
+    if (exclude.length > 0) {
+        parts.push("NOT (" + exclude.join(" OR ") + ")");
     }
-    return ret;
+    return "(" + parts.join(" AND ") + ")";
 }
 //# sourceMappingURL=expand_in.js.map

package/build/src/operators/_bit_operations.d.ts

@@ -1,6 +1,2 @@
 import { XString } from "../types";
-export declare function get_bit_operation_chunks(left: XString, right: XString): {
-    leftChunk: number;
-    rightChunk: number;
-    chunkLen: number;
-}[];
+export declare function bit_operation(left: XString, right: XString, op: (l: number, r: number) => number): XString;