@abaplint/cli 2.113.127 → 2.113.128

package/build/cli.js

@@ -19366,7 +19366,7 @@ const _combi_1 = __webpack_require__(/*! ./_combi */ "./node_modules/@abaplint/c
 const chain_1 = __webpack_require__(/*! ./chain */ "./node_modules/@abaplint/core/build/src/abap/3_structures/structures/chain.js");
 class DynproLoop {
     getMatcher() {
-        return (0, _combi_1.beginEnd)((0, _combi_1.sta)(Statements.DynproLoop), (0, _combi_1.star)((0, _combi_1.alt)((0, _combi_1.sta)(Statements.Module), (0, _combi_1.sub)(chain_1.Chain))), (0, _combi_1.sta)(Statements.EndLoop));
+        return (0, _combi_1.beginEnd)((0, _combi_1.sta)(Statements.DynproLoop), (0, _combi_1.star)((0, _combi_1.alt)((0, _combi_1.sta)(Statements.Module), (0, _combi_1.sta)(Statements.Field), (0, _combi_1.sub)(chain_1.Chain))), (0, _combi_1.sta)(Statements.EndLoop));
     }
 }
 exports.DynproLoop = DynproLoop;
@@ -23722,6 +23722,9 @@ class TypeUtils {
             else if ((target instanceof basic_1.StringType || target instanceof basic_1.CharacterType)
                 && source instanceof basic_1.StructureType
                 && this.isCharLike(source)) {
+                if (this.structureContainsString(source) === true) {
+                    return false;
+                }
                 return true;
             }
             else if (source instanceof basic_1.StructureType) {
@@ -24740,8 +24743,7 @@ class AttributeChain {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), "Not an object reference(AttributeChain)"));
             return void_type_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
-        const children = node.getChildren().slice();
-        const first = children[0];
+        const first = node.getChildren()[0];
         if (!(first.get() instanceof expressions_1.AttributeName)) {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), "AttributeChain, unexpected first child"));
             return void_type_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
