@awsless/cli 0.1.40 → 0.1.42

package/dist/bin.js

@@ -188726,7 +188726,7 @@ var TERM_STOP = /* @__PURE__ */ new Set([
   "{",
   "}"
 ]);
-var Parser = class {
+var Parser$1 = class {
   text;
   defaultOperator;
   pos = 0;
@@ -188985,7 +188985,7 @@ var Parser = class {
 };
 var unescape3 = (text2) => text2.replace(/\\(.)/g, "$1");
 var parseQueryString = (text2, defaultOperator) => {
-  const parser2 = new Parser(text2, defaultOperator);
+  const parser2 = new Parser$1(text2, defaultOperator);
   const clauses = parser2.parseClauses();
   parser2.skipSpace();
   if (!parser2.eof())
@@ -189397,7 +189397,9 @@ var resolveMinimumShouldMatch = (spec, count) => {
 var boolQuery = ({ must, filter: filter2, should, mustNot, minimumShouldMatch, boost = 1 }) => {
   if (must.length + filter2.length + should.length + mustNot.length === 0)
     return matchAll(boost);
-  const msm = minimumShouldMatch === undefined ? should.length > 0 && must.length === 0 && filter2.length === 0 ? 1 : 0 : resolveMinimumShouldMatch(minimumShouldMatch, should.length);
+  const optionalOnly = should.length > 0 && must.length === 0 && filter2.length === 0;
+  const requested = minimumShouldMatch === undefined ? 0 : resolveMinimumShouldMatch(minimumShouldMatch, should.length);
+  const msm = optionalOnly ? Math.max(1, requested) : requested;
   return { match: (unit) => {
     let score = 0;
     for (const query of must) {
@@ -190238,6 +190240,507 @@ var compileStringNode = (ctx, node, settings2) => {
       });
   }
 };
+var DocField = class {
+  values;
+  constructor(values) {
+    this.values = values;
+  }
+};
+var ParamsBag = class {
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+};
+var OPERATORS = [
+  "&&",
+  "||",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "?",
+  ":",
+  "!",
+  "<",
+  ">",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "(",
+  ")",
+  "[",
+  "]",
+  ".",
+  ",",
+  ";"
+];
+var REJECTED_BEFORE = [
+  "<<<",
+  ">>>",
+  "<<",
+  ">>",
+  "++",
+  "--",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "===",
+  "!==",
+  "?:",
+  "->",
+  "::"
+];
+var REJECTED_AFTER = [
+  "&",
+  "|",
+  "^",
+  "~",
+  "=",
+  "{",
+  "}"
+];
+var tokenize = (source) => {
+  const tokens = [];
+  let i4 = 0;
+  while (i4 < source.length) {
+    const char = source[i4];
+    if (/\s/.test(char)) {
+      i4++;
+      continue;
+    }
+    if (/[0-9]/.test(char) || char === "." && /[0-9]/.test(source[i4 + 1] ?? "")) {
+      const match2 = /^[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?[lLfFdD]?/.exec(source.slice(i4));
+      tokens.push({
+        kind: "number",
+        value: Number.parseFloat(match2[0].replace(/[lLfFdD]$/, ""))
+      });
+      i4 += match2[0].length;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      let j4 = i4 + 1;
+      let text2 = "";
+      while (j4 < source.length && source[j4] !== char) {
+        if (source[j4] === "\\")
+          j4++;
+        text2 += source[j4];
+        j4++;
+      }
+      if (j4 >= source.length)
+        throw illegalArgument(`Unterminated string in script: ${source}`);
+      tokens.push({
+        kind: "string",
+        value: text2
+      });
+      i4 = j4 + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(char)) {
+      const match2 = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(source.slice(i4));
+      tokens.push({
+        kind: "name",
+        value: match2[0]
+      });
+      i4 += match2[0].length;
+      continue;
+    }
+    const rejected = REJECTED_BEFORE.find((candidate) => source.startsWith(candidate, i4)) ?? (OPERATORS.some((candidate) => source.startsWith(candidate, i4)) ? undefined : REJECTED_AFTER.find((candidate) => source.startsWith(candidate, i4)));
+    if (rejected)
+      throw unsupported2(`the "${rejected}" operator in scripts`);
+    const op = OPERATORS.find((candidate) => source.startsWith(candidate, i4));
+    if (!op)
+      throw unsupported2(`the "${char}" character in scripts`);
+    tokens.push({
+      kind: "op",
+      value: op
+    });
+    i4 += op.length;
+  }
+  tokens.push({ kind: "end" });
+  return tokens;
+};
+var truthy = (value) => {
+  if (typeof value !== "boolean")
+    throw illegalArgument("Script conditions must evaluate to a boolean");
+  return value;
+};
+var number4 = (value, what) => {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  throw illegalArgument(`Script operator ${what} needs numbers, got ${describe3(value)}`);
+};
+var describe3 = (value) => {
+  if (value === null)
+    return "null";
+  if (value instanceof DocField)
+    return "doc field";
+  if (value instanceof ParamsBag)
+    return "params";
+  if (Array.isArray(value))
+    return "list";
+  return typeof value;
+};
+var equal = (a4, b3) => {
+  if (a4 instanceof DocField || b3 instanceof DocField)
+    throw illegalArgument("Compare doc['field'].value, not the field itself");
+  return a4 === b3;
+};
+var contains = (list2, value) => list2.some((entry) => equal(entry, value));
+var member = (target2, name, args, source) => {
+  if (target2 instanceof ParamsBag) {
+    if (args)
+      throw unsupported2(`calling "${name}" on params`);
+    const value = target2.params[name];
+    return value === undefined ? null : value;
+  }
+  if (target2 instanceof DocField) {
+    switch (name) {
+      case "value":
+        if (args)
+          break;
+        return target2.values[0] ?? null;
+      case "values":
+        if (args)
+          break;
+        return target2.values;
+      case "length":
+      case "size":
+        return target2.values.length;
+      case "empty":
+      case "isEmpty":
+        return target2.values.length === 0;
+      case "contains":
+        if (args?.length !== 1)
+          break;
+        return contains(target2.values, args[0]);
+    }
+    throw unsupported2(`"${name}" on a doc field in scripts (${source})`);
+  }
+  if (Array.isArray(target2)) {
+    switch (name) {
+      case "length":
+      case "size":
+        return target2.length;
+      case "empty":
+      case "isEmpty":
+        return target2.length === 0;
+      case "contains":
+        if (args?.length !== 1)
+          break;
+        return contains(target2, args[0]);
+    }
+    throw unsupported2(`"${name}" on a list in scripts (${source})`);
+  }
+  if (typeof target2 === "string") {
+    switch (name) {
+      case "length":
+        return target2.length;
+      case "isEmpty":
+      case "empty":
+        return target2.length === 0;
+      case "toLowerCase":
+        return target2.toLowerCase();
+      case "toUpperCase":
+        return target2.toUpperCase();
+      case "contains":
+      case "startsWith":
+      case "endsWith":
+      case "equals":
+        if (args?.length !== 1 || typeof args[0] !== "string")
+          break;
+        if (name === "equals")
+          return target2 === args[0];
+        if (name === "contains")
+          return target2.includes(args[0]);
+        return name === "startsWith" ? target2.startsWith(args[0]) : target2.endsWith(args[0]);
+    }
+    throw unsupported2(`"${name}" on a string in scripts (${source})`);
+  }
+  if (target2 === null)
+    throw illegalArgument(`Cannot access "${name}" on null in script: ${source}`);
+  throw unsupported2(`"${name}" on a ${describe3(target2)} in scripts (${source})`);
+};
+var mathFunction = (name, args) => {
+  switch (name) {
+    case "max":
+      return Math.max(...args);
+    case "min":
+      return Math.min(...args);
+    case "abs":
+      return Math.abs(args[0]);
+    case "floor":
+      return Math.floor(args[0]);
+    case "ceil":
+      return Math.ceil(args[0]);
+    case "round":
+      return Math.round(args[0]);
+    case "sqrt":
+      return Math.sqrt(args[0]);
+    case "pow":
+      return Math.pow(args[0], args[1]);
+    case "log":
+      return Math.log(args[0]);
+  }
+  throw unsupported2(`"Math.${name}" in scripts`);
+};
+var Parser = class {
+  tokens;
+  source;
+  pos = 0;
+  constructor(tokens, source) {
+    this.tokens = tokens;
+    this.source = source;
+  }
+  parse() {
+    if (this.isName("return"))
+      this.pos++;
+    const node = this.ternary();
+    if (this.isOp(";"))
+      this.pos++;
+    if (this.peek().kind !== "end")
+      throw unsupported2(`multi-statement scripts (${this.source})`);
+    return node;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  isOp(value) {
+    const token = this.peek();
+    return token.kind === "op" && token.value === value;
+  }
+  isName(value) {
+    const token = this.peek();
+    return token.kind === "name" && token.value === value;
+  }
+  expectOp(value) {
+    if (!this.isOp(value))
+      throw illegalArgument(`Expected "${value}" in script: ${this.source}`);
+    this.pos++;
+  }
+  ternary() {
+    const condition = this.or();
+    if (!this.isOp("?"))
+      return condition;
+    this.pos++;
+    const whenTrue = this.ternary();
+    this.expectOp(":");
+    const whenFalse = this.ternary();
+    return (scope) => truthy(condition(scope)) ? whenTrue(scope) : whenFalse(scope);
+  }
+  or() {
+    let left = this.and();
+    while (this.isOp("||")) {
+      this.pos++;
+      const right = this.and();
+      const current = left;
+      left = (scope) => truthy(current(scope)) || truthy(right(scope));
+    }
+    return left;
+  }
+  and() {
+    let left = this.equality();
+    while (this.isOp("&&")) {
+      this.pos++;
+      const right = this.equality();
+      const current = left;
+      left = (scope) => truthy(current(scope)) && truthy(right(scope));
+    }
+    return left;
+  }
+  equality() {
+    let left = this.relational();
+    while (this.isOp("==") || this.isOp("!=")) {
+      const op = this.peek().value;
+      this.pos++;
+      const right = this.relational();
+      const current = left;
+      left = (scope) => op === "==" === equal(current(scope), right(scope));
+    }
+    return left;
+  }
+  relational() {
+    let left = this.additive();
+    while (this.isOp("<") || this.isOp("<=") || this.isOp(">") || this.isOp(">=")) {
+      const op = this.peek().value;
+      this.pos++;
+      const right = this.additive();
+      const current = left;
+      left = (scope) => {
+        const a4 = number4(current(scope), op);
+        const b3 = number4(right(scope), op);
+        return op === "<" ? a4 < b3 : op === "<=" ? a4 <= b3 : op === ">" ? a4 > b3 : a4 >= b3;
+      };
+    }
+    return left;
+  }
+  additive() {
+    let left = this.multiplicative();
+    while (this.isOp("+") || this.isOp("-")) {
+      const op = this.peek().value;
+      this.pos++;
+      const right = this.multiplicative();
+      const current = left;
+      left = (scope) => {
+        const a4 = current(scope);
+        const b3 = right(scope);
+        if (op === "+" && (typeof a4 === "string" || typeof b3 === "string"))
+          return `${String(a4)}${String(b3)}`;
+        return op === "+" ? number4(a4, op) + number4(b3, op) : number4(a4, op) - number4(b3, op);
+      };
+    }
+    return left;
+  }
+  multiplicative() {
+    let left = this.unary();
+    while (this.isOp("*") || this.isOp("/") || this.isOp("%")) {
+      const op = this.peek().value;
+      this.pos++;
+      const right = this.unary();
+      const current = left;
+      left = (scope) => {
+        const a4 = number4(current(scope), op);
+        const b3 = number4(right(scope), op);
+        return op === "*" ? a4 * b3 : op === "/" ? a4 / b3 : a4 % b3;
+      };
+    }
+    return left;
+  }
+  unary() {
+    if (this.isOp("!")) {
+      this.pos++;
+      const operand = this.unary();
+      return (scope) => !truthy(operand(scope));
+    }
+    if (this.isOp("-")) {
+      this.pos++;
+      const operand = this.unary();
+      return (scope) => -number4(operand(scope), "-");
+    }
+    return this.postfix();
+  }
+  postfix() {
+    let node = this.primary();
+    while (true) {
+      if (this.isOp(".")) {
+        this.pos++;
+        const token = this.peek();
+        if (token.kind !== "name")
+          throw illegalArgument(`Expected a member name in script: ${this.source}`);
+        this.pos++;
+        const name = token.value;
+        const args = this.isOp("(") ? this.arguments() : undefined;
+        const target2 = node;
+        node = (scope) => member(target2(scope), name, args?.map((arg) => arg(scope)), this.source);
+        continue;
+      }
+      if (this.isOp("[")) {
+        this.pos++;
+        const key = this.ternary();
+        this.expectOp("]");
+        const target2 = node;
+        node = (scope) => index(target2(scope), key(scope), this.source);
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+  arguments() {
+    this.expectOp("(");
+    const args = [];
+    if (!this.isOp(")")) {
+      args.push(this.ternary());
+      while (this.isOp(",")) {
+        this.pos++;
+        args.push(this.ternary());
+      }
+    }
+    this.expectOp(")");
+    return args;
+  }
+  primary() {
+    const token = this.peek();
+    if (token.kind === "number") {
+      this.pos++;
+      return () => token.value;
+    }
+    if (token.kind === "string") {
+      this.pos++;
+      return () => token.value;
+    }
+    if (token.kind === "op" && token.value === "(") {
+      this.pos++;
+      const inner = this.ternary();
+      this.expectOp(")");
+      return inner;
+    }
+    if (token.kind === "name") {
+      this.pos++;
+      switch (token.value) {
+        case "true":
+          return () => true;
+        case "false":
+          return () => false;
+        case "null":
+          return () => null;
+        case "params":
+          return (scope) => new ParamsBag(scope.params);
+        case "doc": {
+          this.expectOp("[");
+          const key = this.ternary();
+          this.expectOp("]");
+          return (scope) => {
+            const name = key(scope);
+            if (typeof name !== "string")
+              throw illegalArgument(`doc[] needs a field name in script: ${this.source}`);
+            return new DocField(scope.field(name));
+          };
+        }
+        case "Math": {
+          this.expectOp(".");
+          const name = this.peek();
+          if (name.kind !== "name")
+            throw illegalArgument(`Expected a Math function in script: ${this.source}`);
+          this.pos++;
+          const args = this.arguments();
+          return (scope) => mathFunction(name.value, args.map((arg) => number4(arg(scope), `Math.${name.value}`)));
+        }
+      }
+      throw unsupported2(`the "${token.value}" identifier in scripts (${this.source})`);
+    }
+    throw illegalArgument(`Unexpected token in script: ${this.source}`);
+  }
+};
+var index = (target2, key, source) => {
+  if (Array.isArray(target2)) {
+    if (typeof key !== "number")
+      throw illegalArgument(`List index must be a number in script: ${source}`);
+    return target2[key] ?? null;
+  }
+  if (target2 instanceof ParamsBag) {
+    if (typeof key !== "string")
+      throw illegalArgument(`params key must be a string in script: ${source}`);
+    const value = target2.params[key];
+    return value === undefined ? null : value;
+  }
+  throw unsupported2(`indexing a ${describe3(target2)} in scripts (${source})`);
+};
+var cache3 = /* @__PURE__ */ new Map;
+var compileScript = (source) => {
+  const cached2 = cache3.get(source);
+  if (cached2)
+    return cached2;
+  const node = new Parser(tokenize(source), source).parse();
+  cache3.set(source, node);
+  return node;
+};
 var LONG_MAX = 2 ** 63;
 var LONG_MIN = -(2 ** 63);
 var parseSort = (sort2) => {
@@ -190254,8 +190757,10 @@ var parseSort = (sort2) => {
     if (!isPlainObject3(entry))
       throw illegalArgument("sort entries must be strings or objects");
     for (const [field, options2] of Object.entries(entry)) {
-      if (field === "_script")
-        throw unsupported2("script sorting");
+      if (field === "_script") {
+        specs.push(makeScriptSpec(options2));
+        continue;
+      }
       if (field === "_geo_distance")
         throw unsupported2("geo distance sorting");
       specs.push(makeSpec(field, isPlainObject3(options2) ? options2 : { order: options2 }));
@@ -190263,6 +190768,44 @@ var parseSort = (sort2) => {
   }
   return specs;
 };
+var makeScriptSpec = (options2) => {
+  if (!isPlainObject3(options2))
+    throw illegalArgument("_script sort needs an object");
+  for (const key of Object.keys(options2))
+    if (![
+      "type",
+      "order",
+      "script",
+      "mode",
+      "nested"
+    ].includes(key))
+      throw unsupported2(`the "${key}" _script sort option`);
+  if (options2.nested !== undefined)
+    throw unsupported2("nested script sorting");
+  if (options2.mode !== undefined)
+    throw unsupported2('the "mode" _script sort option');
+  const type = options2.type === undefined ? undefined : String(options2.type);
+  if (type !== "number" && type !== "string")
+    throw illegalArgument(`_script sort needs a type of "number" or "string", got [${String(options2.type)}]`);
+  const script2 = options2.script;
+  if (!isPlainObject3(script2))
+    throw illegalArgument("_script sort needs a script object");
+  if (script2.lang !== undefined && script2.lang !== "painless")
+    throw unsupported2(`the "${String(script2.lang)}" script language`);
+  if (script2.id !== undefined)
+    throw unsupported2("stored scripts");
+  const source = script2.source ?? script2.inline;
+  if (typeof source !== "string")
+    throw illegalArgument("_script sort needs a script source");
+  const params = isPlainObject3(script2.params) ? script2.params : {};
+  const spec = makeSpec("_script", { order: options2.order });
+  spec.script = {
+    run: compileScript(source),
+    type,
+    params
+  };
+  return spec;
+};
 var makeSpec = (field, options2) => {
   for (const key of Object.keys(options2))
     if (![
@@ -190352,11 +190895,43 @@ var reduce = (values, mode, order) => {
     }
   }
 };
+var scriptFieldValues = (ctx, doc2) => (name) => {
+  const field = resolveField(ctx.index.mapping, name);
+  if (!field)
+    throw illegalArgument(`No field found for [${name}] in mapping`);
+  if (field.type === "object" || field.type === "nested")
+    throw illegalArgument(`Fielddata is not supported on field [${name}] of type [${field.type}]`);
+  if (field.type === "text" && field.mapping.fielddata !== true)
+    throw illegalArgument(TEXT_SORT_ERROR.replace("FIELD", name));
+  return comparableValues(doc2, field);
+};
+var scriptSortValue = (ctx, doc2, spec) => {
+  const { run, type, params } = spec.script;
+  const result = run({
+    field: scriptFieldValues(ctx, doc2),
+    params
+  });
+  if (result === null)
+    return null;
+  if (result instanceof DocField)
+    throw illegalArgument("A script sort must return a value, not doc['field']");
+  if (Array.isArray(result) || typeof result === "object")
+    throw illegalArgument("A script sort must return a number or string");
+  if (type === "string")
+    return String(result);
+  if (typeof result === "boolean")
+    return result ? 1 : 0;
+  if (typeof result === "string")
+    throw illegalArgument(`A script sort of type number returned the string [${result}]`);
+  return result;
+};
 var sortValueOf = (ctx, doc2, score, spec) => {
   if (spec.field === "_score")
     return score;
   if (spec.field === "_doc")
     return doc2.order;
+  if (spec.script)
+    return scriptSortValue(ctx, doc2, spec);
   const field = requireSortableField(ctx, spec.field, spec.unmappedType);
   if (!field)
     return null;
@@ -190431,7 +191006,7 @@ var isAfter = (hit, cursor3, specs) => {
 var renderSortValue = (ctx, value, spec) => {
   if (value !== null)
     return typeof value === "boolean" ? value ? 1 : 0 : value;
-  if (spec.field === "_score" || spec.field === "_doc")
+  if (spec.field === "_score" || spec.field === "_doc" || spec.script)
     return null;
   const field = resolveField(ctx.index.mapping, spec.field);
   if (!(field ? isNumericType(field.type) || field.type === "date" || field.type === "boolean" : spec.unmappedType !== "keyword"))
@@ -190598,13 +191173,13 @@ var subResults = (agg, subAggs, units) => {
   return subAggs === undefined ? {} : runAggregations(agg, subAggs, units);
 };
 var compileFilter = (agg, query) => {
-  const cache3 = /* @__PURE__ */ new Map;
+  const cache4 = /* @__PURE__ */ new Map;
   return (unit) => {
-    const index = unit.root.index;
-    let compiled = cache3.get(index);
+    const index2 = unit.root.index;
+    let compiled = cache4.get(index2);
     if (!compiled) {
-      compiled = compileQuery(agg.contextFor(index), query);
-      cache3.set(index, compiled);
+      compiled = compileQuery(agg.contextFor(index2), query);
+      cache4.set(index2, compiled);
     }
     return compiled.match(unit) !== undefined;
   };
@@ -191138,10 +191713,10 @@ var readBoolean = (value, what) => {
 var readInteger = (value, what) => {
   if (value === undefined || value === null)
     return;
-  const number4 = typeof value === "number" ? value : Number(value);
-  if (!Number.isInteger(number4))
+  const number5 = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(number5))
     throw illegalArgument(`[${what}] must be an integer`);
-  return number4;
+  return number5;
 };
 var queryFromParams = (params) => {
   const q3 = params.get("q");
@@ -191175,16 +191750,16 @@ var resolveQuery = (body, params) => {
     throw illegalArgument("Cannot combine the q parameter with a request body query");
   return fromParams ?? body.query;
 };
-var collectMatches = (index, query, now) => {
-  const ctx = createContext(index, now);
+var collectMatches = (index2, query, now) => {
+  const ctx = createContext(index2, now);
   let compiled;
   try {
     compiled = compileQuery(ctx, query);
   } catch (error53) {
-    throw wrapSearchError(error53, index.name);
+    throw wrapSearchError(error53, index2.name);
   }
   const hits = [];
-  for (const doc2 of index.docs.values()) {
+  for (const doc2 of index2.docs.values()) {
     const score = compiled.match(doc2);
     if (score !== undefined)
       hits.push({
@@ -191194,7 +191769,7 @@ var collectMatches = (index, query, now) => {
       });
   }
   return {
-    index,
+    index: index2,
     ctx,
     hits
   };
@@ -191203,8 +191778,8 @@ var countDocuments = (store2, indices, body, params) => {
   const query = resolveQuery(body ?? {}, params);
   let count = 0;
   const now = Date.now();
-  for (const index of store2.resolve(indices))
-    count += collectMatches(index, query, now).hits.length;
+  for (const index2 of store2.resolve(indices))
+    count += collectMatches(index2, query, now).hits.length;
   return count;
 };
 var deleteByQuery = (store2, indices, body, params) => {
@@ -191213,9 +191788,9 @@ var deleteByQuery = (store2, indices, body, params) => {
     throw illegalArgument("query is missing");
   let deleted = 0;
   const now = Date.now();
-  for (const index of store2.resolve(indices))
-    for (const hit of collectMatches(index, query, now).hits) {
-      index.delete(hit.doc.id);
+  for (const index2 of store2.resolve(indices))
+    for (const hit of collectMatches(index2, query, now).hits) {
+      index2.delete(hit.doc.id);
       deleted++;
     }
   return deleted;
@@ -191253,15 +191828,15 @@ var search = (store2, request) => {
   const indices = store2.resolve(request.indices);
   const now = started;
   const matches = [];
-  for (const index of indices) {
-    const matched = collectMatches(index, query, now);
+  for (const index2 of indices) {
+    const matched = collectMatches(index2, query, now);
     if (minScore !== undefined)
       matched.hits = matched.hits.filter((hit) => hit.score >= minScore);
     try {
       for (const hit of matched.hits)
         hit.sort = specs.map((spec) => sortValueOf(matched.ctx, hit.doc, hit.score, spec));
     } catch (error53) {
-      throw wrapSearchError(error53, index.name);
+      throw wrapSearchError(error53, index2.name);
     }
     matches.push(matched);
   }
@@ -191345,7 +191920,7 @@ var runAggs = (spec, hits, contexts, indices) => {
   const agg = {
     contextFor: (name) => contexts.get(name),
     scores,
-    allDocs: () => indices.flatMap((index) => [...index.docs.values()])
+    allDocs: () => indices.flatMap((index2) => [...index2.docs.values()])
   };
   try {
     return runAggregations(agg, spec, hits.map((h4) => h4.doc));
@@ -191376,8 +191951,8 @@ var optionalBody = (request) => {
     throw illegalArgument("request body must be a JSON object");
   return request.body;
 };
-var writeResponse = (index, result) => ({
-  _index: index.name,
+var writeResponse = (index2, result) => ({
+  _index: index2.name,
   _id: result.doc.id,
   _version: result.doc.version,
   result: result.result,
@@ -191385,17 +191960,17 @@ var writeResponse = (index, result) => ({
   _seq_no: result.doc.seqNo,
   _primary_term: 1
 });
-var getResponse = (index, id, sourceFilter) => {
-  const doc2 = index.get(id);
+var getResponse = (index2, id, sourceFilter) => {
+  const doc2 = index2.get(id);
   if (!doc2)
     return {
-      _index: index.name,
+      _index: index2.name,
       _id: id,
       found: false
     };
   const source = applySourceFilter(doc2.source, sourceFilter);
   return {
-    _index: index.name,
+    _index: index2.name,
     _id: id,
     _version: doc2.version,
     _seq_no: doc2.seqNo,
@@ -191472,17 +192047,17 @@ var parseBulkBody = (raw, defaultIndex) => {
   }
   return items;
 };
-var bulkError = (error53, index, id) => {
+var bulkError = (error53, index2, id) => {
   if (!(error53 instanceof OpenSearchError))
     throw error53;
   return {
-    _index: index,
+    _index: index2,
     _id: id ?? null,
     status: error53.status,
     error: {
       type: error53.type,
       reason: error53.reason,
-      index,
+      index: index2,
       index_uuid: "_na_",
       shard: "0"
     }
@@ -191497,12 +192072,12 @@ var runBulk = (store2, request, defaultIndex) => {
     const id = item.meta._id === undefined ? undefined : String(item.meta._id);
     try {
       if (item.action === "delete") {
-        const index2 = store2.indices.get(indexName);
-        if (!index2)
+        const index3 = store2.indices.get(indexName);
+        if (!index3)
           throw indexNotFound(indexName);
         if (id === undefined)
           throw illegalArgument("Validation Failed: 1: id is missing;");
-        const doc2 = index2.delete(id);
+        const doc2 = index3.delete(id);
         return { delete: {
           _index: indexName,
           _id: id,
@@ -191514,20 +192089,20 @@ var runBulk = (store2, request, defaultIndex) => {
           status: doc2 ? 200 : 404
         } };
       }
-      const index = store2.getOrCreate(indexName);
+      const index2 = store2.getOrCreate(indexName);
       if (item.action === "update") {
         if (id === undefined)
           throw illegalArgument("Validation Failed: 1: id is missing;");
-        const result2 = index.update(id, item.source);
+        const result2 = index2.update(id, item.source);
         return { update: {
-          ...writeResponse(index, result2),
+          ...writeResponse(index2, result2),
           status: 200
         } };
       }
       const create = item.action === "create" || item.meta.op_type === "create";
-      const result = index.put(id ?? generateId(), item.source, { create });
+      const result = index2.put(id ?? generateId(), item.source, { create });
       return { [item.action]: {
-        ...writeResponse(index, result),
+        ...writeResponse(index2, result),
         status: result.result === "created" ? 201 : 200
       } };
     } catch (error53) {
@@ -191546,14 +192121,14 @@ var catIndices = (store2, params, expression) => {
   if (format3 !== "json")
     throw unsupported2(`the "${format3}" cat format (use format=json)`);
   const indices = expression === undefined ? [...store2.indices.values()] : store2.resolve(expression);
-  return ok(indices.map((index) => ({
+  return ok(indices.map((index2) => ({
     health: "green",
     status: "open",
-    index: index.name,
-    uuid: index.uuid,
+    index: index2.name,
+    uuid: index2.uuid,
     pri: "1",
     rep: "1",
-    "docs.count": String(index.docs.size),
+    "docs.count": String(index2.docs.size),
     "docs.deleted": "0",
     "store.size": "0b",
     "pri.store.size": "0b"
@@ -191595,13 +192170,13 @@ var mgetDocs = (store2, request, defaultIndex) => {
     for (const doc2 of body.docs) {
       if (!isPlainObject3(doc2))
         throw illegalArgument("docs entries must be objects");
-      const index = doc2._index === undefined ? defaultIndex : String(doc2._index);
-      if (index === undefined)
+      const index2 = doc2._index === undefined ? defaultIndex : String(doc2._index);
+      if (index2 === undefined)
         throw illegalArgument("Validation Failed: 1: index is missing;");
       if (doc2._id === undefined)
         throw illegalArgument("Validation Failed: 1: id is missing;");
       entries2.push({
-        index,
+        index: index2,
         id: String(doc2._id),
         filter: doc2._source === undefined ? filter2 : parseSourceFilter(doc2._source)
       });
@@ -191609,8 +192184,8 @@ var mgetDocs = (store2, request, defaultIndex) => {
   else
     throw illegalArgument("Validation Failed: 1: no documents to get;");
   return ok({ docs: entries2.map((entry) => {
-    const index = store2.indices.get(entry.index);
-    if (!index) {
+    const index2 = store2.indices.get(entry.index);
+    if (!index2) {
       const error53 = indexNotFound(entry.index);
       return {
         _index: entry.index,
@@ -191622,17 +192197,17 @@ var mgetDocs = (store2, request, defaultIndex) => {
         }
       };
     }
-    return getResponse(index, entry.id, entry.filter);
+    return getResponse(index2, entry.id, entry.filter);
   }) });
 };
 var putDocument = (store2, request, indexName, id, forceCreate) => {
   const source = requireBody(request);
-  const index = store2.getOrCreate(indexName);
+  const index2 = store2.getOrCreate(indexName);
   const create = forceCreate || request.params.get("op_type") === "create";
-  if (create && id !== undefined && index.get(id))
+  if (create && id !== undefined && index2.get(id))
     throw versionConflict(indexName, id);
-  const result = index.put(id ?? generateId(), source, { create });
-  return ok(writeResponse(index, result), result.result === "created" ? 201 : 200);
+  const result = index2.put(id ?? generateId(), source, { create });
+  return ok(writeResponse(index2, result), result.result === "created" ? 201 : 200);
 };
 var createRoutes = (store2) => {
   const route = (methods, pattern, handler) => ({
@@ -191721,14 +192296,14 @@ var createRoutes = (store2) => {
     }),
     route("GET", "/_mapping", () => {
       const result = {};
-      for (const index of store2.indices.values())
-        result[index.name] = { mappings: index.mapping };
+      for (const index2 of store2.indices.values())
+        result[index2.name] = { mappings: index2.mapping };
       return ok(result);
     }),
     route("GET", "/_all", () => {
       const result = {};
-      for (const index of store2.indices.values())
-        result[index.name] = index.describe();
+      for (const index2 of store2.indices.values())
+        result[index2.name] = index2.describe();
       return ok(result);
     }),
     route("HEAD", "/:index", (_request, path6) => {
@@ -191737,8 +192312,8 @@ var createRoutes = (store2) => {
     }),
     route("GET", "/:index", (_request, path6) => {
       const result = {};
-      for (const index of store2.resolve(path6.index))
-        result[index.name] = index.describe();
+      for (const index2 of store2.resolve(path6.index))
+        result[index2.name] = index2.describe();
       return ok(result);
     }),
     route("PUT", "/:index", (request, path6) => {
@@ -191765,33 +192340,33 @@ var createRoutes = (store2) => {
     }),
     route("GET", "/:index/_mapping", (_request, path6) => {
       const result = {};
-      for (const index of store2.resolve(path6.index))
-        result[index.name] = { mappings: index.mapping };
+      for (const index2 of store2.resolve(path6.index))
+        result[index2.name] = { mappings: index2.mapping };
       return ok(result);
     }),
     route("PUT,POST", "/:index/_mapping", (request, path6) => {
       const body = requireBody(request);
-      for (const index of store2.resolve(path6.index))
-        index.putMapping(body);
+      for (const index2 of store2.resolve(path6.index))
+        index2.putMapping(body);
       return ok({ acknowledged: true });
     }),
     route("GET", "/:index/_settings", (_request, path6) => {
       const result = {};
-      for (const index of store2.resolve(path6.index))
-        result[index.name] = { settings: index.describe().settings };
+      for (const index2 of store2.resolve(path6.index))
+        result[index2.name] = { settings: index2.describe().settings };
       return ok(result);
     }),
     route("POST", "/:index/_doc", (request, path6) => putDocument(store2, request, path6.index, undefined, false)),
     route("PUT,POST", "/:index/_doc/:id", (request, path6) => putDocument(store2, request, path6.index, path6.id, false)),
     route("PUT,POST", "/:index/_create/:id", (request, path6) => putDocument(store2, request, path6.index, path6.id, true)),
     route("GET", "/:index/_doc/:id", (request, path6) => {
-      const index = store2.get(path6.index);
-      const response = getResponse(index, path6.id, sourceFilterFromParams(request.params));
+      const index2 = store2.get(path6.index);
+      const response = getResponse(index2, path6.id, sourceFilterFromParams(request.params));
       return ok(response, response.found ? 200 : 404);
     }),
     route("HEAD", "/:index/_doc/:id", (_request, path6) => {
-      const index = store2.get(path6.index);
-      return ok(undefined, index.get(path6.id) ? 200 : 404);
+      const index2 = store2.get(path6.index);
+      return ok(undefined, index2.get(path6.id) ? 200 : 404);
     }),
     route("GET", "/:index/_source/:id", (request, path6) => {
       const doc2 = store2.get(path6.index).get(path6.id);
@@ -191800,14 +192375,14 @@ var createRoutes = (store2) => {
       return ok(applySourceFilter(doc2.source, sourceFilterFromParams(request.params)) ?? {});
     }),
     route("HEAD", "/:index/_source/:id", (_request, path6) => {
-      const index = store2.get(path6.index);
-      return ok(undefined, index.get(path6.id) ? 200 : 404);
+      const index2 = store2.get(path6.index);
+      return ok(undefined, index2.get(path6.id) ? 200 : 404);
     }),
     route("DELETE", "/:index/_doc/:id", (_request, path6) => {
-      const index = store2.get(path6.index);
-      const doc2 = index.delete(path6.id);
+      const index2 = store2.get(path6.index);
+      const doc2 = index2.delete(path6.id);
       return ok({
-        _index: index.name,
+        _index: index2.name,
         _id: path6.id,
         _version: doc2 ? doc2.version + 1 : 1,
         result: doc2 ? "deleted" : "not_found",
@@ -191817,10 +192392,10 @@ var createRoutes = (store2) => {
       }, doc2 ? 200 : 404);
     }),
     route("POST", "/:index/_update/:id", (request, path6) => {
-      const index = store2.get(path6.index);
+      const index2 = store2.get(path6.index);
       const body = requireBody(request);
-      const result = index.update(path6.id, body);
-      const response = writeResponse(index, result);
+      const result = index2.update(path6.id, body);
+      const response = writeResponse(index2, result);
       const sourceParam = request.params.get("_source") ?? (body._source === true ? "true" : undefined);
       if (sourceParam !== undefined && sourceParam !== "false")
         response.get = {
@@ -192557,9 +193132,9 @@ ${(errors4.trim() || output.trim()).slice(-2000)}`);
             const hashes = files.map((file3) => $hash(join33(staticDir, file3)));
             const version3 = $combine(...hashes).pipe((hashes2) => {
               const hash3 = createHash19("sha1");
-              for (const [index, file3] of files.entries()) {
+              for (const [index2, file3] of files.entries()) {
                 hash3.update(file3);
-                hash3.update(hashes2[index]);
+                hash3.update(hashes2[index2]);
               }
               return hash3.digest("hex");
             });
@@ -192734,9 +193309,9 @@ var storeFeature = defineFeature({
     for (const [id, props] of Object.entries(ctx.stackConfig.stores ?? {})) {
       const group = new Group(ctx.stack, "store", id);
       const folder = getFeatureFolder("store", ctx.stack.name, id);
-      for (const [index, rule] of Object.entries(props.lifecycle ?? [])) {
+      for (const [index2, rule] of Object.entries(props.lifecycle ?? [])) {
         bucket.addLifecycleRule({
-          id: `expire-${kebabCase(`${folder}${rule.prefix ?? `rule-${index}`}`)}`,
+          id: `expire-${kebabCase(`${folder}${rule.prefix ?? `rule-${index2}`}`)}`,
           enabled: true,
           prefix: `${folder}${rule.prefix ?? ""}`,
           expiration: { days: toDays11(rule.expiration) }
@@ -192827,12 +193402,12 @@ var createDataReset = (props) => {
         const client2 = new Client5({ node: `http://localhost:${search2.port}` });
         for (const stack of props.stackConfigs) {
           for (const [id, searchProps] of Object.entries(stack.searchs ?? {})) {
-            const index = formatSearchIndexName(stack.name, id);
+            const index2 = formatSearchIndexName(stack.name, id);
             try {
-              await client2.indices.delete({ index });
+              await client2.indices.delete({ index: index2 });
             } catch {}
             await applySearchIndex(client2, {
-              index,
+              index: index2,
               mappings: resolveSearchMappings(searchProps),
               settings: searchProps.settings
             });
@@ -192862,11 +193437,11 @@ var formatTableKeys = (props) => {
     hash: props.hash,
     ...props.sort ? { sort: props.sort } : {},
     ...props.indexes && Object.keys(props.indexes).length > 0 ? {
-      indexes: Object.fromEntries(Object.entries(props.indexes).map(([name, index]) => [
+      indexes: Object.fromEntries(Object.entries(props.indexes).map(([name, index2]) => [
         name,
         {
-          hash: index.hash,
-          ...index.sort ? { sort: index.sort } : {}
+          hash: index2.hash,
+          ...index2.sort ? { sort: index2.sort } : {}
         }
       ]))
     } : {}
@@ -192883,9 +193458,9 @@ var createTableInput = (name, props) => {
   const attributes = new Set([
     props.hash,
     props.sort,
-    ...Object.values(props.indexes ?? {}).map((index) => [
-      index.hash,
-      index.sort
+    ...Object.values(props.indexes ?? {}).map((index2) => [
+      index2.hash,
+      index2.sort
     ])
   ].flat(2).filter((v3) => !!v3));
   return {
@@ -192899,12 +193474,12 @@ var createTableInput = (name, props) => {
       AttributeName: name2,
       AttributeType: attributeTypes[props.fields?.[name2] ?? "string"]
     })),
-    GlobalSecondaryIndexes: props.indexes && Object.keys(props.indexes).length > 0 ? Object.entries(props.indexes).map(([name2, index]) => ({
+    GlobalSecondaryIndexes: props.indexes && Object.keys(props.indexes).length > 0 ? Object.entries(props.indexes).map(([name2, index2]) => ({
       IndexName: name2,
-      Projection: { ProjectionType: constantCase(index.projection) },
+      Projection: { ProjectionType: constantCase(index2.projection) },
       KeySchema: [
-        ...index.hash.map((name3) => ({ AttributeName: name3, KeyType: "HASH" })),
-        ...(index.sort ?? []).map((name3) => ({ AttributeName: name3, KeyType: "RANGE" }))
+        ...index2.hash.map((name3) => ({ AttributeName: name3, KeyType: "HASH" })),
+        ...(index2.sort ?? []).map((name3) => ({ AttributeName: name3, KeyType: "RANGE" }))
       ]
     })) : undefined,
     StreamSpecification: props.stream ? {
@@ -193036,9 +193611,9 @@ var tableFeature = defineFeature({
           resourceName: name
         });
         const sort2 = props.sort ? keyValue(props.sort) : "undefined";
-        const indexes = props.indexes && Object.keys(props.indexes).length > 0 ? `{ ${Object.entries(props.indexes).map(([indexName, index]) => {
-          const indexSort = index.sort ? `; sort: ${keyValue(index.sort)}` : "";
-          return `'${indexName}': { hash: ${keyValue(index.hash)}${indexSort} }`;
+        const indexes = props.indexes && Object.keys(props.indexes).length > 0 ? `{ ${Object.entries(props.indexes).map(([indexName, index2]) => {
+          const indexSort = index2.sort ? `; sort: ${keyValue(index2.sort)}` : "";
+          return `'${indexName}': { hash: ${keyValue(index2.hash)}${indexSort} }`;
         }).join("; ")} }` : "undefined";
         list2.addType(name, `{
 			readonly name: '${tableName}'
@@ -193100,9 +193675,9 @@ var tableFeature = defineFeature({
         const attributes = new Set([
           props.hash,
           props.sort,
-          ...Object.values(props.indexes ?? {}).map((index) => [
-            index.hash,
-            index.sort
+          ...Object.values(props.indexes ?? {}).map((index2) => [
+            index2.hash,
+            index2.sort
           ])
         ].flat(2).filter((v3) => !!v3));
         const types2 = {
@@ -193131,15 +193706,15 @@ var tableFeature = defineFeature({
         pointInTimeRecovery: {
           enabled: props.pointInTimeRecovery
         },
-        globalSecondaryIndex: Object.entries(props.indexes ?? {}).map(([name2, index]) => ({
+        globalSecondaryIndex: Object.entries(props.indexes ?? {}).map(([name2, index2]) => ({
           name: name2,
-          projectionType: constantCase(index.projection),
+          projectionType: constantCase(index2.projection),
           keySchema: [
-            ...index.hash.map((name3) => ({
+            ...index2.hash.map((name3) => ({
               keyType: "HASH",
               attributeName: name3
             })),
-            ...(index.sort ?? []).map((name3) => ({
+            ...(index2.sort ?? []).map((name3) => ({
               keyType: "RANGE",
               attributeName: name3
             }))
@@ -193637,11 +194212,11 @@ var vpcFeature = defineFeature({
       const type = _type;
       const subnetIds = subnetIdsByType[type];
       for (const [i4, zone] of zones.entries()) {
-        const index = i4 + 1;
-        const id = `${type}-${index}`;
+        const index2 = i4 + 1;
+        const id = `${type}-${index2}`;
         const subnet = new aws.Subnet(group, id, {
           tags: {
-            Name: `${ctx.app.name}--${type}-${index}`
+            Name: `${ctx.app.name}--${type}-${index2}`
           },
           vpcId: vpc.id,
           cidrBlock: `10.0.${block2}.0/20`,
@@ -194610,14 +195185,14 @@ var import_aws_cron_expression_validator = __toESM(require_src6(), 1);
 var RateExpressionSchema = exports_external.custom((value) => {
   return exports_external.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
     const [str] = rate.split(" ");
-    const number4 = parseInt(str);
-    return number4 > 0;
+    const number5 = parseInt(str);
+    return number5 > 0;
   }).safeParse(value).success;
 }, { message: "Invalid rate expression" }).transform((rate) => {
   const [str] = rate.split(" ");
-  const number4 = parseInt(str);
+  const number5 = parseInt(str);
   const more = rate.endsWith("s");
-  if (more && number4 === 1) {
+  if (more && number5 === 1) {
     return `rate(${rate.substring(0, rate.length - 1)})`;
   }
   return `rate(${rate})`;
@@ -195038,15 +195613,15 @@ function patchErrorMessageFormatter(message2, args) {
 }
 var PatchError = function(_super) {
   __extends(PatchError2, _super);
-  function PatchError2(message2, name, index, operation, tree) {
+  function PatchError2(message2, name, index2, operation, tree) {
     var _newTarget = this.constructor;
-    var _this = _super.call(this, patchErrorMessageFormatter(message2, { name, index, operation, tree })) || this;
+    var _this = _super.call(this, patchErrorMessageFormatter(message2, { name, index: index2, operation, tree })) || this;
     _this.name = name;
-    _this.index = index;
+    _this.index = index2;
     _this.operation = operation;
     _this.tree = tree;
     Object.setPrototypeOf(_this, _newTarget.prototype);
-    _this.message = patchErrorMessageFormatter(message2, { name, index, operation, tree });
+    _this.message = patchErrorMessageFormatter(message2, { name, index: index2, operation, tree });
     return _this;
   }
   return PatchError2;
@@ -195123,7 +195698,7 @@ function getValueByPointer(document2, pointer) {
   applyOperation(document2, getOriginalDestination);
   return getOriginalDestination.value;
 }
-function applyOperation(document2, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
+function applyOperation(document2, operation, validateOperation, mutateDocument, banPrototypeModifications, index2) {
   if (validateOperation === undefined) {
     validateOperation = false;
   }
@@ -195133,8 +195708,8 @@ function applyOperation(document2, operation, validateOperation, mutateDocument,
   if (banPrototypeModifications === undefined) {
     banPrototypeModifications = true;
   }
-  if (index === undefined) {
-    index = 0;
+  if (index2 === undefined) {
+    index2 = 0;
   }
   if (validateOperation) {
     if (typeof validateOperation == "function") {
@@ -195161,7 +195736,7 @@ function applyOperation(document2, operation, validateOperation, mutateDocument,
     } else if (operation.op === "test") {
       returnValue.test = _areEquals(document2, operation.value);
       if (returnValue.test === false) {
-        throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
+        throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index2, operation, document2);
       }
       returnValue.newDocument = document2;
       return returnValue;
@@ -195174,7 +195749,7 @@ function applyOperation(document2, operation, validateOperation, mutateDocument,
       return returnValue;
     } else {
       if (validateOperation) {
-        throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document2);
+        throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index2, operation, document2);
       } else {
         return returnValue;
       }
@@ -195222,18 +195797,18 @@ function applyOperation(document2, operation, validateOperation, mutateDocument,
           key = obj.length;
         } else {
           if (validateOperation && !isInteger(key)) {
-            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document2);
+            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index2, operation, document2);
           } else if (isInteger(key)) {
             key = ~~key;
           }
         }
         if (t2 >= len) {
           if (validateOperation && operation.op === "add" && key > obj.length) {
-            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document2);
+            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index2, operation, document2);
           }
           var returnValue = arrOps[operation.op].call(operation, obj, key, document2);
           if (returnValue.test === false) {
-            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
+            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index2, operation, document2);
           }
           return returnValue;
         }
@@ -195241,14 +195816,14 @@ function applyOperation(document2, operation, validateOperation, mutateDocument,
         if (t2 >= len) {
           var returnValue = objOps[operation.op].call(operation, obj, key, document2);
           if (returnValue.test === false) {
-            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
+            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index2, operation, document2);
           }
           return returnValue;
         }
       }
       obj = obj[key];
       if (validateOperation && t2 < len && (!obj || typeof obj !== "object")) {
-        throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document2);
+        throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index2, operation, document2);
       }
     }
   }
@@ -195276,44 +195851,44 @@ function applyPatch(document2, patch, validateOperation, mutateDocument, banProt
   results.newDocument = document2;
   return results;
 }
-function applyReducer(document2, operation, index) {
+function applyReducer(document2, operation, index2) {
   var operationResult = applyOperation(document2, operation);
   if (operationResult.test === false) {
-    throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
+    throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index2, operation, document2);
   }
   return operationResult.newDocument;
 }
-function validator(operation, index, document2, existingPathFragment) {
+function validator(operation, index2, document2, existingPathFragment) {
   if (typeof operation !== "object" || operation === null || Array.isArray(operation)) {
-    throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document2);
+    throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index2, operation, document2);
   } else if (!objOps[operation.op]) {
-    throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document2);
+    throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index2, operation, document2);
   } else if (typeof operation.path !== "string") {
-    throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document2);
+    throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index2, operation, document2);
   } else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) {
-    throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document2);
+    throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index2, operation, document2);
   } else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") {
-    throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document2);
+    throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index2, operation, document2);
   } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === undefined) {
-    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document2);
+    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index2, operation, document2);
   } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) {
-    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document2);
+    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index2, operation, document2);
   } else if (document2) {
     if (operation.op == "add") {
       var pathLen = operation.path.split("/").length;
       var existingPathLen = existingPathFragment.split("/").length;
       if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
-        throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document2);
+        throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index2, operation, document2);
       }
     } else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
       if (operation.path !== existingPathFragment) {
-        throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document2);
+        throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index2, operation, document2);
       }
     } else if (operation.op === "move" || operation.op === "copy") {
       var existingValue = { op: "_get", path: operation.from, value: undefined };
       var error53 = validate3([existingValue], document2);
       if (error53 && error53.name === "OPERATION_PATH_UNRESOLVABLE") {
-        throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document2);
+        throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index2, operation, document2);
       }
     }
   }
@@ -195859,7 +196434,7 @@ var logConfigError = (error53) => {
     const length2 = issue2.path.length;
     const end = ["}"];
     issue2.path.forEach((path6, i4) => {
-      const index = i4 + 1;
+      const index2 = i4 + 1;
       const entry = context[path6];
       if (typeof entry !== "undefined") {
         context = entry;
@@ -195868,30 +196443,30 @@ var logConfigError = (error53) => {
       }
       if (typeof path6 === "string") {
         const key = path6 + `: `;
-        if (index === length2 || endType(entry)) {
+        if (index2 === length2 || endType(entry)) {
           const space = " ".repeat(key.length);
           const value = format3(entry);
           const error54 = icon.arrow.top.repeat(value.length);
-          message2.push(codeLine(key + color2.warning(value), index));
-          message2.push(codeLine(space + color2.error(error54), index));
+          message2.push(codeLine(key + color2.warning(value), index2));
+          message2.push(codeLine(space + color2.error(error54), index2));
         } else if (Array.isArray(entry)) {
-          message2.push(codeLine(key + "[", index));
-          end.unshift(codeLine("]", index));
+          message2.push(codeLine(key + "[", index2));
+          end.unshift(codeLine("]", index2));
         } else if (typeof entry === "object") {
-          if (inStack && index === 3) {
+          if (inStack && index2 === 3) {
             const name = error53.data.stacks[issue2.path[1]].name;
-            message2.push(codeLine("name: " + color2.info(`"${name}"`) + ",", index));
+            message2.push(codeLine("name: " + color2.info(`"${name}"`) + ",", index2));
           }
-          message2.push(codeLine(key + "{", index));
-          end.unshift(codeLine("}", index));
+          message2.push(codeLine(key + "{", index2));
+          end.unshift(codeLine("}", index2));
         }
       } else if (typeof entry === "object") {
-        message2.push(codeLine("{", index));
-        end.unshift(codeLine("}", index));
+        message2.push(codeLine("{", index2));
+        end.unshift(codeLine("}", index2));
       } else if (typeof entry === "string") {
-        message2.push(codeLine(color2.warning(`"${entry}"`), index));
+        message2.push(codeLine(color2.warning(`"${entry}"`), index2));
         const error54 = icon.arrow.top.repeat(entry.length + 2);
-        message2.push(codeLine(color2.error(error54), index));
+        message2.push(codeLine(color2.error(error54), index2));
       }
     });
     logs_exports.error([...message2, ...end].join(`
@@ -196591,7 +197166,7 @@ import {
   deleteItem,
   DynamoDBClient,
   getItem,
-  number as number4,
+  number as number5,
   object as object2,
   optional as optional2,
   putItem,
@@ -196895,8 +197470,8 @@ function buildLocalizeFn(args) {
       const width = options2?.width ? String(options2.width) : args.defaultWidth;
       valuesArray = args.values[width] || args.values[defaultWidth];
     }
-    const index = args.argumentCallback ? args.argumentCallback(value) : value;
-    return valuesArray[index];
+    const index2 = args.argumentCallback ? args.argumentCallback(value) : value;
+    return valuesArray[index2];
   };
 }
 
@@ -197021,19 +197596,19 @@ var formattingDayPeriodValues = {
   }
 };
 var ordinalNumber = (dirtyNumber, _options) => {
-  const number4 = Number(dirtyNumber);
-  const rem100 = number4 % 100;
+  const number5 = Number(dirtyNumber);
+  const rem100 = number5 % 100;
   if (rem100 > 20 || rem100 < 10) {
     switch (rem100 % 10) {
       case 1:
-        return number4 + "st";
+        return number5 + "st";
       case 2:
-        return number4 + "nd";
+        return number5 + "nd";
       case 3:
-        return number4 + "rd";
+        return number5 + "rd";
     }
   }
-  return number4 + "th";
+  return number5 + "th";
 };
 var localize = {
   ordinalNumber,
@@ -197212,7 +197787,7 @@ var match2 = {
     defaultMatchWidth: "wide",
     parsePatterns: parseQuarterPatterns,
     defaultParseWidth: "any",
-    valueCallback: (index) => index + 1
+    valueCallback: (index2) => index2 + 1
   }),
   month: buildMatchFn({
     matchPatterns: matchMonthPatterns,
@@ -197305,9 +197880,9 @@ function getWeek(date5, options2) {
 }
 
 // ../../node_modules/.pnpm/date-fns@4.4.0/node_modules/date-fns/_lib/addLeadingZeros.js
-function addLeadingZeros(number4, targetLength) {
-  const sign2 = number4 < 0 ? "-" : "";
-  const output = Math.abs(number4).toString().padStart(targetLength, "0");
+function addLeadingZeros(number5, targetLength) {
+  const sign2 = number5 < 0 ? "-" : "";
+  const output = Math.abs(number5).toString().padStart(targetLength, "0");
   return sign2 + output;
 }
 
@@ -198101,7 +198676,7 @@ var table2 = define2("awsless-deployments", {
     appId: string4(),
     id: string4(),
     branch: string4(),
-    seq: number4(),
+    seq: number5(),
     createdAt: string4(),
     user: optional2(string4()),
     commit: optional2(string4()),
@@ -199397,7 +199972,7 @@ var formatFileName = (test, error53) => {
   }
   return name.join("");
 };
-var logTestError = (index, event, test, error53) => {
+var logTestError = (index2, event, test, error53) => {
   if (error53.stack) {
     debug(`Test error in ${test.file} \u203A ${test.name}: ${error53.message}
 ${error53.stack}`);
@@ -199410,7 +199985,7 @@ ${error53.stack}`);
   ].join(" ");
   logs_exports.error([
     color2.error.inverse.bold(` FAIL `),
-    color2.dim(`(${index}/${event.errors.length + event.failed})`),
+    color2.dim(`(${index2}/${event.errors.length + event.failed})`),
     color2.dim(icon.arrow.right),
     formatFileName(test, error53),
     color2.dim(icon.arrow.right),
@@ -199497,7 +200072,7 @@ var runTests = async (tests, stackFilters = [], testFilters = [], opts) => {
     return [dir, fingerprint];
   }))));
   for (const test of selected) {
-    for (const [index, dir] of test.paths.entries()) {
+    for (const [index2, dir] of test.paths.entries()) {
       const files = await countTestFiles(dir);
       if (files === 0) {
         continue;
@@ -199517,7 +200092,7 @@ var runTests = async (tests, stackFilters = [], testFilters = [], opts) => {
         continue;
       }
       pending.push({
-        name: test.paths.length > 1 ? `${test.name}:${index}` : test.name,
+        name: test.paths.length > 1 ? `${test.name}:${index2}` : test.name,
         stack: test.name,
         dir,
         file: file3,
@@ -200506,9 +201081,9 @@ var createSqsServer = (props) => {
         throw new Error(`Unknown local queue: ${input.QueueUrl}`);
       }
       const store2 = storeOf(queue);
-      const index = store2.findIndex((message3) => message3.receipt === input.ReceiptHandle);
-      if (index >= 0) {
-        store2.splice(index, 1);
+      const index2 = store2.findIndex((message3) => message3.receipt === input.ReceiptHandle);
+      if (index2 >= 0) {
+        store2.splice(index2, 1);
       }
       return {};
     },
@@ -200520,9 +201095,9 @@ var createSqsServer = (props) => {
       const store2 = storeOf(queue);
       return {
         Successful: (input.Entries ?? []).map((entry) => {
-          const index = store2.findIndex((message3) => message3.receipt === entry.ReceiptHandle);
-          if (index >= 0) {
-            store2.splice(index, 1);
+          const index2 = store2.findIndex((message3) => message3.receipt === entry.ReceiptHandle);
+          if (index2 >= 0) {
+            store2.splice(index2, 1);
           }
           return { Id: entry.Id };
         }),
@@ -204016,8 +204591,8 @@ var startDev = async (props) => {
   await mkdir12(join52(directories.output, "local"), { recursive: true });
   await writeFile16(watchdogPath(), WATCHDOG_SOURCE);
   const routerPorts = {};
-  Object.keys(appConfig.router ?? {}).forEach((id, index) => {
-    routerPorts[id] = props.port + 1 + index;
+  Object.keys(appConfig.router ?? {}).forEach((id, index2) => {
+    routerPorts[id] = props.port + 1 + index2;
   });
   const firstBoot = props.pool.peek("session") === undefined;
   props.pool.begin();
@@ -204788,11 +205363,11 @@ var clearCache = (program3) => {
       });
       await workspace.hydrate(app);
       let distributionId;
-      let cache3;
+      let cache4;
       try {
         distributionId = await shared.entry("icon", "distribution-id", name);
         const entry = shared.entry("icon", "cache", name);
-        cache3 = { bucket: await entry.bucket, prefix: entry.prefix };
+        cache4 = { bucket: await entry.bucket, prefix: entry.prefix };
       } catch {
         throw new ExpectedError(`The icon resource hasn't been deployed yet.`);
       }
@@ -204812,14 +205387,14 @@ var clearCache = (program3) => {
           let continuationToken;
           while (true) {
             const result = await s3Client.send(new ListObjectsV2Command({
-              Bucket: cache3.bucket,
-              Prefix: cache3.prefix,
+              Bucket: cache4.bucket,
+              Prefix: cache4.prefix,
               ContinuationToken: continuationToken,
               MaxKeys: 1000
             }));
             if (result.Contents && result.Contents.length > 0) {
               await s3Client.send(new DeleteObjectsCommand({
-                Bucket: cache3.bucket,
+                Bucket: cache4.bucket,
                 Delete: {
                   Objects: result.Contents.map((obj) => ({
                     Key: obj.Key
@@ -204915,11 +205490,11 @@ var clearCache2 = (program3) => {
       });
       await workspace.hydrate(app);
       let distributionId;
-      let cache3;
+      let cache4;
       try {
         distributionId = await shared.entry("image", "distribution-id", name);
         const entry = shared.entry("image", "cache", name);
-        cache3 = { bucket: await entry.bucket, prefix: entry.prefix };
+        cache4 = { bucket: await entry.bucket, prefix: entry.prefix };
       } catch {
         throw new ExpectedError(`The image resource hasn't been deployed yet.`);
       }
@@ -204939,14 +205514,14 @@ var clearCache2 = (program3) => {
           let continuationToken;
           while (true) {
             const result = await s3Client.send(new ListObjectsV2Command2({
-              Bucket: cache3.bucket,
-              Prefix: cache3.prefix,
+              Bucket: cache4.bucket,
+              Prefix: cache4.prefix,
               ContinuationToken: continuationToken,
               MaxKeys: 1000
             }));
             if (result.Contents && result.Contents.length > 0) {
               await s3Client.send(new DeleteObjectsCommand2({
-                Bucket: cache3.bucket,
+                Bucket: cache4.bucket,
                 Delete: {
                   Objects: result.Contents.map((obj) => ({
                     Key: obj.Key
@@ -205212,10 +205787,10 @@ var pruneSiteVersions = async (props) => {
   } while (cursor3);
   const cutoff = subHours(new Date, 24);
   const garbage = [...unreferenced.values()].filter((entry) => isBefore(entry.newest, cutoff)).flatMap((entry) => entry.keys);
-  for (let index = 0;index < garbage.length; index += 1000) {
+  for (let index2 = 0;index2 < garbage.length; index2 += 1000) {
     await props.s3.send(new DeleteObjectsCommand3({
       Bucket: props.bucket,
-      Delete: { Objects: garbage.slice(index, index + 1000).map((key) => ({ Key: key })) }
+      Delete: { Objects: garbage.slice(index2, index2 + 1000).map((key) => ({ Key: key })) }
     }));
   }
 };
@@ -205939,12 +206514,12 @@ var nodes3 = new Int32Array([
 var bdd3 = import_endpoints5.BinaryDecisionDiagram.from(nodes3, root4, _data3.conditions, _data3.results);
 
 // ../../node_modules/.pnpm/@aws-sdk+client-iot-data-plane@3.1113.0/node_modules/@aws-sdk/client-iot-data-plane/dist-es/endpoint/endpointResolver.js
-var cache3 = new import_endpoints6.EndpointCache({
+var cache4 = new import_endpoints6.EndpointCache({
   size: 50,
   params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
 });
 var defaultEndpointResolver3 = (endpointParams, context = {}) => {
-  return cache3.get(endpointParams, () => import_endpoints6.decideEndpoint(bdd3, {
+  return cache4.get(endpointParams, () => import_endpoints6.decideEndpoint(bdd3, {
     endpointParams,
     logger: context.logger
   }));
@@ -206714,11 +207289,11 @@ var getHttpAuthExtensionConfiguration3 = (runtimeConfig) => {
   let _credentials = runtimeConfig.credentials;
   return {
     setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
+      const index2 = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index2 === -1) {
         _httpAuthSchemes.push(httpAuthScheme);
       } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+        _httpAuthSchemes.splice(index2, 1, httpAuthScheme);
       }
     },
     httpAuthSchemes() {
@@ -207135,9 +207710,9 @@ var sinon;
   }
   function ensureArgs(name, behavior, args) {
     const property = name.replace(/sArg/, "ArgAt");
-    const index = behavior[property];
-    if (index >= args.length) {
-      throw new TypeError(`${name} failed: ${index + 1} arguments required but only ${args.length} present`);
+    const index2 = behavior[property];
+    if (index2 >= args.length) {
+      throw new TypeError(`${name} failed: ${index2 + 1} arguments required but only ${args.length} present`);
     }
   }
   function callCallback(behavior, args) {
@@ -207222,8 +207797,8 @@ var sinon;
       }
       throw new Error("Unable to find wrapped method");
     },
-    onCall: function onCall(index) {
-      return this.stub.onCall(index);
+    onCall: function onCall(index2) {
+      return this.stub.onCall(index2);
     },
     onFirstCall: function onFirstCall() {
       return this.stub.onFirstCall();
@@ -207412,44 +207987,44 @@ var sinon;
       fake.exceptionCreator = undefined;
       fake.callsThrough = false;
     },
-    callsArg: function callsArg(fake, index) {
-      if (typeof index !== "number") {
+    callsArg: function callsArg(fake, index2) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
-      fake.callArgAt = index;
+      fake.callArgAt = index2;
       fake.callbackArguments = [];
       fake.callbackContext = undefined;
       fake.callArgProp = undefined;
       fake.callbackAsync = false;
       fake.callsThrough = false;
     },
-    callsArgOn: function callsArgOn(fake, index, context) {
-      if (typeof index !== "number") {
+    callsArgOn: function callsArgOn(fake, index2, context) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
-      fake.callArgAt = index;
+      fake.callArgAt = index2;
       fake.callbackArguments = [];
       fake.callbackContext = context;
       fake.callArgProp = undefined;
       fake.callbackAsync = false;
       fake.callsThrough = false;
     },
-    callsArgWith: function callsArgWith(fake, index) {
-      if (typeof index !== "number") {
+    callsArgWith: function callsArgWith(fake, index2) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
-      fake.callArgAt = index;
+      fake.callArgAt = index2;
       fake.callbackArguments = slice(arguments, 2);
       fake.callbackContext = undefined;
       fake.callArgProp = undefined;
       fake.callbackAsync = false;
       fake.callsThrough = false;
     },
-    callsArgOnWith: function callsArgWith(fake, index, context) {
-      if (typeof index !== "number") {
+    callsArgOnWith: function callsArgWith(fake, index2, context) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
-      fake.callArgAt = index;
+      fake.callArgAt = index2;
       fake.callbackArguments = slice(arguments, 3);
       fake.callbackContext = context;
       fake.callArgProp = undefined;
@@ -207515,19 +208090,19 @@ var sinon;
       fake.exceptionCreator = undefined;
       fake.fakeFn = undefined;
     },
-    returnsArg: function returnsArg(fake, index) {
-      if (typeof index !== "number") {
+    returnsArg: function returnsArg(fake, index2) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
       fake.callsThrough = false;
-      fake.returnArgAt = index;
+      fake.returnArgAt = index2;
     },
-    throwsArg: function throwsArg(fake, index) {
-      if (typeof index !== "number") {
+    throwsArg: function throwsArg(fake, index2) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
       fake.callsThrough = false;
-      fake.throwArgAt = index;
+      fake.throwArgAt = index2;
     },
     returnsThis: function returnsThis(fake) {
       fake.returnThis = true;
@@ -207544,11 +208119,11 @@ var sinon;
       fake.fakeFn = undefined;
       fake.callsThrough = false;
     },
-    resolvesArg: function resolvesArg(fake, index) {
-      if (typeof index !== "number") {
+    resolvesArg: function resolvesArg(fake, index2) {
+      if (typeof index2 !== "number") {
         throw new TypeError("argument index is not number");
       }
-      fake.resolveArgAt = index;
+      fake.resolveArgAt = index2;
       fake.returnValue = undefined;
       fake.resolve = true;
       fake.resolveThis = false;
@@ -208450,8 +209025,8 @@ var sinon;
     matchingFakes: function() {
       return emptyFakes;
     },
-    getCall: function getCall(index) {
-      let i5 = index;
+    getCall: function getCall(index2) {
+      let i5 = index2;
       if (i5 < 0) {
         i5 += this.callCount;
       }
@@ -209403,11 +209978,11 @@ ${join54(calls, `
       this.resetHistory();
       this.resetBehavior();
     },
-    onCall: function onCall(index) {
-      if (!this.behaviors[index]) {
-        this.behaviors[index] = behavior.create(this);
+    onCall: function onCall(index2) {
+      if (!this.behaviors[index2]) {
+        this.behaviors[index2] = behavior.create(this);
       }
-      return this.behaviors[index];
+      return this.behaviors[index2];
     },
     onFirstCall: function onFirstCall() {
       return this.onCall(0);
@@ -209947,10 +210522,10 @@ ${wrappedMethodDesc.stackTraceError.stack}`;
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index, spies) {
+  function checkAdjacentCalls(callMap, spy, index2, spies) {
     var calledBeforeNext = true;
-    if (index !== spies.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    if (index2 !== spies.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -211392,24 +211967,24 @@ ${job.error.stack.split(`
   createMatcher.array.deepEquals = function(expectation) {
     return createMatcher(function(actual) {
       var sameLength = actual.length === expectation.length;
-      return typeOf(actual) === "array" && sameLength && every(actual, function(element, index) {
-        var expected = expectation[index];
+      return typeOf(actual) === "array" && sameLength && every(actual, function(element, index2) {
+        var expected = expectation[index2];
         return typeOf(expected) === "array" && typeOf(element) === "array" ? createMatcher.array.deepEquals(expected).test(element) : deepEqual2(expected, element);
       });
     }, `deepEquals([${iterableToString(expectation)}])`);
   };
   createMatcher.array.startsWith = function(expectation) {
     return createMatcher(function(actual) {
-      return typeOf(actual) === "array" && every(expectation, function(expectedElement, index) {
-        return actual[index] === expectedElement;
+      return typeOf(actual) === "array" && every(expectation, function(expectedElement, index2) {
+        return actual[index2] === expectedElement;
       });
     }, `startsWith([${iterableToString(expectation)}])`);
   };
   createMatcher.array.endsWith = function(expectation) {
     return createMatcher(function(actual) {
       var offset = actual.length - expectation.length;
-      return typeOf(actual) === "array" && every(expectation, function(expectedElement, index) {
-        return actual[offset + index] === expectedElement;
+      return typeOf(actual) === "array" && every(expectation, function(expectedElement, index2) {
+        return actual[offset + index2] === expectedElement;
       });
     }, `endsWith([${iterableToString(expectation)}])`);
   };
@@ -212043,10 +212618,10 @@ ${job.error.stack.split(`
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index, spies) {
+  function checkAdjacentCalls(callMap, spy, index2, spies) {
     var calledBeforeNext = true;
-    if (index !== spies.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    if (index2 !== spies.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -212814,16 +213389,16 @@ ${job.error.stack.split(`
     });
     var encoders = {};
     var decoders = {};
-    function indexCodePointFor(pointer, index2) {
-      if (!index2)
+    function indexCodePointFor(pointer, index3) {
+      if (!index3)
         return null;
-      return index2[pointer] || null;
+      return index3[pointer] || null;
     }
-    function indexPointerFor(code_point, index2) {
-      var pointer = index2.indexOf(code_point);
+    function indexPointerFor(code_point, index3) {
+      var pointer = index3.indexOf(code_point);
       return pointer === -1 ? null : pointer;
     }
-    function index(name) {
+    function index2(name) {
       if (!("encoding-indexes" in global2)) {
         throw Error("Indexes missing." + " Did you forget to include encoding-indexes.js first?");
       }
@@ -212836,7 +213411,7 @@ ${job.error.stack.split(`
         return 59335;
       var offset = 0;
       var code_point_offset = 0;
-      var idx = index("gb18030-ranges");
+      var idx = index2("gb18030-ranges");
       var i5;
       for (i5 = 0;i5 < idx.length; ++i5) {
         var entry = idx[i5];
@@ -212854,7 +213429,7 @@ ${job.error.stack.split(`
         return 7457;
       var offset = 0;
       var pointer_offset = 0;
-      var idx = index("gb18030-ranges");
+      var idx = index2("gb18030-ranges");
       var i5;
       for (i5 = 0;i5 < idx.length; ++i5) {
         var entry = idx[i5];
@@ -212868,7 +213443,7 @@ ${job.error.stack.split(`
       return pointer_offset + code_point - offset;
     }
     function indexShiftJISPointerFor(code_point) {
-      shift_jis_index = shift_jis_index || index("jis0208").map(function(code_point2, pointer) {
+      shift_jis_index = shift_jis_index || index2("jis0208").map(function(code_point2, pointer) {
         return inRange(pointer, 8272, 8835) ? null : code_point2;
       });
       var index_ = shift_jis_index;
@@ -212876,7 +213451,7 @@ ${job.error.stack.split(`
     }
     var shift_jis_index;
     function indexBig5PointerFor(code_point) {
-      big5_index_no_hkscs = big5_index_no_hkscs || index("big5").map(function(code_point2, pointer) {
+      big5_index_no_hkscs = big5_index_no_hkscs || index2("big5").map(function(code_point2, pointer) {
         return pointer < (161 - 129) * 157 ? null : code_point2;
       });
       var index_ = big5_index_no_hkscs;
@@ -213153,27 +213728,27 @@ ${job.error.stack.split(`
     decoders["UTF-8"] = function(options2) {
       return new UTF8Decoder(options2);
     };
-    function SingleByteDecoder(index2, options2) {
+    function SingleByteDecoder(index3, options2) {
       var fatal = options2.fatal;
       this.handler = function(stream, bite) {
         if (bite === end_of_stream)
           return finished;
         if (isASCIIByte(bite))
           return bite;
-        var code_point = index2[bite - 128];
+        var code_point = index3[bite - 128];
         if (code_point === null)
           return decoderError(fatal);
         return code_point;
       };
     }
-    function SingleByteEncoder(index2, options2) {
+    function SingleByteEncoder(index3, options2) {
       var fatal = options2.fatal;
       this.handler = function(stream, code_point) {
         if (code_point === end_of_stream)
           return finished;
         if (isASCIICodePoint(code_point))
           return code_point;
-        var pointer = indexPointerFor(code_point, index2);
+        var pointer = indexPointerFor(code_point, index3);
         if (pointer === null)
           encoderError(code_point);
         return pointer + 128;
@@ -213187,7 +213762,7 @@ ${job.error.stack.split(`
           return;
         category.encodings.forEach(function(encoding) {
           var name = encoding.name;
-          var idx = index(name.toLowerCase());
+          var idx = index2(name.toLowerCase());
           decoders[name] = function(options2) {
             return new SingleByteDecoder(idx, options2);
           };
@@ -213253,7 +213828,7 @@ ${job.error.stack.split(`
           var offset = bite < 127 ? 64 : 65;
           if (inRange(bite, 64, 126) || inRange(bite, 128, 254))
             pointer = (lead - 129) * 190 + (bite - offset);
-          code_point = pointer === null ? null : indexCodePointFor(pointer, index("gb18030"));
+          code_point = pointer === null ? null : indexCodePointFor(pointer, index2("gb18030"));
           if (code_point === null && isASCIIByte(bite))
             stream.prepend(bite);
           if (code_point === null)
@@ -213282,7 +213857,7 @@ ${job.error.stack.split(`
           return encoderError(code_point);
         if (gbk_flag && code_point === 8364)
           return 128;
-        var pointer = indexPointerFor(code_point, index("gb18030"));
+        var pointer = indexPointerFor(code_point, index2("gb18030"));
         if (pointer !== null) {
           var lead = floor(pointer / 190) + 129;
           var trail = pointer % 190;
@@ -213339,7 +213914,7 @@ ${job.error.stack.split(`
             case 1166:
               return [234, 780];
           }
-          var code_point = pointer === null ? null : indexCodePointFor(pointer, index("big5"));
+          var code_point = pointer === null ? null : indexCodePointFor(pointer, index2("big5"));
           if (code_point === null && isASCIIByte(bite))
             stream.prepend(bite);
           if (code_point === null)
@@ -213403,7 +213978,7 @@ ${job.error.stack.split(`
           eucjp_lead = 0;
           var code_point = null;
           if (inRange(lead, 161, 254) && inRange(bite, 161, 254)) {
-            code_point = indexCodePointFor((lead - 161) * 94 + (bite - 161), index(!eucjp_jis0212_flag ? "jis0208" : "jis0212"));
+            code_point = indexCodePointFor((lead - 161) * 94 + (bite - 161), index2(!eucjp_jis0212_flag ? "jis0208" : "jis0212"));
           }
           eucjp_jis0212_flag = false;
           if (!inRange(bite, 161, 254))
@@ -213436,7 +214011,7 @@ ${job.error.stack.split(`
           return [142, code_point - 65377 + 161];
         if (code_point === 8722)
           code_point = 65293;
-        var pointer = indexPointerFor(code_point, index("jis0208"));
+        var pointer = indexPointerFor(code_point, index2("jis0208"));
         if (pointer === null)
           return encoderError(code_point);
         var lead = floor(pointer / 94) + 161;
@@ -213539,7 +214114,7 @@ ${job.error.stack.split(`
             if (inRange(bite, 33, 126)) {
               iso2022jp_decoder_state = states.LeadByte;
               var pointer = (iso2022jp_lead - 33) * 94 + bite - 33;
-              var code_point = indexCodePointFor(pointer, index("jis0208"));
+              var code_point = indexCodePointFor(pointer, index2("jis0208"));
               if (code_point === null)
                 return decoderError(fatal);
               return code_point;
@@ -213627,7 +214202,7 @@ ${job.error.stack.split(`
         }
         if (code_point === 8722)
           code_point = 65293;
-        var pointer = indexPointerFor(code_point, index("jis0208"));
+        var pointer = indexPointerFor(code_point, index2("jis0208"));
         if (pointer === null)
           return encoderError(code_point);
         if (iso2022jp_state !== states.jis0208) {
@@ -213666,7 +214241,7 @@ ${job.error.stack.split(`
             pointer = (lead - lead_offset) * 188 + bite - offset;
           if (inRange(pointer, 8836, 10715))
             return 57344 - 8836 + pointer;
-          var code_point = pointer === null ? null : indexCodePointFor(pointer, index("jis0208"));
+          var code_point = pointer === null ? null : indexCodePointFor(pointer, index2("jis0208"));
           if (code_point === null && isASCIIByte(bite))
             stream.prepend(bite);
           if (code_point === null)
@@ -213731,7 +214306,7 @@ ${job.error.stack.split(`
           euckr_lead = 0;
           if (inRange(bite, 65, 254))
             pointer = (lead - 129) * 190 + (bite - 65);
-          var code_point = pointer === null ? null : indexCodePointFor(pointer, index("euc-kr"));
+          var code_point = pointer === null ? null : indexCodePointFor(pointer, index2("euc-kr"));
           if (pointer === null && isASCIIByte(bite))
             stream.prepend(bite);
           if (code_point === null)
@@ -213754,7 +214329,7 @@ ${job.error.stack.split(`
           return finished;
         if (isASCIICodePoint(code_point))
           return code_point;
-        var pointer = indexPointerFor(code_point, index("euc-kr"));
+        var pointer = indexPointerFor(code_point, index2("euc-kr"));
         if (pointer === null)
           return encoderError(code_point);
         var lead = floor(pointer / 190) + 129;
@@ -214021,7 +214596,7 @@ ${job.error.stack.split(`
       fail(value, true, message3, "==", assert2.ok);
   }
   assert2.ok = ok2;
-  assert2.equal = function equal(actual, expected, message3) {
+  assert2.equal = function equal2(actual, expected, message3) {
     if (actual != expected)
       fail(actual, expected, message3, "==", assert2.equal);
   };
@@ -214924,7 +215499,7 @@ ${job.error.stack.split(`
       castInput: function castInput(value) {
         return value;
       },
-      tokenize: function tokenize(value) {
+      tokenize: function tokenize2(value) {
         return value.split("");
       },
       join: function join54(chars) {
@@ -215237,8 +215812,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       var options2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/), delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [], list4 = [], i5 = 0;
       function parseIndex() {
-        var index = {};
-        list4.push(index);
+        var index2 = {};
+        list4.push(index2);
         while (i5 < diffstr.length) {
           var line = diffstr[i5];
           if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
@@ -215246,19 +215821,19 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
           if (header) {
-            index.index = header[1];
+            index2.index = header[1];
           }
           i5++;
         }
-        parseFileHeader(index);
-        parseFileHeader(index);
-        index.hunks = [];
+        parseFileHeader(index2);
+        parseFileHeader(index2);
+        index2.hunks = [];
         while (i5 < diffstr.length) {
           var _line = diffstr[i5];
           if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
             break;
           } else if (/^@@/.test(_line)) {
-            index.hunks.push(parseHunk());
+            index2.hunks.push(parseHunk());
           } else if (_line && options2.strict) {
             throw new Error("Unknown line " + (i5 + 1) + " " + JSON.stringify(_line));
           } else {
@@ -215266,7 +215841,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
         }
       }
-      function parseFileHeader(index) {
+      function parseFileHeader(index2) {
         var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i5]);
         if (fileHeader) {
           var keyPrefix = fileHeader[1] === "---" ? "old" : "new";
@@ -215275,8 +215850,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           if (/^".*"$/.test(fileName)) {
             fileName = fileName.substr(1, fileName.length - 2);
           }
-          index[keyPrefix + "FileName"] = fileName;
-          index[keyPrefix + "Header"] = (data[1] || "").trim();
+          index2[keyPrefix + "FileName"] = fileName;
+          index2[keyPrefix + "Header"] = (data[1] || "").trim();
           i5++;
         }
       }
@@ -215455,16 +216030,16 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       }
       var currentIndex = 0;
       function processIndex() {
-        var index = uniDiff[currentIndex++];
-        if (!index) {
+        var index2 = uniDiff[currentIndex++];
+        if (!index2) {
           return options2.complete();
         }
-        options2.loadFile(index, function(err, data) {
+        options2.loadFile(index2, function(err, data) {
           if (err) {
             return options2.complete(err);
           }
-          var updatedContent = applyPatch2(data, index, options2);
-          options2.patched(index, updatedContent, function(err2) {
+          var updatedContent = applyPatch2(data, index2, options2);
+          options2.patched(index2, updatedContent, function(err2) {
             if (err2) {
               return options2.complete(err2);
             }
@@ -215703,11 +216278,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     function fileNameChanged(patch) {
       return patch.newFileName && patch.newFileName !== patch.oldFileName;
     }
-    function selectField(index, mine, theirs) {
+    function selectField(index2, mine, theirs) {
       if (mine === theirs) {
         return mine;
       } else {
-        index.conflict = true;
+        index2.conflict = true;
         return {
           mine,
           theirs
@@ -216318,8 +216893,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
     }
     var result = [];
-    $replace(string5, rePropName, function(match3, number5, quote, subString) {
-      result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number5 || match3;
+    $replace(string5, rePropName, function(match3, number6, quote, subString) {
+      result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number6 || match3;
     });
     return result;
   };
@@ -216586,10 +217161,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   var Map2 = getNative(root5, "Map"), nativeCreate = getNative(Object, "create");
   var symbolProto = Symbol2 ? Symbol2.prototype : undefined, symbolToString = symbolProto ? symbolProto.toString : undefined;
   function Hash(entries2) {
-    var index = -1, length2 = entries2 ? entries2.length : 0;
+    var index2 = -1, length2 = entries2 ? entries2.length : 0;
     this.clear();
-    while (++index < length2) {
-      var entry = entries2[index];
+    while (++index2 < length2) {
+      var entry = entries2[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -216622,10 +217197,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   Hash.prototype.has = hashHas;
   Hash.prototype.set = hashSet;
   function ListCache(entries2) {
-    var index = -1, length2 = entries2 ? entries2.length : 0;
+    var index2 = -1, length2 = entries2 ? entries2.length : 0;
     this.clear();
-    while (++index < length2) {
-      var entry = entries2[index];
+    while (++index2 < length2) {
+      var entry = entries2[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -216633,31 +217208,31 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     this.__data__ = [];
   }
   function listCacheDelete(key) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    if (index < 0) {
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    if (index2 < 0) {
       return false;
     }
     var lastIndex = data.length - 1;
-    if (index == lastIndex) {
+    if (index2 == lastIndex) {
       data.pop();
     } else {
-      splice.call(data, index, 1);
+      splice.call(data, index2, 1);
     }
     return true;
   }
   function listCacheGet(key) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    return index < 0 ? undefined : data[index][1];
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    return index2 < 0 ? undefined : data[index2][1];
   }
   function listCacheHas(key) {
     return assocIndexOf(this.__data__, key) > -1;
   }
   function listCacheSet(key, value) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    if (index < 0) {
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    if (index2 < 0) {
       data.push([key, value]);
     } else {
-      data[index][1] = value;
+      data[index2][1] = value;
     }
     return this;
   }
@@ -216667,10 +217242,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   ListCache.prototype.has = listCacheHas;
   ListCache.prototype.set = listCacheSet;
   function MapCache(entries2) {
-    var index = -1, length2 = entries2 ? entries2.length : 0;
+    var index2 = -1, length2 = entries2 ? entries2.length : 0;
     this.clear();
-    while (++index < length2) {
-      var entry = entries2[index];
+    while (++index2 < length2) {
+      var entry = entries2[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -216710,11 +217285,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   }
   function baseGet(object3, path6) {
     path6 = isKey(path6, object3) ? [path6] : castPath(path6);
-    var index = 0, length2 = path6.length;
-    while (object3 != null && index < length2) {
-      object3 = object3[toKey(path6[index++])];
+    var index2 = 0, length2 = path6.length;
+    while (object3 != null && index2 < length2) {
+      object3 = object3[toKey(path6[index2++])];
     }
-    return index && index == length2 ? object3 : undefined;
+    return index2 && index2 == length2 ? object3 : undefined;
   }
   function baseIsNative(value) {
     if (!isObject2(value) || isMasked(value)) {
@@ -216767,8 +217342,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     if (reLeadingDot.test(string5)) {
       result.push("");
     }
-    string5.replace(rePropName, function(match3, number5, quote, string6) {
-      result.push(quote ? string6.replace(reEscapeChar, "$1") : number5 || match3);
+    string5.replace(rePropName, function(match3, number6, quote, string6) {
+      result.push(quote ? string6.replace(reEscapeChar, "$1") : number6 || match3);
     });
     return result;
   });
@@ -216795,12 +217370,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       throw new TypeError(FUNC_ERROR_TEXT);
     }
     var memoized = function() {
-      var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache4 = memoized.cache;
-      if (cache4.has(key)) {
-        return cache4.get(key);
+      var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache5 = memoized.cache;
+      if (cache5.has(key)) {
+        return cache5.get(key);
       }
       var result = func.apply(this, args);
-      memoized.cache = cache4.set(key, result);
+      memoized.cache = cache5.set(key, result);
       return result;
     };
     memoized.cache = new (memoize.Cache || MapCache);
@@ -217264,8 +217839,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     restore: function restore() {
       return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
     },
-    getRequest: function getRequest(index) {
-      return this.requests[index] || null;
+    getRequest: function getRequest(index2) {
+      return this.requests[index2] || null;
     },
     reset: function reset() {
       this.resetBehavior();
@@ -217860,14 +218435,14 @@ ${inspect2(response)}
         clearResponse(this);
         if (this.async) {
           var chunkSize = this.chunkSize || 10;
-          var index = 0;
+          var index2 = 0;
           do {
             this.readyStateChange(FakeXMLHttpRequest.LOADING);
             if (isTextResponse) {
-              this.responseText = this.response += body.substring(index, index + chunkSize);
+              this.responseText = this.response += body.substring(index2, index2 + chunkSize);
             }
-            index += chunkSize;
-          } while (index < body.length);
+            index2 += chunkSize;
+          } while (index2 < body.length);
         }
         this.response = convertResponseBody(this.responseType, contentType2, body);
         if (isTextResponse) {
@@ -218315,8 +218890,8 @@ ${inspect2(response)}
       const value = this.tryConsume(type);
       if (value !== undefined)
         return value;
-      const { type: nextType, index } = this.peek();
-      throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
+      const { type: nextType, index: index2 } = this.peek();
+      throw new TypeError(`Unexpected ${nextType} at ${index2}, expected ${type}: ${DEBUG_URL}`);
     }
     text() {
       let result = "";
@@ -218421,9 +218996,9 @@ ${inspect2(response)}
           throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
         }
         return [
-          value.map((value2, index) => {
+          value.map((value2, index2) => {
             if (typeof value2 !== "string") {
-              throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
+              throw new TypeError(`Expected "${token.name}/${index2}" to be a string`);
             }
             return encodeValue(value2);
           }).join(delimiter2)
@@ -218486,20 +219061,20 @@ ${inspect2(response)}
     const regexp = new RegExp(pattern, flags);
     return { regexp, keys };
   }
-  function* flatten(tokens, index, init) {
-    if (index === tokens.length) {
+  function* flatten(tokens, index2, init) {
+    if (index2 === tokens.length) {
       return yield init;
     }
-    const token = tokens[index];
+    const token = tokens[index2];
     if (token.type === "group") {
       const fork = init.slice();
       for (const seq of flatten(token.tokens, 0, fork)) {
-        yield* flatten(tokens, index + 1, seq);
+        yield* flatten(tokens, index2 + 1, seq);
       }
     } else {
       init.push(token);
     }
-    yield* flatten(tokens, index + 1, init);
+    yield* flatten(tokens, index2 + 1, init);
   }
   function sequenceToRegExp(tokens, delimiter2, keys) {
     let result = "";
@@ -218538,13 +219113,13 @@ ${inspect2(response)}
     return `(?:(?!${values.map(escape2).join("|")}).)`;
   }
   function stringify6(data) {
-    return data.tokens.map(function stringifyToken(token, index, tokens) {
+    return data.tokens.map(function stringifyToken(token, index2, tokens) {
       if (token.type === "text")
         return escapeText(token.value);
       if (token.type === "group") {
         return `{${token.tokens.map(stringifyToken).join("")}}`;
       }
-      const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
+      const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index2 + 1]);
       const key = isSafe ? token.name : JSON.stringify(token.name);
       if (token.type === "param")
         return `:${key}`;
@@ -219931,10 +220506,10 @@ function requireReactIs() {
   return reactIs.exports;
 }
 var reactIsExports = requireReactIs();
-var index = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports);
+var index2 = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports);
 var ReactIs18 = /* @__PURE__ */ _mergeNamespaces({
   __proto__: null,
-  default: index
+  default: index2
 }, [reactIsExports]);
 var reactIsMethods = [
   "isAsyncMode",
@@ -221253,16 +221828,16 @@ var refresh2 = (program3) => {
       }
       const commitAll = options2.commit === true;
       const commitIndexes = Array.isArray(options2.commit) ? options2.commit.flatMap((value) => value.split(",")).filter((value) => value !== "").map((value) => {
-        const index2 = Number(value);
-        if (!Number.isInteger(index2) || index2 < 0 || index2 >= result.operations.length) {
+        const index3 = Number(value);
+        if (!Number.isInteger(index3) || index3 < 0 || index3 >= result.operations.length) {
           throw new ExpectedError(`Invalid state change index: ${value}`);
         }
-        return index2;
+        return index3;
       }) : [];
       let skipped = 0;
-      for (const [index2, entry] of result.operations.entries()) {
+      for (const [index3, entry] of result.operations.entries()) {
         logs_exports.warning([
-          `${color2.warning.bold.inverse(` ${capitalCase(entry.operation)} `)} ${color2.dim(`#${index2}`)}`,
+          `${color2.warning.bold.inverse(` ${capitalCase(entry.operation)} `)} ${color2.dim(`#${index3}`)}`,
           entry.urn
         ].join(`
 `));
@@ -221272,7 +221847,7 @@ var refresh2 = (program3) => {
             logs_exports.message(diffResult);
           }
         }
-        if (commitAll || commitIndexes.includes(index2)) {
+        if (commitAll || commitIndexes.includes(index3)) {
           entry.commit();
           continue;
         }