npm - @nine-lab/nine-mu - Versions diffs - 0.1.408 → 0.1.410 - Mend

@nine-lab/nine-mu 0.1.408 → 0.1.410

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/nine-mu.js +551 -551
package/dist/nine-mu.js.map +1 -1
package/dist/nine-mu.umd.js +1 -1
package/dist/nine-mu.umd.js.map +1 -1
package/package.json +1 -1
package/src/components/ai/NineNaturalQuery.js +3 -25

package/dist/nine-mu.js CHANGED Viewed

@@ -500,9 +500,9 @@ class ParseInputLazyPath {
     return this._cachedPath;
   }
 }
-const handleResult = (ctx, result2) => {
-  if (isValid(result2)) {
-    return { success: true, data: result2.value };
+const handleResult = (ctx, result) => {
+  if (isValid(result)) {
+    return { success: true, data: result.value };
   } else {
     if (!ctx.common.issues.length) {
       throw new Error("Validation failed but no issues detected.");
@@ -573,21 +573,21 @@ let ZodType$1 = class ZodType {
     };
   }
   _parseSync(input) {
-    const result2 = this._parse(input);
-    if (isAsync(result2)) {
+    const result = this._parse(input);
+    if (isAsync(result)) {
       throw new Error("Synchronous parse encountered promise.");
     }
-    return result2;
+    return result;
   }
   _parseAsync(input) {
-    const result2 = this._parse(input);
-    return Promise.resolve(result2);
+    const result = this._parse(input);
+    return Promise.resolve(result);
   }
   parse(data, params) {
-    const result2 = this.safeParse(data, params);
-    if (result2.success)
-      return result2.data;
-    throw result2.error;
+    const result = this.safeParse(data, params);
+    if (result.success)
+      return result.data;
+    throw result.error;
   }
   safeParse(data, params) {
     const ctx = {
@@ -602,8 +602,8 @@ let ZodType$1 = class ZodType {
       data,
       parsedType: getParsedType(data)
     };
-    const result2 = this._parseSync({ data, path: ctx.path, parent: ctx });
-    return handleResult(ctx, result2);
+    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+    return handleResult(ctx, result);
   }
   "~validate"(data) {
     var _a2, _b;
@@ -620,9 +620,9 @@ let ZodType$1 = class ZodType {
     };
     if (!this["~standard"].async) {
       try {
-        const result2 = this._parseSync({ data, path: [], parent: ctx });
-        return isValid(result2) ? {
-          value: result2.value
+        const result = this._parseSync({ data, path: [], parent: ctx });
+        return isValid(result) ? {
+          value: result.value
         } : {
           issues: ctx.common.issues
         };
@@ -636,17 +636,17 @@ let ZodType$1 = class ZodType {
         };
       }
     }
-    return this._parseAsync({ data, path: [], parent: ctx }).then((result2) => isValid(result2) ? {
-      value: result2.value
+    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
+      value: result.value
     } : {
       issues: ctx.common.issues
     });
   }
   async parseAsync(data, params) {
-    const result2 = await this.safeParseAsync(data, params);
-    if (result2.success)
-      return result2.data;
-    throw result2.error;
+    const result = await this.safeParseAsync(data, params);
+    if (result.success)
+      return result.data;
+    throw result.error;
   }
   async safeParseAsync(data, params) {
     const ctx = {
@@ -662,8 +662,8 @@ let ZodType$1 = class ZodType {
       parsedType: getParsedType(data)
     };
     const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
-    const result2 = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
-    return handleResult(ctx, result2);
+    const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+    return handleResult(ctx, result);
   }
   refine(check2, message) {
     const getIssueProperties = (val) => {
@@ -676,13 +676,13 @@ let ZodType$1 = class ZodType {
       }
     };
     return this._refinement((val, ctx) => {
-      const result2 = check2(val);
+      const result = check2(val);
       const setError = () => ctx.addIssue({
         code: ZodIssueCode.custom,
         ...getIssueProperties(val)
       });
-      if (typeof Promise !== "undefined" && result2 instanceof Promise) {
-        return result2.then((data) => {
+      if (typeof Promise !== "undefined" && result instanceof Promise) {
+        return result.then((data) => {
           if (!data) {
             setError();
             return false;
@@ -691,7 +691,7 @@ let ZodType$1 = class ZodType {
           }
         });
       }
-      if (!result2) {
+      if (!result) {
         setError();
         return false;
       } else {
@@ -2186,14 +2186,14 @@ let ZodArray$1 = class ZodArray extends ZodType$1 {
     if (ctx.common.async) {
       return Promise.all([...ctx.data].map((item, i) => {
         return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
-      })).then((result3) => {
-        return ParseStatus.mergeArray(status, result3);
+      })).then((result2) => {
+        return ParseStatus.mergeArray(status, result2);
       });
     }
-    const result2 = [...ctx.data].map((item, i) => {
+    const result = [...ctx.data].map((item, i) => {
       return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
-    return ParseStatus.mergeArray(status, result2);
+    return ParseStatus.mergeArray(status, result);
   }
   get element() {
     return this._def.type;
@@ -2600,18 +2600,18 @@ let ZodUnion$1 = class ZodUnion extends ZodType$1 {
     const { ctx } = this._processInputParams(input);
     const options = this._def.options;
     function handleResults(results) {
-      for (const result2 of results) {
-        if (result2.result.status === "valid") {
-          return result2.result;
+      for (const result of results) {
+        if (result.result.status === "valid") {
+          return result.result;
         }
       }
-      for (const result2 of results) {
-        if (result2.result.status === "dirty") {
-          ctx.common.issues.push(...result2.ctx.common.issues);
-          return result2.result;
+      for (const result of results) {
+        if (result.result.status === "dirty") {
+          ctx.common.issues.push(...result.ctx.common.issues);
+          return result.result;
         }
       }
-      const unionErrors = results.map((result2) => new ZodError(result2.ctx.common.issues));
+      const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union,
         unionErrors
@@ -2649,15 +2649,15 @@ let ZodUnion$1 = class ZodUnion extends ZodType$1 {
           },
           parent: null
         };
-        const result2 = option._parseSync({
+        const result = option._parseSync({
           data: ctx.data,
           path: ctx.path,
           parent: childCtx
         });
-        if (result2.status === "valid") {
-          return result2;
-        } else if (result2.status === "dirty" && !dirty) {
-          dirty = { result: result2, ctx: childCtx };
+        if (result.status === "valid") {
+          return result;
+        } else if (result.status === "dirty" && !dirty) {
+          dirty = { result, ctx: childCtx };
         }
         if (childCtx.common.issues.length) {
           issues.push(childCtx.common.issues);
@@ -3206,43 +3206,43 @@ class ZodEffects extends ZodType$1 {
         return Promise.resolve(processed).then(async (processed2) => {
           if (status.value === "aborted")
             return INVALID;
-          const result2 = await this._def.schema._parseAsync({
+          const result = await this._def.schema._parseAsync({
             data: processed2,
             path: ctx.path,
             parent: ctx
           });
-          if (result2.status === "aborted")
+          if (result.status === "aborted")
             return INVALID;
-          if (result2.status === "dirty")
-            return DIRTY(result2.value);
+          if (result.status === "dirty")
+            return DIRTY(result.value);
           if (status.value === "dirty")
-            return DIRTY(result2.value);
-          return result2;
+            return DIRTY(result.value);
+          return result;
         });
       } else {
         if (status.value === "aborted")
           return INVALID;
-        const result2 = this._def.schema._parseSync({
+        const result = this._def.schema._parseSync({
           data: processed,
           path: ctx.path,
           parent: ctx
         });
-        if (result2.status === "aborted")
+        if (result.status === "aborted")
           return INVALID;
-        if (result2.status === "dirty")
-          return DIRTY(result2.value);
+        if (result.status === "dirty")
+          return DIRTY(result.value);
         if (status.value === "dirty")
-          return DIRTY(result2.value);
-        return result2;
+          return DIRTY(result.value);
+        return result;
       }
     }
     if (effect.type === "refinement") {
       const executeRefinement = (acc) => {
-        const result2 = effect.refinement(acc, checkCtx);
+        const result = effect.refinement(acc, checkCtx);
         if (ctx.common.async) {
-          return Promise.resolve(result2);
+          return Promise.resolve(result);
         }
-        if (result2 instanceof Promise) {
+        if (result instanceof Promise) {
           throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
         }
         return acc;
@@ -3280,18 +3280,18 @@ class ZodEffects extends ZodType$1 {
         });
         if (!isValid(base2))
           return INVALID;
-        const result2 = effect.transform(base2.value, checkCtx);
-        if (result2 instanceof Promise) {
+        const result = effect.transform(base2.value, checkCtx);
+        if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
         }
-        return { status: status.value, value: result2 };
+        return { status: status.value, value: result };
       } else {
         return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base2) => {
           if (!isValid(base2))
             return INVALID;
-          return Promise.resolve(effect.transform(base2.value, checkCtx)).then((result2) => ({
+          return Promise.resolve(effect.transform(base2.value, checkCtx)).then((result) => ({
             status: status.value,
-            value: result2
+            value: result
           }));
         });
       }
@@ -3388,18 +3388,18 @@ let ZodCatch$1 = class ZodCatch extends ZodType$1 {
         issues: []
       }
     };
-    const result2 = this._def.innerType._parse({
+    const result = this._def.innerType._parse({
       data: newCtx.data,
       path: newCtx.path,
       parent: {
         ...newCtx
       }
     });
-    if (isAsync(result2)) {
-      return result2.then((result3) => {
+    if (isAsync(result)) {
+      return result.then((result2) => {
         return {
           status: "valid",
-          value: result3.status === "valid" ? result3.value : this._def.catchValue({
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
             get error() {
               return new ZodError(newCtx.common.issues);
             },
@@ -3410,7 +3410,7 @@ let ZodCatch$1 = class ZodCatch extends ZodType$1 {
     } else {
       return {
         status: "valid",
-        value: result2.status === "valid" ? result2.value : this._def.catchValue({
+        value: result.status === "valid" ? result.value : this._def.catchValue({
           get error() {
             return new ZodError(newCtx.common.issues);
           },
@@ -3523,14 +3523,14 @@ class ZodPipeline extends ZodType$1 {
 }
 let ZodReadonly$1 = class ZodReadonly extends ZodType$1 {
   _parse(input) {
-    const result2 = this._def.innerType._parse(input);
+    const result = this._def.innerType._parse(input);
     const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
       }
       return data;
     };
-    return isAsync(result2) ? result2.then((data) => freeze(data)) : freeze(result2);
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
   }
   unwrap() {
     return this._def.innerType;
@@ -4032,50 +4032,50 @@ function formatError(error, _mapper) {
 }
 const _parse = (_Err) => (schema, value, _ctx, _params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
-  const result2 = schema._zod.run({ value, issues: [] }, ctx);
-  if (result2 instanceof Promise) {
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
-  if (result2.issues.length) {
-    const e = new ((_params == null ? void 0 : _params.Err) ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  if (result.issues.length) {
+    const e = new ((_params == null ? void 0 : _params.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
     captureStackTrace(e, _params == null ? void 0 : _params.callee);
     throw e;
   }
-  return result2.value;
+  return result.value;
 };
 const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result2 = schema._zod.run({ value, issues: [] }, ctx);
-  if (result2 instanceof Promise)
-    result2 = await result2;
-  if (result2.issues.length) {
-    const e = new ((params == null ? void 0 : params.Err) ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new ((params == null ? void 0 : params.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
     captureStackTrace(e, params == null ? void 0 : params.callee);
     throw e;
   }
-  return result2.value;
+  return result.value;
 };
 const _safeParse = (_Err) => (schema, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result2 = schema._zod.run({ value, issues: [] }, ctx);
-  if (result2 instanceof Promise) {
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
-  return result2.issues.length ? {
+  return result.issues.length ? {
     success: false,
-    error: new (_Err ?? $ZodError)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result2.value };
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
 };
 const safeParse$2 = /* @__PURE__ */ _safeParse($ZodRealError);
 const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result2 = schema._zod.run({ value, issues: [] }, ctx);
-  if (result2 instanceof Promise)
-    result2 = await result2;
-  return result2.issues.length ? {
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
     success: false,
-    error: new _Err(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result2.value };
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
 };
 const safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError);
 const cuid = /^[cC][^\s-]{8,}$/;
@@ -4620,13 +4620,13 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       return payload;
     };
     inst._zod.run = (payload, ctx) => {
-      const result2 = inst._zod.parse(payload, ctx);
-      if (result2 instanceof Promise) {
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
         if (ctx.async === false)
           throw new $ZodAsyncError();
-        return result2.then((result3) => runChecks(result3, checks, ctx));
+        return result.then((result2) => runChecks(result2, checks, ctx));
       }
-      return runChecks(result2, checks, ctx);
+      return runChecks(result, checks, ctx);
     };
   }
   inst["~standard"] = {
@@ -5028,11 +5028,11 @@ const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result2, final, index) {
-  if (result2.issues.length) {
-    final.issues.push(...prefixIssues(index, result2.issues));
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
   }
-  final.value[index] = result2.value;
+  final.value[index] = result.value;
 }
 const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5051,14 +5051,14 @@ const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     const proms = [];
     for (let i = 0; i < input.length; i++) {
       const item = input[i];
-      const result2 = def.element._zod.run({
+      const result = def.element._zod.run({
         value: item,
         issues: []
       }, ctx);
-      if (result2 instanceof Promise) {
-        proms.push(result2.then((result3) => handleArrayResult(result3, payload, i)));
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
       } else {
-        handleArrayResult(result2, payload, i);
+        handleArrayResult(result, payload, i);
       }
     }
     if (proms.length) {
@@ -5067,28 +5067,28 @@ const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handleObjectResult(result2, final, key) {
-  if (result2.issues.length) {
-    final.issues.push(...prefixIssues(key, result2.issues));
+function handleObjectResult(result, final, key) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(key, result.issues));
   }
-  final.value[key] = result2.value;
+  final.value[key] = result.value;
 }
-function handleOptionalObjectResult(result2, final, key, input) {
-  if (result2.issues.length) {
+function handleOptionalObjectResult(result, final, key, input) {
+  if (result.issues.length) {
     if (input[key] === void 0) {
       if (key in input) {
         final.value[key] = void 0;
       } else {
-        final.value[key] = result2.value;
+        final.value[key] = result.value;
       }
     } else {
-      final.issues.push(...prefixIssues(key, result2.issues));
+      final.issues.push(...prefixIssues(key, result.issues));
     }
-  } else if (result2.value === void 0) {
+  } else if (result.value === void 0) {
     if (key in input)
       final.value[key] = void 0;
   } else {
-    final.value[key] = result2.value;
+    final.value[key] = result.value;
   }
 }
 const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
@@ -5254,9 +5254,9 @@ const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   };
 });
 function handleUnionResults(results, final, inst, ctx) {
-  for (const result2 of results) {
-    if (result2.issues.length === 0) {
-      final.value = result2.value;
+  for (const result of results) {
+    if (result.issues.length === 0) {
+      final.value = result.value;
       return final;
     }
   }
@@ -5264,7 +5264,7 @@ function handleUnionResults(results, final, inst, ctx) {
     code: "invalid_union",
     input: final.value,
     inst,
-    errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
   });
   return final;
 }
@@ -5289,17 +5289,17 @@ const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     let async = false;
     const results = [];
     for (const option of def.options) {
-      const result2 = option._zod.run({
+      const result = option._zod.run({
         value: payload.value,
         issues: []
       }, ctx);
-      if (result2 instanceof Promise) {
-        results.push(result2);
+      if (result instanceof Promise) {
+        results.push(result);
         async = true;
       } else {
-        if (result2.issues.length === 0)
-          return result2;
-        results.push(result2);
+        if (result.issues.length === 0)
+          return result;
+        results.push(result);
       }
     }
     if (!async)
@@ -5432,21 +5432,21 @@ function mergeValues(a, b) {
   }
   return { valid: false, mergeErrorPath: [] };
 }
-function handleIntersectionResults(result2, left, right) {
+function handleIntersectionResults(result, left, right) {
   if (left.issues.length) {
-    result2.issues.push(...left.issues);
+    result.issues.push(...left.issues);
   }
   if (right.issues.length) {
-    result2.issues.push(...right.issues);
+    result.issues.push(...right.issues);
   }
-  if (aborted(result2))
-    return result2;
+  if (aborted(result))
+    return result;
   const merged = mergeValues(left.value, right.value);
   if (!merged.valid) {
     throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
   }
-  result2.value = merged.data;
-  return result2;
+  result.value = merged.data;
+  return result;
 }
 const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5467,19 +5467,19 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       payload.value = {};
       for (const key of values) {
         if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          const result2 = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-          if (result2 instanceof Promise) {
-            proms.push(result2.then((result3) => {
-              if (result3.issues.length) {
-                payload.issues.push(...prefixIssues(key, result3.issues));
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
               }
-              payload.value[key] = result3.value;
+              payload.value[key] = result2.value;
             }));
           } else {
-            if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
             }
-            payload.value[key] = result2.value;
+            payload.value[key] = result.value;
           }
         }
       }
@@ -5519,19 +5519,19 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
           payload.value[keyResult.value] = keyResult.value;
           continue;
         }
-        const result2 = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-        if (result2 instanceof Promise) {
-          proms.push(result2.then((result3) => {
-            if (result3.issues.length) {
-              payload.issues.push(...prefixIssues(key, result3.issues));
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => {
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
             }
-            payload.value[keyResult.value] = result3.value;
+            payload.value[keyResult.value] = result2.value;
           }));
         } else {
-          if (result2.issues.length) {
-            payload.issues.push(...prefixIssues(key, result2.issues));
+          if (result.issues.length) {
+            payload.issues.push(...prefixIssues(key, result.issues));
           }
-          payload.value[keyResult.value] = result2.value;
+          payload.value[keyResult.value] = result.value;
         }
       }
     }
@@ -5643,11 +5643,11 @@ const $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
       payload.value = def.defaultValue;
       return payload;
     }
-    const result2 = def.innerType._zod.run(payload, ctx);
-    if (result2 instanceof Promise) {
-      return result2.then((result3) => handleDefaultResult(result3, def));
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => handleDefaultResult(result2, def));
     }
-    return handleDefaultResult(result2, def);
+    return handleDefaultResult(result, def);
   };
 });
 function handleDefaultResult(payload, def) {
@@ -5674,11 +5674,11 @@ const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, d
     return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
-    const result2 = def.innerType._zod.run(payload, ctx);
-    if (result2 instanceof Promise) {
-      return result2.then((result3) => handleNonOptionalResult(result3, inst));
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => handleNonOptionalResult(result2, inst));
     }
-    return handleNonOptionalResult(result2, inst);
+    return handleNonOptionalResult(result, inst);
   };
 });
 function handleNonOptionalResult(payload, inst) {
@@ -5698,15 +5698,15 @@ const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
   defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   defineLazy(inst._zod, "values", () => def.innerType._zod.values);
   inst._zod.parse = (payload, ctx) => {
-    const result2 = def.innerType._zod.run(payload, ctx);
-    if (result2 instanceof Promise) {
-      return result2.then((result3) => {
-        payload.value = result3.value;
-        if (result3.issues.length) {
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => {
+        payload.value = result2.value;
+        if (result2.issues.length) {
           payload.value = def.catchValue({
             ...payload,
             error: {
-              issues: result3.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
             },
             input: payload.value
           });
@@ -5715,12 +5715,12 @@ const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
         return payload;
       });
     }
-    payload.value = result2.value;
-    if (result2.issues.length) {
+    payload.value = result.value;
+    if (result.issues.length) {
       payload.value = def.catchValue({
         ...payload,
         error: {
-          issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
         },
         input: payload.value
       });
@@ -5755,11 +5755,11 @@ const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) =>
   defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
   defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   inst._zod.parse = (payload, ctx) => {
-    const result2 = def.innerType._zod.run(payload, ctx);
-    if (result2 instanceof Promise) {
-      return result2.then(handleReadonlyResult);
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then(handleReadonlyResult);
     }
-    return handleReadonlyResult(result2);
+    return handleReadonlyResult(result);
   };
 });
 function handleReadonlyResult(payload) {
@@ -5782,8 +5782,8 @@ const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     return;
   };
 });
-function handleRefineResult(result2, payload, input, inst) {
-  if (!result2) {
+function handleRefineResult(result, payload, input, inst) {
+  if (!result) {
     const _iss = {
       code: "custom",
       input,
@@ -6288,12 +6288,12 @@ function isZ4Schema(s) {
 }
 function safeParse$1(schema, data) {
   if (isZ4Schema(schema)) {
-    const result3 = safeParse$2(schema, data);
-    return result3;
+    const result2 = safeParse$2(schema, data);
+    return result2;
   }
   const v3Schema = schema;
-  const result2 = v3Schema.safeParse(data);
-  return result2;
+  const result = v3Schema.safeParse(data);
+  return result;
 }
 function getObjectShape(schema) {
   var _a2, _b;
@@ -8553,11 +8553,11 @@ function getMethodLiteral(schema) {
   return value;
 }
 function parseWithCompat(schema, data) {
-  const result2 = safeParse$1(schema, data);
-  if (!result2.success) {
-    throw result2.error;
+  const result = safeParse$1(schema, data);
+  if (!result.success) {
+    throw result.error;
   }
-  return result2.data;
+  return result.data;
 }
 const DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
 class Protocol {
@@ -8634,12 +8634,12 @@ class Protocol {
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
-            const result2 = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+            const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
             this._clearTaskQueue(taskId);
             return {
-              ...result2,
+              ...result,
               _meta: {
-                ...result2._meta,
+                ...result._meta,
                 [RELATED_TASK_META_KEY]: {
                   taskId
                 }
@@ -8870,12 +8870,12 @@ class Protocol {
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
-    }).then(() => handler(request, fullExtra)).then(async (result2) => {
+    }).then(() => handler(request, fullExtra)).then(async (result) => {
       if (abortController.signal.aborted) {
         return;
       }
       const response = {
-        result: result2,
+        result,
         jsonrpc: "2.0",
         id: request.id
       };
@@ -8961,9 +8961,9 @@ class Protocol {
     this._cleanupTimeout(messageId);
     let isTaskResponse = false;
     if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
-      const result2 = response.result;
-      if (result2.task && typeof result2.task === "object") {
-        const task = result2.task;
+      const result = response.result;
+      if (result.task && typeof result.task === "object") {
+        const task = result.task;
         if (typeof task.taskId === "string") {
           isTaskResponse = true;
           this._taskProgressTokens.set(task.taskId, messageId);
@@ -9022,8 +9022,8 @@ class Protocol {
     const { task } = options ?? {};
     if (!task) {
       try {
-        const result2 = await this.request(request, resultSchema, options);
-        yield { type: "result", result: result2 };
+        const result = await this.request(request, resultSchema, options);
+        yield { type: "result", result };
       } catch (error) {
         yield {
           type: "error",
@@ -9046,8 +9046,8 @@ class Protocol {
         yield { type: "taskStatus", task: task2 };
         if (isTerminal(task2.status)) {
           if (task2.status === "completed") {
-            const result2 = await this.getTaskResult({ taskId }, resultSchema, options);
-            yield { type: "result", result: result2 };
+            const result = await this.getTaskResult({ taskId }, resultSchema, options);
+            yield { type: "result", result };
           } else if (task2.status === "failed") {
             yield {
               type: "error",
@@ -9062,8 +9062,8 @@ class Protocol {
           return;
         }
         if (task2.status === "input_required") {
-          const result2 = await this.getTaskResult({ taskId }, resultSchema, options);
-          yield { type: "result", result: result2 };
+          const result = await this.getTaskResult({ taskId }, resultSchema, options);
+          yield { type: "result", result };
           return;
         }
         const pollInterval = task2.pollInterval ?? ((_a2 = this._options) == null ? void 0 : _a2.defaultTaskPollInterval) ?? 1e3;
@@ -9465,8 +9465,8 @@ class Protocol {
         }
         return task;
       },
-      storeTaskResult: async (taskId, status, result2) => {
-        await taskStore.storeTaskResult(taskId, status, result2, sessionId);
+      storeTaskResult: async (taskId, status, result) => {
+        await taskStore.storeTaskResult(taskId, status, result, sessionId);
         const task = await taskStore.getTask(taskId, sessionId);
         if (task) {
           const notification = TaskStatusNotificationSchema.parse({
@@ -9513,20 +9513,20 @@ function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeCapabilities(base2, additional) {
-  const result2 = { ...base2 };
+  const result = { ...base2 };
   for (const key in additional) {
     const k = key;
     const addValue = additional[k];
     if (addValue === void 0)
       continue;
-    const baseValue = result2[k];
+    const baseValue = result[k];
     if (isPlainObject(baseValue) && isPlainObject(addValue)) {
-      result2[k] = { ...baseValue, ...addValue };
+      result[k] = { ...baseValue, ...addValue };
     } else {
-      result2[k] = addValue;
+      result[k] = addValue;
     }
   }
-  return result2;
+  return result;
 }
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -11435,10 +11435,10 @@ function requireKeyword() {
     if (def.async && !schemaEnv.$async)
       throw new Error("async keyword in sync schema");
   }
-  function useKeyword(gen, keyword2, result2) {
-    if (result2 === void 0)
+  function useKeyword(gen, keyword2, result) {
+    if (result === void 0)
       throw new Error(`keyword "${keyword2}" failed to compile`);
-    return gen.scopeValue("keyword", typeof result2 == "function" ? { ref: result2 } : { ref: result2, code: (0, codegen_1.stringify)(result2) });
+    return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
   }
   function validSchemaType(schema, schemaType, allowUndefined = false) {
     return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
@@ -16379,17 +16379,17 @@ class ExperimentalClientTasks {
     const validator = clientInternal.getToolOutputValidator(params.name);
     for await (const message of stream) {
       if (message.type === "result" && validator) {
-        const result2 = message.result;
-        if (!result2.structuredContent && !result2.isError) {
+        const result = message.result;
+        if (!result.structuredContent && !result.isError) {
           yield {
             type: "error",
             error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
           };
           return;
         }
-        if (result2.structuredContent) {
+        if (result.structuredContent) {
           try {
-            const validationResult = validator(result2.structuredContent);
+            const validationResult = validator(result.structuredContent);
             if (!validationResult.valid) {
               yield {
                 type: "error",
@@ -16578,20 +16578,20 @@ class Client extends Protocol {
     var _a2, _b, _c, _d, _e, _f;
     if (config2.tools && ((_b = (_a2 = this._serverCapabilities) == null ? void 0 : _a2.tools) == null ? void 0 : _b.listChanged)) {
       this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => {
-        const result2 = await this.listTools();
-        return result2.tools;
+        const result = await this.listTools();
+        return result.tools;
       });
     }
     if (config2.prompts && ((_d = (_c = this._serverCapabilities) == null ? void 0 : _c.prompts) == null ? void 0 : _d.listChanged)) {
       this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => {
-        const result2 = await this.listPrompts();
-        return result2.prompts;
+        const result = await this.listPrompts();
+        return result.prompts;
       });
     }
     if (config2.resources && ((_f = (_e = this._serverCapabilities) == null ? void 0 : _e.resources) == null ? void 0 : _f.listChanged)) {
       this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => {
-        const result2 = await this.listResources();
-        return result2.resources;
+        const result = await this.listResources();
+        return result.resources;
       });
     }
   }
@@ -16662,16 +16662,16 @@ class Client extends Protocol {
         if (params.mode === "url" && !supportsUrlMode) {
           throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
         }
-        const result2 = await Promise.resolve(handler(request, extra));
+        const result = await Promise.resolve(handler(request, extra));
         if (params.task) {
-          const taskValidationResult = safeParse$1(CreateTaskResultSchema, result2);
+          const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
             const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
             throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
           }
           return taskValidationResult.data;
         }
-        const validationResult = safeParse$1(ElicitResultSchema, result2);
+        const validationResult = safeParse$1(ElicitResultSchema, result);
         if (!validationResult.success) {
           const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
@@ -16698,9 +16698,9 @@ class Client extends Protocol {
           throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
         }
         const { params } = validatedRequest.data;
-        const result2 = await Promise.resolve(handler(request, extra));
+        const result = await Promise.resolve(handler(request, extra));
         if (params.task) {
-          const taskValidationResult = safeParse$1(CreateTaskResultSchema, result2);
+          const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
             const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
             throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
@@ -16709,7 +16709,7 @@ class Client extends Protocol {
         }
         const hasTools = params.tools || params.toolChoice;
         const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
-        const validationResult = safeParse$1(resultSchema, result2);
+        const validationResult = safeParse$1(resultSchema, result);
         if (!validationResult.success) {
           const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
@@ -16732,7 +16732,7 @@ class Client extends Protocol {
       return;
     }
     try {
-      const result2 = await this.request({
+      const result = await this.request({
         method: "initialize",
         params: {
           protocolVersion: LATEST_PROTOCOL_VERSION,
@@ -16740,18 +16740,18 @@ class Client extends Protocol {
           clientInfo: this._clientInfo
         }
       }, InitializeResultSchema, options);
-      if (result2 === void 0) {
-        throw new Error(`Server sent invalid initialize result: ${result2}`);
+      if (result === void 0) {
+        throw new Error(`Server sent invalid initialize result: ${result}`);
       }
-      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result2.protocolVersion)) {
-        throw new Error(`Server's protocol version is not supported: ${result2.protocolVersion}`);
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
       }
-      this._serverCapabilities = result2.capabilities;
-      this._serverVersion = result2.serverInfo;
+      this._serverCapabilities = result.capabilities;
+      this._serverVersion = result.serverInfo;
       if (transport.setProtocolVersion) {
-        transport.setProtocolVersion(result2.protocolVersion);
+        transport.setProtocolVersion(result.protocolVersion);
       }
-      this._instructions = result2.instructions;
+      this._instructions = result.instructions;
       await this.notification({
         method: "notifications/initialized"
       });
@@ -16911,15 +16911,15 @@ class Client extends Protocol {
     if (this.isToolTaskRequired(params.name)) {
       throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
     }
-    const result2 = await this.request({ method: "tools/call", params }, resultSchema, options);
+    const result = await this.request({ method: "tools/call", params }, resultSchema, options);
     const validator = this.getToolOutputValidator(params.name);
     if (validator) {
-      if (!result2.structuredContent && !result2.isError) {
+      if (!result.structuredContent && !result.isError) {
         throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
       }
-      if (result2.structuredContent) {
+      if (result.structuredContent) {
         try {
-          const validationResult = validator(result2.structuredContent);
+          const validationResult = validator(result.structuredContent);
           if (!validationResult.valid) {
             throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
           }
@@ -16931,7 +16931,7 @@ class Client extends Protocol {
         }
       }
     }
-    return result2;
+    return result;
   }
   isToolTask(toolName) {
     var _a2, _b, _c, _d;
@@ -16977,9 +16977,9 @@ class Client extends Protocol {
     return this._cachedToolOutputValidators.get(toolName);
   }
   async listTools(params, options) {
-    const result2 = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
-    this.cacheToolMetadata(result2.tools);
-    return result2;
+    const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
+    this.cacheToolMetadata(result.tools);
+    return result;
   }
   /**
    * Set up a single list changed handler.
@@ -17371,11 +17371,11 @@ class NineMuService {
           currentRoutes
         })
       });
-      const result2 = await response.json();
-      if (!result2.success) {
-        throw new Error(result2.error || "소스 생성 중 서버 오류가 발생했습니다.");
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "소스 생성 중 서버 오류가 발생했습니다.");
       }
-      return result2;
+      return result;
     } catch (error) {
       trace.error("NineMu Service Error:", error);
       throw error;
@@ -17408,11 +17408,11 @@ class NineMuService {
         })
       });
       trace.log(response);
-      const result2 = await response.json();
-      if (!result2.success) {
-        throw new Error(result2.error || "소스 생성 중 서버 오류가 발생했습니다.");
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "소스 생성 중 서버 오류가 발생했습니다.");
       }
-      return result2;
+      return result;
     } catch (error) {
       trace.error("NineMu Service Error:", error);
       throw error;
@@ -17512,7 +17512,7 @@ initActions_fn = function() {
       target.setAttribute("disabled", "disabled");
       __privateGet(this, _$nineChatMessage).add("me", userInput);
       __privateGet(this, _$nineChatMessage).add("ing", "");
-      const [result2, err] = await nine$1.safe(__privateGet(this, _manager).handleChatSubmit(target.value));
+      const [result, err] = await nine$1.safe(__privateGet(this, _manager).handleChatSubmit(target.value));
       setTimeout(() => {
         target.value = "";
       });
@@ -17522,8 +17522,8 @@ initActions_fn = function() {
         trace.error(err);
         __privateGet(this, _$nineChatMessage).add("ai", err.message || "알 수 없는 오류가 발생했습니다. 다시 시도해주세요.");
       } else {
-        trace.log(result2);
-        const rawText = (_b = (_a2 = result2 == null ? void 0 : result2.content) == null ? void 0 : _a2[0]) == null ? void 0 : _b.text;
+        trace.log(result);
+        const rawText = (_b = (_a2 = result == null ? void 0 : result.content) == null ? void 0 : _a2[0]) == null ? void 0 : _b.text;
         const parsed = JSON.parse(rawText);
         if (parsed.message) {
           __privateGet(this, _manager).addChatHistory(parsed.message);
@@ -17540,7 +17540,7 @@ render_fn = function() {
   const customImport = nine$1.cssPath ? `@import "${nine$1.cssPath}/nine-mu.css";` : "";
   this.shadowRoot.innerHTML = `
             <style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
             <div class="wrapper">
@@ -17849,16 +17849,16 @@ class TextLeaf extends Text {
   }
   sliceString(from, to = this.length, lineSep = "\n") {
     [from, to] = clip(this, from, to);
-    let result2 = "";
+    let result = "";
     for (let pos = 0, i = 0; pos <= to && i < this.text.length; i++) {
       let line = this.text[i], end = pos + line.length;
       if (pos > from && i)
-        result2 += lineSep;
+        result += lineSep;
       if (from < end && to > pos)
-        result2 += line.slice(Math.max(0, from - pos), to - pos);
+        result += line.slice(Math.max(0, from - pos), to - pos);
       pos = end + 1;
     }
-    return result2;
+    return result;
   }
   flatten(target) {
     for (let line of this.text)
@@ -17935,16 +17935,16 @@ class TextNode extends Text {
   }
   sliceString(from, to = this.length, lineSep = "\n") {
     [from, to] = clip(this, from, to);
-    let result2 = "";
+    let result = "";
     for (let i = 0, pos = 0; i < this.children.length && pos <= to; i++) {
       let child = this.children[i], end = pos + child.length;
       if (pos > from && i)
-        result2 += lineSep;
+        result += lineSep;
       if (from < end && to > pos)
-        result2 += child.sliceString(from - pos, to - pos, lineSep);
+        result += child.sliceString(from - pos, to - pos, lineSep);
       pos = end + 1;
     }
-    return result2;
+    return result;
   }
   flatten(target) {
     for (let child of this.children)
@@ -18253,21 +18253,21 @@ class ChangeDesc {
   The length of the document before the change.
   */
   get length() {
-    let result2 = 0;
+    let result = 0;
     for (let i = 0; i < this.sections.length; i += 2)
-      result2 += this.sections[i];
-    return result2;
+      result += this.sections[i];
+    return result;
   }
   /**
   The length of the document after the change.
   */
   get newLength() {
-    let result2 = 0;
+    let result = 0;
     for (let i = 0; i < this.sections.length; i += 2) {
       let ins = this.sections[i + 1];
-      result2 += ins < 0 ? this.sections[i] : ins;
+      result += ins < 0 ? this.sections[i] : ins;
     }
-    return result2;
+    return result;
   }
   /**
   False when there are actual changes in this set.
@@ -18377,12 +18377,12 @@ class ChangeDesc {
   @internal
   */
   toString() {
-    let result2 = "";
+    let result = "";
     for (let i = 0; i < this.sections.length; ) {
       let len = this.sections[i++], ins = this.sections[i++];
-      result2 += (result2 ? " " : "") + len + (ins >= 0 ? ":" + ins : "");
+      result += (result ? " " : "") + len + (ins >= 0 ? ":" + ins : "");
     }
-    return result2;
+    return result;
   }
   /**
   Serialize this change desc to a JSON-representable value.
@@ -19450,16 +19450,16 @@ class Configuration {
   }
 }
 function flatten(extension, compartments, newCompartments) {
-  let result2 = [[], [], [], [], []];
+  let result = [[], [], [], [], []];
   let seen = /* @__PURE__ */ new Map();
   function inner(ext, prec2) {
     let known = seen.get(ext);
     if (known != null) {
       if (known <= prec2)
         return;
-      let found = result2[known].indexOf(ext);
+      let found = result[known].indexOf(ext);
       if (found > -1)
-        result2[known].splice(found, 1);
+        result[known].splice(found, 1);
       if (ext instanceof CompartmentInstance)
         newCompartments.delete(ext.compartment);
     }
@@ -19476,11 +19476,11 @@ function flatten(extension, compartments, newCompartments) {
     } else if (ext instanceof PrecExtension) {
       inner(ext.inner, ext.prec);
     } else if (ext instanceof StateField) {
-      result2[prec2].push(ext);
+      result[prec2].push(ext);
       if (ext.provides)
         inner(ext.provides, prec2);
     } else if (ext instanceof FacetProvider) {
-      result2[prec2].push(ext);
+      result[prec2].push(ext);
       if (ext.facet.extensions)
         inner(ext.facet.extensions, Prec_.default);
     } else {
@@ -19491,7 +19491,7 @@ function flatten(extension, compartments, newCompartments) {
     }
   }
   inner(extension, Prec_.default);
-  return result2.reduce((a, b) => a.concat(b));
+  return result.reduce((a, b) => a.concat(b));
 }
 function ensureAddr(state, addr) {
   if (addr & 1)
@@ -19601,13 +19601,13 @@ class StateEffect {
   static mapEffects(effects, mapping) {
     if (!effects.length)
       return effects;
-    let result2 = [];
+    let result = [];
     for (let effect of effects) {
       let mapped = effect.map(mapping);
       if (mapped)
-        result2.push(mapped);
+        result.push(mapped);
     }
-    return result2;
+    return result;
   }
 }
 StateEffect.reconfigure = /* @__PURE__ */ StateEffect.define();
@@ -19705,7 +19705,7 @@ Transaction.userEvent = /* @__PURE__ */ Annotation.define();
 Transaction.addToHistory = /* @__PURE__ */ Annotation.define();
 Transaction.remote = /* @__PURE__ */ Annotation.define();
 function joinRanges(a, b) {
-  let result2 = [];
+  let result = [];
   for (let iA = 0, iB = 0; ; ) {
     let from, to;
     if (iA < a.length && (iB == b.length || b[iB] >= a[iA])) {
@@ -19715,11 +19715,11 @@ function joinRanges(a, b) {
       from = b[iB++];
       to = b[iB++];
     } else
-      return result2;
-    if (!result2.length || result2[result2.length - 1] < from)
-      result2.push(from, to);
-    else if (result2[result2.length - 1] < to)
-      result2[result2.length - 1] = to;
+      return result;
+    if (!result.length || result[result.length - 1] < from)
+      result.push(from, to);
+    else if (result[result.length - 1] < to)
+      result[result.length - 1] = to;
   }
 }
 function mergeTransaction(a, b, sequential) {
@@ -19769,23 +19769,23 @@ function resolveTransaction(state, specs, filter) {
 }
 function filterTransaction(tr) {
   let state = tr.startState;
-  let result2 = true;
+  let result = true;
   for (let filter of state.facet(changeFilter)) {
     let value = filter(tr);
     if (value === false) {
-      result2 = false;
+      result = false;
       break;
     }
     if (Array.isArray(value))
-      result2 = result2 === true ? value : joinRanges(result2, value);
+      result = result === true ? value : joinRanges(result, value);
   }
-  if (result2 !== true) {
+  if (result !== true) {
     let changes, back;
-    if (result2 === false) {
+    if (result === false) {
       back = tr.changes.invertedDesc;
       changes = ChangeSet.empty(state.doc.length);
     } else {
-      let filtered = tr.changes.filter(result2);
+      let filtered = tr.changes.filter(result);
       changes = filtered.changes;
       back = filtered.filtered.mapDesc(filtered.changes).invertedDesc;
     }
@@ -19953,14 +19953,14 @@ class EditorState {
     let changes = this.changes(result1.changes), ranges = [result1.range];
     let effects = asArray$1(result1.effects);
     for (let i = 1; i < sel.ranges.length; i++) {
-      let result2 = f(sel.ranges[i]);
-      let newChanges = this.changes(result2.changes), newMapped = newChanges.map(changes);
+      let result = f(sel.ranges[i]);
+      let newChanges = this.changes(result.changes), newMapped = newChanges.map(changes);
       for (let j = 0; j < i; j++)
         ranges[j] = ranges[j].map(newMapped);
       let mapBy = changes.mapDesc(newChanges, true);
-      ranges.push(result2.range.map(mapBy));
+      ranges.push(result.range.map(mapBy));
       changes = changes.compose(newMapped);
-      effects = StateEffect.mapEffects(effects, newMapped).concat(StateEffect.mapEffects(asArray$1(result2.effects), mapBy));
+      effects = StateEffect.mapEffects(effects, newMapped).concat(StateEffect.mapEffects(asArray$1(result.effects), mapBy));
     }
     return {
       changes,
@@ -20009,7 +20009,7 @@ class EditorState {
   not use `doc` or `selection`) to fields.
   */
   toJSON(fields) {
-    let result2 = {
+    let result = {
       doc: this.sliceDoc(),
       selection: this.selection.toJSON()
     };
@@ -20017,9 +20017,9 @@ class EditorState {
       for (let prop in fields) {
         let value = fields[prop];
         if (value instanceof StateField && this.config.address[value.id] != null)
-          result2[prop] = value.spec.toJSON(this.field(fields[prop]), this);
+          result[prop] = value.spec.toJSON(this.field(fields[prop]), this);
       }
-    return result2;
+    return result;
   }
   /**
   Deserialize a state from its JSON representation. When custom
@@ -20123,9 +20123,9 @@ class EditorState {
   languageDataAt(name2, pos, side = -1) {
     let values = [];
     for (let provider of this.facet(languageData)) {
-      for (let result2 of provider(this, pos, side)) {
-        if (Object.prototype.hasOwnProperty.call(result2, name2))
-          values.push(result2[name2]);
+      for (let result of provider(this, pos, side)) {
+        if (Object.prototype.hasOwnProperty.call(result, name2))
+          values.push(result[name2]);
       }
     }
     return values;
@@ -20188,22 +20188,22 @@ EditorState.transactionFilter = transactionFilter;
 EditorState.transactionExtender = transactionExtender;
 Compartment.reconfigure = /* @__PURE__ */ StateEffect.define();
 function combineConfig(configs, defaults2, combine = {}) {
-  let result2 = {};
+  let result = {};
   for (let config2 of configs)
     for (let key of Object.keys(config2)) {
-      let value = config2[key], current = result2[key];
+      let value = config2[key], current = result[key];
       if (current === void 0)
-        result2[key] = value;
+        result[key] = value;
       else if (current === value || value === void 0) ;
       else if (Object.hasOwnProperty.call(combine, key))
-        result2[key] = combine[key](current, value);
+        result[key] = combine[key](current, value);
       else
         throw new Error("Config merge conflict for field " + key);
     }
   for (let key in defaults2)
-    if (result2[key] === void 0)
-      result2[key] = defaults2[key];
-  return result2;
+    if (result[key] === void 0)
+      result[key] = defaults2[key];
+  return result;
 }
 class RangeValue {
   /**
@@ -20530,12 +20530,12 @@ class RangeSet {
   static join(sets) {
     if (!sets.length)
       return RangeSet.empty;
-    let result2 = sets[sets.length - 1];
+    let result = sets[sets.length - 1];
     for (let i = sets.length - 2; i >= 0; i--) {
       for (let layer2 = sets[i]; layer2 != RangeSet.empty; layer2 = layer2.nextLayer)
-        result2 = new RangeSet(layer2.chunkPos, layer2.chunk, result2, Math.max(layer2.maxPoint, result2.maxPoint));
+        result = new RangeSet(layer2.chunkPos, layer2.chunk, result, Math.max(layer2.maxPoint, result.maxPoint));
     }
-    return result2;
+    return result;
   }
 }
 RangeSet.empty = /* @__PURE__ */ new RangeSet([], [], null, -1);
@@ -20643,9 +20643,9 @@ class RangeSetBuilder {
       this.finishChunk(false);
     if (this.chunks.length == 0)
       return next;
-    let result2 = RangeSet.create(this.chunkPos, this.chunks, this.nextLayer ? this.nextLayer.finishInner(next) : next, this.setMaxPoint);
+    let result = RangeSet.create(this.chunkPos, this.chunks, this.nextLayer ? this.nextLayer.finishInner(next) : next, this.setMaxPoint);
     this.from = null;
-    return result2;
+    return result;
   }
 }
 function findSharedChunks(a, b, textDiff) {
@@ -22002,10 +22002,10 @@ var Direction = /* @__PURE__ */ (function(Direction2) {
 })(Direction || (Direction = {}));
 const LTR = Direction.LTR, RTL = Direction.RTL;
 function dec(str) {
-  let result2 = [];
+  let result = [];
   for (let i = 0; i < str.length; i++)
-    result2.push(1 << +str[i]);
-  return result2;
+    result.push(1 << +str[i]);
+  return result;
 }
 const LowTypes = /* @__PURE__ */ dec("88888888888888888888888888888888888666888888787833333333337888888000000000000000000000000008888880000000000000000000000000088888888888888888888888888888888888887866668888088888663380888308888800000000000000000000000800000000000000000000000000000008");
 const ArabicTypes = /* @__PURE__ */ dec("4444448826627288999999999992222222222222222222222222222222222222222222222229999999999999999999994444444444644222822222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222999999949999999229989999223333333333");
@@ -22518,13 +22518,13 @@ function getIsolatedRanges(view, line) {
   if (!isolates.length)
     return isolates;
   let sets = isolates.map((i) => i instanceof Function ? i(view) : i);
-  let result2 = [];
+  let result = [];
   RangeSet.spans(sets, line.from, line.to, {
     point() {
     },
     span(fromDoc, toDoc, active, open) {
       let from = fromDoc - line.from, to = toDoc - line.from;
-      let level = result2;
+      let level = result;
       for (let i = active.length - 1; i >= 0; i--, open--) {
         let direction = active[i].spec.bidiIsolate, update;
         if (direction == null)
@@ -22540,7 +22540,7 @@ function getIsolatedRanges(view, line) {
       }
     }
   });
-  return result2;
+  return result;
 }
 const scrollMargins = /* @__PURE__ */ Facet.define();
 function getScrollMargins(view) {
@@ -22593,7 +22593,7 @@ class ChangedRange {
   static extendWithRanges(diff, ranges) {
     if (ranges.length == 0)
       return diff;
-    let result2 = [];
+    let result = [];
     for (let dI = 0, rI = 0, off = 0; ; ) {
       let nextD = dI < diff.length ? diff[dI].fromB : 1e9;
       let nextR = rI < ranges.length ? ranges[rI] : 1e9;
@@ -22618,9 +22618,9 @@ class ChangedRange {
           break;
         }
       }
-      result2.push(new ChangedRange(fromA, toA, fromB, toB));
+      result.push(new ChangedRange(fromA, toA, fromB, toB));
     }
-    return result2;
+    return result;
   }
 }
 class ViewUpdate {
@@ -22896,9 +22896,9 @@ class DocTile extends CompositeTile {
           i = 0;
         } else {
           let end = pos + next.length;
-          let result2 = f(next, pos);
-          if (result2 !== void 0)
-            return result2;
+          let result = f(next, pos);
+          if (result !== void 0)
+            return result;
           pos = end + next.breakAfter;
         }
       }
@@ -24243,7 +24243,7 @@ class DocView {
     return scan(tile, offset);
   }
   measureVisibleLineHeights(viewport) {
-    let result2 = [], { from, to } = viewport;
+    let result = [], { from, to } = viewport;
     let contentWidth = this.view.contentDOM.clientWidth;
     let isWider = contentWidth > Math.max(this.view.scrollDOM.clientWidth, this.minWidth) + 1;
     let widest = -1, ltr = this.view.textDirection == Direction.LTR;
@@ -24261,8 +24261,8 @@ class DocView {
             scan(child, pos, childRect);
         } else if (pos >= from) {
           if (spaceAbove > 0)
-            result2.push(-spaceAbove);
-          result2.push(height + spaceAbove);
+            result.push(-spaceAbove);
+          result.push(height + spaceAbove);
           spaceAbove = 0;
           if (isWider) {
             let last = child.dom.lastChild;
@@ -24285,7 +24285,7 @@ class DocView {
       }
     };
     scan(this.tile, 0, null);
-    return result2;
+    return result;
   }
   textDirectionAt(pos) {
     let { tile } = this.tile.resolveBlock(pos, 1);
@@ -25305,16 +25305,16 @@ function findDiff(a, b, preferredPos, preferredSide) {
   return { from, toA, toB };
 }
 function selectionPoints(view) {
-  let result2 = [];
+  let result = [];
   if (view.root.activeElement != view.contentDOM)
-    return result2;
+    return result;
   let { anchorNode, anchorOffset, focusNode, focusOffset } = view.observer.selectionRange;
   if (anchorNode) {
-    result2.push(new DOMPoint(anchorNode, anchorOffset));
+    result.push(new DOMPoint(anchorNode, anchorOffset));
     if (focusNode != anchorNode || focusOffset != anchorOffset)
-      result2.push(new DOMPoint(focusNode, focusOffset));
+      result.push(new DOMPoint(focusNode, focusOffset));
   }
-  return result2;
+  return result;
 }
 function selectionFromPoints(points, base2) {
   if (points.length == 0)
@@ -25477,9 +25477,9 @@ function bindHandler(plugin, handler) {
   };
 }
 function computeHandlers(plugins) {
-  let result2 = /* @__PURE__ */ Object.create(null);
+  let result = /* @__PURE__ */ Object.create(null);
   function record2(type2) {
-    return result2[type2] || (result2[type2] = { observers: [], handlers: [] });
+    return result[type2] || (result[type2] = { observers: [], handlers: [] });
   }
   for (let plugin of plugins) {
     let spec = plugin.spec, handlers2 = spec && spec.plugin.domEventHandlers, observers2 = spec && spec.plugin.domEventObservers;
@@ -25500,7 +25500,7 @@ function computeHandlers(plugins) {
     record2(type2).handlers.push(handlers[type2]);
   for (let type2 in observers)
     record2(type2).observers.push(observers[type2]);
-  return result2;
+  return result;
 }
 const PendingKeys = [
   { key: "Backspace", keyCode: 8, inputType: "deleteContentBackward" },
@@ -26243,11 +26243,11 @@ class HeightMap {
     return HeightMap.of(nodes);
   }
   // Again, these are base cases, and are overridden for branch and gap nodes.
-  decomposeLeft(_to, result2) {
-    result2.push(this);
+  decomposeLeft(_to, result) {
+    result.push(this);
   }
-  decomposeRight(_from, result2) {
-    result2.push(this);
+  decomposeRight(_from, result) {
+    result.push(this);
   }
   applyChanges(decorations2, oldDoc, oracle, changes) {
     let me = this, doc2 = oracle.doc;
@@ -26490,11 +26490,11 @@ class HeightMapGap extends HeightMap {
     }
     return HeightMap.of(nodes);
   }
-  decomposeLeft(to, result2) {
-    result2.push(new HeightMapGap(to - 1), null);
+  decomposeLeft(to, result) {
+    result.push(new HeightMapGap(to - 1), null);
   }
-  decomposeRight(from, result2) {
-    result2.push(null, new HeightMapGap(this.length - from - 1));
+  decomposeRight(from, result) {
+    result.push(null, new HeightMapGap(this.length - from - 1));
   }
   updateHeight(oracle, offset = 0, force = false, measured) {
     let end = offset + this.length;
@@ -26522,10 +26522,10 @@ class HeightMapGap extends HeightMap {
       }
       if (pos <= end)
         nodes.push(null, new HeightMapGap(end - pos).updateHeight(oracle, pos));
-      let result2 = HeightMap.of(nodes);
-      if (singleHeight < 0 || Math.abs(result2.height - this.height) >= Epsilon || Math.abs(singleHeight - this.heightMetrics(oracle, offset).perLine) >= Epsilon)
+      let result = HeightMap.of(nodes);
+      if (singleHeight < 0 || Math.abs(result.height - this.height) >= Epsilon || Math.abs(singleHeight - this.heightMetrics(oracle, offset).perLine) >= Epsilon)
         heightChangeFlag = true;
-      return replace(this, result2);
+      return replace(this, result);
     } else if (force || this.outdated) {
       this.setHeight(oracle.heightForGap(offset, offset + this.length));
       this.outdated = false;
@@ -26585,43 +26585,43 @@ class HeightMapBranch extends HeightMap {
       return this.balanced(this.left.replace(from, to, nodes), this.right);
     if (from > this.left.length)
       return this.balanced(this.left, this.right.replace(from - rightStart, to - rightStart, nodes));
-    let result2 = [];
+    let result = [];
     if (from > 0)
-      this.decomposeLeft(from, result2);
-    let left = result2.length;
+      this.decomposeLeft(from, result);
+    let left = result.length;
     for (let node of nodes)
-      result2.push(node);
+      result.push(node);
     if (from > 0)
-      mergeGaps(result2, left - 1);
+      mergeGaps(result, left - 1);
     if (to < this.length) {
-      let right = result2.length;
-      this.decomposeRight(to, result2);
-      mergeGaps(result2, right);
+      let right = result.length;
+      this.decomposeRight(to, result);
+      mergeGaps(result, right);
     }
-    return HeightMap.of(result2);
+    return HeightMap.of(result);
   }
-  decomposeLeft(to, result2) {
+  decomposeLeft(to, result) {
     let left = this.left.length;
     if (to <= left)
-      return this.left.decomposeLeft(to, result2);
-    result2.push(this.left);
+      return this.left.decomposeLeft(to, result);
+    result.push(this.left);
     if (this.break) {
       left++;
       if (to >= left)
-        result2.push(null);
+        result.push(null);
     }
     if (to > left)
-      this.right.decomposeLeft(to - left, result2);
+      this.right.decomposeLeft(to - left, result);
   }
-  decomposeRight(from, result2) {
+  decomposeRight(from, result) {
     let left = this.left.length, right = left + this.break;
     if (from >= right)
-      return this.right.decomposeRight(from - right, result2);
+      return this.right.decomposeRight(from - right, result);
     if (from < left)
-      this.left.decomposeRight(from, result2);
+      this.left.decomposeRight(from, result);
     if (this.break && from < right)
-      result2.push(null);
-    result2.push(this.right);
+      result.push(null);
+    result.push(this.right);
   }
   balanced(left, right) {
     if (left.size > 2 * right.size || right.size > 2 * left.size)
@@ -26994,13 +26994,13 @@ class ViewState {
     let measureContent = refresh || this.mustMeasureContent || this.contentDOMHeight != domRect.height;
     this.contentDOMHeight = domRect.height;
     this.mustMeasureContent = false;
-    let result2 = 0, bias = 0;
+    let result = 0, bias = 0;
     if (domRect.width && domRect.height) {
       let { scaleX, scaleY } = getScale(dom, domRect);
       if (scaleX > 5e-3 && Math.abs(this.scaleX - scaleX) > 5e-3 || scaleY > 5e-3 && Math.abs(this.scaleY - scaleY) > 5e-3) {
         this.scaleX = scaleX;
         this.scaleY = scaleY;
-        result2 |= 16;
+        result |= 16;
         refresh = measureContent = true;
       }
     }
@@ -27009,13 +27009,13 @@ class ViewState {
     if (this.paddingTop != paddingTop || this.paddingBottom != paddingBottom) {
       this.paddingTop = paddingTop;
       this.paddingBottom = paddingBottom;
-      result2 |= 16 | 2;
+      result |= 16 | 2;
     }
     if (this.editorWidth != view.scrollDOM.clientWidth) {
       if (oracle.lineWrapping)
         measureContent = true;
       this.editorWidth = view.scrollDOM.clientWidth;
-      result2 |= 16;
+      result |= 16;
     }
     let scrollParent = scrollableParents(this.view.contentDOM, false).y;
     if (scrollParent != this.scrollParent) {
@@ -27044,7 +27044,7 @@ class ViewState {
     if (this.contentDOMWidth != contentWidth || this.editorHeight != view.scrollDOM.clientHeight) {
       this.contentDOMWidth = domRect.width;
       this.editorHeight = view.scrollDOM.clientHeight;
-      result2 |= 16;
+      result |= 16;
     }
     if (measureContent) {
       let lineHeights = view.docView.measureVisibleLineHeights(this.viewport);
@@ -27055,7 +27055,7 @@ class ViewState {
         refresh = lineHeight > 0 && oracle.refresh(whiteSpace, lineHeight, charWidth, textHeight, Math.max(5, contentWidth / charWidth), lineHeights);
         if (refresh) {
           view.docView.minWidth = 0;
-          result2 |= 16;
+          result |= 16;
         }
       }
       if (dTop > 0 && dBottom > 0)
@@ -27068,25 +27068,25 @@ class ViewState {
         this.heightMap = (refresh ? HeightMap.empty().applyChanges(this.stateDeco, Text.empty, this.heightOracle, [new ChangedRange(0, 0, 0, view.state.doc.length)]) : this.heightMap).updateHeight(oracle, 0, refresh, new MeasuredHeights(vp.from, heights));
       }
       if (heightChangeFlag)
-        result2 |= 2;
+        result |= 2;
     }
     let viewportChange = !this.viewportIsAppropriate(this.viewport, bias) || this.scrollTarget && (this.scrollTarget.range.head < this.viewport.from || this.scrollTarget.range.head > this.viewport.to);
     if (viewportChange) {
-      if (result2 & 2)
-        result2 |= this.updateScaler();
+      if (result & 2)
+        result |= this.updateScaler();
       this.viewport = this.getViewport(bias, this.scrollTarget);
-      result2 |= this.updateForViewport();
+      result |= this.updateForViewport();
     }
-    if (result2 & 2 || viewportChange)
+    if (result & 2 || viewportChange)
       this.updateViewportLines();
     if (this.lineGaps.length || this.viewport.to - this.viewport.from > 2e3 << 1)
       this.updateLineGaps(this.ensureLineGaps(refresh ? [] : this.lineGaps, view));
-    result2 |= this.computeVisibleRanges();
+    result |= this.computeVisibleRanges();
     if (this.mustEnforceCursorAssoc) {
       this.mustEnforceCursorAssoc = false;
       view.docView.enforceCursorAssoc();
     }
-    return result2;
+    return result;
   }
   get visibleTop() {
     return this.scaler.fromDOM(this.pixelViewport.top);
@@ -29283,10 +29283,10 @@ class EditorView {
   */
   static theme(spec, options) {
     let prefix = StyleModule.newName();
-    let result2 = [theme.of(prefix), styleModule.of(buildTheme(`.${prefix}`, spec))];
+    let result = [theme.of(prefix), styleModule.of(buildTheme(`.${prefix}`, spec))];
     if (options && options.dark)
-      result2.push(darkTheme.of(true));
-    return result2;
+      result.push(darkTheme.of(true));
+    return result;
   }
   /**
   Create an extension that adds styles to the base theme. Like
@@ -29360,13 +29360,13 @@ class CachedOrder {
   static update(cache2, changes) {
     if (changes.empty && !cache2.some((c) => c.fresh))
       return cache2;
-    let result2 = [], lastDir = cache2.length ? cache2[cache2.length - 1].dir : Direction.LTR;
+    let result = [], lastDir = cache2.length ? cache2[cache2.length - 1].dir : Direction.LTR;
     for (let i = Math.max(0, cache2.length - 10); i < cache2.length; i++) {
       let entry = cache2[i];
       if (entry.dir == lastDir && !changes.touchesRange(entry.from, entry.to))
-        result2.push(new CachedOrder(changes.mapPos(entry.from, 1), changes.mapPos(entry.to, -1), entry.dir, entry.isolates, false, entry.order));
+        result.push(new CachedOrder(changes.mapPos(entry.from, 1), changes.mapPos(entry.to, -1), entry.dir, entry.isolates, false, entry.order));
     }
-    return result2;
+    return result;
   }
 }
 function attrsFromFacet(view, facet, base2) {
@@ -29380,9 +29380,9 @@ function attrsFromFacet(view, facet, base2) {
 const currentPlatform = browser.mac ? "mac" : browser.windows ? "win" : browser.linux ? "linux" : "key";
 function normalizeKeyName(name2, platform) {
   const parts = name2.split(/-(?!$)/);
-  let result2 = parts[parts.length - 1];
-  if (result2 == "Space")
-    result2 = " ";
+  let result = parts[parts.length - 1];
+  if (result == "Space")
+    result = " ";
   let alt, ctrl, shift2, meta2;
   for (let i = 0; i < parts.length - 1; ++i) {
     const mod = parts[i];
@@ -29403,14 +29403,14 @@ function normalizeKeyName(name2, platform) {
       throw new Error("Unrecognized modifier name: " + mod);
   }
   if (alt)
-    result2 = "Alt-" + result2;
+    result = "Alt-" + result;
   if (ctrl)
-    result2 = "Ctrl-" + result2;
+    result = "Ctrl-" + result;
   if (meta2)
-    result2 = "Meta-" + result2;
+    result = "Meta-" + result;
   if (shift2)
-    result2 = "Shift-" + result2;
-  return result2;
+    result = "Shift-" + result;
+  return result;
 }
 function modifiers(name2, event, shift2) {
   if (event.altKey)
@@ -29997,16 +29997,16 @@ function matchRanges(view, maxLength) {
   let visible = view.visibleRanges;
   if (visible.length == 1 && visible[0].from == view.viewport.from && visible[0].to == view.viewport.to)
     return visible;
-  let result2 = [];
+  let result = [];
   for (let { from, to } of visible) {
     from = Math.max(view.state.doc.lineAt(from).from, from - maxLength);
     to = Math.min(view.state.doc.lineAt(to).to, to + maxLength);
-    if (result2.length && result2[result2.length - 1].to >= from)
-      result2[result2.length - 1].to = to;
+    if (result.length && result[result.length - 1].to >= from)
+      result[result.length - 1].to = to;
     else
-      result2.push({ from, to });
+      result.push({ from, to });
   }
-  return result2;
+  return result;
 }
 class MatchDecorator {
   /**
@@ -30804,10 +30804,10 @@ class HoverPlugin {
     };
     if (open && "then" in open) {
       let pending = this.pending = { pos };
-      open.then((result2) => {
+      open.then((result) => {
         if (this.pending == pending) {
           this.pending = null;
-          done(result2);
+          done(result);
         }
       }, (e) => logException(view.state, e, "hover tooltip"));
     } else {
@@ -31151,7 +31151,7 @@ const dialogField = /* @__PURE__ */ StateField.define({
 });
 const openDialogEffect = /* @__PURE__ */ StateEffect.define();
 const closeDialogEffect = /* @__PURE__ */ StateEffect.define();
-function createDialog(view, config2, result2) {
+function createDialog(view, config2, result) {
   let content2 = config2.content ? config2.content(view, () => done(null)) : null;
   if (!content2) {
     content2 = crelt("form");
@@ -31197,7 +31197,7 @@ function createDialog(view, config2, result2) {
   function done(form) {
     if (panel.contains(panel.ownerDocument.activeElement))
       view.focus();
-    result2(form);
+    result(form);
   }
   return {
     dom: panel,
@@ -31249,10 +31249,10 @@ const unfixGutters = /* @__PURE__ */ Facet.define({
   combine: (values) => values.some((x) => x)
 });
 function gutters(config2) {
-  let result2 = [
+  let result = [
     gutterView
   ];
-  return result2;
+  return result;
 }
 const gutterView = /* @__PURE__ */ ViewPlugin.fromClass(class {
   constructor(view) {
@@ -31586,12 +31586,12 @@ const lineNumberConfig = /* @__PURE__ */ Facet.define({
   combine(values) {
     return combineConfig(values, { formatNumber: String, domEventHandlers: {} }, {
       domEventHandlers(a, b) {
-        let result2 = Object.assign({}, a);
+        let result = Object.assign({}, a);
         for (let event in b) {
-          let exists = result2[event], add2 = b[event];
-          result2[event] = exists ? (view, line, event2) => exists(view, line, event2) || add2(view, line, event2) : add2;
+          let exists = result[event], add2 = b[event];
+          result[event] = exists ? (view, line, event2) => exists(view, line, event2) || add2(view, line, event2) : add2;
         }
-        return result2;
+        return result;
       }
     });
   }
@@ -31624,9 +31624,9 @@ const lineNumberGutter = /* @__PURE__ */ activeGutters.compute([lineNumberConfig
   },
   widgetMarker: (view, widget, block) => {
     for (let m of view.state.facet(lineNumberWidgetMarker)) {
-      let result2 = m(view, widget, block);
-      if (result2)
-        return result2;
+      let result = m(view, widget, block);
+      if (result)
+        return result;
     }
     return null;
   },
@@ -31709,8 +31709,8 @@ class NodeProp {
     if (typeof match != "function")
       match = NodeType.match(match);
     return (type2) => {
-      let result2 = match(type2);
-      return result2 === void 0 ? null : [this, result2];
+      let result = match(type2);
+      return result === void 0 ? null : [this, result];
     };
   }
 }
@@ -32028,11 +32028,11 @@ class Tree {
   constructor.
   */
   get propValues() {
-    let result2 = [];
+    let result = [];
     if (this.props)
       for (let id2 in this.props)
-        result2.push([+id2, this.props[id2]]);
-    return result2;
+        result.push([+id2, this.props[id2]]);
+    return result;
   }
   /**
   Balance the direct children of this tree, producing a copy of
@@ -32097,30 +32097,30 @@ class TreeBuffer {
   @internal
   */
   toString() {
-    let result2 = [];
+    let result = [];
     for (let index = 0; index < this.buffer.length; ) {
-      result2.push(this.childString(index));
+      result.push(this.childString(index));
       index = this.buffer[index + 3];
     }
-    return result2.join(",");
+    return result.join(",");
   }
   /**
   @internal
   */
   childString(index) {
     let id2 = this.buffer[index], endIndex = this.buffer[index + 3];
-    let type2 = this.set.types[id2], result2 = type2.name;
-    if (/\W/.test(result2) && !type2.isError)
-      result2 = JSON.stringify(result2);
+    let type2 = this.set.types[id2], result = type2.name;
+    if (/\W/.test(result) && !type2.isError)
+      result = JSON.stringify(result);
     index += 4;
     if (endIndex == index)
-      return result2;
+      return result;
     let children = [];
     while (index < endIndex) {
       children.push(this.childString(index));
       index = this.buffer[index + 3];
     }
-    return result2 + "(" + children.join(",") + ")";
+    return result + "(" + children.join(",") + ")";
   }
   /**
   @internal
@@ -32370,22 +32370,22 @@ class TreeNode extends BaseNode {
   }
 }
 function getChildren(node, type2, before, after) {
-  let cur2 = node.cursor(), result2 = [];
+  let cur2 = node.cursor(), result = [];
   if (!cur2.firstChild())
-    return result2;
+    return result;
   if (before != null)
     for (let found = false; !found; ) {
       found = cur2.type.is(before);
       if (!cur2.nextSibling())
-        return result2;
+        return result;
     }
   for (; ; ) {
     if (after != null && cur2.type.is(after))
-      return result2;
+      return result;
     if (cur2.type.is(type2))
-      result2.push(cur2.node);
+      result.push(cur2.node);
     if (!cur2.nextSibling())
-      return after == null ? result2 : [];
+      return after == null ? result : [];
   }
 }
 function matchNodeContext(node, context, i = context.length - 1) {
@@ -32832,14 +32832,14 @@ class TreeCursor {
   get node() {
     if (!this.buffer)
       return this._tree;
-    let cache2 = this.bufferNode, result2 = null, depth = 0;
+    let cache2 = this.bufferNode, result = null, depth = 0;
     if (cache2 && cache2.context == this.buffer) {
       scan: for (let index = this.index, d = this.stack.length; d >= 0; ) {
         for (let c = cache2; c; c = c._parent)
           if (c.index == index) {
             if (index == this.index)
               return c;
-            result2 = c;
+            result = c;
             depth = d + 1;
             break scan;
           }
@@ -32847,8 +32847,8 @@ class TreeCursor {
       }
     }
     for (let i = depth; i < this.stack.length; i++)
-      result2 = new BufferNode(this.buffer, result2, this.stack[i]);
-    return this.bufferNode = new BufferNode(this.buffer, result2, this.index);
+      result = new BufferNode(this.buffer, result, this.stack[i]);
+    return this.bufferNode = new BufferNode(this.buffer, result, this.index);
   }
   /**
   Get the [tree](#common.Tree) that represents the current node, if
@@ -33048,13 +33048,13 @@ function buildTree(data) {
   function findBufferSize(maxSize, inRepeat) {
     let fork = cursor.fork();
     let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;
-    let result2 = { size: 0, start: 0, skip: 0 };
+    let result = { size: 0, start: 0, skip: 0 };
     scan: for (let minPos = fork.pos - maxSize; fork.pos > minPos; ) {
       let nodeSize2 = fork.size;
       if (fork.id == inRepeat && nodeSize2 >= 0) {
-        result2.size = size;
-        result2.start = start;
-        result2.skip = skip;
+        result.size = size;
+        result.start = start;
+        result.skip = skip;
         skip += 4;
         size += 4;
         fork.next();
@@ -33082,11 +33082,11 @@ function buildTree(data) {
       skip += localSkipped;
     }
     if (inRepeat < 0 || size == maxSize) {
-      result2.size = size;
-      result2.start = start;
-      result2.skip = skip;
+      result.size = size;
+      result.start = start;
+      result.skip = skip;
     }
-    return result2.size > 4 ? result2 : void 0;
+    return result.size > 4 ? result : void 0;
   }
   function copyToBuffer(bufferStart, buffer2, index) {
     let { id: id2, start, end, size } = cursor;
@@ -33254,11 +33254,11 @@ class TreeFragment {
   true.
   */
   static addTree(tree, fragments = [], partial2 = false) {
-    let result2 = [new TreeFragment(0, tree.length, tree, 0, false, partial2)];
+    let result = [new TreeFragment(0, tree.length, tree, 0, false, partial2)];
     for (let f of fragments)
       if (f.to > tree.length)
-        result2.push(f);
-    return result2;
+        result.push(f);
+    return result;
   }
   /**
   Apply a set of edits to an array of fragments, removing or
@@ -33268,7 +33268,7 @@ class TreeFragment {
   static applyChanges(fragments, changes, minGap = 128) {
     if (!changes.length)
       return fragments;
-    let result2 = [];
+    let result = [];
     let fI = 1, nextF = fragments.length ? fragments[0] : null;
     for (let cI = 0, pos = 0, off = 0; ; cI++) {
       let nextC = cI < changes.length ? changes[cI] : null;
@@ -33281,7 +33281,7 @@ class TreeFragment {
             cut = fFrom >= fTo ? null : new TreeFragment(fFrom, fTo, cut.tree, cut.offset + off, cI > 0, !!nextC);
           }
           if (cut)
-            result2.push(cut);
+            result.push(cut);
           if (nextF.to > nextPos)
             break;
           nextF = fI < fragments.length ? fragments[fI++] : null;
@@ -33291,7 +33291,7 @@ class TreeFragment {
       pos = nextC.toA;
       off = nextC.toA - nextC.toB;
     }
-    return result2;
+    return result;
   }
 }
 class Parser {
@@ -33546,13 +33546,13 @@ function tagHighlighter(tags2, options) {
   };
 }
 function highlightTags(highlighters, tags2) {
-  let result2 = null;
+  let result = null;
   for (let highlighter of highlighters) {
     let value = highlighter.style(tags2);
     if (value)
-      result2 = result2 ? result2 + " " + value : value;
+      result = result ? result + " " + value : value;
   }
-  return result2;
+  return result;
 }
 function highlightTree(tree, highlighter, putStyle, from = 0, to = tree.length) {
   let builder = new HighlightBuilder(from, Array.isArray(highlighter) ? highlighter : [highlighter], putStyle);
@@ -34110,10 +34110,10 @@ class Language {
       return [{ from: 0, to: state.doc.length }];
     if (!lang || !lang.allowsNesting)
       return [];
-    let result2 = [];
+    let result = [];
     let explore = (tree, from) => {
       if (tree.prop(languageDataProp) == this.data) {
-        result2.push({ from, to: from + tree.length });
+        result.push({ from, to: from + tree.length });
         return;
       }
       let mount = tree.prop(NodeProp.mounted);
@@ -34121,14 +34121,14 @@ class Language {
         if (mount.tree.prop(languageDataProp) == this.data) {
           if (mount.overlay)
             for (let r of mount.overlay)
-              result2.push({ from: r.from + from, to: r.to + from });
+              result.push({ from: r.from + from, to: r.to + from });
           else
-            result2.push({ from, to: from + tree.length });
+            result.push({ from, to: from + tree.length });
           return;
         } else if (mount.overlay) {
-          let size = result2.length;
+          let size = result.length;
           explore(mount.tree, mount.overlay[0].from + from);
-          if (result2.length > size)
+          if (result.length > size)
             return;
         }
       }
@@ -34139,7 +34139,7 @@ class Language {
       }
     };
     explore(syntaxTree(state), 0);
-    return result2;
+    return result;
   }
   /**
   Indicates whether this language allows nested languages. The
@@ -34598,25 +34598,25 @@ function getIndentUnit(state) {
   return unit.charCodeAt(0) == 9 ? state.tabSize * unit.length : unit.length;
 }
 function indentString(state, cols) {
-  let result2 = "", ts = state.tabSize, ch = state.facet(indentUnit)[0];
+  let result = "", ts = state.tabSize, ch = state.facet(indentUnit)[0];
   if (ch == "	") {
     while (cols >= ts) {
-      result2 += "	";
+      result += "	";
       cols -= ts;
     }
     ch = " ";
   }
   for (let i = 0; i < cols; i++)
-    result2 += ch;
-  return result2;
+    result += ch;
+  return result;
 }
 function getIndentation(context, pos) {
   if (context instanceof EditorState)
     context = new IndentContext(context);
   for (let service of context.state.facet(indentService)) {
-    let result2 = service(context, pos);
-    if (result2 !== void 0)
-      return result2;
+    let result = service(context, pos);
+    if (result !== void 0)
+      return result;
   }
   let tree = syntaxTree(context.state);
   return tree.length >= pos ? syntaxIndentation(context, tree, pos) : null;
@@ -34666,11 +34666,11 @@ class IndentContext {
   */
   column(pos, bias = 1) {
     let { text, from } = this.lineAt(pos, bias);
-    let result2 = this.countColumn(text, pos - from);
+    let result = this.countColumn(text, pos - from);
     let override = this.options.overrideIndentation ? this.options.overrideIndentation(from) : -1;
     if (override > -1)
-      result2 += override - this.countColumn(text, text.search(/\S|$/));
-    return result2;
+      result += override - this.countColumn(text, text.search(/\S|$/));
+    return result;
   }
   /**
   Find the column position (taking tabs into account) of the given
@@ -35548,9 +35548,9 @@ class HistEvent {
   static fromTransaction(tr, selection) {
     let effects = none$1;
     for (let invert of tr.startState.facet(invertedEffects)) {
-      let result2 = invert(tr);
-      if (result2.length)
-        effects = effects.concat(result2);
+      let result = invert(tr);
+      if (result.length)
+        effects = effects.concat(result);
     }
     if (!effects.length && tr.changes.empty)
       return null;
@@ -35611,9 +35611,9 @@ function addMappingToBranch(branch, mapping) {
   while (length) {
     let event = mapEvent(branch[length - 1], mapping, selections);
     if (event.changes && !event.changes.empty || event.effects.length) {
-      let result2 = branch.slice(0, length);
-      result2[length - 1] = event;
-      return result2;
+      let result = branch.slice(0, length);
+      result[length - 1] = event;
+      return result;
     } else {
       mapping = event.mapped;
       length--;
@@ -36629,13 +36629,13 @@ function toCharEnd(text, pos) {
 const gotoLine = (view) => {
   let { state } = view;
   let line = String(state.doc.lineAt(view.state.selection.main.head).number);
-  let { close, result: result2 } = showDialog(view, {
+  let { close, result } = showDialog(view, {
     label: state.phrase("Go to line"),
     input: { type: "text", name: "line", value: line },
     focus: true,
     submitLabel: state.phrase("go")
   });
-  result2.then((form) => {
+  result.then((form) => {
     let match = form && /^([+-])?(\d+)?(:\d+)?(%)?$/.exec(form.elements["line"].value);
     if (!match) {
       view.dispatch({ effects: close });
@@ -36982,16 +36982,16 @@ class RegExpQuery extends QueryType {
   prevMatch(state, curFrom, curTo) {
     return this.prevMatchInRange(state, 0, curFrom) || this.prevMatchInRange(state, curTo, state.doc.length);
   }
-  getReplacement(result2) {
+  getReplacement(result) {
     return this.spec.unquote(this.spec.replace).replace(/\$([$&]|\d+)/g, (m, i) => {
       if (i == "&")
-        return result2.match[0];
+        return result.match[0];
       if (i == "$")
         return "$";
       for (let l = i.length; l > 0; l--) {
         let n = +i.slice(0, l);
-        if (n > 0 && n < result2.match.length)
-          return result2.match[n] + i.slice(l);
+        if (n > 0 && n < result.match.length)
+          return result.match[n] + i.slice(l);
       }
       return m;
     });
@@ -37712,8 +37712,8 @@ class Stack {
         }
       nextStates = best;
     }
-    let result2 = [];
-    for (let i = 0; i < nextStates.length && result2.length < 4; i += 2) {
+    let result = [];
+    for (let i = 0; i < nextStates.length && result.length < 4; i += 2) {
       let s = nextStates[i + 1];
       if (s == this.state)
         continue;
@@ -37723,9 +37723,9 @@ class Stack {
       stack.shiftContext(nextStates[i], this.pos);
       stack.reducePos = this.pos;
       stack.score -= 200;
-      result2.push(stack);
+      result.push(stack);
     }
-    return result2;
+    return result;
   }
   // Force a reduce, if possible. Return false if that can't
   // be done.
@@ -38086,17 +38086,17 @@ class InputStream {
   units, since the library does not track lookbehind.
   */
   peek(offset) {
-    let idx = this.chunkOff + offset, pos, result2;
+    let idx = this.chunkOff + offset, pos, result;
     if (idx >= 0 && idx < this.chunk.length) {
       pos = this.pos + offset;
-      result2 = this.chunk.charCodeAt(idx);
+      result = this.chunk.charCodeAt(idx);
     } else {
       let resolved = this.resolveOffset(offset, 1);
       if (resolved == null)
         return -1;
       pos = resolved;
       if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {
-        result2 = this.chunk2.charCodeAt(pos - this.chunk2Pos);
+        result = this.chunk2.charCodeAt(pos - this.chunk2Pos);
       } else {
         let i = this.rangeIndex, range = this.range;
         while (range.to <= pos)
@@ -38104,12 +38104,12 @@ class InputStream {
         this.chunk2 = this.input.chunk(this.chunk2Pos = pos);
         if (pos + this.chunk2.length > range.to)
           this.chunk2 = this.chunk2.slice(0, range.to - pos);
-        result2 = this.chunk2.charCodeAt(0);
+        result = this.chunk2.charCodeAt(0);
       }
     }
     if (pos >= this.token.lookAhead)
       this.token.lookAhead = pos + 1;
-    return result2;
+    return result;
   }
   /**
   Accept a token. By default, the end of the token is set to the
@@ -38222,14 +38222,14 @@ class InputStream {
       return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);
     if (from >= this.range.from && to <= this.range.to)
       return this.input.read(from, to);
-    let result2 = "";
+    let result = "";
     for (let r of this.ranges) {
       if (r.from >= to)
         break;
       if (r.to > from)
-        result2 += this.input.read(Math.max(r.from, from), Math.min(r.to, to));
+        result += this.input.read(Math.max(r.from, from), Math.min(r.to, to));
     }
-    return result2;
+    return result;
   }
 }
 class TokenGroup {
@@ -38512,12 +38512,12 @@ class TokenCache {
       let { parser: parser2 } = stack.p;
       for (let i = 0; i < parser2.specialized.length; i++)
         if (parser2.specialized[i] == token.value) {
-          let result2 = parser2.specializers[i](this.stream.read(token.start, token.end), stack);
-          if (result2 >= 0 && stack.p.parser.dialect.allows(result2 >> 1)) {
-            if ((result2 & 1) == 0)
-              token.value = result2 >> 1;
+          let result = parser2.specializers[i](this.stream.read(token.start, token.end), stack);
+          if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {
+            if ((result & 1) == 0)
+              token.value = result >> 1;
             else
-              token.extended = result2 >> 1;
+              token.extended = result >> 1;
             break;
           }
         }
@@ -39019,28 +39019,28 @@ class LRParser extends Parser {
       4
       /* ParseState.DefaultReduce */
     );
-    let result2 = deflt ? action(deflt) : void 0;
+    let result = deflt ? action(deflt) : void 0;
     for (let i = this.stateSlot(
       state,
       1
       /* ParseState.Actions */
-    ); result2 == null; i += 3) {
+    ); result == null; i += 3) {
       if (this.data[i] == 65535) {
         if (this.data[i + 1] == 1)
           i = pair(this.data, i + 2);
         else
           break;
       }
-      result2 = action(pair(this.data, i + 1));
+      result = action(pair(this.data, i + 1));
     }
-    return result2;
+    return result;
   }
   /**
   Get the states that can follow this one through shift actions or
   goto jumps. @internal
   */
   nextStates(state) {
-    let result2 = [];
+    let result = [];
     for (let i = this.stateSlot(
       state,
       1
@@ -39054,11 +39054,11 @@ class LRParser extends Parser {
       }
       if ((this.data[i + 2] & 65536 >> 16) == 0) {
         let value = this.data[i + 1];
-        if (!result2.some((v, i2) => i2 & 1 && v == value))
-          result2.push(this.data[i], value);
+        if (!result.some((v, i2) => i2 & 1 && v == value))
+          result.push(this.data[i], value);
       }
     }
-    return result2;
+    return result;
   }
   /**
   Configure the parser. Returns a new parser instance that has the
@@ -39633,17 +39633,17 @@ class FuzzyMatcher {
     return chars.length == 2 ? null : this.result((any[0] ? -700 : 0) + -200 + -1100, any, word);
   }
   result(score2, positions, word) {
-    let result2 = [], i = 0;
+    let result = [], i = 0;
     for (let pos of positions) {
       let to = pos + (this.astral ? codePointSize(codePointAt(word, pos)) : 1);
-      if (i && result2[i - 1] == pos)
-        result2[i - 1] = to;
+      if (i && result[i - 1] == pos)
+        result[i - 1] = to;
       else {
-        result2[i++] = pos;
-        result2[i++] = to;
+        result[i++] = pos;
+        result[i++] = to;
       }
     }
-    return this.ret(score2 - word.length, result2);
+    return this.ret(score2 - word.length, result);
   }
 }
 class StrictMatcher {
@@ -40101,17 +40101,17 @@ function sortOptions(active, state) {
         option.score += sectionOrder[typeof section == "string" ? section : section.name];
     }
   }
-  let result2 = [], prev = null;
+  let result = [], prev = null;
   let compare2 = conf.compareCompletions;
   for (let opt of options.sort((a, b) => b.score - a.score || compare2(a.completion, b.completion))) {
     let cur2 = opt.completion;
     if (!prev || prev.label != cur2.label || prev.detail != cur2.detail || prev.type != null && cur2.type != null && prev.type != cur2.type || prev.apply != cur2.apply || prev.boost != cur2.boost)
-      result2.push(opt);
+      result.push(opt);
     else if (score(opt.completion) > score(prev))
-      result2[result2.length - 1] = opt;
+      result[result.length - 1] = opt;
     prev = opt.completion;
   }
-  return result2;
+  return result;
 }
 class CompletionDialog {
   constructor(options, attrs, tooltip, timestamp, selected, disabled) {
@@ -40223,14 +40223,14 @@ const baseAttrs = {
 };
 const noAttrs = {};
 function makeAttrs(id2, selected) {
-  let result2 = {
+  let result = {
     "aria-autocomplete": "list",
     "aria-haspopup": "listbox",
     "aria-controls": id2
   };
   if (selected > -1)
-    result2["aria-activedescendant"] = id2 + "-" + selected;
-  return result2;
+    result["aria-activedescendant"] = id2 + "-" + selected;
+  return result;
 }
 const none = [];
 function getUpdateType(tr, conf) {
@@ -40297,10 +40297,10 @@ class ActiveSource {
   }
 }
 class ActiveResult extends ActiveSource {
-  constructor(source, explicit, limit2, result2, from, to) {
+  constructor(source, explicit, limit2, result, from, to) {
     super(source, 3, explicit);
     this.limit = limit2;
-    this.result = result2;
+    this.result = result;
     this.from = from;
     this.to = to;
   }
@@ -40311,29 +40311,29 @@ class ActiveResult extends ActiveSource {
     var _a2;
     if (!(type2 & 3))
       return this.map(tr.changes);
-    let result2 = this.result;
-    if (result2.map && !tr.changes.empty)
-      result2 = result2.map(result2, tr.changes);
+    let result = this.result;
+    if (result.map && !tr.changes.empty)
+      result = result.map(result, tr.changes);
     let from = tr.changes.mapPos(this.from), to = tr.changes.mapPos(this.to, 1);
     let pos = cur(tr.state);
-    if (pos > to || !result2 || type2 & 2 && (cur(tr.startState) == this.from || pos < this.limit))
+    if (pos > to || !result || type2 & 2 && (cur(tr.startState) == this.from || pos < this.limit))
       return new ActiveSource(
         this.source,
         type2 & 4 ? 1 : 0
         /* State.Inactive */
       );
     let limit2 = tr.changes.mapPos(this.limit);
-    if (checkValid(result2.validFor, tr.state, from, to))
-      return new ActiveResult(this.source, this.explicit, limit2, result2, from, to);
-    if (result2.update && (result2 = result2.update(result2, from, to, new CompletionContext(tr.state, pos, false))))
-      return new ActiveResult(this.source, this.explicit, limit2, result2, result2.from, (_a2 = result2.to) !== null && _a2 !== void 0 ? _a2 : cur(tr.state));
+    if (checkValid(result.validFor, tr.state, from, to))
+      return new ActiveResult(this.source, this.explicit, limit2, result, from, to);
+    if (result.update && (result = result.update(result, from, to, new CompletionContext(tr.state, pos, false))))
+      return new ActiveResult(this.source, this.explicit, limit2, result, result.from, (_a2 = result.to) !== null && _a2 !== void 0 ? _a2 : cur(tr.state));
     return new ActiveSource(this.source, 1, this.explicit);
   }
   map(mapping) {
     if (mapping.empty)
       return this;
-    let result2 = this.result.map ? this.result.map(this.result, mapping) : this.result;
-    if (!result2)
+    let result = this.result.map ? this.result.map(this.result, mapping) : this.result;
+    if (!result)
       return new ActiveSource(
         this.source,
         0
@@ -40370,16 +40370,16 @@ const completionState = /* @__PURE__ */ StateField.define({
 });
 function applyCompletion(view, option) {
   const apply = option.completion.apply || option.completion.label;
-  let result2 = view.state.field(completionState).active.find((a) => a.source == option.source);
-  if (!(result2 instanceof ActiveResult))
+  let result = view.state.field(completionState).active.find((a) => a.source == option.source);
+  if (!(result instanceof ActiveResult))
     return false;
   if (typeof apply == "string")
     view.dispatch({
-      ...insertCompletionText(view.state, apply, result2.from, result2.to),
+      ...insertCompletionText(view.state, apply, result.from, result.to),
       annotations: pickedCompletion.of(option.completion)
     });
   else
-    apply(view, option.completion, result2.from, result2.to);
+    apply(view, option.completion, result.from, result.to);
   return true;
 }
 const createTooltip = /* @__PURE__ */ completionTooltip(completionState, applyCompletion);
@@ -40501,9 +40501,9 @@ const completionPlugin = /* @__PURE__ */ ViewPlugin.fromClass(class {
     let context = new CompletionContext(state, pos, active.explicit, this.view);
     let pending = new RunningQuery(active, context);
     this.running.push(pending);
-    Promise.resolve(active.source(context)).then((result2) => {
+    Promise.resolve(active.source(context)).then((result) => {
       if (!pending.context.aborted) {
-        pending.done = result2 || null;
+        pending.done = result || null;
         this.scheduleAccept();
       }
     }, (err) => {
@@ -40590,8 +40590,8 @@ const commitCharacters = /* @__PURE__ */ Prec.highest(/* @__PURE__ */ EditorView
     if (!field || !field.open || field.open.disabled || field.open.selected < 0 || event.key.length > 1 || event.ctrlKey && !(windows && event.altKey) || event.metaKey)
       return false;
     let option = field.open.options[field.open.selected];
-    let result2 = field.active.find((a) => a.source == option.source);
-    let commitChars = option.completion.commitCharacters || result2.result.commitCharacters;
+    let result = field.active.find((a) => a.source == option.source);
+    let commitChars = option.completion.commitCharacters || result.result.commitCharacters;
     if (commitChars && commitChars.indexOf(event.key) > -1)
       applyCompletion(view, option);
     return false;
@@ -41386,9 +41386,9 @@ function findDiagnostic(diagnostics, diagnostic = null, after = 0) {
 }
 function hideTooltip(tr, tooltip) {
   let from = tooltip.pos, to = tooltip.end || from;
-  let result2 = tr.state.facet(lintConfig).hideOn(tr, from, to);
-  if (result2 != null)
-    return result2;
+  let result = tr.state.facet(lintConfig).hideOn(tr, from, to);
+  if (result != null)
+    return result;
   let line = tr.startState.doc.lineAt(tooltip.pos);
   return !!(tr.effects.some((e) => e.is(setDiagnosticsEffect)) || tr.changes.touchesRange(line.from, Math.max(line.to, to)));
 }
@@ -43790,7 +43790,7 @@ class NineDiff extends HTMLElement {
     const customImport = nine.cssPath ? `@import "${nine.cssPath}/nine-mu.css";` : "";
     this.shadowRoot.innerHTML = `
            	<style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -43930,7 +43930,7 @@ renderScaffolding_fn = function() {
   const customImport = nine$1.cssPath ? `@import "${nine$1.cssPath}/nine-mu.css";` : "";
   this.shadowRoot.innerHTML = `
             <style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -44039,7 +44039,7 @@ render_fn2 = function() {
   const customImport = nine$1.cssPath ? `@import "${nine$1.cssPath}/nine-mu.css";` : "";
   this.shadowRoot.innerHTML = `
            	<style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -44369,7 +44369,7 @@ class ChatMessageBody extends HTMLElement {
       const customImport = nine.cssPath ? `@import "${nine.cssPath}/nine-mu.css";` : "";
       this.shadowRoot.innerHTML = `
             <style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -44484,7 +44484,7 @@ render_fn3 = function() {
   const customImport = nine.cssPath ? `@import "${nine.cssPath}/nine-mu.css";` : "";
   this.shadowRoot.innerHTML = `
             <style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -44520,9 +44520,9 @@ handleQuestion_fn = async function(question2) {
     });
     trace.log(response);
     if (response.list) {
-      const el = document.querySelector("nine-natual-query-result");
-      if (el) {
-        el.redraw(result.list);
+      const $el = document.querySelector("nine-natural-query-result");
+      if ($el) {
+        $el.redraw(response.list);
       }
     }
   } catch (error) {
@@ -44638,7 +44638,7 @@ render_fn4 = function() {
   const customImport = nine$1.cssPath ? `@import "${nine$1.cssPath}/nine-mu.css";` : "";
   this.shadowRoot.innerHTML = `
             <style>
-                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.407"}/dist/css/nine-mu.css";
+                @import "https://cdn.jsdelivr.net/npm/@nine-lab/nine-mu@${"0.1.409"}/dist/css/nine-mu.css";
                 ${customImport}
             </style>
@@ -44873,7 +44873,7 @@ function NineHook({ children, menuData, views, error404, onCatch, fallback, styl
   );
 }
 const NineMu = {
-  version: "0.1.407",
+  version: "0.1.409",
   init: (config2) => {
     trace$1.log("🛠️ Nine-Mu Engine initialized", config2);
   }