@@ -26528,23 +26530,25 @@ class MethodCallChain {
     static runSyntax(node, input, targetType) {
         var _a, _b;
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
-        const children = node.getChildren().slice();
-        const first = children.shift();
+        const children = node.getChildren();
+        const first = children[0];
         if (first === undefined) {
             const message = "MethodCallChain, first child expected";
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
+        let currentIndex = 1;
         let context = this.findTop(first, input, targetType);
         if (first.get() instanceof Expressions.MethodCall) {
-            children.unshift(first);
+            currentIndex--;
         }
         let previous = undefined;
-        while (children.length > 0) {
-            const current = children.shift();
+        while (currentIndex <= children.length) {
+            const current = children[currentIndex];
             if (current === undefined) {
                 break;
             }
+            currentIndex++;
             if (current instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.MethodCall) {
                 // for built-in methods set className to undefined
                 const className = context instanceof basic_1.ObjectReferenceType ? context.getIdentifierName() : undefined;
@@ -28095,46 +28099,49 @@ class Source {
         let hexExpected = false;
         let hexNext = false;
         while (children.length >= 0) {
-            if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.MethodCallChain) {
-                context = method_call_chain_1.MethodCallChain.runSyntax(first, input, targetType);
-                if (context === undefined) {
-                    const message = "Method has no RETURNING value";
-                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+            if (first instanceof nodes_1.ExpressionNode) {
+                const get = first.get();
+                if (get instanceof Expressions.MethodCallChain) {
+                    context = method_call_chain_1.MethodCallChain.runSyntax(first, input, targetType);
+                    if (context === undefined) {
+                        const message = "Method has no RETURNING value";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+                    }
                 }
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.FieldChain) {
-                context = field_chain_1.FieldChain.runSyntax(first, input, type);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.StringTemplate) {
-                context = string_template_1.StringTemplate.runSyntax(first, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Source) {
-                const found = Source.runSyntax(first, input);
-                context = this.infer(context, found);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Constant) {
-                const found = constant_1.Constant.runSyntax(first);
-                context = this.infer(context, found);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dereference) {
-                context = dereference_1.Dereference.runSyntax(first, context, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ComponentChain) {
-                context = component_chain_1.ComponentChain.runSyntax(context, first, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ArithOperator) {
-                if (first.concatTokens() === "**") {
-                    context = new basic_1.FloatType();
+                else if (get instanceof Expressions.FieldChain) {
+                    context = field_chain_1.FieldChain.runSyntax(first, input, type);
                 }
-                const operator = first.concatTokens().toUpperCase();
-                if (operator === "BIT-OR" || operator === "BIT-AND" || operator === "BIT-XOR") {
-                    hexExpected = true;
-                    hexNext = true;
+                else if (get instanceof Expressions.StringTemplate) {
+                    context = string_template_1.StringTemplate.runSyntax(first, input);
+                }
+                else if (get instanceof Expressions.Source) {
+                    const found = Source.runSyntax(first, input);
+                    context = this.infer(context, found);
+                }
+                else if (get instanceof Expressions.Constant) {
+                    const found = constant_1.Constant.runSyntax(first);
+                    context = this.infer(context, found);
+                }
+                else if (get instanceof Expressions.Dereference) {
+                    context = dereference_1.Dereference.runSyntax(first, context, input);
+                }
+                else if (get instanceof Expressions.ComponentChain) {
+                    context = component_chain_1.ComponentChain.runSyntax(context, first, input);
+                }
+                else if (get instanceof Expressions.ArithOperator) {
+                    if (first.concatTokens() === "**") {
+                        context = new basic_1.FloatType();
+                    }
+                    const operator = first.concatTokens().toUpperCase();
+                    if (operator === "BIT-OR" || operator === "BIT-AND" || operator === "BIT-XOR") {
+                        hexExpected = true;
+                        hexNext = true;
+                    }
+                }
+                else if (get instanceof Expressions.AttributeChain) {
+                    context = attribute_chain_1.AttributeChain.runSyntax(context, first, input, type);
                 }
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.AttributeChain) {
-                context = attribute_chain_1.AttributeChain.runSyntax(context, first, input, type);
             }
             if (hexExpected === true) {
                 if (!(context instanceof basic_1.VoidType)
@@ -28179,7 +28186,7 @@ class Source {
     }
     static addIfInferred(node, input, inferredType) {
         const basic = new basic_types_1.BasicTypes(input);
-        const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
+        const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeName === "#" && inferredType && typeToken) {
@@ -28203,7 +28210,7 @@ class Source {
     }
     static determineType(node, input, targetType) {
         const basic = new basic_types_1.BasicTypes(input);
-        const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
+        const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeExpression === undefined) {
@@ -28740,8 +28747,8 @@ class Target {
                 return found.getType();
             }
         }
-        const children = node.getChildren().slice();
-        const first = children.shift();
+        const children = node.getChildren();
+        const first = children[0];
         if (first === undefined || !(first instanceof nodes_1.ExpressionNode)) {
             return undefined;
         }
@@ -28751,11 +28758,13 @@ class Target {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
-        while (children.length > 0) {
-            const current = children.shift();
+        let currentIndex = 1;
+        while (currentIndex <= children.length) {
+            const current = children[currentIndex];
             if (current === undefined) {
                 break;
             }
+            currentIndex++;
             if (current.get() instanceof tokens_1.Dash) {
                 if (context instanceof unknown_type_1.UnknownType) {
                     const message = "Not a structure, type unknown, target";
@@ -54308,7 +54317,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.113.127";
+        return "2.113.128";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -60635,7 +60644,8 @@ ${indentation}${uniqueName1}-attr3 = 'IF_T100_DYN_MSG~MSGV3'.
 ${indentation}${uniqueName1}-attr4 = 'IF_T100_DYN_MSG~MSGV4'.\n`;
         }
         abap += `${indentation}DATA ${uniqueName2} TYPE REF TO ${className}.
-${indentation}CREATE OBJECT ${uniqueName2} EXPORTING textid = ${uniqueName1}.\n`;
+${indentation}CREATE OBJECT ${uniqueName2}.
+${indentation}${uniqueName2}->if_t100_message~t100key = ${uniqueName1}.\n`;
         if (withs.length > 0) {
             abap += `${indentation}${uniqueName2}->if_t100_dyn_msg~msgty = 'E'.\n`;
         }
@@ -77950,73 +77960,278 @@ function unescape(str) {
 
 /***/ }),
 
-/***/ "./node_modules/balanced-match/index.js":
-/*!**********************************************!*\
-  !*** ./node_modules/balanced-match/index.js ***!
-  \**********************************************/
-/***/ ((module) => {
+/***/ "./node_modules/@isaacs/balanced-match/dist/commonjs/index.js":
+/*!********************************************************************!*\
+  !*** ./node_modules/@isaacs/balanced-match/dist/commonjs/index.js ***!
+  \********************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
 
-module.exports = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.range = exports.balanced = void 0;
+const balanced = (a, b, str) => {
+    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+    const r = ma !== null && mb != null && (0, exports.range)(ma, mb, str);
+    return (r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + ma.length, r[1]),
+        post: str.slice(r[1] + mb.length),
+    });
+};
+exports.balanced = balanced;
+const maybeMatch = (reg, str) => {
+    const m = str.match(reg);
+    return m ? m[0] : null;
+};
+const range = (a, b, str) => {
+    let begs, beg, left, right = undefined, result;
+    let ai = str.indexOf(a);
+    let bi = str.indexOf(b, ai + 1);
+    let i = ai;
+    if (ai >= 0 && bi > 0) {
+        if (a === b) {
+            return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+            if (i === ai) {
+                begs.push(i);
+                ai = str.indexOf(a, i + 1);
+            }
+            else if (begs.length === 1) {
+                const r = begs.pop();
+                if (r !== undefined)
+                    result = [r, bi];
+            }
+            else {
+                beg = begs.pop();
+                if (beg !== undefined && beg < left) {
+                    left = beg;
+                    right = bi;
+                }
+                bi = str.indexOf(b, i + 1);
+            }
+            i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length && right !== undefined) {
+            result = [left, right];
+        }
+    }
+    return result;
+};
+exports.range = range;
+//# sourceMappingURL=index.js.map
 
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
+/***/ }),
 
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
+/***/ "./node_modules/@isaacs/brace-expansion/dist/commonjs/index.js":
+/*!*********************************************************************!*\
+  !*** ./node_modules/@isaacs/brace-expansion/dist/commonjs/index.js ***!
+  \*********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-  if (ai >= 0 && bi > 0) {
-    begs = [];
-    left = str.length;
+"use strict";
 
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.expand = expand;
+const balanced_match_1 = __webpack_require__(/*! @isaacs/balanced-match */ "./node_modules/@isaacs/balanced-match/dist/commonjs/index.js");
+const escSlash = '\0SLASH' + Math.random() + '\0';
+const escOpen = '\0OPEN' + Math.random() + '\0';
+const escClose = '\0CLOSE' + Math.random() + '\0';
+const escComma = '\0COMMA' + Math.random() + '\0';
+const escPeriod = '\0PERIOD' + Math.random() + '\0';
+const escSlashPattern = new RegExp(escSlash, 'g');
+const escOpenPattern = new RegExp(escOpen, 'g');
+const escClosePattern = new RegExp(escClose, 'g');
+const escCommaPattern = new RegExp(escComma, 'g');
+const escPeriodPattern = new RegExp(escPeriod, 'g');
+const slashPattern = /\\\\/g;
+const openPattern = /\\{/g;
+const closePattern = /\\}/g;
+const commaPattern = /\\,/g;
+const periodPattern = /\\./g;
+function numeric(str) {
+    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+    return str
+        .replace(slashPattern, escSlash)
+        .replace(openPattern, escOpen)
+        .replace(closePattern, escClose)
+        .replace(commaPattern, escComma)
+        .replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+    return str
+        .replace(escSlashPattern, '\\')
+        .replace(escOpenPattern, '{')
+        .replace(escClosePattern, '}')
+        .replace(escCommaPattern, ',')
+        .replace(escPeriodPattern, '.');
+}
+/**
+ * Basically just str.split(","), but handling cases
+ * where we have nested braced sections, which should be
+ * treated as individual members, like {a,{b,c},d}
+ */
+function parseCommaParts(str) {
+    if (!str) {
+        return [''];
+    }
+    const parts = [];
+    const m = (0, balanced_match_1.balanced)('{', '}', str);
+    if (!m) {
+        return str.split(',');
+    }
+    const { pre, body, post } = m;
+    const p = pre.split(',');
+    p[p.length - 1] += '{' + body + '}';
+    const postParts = parseCommaParts(post);
+    if (post.length) {
+        ;
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+    }
+    parts.push.apply(parts, p);
+    return parts;
+}
+function expand(str) {
+    if (!str) {
+        return [];
+    }
+    // I don't know why Bash 4.3 does this, but it does.
+    // Anything starting with {} will have the first two bytes preserved
+    // but *only* at the top level, so {},a}b will not expand to anything,
+    // but a{},b}c will be expanded to [a}c,abc].
+    // One could argue that this is a bug in Bash, but since the goal of
+    // this module is to match Bash's rules, we escape a leading {}
+    if (str.slice(0, 2) === '{}') {
+        str = '\\{\\}' + str.slice(2);
+    }
+    return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+    return '{' + str + '}';
+}
+function isPadded(el) {
+    return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+    return i <= y;
+}
+function gte(i, y) {
+    return i >= y;
+}
+function expand_(str, isTop) {
+    /** @type {string[]} */
+    const expansions = [];
+    const m = (0, balanced_match_1.balanced)('{', '}', str);
+    if (!m)
+        return [str];
+    // no need to expand pre, since it is guaranteed to be free of brace-sets
+    const pre = m.pre;
+    const post = m.post.length ? expand_(m.post, false) : [''];
+    if (/\$$/.test(m.pre)) {
+        for (let k = 0; k < post.length; k++) {
+            const expansion = pre + '{' + m.body + '}' + post[k];
+            expansions.push(expansion);
         }
-
-        bi = str.indexOf(b, i + 1);
-      }
-
-      i = ai < bi && ai >= 0 ? ai : bi;
     }
-
-    if (begs.length) {
-      result = [ left, right ];
+    else {
+        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        const isSequence = isNumericSequence || isAlphaSequence;
+        const isOptions = m.body.indexOf(',') >= 0;
+        if (!isSequence && !isOptions) {
+            // {a},b}
+            if (m.post.match(/,(?!,).*\}/)) {
+                str = m.pre + '{' + m.body + escClose + m.post;
+                return expand_(str);
+            }
+            return [str];
+        }
+        let n;
+        if (isSequence) {
+            n = m.body.split(/\.\./);
+        }
+        else {
+            n = parseCommaParts(m.body);
+            if (n.length === 1 && n[0] !== undefined) {
+                // x{{a,b}}y ==> x{a}y x{b}y
+                n = expand_(n[0], false).map(embrace);
+                //XXX is this necessary? Can't seem to hit it in tests.
+                /* c8 ignore start */
+                if (n.length === 1) {
+                    return post.map(p => m.pre + n[0] + p);
+                }
+                /* c8 ignore stop */
+            }
+        }
+        // at this point, n is the parts, and we know it's not a comma set
+        // with a single entry.
+        let N;
+        if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+            const x = numeric(n[0]);
+            const y = numeric(n[1]);
+            const width = Math.max(n[0].length, n[1].length);
+            let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+            let test = lte;
+            const reverse = y < x;
+            if (reverse) {
+                incr *= -1;
+                test = gte;
+            }
+            const pad = n.some(isPadded);
+            N = [];
+            for (let i = x; test(i, y); i += incr) {
+                let c;
+                if (isAlphaSequence) {
+                    c = String.fromCharCode(i);
+                    if (c === '\\') {
+                        c = '';
+                    }
+                }
+                else {
+                    c = String(i);
+                    if (pad) {
+                        const need = width - c.length;
+                        if (need > 0) {
+                            const z = new Array(need + 1).join('0');
+                            if (i < 0) {
+                                c = '-' + z + c.slice(1);
+                            }
+                            else {
+                                c = z + c;
+                            }
+                        }
+                    }
+                }
+                N.push(c);
+            }
+        }
+        else {
+            N = [];
+            for (let j = 0; j < n.length; j++) {
+                N.push.apply(N, expand_(n[j], false));
+            }
+        }
+        for (let j = 0; j < N.length; j++) {
+            for (let k = 0; k < post.length; k++) {
+                const expansion = pre + N[j] + post[k];
+                if (!isTop || isSequence || expansion) {
+                    expansions.push(expansion);
+                }
+            }
+        }
     }
-  }
-
-  return result;
+    return expansions;
 }
-
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
@@ -80197,219 +80412,6 @@ class GlobStream extends GlobUtil {
 exports.GlobStream = GlobStream;
 //# sourceMappingURL=walker.js.map
 
-/***/ }),
-
-/***/ "./node_modules/glob/node_modules/brace-expansion/index.js":
-/*!*****************************************************************!*\
-  !*** ./node_modules/glob/node_modules/brace-expansion/index.js ***!
-  \*****************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var balanced = __webpack_require__(/*! balanced-match */ "./node_modules/balanced-match/index.js");
-
-module.exports = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
-function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
-}
-
-function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
-}
-
-function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
-}
-
-
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
-  if (!str)
-    return [''];
-
-  var parts = [];
-  var m = balanced('{', '}', str);
-
-  if (!m)
-    return str.split(',');
-
-  var pre = m.pre;
-  var body = m.body;
-  var post = m.post;
-  var p = pre.split(',');
-
-  p[p.length-1] += '{' + body + '}';
-  var postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length-1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-
-  parts.push.apply(parts, p);
-
-  return parts;
-}
-
-function expandTop(str) {
-  if (!str)
-    return [];
-
-  // I don't know why Bash 4.3 does this, but it does.
-  // Anything starting with {} will have the first two bytes preserved
-  // but *only* at the top level, so {},a}b will not expand to anything,
-  // but a{},b}c will be expanded to [a}c,abc].
-  // One could argue that this is a bug in Bash, but since the goal of
-  // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
-  }
-
-  return expand(escapeBraces(str), true).map(unescapeBraces);
-}
-
-function embrace(str) {
-  return '{' + str + '}';
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-
-function expand(str, isTop) {
-  var expansions = [];
-
-  var m = balanced('{', '}', str);
-  if (!m) return [str];
-
-  // no need to expand pre, since it is guaranteed to be free of brace-sets
-  var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
-
-  if (/\$$/.test(m.pre)) {    
-    for (var k = 0; k < post.length; k++) {
-      var expansion = pre+ '{' + m.body + '}' + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(',') >= 0;
-    if (!isSequence && !isOptions) {
-      // {a},b}
-      if (m.post.match(/,.*\}/)) {
-        str = m.pre + '{' + m.body + escClose + m.post;
-        return expand(str);
-      }
-      return [str];
-    }
-
-    var n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1) {
-        // x{{a,b}}y ==> x{a}y x{b}y
-        n = expand(n[0], false).map(embrace);
-        if (n.length === 1) {
-          return post.map(function(p) {
-            return m.pre + n[0] + p;
-          });
-        }
-      }
-    }
-
-    // at this point, n is the parts, and we know it's not a comma set
-    // with a single entry.
-    var N;
-
-    if (isSequence) {
-      var x = numeric(n[0]);
-      var y = numeric(n[1]);
-      var width = Math.max(n[0].length, n[1].length)
-      var incr = n.length == 3
-        ? Math.abs(numeric(n[2]))
-        : 1;
-      var test = lte;
-      var reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      var pad = n.some(isPadded);
-
-      N = [];
-
-      for (var i = x; test(i, y); i += incr) {
-        var c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === '\\')
-            c = '';
-        } else {
-          c = String(i);
-          if (pad) {
-            var need = width - c.length;
-            if (need > 0) {
-              var z = new Array(need + 1).join('0');
-              if (i < 0)
-                c = '-' + z + c.slice(1);
-              else
-                c = z + c;
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-
-      for (var j = 0; j < n.length; j++) {
-        N.push.apply(N, expand(n[j], false));
-      }
-    }
-
-    for (var j = 0; j < N.length; j++) {
-      for (var k = 0; k < post.length; k++) {
-        var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion)
-          expansions.push(expansion);
-      }
-    }
-  }
-
-  return expansions;
-}
-
-
-
 /***/ }),
 
 /***/ "./node_modules/glob/node_modules/lru-cache/dist/commonjs/index.js":
@@ -82810,16 +82812,13 @@ exports.escape = escape;
 /*!*************************************************************************!*\
   !*** ./node_modules/glob/node_modules/minimatch/dist/commonjs/index.js ***!
   \*************************************************************************/
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;
-const brace_expansion_1 = __importDefault(__webpack_require__(/*! brace-expansion */ "./node_modules/glob/node_modules/brace-expansion/index.js"));
+const brace_expansion_1 = __webpack_require__(/*! @isaacs/brace-expansion */ "./node_modules/@isaacs/brace-expansion/dist/commonjs/index.js");
 const assert_valid_pattern_js_1 = __webpack_require__(/*! ./assert-valid-pattern.js */ "./node_modules/glob/node_modules/minimatch/dist/commonjs/assert-valid-pattern.js");
 const ast_js_1 = __webpack_require__(/*! ./ast.js */ "./node_modules/glob/node_modules/minimatch/dist/commonjs/ast.js");
 const escape_js_1 = __webpack_require__(/*! ./escape.js */ "./node_modules/glob/node_modules/minimatch/dist/commonjs/escape.js");
@@ -82972,7 +82971,7 @@ const braceExpand = (pattern, options = {}) => {
         // shortcut. no need to expand.
         return [pattern];
     }
-    return (0, brace_expansion_1.default)(pattern);
+    return (0, brace_expansion_1.expand)(pattern);
 };
 exports.braceExpand = braceExpand;
 exports.minimatch.braceExpand = exports.braceExpand;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/cli",
-    "version": "2.113.127",
+    "version": "2.113.128",
     "description": "abaplint - Command Line Interface",
     "funding": "https://github.com/sponsors/larshp",
     "bin": {
@@ -38,17 +38,17 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@abaplint/core": "^2.113.127",
+        "@abaplint/core": "^2.113.128",
         "@types/chai": "^4.3.20",
         "@types/minimist": "^1.2.5",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^24.0.0",
+        "@types/node": "^24.0.1",
         "@types/progress": "^2.0.7",
         "chai": "^4.5.0",
         "p-limit": "^3.1.0",
         "chalk": "^5.4.1",
-        "eslint": "^9.28.0",
-        "glob": "^11.0.2",
+        "eslint": "^9.29.0",
+        "glob": "^11.0.3",
         "json5": "^2.2.3",
         "memfs": "^4.17.2",
         "minimist": "^1.2.8",