@intentic/claude-plugin 1.330.0 → 1.332.0

package/dist/fileq.mjs

@@ -376,8 +376,8 @@ function isNiladic(namedFlagWithNegation) {
   }
   return false;
 }
-function findFlagsByArgument(arg, flags, allowsNegation, resolvedAliases, config) {
-  const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(arg);
+function findFlagsByArgument(arg2, flags, allowsNegation, resolvedAliases, config) {
+  const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(arg2);
   if (shorthandMatch) {
     const batch = shorthandMatch[1];
     return Array.from(batch).map((alias) => {
@@ -389,15 +389,15 @@ function findFlagsByArgument(arg, flags, allowsNegation, resolvedAliases, config
       return namedFlag;
     });
   }
-  const flagNameMatch = FLAG_NAME_PATTERN.exec(arg);
+  const flagNameMatch = FLAG_NAME_PATTERN.exec(arg2);
   if (flagNameMatch) {
     const externalFlagName = flagNameMatch[1];
     return [findInternalFlagMatch(externalFlagName, flags, allowsNegation, config)];
   }
   return [];
 }
-function findFlagByArgumentWithInput(arg, flags, allowsNegation, resolvedAliases, config) {
-  const flagsNameMatch = FLAG_NAME_VALUE_PATTERN.exec(arg);
+function findFlagByArgumentWithInput(arg2, flags, allowsNegation, resolvedAliases, config) {
+  const flagsNameMatch = FLAG_NAME_VALUE_PATTERN.exec(arg2);
   if (flagsNameMatch) {
     const externalFlagName = flagsNameMatch[1];
     const namedFlag = findInternalFlagMatch(externalFlagName, flags, allowsNegation, config);
@@ -407,7 +407,7 @@ function findFlagByArgumentWithInput(arg, flags, allowsNegation, resolvedAliases
     }
     return [namedFlag, valueText];
   }
-  const aliasValueMatch = ALIAS_VALUE_PATTERN.exec(arg);
+  const aliasValueMatch = ALIAS_VALUE_PATTERN.exec(arg2);
   if (aliasValueMatch) {
     const aliasName = aliasValueMatch[1];
     const namedFlag = resolvedAliases[aliasName];
@@ -1343,8 +1343,8 @@ async function scanInputsAndRunTarget(app2, rawInputs, context, text, ansiColorB
   const scanner = buildRouteScanner(app2.root, app2.config.scanner, [app2.config.name], additionalFlags);
   let error2;
   while (inputs.length > 0 && !error2) {
-    const arg = inputs.shift();
-    error2 = scanner.next(arg);
+    const arg2 = inputs.shift();
+    error2 = scanner.next(arg2);
   }
   if (error2) {
     const routeNames = listAllRouteNamesAndAliasesForScan(
@@ -2601,11 +2601,21 @@ var init_version = __esm({
   }
 });
 
+// ../../_tools/base/src/text/escape.ts
+var escapeRegExp;
+var init_escape = __esm({
+  "../../_tools/base/src/text/escape.ts"() {
+    "use strict";
+    escapeRegExp = (text) => text.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  }
+});
+
 // ../../_tools/base/src/format.ts
 var CHARS_PER_TOKEN, tokensOfChars, estimateTokens, plural;
 var init_format = __esm({
   "../../_tools/base/src/format.ts"() {
     "use strict";
+    init_escape();
     CHARS_PER_TOKEN = 4;
     tokensOfChars = (chars) => Math.ceil(chars / CHARS_PER_TOKEN);
     estimateTokens = (text) => tokensOfChars(text.length);
@@ -2729,13 +2739,13 @@ var init_outside_text = __esm({
       let out = "";
       let cursor = 0;
       for (const match of folded.text.matchAll(pattern)) {
-        const start = folded.starts[match.index] ?? match.index;
+        const start2 = folded.starts[match.index] ?? match.index;
         const last = match.index + match[0].length - 1;
         const end = folded.ends[last] ?? last + 1;
-        if (start < cursor) {
+        if (start2 < cursor) {
           continue;
         }
-        out += original.slice(cursor, start) + NEUTRALIZED;
+        out += original.slice(cursor, start2) + NEUTRALIZED;
         cursor = end;
       }
       return out + original.slice(cursor);
@@ -3606,9 +3616,9 @@ var init_Deferred = __esm({
       constructor() {
         this.resolve = () => null;
         this.reject = () => null;
-        this.promise = new Promise((resolve6, reject) => {
+        this.promise = new Promise((resolve7, reject) => {
           this.reject = reject;
-          this.resolve = resolve6;
+          this.resolve = resolve7;
         });
       }
     };
@@ -8341,17 +8351,42 @@ var init_formats = __esm({
   }
 });
 
+// ../../_tools/base/src/text/one-line.ts
+var SPACE, INVISIBLE, cutAt, oneLine;
+var init_one_line = __esm({
+  "../../_tools/base/src/text/one-line.ts"() {
+    "use strict";
+    SPACE = /\s+/gu;
+    INVISIBLE = /[\p{Cc}\p{Cf}]/gu;
+    cutAt = (text, units2) => {
+      const high = text.charCodeAt(units2 - 1);
+      return text.slice(0, high >= 55296 && high <= 56319 ? units2 - 1 : units2);
+    };
+    oneLine = (text, max2 = Number.POSITIVE_INFINITY, options = {}) => {
+      const flat = text.replaceAll(SPACE, " ").replaceAll(INVISIBLE, "").replaceAll(SPACE, " ").trim();
+      if (flat.length <= max2) {
+        return flat;
+      }
+      const ellipsis = options.ellipsis === false ? "" : options.ellipsis ?? "\u2026";
+      if (ellipsis.length >= max2) {
+        return cutAt(flat, Math.max(0, max2));
+      }
+      return `${cutAt(flat, max2 - ellipsis.length).trimEnd()}${ellipsis}`;
+    };
+  }
+});
+
 // ../fileq/src/lib/check/finding.ts
 var error, warning, plural2, excerpt, LEFTOVER_CERTAIN, LEFTOVER_LIKELY, leftoverText, EMU_PER_INCH, inches;
 var init_finding = __esm({
   "../fileq/src/lib/check/finding.ts"() {
     "use strict";
+    init_one_line();
     error = (rule, where, message) => ({ severity: "error", rule, where, message });
     warning = (rule, where, message) => ({ severity: "warning", rule, where, message });
     plural2 = (count, noun, nouns = `${noun}s`) => `${count} ${count === 1 ? noun : nouns}`;
     excerpt = (text, max2 = 60) => {
-      const line2 = text.replaceAll(/\s+/g, " ").trim();
-      return `"${line2.length > max2 ? `${line2.slice(0, max2 - 1)}\u2026` : line2}"`;
+      return `"${oneLine(text, max2)}"`;
     };
     LEFTOVER_CERTAIN = [
       /\bClick (?:or tap )?(?:here )?(?:to|icon to) (?:add|edit|enter|insert)\b[^.\n]*/i,
@@ -8525,10 +8560,10 @@ var init_esm = __esm({
       0
     ]);
     clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-    freb = function(eb, start) {
+    freb = function(eb, start2) {
       var b3 = new u16(31);
       for (var i3 = 0; i3 < 31; ++i3) {
-        b3[i3] = start += 1 << eb[i3 - 1];
+        b3[i3] = start2 += 1 << eb[i3 - 1];
       }
       var r2 = new i32(b3[30]);
       for (var i3 = 1; i3 < 30; ++i3) {
@@ -8879,9 +8914,10 @@ var decodeEntities, attributeOf;
 var init_xml = __esm({
   "../fileq/src/lib/xml.ts"() {
     "use strict";
+    init_escape();
     decodeEntities = (text) => text.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll(/&#x([0-9a-f]+);/gi, (_3, hex) => String.fromCodePoint(Number.parseInt(hex, 16))).replaceAll(/&#(\d+);/g, (_3, dec) => String.fromCodePoint(Number(dec))).replaceAll("&amp;", "&");
     attributeOf = (attributes, name) => {
-      const match = new RegExp(`(?:^|\\s)${name.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(attributes);
+      const match = new RegExp(`(?:^|\\s)${escapeRegExp(name)}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(attributes);
       if (match === null) {
         return void 0;
       }
@@ -9263,11 +9299,11 @@ var init_check_docx = __esm({
       }
       return owner;
     };
-    stepField = (node, open, fields, where) => {
+    stepField = (node, open2, fields, where) => {
       const type = node.attrs["w:fldCharType"];
-      const current = open.at(-1);
+      const current = open2.at(-1);
       if (type === "begin") {
-        open.push({ instruction: "", result: "", separated: false, where });
+        open2.push({ instruction: "", result: "", separated: false, where });
         return;
       }
       if (current === void 0) {
@@ -9276,7 +9312,7 @@ var init_check_docx = __esm({
       if (type === "separate") {
         current.separated = true;
       } else if (type === "end") {
-        open.pop();
+        open2.pop();
         fields.push({
           instruction: current.instruction.trim(),
           result: current.result,
@@ -9287,15 +9323,15 @@ var init_check_docx = __esm({
     };
     fieldsIn = (body, whereOfNode) => {
       const fields = [];
-      const open = [];
+      const open2 = [];
       for (const node of everyElement(body)) {
         if (node.name === "w:fldSimple") {
           const result = textIn(node, "w:t");
           fields.push({ instruction: (node.attrs["w:instr"] ?? "").trim(), result, hasResult: result.trim() !== "", where: whereOfNode(node) });
         } else if (node.name === "w:fldChar") {
-          stepField(node, open, fields, whereOfNode(node));
+          stepField(node, open2, fields, whereOfNode(node));
         } else {
-          const current = open.at(-1);
+          const current = open2.at(-1);
           const text = node.children.filter((child) => !isElement(child)).join("");
           if (current !== void 0 && node.name === "w:instrText" && !current.separated) {
             current.instruction += text;
@@ -10552,7 +10588,7 @@ async function JBig2(e2 = {}) {
   };
   if (n2.noExitRuntime && n2.noExitRuntime, n2.print && n2.print, n2.printErr && n2.printErr, n2.wasmBinary && n2.wasmBinary, n2.arguments && n2.arguments, n2.thisProgram && n2.thisProgram, n2.preInit) for (typeof n2.preInit == `function` && (n2.preInit = [n2.preInit]); n2.preInit.length > 0; ) n2.preInit.shift()();
   n2.writeArrayToMemory = writeArrayToMemory;
-  function run5() {
+  function run3() {
     preRun();
     function doRun() {
       n2.calledRun = true, initRuntime(), a2?.(n2), n2.onRuntimeInitialized?.(), postRun();
@@ -10562,7 +10598,7 @@ async function JBig2(e2 = {}) {
     }, 1)) : doRun();
   }
   var u2 = {}();
-  return run5(), t2 = s2 ? n2 : new Promise((e3, t3) => {
+  return run3(), t2 = s2 ? n2 : new Promise((e3, t3) => {
     a2 = e3;
   }), t2;
 }
@@ -10607,7 +10643,7 @@ async function OpenJPEG(e2 = {}) {
   };
   if (n2.noExitRuntime && n2.noExitRuntime, n2.print && n2.print, n2.printErr && n2.printErr, n2.wasmBinary && n2.wasmBinary, n2.arguments && n2.arguments, n2.thisProgram && (i3 = n2.thisProgram), n2.preInit) for (typeof n2.preInit == `function` && (n2.preInit = [n2.preInit]); n2.preInit.length > 0; ) n2.preInit.shift()();
   n2.writeArrayToMemory = writeArrayToMemory;
-  function run5() {
+  function run3() {
     preRun();
     function doRun() {
       n2.calledRun = true, initRuntime(), o2?.(n2), n2.onRuntimeInitialized?.(), postRun();
@@ -10617,7 +10653,7 @@ async function OpenJPEG(e2 = {}) {
     }, 1)) : doRun();
   }
   var f2 = {}();
-  return run5(), t2 = s2 ? n2 : new Promise((e3, t3) => {
+  return run3(), t2 = s2 ? n2 : new Promise((e3, t3) => {
     o2 = e3;
   }), t2;
 }
@@ -49313,7 +49349,7 @@ var init_check_pdf = __esm({
       ])
     });
     isGlyph = (item) => typeof item !== "number";
-    visibleCharacters = (run5) => run5.filter((item) => isGlyph(item) && /\S/.test(item.unicode ?? "")).length;
+    visibleCharacters = (run3) => run3.filter((item) => isGlyph(item) && /\S/.test(item.unicode ?? "")).length;
     fontOf = (page, id) => {
       if (id === void 0) {
         return void 0;
@@ -49484,8 +49520,8 @@ var decoder, toUTF8String, toHexString, getView, readInt16LE, readUInt16BE, read
 var init_utils = __esm({
   "../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/utils.js"() {
     decoder = new TextDecoder();
-    toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
-    toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i3) => memo + `0${i3.toString(16)}`.slice(-2), "");
+    toUTF8String = (input, start2 = 0, end = input.length) => decoder.decode(input.slice(start2, end));
+    toHexString = (input, start2 = 0, end = input.length) => input.slice(start2, end).reduce((memo, i3) => memo + `0${i3.toString(16)}`.slice(-2), "");
     getView = (input, offset) => new DataView(input.buffer, input.byteOffset + offset);
     readInt16LE = (input, offset = 0) => getView(input, offset).getInt16(0, true);
     readUInt16BE = (input, offset = 0) => getView(input, offset).getUint16(0, false);
@@ -49843,12 +49879,12 @@ function extractOrientation(exifBlock, isBigEndian) {
   const offset = EXIF_HEADER_BYTES + idfOffset;
   const idfDirectoryEntries = readUInt(exifBlock, 16, offset, isBigEndian);
   for (let directoryEntryNumber = 0; directoryEntryNumber < idfDirectoryEntries; directoryEntryNumber++) {
-    const start = offset + NUM_DIRECTORY_ENTRIES_BYTES + directoryEntryNumber * IDF_ENTRY_BYTES;
-    const end = start + IDF_ENTRY_BYTES;
-    if (start > exifBlock.length) {
+    const start2 = offset + NUM_DIRECTORY_ENTRIES_BYTES + directoryEntryNumber * IDF_ENTRY_BYTES;
+    const end = start2 + IDF_ENTRY_BYTES;
+    if (start2 > exifBlock.length) {
       return;
     }
-    const block = exifBlock.slice(start, end);
+    const block = exifBlock.slice(start2, end);
     const tagNumber = readUInt(block, 16, 0, isBigEndian);
     if (tagNumber === 274) {
       const dataFormat = readUInt(block, 16, 2, isBigEndian);
@@ -50882,9 +50918,9 @@ var init_check_pptx = __esm({
         () => intAttr(childAt(pPr, "a:defRPr"), attribute),
         ...style.listStyles.map((listStyle) => () => intAttr(childAt(listStyle, `a:lvl${level}pPr`, "a:defRPr"), attribute))
       ]);
-      const runSizes = runs.flatMap((run5) => intAttr(childNamed(run5, "a:rPr"), "sz") ?? []);
+      const runSizes = runs.flatMap((run3) => intAttr(childNamed(run3, "a:rPr"), "sz") ?? []);
       const size = runSizes.length > 0 ? Math.max(...runSizes) : intAttr(childNamed(p2, "a:endParaRPr"), "sz") ?? inherited("sz") ?? DEFAULT_SIZE_HUNDREDTHS;
-      const bold = runs.some((run5) => childNamed(run5, "a:rPr")?.attrs["b"] === "1") || runs.length > 0 && inherited("b") === 1;
+      const bold = runs.some((run3) => childNamed(run3, "a:rPr")?.attrs["b"] === "1") || runs.length > 0 && inherited("b") === 1;
       const spacing = (name) => firstOf([
         () => hundredthsAt(pPr, [name, "a:spcPts"], "val"),
         ...style.listStyles.map((listStyle) => () => hundredthsAt(listStyle, [`a:lvl${level}pPr`, name, "a:spcPts"], "val"))
@@ -51521,7 +51557,7 @@ var require_ignore = __commonJS({
     }
     var UNDEFINED = void 0;
     var EMPTY = "";
-    var SPACE = " ";
+    var SPACE2 = " ";
     var ESCAPE = "\\";
     var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
     var BOM = "\uFEFF";
@@ -51573,9 +51609,9 @@ var require_ignore = __commonJS({
       const source = `[${body}]`;
       return new RegExp(source).test("/") ? NON_SLASH + source : source;
     };
-    var scanBracket = (pattern, start) => {
+    var scanBracket = (pattern, start2) => {
       const { length } = pattern;
-      let index = start + 1;
+      let index = start2 + 1;
       let negated = EMPTY;
       const lead = pattern[index];
       if (lead === "!" || lead === "^") {
@@ -51662,7 +51698,7 @@ var require_ignore = __commonJS({
           const escaped = pattern[index + 1];
           if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) {
             out += hold(NEVER_MATCH);
-          } else if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
+          } else if (escaped === "*" || escaped === "[" || escaped === SPACE2 || escaped === ESCAPE) {
             out += pattern.slice(index, index + 2);
           } else {
             out += hold(
@@ -51707,8 +51743,8 @@ var require_ignore = __commonJS({
         //   ever starts again inside it -- `(\\+?) ` did, which made a long run
         //   quadratic.
         /(\\+)( ?)/g,
-        (_3, run5, space) => space ? run5.slice(0, run5.length - run5.length % 2) + SPACE : run5,
-        ESCAPE + SPACE
+        (_3, run3, space) => space ? run3.slice(0, run3.length - run3.length % 2) + SPACE2 : run3,
+        ESCAPE + SPACE2
       ],
       // Escape metacharacters
       // which is written down by users but means special for regular expressions.
@@ -51880,10 +51916,10 @@ var require_ignore = __commonJS({
     var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
     var replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
     var WILDCARD = "[^\\/]*";
-    var separatorAfter = (run5, at2) => {
+    var separatorAfter = (run3, at2) => {
       let separator = EMPTY;
-      for (let index = at2 + 1; index < run5.length && !run5[index].wildcard; index++) {
-        separator += run5[index].single;
+      for (let index = at2 + 1; index < run3.length && !run3[index].wildcard; index++) {
+        separator += run3[index].single;
       }
       return separator;
     };
@@ -51943,26 +51979,26 @@ var require_ignore = __commonJS({
         }
       }
       let out = EMPTY;
-      let run5 = [];
+      let run3 = [];
       const flush = () => {
         let lastWildcard;
-        run5.forEach((token, at2) => {
+        run3.forEach((token, at2) => {
           if (token.wildcard) {
             lastWildcard = at2;
           }
         });
-        run5.forEach((token, at2) => {
+        run3.forEach((token, at2) => {
           if (!token.wildcard) {
             out += token.single;
             return;
           }
-          out += at2 === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run5, at2)})[^\\/])*`;
+          out += at2 === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run3, at2)})[^\\/])*`;
         });
-        run5 = [];
+        run3 = [];
       };
       tokens.forEach((token) => {
         if (token.boundary === void 0) {
-          run5.push(token);
+          run3.push(token);
           return;
         }
         flush();
@@ -52076,7 +52112,7 @@ var require_ignore = __commonJS({
         end--;
       }
       const lineEnd = end;
-      while (end && body[end - 1] === SPACE) {
+      while (end && body[end - 1] === SPACE2) {
         end--;
       }
       if (end === lineEnd) {
@@ -52086,7 +52122,7 @@ var require_ignore = __commonJS({
       while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {
         backslashes++;
       }
-      return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+      return backslashes % 2 ? body.slice(0, end - 1) + SPACE2 : body.slice(0, end);
     };
     var createRule = ({
       pattern,
@@ -52102,7 +52138,7 @@ var require_ignore = __commonJS({
         body = body.slice(1);
       }
       const last = body[body.length - 1];
-      if (last === SPACE || last === "\r" || last === "\n") {
+      if (last === SPACE2 || last === "\r" || last === "\n") {
         body = trimEnd2(body);
       }
       if (!body) {
@@ -52199,13 +52235,13 @@ var require_ignore = __commonJS({
         const rules = this._rules;
         const { length } = rules;
         const shortcut = this._basenameCount * 2 >= length;
-        const basename7 = shortcut ? basenameOf(path) : path;
+        const basename8 = shortcut ? basenameOf(path) : path;
         for (let index = 0; index < length; index++) {
           const rule = rules[index];
           const { negative } = rule;
           const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
           if (!skip && rule[mode].test(
-            shortcut && rule._basenameOnly ? basename7 : path
+            shortcut && rule._basenameOnly ? basename8 : path
           )) {
             ignored = !negative;
             unignored = negative;
@@ -52391,6 +52427,105 @@ var init_turn_preamble = __esm({
   }
 });
 
+// ../../_tools/constants/src/one-liner.ts
+var SETUP_CODE_PATTERN, SYNC_LEAF_PATTERN, FIX_CODE_PATTERN, SLUG_PATTERN, IMAGE_HASH_PATTERN, SHORT_CODE_PATTERN, HOSTNAME_PATTERN, DEFAULT_SYNC_ROOT, isOneLinerHost, arg, slug, host, shortCode, RECREATE, coded, VERBS, ONE_LINER_VERBS;
+var init_one_liner = __esm({
+  "../../_tools/constants/src/one-liner.ts"() {
+    "use strict";
+    init_src();
+    SETUP_CODE_PATTERN = /^[A-Za-z0-9]{6,64}$/;
+    SYNC_LEAF_PATTERN = /^[a-z0-9][a-z0-9-]{0,80}$/;
+    FIX_CODE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
+    SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{1,62}$/;
+    IMAGE_HASH_PATTERN = /^[a-f0-9]{8,64}$/;
+    SHORT_CODE_PATTERN = /^[0-9A-Za-z]{4}-?[0-9A-Za-z]{4}$/;
+    HOSTNAME_PATTERN = /^(?=.{4,253}$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/;
+    DEFAULT_SYNC_ROOT = "~/intentic";
+    isOneLinerHost = (host2) => HOSTNAME_PATTERN.test(host2) && !/^\d+$/.test(host2.slice(host2.lastIndexOf(".") + 1));
+    arg = (name, pattern, normalize) => ({
+      name,
+      test: (value) => pattern.test(value),
+      ...normalize === void 0 ? {} : { normalize }
+    });
+    slug = arg(`sandbox name`, SLUG_PATTERN);
+    host = { name: `sandbox address`, test: isOneLinerHost, normalize: (value) => value.toLowerCase() };
+    shortCode = arg(`code`, SHORT_CODE_PATTERN);
+    RECREATE = { sh: `recreate.sh`, ps1: `recreate.ps1` };
+    coded = (sh, ps1) => ({
+      files: { sh, ps1 },
+      required: [host, shortCode],
+      optional: [],
+      sh: ([address = ``, code = ``]) => ({ args: [address, code] }),
+      ps1: ([address = ``, code = ``]) => [
+        { name: `Sandbox`, value: address },
+        { name: `Code`, value: code }
+      ]
+    });
+    VERBS = {
+      setup: {
+        files: { sh: `connect.sh`, ps1: `connect.ps1` },
+        required: [arg(`setup code`, SETUP_CODE_PATTERN)],
+        optional: [arg(`sync folder`, SYNC_LEAF_PATTERN)],
+        sh: ([code = ``, leaf]) => ({ args: [code], env: leaf === void 0 ? [] : [[`SYNC_DIR`, `${DEFAULT_SYNC_ROOT}/${leaf}`]] }),
+        ps1: ([code = ``, leaf]) => [
+          { name: `SetupCode`, value: code },
+          ...leaf === void 0 ? [] : [{ name: `SyncDir`, value: `${DEFAULT_SYNC_ROOT}/${leaf}` }]
+        ]
+      },
+      fix: {
+        files: { sh: `fix.sh`, ps1: `fix.ps1` },
+        required: [arg(`fix code`, FIX_CODE_PATTERN)],
+        optional: [],
+        sh: ([code = ``]) => ({ args: [code] }),
+        ps1: ([code = ``]) => [{ name: `Code`, value: code }]
+      },
+      update: {
+        files: RECREATE,
+        required: [slug],
+        optional: [],
+        sh: ([name = ``]) => ({ args: [name] }),
+        ps1: ([name = ``]) => [{ name: `Slug`, value: name }]
+      },
+      rollback: {
+        files: RECREATE,
+        required: [slug],
+        optional: [],
+        sh: ([name = ``]) => ({ args: [name, `--rollback`] }),
+        ps1: ([name = ``]) => [{ name: `Slug`, value: name }, { name: `Rollback` }]
+      },
+      restart: {
+        files: RECREATE,
+        required: [slug],
+        optional: [],
+        sh: ([name = ``]) => ({ args: [name, `--restart`] }),
+        ps1: ([name = ``]) => [{ name: `Slug`, value: name }, { name: `Restart` }]
+      },
+      rebuild: {
+        files: RECREATE,
+        required: [slug, arg(`image hash`, IMAGE_HASH_PATTERN)],
+        optional: [],
+        sh: ([name = ``, hash = ``]) => ({ args: [name, hash] }),
+        ps1: ([name = ``, hash = ``]) => [
+          { name: `Slug`, value: name },
+          { name: `Hash`, value: hash }
+        ]
+      },
+      // Recoverable for 7 days; with no name the script lists the sandboxes on the device and asks which.
+      remove: {
+        files: { sh: `cleanup.sh`, ps1: `cleanup.ps1` },
+        required: [],
+        optional: [slug],
+        sh: ([name]) => ({ args: name === void 0 ? [] : [name, `--yes`] }),
+        ps1: ([name]) => name === void 0 ? [] : [{ name: `Slug`, value: name }, { name: `Yes` }]
+      },
+      device: coded(`device.sh`, `device.ps1`),
+      sync: coded(`sync.sh`, `sync.ps1`),
+      server: coded(`connect-host.sh`, `connect-host.ps1`)
+    };
+    ONE_LINER_VERBS = Object.keys(VERBS);
+  }
+});
+
 // ../../_tools/constants/src/index.ts
 var STATE_DIR, REFERENCE_DIR, GOOGLE_CLIENT_ID, GOOGLE_TOKEN_STORAGE_KEY;
 var init_src = __esm({
@@ -52400,6 +52535,7 @@ var init_src = __esm({
     init_profile();
     init_hosted_tiers();
     init_turn_preamble();
+    init_one_liner();
     STATE_DIR = ".intentic";
     REFERENCE_DIR = "refs";
     GOOGLE_CLIENT_ID = "481795963975-cq9msl6higcd91joidrfp8mjlkuq5fk3.apps.googleusercontent.com";
@@ -52436,15 +52572,15 @@ var init_constants = __esm({
     ]);
     isSeparator = (char) => char === "/" || char === "\\";
     firstSegment = (relPath) => {
-      let start = 0;
-      while (isSeparator(relPath[start])) {
-        start++;
+      let start2 = 0;
+      while (isSeparator(relPath[start2])) {
+        start2++;
       }
-      let end = start;
+      let end = start2;
       while (end < relPath.length && !isSeparator(relPath[end])) {
         end++;
       }
-      return relPath.slice(start, end);
+      return relPath.slice(start2, end);
     };
     isReferencePath = (relPath) => firstSegment(relPath) === REFERENCE_DIR;
     AGENT_WORKTREE_SEGMENTS = [".claude", "worktrees"];
@@ -52922,7 +53058,7 @@ function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCou
   const single = new Int32Array(slotCount);
   single.fill(-1, dict1AtomCount, dictSize);
   single.fill(-1, dictSize + dict2AtomCount, slotCount);
-  const start = new Int32Array(slotCount);
+  const start2 = new Int32Array(slotCount);
   const length = new Int32Array(slotCount);
   function decodeDelta(count, off) {
     let previous = 0;
@@ -52958,7 +53094,7 @@ function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCou
       references[ngramIndex * 2] = a2;
       references[ngramIndex * 2 + 1] = b3;
       ngramIndex += 1;
-      start[slot] = poolSize;
+      start2[slot] = poolSize;
       const entryLength = (single[a2] < 0 ? length[a2] : 1) + (single[b3] < 0 ? length[b3] : 1);
       length[slot] = entryLength;
       poolSize += entryLength;
@@ -52973,7 +53109,7 @@ function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCou
       const source = references[index * 2 + half];
       const value = single[source];
       if (value < 0) {
-        let read2 = start[source];
+        let read2 = start2[source];
         const readEnd = read2 + length[source];
         while (read2 < readEnd)
           pool[write3++] = pool[read2++];
@@ -52991,7 +53127,7 @@ function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCou
     }
     const value = single[slot];
     if (value < 0) {
-      let read2 = start[slot];
+      let read2 = start2[slot];
       const readEnd = read2 + length[slot];
       while (read2 < readEnd)
         out[outIndex++] = pool[read2++];
@@ -60779,17 +60915,17 @@ var init_markdown = __esm({
     };
     renderFlow = (nodes, options) => {
       const blocks = [];
-      let run5 = "";
+      let run3 = "";
       const flush = () => {
-        const paragraph = collapse(run5);
+        const paragraph = collapse(run3);
         if (paragraph !== "") {
           blocks.push(paragraph);
         }
-        run5 = "";
+        run3 = "";
       };
       for (const node of nodes) {
         if (isText(node)) {
-          run5 += node.value;
+          run3 += node.value;
           continue;
         }
         if (!isElement2(node) || NON_CONTENT2.has(node.tagName)) {
@@ -60797,7 +60933,7 @@ var init_markdown = __esm({
         }
         const block = renderBlock(node, options);
         if (block === void 0) {
-          run5 += renderInline(node, options);
+          run3 += renderInline(node, options);
         } else {
           flush();
           if (block !== "") {
@@ -60916,11 +61052,11 @@ var init_markdown = __esm({
     };
     renderList = (el, options, depth) => {
       const ordered = el.tagName === "ol";
-      const start = Number(attr(el, "start") ?? "1");
+      const start2 = Number(attr(el, "start") ?? "1");
       const items = el.childNodes.filter(isElement2).filter((child) => child.tagName === "li");
       const lines = [];
       items.forEach((item, index) => {
-        const marker = ordered ? `${start + index}. ` : "- ";
+        const marker = ordered ? `${start2 + index}. ` : "- ";
         const indent = "    ".repeat(depth);
         const nested = [];
         const inlineParts = [];
@@ -61045,6 +61181,273 @@ ${fence}`;
   }
 });
 
+// ../../_tools/base/src/async.ts
+var keyedLock, sleep;
+var init_async = __esm({
+  "../../_tools/base/src/async.ts"() {
+    "use strict";
+    init_errors();
+    keyedLock = () => {
+      const tails = /* @__PURE__ */ new Map();
+      return (key, task) => {
+        const next = (tails.get(key) ?? Promise.resolve()).then(task, task);
+        const tail = next.catch(() => void 0);
+        tails.set(key, tail);
+        void tail.then(() => {
+          if (tails.get(key) === tail) {
+            tails.delete(key);
+          }
+        });
+        return next;
+      };
+    };
+    sleep = (ms2, options) => new Promise((resolve7) => {
+      const signal = options?.signal;
+      if (signal?.aborted === true) {
+        resolve7();
+        return;
+      }
+      const done = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", done);
+        resolve7();
+      };
+      const timer = setTimeout(done, ms2);
+      if (options?.unref === true) {
+        timer.unref?.();
+      }
+      signal?.addEventListener("abort", done, { once: true });
+    });
+  }
+});
+
+// ../../_tools/base/src/node/process.ts
+import { spawn, spawnSync } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+var DEFAULT_MAX_OUTPUT, PIPE_QUIET_MS, PIPE_LINGER_MS, PIPE_POLL_MS, KILL_GRACE_MS, textCollector, delay, signalGroup, GROUP_POLL_MS, groupAlive, stopProcessTree, spawnOptions, start, stopperFor, drain, run2, runBounded, ProcessError, execBounded;
+var init_process = __esm({
+  "../../_tools/base/src/node/process.ts"() {
+    "use strict";
+    init_async();
+    init_errors();
+    DEFAULT_MAX_OUTPUT = 8 * 1024 * 1024;
+    PIPE_QUIET_MS = 1e3;
+    PIPE_LINGER_MS = 5e3;
+    PIPE_POLL_MS = 50;
+    KILL_GRACE_MS = 2e3;
+    textCollector = (maxOutput) => {
+      const decoder5 = new StringDecoder("utf8");
+      const half = Math.floor(maxOutput / 2);
+      let head = "";
+      let tail = "";
+      let dropped = 0;
+      const take = (text) => {
+        const room = Math.max(half - head.length, 0);
+        head += text.slice(0, room);
+        tail += text.slice(room);
+        if (tail.length > half) {
+          dropped += tail.length - half;
+          tail = tail.slice(-half);
+        }
+      };
+      return {
+        write: (chunk) => take(decoder5.write(chunk)),
+        end: () => {
+          take(decoder5.end());
+          return { text: dropped === 0 ? `${head}${tail}` : `${head}
+\u2026 [${dropped} characters cut] \u2026
+${tail}`, dropped };
+        }
+      };
+    };
+    delay = (ms2) => sleep(ms2, { unref: true });
+    signalGroup = (pid, signal) => {
+      try {
+        process.kill(-pid, signal);
+      } catch (error2) {
+        if (errnoCode(error2) !== "ESRCH") {
+          throw error2;
+        }
+      }
+    };
+    GROUP_POLL_MS = 25;
+    groupAlive = (pid) => {
+      try {
+        process.kill(-pid, 0);
+        return true;
+      } catch (error2) {
+        return errnoCode(error2) !== "ESRCH";
+      }
+    };
+    stopProcessTree = async (child, killGraceMs = KILL_GRACE_MS) => {
+      const pid = child.pid;
+      if (pid === void 0) {
+        return;
+      }
+      if (process.platform === "win32") {
+        await new Promise((resolve7) => {
+          spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).once("exit", () => resolve7()).once("error", () => resolve7());
+        });
+        child.kill();
+        return;
+      }
+      signalGroup(pid, "SIGTERM");
+      const until = Date.now() + killGraceMs;
+      while (groupAlive(pid) && Date.now() < until) {
+        await delay(GROUP_POLL_MS);
+      }
+      signalGroup(pid, "SIGKILL");
+    };
+    spawnOptions = (options) => {
+      const spawned = {
+        stdio: [options.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+        // A process group of its own, which a deadline ends whole. On Windows this would open a console window
+        // instead, and taskkill /T finds the tree without one.
+        detached: process.platform !== "win32",
+        windowsHide: true
+      };
+      if (options.cwd !== void 0) {
+        spawned.cwd = options.cwd;
+      }
+      if (options.env !== void 0) {
+        spawned.env = options.env;
+      }
+      return spawned;
+    };
+    start = (command, args, options) => {
+      try {
+        return spawn(command, [...args], spawnOptions(options));
+      } catch (error2) {
+        return error2 instanceof Error ? error2 : new Error(String(error2));
+      }
+    };
+    stopperFor = (child, options) => {
+      let stopping;
+      let timedOut = false;
+      let aborted = false;
+      const stop = () => {
+        stopping ??= stopProcessTree(child, options.killGraceMs);
+      };
+      const deadline = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+        timedOut = true;
+        stop();
+      }, options.timeoutMs);
+      const onAbort = () => {
+        aborted = true;
+        stop();
+      };
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      return {
+        timedOut: () => timedOut,
+        aborted: () => aborted,
+        stopped: async () => {
+          await stopping;
+        },
+        dispose: () => {
+          clearTimeout(deadline);
+          options.signal?.removeEventListener("abort", onAbort);
+        }
+      };
+    };
+    drain = async (child, closed, lastData) => {
+      const exitedAt = Date.now();
+      for (; ; ) {
+        if (await Promise.race([closed, delay(PIPE_POLL_MS).then(() => false)])) {
+          return true;
+        }
+        const now = Date.now();
+        if (now - lastData() >= PIPE_QUIET_MS || now - exitedAt >= PIPE_LINGER_MS) {
+          child.stdout?.destroy();
+          child.stderr?.destroy();
+          return false;
+        }
+      }
+    };
+    run2 = async (command, args, options, stdout) => {
+      const stderr = textCollector(options.maxOutput ?? DEFAULT_MAX_OUTPUT);
+      const failed = (spawnError, aborted) => ({
+        exitCode: null,
+        exitSignal: null,
+        stdout: stdout.end(),
+        stderr: stderr.end(),
+        timedOut: false,
+        aborted,
+        lingering: false,
+        spawnError
+      });
+      if (options.signal?.aborted === true) {
+        return failed(new Error(`${command} was not started: the call was aborted`), true);
+      }
+      const child = start(command, args, options);
+      if (child instanceof Error) {
+        return failed(child, false);
+      }
+      options.onSpawn?.(child);
+      let lastData = Date.now();
+      const heard = (sink) => (chunk) => {
+        lastData = Date.now();
+        sink.write(chunk);
+      };
+      child.stdout?.on("data", heard(stdout));
+      child.stderr?.on("data", heard(stderr));
+      if (options.input !== void 0 && child.stdin !== null) {
+        child.stdin.on("error", () => void 0);
+        child.stdin.end(options.input);
+      }
+      const closed = new Promise((resolve7) => child.once("close", () => resolve7(true)));
+      const stopper = stopperFor(child, options);
+      const ended = await new Promise((resolve7) => {
+        child.once("exit", (code, signal) => resolve7({ code, signal }));
+        child.once("error", (error2) => resolve7(error2));
+      });
+      stopper.dispose();
+      if (ended instanceof Error) {
+        return failed(ended, stopper.aborted());
+      }
+      await stopper.stopped();
+      const drained = await drain(child, closed, () => lastData);
+      return {
+        exitCode: ended.code,
+        exitSignal: ended.signal,
+        stdout: stdout.end(),
+        stderr: stderr.end(),
+        timedOut: stopper.timedOut(),
+        aborted: stopper.aborted(),
+        lingering: !drained
+      };
+    };
+    runBounded = async (command, args, options = {}) => await run2(command, args, options, textCollector(options.maxOutput ?? DEFAULT_MAX_OUTPUT));
+    ProcessError = class extends Error {
+      code;
+      killed;
+      signal;
+      stdout;
+      stderr;
+      timedOut;
+      constructor(command, args, result) {
+        const line2 = [command, ...args].join(" ");
+        const reason = result.spawnError !== void 0 ? result.spawnError.message : result.timedOut ? "it ran past its deadline and was stopped" : result.aborted ? "it was aborted" : `exit ${result.exitCode ?? result.exitSignal ?? "unknown"}`;
+        super(`Command failed: ${line2} (${reason})${result.stderr.text.trim() === "" ? "" : `
+${result.stderr.text.trimEnd()}`}`, result.spawnError === void 0 ? {} : { cause: result.spawnError });
+        this.name = "ProcessError";
+        this.code = result.spawnError !== void 0 ? errnoCode(result.spawnError) : result.exitCode ?? void 0;
+        this.killed = result.timedOut || result.aborted;
+        this.signal = result.exitSignal;
+        this.stdout = result.stdout.text;
+        this.stderr = result.stderr.text;
+        this.timedOut = result.timedOut;
+      }
+    };
+    execBounded = async (command, args, options = {}) => {
+      const result = await runBounded(command, args, options);
+      if (result.exitCode !== 0) {
+        throw new ProcessError(command, args, result);
+      }
+      return { stdout: result.stdout.text, stderr: result.stderr.text };
+    };
+  }
+});
+
 // ../fileq/src/lib/tools.ts
 import { accessSync, constants } from "node:fs";
 import { join as join2 } from "node:path";
@@ -61067,15 +61470,13 @@ var init_tools = __esm({
 });
 
 // ../fileq/src/lib/archives.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var run2, zipEntries, BLOCK, decoder2, field, octal, headerChecks, looksLikeTar, paxPath, blockAt, NAME_CARRIERS, carriedName, entryOf, tarEntries, gzipName, gzipHead, tarOnPath, LISTING_LINE, parseTarListing, TAR_TIMEOUT_MS, TAR_MAX_BUFFER, listWithTar;
+var zipEntries, BLOCK, decoder2, field, octal, headerChecks, looksLikeTar, paxPath, blockAt, NAME_CARRIERS, carriedName, entryOf, tarEntries, gzipName, gzipHead, tarOnPath, LISTING_LINE, parseTarListing, TAR_TIMEOUT_MS, TAR_MAX_OUTPUT, listWithTar;
 var init_archives = __esm({
   "../fileq/src/lib/archives.ts"() {
     "use strict";
+    init_process();
     init_esm();
     init_tools();
-    run2 = promisify(execFile);
     zipEntries = (bytes) => {
       const entries = [];
       unzipSync(bytes, {
@@ -61198,9 +61599,9 @@ var init_archives = __esm({
       return entries;
     };
     TAR_TIMEOUT_MS = 6e4;
-    TAR_MAX_BUFFER = 16 * 1024 * 1024;
+    TAR_MAX_OUTPUT = 16 * 1024 * 1024;
     listWithTar = async (absPath) => {
-      const { stdout } = await run2("tar", ["-tvf", absPath], { timeout: TAR_TIMEOUT_MS, maxBuffer: TAR_MAX_BUFFER });
+      const { stdout } = await execBounded("tar", ["-tvf", absPath], { timeoutMs: TAR_TIMEOUT_MS, maxOutput: TAR_MAX_OUTPUT });
       return parseTarListing(stdout);
     };
   }
@@ -61913,7 +62314,7 @@ var require_underscore_node_f = __commonJS({
       "\u2028": "u2028",
       "\u2029": "u2029"
     };
-    var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
+    var escapeRegExp2 = /\\|'|\r|\n|\u2028|\u2029/g;
     function escapeChar(match) {
       return "\\" + escapes[match];
     }
@@ -61929,7 +62330,7 @@ var require_underscore_node_f = __commonJS({
       var index = 0;
       var source = "__p+='";
       text.replace(matcher2, function(match, escape2, interpolate, evaluate, offset) {
-        source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
+        source += text.slice(index, offset).replace(escapeRegExp2, escapeChar);
         index = offset + match.length;
         if (escape2) {
           source += "'+\n((__t=(" + escape2 + "))==null?'':_.escape(__t))+\n'";
@@ -62065,12 +62466,12 @@ var require_underscore_node_f = __commonJS({
       memoize2.cache = {};
       return memoize2;
     }
-    var delay = restArguments(function(func, wait, args) {
+    var delay2 = restArguments(function(func, wait, args) {
       return setTimeout(function() {
         return func.apply(null, args);
       }, wait);
     });
-    var defer = partial(delay, _$1, 1);
+    var defer = partial(delay2, _$1, 1);
     function throttle(func, wait, options) {
       var timeout, context, args, result2;
       var previous = 0;
@@ -62145,10 +62546,10 @@ var require_underscore_node_f = __commonJS({
     }
     function compose() {
       var args = arguments;
-      var start = args.length - 1;
+      var start2 = args.length - 1;
       return function() {
-        var i3 = start;
-        var result2 = args[start].apply(this, arguments);
+        var i3 = start2;
+        var result2 = args[start2].apply(this, arguments);
         while (i3--) result2 = args[i3].call(this, result2);
         return result2;
       };
@@ -62590,18 +62991,18 @@ var require_underscore_node_f = __commonJS({
       }
       return result2;
     }
-    function range(start, stop, step) {
+    function range(start2, stop, step) {
       if (stop == null) {
-        stop = start || 0;
-        start = 0;
+        stop = start2 || 0;
+        start2 = 0;
       }
       if (!step) {
-        step = stop < start ? -1 : 1;
+        step = stop < start2 ? -1 : 1;
       }
-      var length = Math.max(Math.ceil((stop - start) / step), 0);
+      var length = Math.max(Math.ceil((stop - start2) / step), 0);
       var range2 = Array(length);
-      for (var idx = 0; idx < length; idx++, start += step) {
-        range2[idx] = start;
+      for (var idx = 0; idx < length; idx++, start2 += step) {
+        range2[idx] = start2;
       }
       return range2;
     }
@@ -62719,7 +63120,7 @@ var require_underscore_node_f = __commonJS({
       bind,
       bindAll,
       memoize,
-      delay,
+      delay: delay2,
       defer,
       throttle,
       debounce,
@@ -62821,7 +63222,7 @@ var require_underscore_node_f = __commonJS({
     exports2.debounce = debounce;
     exports2.defaults = defaults;
     exports2.defer = defer;
-    exports2.delay = delay;
+    exports2.delay = delay2;
     exports2.difference = difference;
     exports2.each = each;
     exports2.every = every;
@@ -62991,14 +63392,14 @@ var require_promises = __commonJS({
       }
     };
     function defer() {
-      var resolve6;
+      var resolve7;
       var reject;
       var promise = new Promise(function(resolveArg, rejectArg) {
-        resolve6 = resolveArg;
+        resolve7 = resolveArg;
         reject = rejectArg;
       });
       return {
-        resolve: resolve6,
+        resolve: resolve7,
         reject,
         promise
       };
@@ -63010,8 +63411,8 @@ var require_promises = __commonJS({
     }
     ExternalPromise.__proto__ = Promise;
     ExternalPromise.prototype.__proto__ = Promise.prototype;
-    ExternalPromise.prototype.done = function(resolve6, reject) {
-      return this.then(resolve6, reject).catch(function(error2) {
+    ExternalPromise.prototype.done = function(resolve7, reject) {
+      return this.then(resolve7, reject).catch(function(error2) {
         if (isNode3()) {
           var stack = error2 instanceof Error ? error2.stack : error2;
           process.stderr.write("Fatal " + stack + "\n");
@@ -63402,10 +63803,10 @@ var require_base64_js = __commonJS({
     function tripletToBase64(num) {
       return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
     }
-    function encodeChunk(uint8, start, end) {
+    function encodeChunk(uint8, start2, end) {
       var tmp;
       var output = [];
-      for (var i4 = start; i4 < end; i4 += 3) {
+      for (var i4 = start2; i4 < end; i4 += 3) {
         tmp = (uint8[i4] << 16 & 16711680) + (uint8[i4 + 1] << 8 & 65280) + (uint8[i4 + 2] & 255);
         output.push(tripletToBase64(tmp));
       }
@@ -63514,15 +63915,15 @@ var require_safe_buffer = __commonJS({
       copyProps(buffer, exports2);
       exports2.Buffer = SafeBuffer;
     }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer2(arg, encodingOrOffset, length);
+    function SafeBuffer(arg2, encodingOrOffset, length) {
+      return Buffer2(arg2, encodingOrOffset, length);
     }
     copyProps(Buffer2, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
+    SafeBuffer.from = function(arg2, encodingOrOffset, length) {
+      if (typeof arg2 === "number") {
         throw new TypeError("Argument must not be a number");
       }
-      return Buffer2(arg, encodingOrOffset, length);
+      return Buffer2(arg2, encodingOrOffset, length);
     };
     SafeBuffer.alloc = function(size, fill, encoding) {
       if (typeof size !== "number") {
@@ -63558,47 +63959,47 @@ var require_safe_buffer = __commonJS({
 // ../../node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.js
 var require_util = __commonJS({
   "../../node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.js"(exports2) {
-    function isArray(arg) {
+    function isArray(arg2) {
       if (Array.isArray) {
-        return Array.isArray(arg);
+        return Array.isArray(arg2);
       }
-      return objectToString2(arg) === "[object Array]";
+      return objectToString2(arg2) === "[object Array]";
     }
     exports2.isArray = isArray;
-    function isBoolean(arg) {
-      return typeof arg === "boolean";
+    function isBoolean(arg2) {
+      return typeof arg2 === "boolean";
     }
     exports2.isBoolean = isBoolean;
-    function isNull(arg) {
-      return arg === null;
+    function isNull(arg2) {
+      return arg2 === null;
     }
     exports2.isNull = isNull;
-    function isNullOrUndefined(arg) {
-      return arg == null;
+    function isNullOrUndefined(arg2) {
+      return arg2 == null;
     }
     exports2.isNullOrUndefined = isNullOrUndefined;
-    function isNumber2(arg) {
-      return typeof arg === "number";
+    function isNumber2(arg2) {
+      return typeof arg2 === "number";
     }
     exports2.isNumber = isNumber2;
-    function isString(arg) {
-      return typeof arg === "string";
+    function isString(arg2) {
+      return typeof arg2 === "string";
     }
     exports2.isString = isString;
-    function isSymbol(arg) {
-      return typeof arg === "symbol";
+    function isSymbol(arg2) {
+      return typeof arg2 === "symbol";
     }
     exports2.isSymbol = isSymbol;
-    function isUndefined(arg) {
-      return arg === void 0;
+    function isUndefined(arg2) {
+      return arg2 === void 0;
     }
     exports2.isUndefined = isUndefined;
     function isRegExp(re2) {
       return objectToString2(re2) === "[object RegExp]";
     }
     exports2.isRegExp = isRegExp;
-    function isObject2(arg) {
-      return typeof arg === "object" && arg !== null;
+    function isObject2(arg2) {
+      return typeof arg2 === "object" && arg2 !== null;
     }
     exports2.isObject = isObject2;
     function isDate(d2) {
@@ -63609,13 +64010,13 @@ var require_util = __commonJS({
       return objectToString2(e2) === "[object Error]" || e2 instanceof Error;
     }
     exports2.isError = isError2;
-    function isFunction(arg) {
-      return typeof arg === "function";
+    function isFunction(arg2) {
+      return typeof arg2 === "function";
     }
     exports2.isFunction = isFunction;
-    function isPrimitive2(arg) {
-      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
-      typeof arg === "undefined";
+    function isPrimitive2(arg2) {
+      return arg2 === null || typeof arg2 === "boolean" || typeof arg2 === "number" || typeof arg2 === "string" || typeof arg2 === "symbol" || // ES6 symbol
+      typeof arg2 === "undefined";
     }
     exports2.isPrimitive = isPrimitive2;
     exports2.isBuffer = __require("buffer").Buffer.isBuffer;
@@ -63717,7 +64118,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join9(s2) {
+      BufferList.prototype.join = function join10(s2) {
         if (this.length === 0) return "";
         var p2 = this.head;
         var ret2 = "" + p2.data;
@@ -64398,8 +64799,8 @@ var require_string_decoder = __commonJS({
       if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
       return nenc || enc;
     }
-    exports2.StringDecoder = StringDecoder;
-    function StringDecoder(encoding) {
+    exports2.StringDecoder = StringDecoder2;
+    function StringDecoder2(encoding) {
       this.encoding = normalizeEncoding(encoding);
       var nb;
       switch (this.encoding) {
@@ -64426,7 +64827,7 @@ var require_string_decoder = __commonJS({
       this.lastTotal = 0;
       this.lastChar = Buffer2.allocUnsafe(nb);
     }
-    StringDecoder.prototype.write = function(buf) {
+    StringDecoder2.prototype.write = function(buf) {
       if (buf.length === 0) return "";
       var r2;
       var i3;
@@ -64441,9 +64842,9 @@ var require_string_decoder = __commonJS({
       if (i3 < buf.length) return r2 ? r2 + this.text(buf, i3) : this.text(buf, i3);
       return r2 || "";
     };
-    StringDecoder.prototype.end = utf8End;
-    StringDecoder.prototype.text = utf8Text;
-    StringDecoder.prototype.fillLast = function(buf) {
+    StringDecoder2.prototype.end = utf8End;
+    StringDecoder2.prototype.text = utf8Text;
+    StringDecoder2.prototype.fillLast = function(buf) {
       if (this.lastNeed <= buf.length) {
         buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
         return this.lastChar.toString(this.encoding, 0, this.lastTotal);
@@ -64615,7 +65016,7 @@ var require_stream_readable = __commonJS({
     }
     var BufferList = require_BufferList();
     var destroyImpl = require_destroy();
-    var StringDecoder;
+    var StringDecoder2;
     util.inherits(Readable, Stream2);
     var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
     function prependListener(emitter, event, fn2) {
@@ -64657,8 +65058,8 @@ var require_stream_readable = __commonJS({
       this.decoder = null;
       this.encoding = null;
       if (options.encoding) {
-        if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
-        this.decoder = new StringDecoder(options.encoding);
+        if (!StringDecoder2) StringDecoder2 = require_string_decoder().StringDecoder;
+        this.decoder = new StringDecoder2(options.encoding);
         this.encoding = options.encoding;
       }
     }
@@ -64774,8 +65175,8 @@ var require_stream_readable = __commonJS({
       return this._readableState.flowing === false;
     };
     Readable.prototype.setEncoding = function(enc) {
-      if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
-      this._readableState.decoder = new StringDecoder(enc);
+      if (!StringDecoder2) StringDecoder2 = require_string_decoder().StringDecoder;
+      this._readableState.decoder = new StringDecoder2(enc);
       this._readableState.encoding = enc;
       return this;
     };
@@ -65692,8 +66093,8 @@ var require_lib2 = __commonJS({
         return this;
       }
       var p2 = this.constructor;
-      return this.then(resolve7, reject2);
-      function resolve7(value) {
+      return this.then(resolve8, reject2);
+      function resolve8(value) {
         function yes() {
           return value;
         }
@@ -65846,8 +66247,8 @@ var require_lib2 = __commonJS({
       }
       return out;
     }
-    Promise2.resolve = resolve6;
-    function resolve6(value) {
+    Promise2.resolve = resolve7;
+    function resolve7(value) {
       if (value instanceof this) {
         return value;
       }
@@ -65972,7 +66373,7 @@ var require_setImmediate = __commonJS({
       function clearImmediate(handle) {
         delete tasksByHandle[handle];
       }
-      function run5(task) {
+      function run3(task) {
         var callback = task.callback;
         var args = task.args;
         switch (args.length) {
@@ -66001,7 +66402,7 @@ var require_setImmediate = __commonJS({
           if (task) {
             currentlyRunningATask = true;
             try {
-              run5(task);
+              run3(task);
             } finally {
               clearImmediate(handle);
               currentlyRunningATask = false;
@@ -66382,10 +66783,10 @@ var require_utils = __commonJS({
           if (typeof Blob.prototype.arrayBuffer !== "undefined") {
             return data.arrayBuffer();
           } else if (typeof FileReader !== "undefined") {
-            return new external.Promise(function(resolve6, reject) {
+            return new external.Promise(function(resolve7, reject) {
               var reader = new FileReader();
               reader.onload = function(e2) {
-                resolve6(e2.target.result);
+                resolve7(e2.target.result);
               };
               reader.onerror = function(e2) {
                 reject(e2.target.error);
@@ -66512,10 +66913,10 @@ var require_GenericWorker = __commonJS({
        * @param {String} name the name of the event (data, end, error)
        * @param {Object} arg the argument to call the callback with.
        */
-      emit: function(name, arg) {
+      emit: function(name, arg2) {
         if (this._listeners[name]) {
           for (var i3 = 0; i3 < this._listeners[name].length; i3++) {
-            this._listeners[name][i3].call(this, arg);
+            this._listeners[name][i3].call(this, arg2);
           }
         }
       },
@@ -66944,7 +67345,7 @@ var require_StreamHelper = __commonJS({
       }
     }
     function accumulate(helper, updateCallback) {
-      return new external.Promise(function(resolve6, reject) {
+      return new external.Promise(function(resolve7, reject) {
         var dataArray = [];
         var chunkType = helper._internalType, resultType = helper._outputType, mimeType = helper._mimeType;
         helper.on("data", function(data, meta) {
@@ -66958,7 +67359,7 @@ var require_StreamHelper = __commonJS({
         }).on("end", function() {
           try {
             var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
-            resolve6(result);
+            resolve7(result);
           } catch (e2) {
             reject(e2);
           }
@@ -68317,7 +68718,7 @@ var require_deflate = __commonJS({
       s2.pending_buf[s2.pending++] = b3 >>> 8 & 255;
       s2.pending_buf[s2.pending++] = b3 & 255;
     }
-    function read_buf(strm, buf, start, size) {
+    function read_buf(strm, buf, start2, size) {
       var len = strm.avail_in;
       if (len > size) {
         len = size;
@@ -68326,11 +68727,11 @@ var require_deflate = __commonJS({
         return 0;
       }
       strm.avail_in -= len;
-      utils.arraySet(buf, strm.input, strm.next_in, len, start);
+      utils.arraySet(buf, strm.input, strm.next_in, len, start2);
       if (strm.state.wrap === 1) {
-        strm.adler = adler32(strm.adler, buf, len, start);
+        strm.adler = adler32(strm.adler, buf, len, start2);
       } else if (strm.state.wrap === 2) {
-        strm.adler = crc32(strm.adler, buf, len, start);
+        strm.adler = crc32(strm.adler, buf, len, start2);
       }
       strm.next_in += len;
       strm.total_in += len;
@@ -69600,7 +70001,7 @@ var require_inffast = __commonJS({
     "use strict";
     var BAD = 30;
     var TYPE = 12;
-    module2.exports = function inflate_fast(strm, start) {
+    module2.exports = function inflate_fast(strm, start2) {
       var state;
       var _in;
       var last;
@@ -69631,7 +70032,7 @@ var require_inffast = __commonJS({
       last = _in + (strm.avail_in - 5);
       _out = strm.next_out;
       output = strm.output;
-      beg = _out - (start - strm.avail_out);
+      beg = _out - (start2 - strm.avail_out);
       end = _out + (strm.avail_out - 257);
       dmax = state.dmax;
       wsize = state.wsize;
@@ -72267,16 +72668,16 @@ var require_object = __commonJS({
        * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
        * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
        */
-      folder: function(arg) {
-        if (!arg) {
+      folder: function(arg2) {
+        if (!arg2) {
           return this;
         }
-        if (isRegExp(arg)) {
+        if (isRegExp(arg2)) {
           return this.filter(function(relativePath, file) {
-            return file.dir && arg.test(relativePath);
+            return file.dir && arg2.test(relativePath);
           });
         }
-        var name = this.root + arg;
+        var name = this.root + arg2;
         var newFolder = folderAdd.call(this, name);
         var ret2 = this.clone();
         ret2.root = newFolder.name;
@@ -73071,7 +73472,7 @@ var require_load = __commonJS({
     var Crc32Probe = require_Crc32Probe();
     var nodejsUtils = require_nodejsUtils();
     function checkEntryCRC32(zipEntry) {
-      return new external.Promise(function(resolve6, reject) {
+      return new external.Promise(function(resolve7, reject) {
         var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());
         worker.on("error", function(e2) {
           reject(e2);
@@ -73079,7 +73480,7 @@ var require_load = __commonJS({
           if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {
             reject(new Error("Corrupted zip : CRC32 mismatch"));
           } else {
-            resolve6();
+            resolve7();
           }
         }).resume();
       });
@@ -74640,9 +75041,9 @@ var require_dom = __commonJS({
         this.replaceData(offset, count, "");
       },
       replaceData: function(offset, count, text) {
-        var start = this.data.substring(0, offset);
+        var start2 = this.data.substring(0, offset);
         var end = this.data.substring(offset + count);
-        text = start + text + end;
+        text = start2 + text + end;
         this.nodeValue = this.data = text;
         this.length = text.length;
       }
@@ -77285,11 +77686,11 @@ var require_sax = __commonJS({
         }
       }
       function appendText2(end2) {
-        if (end2 > start) {
-          var xt2 = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
-          locator && position(start);
-          domBuilder.characters(xt2, 0, end2 - start);
-          start = end2;
+        if (end2 > start2) {
+          var xt2 = source.substring(start2, end2).replace(/&#?\w+;/g, entityReplacer);
+          locator && position(start2);
+          domBuilder.characters(xt2, 0, end2 - start2);
+          start2 = end2;
         }
       }
       function position(p2, m2) {
@@ -77306,20 +77707,20 @@ var require_sax = __commonJS({
       var locator = domBuilder.locator;
       var parseStack = [{ currentNSMap: defaultNSMapCopy }];
       var closeMap = {};
-      var start = 0;
+      var start2 = 0;
       while (true) {
         try {
-          var tagStart = source.indexOf("<", start);
+          var tagStart = source.indexOf("<", start2);
           if (tagStart < 0) {
-            if (!source.substr(start).match(/^\s*$/)) {
+            if (!source.substr(start2).match(/^\s*$/)) {
               var doc = domBuilder.doc;
-              var text = doc.createTextNode(source.substr(start));
+              var text = doc.createTextNode(source.substr(start2));
               doc.appendChild(text);
               domBuilder.currentElement = text;
             }
             return;
           }
-          if (tagStart > start) {
+          if (tagStart > start2) {
             appendText2(tagStart);
           }
           switch (source.charAt(tagStart + 1)) {
@@ -77409,10 +77810,10 @@ var require_sax = __commonJS({
           errorHandler.error("element parse error: " + e2);
           end = -1;
         }
-        if (end > start) {
-          start = end;
+        if (end > start2) {
+          start2 = end;
         } else {
-          appendText2(Math.max(tagStart, start) + 1);
+          appendText2(Math.max(tagStart, start2) + 1);
         }
       }
     }
@@ -77421,7 +77822,7 @@ var require_sax = __commonJS({
       t2.columnNumber = f2.columnNumber;
       return t2;
     }
-    function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+    function parseElementStartPart(source, start2, el, currentNSMap, entityReplacer, errorHandler) {
       function addAttribute(qname, value2, startIndex) {
         if (el.attributeNames.hasOwnProperty(qname)) {
           errorHandler.fatalError("Attribute " + qname + " redefined");
@@ -77438,17 +77839,17 @@ var require_sax = __commonJS({
       }
       var attrName;
       var value;
-      var p2 = ++start;
+      var p2 = ++start2;
       var s2 = S_TAG;
       while (true) {
         var c2 = source.charAt(p2);
         if (s2 === S_TAG && c2 === "<") {
-          throw new Error("unexpected < in tag name: " + source.slice(start, p2));
+          throw new Error("unexpected < in tag name: " + source.slice(start2, p2));
         }
         switch (c2) {
           case "=":
             if (s2 === S_ATTR) {
-              attrName = source.slice(start, p2);
+              attrName = source.slice(start2, p2);
               s2 = S_EQ;
             } else if (s2 === S_ATTR_SPACE) {
               s2 = S_EQ;
@@ -77461,22 +77862,22 @@ var require_sax = __commonJS({
             if (s2 === S_EQ || s2 === S_ATTR) {
               if (s2 === S_ATTR) {
                 errorHandler.warning('attribute value must after "="');
-                attrName = source.slice(start, p2);
+                attrName = source.slice(start2, p2);
               }
-              start = p2 + 1;
-              p2 = source.indexOf(c2, start);
+              start2 = p2 + 1;
+              p2 = source.indexOf(c2, start2);
               if (p2 > 0) {
-                value = source.slice(start, p2);
-                addAttribute(attrName, value, start - 1);
+                value = source.slice(start2, p2);
+                addAttribute(attrName, value, start2 - 1);
                 s2 = S_ATTR_END;
               } else {
                 throw new Error("attribute value no end '" + c2 + "' match");
               }
             } else if (s2 == S_ATTR_NOQUOT_VALUE) {
-              value = source.slice(start, p2);
-              addAttribute(attrName, value, start);
+              value = source.slice(start2, p2);
+              addAttribute(attrName, value, start2);
               errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c2 + ")!!");
-              start = p2 + 1;
+              start2 = p2 + 1;
               s2 = S_ATTR_END;
             } else {
               throw new Error('attribute value must after "="');
@@ -77485,7 +77886,7 @@ var require_sax = __commonJS({
           case "/":
             switch (s2) {
               case S_TAG:
-                el.setTagName(source.slice(start, p2));
+                el.setTagName(source.slice(start2, p2));
               case S_ATTR_END:
               case S_TAG_SPACE:
               case S_TAG_CLOSE:
@@ -77505,13 +77906,13 @@ var require_sax = __commonJS({
           case "":
             errorHandler.error("unexpected end of input");
             if (s2 == S_TAG) {
-              el.setTagName(source.slice(start, p2));
+              el.setTagName(source.slice(start2, p2));
             }
             return p2;
           case ">":
             switch (s2) {
               case S_TAG:
-                el.setTagName(source.slice(start, p2));
+                el.setTagName(source.slice(start2, p2));
               case S_ATTR_END:
               case S_TAG_SPACE:
               case S_TAG_CLOSE:
@@ -77520,7 +77921,7 @@ var require_sax = __commonJS({
               case S_ATTR_NOQUOT_VALUE:
               //Compatible state
               case S_ATTR:
-                value = source.slice(start, p2);
+                value = source.slice(start2, p2);
                 if (value.slice(-1) === "/") {
                   el.closed = true;
                   value = value.slice(0, -1);
@@ -77531,12 +77932,12 @@ var require_sax = __commonJS({
                 }
                 if (s2 == S_ATTR_NOQUOT_VALUE) {
                   errorHandler.warning('attribute "' + value + '" missed quot(")!');
-                  addAttribute(attrName, value, start);
+                  addAttribute(attrName, value, start2);
                 } else {
                   if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
                     errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
                   }
-                  addAttribute(value, value, start);
+                  addAttribute(value, value, start2);
                 }
                 break;
               case S_EQ:
@@ -77550,17 +77951,17 @@ var require_sax = __commonJS({
             if (c2 <= " ") {
               switch (s2) {
                 case S_TAG:
-                  el.setTagName(source.slice(start, p2));
+                  el.setTagName(source.slice(start2, p2));
                   s2 = S_TAG_SPACE;
                   break;
                 case S_ATTR:
-                  attrName = source.slice(start, p2);
+                  attrName = source.slice(start2, p2);
                   s2 = S_ATTR_SPACE;
                   break;
                 case S_ATTR_NOQUOT_VALUE:
-                  var value = source.slice(start, p2);
+                  var value = source.slice(start2, p2);
                   errorHandler.warning('attribute "' + value + '" missed quot(")!!');
-                  addAttribute(attrName, value, start);
+                  addAttribute(attrName, value, start2);
                 case S_ATTR_END:
                   s2 = S_TAG_SPACE;
                   break;
@@ -77575,19 +77976,19 @@ var require_sax = __commonJS({
                   if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
                     errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
                   }
-                  addAttribute(attrName, attrName, start);
-                  start = p2;
+                  addAttribute(attrName, attrName, start2);
+                  start2 = p2;
                   s2 = S_ATTR;
                   break;
                 case S_ATTR_END:
                   errorHandler.warning('attribute space is required"' + attrName + '"!!');
                 case S_TAG_SPACE:
                   s2 = S_ATTR;
-                  start = p2;
+                  start2 = p2;
                   break;
                 case S_EQ:
                   s2 = S_ATTR_NOQUOT_VALUE;
-                  start = p2;
+                  start2 = p2;
                   break;
                 case S_TAG_CLOSE:
                   throw new Error("elements closed character '/' and '>' must be connected to");
@@ -77698,14 +78099,14 @@ var require_sax = __commonJS({
         }
       }
     }
-    function parseDCC(source, start, domBuilder, errorHandler) {
-      var next = source.charAt(start + 2);
+    function parseDCC(source, start2, domBuilder, errorHandler) {
+      var next = source.charAt(start2 + 2);
       switch (next) {
         case "-":
-          if (source.charAt(start + 3) === "-") {
-            var end = source.indexOf("-->", start + 4);
-            if (end > start) {
-              domBuilder.comment(source, start + 4, end - start - 4);
+          if (source.charAt(start2 + 3) === "-") {
+            var end = source.indexOf("-->", start2 + 4);
+            if (end > start2) {
+              domBuilder.comment(source, start2 + 4, end - start2 - 4);
               return end + 3;
             } else {
               errorHandler.error("Unclosed comment");
@@ -77715,14 +78116,14 @@ var require_sax = __commonJS({
             return -1;
           }
         default:
-          if (source.substr(start + 3, 6) == "CDATA[") {
-            var end = source.indexOf("]]>", start + 9);
+          if (source.substr(start2 + 3, 6) == "CDATA[") {
+            var end = source.indexOf("]]>", start2 + 9);
             domBuilder.startCDATA();
-            domBuilder.characters(source, start + 9, end - start - 9);
+            domBuilder.characters(source, start2 + 9, end - start2 - 9);
             domBuilder.endCDATA();
             return end + 3;
           }
-          var matchs = split(source, start);
+          var matchs = split(source, start2);
           var len = matchs.length;
           if (len > 1 && /!doctype/i.test(matchs[0][0])) {
             var name = matchs[1][0];
@@ -77744,10 +78145,10 @@ var require_sax = __commonJS({
       }
       return -1;
     }
-    function parseInstruction(source, start, domBuilder) {
-      var end = source.indexOf("?>", start);
+    function parseInstruction(source, start2, domBuilder) {
+      var end = source.indexOf("?>", start2);
       if (end) {
-        var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)$/);
+        var match = source.substring(start2, end).match(/^<\?(\S*)\s*([\s\S]*?)$/);
         if (match) {
           var len = match[0].length;
           domBuilder.processingInstruction(match[1], match[2]);
@@ -77802,11 +78203,11 @@ var require_sax = __commonJS({
       //	getType:function(uri,localName){}
       //	getType:function(i){},
     };
-    function split(source, start) {
+    function split(source, start2) {
       var match;
       var buf = [];
       var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
-      reg.lastIndex = start;
+      reg.lastIndex = start2;
       reg.exec(source);
       while (match = reg.exec(source)) {
         buf.push(match);
@@ -77937,9 +78338,9 @@ var require_dom_parser = __commonJS({
         this.locator && position(this.locator, ins);
         appendElement(this, ins);
       },
-      ignorableWhitespace: function(ch2, start, length) {
+      ignorableWhitespace: function(ch2, start2, length) {
       },
-      characters: function(chars, start, length) {
+      characters: function(chars, start2, length) {
         chars = _toString.apply(this, arguments);
         if (chars) {
           if (this.cdata) {
@@ -77966,7 +78367,7 @@ var require_dom_parser = __commonJS({
         }
       },
       //LexicalHandler
-      comment: function(chars, start, length) {
+      comment: function(chars, start2, length) {
         chars = _toString.apply(this, arguments);
         var comm = this.doc.createComment(chars);
         this.locator && position(this.locator, comm);
@@ -78006,12 +78407,12 @@ var require_dom_parser = __commonJS({
         return "\n@" + (l3.systemId || "") + "#[line:" + l3.lineNumber + ",col:" + l3.columnNumber + "]";
       }
     }
-    function _toString(chars, start, length) {
+    function _toString(chars, start2, length) {
       if (typeof chars == "string") {
-        return chars.substr(start, length);
+        return chars.substr(start2, length);
       } else {
-        if (chars.length >= start + length || start) {
-          return new java.lang.String(chars, start, length) + "";
+        if (chars.length >= start2 + length || start2) {
+          return new java.lang.String(chars, start2, length) + "";
         }
         return chars;
       }
@@ -81873,7 +82274,7 @@ var require_transforms = __commonJS({
   "../../node_modules/.pnpm/mammoth@1.13.0/node_modules/mammoth/lib/transforms.js"(exports2) {
     var _3 = require_underscore_node();
     exports2.paragraph = paragraph;
-    exports2.run = run5;
+    exports2.run = run3;
     exports2._elements = elements;
     exports2._elementsOfType = elementsOfType;
     exports2.getDescendantsOfType = getDescendantsOfType;
@@ -81881,7 +82282,7 @@ var require_transforms = __commonJS({
     function paragraph(transform) {
       return elementsOfType("paragraph", transform);
     }
-    function run5(transform) {
+    function run3(transform) {
       return elementsOfType("run", transform);
     }
     function elementsOfType(elementType, transform) {
@@ -83654,10 +84055,10 @@ var require_html_writer = __commonJS({
       var indentationLevel = 0;
       var indentation = "  ";
       var stack = [];
-      var start = true;
+      var start2 = true;
       var inText = false;
       var writer2 = simpleWriter();
-      function open(tagName, attributes) {
+      function open2(tagName, attributes) {
         if (indentedElements[tagName]) {
           indent();
         }
@@ -83666,7 +84067,7 @@ var require_html_writer = __commonJS({
         if (indentedElements[tagName]) {
           indentationLevel++;
         }
-        start = false;
+        start2 = false;
       }
       function close(tagName) {
         if (indentedElements[tagName]) {
@@ -83696,7 +84097,7 @@ var require_html_writer = __commonJS({
       }
       function indent() {
         inText = false;
-        if (!start && insideIndentedElement() && !isInPre()) {
+        if (!start2 && insideIndentedElement() && !isInPre()) {
           writer2._append("\n");
           for (var i3 = 0; i3 < indentationLevel; i3++) {
             writer2._append(indentation);
@@ -83710,7 +84111,7 @@ var require_html_writer = __commonJS({
       }
       return {
         asString: writer2.asString,
-        open,
+        open: open2,
         close,
         text,
         selfClosing
@@ -83718,7 +84119,7 @@ var require_html_writer = __commonJS({
     }
     function simpleWriter() {
       var fragments = [];
-      function open(tagName, attributes) {
+      function open2(tagName, attributes) {
         var attributeString = generateAttributeString(attributes);
         fragments.push("<" + tagName + attributeString + ">");
       }
@@ -83745,7 +84146,7 @@ var require_html_writer = __commonJS({
       }
       return {
         asString,
-        open,
+        open: open2,
         close,
         text,
         selfClosing,
@@ -83769,9 +84170,9 @@ var require_markdown_writer = __commonJS({
     function symmetricMarkdownElement(end) {
       return markdownElement(end, end);
     }
-    function markdownElement(start, end) {
+    function markdownElement(start2, end) {
       return function() {
-        return { start, end };
+        return { start: start2, end };
       };
     }
     function markdownLink(attributes) {
@@ -83813,9 +84214,9 @@ var require_markdown_writer = __commonJS({
       list.count++;
       listItem.hasClosed = false;
       var bullet = list.isOrdered ? list.count + "." : "-";
-      var start = repeatString("	", list.indent) + bullet + " ";
+      var start2 = repeatString("	", list.indent) + bullet + " ";
       return {
-        start,
+        start: start2,
         end: function() {
           if (!listItem.hasClosed) {
             listItem.hasClosed = true;
@@ -83848,7 +84249,7 @@ var require_markdown_writer = __commonJS({
       var elementStack = [];
       var list = null;
       var listItem = {};
-      function open(tagName, attributes) {
+      function open2(tagName, attributes) {
         attributes = attributes || {};
         var createElement = htmlToMarkdown[tagName] || function() {
           return {};
@@ -83882,7 +84283,7 @@ var require_markdown_writer = __commonJS({
         fragments.push(end || "");
       }
       function selfClosing(tagName, attributes) {
-        open(tagName, attributes);
+        open2(tagName, attributes);
         close(tagName);
       }
       function text(value) {
@@ -83893,7 +84294,7 @@ var require_markdown_writer = __commonJS({
       }
       return {
         asString,
-        open,
+        open: open2,
         close,
         text,
         selfClosing
@@ -84031,47 +84432,47 @@ var require_document_to_html = __commonJS({
           return defaultParagraphStyle;
         }
       }
-      function convertRun(run5, messages, context) {
+      function convertRun(run3, messages, context) {
         var nodes = function() {
-          return convertElements(run5.children, messages, context);
+          return convertElements(run3.children, messages, context);
         };
         var paths = [];
-        if (run5.highlight !== null) {
-          var path = findHtmlPath({ type: "highlight", color: run5.highlight });
+        if (run3.highlight !== null) {
+          var path = findHtmlPath({ type: "highlight", color: run3.highlight });
           if (path) {
             paths.push(path);
           }
         }
-        if (run5.isSmallCaps) {
+        if (run3.isSmallCaps) {
           paths.push(findHtmlPathForRunProperty("smallCaps"));
         }
-        if (run5.isAllCaps) {
+        if (run3.isAllCaps) {
           paths.push(findHtmlPathForRunProperty("allCaps"));
         }
-        if (run5.isStrikethrough) {
+        if (run3.isStrikethrough) {
           paths.push(findHtmlPathForRunProperty("strikethrough", "s"));
         }
-        if (run5.isUnderline) {
+        if (run3.isUnderline) {
           paths.push(findHtmlPathForRunProperty("underline"));
         }
-        if (run5.verticalAlignment === documents.verticalAlignment.subscript) {
+        if (run3.verticalAlignment === documents.verticalAlignment.subscript) {
           paths.push(htmlPaths.element("sub", {}, { fresh: false }));
         }
-        if (run5.verticalAlignment === documents.verticalAlignment.superscript) {
+        if (run3.verticalAlignment === documents.verticalAlignment.superscript) {
           paths.push(htmlPaths.element("sup", {}, { fresh: false }));
         }
-        if (run5.isItalic) {
+        if (run3.isItalic) {
           paths.push(findHtmlPathForRunProperty("italic", "em"));
         }
-        if (run5.isBold) {
+        if (run3.isBold) {
           paths.push(findHtmlPathForRunProperty("bold", "strong"));
         }
         var stylePath = htmlPaths.empty;
-        var style = findStyle(run5);
+        var style = findStyle(run3);
         if (style) {
           stylePath = style.to;
-        } else if (run5.styleId) {
-          messages.push(unrecognisedStyleWarning("run", run5));
+        } else if (run3.styleId) {
+          messages.push(unrecognisedStyleWarning("run", run3));
         }
         paths.push(stylePath);
         paths.forEach(function(path2) {
@@ -84381,9 +84782,9 @@ var require_TokenIterator = __commonJS({
       return this._tokens[this._tokens.length - 1];
     };
     TokenIterator.prototype.to = function(end) {
-      var start = this.head().source;
+      var start2 = this.head().source;
       var endToken = end.head() || end.end();
-      return start.to(endToken.source);
+      return start2.to(endToken.source);
     };
   }
 });
@@ -84912,7 +85313,7 @@ var require_rules = __commonJS({
       });
       var repeatedRule = exports2.firstOf.apply(null, ["rules"].concat(rights));
       return function(input) {
-        var start = input;
+        var start2 = input;
         var leftResult = leftRule(input);
         if (!leftResult.isSuccess()) {
           return leftResult;
@@ -84920,7 +85321,7 @@ var require_rules = __commonJS({
         var repeatedResult = repeatedRule(leftResult.remaining());
         while (repeatedResult.isSuccess()) {
           var remaining = repeatedResult.remaining();
-          var source = start.to(repeatedResult.remaining());
+          var source = start2.to(repeatedResult.remaining());
           var right = repeatedResult.value();
           leftResult = results.success(
             right(leftResult.value(), source),
@@ -85241,7 +85642,7 @@ var require_lop = __commonJS({
 var require_document_matchers = __commonJS({
   "../../node_modules/.pnpm/mammoth@1.13.0/node_modules/mammoth/lib/styles/document-matchers.js"(exports2) {
     exports2.paragraph = paragraph;
-    exports2.run = run5;
+    exports2.run = run3;
     exports2.table = table2;
     exports2.bold = new Matcher("bold");
     exports2.italic = new Matcher("italic");
@@ -85259,7 +85660,7 @@ var require_document_matchers = __commonJS({
     function paragraph(options) {
       return new Matcher("paragraph", options);
     }
-    function run5(options) {
+    function run3(options) {
       return new Matcher("run", options);
     }
     function table2(options) {
@@ -88765,8 +89166,8 @@ var require_dist2 = __commonJS({
       }
       return index;
     }
-    function trailingOWS(header, start, end) {
-      while (end > start) {
+    function trailingOWS(header, start2, end) {
+      while (end > start2) {
         const char = header.charCodeAt(end - 1);
         if (char !== SP && char !== HTAB)
           break;
@@ -89563,7 +89964,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
     return reader.read(buffer);
   }
   signal.throwIfAborted();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
@@ -89583,7 +89984,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
       try {
         const result = await reader.read(buffer);
         cleanup();
-        resolve6(result);
+        resolve7(result);
       } catch (error2) {
         cleanup();
         reject(error2);
@@ -97627,7 +98028,7 @@ var init_MP4Parser = __esm({
         }
         const chapters = [];
         for (let i3 = 0; i3 < chapterTrack.chunkOffsetTable.length && len > 0; ++i3) {
-          const start = chapterTrack.timeToSampleTable.slice(0, i3).reduce((acc, cur) => acc + cur.duration, 0);
+          const start2 = chapterTrack.timeToSampleTable.slice(0, i3).reduce((acc, cur) => acc + cur.duration, 0);
           const chunkOffset = chapterTrack.chunkOffsetTable[i3];
           const nextChunkLen = chunkOffset - this.tokenizer.position;
           const sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i3];
@@ -97641,7 +98042,7 @@ var init_MP4Parser = __esm({
           const chapter = {
             title,
             timeScale: chapterTrack.media.header ? chapterTrack.media.header.timeScale : 0,
-            start,
+            start: start2,
             sampleOffset: this.findSampleOffset(track, this.tokenizer.position)
           };
           debug17(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${track.header.duration}`);
@@ -100345,9 +100746,9 @@ var init_odt = __esm({
     ];
     dropSubtrees = (xml) => DROP_SUBTREE.reduce((text, tag) => text.replaceAll(new RegExp(`<${tag}\\b[^>]*?(?:/>|>[\\s\\S]*?</${tag}>)`, "g"), ""), xml);
     odfToHtml = (xml) => {
-      const start = xml.indexOf("<office:text");
+      const start2 = xml.indexOf("<office:text");
       const end = xml.lastIndexOf("</office:text>");
-      const body = dropSubtrees(start === -1 || end === -1 ? xml : xml.slice(start, end));
+      const body = dropSubtrees(start2 === -1 || end === -1 ? xml : xml.slice(start2, end));
       return body.replaceAll(/<text:h\b([^>]*)>([\s\S]*?)<\/text:h>/g, (_3, attributes, inner) => {
         const level = Math.min(6, Math.max(1, Number(attributeOf(attributes, "text:outline-level") ?? "1") || 1));
         return `<h${level}>${inner}</h${level}>`;
@@ -100474,15 +100875,15 @@ var init_pdf_furniture = __esm({
 });
 
 // ../fileq/src/lib/derivers/pdf.ts
-import { execFile as execFile2, spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { mkdtemp, readdir, readFile as readFile10, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join3 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var SCAN_THRESHOLD_CHARS_PER_PAGE, MAX_OCR_PAGES, OCR_DPI, OCR_TIMEOUT_MS, run3, checked, ocrAvailable, readPages, recognisePages, pagesToMarkdown, furnitureNotes, withoutFurniture, pdfDeriver;
+var SCAN_THRESHOLD_CHARS_PER_PAGE, MAX_OCR_PAGES, OCR_DPI, OCR_TIMEOUT_MS, checked, ocrAvailable, readPages, recognisePages, pagesToMarkdown, furnitureNotes, withoutFurniture, pdfDeriver;
 var init_pdf = __esm({
   "../fileq/src/lib/derivers/pdf.ts"() {
     "use strict";
+    init_process();
     init_dist2();
     init_tools();
     init_pdf_furniture();
@@ -100490,31 +100891,28 @@ var init_pdf = __esm({
     MAX_OCR_PAGES = 20;
     OCR_DPI = "200";
     OCR_TIMEOUT_MS = 6e4 + MAX_OCR_PAGES * 15e3;
-    run3 = promisify2(execFile2);
     checked = /* @__PURE__ */ new Map();
     ocrAvailable = () => {
       const path = process.env["PATH"] ?? "";
       let available = checked.get(path);
       if (available === void 0) {
-        available = onPath("pdftoppm") && onPath("ocr") && spawnSync("ocr", ["--check"], { stdio: "ignore", timeout: 1e4 }).status === 0;
+        available = onPath("pdftoppm") && onPath("ocr") && spawnSync2("ocr", ["--check"], { stdio: "ignore", timeout: 1e4 }).status === 0;
         checked.set(path, available);
       }
       return available;
     };
-    readPages = (images) => new Promise((resolve6, reject) => {
-      execFile2("ocr", [...images], { timeout: OCR_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 }, (error2, stdout) => {
-        if (error2 === null || error2.code === 1) {
-          resolve6(stdout);
-        } else {
-          reject(error2);
-        }
-      });
-    });
+    readPages = async (images) => {
+      const result = await runBounded("ocr", images, { timeoutMs: OCR_TIMEOUT_MS, maxOutput: 16 * 1024 * 1024 });
+      if (!result.timedOut && (result.exitCode === 0 || result.exitCode === 1)) {
+        return result.stdout.text;
+      }
+      throw new ProcessError("ocr", images, result);
+    };
     recognisePages = async (absPath, totalPages) => {
       const dir = await mkdtemp(join3(tmpdir(), "fileq-ocr-"));
       try {
-        await run3("pdftoppm", ["-r", OCR_DPI, "-png", "-f", "1", "-l", String(Math.min(totalPages, MAX_OCR_PAGES)), absPath, join3(dir, "page")], {
-          timeout: 12e4
+        await execBounded("pdftoppm", ["-r", OCR_DPI, "-png", "-f", "1", "-l", String(Math.min(totalPages, MAX_OCR_PAGES)), absPath, join3(dir, "page")], {
+          timeoutMs: 12e4
         });
         const images = (await readdir(dir)).filter((name) => name.endsWith(".png")).toSorted();
         if (images.length === 0) {
@@ -100588,7 +100986,7 @@ var init_pptx = __esm({
     SLIDE_PART = /^ppt\/slides\/slide(\d+)\.xml$/;
     NOTES_PART = /^ppt\/notesSlides\/notesSlide(\d+)\.xml$/;
     slideParagraphs = (xml) => [...xml.matchAll(/<a:p\b[\s\S]*?<\/a:p>/g)].map(
-      (paragraph) => [...paragraph[0].matchAll(/<a:t[^>]*>([\s\S]*?)<\/a:t>/g)].map((run5) => decodeEntities(run5[1] ?? "")).join("").trim()
+      (paragraph) => [...paragraph[0].matchAll(/<a:t[^>]*>([\s\S]*?)<\/a:t>/g)].map((run3) => decodeEntities(run3[1] ?? "")).join("").trim()
     ).filter((text) => text !== "");
     partsByNumber = (names, pattern) => {
       const map = /* @__PURE__ */ new Map();
@@ -102724,15 +103122,15 @@ var require_row = __commonJS({
         });
       }
       // remove cell(s) and shift all higher cells down by count
-      splice(start, count, ...inserts) {
-        const nKeep = start + count;
+      splice(start2, count, ...inserts) {
+        const nKeep = start2 + count;
         const nExpand = inserts.length - count;
         const nEnd = this._cells.length;
         let i3;
         let cSrc;
         let cDst;
         if (nExpand < 0) {
-          for (i3 = start + inserts.length; i3 <= nEnd; i3++) {
+          for (i3 = start2 + inserts.length; i3 <= nEnd; i3++) {
             cDst = this._cells[i3 - 1];
             cSrc = this._cells[i3 - nExpand - 1];
             if (cSrc) {
@@ -102760,7 +103158,7 @@ var require_row = __commonJS({
           }
         }
         for (i3 = 0; i3 < inserts.length; i3++) {
-          cDst = this.getCell(start + i3);
+          cDst = this.getCell(start2 + i3);
           cDst.value = inserts[i3];
           cDst.style = {};
           cDst._comment = void 0;
@@ -104101,12 +104499,12 @@ var require_worksheet = __commonJS({
         }
         return this._columns[c2 - 1];
       }
-      spliceColumns(start, count, ...inserts) {
+      spliceColumns(start2, count, ...inserts) {
         const rows = this._rows;
         const nRows = rows.length;
         if (inserts.length > 0) {
           for (let i3 = 0; i3 < nRows; i3++) {
-            const rowArguments = [start, count];
+            const rowArguments = [start2, count];
             inserts.forEach((insert) => {
               rowArguments.push(insert[i3] || null);
             });
@@ -104116,15 +104514,15 @@ var require_worksheet = __commonJS({
         } else {
           this._rows.forEach((r2) => {
             if (r2) {
-              r2.splice(start, count);
+              r2.splice(start2, count);
             }
           });
         }
         const nExpand = inserts.length - count;
-        const nKeep = start + count;
+        const nKeep = start2 + count;
         const nEnd = this._columns.length;
         if (nExpand < 0) {
-          for (let i3 = start + inserts.length; i3 <= nEnd; i3++) {
+          for (let i3 = start2 + inserts.length; i3 <= nEnd; i3++) {
             this.getColumn(i3).defn = this.getColumn(i3 - nExpand).defn;
           }
         } else if (nExpand > 0) {
@@ -104132,10 +104530,10 @@ var require_worksheet = __commonJS({
             this.getColumn(i3 + nExpand).defn = this.getColumn(i3).defn;
           }
         }
-        for (let i3 = start; i3 < start + inserts.length; i3++) {
+        for (let i3 = start2; i3 < start2 + inserts.length; i3++) {
           this.getColumn(i3).defn = null;
         }
-        this.workbook.definedNames.spliceColumns(this.name, start, count, inserts.length);
+        this.workbook.definedNames.spliceColumns(this.name, start2, count, inserts.length);
       }
       get lastColumn() {
         return this.getColumn(this.columnCount);
@@ -104186,8 +104584,8 @@ var require_worksheet = __commonJS({
         return this._rows[r2 - 1];
       }
       // find multiple rows (if exists) by row number
-      findRows(start, length) {
-        return this._rows.slice(start - 1, start - 1 + length);
+      findRows(start2, length) {
+        return this._rows.slice(start2 - 1, start2 - 1 + length);
       }
       get rowCount() {
         return this._lastRowNumber;
@@ -104208,10 +104606,10 @@ var require_worksheet = __commonJS({
         return row;
       }
       // get multiple rows by row number.
-      getRows(start, length) {
+      getRows(start2, length) {
         if (length < 1) return void 0;
         const rows = [];
-        for (let i3 = start; i3 < start + length; i3++) {
+        for (let i3 = start2; i3 < start2 + length; i3++) {
           rows.push(this.getRow(i3));
         }
         return rows;
@@ -104278,15 +104676,15 @@ var require_worksheet = __commonJS({
           });
         }
       }
-      spliceRows(start, count, ...inserts) {
-        const nKeep = start + count;
+      spliceRows(start2, count, ...inserts) {
+        const nKeep = start2 + count;
         const nInserts = inserts.length;
         const nExpand = nInserts - count;
         const nEnd = this._rows.length;
         let i3;
         let rSrc;
         if (nExpand < 0) {
-          if (start === nEnd) {
+          if (start2 === nEnd) {
             this._rows[nEnd - 1] = void 0;
           }
           for (i3 = nKeep; i3 <= nEnd; i3++) {
@@ -104327,11 +104725,11 @@ var require_worksheet = __commonJS({
           }
         }
         for (i3 = 0; i3 < nInserts; i3++) {
-          const rDst = this.getRow(start + i3);
+          const rDst = this.getRow(start2 + i3);
           rDst.style = {};
           rDst.values = inserts[i3];
         }
-        this.workbook.definedNames.spliceRows(this.name, start, count, nInserts);
+        this.workbook.definedNames.spliceRows(this.name, start2, count, nInserts);
       }
       // iterate over every row in the worksheet, including maybe empty rows
       eachRow(options, iteratee) {
@@ -104502,7 +104900,7 @@ var require_worksheet = __commonJS({
       // =========================================================================
       // Worksheet Protection
       protect(password, options) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           this.sheetProtection = {
             sheet: true
           };
@@ -104526,7 +104924,7 @@ var require_worksheet = __commonJS({
               delete this.sheetProtection.spinCount;
             }
           }
-          resolve6();
+          resolve7();
         });
       }
       unprotect() {
@@ -104767,17 +105165,17 @@ var require_cell_matrix = __commonJS({
         }
         return void 0;
       }
-      spliceRows(sheetName, start, numDelete, numInsert) {
+      spliceRows(sheetName, start2, numDelete, numInsert) {
         const sheet = this.sheets[sheetName];
         if (sheet) {
           const inserts = [];
           for (let i3 = 0; i3 < numInsert; i3++) {
             inserts.push([]);
           }
-          sheet.splice(start, numDelete, ...inserts);
+          sheet.splice(start2, numDelete, ...inserts);
         }
       }
-      spliceColumns(sheetName, start, numDelete, numInsert) {
+      spliceColumns(sheetName, start2, numDelete, numInsert) {
         const sheet = this.sheets[sheetName];
         if (sheet) {
           const inserts = [];
@@ -104785,7 +105183,7 @@ var require_cell_matrix = __commonJS({
             inserts.push(null);
           }
           _3.each(sheet, (row) => {
-            row.splice(start, numDelete, ...inserts);
+            row.splice(start2, numDelete, ...inserts);
           });
         }
       }
@@ -104925,15 +105323,15 @@ var require_defined_names = __commonJS({
           }
         });
       }
-      spliceRows(sheetName, start, numDelete, numInsert) {
+      spliceRows(sheetName, start2, numDelete, numInsert) {
         _3.each(this.matrixMap, (matrix) => {
-          matrix.spliceRows(sheetName, start, numDelete, numInsert);
+          matrix.spliceRows(sheetName, start2, numDelete, numInsert);
           this.normaliseMatrix(matrix, sheetName);
         });
       }
-      spliceColumns(sheetName, start, numDelete, numInsert) {
+      spliceColumns(sheetName, start2, numDelete, numInsert) {
         _3.each(this.matrixMap, (matrix) => {
-          matrix.spliceColumns(sheetName, start, numDelete, numInsert);
+          matrix.spliceColumns(sheetName, start2, numDelete, numInsert);
           this.normaliseMatrix(matrix, sheetName);
         });
       }
@@ -105019,8 +105417,8 @@ var require_buffer_list = __commonJS({
       Object.defineProperty(Constructor, "prototype", { writable: false });
       return Constructor;
     }
-    function _toPropertyKey(arg) {
-      var key = _toPrimitive(arg, "string");
+    function _toPropertyKey(arg2) {
+      var key = _toPrimitive(arg2, "string");
       return typeof key === "symbol" ? key : String(key);
     }
     function _toPrimitive(input, hint) {
@@ -105089,7 +105487,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join9(s2) {
+        value: function join10(s2) {
           if (this.length === 0) return "";
           var p2 = this.head;
           var ret2 = "" + p2.data;
@@ -105345,14 +105743,14 @@ var require_errors2 = __commonJS({
       }
       return str.substring(this_len - search.length, this_len) === search;
     }
-    function includes(str, search, start) {
-      if (typeof start !== "number") {
-        start = 0;
+    function includes(str, search, start2) {
+      if (typeof start2 !== "number") {
+        start2 = 0;
       }
-      if (start + search.length > str.length) {
+      if (start2 + search.length > str.length) {
         return false;
       } else {
-        return str.indexOf(search, start) !== -1;
+        return str.indexOf(search, start2) !== -1;
       }
     }
     createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
@@ -105388,8 +105786,8 @@ var require_errors2 = __commonJS({
     createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
     createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
     createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
-    createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
-      return "Unknown encoding: " + arg;
+    createErrorType("ERR_UNKNOWN_ENCODING", function(arg2) {
+      return "Unknown encoding: " + arg2;
     }, TypeError);
     createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
     module2.exports.codes = codes;
@@ -106001,16 +106399,16 @@ var require_safe_buffer2 = __commonJS({
       copyProps(buffer, exports2);
       exports2.Buffer = SafeBuffer;
     }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer2(arg, encodingOrOffset, length);
+    function SafeBuffer(arg2, encodingOrOffset, length) {
+      return Buffer2(arg2, encodingOrOffset, length);
     }
     SafeBuffer.prototype = Object.create(Buffer2.prototype);
     copyProps(Buffer2, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
+    SafeBuffer.from = function(arg2, encodingOrOffset, length) {
+      if (typeof arg2 === "number") {
         throw new TypeError("Argument must not be a number");
       }
-      return Buffer2(arg, encodingOrOffset, length);
+      return Buffer2(arg2, encodingOrOffset, length);
     };
     SafeBuffer.alloc = function(size, fill, encoding) {
       if (typeof size !== "number") {
@@ -106099,8 +106497,8 @@ var require_string_decoder2 = __commonJS({
       if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
       return nenc || enc;
     }
-    exports2.StringDecoder = StringDecoder;
-    function StringDecoder(encoding) {
+    exports2.StringDecoder = StringDecoder2;
+    function StringDecoder2(encoding) {
       this.encoding = normalizeEncoding(encoding);
       var nb;
       switch (this.encoding) {
@@ -106127,7 +106525,7 @@ var require_string_decoder2 = __commonJS({
       this.lastTotal = 0;
       this.lastChar = Buffer2.allocUnsafe(nb);
     }
-    StringDecoder.prototype.write = function(buf) {
+    StringDecoder2.prototype.write = function(buf) {
       if (buf.length === 0) return "";
       var r2;
       var i3;
@@ -106142,9 +106540,9 @@ var require_string_decoder2 = __commonJS({
       if (i3 < buf.length) return r2 ? r2 + this.text(buf, i3) : this.text(buf, i3);
       return r2 || "";
     };
-    StringDecoder.prototype.end = utf8End;
-    StringDecoder.prototype.text = utf8Text;
-    StringDecoder.prototype.fillLast = function(buf) {
+    StringDecoder2.prototype.end = utf8End;
+    StringDecoder2.prototype.text = utf8Text;
+    StringDecoder2.prototype.fillLast = function(buf) {
       if (this.lastNeed <= buf.length) {
         buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
         return this.lastChar.toString(this.encoding, 0, this.lastTotal);
@@ -106384,8 +106782,8 @@ var require_async_iterator = __commonJS({
       }
       return obj2;
     }
-    function _toPropertyKey(arg) {
-      var key = _toPrimitive(arg, "string");
+    function _toPropertyKey(arg2) {
+      var key = _toPrimitive(arg2, "string");
       return typeof key === "symbol" ? key : String(key);
     }
     function _toPrimitive(input, hint) {
@@ -106413,14 +106811,14 @@ var require_async_iterator = __commonJS({
       };
     }
     function readAndResolve(iter) {
-      var resolve6 = iter[kLastResolve];
-      if (resolve6 !== null) {
+      var resolve7 = iter[kLastResolve];
+      if (resolve7 !== null) {
         var data = iter[kStream].read();
         if (data !== null) {
           iter[kLastPromise] = null;
           iter[kLastResolve] = null;
           iter[kLastReject] = null;
-          resolve6(createIterResult(data, false));
+          resolve7(createIterResult(data, false));
         }
       }
     }
@@ -106428,13 +106826,13 @@ var require_async_iterator = __commonJS({
       process.nextTick(readAndResolve, iter);
     }
     function wrapForNext(lastPromise, iter) {
-      return function(resolve6, reject) {
+      return function(resolve7, reject) {
         lastPromise.then(function() {
           if (iter[kEnded]) {
-            resolve6(createIterResult(void 0, true));
+            resolve7(createIterResult(void 0, true));
             return;
           }
-          iter[kHandlePromise](resolve6, reject);
+          iter[kHandlePromise](resolve7, reject);
         }, reject);
       };
     }
@@ -106454,12 +106852,12 @@ var require_async_iterator = __commonJS({
           return Promise.resolve(createIterResult(void 0, true));
         }
         if (this[kStream].destroyed) {
-          return new Promise(function(resolve6, reject) {
+          return new Promise(function(resolve7, reject) {
             process.nextTick(function() {
               if (_this[kError]) {
                 reject(_this[kError]);
               } else {
-                resolve6(createIterResult(void 0, true));
+                resolve7(createIterResult(void 0, true));
               }
             });
           });
@@ -106482,13 +106880,13 @@ var require_async_iterator = __commonJS({
       return this;
     }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
       var _this2 = this;
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         _this2[kStream].destroy(null, function(err2) {
           if (err2) {
             reject(err2);
             return;
           }
-          resolve6(createIterResult(void 0, true));
+          resolve7(createIterResult(void 0, true));
         });
       });
     }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -106510,15 +106908,15 @@ var require_async_iterator = __commonJS({
         value: stream._readableState.endEmitted,
         writable: true
       }), _defineProperty(_Object$create, kHandlePromise, {
-        value: function value(resolve6, reject) {
+        value: function value(resolve7, reject) {
           var data = iterator[kStream].read();
           if (data) {
             iterator[kLastPromise] = null;
             iterator[kLastResolve] = null;
             iterator[kLastReject] = null;
-            resolve6(createIterResult(data, false));
+            resolve7(createIterResult(data, false));
           } else {
-            iterator[kLastResolve] = resolve6;
+            iterator[kLastResolve] = resolve7;
             iterator[kLastReject] = reject;
           }
         },
@@ -106537,12 +106935,12 @@ var require_async_iterator = __commonJS({
           iterator[kError] = err2;
           return;
         }
-        var resolve6 = iterator[kLastResolve];
-        if (resolve6 !== null) {
+        var resolve7 = iterator[kLastResolve];
+        if (resolve7 !== null) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve6(createIterResult(void 0, true));
+          resolve7(createIterResult(void 0, true));
         }
         iterator[kEnded] = true;
       });
@@ -106557,16 +106955,16 @@ var require_async_iterator = __commonJS({
 var require_from = __commonJS({
   "../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/from.js"(exports2, module2) {
     "use strict";
-    function asyncGeneratorStep(gen, resolve6, reject, _next, _throw, key, arg) {
+    function asyncGeneratorStep(gen, resolve7, reject, _next, _throw, key, arg2) {
       try {
-        var info2 = gen[key](arg);
+        var info2 = gen[key](arg2);
         var value = info2.value;
       } catch (error2) {
         reject(error2);
         return;
       }
       if (info2.done) {
-        resolve6(value);
+        resolve7(value);
       } else {
         Promise.resolve(value).then(_next, _throw);
       }
@@ -106574,13 +106972,13 @@ var require_from = __commonJS({
     function _asyncToGenerator(fn2) {
       return function() {
         var self2 = this, args = arguments;
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var gen = fn2.apply(self2, args);
           function _next(value) {
-            asyncGeneratorStep(gen, resolve6, reject, _next, _throw, "next", value);
+            asyncGeneratorStep(gen, resolve7, reject, _next, _throw, "next", value);
           }
           function _throw(err2) {
-            asyncGeneratorStep(gen, resolve6, reject, _next, _throw, "throw", err2);
+            asyncGeneratorStep(gen, resolve7, reject, _next, _throw, "throw", err2);
           }
           _next(void 0);
         });
@@ -106616,8 +107014,8 @@ var require_from = __commonJS({
       }
       return obj2;
     }
-    function _toPropertyKey(arg) {
-      var key = _toPrimitive(arg, "string");
+    function _toPropertyKey(arg2) {
+      var key = _toPrimitive(arg2, "string");
       return typeof key === "symbol" ? key : String(key);
     }
     function _toPrimitive(input, hint) {
@@ -106712,7 +107110,7 @@ var require_stream_readable2 = __commonJS({
     var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
     var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
     var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
-    var StringDecoder;
+    var StringDecoder2;
     var createReadableStreamAsyncIterator;
     var from;
     require_inherits()(Readable, Stream2);
@@ -106754,8 +107152,8 @@ var require_stream_readable2 = __commonJS({
       this.decoder = null;
       this.encoding = null;
       if (options.encoding) {
-        if (!StringDecoder) StringDecoder = require_string_decoder2().StringDecoder;
-        this.decoder = new StringDecoder(options.encoding);
+        if (!StringDecoder2) StringDecoder2 = require_string_decoder2().StringDecoder;
+        this.decoder = new StringDecoder2(options.encoding);
         this.encoding = options.encoding;
       }
     }
@@ -106876,8 +107274,8 @@ var require_stream_readable2 = __commonJS({
       return this._readableState.flowing === false;
     };
     Readable.prototype.setEncoding = function(enc) {
-      if (!StringDecoder) StringDecoder = require_string_decoder2().StringDecoder;
-      var decoder5 = new StringDecoder(enc);
+      if (!StringDecoder2) StringDecoder2 = require_string_decoder2().StringDecoder;
+      var decoder5 = new StringDecoder2(enc);
       this._readableState.decoder = decoder5;
       this._readableState.encoding = this._readableState.decoder.encoding;
       var p2 = this._readableState.buffer.head;
@@ -107667,14 +108065,14 @@ var require_utils2 = __commonJS({
       nop() {
       },
       promiseImmediate(value) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           if (global.setImmediate) {
             setImmediate(() => {
-              resolve6(value);
+              resolve7(value);
             });
           } else {
             setTimeout(() => {
-              resolve6(value);
+              resolve7(value);
             }, 1);
           }
         });
@@ -107774,9 +108172,9 @@ var require_utils2 = __commonJS({
       },
       fs: {
         exists(path) {
-          return new Promise((resolve6) => {
+          return new Promise((resolve7) => {
             fs2.access(path, fs2.constants.F_OK, (err2) => {
-              resolve6(!err2);
+              resolve7(!err2);
             });
           });
         }
@@ -107999,9 +108397,9 @@ var require_stream_buf = __commonJS({
       },
       async _pipe(chunk) {
         const write3 = function(pipe) {
-          return new Promise((resolve6) => {
+          return new Promise((resolve7) => {
             pipe.write(chunk.toBuffer(), () => {
-              resolve6();
+              resolve7();
             });
           });
         };
@@ -108413,14 +108811,14 @@ var require_ed5 = __commonJS({
     var TAB = 9;
     var NL = 10;
     var CR = 13;
-    var SPACE = 32;
-    exports2.S_LIST = [SPACE, NL, CR, TAB];
+    var SPACE2 = 32;
+    exports2.S_LIST = [SPACE2, NL, CR, TAB];
     function isChar(c2) {
-      return c2 >= SPACE && c2 <= 55295 || c2 === NL || c2 === CR || c2 === TAB || c2 >= 57344 && c2 <= 65533 || c2 >= 65536 && c2 <= 1114111;
+      return c2 >= SPACE2 && c2 <= 55295 || c2 === NL || c2 === CR || c2 === TAB || c2 >= 57344 && c2 <= 65533 || c2 >= 65536 && c2 <= 1114111;
     }
     exports2.isChar = isChar;
     function isS(c2) {
-      return c2 === SPACE || c2 === NL || c2 === CR || c2 === TAB;
+      return c2 === SPACE2 || c2 === NL || c2 === CR || c2 === TAB;
     }
     exports2.isS = isS;
     function isNameStartChar(c2) {
@@ -108454,8 +108852,8 @@ var require_ed2 = __commonJS({
     var TAB = 9;
     var NL = 10;
     var CR = 13;
-    var SPACE = 32;
-    exports2.S_LIST = [SPACE, NL, CR, TAB];
+    var SPACE2 = 32;
+    exports2.S_LIST = [SPACE2, NL, CR, TAB];
     function isChar(c2) {
       return c2 >= 1 && c2 <= 55295 || c2 >= 57344 && c2 <= 65533 || c2 >= 65536 && c2 <= 1114111;
     }
@@ -108469,7 +108867,7 @@ var require_ed2 = __commonJS({
     }
     exports2.isCharAndNotRestricted = isCharAndNotRestricted;
     function isS(c2) {
-      return c2 === SPACE || c2 === NL || c2 === CR || c2 === TAB;
+      return c2 === SPACE2 || c2 === NL || c2 === CR || c2 === TAB;
     }
     exports2.isS = isS;
     function isNameStartChar(c2) {
@@ -108589,7 +108987,7 @@ var require_saxes = __commonJS({
     var TAB = 9;
     var NL = 10;
     var CR = 13;
-    var SPACE = 32;
+    var SPACE2 = 32;
     var BANG = 33;
     var DQUOTE = 34;
     var AMP = 38;
@@ -108969,7 +109367,7 @@ var require_saxes = __commonJS({
         const code = chunk.charCodeAt(i3);
         this.column++;
         if (code < 55296) {
-          if (code >= SPACE || code === TAB) {
+          if (code >= SPACE2 || code === TAB) {
             return code;
           }
           switch (code) {
@@ -109087,20 +109485,20 @@ var require_saxes = __commonJS({
        * instead.
        */
       captureTo(chars) {
-        let { i: start } = this;
+        let { i: start2 } = this;
         const { chunk } = this;
         while (true) {
           const c2 = this.getCode();
           const isNLLike = c2 === NL_LIKE;
           const final = isNLLike ? NL : c2;
           if (final === EOC || chars.includes(final)) {
-            this.text += chunk.slice(start, this.prevI);
+            this.text += chunk.slice(start2, this.prevI);
             return final;
           }
           if (isNLLike) {
-            this.text += `${chunk.slice(start, this.prevI)}
+            this.text += `${chunk.slice(start2, this.prevI)}
 `;
-            start = this.i;
+            start2 = this.i;
           }
         }
       }
@@ -109114,24 +109512,24 @@ var require_saxes = __commonJS({
        * end of the current chunk.
        */
       captureToChar(char) {
-        let { i: start } = this;
+        let { i: start2 } = this;
         const { chunk } = this;
         while (true) {
           let c2 = this.getCode();
           switch (c2) {
             case NL_LIKE:
-              this.text += `${chunk.slice(start, this.prevI)}
+              this.text += `${chunk.slice(start2, this.prevI)}
 `;
-              start = this.i;
+              start2 = this.i;
               c2 = NL;
               break;
             case EOC:
-              this.text += chunk.slice(start);
+              this.text += chunk.slice(start2);
               return false;
             default:
           }
           if (c2 === char) {
-            this.text += chunk.slice(start, this.prevI);
+            this.text += chunk.slice(start2, this.prevI);
             return true;
           }
         }
@@ -109145,15 +109543,15 @@ var require_saxes = __commonJS({
        * instead.
        */
       captureNameChars() {
-        const { chunk, i: start } = this;
+        const { chunk, i: start2 } = this;
         while (true) {
           const c2 = this.getCode();
           if (c2 === EOC) {
-            this.name += chunk.slice(start);
+            this.name += chunk.slice(start2);
             return EOC;
           }
           if (!isNameChar(c2)) {
-            this.name += chunk.slice(start, this.prevI);
+            this.name += chunk.slice(start2, this.prevI);
             return c2 === NL_LIKE ? NL : c2;
           }
         }
@@ -109334,19 +109732,19 @@ var require_saxes = __commonJS({
         }
       }
       sEntity() {
-        let { i: start } = this;
+        let { i: start2 } = this;
         const { chunk } = this;
         loop:
           while (true) {
             switch (this.getCode()) {
               case NL_LIKE:
-                this.entity += `${chunk.slice(start, this.prevI)}
+                this.entity += `${chunk.slice(start2, this.prevI)}
 `;
-                start = this.i;
+                start2 = this.i;
                 break;
               case SEMICOLON: {
                 const { entityReturnState } = this;
-                const entity = this.entity + chunk.slice(start, this.prevI);
+                const entity = this.entity + chunk.slice(start2, this.prevI);
                 this.state = entityReturnState;
                 let parsed;
                 if (entity === "") {
@@ -109362,7 +109760,7 @@ var require_saxes = __commonJS({
                 break loop;
               }
               case EOC:
-                this.entity += chunk.slice(start);
+                this.entity += chunk.slice(start2);
                 break loop;
               default:
             }
@@ -109503,15 +109901,15 @@ var require_saxes = __commonJS({
         }
       }
       sPIRest() {
-        const { chunk, i: start } = this;
+        const { chunk, i: start2 } = this;
         while (true) {
           const c2 = this.getCodeNorm();
           if (c2 === EOC) {
-            this.piTarget += chunk.slice(start);
+            this.piTarget += chunk.slice(start2);
             return;
           }
           if (!this.nameCheck(c2)) {
-            this.piTarget += chunk.slice(start, this.prevI);
+            this.piTarget += chunk.slice(start2, this.prevI);
             const isQuestion = c2 === QUESTION;
             if (isQuestion || isS(c2)) {
               if (this.piTarget === "xml") {
@@ -109630,7 +110028,7 @@ var require_saxes = __commonJS({
         }
         if (!isQuote(c2)) {
           this.fail("value must be quoted.");
-          this.q = SPACE;
+          this.q = SPACE2;
         } else {
           this.q = c2;
         }
@@ -109818,32 +110216,32 @@ var require_saxes = __commonJS({
       }
       sAttribValueQuoted() {
         const { q: q2, chunk } = this;
-        let { i: start } = this;
+        let { i: start2 } = this;
         while (true) {
           switch (this.getCode()) {
             case q2:
-              this.pushAttrib(this.name, this.text + chunk.slice(start, this.prevI));
+              this.pushAttrib(this.name, this.text + chunk.slice(start2, this.prevI));
               this.name = this.text = "";
               this.q = null;
               this.state = S_ATTRIB_VALUE_CLOSED;
               return;
             case AMP:
-              this.text += chunk.slice(start, this.prevI);
+              this.text += chunk.slice(start2, this.prevI);
               this.state = S_ENTITY;
               this.entityReturnState = S_ATTRIB_VALUE_QUOTED;
               return;
             case NL:
             case NL_LIKE:
             case TAB:
-              this.text += `${chunk.slice(start, this.prevI)} `;
-              start = this.i;
+              this.text += `${chunk.slice(start2, this.prevI)} `;
+              start2 = this.i;
               break;
             case LESS:
-              this.text += chunk.slice(start, this.prevI);
+              this.text += chunk.slice(start2, this.prevI);
               this.fail("disallowed character.");
               return;
             case EOC:
-              this.text += chunk.slice(start);
+              this.text += chunk.slice(start2);
               return;
             default:
           }
@@ -109913,7 +110311,7 @@ var require_saxes = __commonJS({
       }
       // END OF STATE ENGINE METHODS
       handleTextInRoot() {
-        let { i: start, forbiddenState } = this;
+        let { i: start2, forbiddenState } = this;
         const { chunk, textHandler: handler } = this;
         scanLoop:
           while (true) {
@@ -109922,7 +110320,7 @@ var require_saxes = __commonJS({
                 this.state = S_OPEN_WAKA;
                 if (handler !== void 0) {
                   const { text } = this;
-                  const slice = chunk.slice(start, this.prevI);
+                  const slice = chunk.slice(start2, this.prevI);
                   if (text.length !== 0) {
                     handler(text + slice);
                     this.text = "";
@@ -109937,7 +110335,7 @@ var require_saxes = __commonJS({
                 this.state = S_ENTITY;
                 this.entityReturnState = S_TEXT;
                 if (handler !== void 0) {
-                  this.text += chunk.slice(start, this.prevI);
+                  this.text += chunk.slice(start2, this.prevI);
                 }
                 forbiddenState = FORBIDDEN_START;
                 break scanLoop;
@@ -109963,15 +110361,15 @@ var require_saxes = __commonJS({
                 break;
               case NL_LIKE:
                 if (handler !== void 0) {
-                  this.text += `${chunk.slice(start, this.prevI)}
+                  this.text += `${chunk.slice(start2, this.prevI)}
 `;
                 }
-                start = this.i;
+                start2 = this.i;
                 forbiddenState = FORBIDDEN_START;
                 break;
               case EOC:
                 if (handler !== void 0) {
-                  this.text += chunk.slice(start);
+                  this.text += chunk.slice(start2);
                 }
                 break scanLoop;
               default:
@@ -109981,7 +110379,7 @@ var require_saxes = __commonJS({
         this.forbiddenState = forbiddenState;
       }
       handleTextOutsideRoot() {
-        let { i: start } = this;
+        let { i: start2 } = this;
         const { chunk, textHandler: handler } = this;
         let nonSpace = false;
         outRootLoop:
@@ -109992,7 +110390,7 @@ var require_saxes = __commonJS({
                 this.state = S_OPEN_WAKA;
                 if (handler !== void 0) {
                   const { text } = this;
-                  const slice = chunk.slice(start, this.prevI);
+                  const slice = chunk.slice(start2, this.prevI);
                   if (text.length !== 0) {
                     handler(text + slice);
                     this.text = "";
@@ -110006,20 +110404,20 @@ var require_saxes = __commonJS({
                 this.state = S_ENTITY;
                 this.entityReturnState = S_TEXT;
                 if (handler !== void 0) {
-                  this.text += chunk.slice(start, this.prevI);
+                  this.text += chunk.slice(start2, this.prevI);
                 }
                 nonSpace = true;
                 break outRootLoop;
               case NL_LIKE:
                 if (handler !== void 0) {
-                  this.text += `${chunk.slice(start, this.prevI)}
+                  this.text += `${chunk.slice(start2, this.prevI)}
 `;
                 }
-                start = this.i;
+                start2 = this.i;
                 break;
               case EOC:
                 if (handler !== void 0) {
-                  this.text += chunk.slice(start);
+                  this.text += chunk.slice(start2);
                 }
                 break outRootLoop;
               default:
@@ -120036,12 +120434,12 @@ var require_xlsx = __commonJS({
     var VmlNotesXform = require_vml_notes_xform();
     var theme1Xml = require_theme1();
     function fsReadFileAsync(filename, options) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         fs2.readFile(filename, options, (error2, data) => {
           if (error2) {
             reject(error2);
           } else {
-            resolve6(data);
+            resolve7(data);
           }
         });
       });
@@ -120168,7 +120566,7 @@ var require_xlsx = __commonJS({
         if (lastDot >= 1) {
           const extension = filename.substr(lastDot + 1);
           const name = filename.substr(0, lastDot);
-          await new Promise((resolve6, reject) => {
+          await new Promise((resolve7, reject) => {
             const streamBuf = new StreamBuf();
             streamBuf.on("finish", () => {
               model.mediaIndex[filename] = model.media.length;
@@ -120180,7 +120578,7 @@ var require_xlsx = __commonJS({
                 buffer: streamBuf.toBuffer()
               };
               model.media.push(medium);
-              resolve6();
+              resolve7();
             });
             entry.on("error", (error2) => {
               reject(error2);
@@ -120205,13 +120603,13 @@ var require_xlsx = __commonJS({
         model.vmlDrawings[`../drawings/${name}.vml`] = vmlDrawing;
       }
       async _processThemeEntry(entry, model, name) {
-        await new Promise((resolve6, reject) => {
+        await new Promise((resolve7, reject) => {
           const stream = new StreamBuf();
           entry.on("error", reject);
           stream.on("error", reject);
           stream.on("finish", () => {
             model.themes[name] = stream.read().toString();
-            resolve6();
+            resolve7();
           });
           entry.pipe(stream);
         });
@@ -120519,9 +120917,9 @@ var require_xlsx = __commonJS({
         });
       }
       _finalize(zip) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           zip.on("finish", () => {
-            resolve6(this);
+            resolve7(this);
           });
           zip.on("error", reject);
           zip.finalize();
@@ -120581,9 +120979,9 @@ var require_xlsx = __commonJS({
       }
       writeFile(filename, options) {
         const stream = fs2.createWriteStream(filename);
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           stream.on("finish", () => {
-            resolve6();
+            resolve7();
           });
           stream.on("error", (error2) => {
             reject(error2);
@@ -120817,8 +121215,8 @@ var require_lodash2 = __commonJS({
       return result;
     }
     function overArg(func, transform) {
-      return function(arg) {
-        return func(transform(arg));
+      return function(arg2) {
+        return func(transform(arg2));
       };
     }
     function setToArray(set) {
@@ -121467,11 +121865,11 @@ var require_lodash5 = __commonJS({
     function toString(value) {
       return value == null ? "" : baseToString(value);
     }
-    function escapeRegExp(string) {
+    function escapeRegExp2(string) {
       string = toString(string);
       return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
     }
-    module2.exports = escapeRegExp;
+    module2.exports = escapeRegExp2;
   }
 });
 
@@ -122487,8 +122885,8 @@ var require_lodash8 = __commonJS({
       return result;
     }
     function overArg(func, transform) {
-      return function(arg) {
-        return func(transform(arg));
+      return function(arg2) {
+        return func(transform(arg2));
       };
     }
     function setToArray(set) {
@@ -124708,7 +125106,7 @@ var require_csv = __commonJS({
       }
       read(stream, options) {
         options = options || {};
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           const worksheet = this.workbook.addWorksheet(options.sheetName);
           const dateFormats = options.dateFormats || [
             "YYYY-MM-DD[T]HH:mm:ssZ",
@@ -124748,7 +125146,7 @@ var require_csv = __commonJS({
           }).on("end", () => {
             csvStream.emit("worksheet", worksheet);
           });
-          csvStream.on("worksheet", resolve6).on("error", reject);
+          csvStream.on("worksheet", resolve7).on("error", reject);
           stream.pipe(csvStream);
         });
       }
@@ -124761,12 +125159,12 @@ var require_csv = __commonJS({
         );
       }
       write(stream, options) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           options = options || {};
           const worksheet = this.workbook.getWorksheet(options.sheetName || options.sheetId);
           const csvStream = fastCsv.format(options.formatterOptions);
           stream.on("finish", () => {
-            resolve6();
+            resolve7();
           });
           csvStream.on("error", reject);
           csvStream.pipe(stream);
@@ -126005,9 +126403,9 @@ var require_readdir_glob = __commonJS({
     var fs2 = __require("fs");
     var { EventEmitter } = __require("events");
     var { Minimatch } = require_minimatch();
-    var { resolve: resolve6 } = __require("path");
+    var { resolve: resolve7 } = __require("path");
     function readdir3(dir, strict) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         fs2.readdir(dir, { withFileTypes: true }, (err2, files) => {
           if (err2) {
             switch (err2.code) {
@@ -126015,7 +126413,7 @@ var require_readdir_glob = __commonJS({
                 if (strict) {
                   reject(err2);
                 } else {
-                  resolve7([]);
+                  resolve8([]);
                 }
                 break;
               case "ENOTSUP":
@@ -126025,7 +126423,7 @@ var require_readdir_glob = __commonJS({
               case "ENAMETOOLONG":
               // Filename too long
               case "UNKNOWN":
-                resolve7([]);
+                resolve8([]);
                 break;
               case "ELOOP":
               // Too many levels of symbolic links
@@ -126034,30 +126432,30 @@ var require_readdir_glob = __commonJS({
                 break;
             }
           } else {
-            resolve7(files);
+            resolve8(files);
           }
         });
       });
     }
     function stat3(file, followSymlinks) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         const statFunc = followSymlinks ? fs2.stat : fs2.lstat;
         statFunc(file, (err2, stats) => {
           if (err2) {
             switch (err2.code) {
               case "ENOENT":
                 if (followSymlinks) {
-                  resolve7(stat3(file, false));
+                  resolve8(stat3(file, false));
                 } else {
-                  resolve7(null);
+                  resolve8(null);
                 }
                 break;
               default:
-                resolve7(null);
+                resolve8(null);
                 break;
             }
           } else {
-            resolve7(stats);
+            resolve8(stats);
           }
         });
       });
@@ -126147,7 +126545,7 @@ var require_readdir_glob = __commonJS({
             (skip) => new Minimatch(skip, { dot: true })
           );
         }
-        this.iterator = explore(resolve6(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+        this.iterator = explore(resolve7(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
         this.paused = false;
         this.inactive = false;
         this.aborted = false;
@@ -126314,10 +126712,10 @@ var require_async = __commonJS({
           if (typeof args[arity - 1] === "function") {
             return asyncFn.apply(this, args);
           }
-          return new Promise((resolve6, reject2) => {
+          return new Promise((resolve7, reject2) => {
             args[arity - 1] = (err2, ...cbArgs) => {
               if (err2) return reject2(err2);
-              resolve6(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+              resolve7(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
             };
             asyncFn.apply(this, args);
           });
@@ -126563,13 +126961,13 @@ var require_async = __commonJS({
       var applyEachSeries = applyEach$1(mapSeries$1);
       const PROMISE_SYMBOL = /* @__PURE__ */ Symbol("promiseCallback");
       function promiseCallback() {
-        let resolve6, reject2;
+        let resolve7, reject2;
         function callback(err2, ...args) {
           if (err2) return reject2(err2);
-          resolve6(args.length > 1 ? args : args[0]);
+          resolve7(args.length > 1 ? args : args[0]);
         }
         callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
-          resolve6 = res, reject2 = rej;
+          resolve7 = res, reject2 = rej;
         });
         return callback;
       }
@@ -126632,8 +127030,8 @@ var require_async = __commonJS({
             return callback(null, results);
           }
           while (readyTasks.length && runningTasks < concurrency) {
-            var run5 = readyTasks.shift();
-            run5();
+            var run3 = readyTasks.shift();
+            run3();
           }
         }
         function addListener(taskName, fn2) {
@@ -126748,7 +127146,7 @@ var require_async = __commonJS({
         }
         if (!match) throw new Error("could not parse args in autoInject\nSource:\n" + src);
         let [, args] = match;
-        return args.replace(/\s/g, "").split(FN_ARG_SPLIT).map((arg) => arg.replace(FN_ARG, "").trim());
+        return args.replace(/\s/g, "").split(FN_ARG_SPLIT).map((arg2) => arg2.replace(FN_ARG, "").trim());
       }
       function autoInject(tasks, callback) {
         var newTasks = {};
@@ -126916,8 +127314,8 @@ var require_async = __commonJS({
             });
           }
           if (rejectOnError || !callback) {
-            return new Promise((resolve6, reject2) => {
-              res = resolve6;
+            return new Promise((resolve7, reject2) => {
+              res = resolve7;
               rej = reject2;
             });
           }
@@ -126956,10 +127354,10 @@ var require_async = __commonJS({
         }
         const eventMethod = (name) => (handler) => {
           if (!handler) {
-            return new Promise((resolve6, reject2) => {
+            return new Promise((resolve7, reject2) => {
               once2(name, (err2, data) => {
                 if (err2) return reject2(err2);
-                resolve6(data);
+                resolve7(data);
               });
             });
           }
@@ -128148,10 +128546,10 @@ var require_polyfills = __commonJS({
       if (platform === "win32") {
         fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : (function(fs$rename) {
           function rename2(from, to2, cb) {
-            var start = Date.now();
+            var start2 = Date.now();
             var backoff = 0;
             fs$rename(from, to2, function CB(er2) {
-              if (er2 && (er2.code === "EACCES" || er2.code === "EPERM" || er2.code === "EBUSY") && Date.now() - start < 6e4) {
+              if (er2 && (er2.code === "EACCES" || er2.code === "EPERM" || er2.code === "EBUSY") && Date.now() - start2 < 6e4) {
                 setTimeout(function() {
                   fs2.stat(to2, function(stater, st2) {
                     if (stater && stater.code === "ENOENT")
@@ -128749,7 +129147,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open(that.path, that.flags, that.mode, function(err2, fd2) {
+        open2(that.path, that.flags, that.mode, function(err2, fd2) {
           if (err2) {
             if (that.autoClose)
               that.destroy();
@@ -128769,7 +129167,7 @@ var require_graceful_fs = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open(that.path, that.flags, that.mode, function(err2, fd2) {
+        open2(that.path, that.flags, that.mode, function(err2, fd2) {
           if (err2) {
             that.destroy();
             that.emit("error", err2);
@@ -128786,8 +129184,8 @@ var require_graceful_fs = __commonJS({
         return new fs3.WriteStream(path, options);
       }
       var fs$open = fs3.open;
-      fs3.open = open;
-      function open(path, flags, mode, cb) {
+      fs3.open = open2;
+      function open2(path, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path, flags, mode, cb);
@@ -129003,19 +129401,19 @@ var require_lodash9 = __commonJS({
       }
       return result;
     }
-    function baseRest(func, start) {
-      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+    function baseRest(func, start2) {
+      start2 = nativeMax(start2 === void 0 ? func.length - 1 : start2, 0);
       return function() {
-        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+        var args = arguments, index = -1, length = nativeMax(args.length - start2, 0), array = Array(length);
         while (++index < length) {
-          array[index] = args[start + index];
+          array[index] = args[start2 + index];
         }
         index = -1;
-        var otherArgs = Array(start + 1);
-        while (++index < start) {
+        var otherArgs = Array(start2 + 1);
+        while (++index < start2) {
           otherArgs[index] = args[index];
         }
-        otherArgs[start] = array;
+        otherArgs[start2] = array;
         return apply(func, this, otherArgs);
       };
     }
@@ -129509,19 +129907,19 @@ var require_lodash11 = __commonJS({
       var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
       return pattern.test(toSource(value));
     }
-    function baseRest(func, start) {
-      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+    function baseRest(func, start2) {
+      start2 = nativeMax(start2 === void 0 ? func.length - 1 : start2, 0);
       return function() {
-        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+        var args = arguments, index = -1, length = nativeMax(args.length - start2, 0), array = Array(length);
         while (++index < length) {
-          array[index] = args[start + index];
+          array[index] = args[start2 + index];
         }
         index = -1;
-        var otherArgs = Array(start + 1);
-        while (++index < start) {
+        var otherArgs = Array(start2 + 1);
+        while (++index < start2) {
           otherArgs[index] = args[index];
         }
-        otherArgs[start] = array;
+        otherArgs[start2] = array;
         return apply(func, this, otherArgs);
       };
     }
@@ -129871,19 +130269,19 @@ var require_lodash12 = __commonJS({
       var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
       return pattern.test(toSource(value));
     }
-    function baseRest(func, start) {
-      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+    function baseRest(func, start2) {
+      start2 = nativeMax(start2 === void 0 ? func.length - 1 : start2, 0);
       return function() {
-        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+        var args = arguments, index = -1, length = nativeMax(args.length - start2, 0), array = Array(length);
         while (++index < length) {
-          array[index] = args[start + index];
+          array[index] = args[start2 + index];
         }
         index = -1;
-        var otherArgs = Array(start + 1);
-        while (++index < start) {
+        var otherArgs = Array(start2 + 1);
+        while (++index < start2) {
           otherArgs[index] = args[index];
         }
-        otherArgs[start] = array;
+        otherArgs[start2] = array;
         return apply(func, this, otherArgs);
       };
     }
@@ -130012,8 +130410,8 @@ var require_lodash13 = __commonJS({
       return result;
     }
     function overArg(func, transform) {
-      return function(arg) {
-        return func(transform(arg));
+      return function(arg2) {
+        return func(transform(arg2));
       };
     }
     var funcProto = Function.prototype;
@@ -130103,8 +130501,8 @@ var require_old = __commonJS({
       var current;
       var base;
       var previous;
-      start();
-      function start() {
+      start2();
+      function start2() {
         var m2 = splitRootRe.exec(p2);
         pos = m2[0].length;
         current = m2[0];
@@ -130151,7 +130549,7 @@ var require_old = __commonJS({
           if (!isWindows) seenLinks[id] = linkTarget;
         }
         p2 = pathModule.resolve(resolvedLink, p2.slice(pos));
-        start();
+        start2();
       }
       if (cache) cache[original] = p2;
       return p2;
@@ -130170,8 +130568,8 @@ var require_old = __commonJS({
       var current;
       var base;
       var previous;
-      start();
-      function start() {
+      start2();
+      function start2() {
         var m2 = splitRootRe.exec(p2);
         pos = m2[0].length;
         current = m2[0];
@@ -130235,7 +130633,7 @@ var require_old = __commonJS({
       }
       function gotResolvedLink(resolvedLink) {
         p2 = pathModule.resolve(resolvedLink, p2.slice(pos));
-        start();
+        start2();
       }
     };
   }
@@ -133255,11 +133653,11 @@ var require_core = __commonJS({
         this._finalize();
       }
       var self2 = this;
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var errored;
         self2._module.on("end", function() {
           if (!errored) {
-            resolve6();
+            resolve7();
           }
         });
         self2._module.on("error", function(err2) {
@@ -135157,14 +135555,14 @@ var require_BufferList2 = __commonJS({
       const offset = this._offset(index);
       return this._bufs[offset[0]][offset[1]];
     };
-    BufferList.prototype.slice = function slice(start, end) {
-      if (typeof start === "number" && start < 0) {
-        start += this.length;
+    BufferList.prototype.slice = function slice(start2, end) {
+      if (typeof start2 === "number" && start2 < 0) {
+        start2 += this.length;
       }
       if (typeof end === "number" && end < 0) {
         end += this.length;
       }
-      return this.copy(null, 0, start, end);
+      return this.copy(null, 0, start2, end);
     };
     BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
       if (typeof srcStart !== "number" || srcStart < 0) {
@@ -135184,7 +135582,7 @@ var require_BufferList2 = __commonJS({
       const len = srcEnd - srcStart;
       let bytes = len;
       let bufoff = copy2 && dstStart || 0;
-      let start = off[1];
+      let start2 = off[1];
       if (srcStart === 0 && srcEnd === this.length) {
         if (!copy2) {
           return this._bufs.length === 1 ? this._bufs[0] : Buffer2.concat(this._bufs, this.length);
@@ -135195,43 +135593,43 @@ var require_BufferList2 = __commonJS({
         }
         return dst;
       }
-      if (bytes <= this._bufs[off[0]].length - start) {
-        return copy2 ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes) : this._bufs[off[0]].slice(start, start + bytes);
+      if (bytes <= this._bufs[off[0]].length - start2) {
+        return copy2 ? this._bufs[off[0]].copy(dst, dstStart, start2, start2 + bytes) : this._bufs[off[0]].slice(start2, start2 + bytes);
       }
       if (!copy2) {
         dst = Buffer2.allocUnsafe(len);
       }
       for (let i3 = off[0]; i3 < this._bufs.length; i3++) {
-        const l3 = this._bufs[i3].length - start;
+        const l3 = this._bufs[i3].length - start2;
         if (bytes > l3) {
-          this._bufs[i3].copy(dst, bufoff, start);
+          this._bufs[i3].copy(dst, bufoff, start2);
           bufoff += l3;
         } else {
-          this._bufs[i3].copy(dst, bufoff, start, start + bytes);
+          this._bufs[i3].copy(dst, bufoff, start2, start2 + bytes);
           bufoff += l3;
           break;
         }
         bytes -= l3;
-        if (start) {
-          start = 0;
+        if (start2) {
+          start2 = 0;
         }
       }
       if (dst.length > bufoff) return dst.slice(0, bufoff);
       return dst;
     };
-    BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
-      start = start || 0;
+    BufferList.prototype.shallowSlice = function shallowSlice(start2, end) {
+      start2 = start2 || 0;
       end = typeof end !== "number" ? this.length : end;
-      if (start < 0) {
-        start += this.length;
+      if (start2 < 0) {
+        start2 += this.length;
       }
       if (end < 0) {
         end += this.length;
       }
-      if (start === end) {
+      if (start2 === end) {
         return this._new();
       }
-      const startOffset = this._offset(start);
+      const startOffset = this._offset(start2);
       const endOffset = this._offset(end);
       const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1);
       if (endOffset[1] === 0) {
@@ -135244,8 +135642,8 @@ var require_BufferList2 = __commonJS({
       }
       return this._new(buffers);
     };
-    BufferList.prototype.toString = function toString(encoding, start, end) {
-      return this.slice(start, end).toString(encoding);
+    BufferList.prototype.toString = function toString(encoding, start2, end) {
+      return this.slice(start2, end).toString(encoding);
     };
     BufferList.prototype.consume = function consume(bytes) {
       bytes = Math.trunc(bytes);
@@ -135784,8 +136182,8 @@ var require_extract = __commonJS({
       };
       var onstreamend = function() {
         self2._stream = null;
-        var drain = overflow(self2._header.size);
-        if (drain) self2._parse(drain, ondrain);
+        var drain2 = overflow(self2._header.size);
+        if (drain2) self2._parse(drain2, ondrain);
         else self2._parse(512, onheader);
         if (!self2._locked) oncontinue();
       };
@@ -136033,7 +136431,7 @@ var require_pack = __commonJS({
     var alloc = Buffer.alloc;
     var Readable = require_readable2().Readable;
     var Writable = require_readable2().Writable;
-    var StringDecoder = __require("string_decoder").StringDecoder;
+    var StringDecoder2 = __require("string_decoder").StringDecoder;
     var headers = require_headers();
     var DMODE = parseInt("755", 8);
     var FMODE = parseInt("644", 8);
@@ -136079,7 +136477,7 @@ var require_pack = __commonJS({
     var LinkSink = function() {
       Writable.call(this);
       this.linkname = "";
-      this._decoder = new StringDecoder("utf-8");
+      this._decoder = new StringDecoder2("utf-8");
       this._destroyed = false;
     };
     inherits2(LinkSink, Writable);
@@ -136231,9 +136629,9 @@ var require_pack = __commonJS({
       this.push(headers.encode(newHeader));
     };
     Pack.prototype._read = function(n2) {
-      var drain = this._drain;
+      var drain2 = this._drain;
       this._drain = noop;
-      drain();
+      drain2();
     };
     module2.exports = Pack;
   }
@@ -137001,7 +137399,7 @@ var require_worksheet_writer = __commonJS({
       // =========================================================================
       // Worksheet Protection
       protect(password, options) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           this.sheetProtection = {
             sheet: true
           };
@@ -137025,7 +137423,7 @@ var require_worksheet_writer = __commonJS({
               delete this.sheetProtection.spinCount;
             }
           }
-          resolve6();
+          resolve7();
         });
       }
       unprotect() {
@@ -137243,9 +137641,9 @@ var require_workbook_writer = __commonJS({
       _commitWorksheets() {
         const commitWorksheet = function(worksheet) {
           if (!worksheet.committed) {
-            return new Promise((resolve6) => {
+            return new Promise((resolve7) => {
               worksheet.stream.on("zipped", () => {
-                resolve6();
+                resolve7();
               });
               worksheet.commit();
             });
@@ -137333,19 +137731,19 @@ var require_workbook_writer = __commonJS({
         return void 0;
       }
       addStyles() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           this.zip.append(this.styles.xml, { name: "xl/styles.xml" });
-          resolve6();
+          resolve7();
         });
       }
       addThemes() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           this.zip.append(theme1Xml, { name: "xl/theme/theme1.xml" });
-          resolve6();
+          resolve7();
         });
       }
       addOfficeRels() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const xform = new RelationshipsXform();
           const xml = xform.toXml([
             { Id: "rId1", Type: RelType.OfficeDocument, Target: "xl/workbook.xml" },
@@ -137353,11 +137751,11 @@ var require_workbook_writer = __commonJS({
             { Id: "rId3", Type: RelType.ExtenderProperties, Target: "docProps/app.xml" }
           ]);
           this.zip.append(xml, { name: "/_rels/.rels" });
-          resolve6();
+          resolve7();
         });
       }
       addContentTypes() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const model = {
             worksheets: this._worksheets.filter(Boolean),
             sharedStrings: this.sharedStrings,
@@ -137367,7 +137765,7 @@ var require_workbook_writer = __commonJS({
           const xform = new ContentTypesXform();
           const xml = xform.toXml(model);
           this.zip.append(xml, { name: "[Content_Types].xml" });
-          resolve6();
+          resolve7();
         });
       }
       addMedia() {
@@ -137392,31 +137790,31 @@ var require_workbook_writer = __commonJS({
         );
       }
       addApp() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const model = {
             worksheets: this._worksheets.filter(Boolean)
           };
           const xform = new AppXform();
           const xml = xform.toXml(model);
           this.zip.append(xml, { name: "docProps/app.xml" });
-          resolve6();
+          resolve7();
         });
       }
       addCore() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const coreXform = new CoreXform();
           const xml = coreXform.toXml(this);
           this.zip.append(xml, { name: "docProps/core.xml" });
-          resolve6();
+          resolve7();
         });
       }
       addSharedStrings() {
         if (this.sharedStrings.count) {
-          return new Promise((resolve6) => {
+          return new Promise((resolve7) => {
             const sharedStringsXform = new SharedStringsXform();
             const xml = sharedStringsXform.toXml(this.sharedStrings);
             this.zip.append(xml, { name: "/xl/sharedStrings.xml" });
-            resolve6();
+            resolve7();
           });
         }
         return Promise.resolve();
@@ -137444,11 +137842,11 @@ var require_workbook_writer = __commonJS({
             });
           }
         });
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const xform = new RelationshipsXform();
           const xml = xform.toXml(relationships);
           this.zip.append(xml, { name: "/xl/_rels/workbook.xml.rels" });
-          resolve6();
+          resolve7();
         });
       }
       addWorkbook() {
@@ -137460,18 +137858,18 @@ var require_workbook_writer = __commonJS({
           properties: {},
           calcProperties: {}
         };
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const xform = new WorkbookXform();
           xform.prepare(model);
           zip.append(xform.toXml(model), { name: "/xl/workbook.xml" });
-          resolve6();
+          resolve7();
         });
       }
       _finalize() {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           this.stream.on("error", reject);
           this.stream.on("finish", () => {
-            resolve6(this);
+            resolve7(this);
           });
           this.zip.on("error", reject);
           this.zip.finalize();
@@ -137992,8 +138390,8 @@ var require_buffers = __commonJS({
       }
       return this.length;
     };
-    Buffers.prototype.copy = function(dst, dStart, start, end) {
-      return this.slice(start, end).copy(dst, dStart, 0, end - start);
+    Buffers.prototype.copy = function(dst, dStart, start2, end) {
+      return this.slice(start2, end).copy(dst, dStart, 0, end - start2);
     };
     Buffers.prototype.splice = function(i3, howMany) {
       var buffers = this.buffers;
@@ -138014,17 +138412,17 @@ var require_buffers = __commonJS({
         startBytes += buffers[ii2].length;
       }
       if (index - startBytes > 0) {
-        var start = index - startBytes;
-        if (start + howMany < buffers[ii2].length) {
-          removed.push(buffers[ii2].slice(start, start + howMany));
+        var start2 = index - startBytes;
+        if (start2 + howMany < buffers[ii2].length) {
+          removed.push(buffers[ii2].slice(start2, start2 + howMany));
           var orig = buffers[ii2];
-          var buf0 = new Buffer(start);
-          for (var i3 = 0; i3 < start; i3++) {
+          var buf0 = new Buffer(start2);
+          for (var i3 = 0; i3 < start2; i3++) {
             buf0[i3] = orig[i3];
           }
-          var buf1 = new Buffer(orig.length - start - howMany);
-          for (var i3 = start + howMany; i3 < orig.length; i3++) {
-            buf1[i3 - howMany - start] = orig[i3];
+          var buf1 = new Buffer(orig.length - start2 - howMany);
+          for (var i3 = start2 + howMany; i3 < orig.length; i3++) {
+            buf1[i3 - howMany - start2] = orig[i3];
           }
           if (reps.length > 0) {
             var reps_ = reps.slice();
@@ -138038,8 +138436,8 @@ var require_buffers = __commonJS({
             ii2 += 2;
           }
         } else {
-          removed.push(buffers[ii2].slice(start));
-          buffers[ii2] = buffers[ii2].slice(0, start);
+          removed.push(buffers[ii2].slice(start2));
+          buffers[ii2] = buffers[ii2].slice(0, start2);
           ii2++;
         }
       }
@@ -138075,10 +138473,10 @@ var require_buffers = __commonJS({
       var ti2 = 0;
       for (var ii2 = si2; ti2 < j2 - i3 && ii2 < buffers.length; ii2++) {
         var len = buffers[ii2].length;
-        var start = ti2 === 0 ? i3 - startBytes : 0;
-        var end = ti2 + len >= j2 - i3 ? Math.min(start + (j2 - i3) - ti2, len) : len;
-        buffers[ii2].copy(target, ti2, start, end);
-        ti2 += end - start;
+        var start2 = ti2 === 0 ? i3 - startBytes : 0;
+        var end = ti2 + len >= j2 - i3 ? Math.min(start2 + (j2 - i3) - ti2, len) : len;
+        buffers[ii2].copy(target, ti2, start2, end);
+        ti2 += end - start2;
       }
       return target;
     };
@@ -138157,8 +138555,8 @@ var require_buffers = __commonJS({
     Buffers.prototype.toBuffer = function() {
       return this.slice();
     };
-    Buffers.prototype.toString = function(encoding, start, end) {
-      return this.slice(start, end).toString(encoding);
+    Buffers.prototype.toString = function(encoding, start2, end) {
+      return this.slice(start2, end).toString(encoding);
     };
   }
 });
@@ -139020,19 +139418,19 @@ var require_queue = __commonJS({
     Queue.prototype._willBeOverCapacity = function(size) {
       return this._capacity < size;
     };
-    Queue.prototype._pushOne = function(arg) {
+    Queue.prototype._pushOne = function(arg2) {
       var length = this.length();
       this._checkCapacity(length + 1);
       var i3 = this._front + length & this._capacity - 1;
-      this[i3] = arg;
+      this[i3] = arg2;
       this._length = length + 1;
     };
-    Queue.prototype.push = function(fn2, receiver, arg) {
+    Queue.prototype.push = function(fn2, receiver, arg2) {
       var length = this.length() + 3;
       if (this._willBeOverCapacity(length)) {
         this._pushOne(fn2);
         this._pushOne(receiver);
-        this._pushOne(arg);
+        this._pushOne(arg2);
         return;
       }
       var j2 = this._front + length - 3;
@@ -139040,7 +139438,7 @@ var require_queue = __commonJS({
       var wrapMask = this._capacity - 1;
       this[j2 + 0 & wrapMask] = fn2;
       this[j2 + 1 & wrapMask] = receiver;
-      this[j2 + 2 & wrapMask] = arg;
+      this[j2 + 2 & wrapMask] = arg2;
       this._length = length;
     };
     Queue.prototype.shift = function() {
@@ -139124,31 +139522,31 @@ var require_async2 = __commonJS({
         this.throwLater(e2);
       }
     };
-    Async.prototype.throwLater = function(fn2, arg) {
+    Async.prototype.throwLater = function(fn2, arg2) {
       if (arguments.length === 1) {
-        arg = fn2;
+        arg2 = fn2;
         fn2 = function() {
-          throw arg;
+          throw arg2;
         };
       }
       if (typeof setTimeout !== "undefined") {
         setTimeout(function() {
-          fn2(arg);
+          fn2(arg2);
         }, 0);
       } else try {
         this._schedule(function() {
-          fn2(arg);
+          fn2(arg2);
         });
       } catch (e2) {
         throw new Error("No async scheduler available\n\n    See http://goo.gl/MqrFmX\n");
       }
     };
-    function AsyncInvokeLater(fn2, receiver, arg) {
-      this._lateQueue.push(fn2, receiver, arg);
+    function AsyncInvokeLater(fn2, receiver, arg2) {
+      this._lateQueue.push(fn2, receiver, arg2);
       this._queueTick();
     }
-    function AsyncInvoke(fn2, receiver, arg) {
-      this._normalQueue.push(fn2, receiver, arg);
+    function AsyncInvoke(fn2, receiver, arg2) {
+      this._normalQueue.push(fn2, receiver, arg2);
       this._queueTick();
     }
     function AsyncSettlePromises(promise) {
@@ -139160,23 +139558,23 @@ var require_async2 = __commonJS({
       Async.prototype.invoke = AsyncInvoke;
       Async.prototype.settlePromises = AsyncSettlePromises;
     } else {
-      Async.prototype.invokeLater = function(fn2, receiver, arg) {
+      Async.prototype.invokeLater = function(fn2, receiver, arg2) {
         if (this._trampolineEnabled) {
-          AsyncInvokeLater.call(this, fn2, receiver, arg);
+          AsyncInvokeLater.call(this, fn2, receiver, arg2);
         } else {
           this._schedule(function() {
             setTimeout(function() {
-              fn2.call(receiver, arg);
+              fn2.call(receiver, arg2);
             }, 100);
           });
         }
       };
-      Async.prototype.invoke = function(fn2, receiver, arg) {
+      Async.prototype.invoke = function(fn2, receiver, arg2) {
         if (this._trampolineEnabled) {
-          AsyncInvoke.call(this, fn2, receiver, arg);
+          AsyncInvoke.call(this, fn2, receiver, arg2);
         } else {
           this._schedule(function() {
-            fn2.call(receiver, arg);
+            fn2.call(receiver, arg2);
           });
         }
       };
@@ -139198,8 +139596,8 @@ var require_async2 = __commonJS({
           continue;
         }
         var receiver = queue.shift();
-        var arg = queue.shift();
-        fn2.call(receiver, arg);
+        var arg2 = queue.shift();
+        fn2.call(receiver, arg2);
       }
     };
     Async.prototype._drainQueues = function() {
@@ -139398,13 +139796,13 @@ var require_thenables = __commonJS({
         promise._captureStackTrace();
         if (context) context._popContext();
         var synchronous = true;
-        var result = util.tryCatch(then).call(x3, resolve6, reject);
+        var result = util.tryCatch(then).call(x3, resolve7, reject);
         synchronous = false;
         if (promise && result === errorObj2) {
           promise._rejectCallback(result.e, true, true);
           promise = null;
         }
-        function resolve6(value) {
+        function resolve7(value) {
           if (!promise) return;
           promise._resolveCallback(value);
           promise = null;
@@ -139939,9 +140337,9 @@ var require_debuggability = __commonJS({
         return false;
       }
       Promise2.prototype._fireEvent = defaultFireEvent;
-      Promise2.prototype._execute = function(executor, resolve6, reject) {
+      Promise2.prototype._execute = function(executor, resolve7, reject) {
         try {
-          executor(resolve6, reject);
+          executor(resolve7, reject);
         } catch (e2) {
           return e2;
         }
@@ -139964,10 +140362,10 @@ var require_debuggability = __commonJS({
         ;
         ;
       };
-      function cancellationExecute(executor, resolve6, reject) {
+      function cancellationExecute(executor, resolve7, reject) {
         var promise = this;
         try {
-          executor(resolve6, reject, function(onCancel) {
+          executor(resolve7, reject, function(onCancel) {
             if (typeof onCancel !== "function") {
               throw new TypeError("onCancel must be a function, got: " + util.toString(onCancel));
             }
@@ -140744,9 +141142,9 @@ var require_method = __commonJS({
         var value;
         if (arguments.length > 1) {
           debug31.deprecated("calling Promise.try with more than 1 argument");
-          var arg = arguments[1];
+          var arg2 = arguments[1];
           var ctx = arguments[2];
-          value = util.isArray(arg) ? tryCatch2(fn2).apply(ctx, arg) : tryCatch2(fn2).call(ctx, arg);
+          value = util.isArray(arg2) ? tryCatch2(fn2).apply(ctx, arg2) : tryCatch2(fn2).call(ctx, arg2);
         } else {
           value = tryCatch2(fn2)();
         }
@@ -141721,9 +142119,9 @@ var require_timers = __commonJS({
         clearTimeout(this.handle);
       };
       var afterValue = function(value) {
-        return delay(+this).thenReturn(value);
+        return delay2(+this).thenReturn(value);
       };
-      var delay = Promise2.delay = function(ms2, value) {
+      var delay2 = Promise2.delay = function(ms2, value) {
         var ret2;
         var handle;
         if (value !== void 0) {
@@ -141745,7 +142143,7 @@ var require_timers = __commonJS({
         return ret2;
       };
       Promise2.prototype.delay = function(ms2) {
-        return delay(ms2, this);
+        return delay2(ms2, this);
       };
       var afterTimeout = function(promise, message, parent) {
         var err2;
@@ -141990,15 +142388,15 @@ var require_generators = __commonJS({
         var stack = new Error().stack;
         return function() {
           var generator = generatorFunction.apply(this, arguments);
-          var spawn = new PromiseSpawn$(
+          var spawn2 = new PromiseSpawn$(
             void 0,
             void 0,
             yieldHandler,
             stack
           );
-          var ret2 = spawn.promise();
-          spawn._generator = generator;
-          spawn._promiseFulfilled(void 0);
+          var ret2 = spawn2.promise();
+          spawn2._generator = generator;
+          spawn2._promiseFulfilled(void 0);
           return ret2;
         };
       };
@@ -142013,9 +142411,9 @@ var require_generators = __commonJS({
         if (typeof generatorFunction !== "function") {
           return apiRejection("generatorFunction must be a function\n\n    See http://goo.gl/MqrFmX\n");
         }
-        var spawn = new PromiseSpawn(generatorFunction, this);
-        var ret2 = spawn.promise();
-        spawn._run(Promise2.spawn);
+        var spawn2 = new PromiseSpawn(generatorFunction, this);
+        var ret2 = spawn2.promise();
+        spawn2._run(Promise2.spawn);
         return ret2;
       };
     };
@@ -142290,7 +142688,7 @@ var require_promisify = __commonJS({
         util.toFastProperties(obj2);
         return obj2;
       }
-      function promisify4(callback, receiver, multiArgs) {
+      function promisify(callback, receiver, multiArgs) {
         return makeNodePromisified(
           callback,
           receiver,
@@ -142310,7 +142708,7 @@ var require_promisify = __commonJS({
         options = Object(options);
         var receiver = options.context === void 0 ? THIS : options.context;
         var multiArgs = !!options.multiArgs;
-        var ret2 = promisify4(fn2, receiver, multiArgs);
+        var ret2 = promisify(fn2, receiver, multiArgs);
         util.copyDescriptors(fn2, ret2, propsFilter);
         return ret2;
       };
@@ -143259,8 +143657,8 @@ var require_promise = __commonJS({
         this._setLength(index + 1);
         return index;
       };
-      Promise2.prototype._proxy = function(proxyable, arg) {
-        this._addCallbacks(void 0, void 0, arg, proxyable, null);
+      Promise2.prototype._proxy = function(proxyable, arg2) {
+        this._addCallbacks(void 0, void 0, arg2, proxyable, null);
       };
       Promise2.prototype._resolveCallback = function(value, shouldBind) {
         if ((this._bitField & 117506048) !== 0) return;
@@ -143716,7 +144114,7 @@ var require_PullStream = __commonJS({
       };
       var rejectHandler;
       var pullStreamRejectHandler;
-      return new Promise2(function(resolve6, reject) {
+      return new Promise2(function(resolve7, reject) {
         rejectHandler = reject;
         pullStreamRejectHandler = function(e2) {
           self2.__emittedError = e2;
@@ -143726,7 +144124,7 @@ var require_PullStream = __commonJS({
           return reject(new Error("FILE_ENDED"));
         self2.once("error", pullStreamRejectHandler);
         self2.stream(eof, includeEof).on("error", reject).pipe(concatStream).on("finish", function() {
-          resolve6(buffer);
+          resolve7(buffer);
         }).on("error", reject);
       }).finally(function() {
         self2.removeListener("error", rejectHandler);
@@ -143769,10 +144167,10 @@ var require_BufferStream = __commonJS({
     if (!Stream2.Writable || !Stream2.Writable.prototype.destroy)
       Stream2 = require_readable();
     module2.exports = function(entry) {
-      return new Promise2(function(resolve6, reject) {
+      return new Promise2(function(resolve7, reject) {
         var chunks = [];
         var bufferStream = Stream2.Transform().on("finish", function() {
-          resolve6(Buffer2.concat(chunks));
+          resolve7(Buffer2.concat(chunks));
         }).on("error", reject);
         bufferStream._transform = function(d2, e2, cb) {
           chunks.push(d2);
@@ -143911,8 +144309,8 @@ var require_parse2 = __commonJS({
             __autodraining = true;
             var draining = entry.pipe(NoopStream());
             draining.promise = function() {
-              return new Promise2(function(resolve6, reject) {
-                draining.on("finish", resolve6);
+              return new Promise2(function(resolve7, reject) {
+                draining.on("finish", resolve7);
                 draining.on("error", reject);
               });
             };
@@ -143967,11 +144365,11 @@ var require_parse2 = __commonJS({
               eof = Buffer2.alloc(4);
               eof.writeUInt32LE(134695760, 0);
             }
-            return new Promise2(function(resolve6, reject) {
+            return new Promise2(function(resolve7, reject) {
               self2.stream(eof).pipe(inflater).on("error", function(err2) {
                 self2.emit("error", err2);
               }).pipe(entry).on("finish", function() {
-                return fileSizeKnown ? self2._readRecord().then(resolve6).catch(reject) : self2._processDataDescriptor(entry).then(resolve6).catch(reject);
+                return fileSizeKnown ? self2._readRecord().then(resolve7).catch(reject) : self2._processDataDescriptor(entry).then(resolve7).catch(reject);
               });
             });
           });
@@ -144013,8 +144411,8 @@ var require_parse2 = __commonJS({
     };
     Parse.prototype.promise = function() {
       var self2 = this;
-      return new Promise2(function(resolve6, reject) {
-        self2.on("finish", resolve6);
+      return new Promise2(function(resolve7, reject) {
+        self2.on("finish", resolve7);
         self2.on("error", reject);
       });
     };
@@ -145792,24 +146190,24 @@ var require_writer2 = __commonJS({
     }
     function endChmod(self2, want, current, path2, cb) {
       var wantMode = want.mode;
-      var chmod = want.follow || self2.type !== "SymbolicLink" ? "chmod" : "lchmod";
-      if (!fs2[chmod]) return cb();
+      var chmod2 = want.follow || self2.type !== "SymbolicLink" ? "chmod" : "lchmod";
+      if (!fs2[chmod2]) return cb();
       if (typeof wantMode !== "number") return cb();
       var curMode = current.mode & parseInt("0777", 8);
       wantMode = wantMode & parseInt("0777", 8);
       if (wantMode === curMode) return cb();
-      fs2[chmod](path2, wantMode, cb);
+      fs2[chmod2](path2, wantMode, cb);
     }
     function endChown(self2, want, current, path2, cb) {
       if (process.platform === "win32") return cb();
       if (!process.getuid || process.getuid() !== 0) return cb();
       if (typeof want.uid !== "number" && typeof want.gid !== "number") return cb();
       if (current.uid === want.uid && current.gid === want.gid) return cb();
-      var chown = self2.props.follow || self2.type !== "SymbolicLink" ? "chown" : "lchown";
-      if (!fs2[chown]) return cb();
+      var chown2 = self2.props.follow || self2.type !== "SymbolicLink" ? "chown" : "lchown";
+      if (!fs2[chown2]) return cb();
       if (typeof want.uid !== "number") want.uid = current.uid;
       if (typeof want.gid !== "number") want.gid = current.gid;
-      fs2[chown](path2, want.uid, want.gid, cb);
+      fs2[chown2](path2, want.uid, want.gid, cb);
     }
     function endUtimes(self2, want, current, path2, cb) {
       if (!fs2.utimes || process.platform === "win32") return cb();
@@ -146003,8 +146401,8 @@ var require_extract2 = __commonJS({
         extract.emit("close");
       });
       extract.promise = function() {
-        return new Promise2(function(resolve6, reject) {
-          extract.on("close", resolve6);
+        return new Promise2(function(resolve7, reject) {
+          extract.on("close", resolve7);
           extract.on("error", reject);
         });
       };
@@ -147055,11 +147453,11 @@ var require_BigInteger = __commonJS({
           var c2 = text[i4];
           if (c2 in alphabetValues) digits.push(parseValue(alphabetValues[c2]));
           else if (c2 === "<") {
-            var start = i4;
+            var start2 = i4;
             do {
               i4++;
             } while (text[i4] !== ">" && i4 < text.length);
-            digits.push(parseValue(text.slice(start + 1, i4)));
+            digits.push(parseValue(text.slice(start2 + 1, i4)));
           } else throw new Error(c2 + " is not a valid character");
         }
         return parseBaseFromArray(digits, base, isNegative);
@@ -147511,8 +147909,8 @@ var require_directory = __commonJS({
                 return;
               }
               var writer = opts.getWriter ? opts.getWriter({ path: extractPath }) : Writer({ path: extractPath });
-              return new Promise2(function(resolve6, reject) {
-                entry.stream(opts.password).on("error", reject).pipe(writer).on("close", resolve6).on("error", reject);
+              return new Promise2(function(resolve7, reject) {
+                entry.stream(opts.password).on("error", reject).pipe(writer).on("close", resolve7).on("error", reject);
               });
             }, { concurrency: opts.concurrency > 1 ? opts.concurrency : 1 });
           });
@@ -147578,12 +147976,12 @@ var require_Open = __commonJS({
             return fs2.createReadStream(filename, { start: offset, end: length && offset + length });
           },
           size: function() {
-            return new Promise2(function(resolve6, reject) {
+            return new Promise2(function(resolve7, reject) {
               fs2.stat(filename, function(err2, d2) {
                 if (err2)
                   reject(err2);
                 else
-                  resolve6(d2.size);
+                  resolve7(d2.size);
               });
             });
           }
@@ -147604,14 +148002,14 @@ var require_Open = __commonJS({
             return request(options2);
           },
           size: function() {
-            return new Promise2(function(resolve6, reject) {
+            return new Promise2(function(resolve7, reject) {
               var req = request(params);
               req.on("response", function(d2) {
                 req.abort();
                 if (!d2.headers["content-length"])
                   reject(new Error("Missing content length header"));
                 else
-                  resolve6(d2.headers["content-length"]);
+                  resolve7(d2.headers["content-length"]);
               }).on("error", reject);
             });
           }
@@ -147621,12 +148019,12 @@ var require_Open = __commonJS({
       s3: function(client, params, options) {
         var source = {
           size: function() {
-            return new Promise2(function(resolve6, reject) {
+            return new Promise2(function(resolve7, reject) {
               client.headObject(params, function(err2, d2) {
                 if (err2)
                   reject(err2);
                 else
-                  resolve6(d2.ContentLength);
+                  resolve7(d2.ContentLength);
               });
             });
           },
@@ -147926,8 +148324,8 @@ var require_tmp = __commonJS({
       if (!_isUndefined(options.name)) {
         const name = options.name;
         if (path.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
-        const basename7 = path.basename(name);
-        if (basename7 === ".." || basename7 === "." || basename7 !== name) {
+        const basename8 = path.basename(name);
+        if (basename8 === ".." || basename8 === "." || basename8 !== name) {
           throw new Error(`name option must not contain a path, found "${name}".`);
         }
       }
@@ -148042,7 +148440,7 @@ var require_iterate_stream = __commonJS({
       const contents = [];
       stream.on("data", (data) => contents.push(data));
       let resolveStreamEndedPromise;
-      const streamEndedPromise = new Promise((resolve6) => resolveStreamEndedPromise = resolve6);
+      const streamEndedPromise = new Promise((resolve7) => resolveStreamEndedPromise = resolve7);
       let ended = false;
       stream.on("end", () => {
         ended = true;
@@ -148067,13 +148465,13 @@ var require_iterate_stream = __commonJS({
       resolveStreamEndedPromise();
     };
     function once(eventEmitter, type) {
-      return new Promise((resolve6) => {
+      return new Promise((resolve7) => {
         let fired = false;
         const handler = () => {
           if (!fired) {
             fired = true;
             eventEmitter.removeListener(type, handler);
-            resolve6();
+            resolve7();
           }
         };
         eventEmitter.addListener(type, handler);
@@ -148597,7 +148995,7 @@ var require_workbook_reader = __commonJS({
                 if (this.sharedStrings && this.workbookRels) {
                   yield* this._parseWorksheet(iterateStream(entry), sheetNo);
                 } else {
-                  await new Promise((resolve6, reject) => {
+                  await new Promise((resolve7, reject) => {
                     tmp.file((err2, path, fd2, tempFileCleanupCallback) => {
                       if (err2) {
                         return reject(err2);
@@ -148607,7 +149005,7 @@ var require_workbook_reader = __commonJS({
                       tempStream.on("error", reject);
                       entry.pipe(tempStream);
                       return tempStream.on("finish", () => {
-                        return resolve6();
+                        return resolve7();
                       });
                     });
                   });
@@ -148835,10 +149233,11 @@ var require_excel = __commonJS({
 });
 
 // ../fileq/src/lib/derivers/xlsx.ts
-var MAX_ROWS_PER_SHEET2, MAX_COLUMNS2, cellText2, oneLine, xlsxDeriver;
+var MAX_ROWS_PER_SHEET2, MAX_COLUMNS2, cellText2, xlsxDeriver;
 var init_xlsx = __esm({
   "../fileq/src/lib/derivers/xlsx.ts"() {
     "use strict";
+    init_one_line();
     init_markdown();
     MAX_ROWS_PER_SHEET2 = 200;
     MAX_COLUMNS2 = 30;
@@ -148851,7 +149250,7 @@ var init_xlsx = __esm({
       }
       if (typeof value === "object") {
         if ("richText" in value) {
-          return value.richText.map((run5) => run5.text).join("");
+          return value.richText.map((run3) => run3.text).join("");
         }
         if ("text" in value) {
           return String(value.text);
@@ -148866,7 +149265,6 @@ var init_xlsx = __esm({
       }
       return String(value);
     };
-    oneLine = (text) => text.replaceAll(/\s+/g, " ").trim();
     xlsxDeriver = {
       name: "xlsx",
       version: 1,
@@ -148902,7 +149300,7 @@ var init_xlsx = __esm({
           }
           sections.push(`## ${sheet.name}
 
-${markdownTable(kept.map((row) => row.map(oneLine)))}`);
+${markdownTable(kept.map((row) => row.map((cell) => oneLine(cell))))}`);
         }
         return { markdown: sections.join("\n\n"), notes };
       }
@@ -148929,23 +149327,120 @@ var init_env = __esm({
   }
 });
 
+// ../../_tools/base/src/node/fs.ts
+import { randomBytes } from "node:crypto";
+import { access, chmod, chown, mkdir, open, rename, rm as rm2 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname2, join as join5, resolve as resolve3 } from "node:path";
+import { setTimeout as sleep2 } from "node:timers/promises";
+var fileLock, TRANSIENT_RENAME, RENAME_ATTEMPTS, RENAME_RETRY_MS, renameOver, stagingOf, writeStaged, directoriesToSync, isUnder, syncDirectories, syncOne, replaceAtomically, writeFileAtomic;
+var init_fs = __esm({
+  "../../_tools/base/src/node/fs.ts"() {
+    "use strict";
+    init_async();
+    init_errors();
+    fileLock = keyedLock();
+    TRANSIENT_RENAME = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+    RENAME_ATTEMPTS = 10;
+    RENAME_RETRY_MS = 25;
+    renameOver = async (from, to2) => {
+      for (let attempt = 1; ; attempt++) {
+        try {
+          await rename(from, to2);
+          return;
+        } catch (error2) {
+          if (process.platform !== "win32" || attempt >= RENAME_ATTEMPTS || !TRANSIENT_RENAME.has(error2.code ?? "")) {
+            throw error2;
+          }
+          await sleep2(RENAME_RETRY_MS);
+        }
+      }
+    };
+    stagingOf = (path) => join5(dirname2(path), `.${basename3(path)}.${randomBytes(6).toString("hex")}.tmp`);
+    writeStaged = async (staging, write3, mode, durable) => {
+      const handle = await open(staging, "w", mode);
+      try {
+        await write3(handle);
+        if (durable) {
+          await handle.sync();
+        }
+      } finally {
+        await handle.close();
+      }
+    };
+    directoriesToSync = (dirs, upTo) => {
+      const top = upTo === void 0 ? void 0 : resolve3(upTo);
+      const seen = /* @__PURE__ */ new Set();
+      for (const dir of dirs) {
+        for (let directory = resolve3(dir); !seen.has(directory); directory = dirname2(directory)) {
+          seen.add(directory);
+          const parent = dirname2(directory);
+          if (top === void 0 || directory === top || parent === directory || !isUnder(top, directory)) {
+            break;
+          }
+        }
+      }
+      return [...seen];
+    };
+    isUnder = (top, path) => path === top || path.startsWith(top.endsWith("/") ? top : `${top}/`);
+    syncDirectories = async (dirs, options = {}) => {
+      if (process.platform === "win32") {
+        return;
+      }
+      for (const directory of directoriesToSync(dirs, options.upTo)) {
+        await syncOne(directory);
+      }
+    };
+    syncOne = async (directory) => {
+      let handle;
+      try {
+        handle = await open(directory, "r");
+        await handle.sync();
+      } catch {
+      } finally {
+        await handle?.close().catch(() => void 0);
+      }
+    };
+    replaceAtomically = async (path, write3, mode, options) => {
+      const staging = stagingOf(path);
+      await mkdir(dirname2(path), { recursive: true });
+      try {
+        await writeStaged(staging, write3, mode, options.durable === true);
+        if (options.owner !== void 0) {
+          await chown(staging, options.owner.uid, options.owner.gid);
+        }
+        if (mode !== void 0) {
+          await chmod(staging, mode);
+        }
+        await renameOver(staging, path);
+      } finally {
+        await rm2(staging, { force: true });
+      }
+      if (options.durable === true) {
+        await syncDirectories([dirname2(path)], options.syncUpTo === void 0 ? {} : { upTo: options.syncUpTo });
+      }
+    };
+    writeFileAtomic = async (path, content, mode, options = {}) => await replaceAtomically(path, async (handle) => await handle.writeFile(content), mode, options);
+  }
+});
+
 // ../fileq/src/lib/sidecar.ts
-import { createHash, randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { mkdir, readFile as readFile14, rename, rm as rm2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { readFile as readFile14, rm as rm3, writeFile } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var DERIVED_DIR, sidecarPathFor, sha256OfFile, EMPTY_FRONT, parseSidecarFront, sidecarBody, readSidecar, isFresh, provenanceNote, writeDerived, writeSidecar, ignoreShadowsInGit, removeSidecar;
 var init_sidecar = __esm({
   "../fileq/src/lib/sidecar.ts"() {
     "use strict";
     init_format();
+    init_fs();
     init_outside_text();
     init_src();
     DERIVED_DIR = `${STATE_DIR}/local/cache/derived`;
-    sidecarPathFor = (workspaceRoot2, relPath) => join5(workspaceRoot2, DERIVED_DIR, `${relPath}.md`);
-    sha256OfFile = (absPath) => new Promise((resolve6, reject) => {
+    sidecarPathFor = (workspaceRoot2, relPath) => join6(workspaceRoot2, DERIVED_DIR, `${relPath}.md`);
+    sha256OfFile = (absPath) => new Promise((resolve7, reject) => {
       const hash = createHash("sha256");
-      createReadStream(absPath).on("error", reject).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve6(hash.digest("hex")));
+      createReadStream(absPath).on("error", reject).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve7(hash.digest("hex")));
     });
     EMPTY_FRONT = { source: void 0, sha256: void 0, deriver: void 0, derivedAt: void 0, title: void 0, notes: [] };
     parseSidecarFront = (content) => {
@@ -149012,16 +149507,8 @@ var init_sidecar = __esm({
         "---",
         ""
       ].join("\n");
-      await mkdir(dirname2(path), { recursive: true });
-      const temp = `${path}.${process.pid}-${randomBytes(4).toString("hex")}.tmp`;
-      try {
-        await writeFile(temp, `${frontMatter}${body === "" ? "" : `${body}
+      await writeFileAtomic(path, `${frontMatter}${body === "" ? "" : `${body}
 `}`);
-        await rename(temp, path);
-      } catch (error2) {
-        await rm2(temp, { force: true });
-        throw error2;
-      }
       return { path, body, tokens: estimateTokens(body) };
     };
     writeSidecar = async (workspaceRoot2, input) => {
@@ -149032,7 +149519,7 @@ var init_sidecar = __esm({
     };
     ignoreShadowsInGit = async (workspaceRoot2) => {
       try {
-        await writeFile(join5(workspaceRoot2, DERIVED_DIR, ".gitignore"), "# fileq's derived shadows; regenerated on demand.\n*\n", { flag: "wx" });
+        await writeFile(join6(workspaceRoot2, DERIVED_DIR, ".gitignore"), "# fileq's derived shadows; regenerated on demand.\n*\n", { flag: "wx" });
       } catch (error2) {
         if (error2.code !== "EEXIST") {
           return;
@@ -149043,7 +149530,7 @@ var init_sidecar = __esm({
       const path = sidecarPathFor(workspaceRoot2, relPath);
       const existed = await readSidecar(path) !== void 0;
       if (existed) {
-        await rm2(path, { force: true });
+        await rm3(path, { force: true });
       }
       return existed;
     };
@@ -149051,15 +149538,15 @@ var init_sidecar = __esm({
 });
 
 // ../fileq/src/lib/content-cache.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var contentCacheDir, contentCachePathFor, readCachedRendering, cacheRendering;
 var init_content_cache = __esm({
   "../fileq/src/lib/content-cache.ts"() {
     "use strict";
     init_env();
     init_sidecar();
-    contentCacheDir = (workspaceRoot2) => workspaceRoot2 === void 0 ? join6(toolHome("fileq"), "by-hash") : join6(workspaceRoot2, DERIVED_DIR, ".by-hash");
-    contentCachePathFor = (workspaceRoot2, sourceSha, deriverStamp2) => join6(contentCacheDir(workspaceRoot2), `${sourceSha}.${deriverStamp2.replaceAll(/[^A-Za-z0-9.+-]/g, "-")}.md`);
+    contentCacheDir = (workspaceRoot2) => workspaceRoot2 === void 0 ? join7(toolHome("fileq"), "by-hash") : join7(workspaceRoot2, DERIVED_DIR, ".by-hash");
+    contentCachePathFor = (workspaceRoot2, sourceSha, deriverStamp2) => join7(contentCacheDir(workspaceRoot2), `${sourceSha}.${deriverStamp2.replaceAll(/[^A-Za-z0-9.+-]/g, "-")}.md`);
     readCachedRendering = async (workspaceRoot2, sourceSha, deriverStamp2) => {
       const path = contentCachePathFor(workspaceRoot2, sourceSha, deriverStamp2);
       const content = await readSidecar(path);
@@ -149238,7 +149725,7 @@ var init_env2 = __esm({
 });
 
 // ../fileq/src/commands/derive.command.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 var outcomeLine, deriveCommand;
 var init_derive_command = __esm({
   "../fileq/src/commands/derive.command.ts"() {
@@ -149280,7 +149767,7 @@ var init_derive_command = __esm({
         }
         let useful = 0;
         for (const file of files) {
-          const outcome = await ensureSidecar(root, resolve3(root, file));
+          const outcome = await ensureSidecar(root, resolve4(root, file));
           if (outcome.kind !== "skipped") {
             useful += 1;
           }
@@ -149334,7 +149821,7 @@ var init_flags = __esm({
 });
 
 // ../fileq/src/commands/read.command.ts
-import { basename as basename3, resolve as resolve4 } from "node:path";
+import { basename as basename4, resolve as resolve5 } from "node:path";
 var readCommand, readInWorkspace, fromOutcome, readOutsideWorkspace, withFinalNewline;
 var init_read_command = __esm({
   "../fileq/src/commands/read.command.ts"() {
@@ -149360,7 +149847,7 @@ var init_read_command = __esm({
         }
       },
       async func(flags, file) {
-        const absPath = resolve4(file);
+        const absPath = resolve5(file);
         const root = workspaceRoot();
         const result = root === void 0 ? await readOutsideWorkspace(void 0, absPath) : await readInWorkspace(root, absPath);
         if (result === void 0) {
@@ -149379,7 +149866,7 @@ var init_read_command = __esm({
           );
           return;
         }
-        const fields = [result.title ?? basename3(absPath), result.format, `${result.tokens} tokens`, result.source];
+        const fields = [result.title ?? basename4(absPath), result.format, `${result.tokens} tokens`, result.source];
         const notes = result.savedPath === void 0 ? [...result.notes, "nothing saved: the rendering cache could not be written"] : result.notes;
         this.process.stdout.write(capsule("fileq", fields, notes));
         if (result.savedPath !== void 0) {
@@ -149503,18 +149990,16 @@ var init_pages = __esm({
 });
 
 // ../fileq/src/lib/render/convert.ts
-import { execFile as execFile3 } from "node:child_process";
 import { readdir as readdir2 } from "node:fs/promises";
-import { basename as basename4, extname as extname2, join as join7 } from "node:path";
-import { promisify as promisify3 } from "node:util";
-var run4, CONVERT_TIMEOUT_MS, RASTER_TIMEOUT_MS, ToolMissing, ConvertFailed, listDir, OFFICE_PACK, inSandbox, rasterizer, office, IMPRESS_PDF, pdfFilter, toPdf, toPngs;
+import { basename as basename5, extname as extname2, join as join8 } from "node:path";
+var CONVERT_TIMEOUT_MS, RASTER_TIMEOUT_MS, ToolMissing, ConvertFailed, listDir, OFFICE_PACK, inSandbox, rasterizer, office, IMPRESS_PDF, pdfFilter, toPdf, toPngs;
 var init_convert = __esm({
   "../fileq/src/lib/render/convert.ts"() {
     "use strict";
     init_errors();
+    init_process();
     init_tools();
     init_pages();
-    run4 = promisify3(execFile3);
     CONVERT_TIMEOUT_MS = 18e4;
     RASTER_TIMEOUT_MS = 12e4;
     ToolMissing = class extends Error {
@@ -149555,13 +150040,13 @@ var init_convert = __esm({
     IMPRESS_PDF = 'pdf:impress_pdf_Export:{"ExportHiddenSlides":{"type":"boolean","value":"true"}}';
     pdfFilter = (format) => format === "pptx" || format === "odp" ? IMPRESS_PDF : "pdf";
     toPdf = async (binary, absPath, format, workDir) => {
-      const outDir = join7(workDir, "pdf");
+      const outDir = join8(workDir, "pdf");
       const args = [
         "--headless",
         "--norestore",
         "--nologo",
         "--nolockcheck",
-        `-env:UserInstallation=file://${join7(workDir, "profile")}`,
+        `-env:UserInstallation=file://${join8(workDir, "profile")}`,
         "--convert-to",
         pdfFilter(format),
         "--outdir",
@@ -149570,29 +150055,29 @@ var init_convert = __esm({
       ];
       let output = "";
       try {
-        const result = await run4(binary, args, { timeout: CONVERT_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 });
+        const result = await execBounded(binary, args, { timeoutMs: CONVERT_TIMEOUT_MS, maxOutput: 4 * 1024 * 1024 });
         output = `${result.stdout}${result.stderr}`;
       } catch (cause) {
         throw new ConvertFailed(`LibreOffice could not convert it: ${errorMessage(cause).split("\n").slice(0, 3).join(" ")}`);
       }
-      const expected = `${basename4(absPath, extname2(absPath))}.pdf`;
+      const expected = `${basename5(absPath, extname2(absPath))}.pdf`;
       const written = await listDir(outDir);
       if (!written.includes(expected)) {
         const said = output.trim().split("\n").slice(-2).join(" ");
         throw new ConvertFailed(`LibreOffice wrote no PDF${said === "" ? "" : ` (it said: ${said})`}; the file may be damaged or password-protected`);
       }
-      return join7(outDir, expected);
+      return join8(outDir, expected);
     };
     toPngs = async (tool, pdf, pages, size, outDir) => {
-      const prefix = join7(outDir, "p");
+      const prefix = join8(outDir, "p");
       try {
         if (tool === "pdftoppm") {
           for (const [first, last] of runsOf(pages)) {
-            await run4("pdftoppm", ["-png", "-scale-to", String(size), "-f", String(first), "-l", String(last), pdf, prefix], { timeout: RASTER_TIMEOUT_MS });
+            await execBounded("pdftoppm", ["-png", "-scale-to", String(size), "-f", String(first), "-l", String(last), pdf, prefix], { timeoutMs: RASTER_TIMEOUT_MS });
           }
         } else {
-          await run4("mutool", ["draw", "-q", "-F", "png", "-w", String(size), "-h", String(size), "-o", `${prefix}-%d.png`, pdf, pages.join(",")], {
-            timeout: RASTER_TIMEOUT_MS
+          await execBounded("mutool", ["draw", "-q", "-F", "png", "-w", String(size), "-h", String(size), "-o", `${prefix}-%d.png`, pdf, pages.join(",")], {
+            timeoutMs: RASTER_TIMEOUT_MS
           });
         }
       } catch (cause) {
@@ -149602,7 +150087,7 @@ var init_convert = __esm({
       for (const name of await readdir2(outDir)) {
         const match = /^p-0*(\d+)\.png$/.exec(name);
         if (match !== null) {
-          drawn.set(Number(match[1]), join7(outDir, name));
+          drawn.set(Number(match[1]), join8(outDir, name));
         }
       }
       return drawn;
@@ -149612,9 +150097,9 @@ var init_convert = __esm({
 
 // ../fileq/src/lib/render/render.ts
 import { createHash as createHash2 } from "node:crypto";
-import { copyFile, mkdir as mkdir2, mkdtemp as mkdtemp2, readFile as readFile15, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir2, mkdtemp as mkdtemp2, readFile as readFile15, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename5, join as join8 } from "node:path";
+import { basename as basename6, join as join9 } from "node:path";
 var RENDERED_DIR, DEFAULT_PAGE_CAP, DEFAULT_SIZE, VIA_OFFICE, SLIDES, NotRenderable, STAMP_FILE, defaultOutDir, readStamp, clearImages, ignoreInGit, pageCount, formatOf, choosePages, renderDocument;
 var init_render = __esm({
   "../fileq/src/lib/render/render.ts"() {
@@ -149638,14 +150123,14 @@ var init_render = __esm({
     defaultOutDir = (absPath, workspaceRoot2) => {
       const relPath = workspaceRoot2 === void 0 ? void 0 : relPathIn(workspaceRoot2, absPath);
       if (workspaceRoot2 !== void 0 && relPath !== void 0) {
-        return join8(workspaceRoot2, RENDERED_DIR, relPath);
+        return join9(workspaceRoot2, RENDERED_DIR, relPath);
       }
       const hash = createHash2("sha256").update(absPath).digest("hex").slice(0, 8);
-      return join8(toolOutDir("fileq"), "rendered", `${basename5(absPath).toLowerCase().replaceAll(/[^a-z0-9.]+/g, "-")}-${hash}`);
+      return join9(toolOutDir("fileq"), "rendered", `${basename6(absPath).toLowerCase().replaceAll(/[^a-z0-9.]+/g, "-")}-${hash}`);
     };
     readStamp = async (dir) => {
       try {
-        const parsed = JSON.parse(await readFile15(join8(dir, STAMP_FILE), "utf8"));
+        const parsed = JSON.parse(await readFile15(join9(dir, STAMP_FILE), "utf8"));
         return parsed.sha256 === void 0 || parsed.size === void 0 || parsed.total === void 0 ? void 0 : { sha256: parsed.sha256, size: parsed.size, total: parsed.total };
       } catch {
         return void 0;
@@ -149653,14 +150138,14 @@ var init_render = __esm({
     };
     clearImages = async (dir) => {
       const names = await listDir(dir);
-      await Promise.all(names.filter((name) => /^(?:slide|page)-\d+\.png$/.test(name)).map((name) => rm3(join8(dir, name), { force: true })));
+      await Promise.all(names.filter((name) => /^(?:slide|page)-\d+\.png$/.test(name)).map((name) => rm4(join9(dir, name), { force: true })));
     };
     ignoreInGit = async (workspaceRoot2, outDir) => {
-      if (workspaceRoot2 === void 0 || !outDir.startsWith(join8(workspaceRoot2, RENDERED_DIR))) {
+      if (workspaceRoot2 === void 0 || !outDir.startsWith(join9(workspaceRoot2, RENDERED_DIR))) {
         return;
       }
       try {
-        await writeFile2(join8(workspaceRoot2, RENDERED_DIR, ".gitignore"), "# fileq's rendered pages; regenerated on demand.\n*\n", { flag: "wx" });
+        await writeFile2(join9(workspaceRoot2, RENDERED_DIR, ".gitignore"), "# fileq's rendered pages; regenerated on demand.\n*\n", { flag: "wx" });
       } catch {
       }
     };
@@ -149715,16 +150200,16 @@ var init_render = __esm({
         const pages = choosePages(request, cached.total, unit, notes);
         const existing = new Set(await listDir(outDir));
         if (pages.every((page) => existing.has(`${unit}-${page}.png`))) {
-          return { format, unit, total: cached.total, images: pages.map((page) => ({ page, path: join8(outDir, `${unit}-${page}.png`) })), outDir, reused: true, notes };
+          return { format, unit, total: cached.total, images: pages.map((page) => ({ page, path: join9(outDir, `${unit}-${page}.png`) })), outDir, reused: true, notes };
         }
         notes.length = 0;
       }
-      const work = await mkdtemp2(join8(tmpdir2(), "fileq-render-"));
+      const work = await mkdtemp2(join9(tmpdir2(), "fileq-render-"));
       try {
         const pdf = binary === void 0 ? request.absPath : await toPdf(binary, request.absPath, format, work);
         const total = await pageCount(pdf);
         const pages = choosePages(request, total, unit, notes);
-        const raster = join8(work, "png");
+        const raster = join9(work, "png");
         await mkdir2(raster, { recursive: true });
         const drawn = await toPngs(tool, pdf, pages, request.size, raster);
         await mkdir2(outDir, { recursive: true });
@@ -149736,7 +150221,7 @@ var init_render = __esm({
         for (const page of pages) {
           const from = drawn.get(page);
           if (from !== void 0) {
-            const path = join8(outDir, `${unit}-${page}.png`);
+            const path = join9(outDir, `${unit}-${page}.png`);
             await copyFile(from, path);
             images.push({ page, path });
           }
@@ -149745,19 +150230,19 @@ var init_render = __esm({
           notes.push(`${pages.length - images.length} of the ${unit}s asked for drew nothing`);
         }
         if (request.outDir === void 0) {
-          await writeFile2(join8(outDir, STAMP_FILE), `${JSON.stringify({ sha256, size: request.size, total })}
+          await writeFile2(join9(outDir, STAMP_FILE), `${JSON.stringify({ sha256, size: request.size, total })}
 `);
         }
         return { format, unit, total, images, outDir, reused: false, notes };
       } finally {
-        await rm3(work, { recursive: true, force: true });
+        await rm4(work, { recursive: true, force: true });
       }
     };
   }
 });
 
 // ../fileq/src/commands/render.command.ts
-import { basename as basename6, resolve as resolve5 } from "node:path";
+import { basename as basename7, resolve as resolve6 } from "node:path";
 var failure, summary, renderCommand;
 var init_render_command = __esm({
   "../fileq/src/commands/render.command.ts"() {
@@ -149782,7 +150267,7 @@ var init_render_command = __esm({
     summary = (file, result) => {
       const drawn = result.images.map((image) => image.page);
       const fields = [
-        basename6(file),
+        basename7(file),
         result.format,
         `${result.total} ${result.unit}${result.total === 1 ? "" : "s"}`,
         drawn.length === 0 ? "nothing drawn" : `drew ${result.unit}${drawn.length === 1 ? "" : "s"} ${describePages(drawn)}`,
@@ -149805,12 +150290,12 @@ var init_render_command = __esm({
         }
       },
       async func(flags, file) {
-        const absPath = resolve5(file);
+        const absPath = resolve6(file);
         let result;
         try {
           const pages = flags.pages === void 0 ? void 0 : parsePages(flags.pages);
           const size = Math.max(64, Math.round(flags.size));
-          result = await renderDocument({ absPath, pages, outDir: flags.out === void 0 ? void 0 : resolve5(flags.out), size }, workspaceRoot());
+          result = await renderDocument({ absPath, pages, outDir: flags.out === void 0 ? void 0 : resolve6(flags.out), size }, workspaceRoot());
         } catch (cause) {
           const known = failure(cause);
           this.process.stdout.write(`fileq: cannot render ${absPath}: ${known?.message ?? errorMessage(cause)}