@poe-platform/safe-bash 0.1.757 → 0.1.758

package/dist/safe-bash-command-ssconvert/index.js

@@ -198781,7 +198781,7 @@ var ParsedCosDocument = class {
     return void 0;
   }
 };
-function parseNodeFromLexer(lexer, bytes, maxDepth, recoverEmptyObject = false) {
+function parseNodeFromLexer(lexer, bytes, maxDepth, repair = false) {
   const stack = [];
   while (true) {
     const tok = lexer.nextToken();
@@ -198790,7 +198790,7 @@ function parseNodeFromLexer(lexer, bytes, maxDepth, recoverEmptyObject = false)
       if (!parent) return void 0;
       throw new PdfError2("E_PARSE", parent.kind === "array" ? "Unterminated PDF array" : "Unterminated PDF dictionary");
     }
-    if (!parent && recoverEmptyObject && tok.kind === "keyword" && tok.value === "endobj") {
+    if (!parent && repair && tok.kind === "keyword" && tok.value === "endobj") {
       return { kind: "null", span: tok.span };
     }
     let node3;
@@ -198805,6 +198805,7 @@ function parseNodeFromLexer(lexer, bytes, maxDepth, recoverEmptyObject = false)
         parent.key = { kind: "name", rawBytes: tok.rawBytes, decoded: tok.decoded, span: tok.span };
         continue;
       } else {
+        if (repair) continue;
         throw new PdfError2("E_PARSE", `Expected dictionary key /Name, got ${tok.kind}`);
       }
     } else {
@@ -198973,7 +198974,7 @@ function parseHeaderVersion(bytes) {
   }
   return head.slice(idx + 5, idx + 8);
 }
-function parseObjectAtOffset(bytes, offset, maxRecursionDepth, recoverEmptyObject = false) {
+function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
   const lexer = new CosByteLexer(bytes, offset);
   const objNumTok = lexer.nextToken();
   const genNumTok = lexer.nextToken();
@@ -198981,7 +198982,7 @@ function parseObjectAtOffset(bytes, offset, maxRecursionDepth, recoverEmptyObjec
   if (objNumTok?.kind !== "number" || genNumTok?.kind !== "number" || objKwTok?.kind !== "keyword" || objKwTok.value !== "obj") {
     throw new PdfError2("E_PARSE", `Malformed indirect object header at byte offset ${offset}`);
   }
-  const value3 = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, recoverEmptyObject);
+  const value3 = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, repair);
   if (!value3) {
     throw new PdfError2("E_PARSE", `Empty indirect object ${objNumTok.value} at offset ${offset}`);
   }
@@ -199170,7 +199171,7 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
         try {
           const token = lexer.nextToken();
           if (token?.kind === "keyword" && token.value === "trailer") {
-            const trailer = parseNodeFromLexer(lexer, bytes, maxRecursionDepth);
+            const trailer = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, true);
             if (trailer?.kind === "dict") trailers.push(trailer);
             pos = lexer.offset;
             continue;
@@ -199226,7 +199227,7 @@ function unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRe
       const t = dictGet(obj.value.dict, "Type");
       if (t?.kind === "name" && t.decoded === "ObjStm") {
         try {
-          for (const [unpackedNum, unpackedVal] of unpackObjectStream(obj.value, maxDecompressedBytes, maxRecursionDepth).entries()) {
+          for (const [unpackedNum, unpackedVal] of unpackObjectStream(obj.value, maxDecompressedBytes, maxRecursionDepth, true).entries()) {
             if (!objects.has(unpackedNum)) {
               objects.set(unpackedNum, {
                 objectNumber: unpackedNum,
@@ -199262,7 +199263,7 @@ function recoveredReferences(objects) {
   }
   return { ...rootRef ? { rootRef } : {}, ...infoRef ? { infoRef } : {} };
 }
-function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth) {
+function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth, repair = false) {
   const nNode = dictGet(streamObj.dict, "N");
   const firstNode = dictGet(streamObj.dict, "First");
   if (nNode?.kind !== "number" || firstNode?.kind !== "number") {
@@ -199282,7 +199283,7 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth)
   for (const pair of pairs) {
     try {
       const valLexer = new CosByteLexer(decoded, firstNode.value + pair.relativeOffset);
-      const node3 = parseNodeFromLexer(valLexer, decoded, maxRecursionDepth);
+      const node3 = parseNodeFromLexer(valLexer, decoded, maxRecursionDepth, repair);
       if (node3) {
         result2.set(pair.objectNumber, node3);
       }
@@ -199465,7 +199466,7 @@ function parseCosDocument(bytes, options = {}) {
       if (!unpacked) {
         const stmObj = objects.get(entry2.objectStreamNumber)?.value;
         if (stmObj?.kind === "stream") {
-          unpacked = unpackObjectStream(stmObj, maxDecompressedBytes, maxRecursionDepth);
+          unpacked = unpackObjectStream(stmObj, maxDecompressedBytes, maxRecursionDepth, recovery === "repair");
           objStmCache.set(entry2.objectStreamNumber, unpacked);
         }
       }
@@ -207937,7 +207938,11 @@ function resolvePageFonts(doc, resourcesDict) {
     let cmap;
     const toUniNode = doc.resolve(dictGet(fObj, "ToUnicode"));
     if (toUniNode?.kind === "stream") {
-      cmap = parseToUnicodeCMap(doc.decodeStream(toUniNode));
+      try {
+        cmap = parseToUnicodeCMap(doc.decodeStream(toUniNode));
+      } catch (error2) {
+        if (error2 instanceof PdfError2 && error2.code === "E_LIMIT") throw error2;
+      }
     }
     const encNode = doc.resolve(dictGet(fObj, "Encoding"));
     if (encNode?.kind === "dict") {
@@ -209061,8 +209066,12 @@ function evaluateContentStreamToDisplayList(params) {
   const images = [];
   const operations = [];
   const emit = (operation) => {
-    const clipPaths = curState().clipPaths;
-    if (clipPaths) operation = { ...operation, value: { ...operation.value, clipPaths } };
+    const { clipPaths, clipImages } = curState();
+    if (clipPaths || clipImages) operation = { ...operation, value: {
+      ...operation.value,
+      ...clipPaths ? { clipPaths } : {},
+      ...clipImages ? { clipImages } : {}
+    } };
     operations.push(operation);
     switch (operation.kind) {
       case "path":
@@ -209326,6 +209335,18 @@ function evaluateContentStreamToDisplayList(params) {
   let hasTextClip = false;
   let activeTm = [1, 0, 0, 1, 0, 0];
   let activeTlm = [1, 0, 0, 1, 0, 0];
+  const paintImage = (image, patternMask, resources, activeFonts, depth) => {
+    if (!patternMask) {
+      emit({ kind: "image", value: image });
+      return;
+    }
+    const st = curState();
+    stateStack.push({ ...st, clipImages: [...st.clipImages ?? [], image] });
+    walkNodes([{ kind: "path-op", paint: "f", segments: [
+      { kind: "rect", x: 0, y: 0, width: 1, height: 1 }
+    ] }], void 0, void 0, resources, activeFonts, depth);
+    stateStack.pop();
+  };
   const walkNodes = (nodes, mcid, actualText, activeResources = params.resourcesDict, activeFonts = fonts, depth = 0) => {
     for (const node3 of nodes) {
       switch (node3.kind) {
@@ -209509,7 +209530,8 @@ function evaluateContentStreamToDisplayList(params) {
                     st.fillAlpha,
                     "PatternShading_" + st.fillPatternName,
                     patClip,
-                    shading?.kind === "stream" ? shading : void 0
+                    shading?.kind === "stream" ? shading : void 0,
+                    st.blendMode
                   );
                   if (shImg) {
                     emit({ kind: "image", value: shImg });
@@ -209618,18 +209640,20 @@ function evaluateContentStreamToDisplayList(params) {
               const subNode = params.cosDoc.resolve(dictGet(xobjNode.dict, "Subtype"));
               const sub = subNode?.kind === "name" ? subNode.decoded : "";
               if (sub === "Image") {
+                const maskNode = params.cosDoc.resolve(dictGet(xobjNode.dict, "ImageMask"));
+                const patternMask = !!st.fillPatternName && maskNode?.kind === "boolean" && maskNode.value;
                 const decoded = decodeXObjectImageToRgba(
                   params.cosDoc,
                   xobjNode,
                   activeResources,
-                  {
+                  patternMask ? { r: 1, g: 1, b: 1, alpha: 1 } : {
                     r: st.fillColor.r,
                     g: st.fillColor.g,
                     b: st.fillColor.b,
                     alpha: st.fillAlpha
                   }
                 );
-                emit({ kind: "image", value: {
+                paintImage({
                   name: node3.name,
                   matrix: [...st.ctm],
                   width: decoded.width,
@@ -209639,7 +209663,7 @@ function evaluateContentStreamToDisplayList(params) {
                   decodedRgba: decoded.rgba,
                   ...st.blendMode && st.blendMode !== "Normal" ? { blendMode: st.blendMode } : {},
                   ...st.clipRect ? { clipRect: [...st.clipRect] } : {}
-                } });
+                }, patternMask, activeResources, activeFonts, depth);
               } else if (sub === "Form" && depth < 8) {
                 const formStreamBytes = params.cosDoc.decodeStream(xobjNode);
                 const formNodes = parseContentStream(formStreamBytes);
@@ -209695,19 +209719,22 @@ function evaluateContentStreamToDisplayList(params) {
         }
         case "inline-image": {
           const st = curState();
+          const maskEntry = dictGet(node3.dict, "ImageMask") ?? dictGet(node3.dict, "IM");
+          const maskNode = params.cosDoc ? params.cosDoc.resolve(maskEntry) : maskEntry;
+          const patternMask = !!st.fillPatternName && maskNode?.kind === "boolean" && maskNode.value;
           const decoded = decodeInlineImageNodeToRgba(
             params.cosDoc,
             node3.dict,
             node3.data,
             activeResources,
-            {
+            patternMask ? { r: 1, g: 1, b: 1, alpha: 1 } : {
               r: st.fillColor.r,
               g: st.fillColor.g,
               b: st.fillColor.b,
               alpha: st.fillAlpha
             }
           );
-          emit({ kind: "image", value: {
+          paintImage({
             name: "InlineImage",
             matrix: [...st.ctm],
             width: decoded.width,
@@ -209717,7 +209744,7 @@ function evaluateContentStreamToDisplayList(params) {
             decodedRgba: decoded.rgba,
             ...st.blendMode && st.blendMode !== "Normal" ? { blendMode: st.blendMode } : {},
             ...st.clipRect ? { clipRect: [...st.clipRect] } : {}
-          } });
+          }, patternMask, activeResources, activeFonts, depth);
           break;
         }
         case "text-object": {
@@ -213067,6 +213094,7 @@ function renderDisplayListToBitmap(displayList, options = {}) {
   const aaVec = options.antialiasVector !== false;
   const aaTxt = options.antialiasText !== false;
   const clipMasks = /* @__PURE__ */ new Map();
+  const imageClipMasks = /* @__PURE__ */ new Map();
   for (const original of paintOperations(displayList)) {
     if (original.kind === "glyph" && (original.value.renderMode === 3 || !original.value.outline && !original.value.unicode.trim())) continue;
     const operation = original.kind === "glyph" ? { kind: "path", value: glyphPaint(original.value) } : original;
@@ -213081,6 +213109,31 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       }
       clipMasks.set(clips, clipMask);
     }
+    const imageClips = original.value.clipImages;
+    if (imageClips) {
+      let imageMask = imageClipMasks.get(imageClips);
+      if (!imageMask) {
+        imageMask = new Uint8Array(width2 * height * 4).fill(255);
+        for (const image of imageClips) {
+          const layer = renderDisplayListToBitmap({
+            ...displayList,
+            rotation: 0,
+            paths: [],
+            glyphs: [],
+            images: [image],
+            operations: [{ kind: "image", value: image }]
+          }, { scale: scale2, transparent: true }).data;
+          for (let i = 3; i < layer.length; i += 4) imageMask[i] = Math.round(imageMask[i] * layer[i] / 255);
+        }
+        imageClipMasks.set(imageClips, imageMask);
+      }
+      if (clipMask) {
+        clipMask = clipMask.slice();
+        for (let i = 3; i < clipMask.length; i += 4) clipMask[i] = Math.round(clipMask[i] * imageMask[i] / 255);
+      } else {
+        clipMask = imageMask;
+      }
+    }
     if (operation.kind === "path") {
       const path2 = operation.value;
       if (path2.fillColor) {
@@ -233295,209 +233348,216 @@ function createDatabaseFunctions(query) {
     }
   }])));
 }
-function createSsconvertCommand(options = {}) {
-  const configured = { ...options };
-  if (configured.replace !== void 0 && typeof configured.replace !== "boolean")
-    throw new TypeError("ssconvert replace must be boolean");
-  const binding = {
-    ...configured,
-    ...configured.io === void 0 ? {} : { io: Object.freeze({
-      ...configured.io.descriptors === void 0 ? {} : { descriptors: Object.freeze(Object.fromEntries(
-        Object.entries(configured.io.descriptors).map(([key, descriptor3]) => [key, Object.freeze({ ...descriptor3 })])
-      )) },
-      ...configured.io.adapters === void 0 ? {} : { adapters: Object.freeze({ ...configured.io.adapters }) },
-      ...configured.io.transport === void 0 ? {} : { transport: Object.freeze({
-        authorize: configured.io.transport.authorize.bind(configured.io.transport),
-        request: configured.io.transport.request.bind(configured.io.transport),
-        redirects: configured.io.transport.redirects
-      }) }
-    }) },
-    ...configured.runtimeFunctions === void 0 ? {} : { runtimeFunctions: snapshotRuntimeFunctions(configured.runtimeFunctions) },
-    ...configured.profile === void 0 ? {} : { profile: Object.freeze({
-      ...configured.profile,
-      ...configured.profile.groups === void 0 ? {} : { groups: Object.freeze({ ...configured.profile.groups }) },
-      ...configured.profile.configurationRoots === void 0 ? {} : {
-        configurationRoots: Object.freeze({ ...configured.profile.configurationRoots })
-      }
-    }) },
-    codecs: Object.freeze([...configured.codecs ?? []]),
-    ...configured.formats === void 0 ? {} : { formats: snapshotFormats(configured.formats) },
-    limits: Object.freeze({ ...defaultSsconvertLimits, ...configured.limits }),
-    environment: Object.freeze({
-      locale: "C",
-      timezone: "UTC",
-      ...configured.environment,
-      env: Object.freeze({ ...configured.environment?.env })
-    })
-  };
-  const command = {
-    name: "ssconvert",
-    description: "Explicitly bound TypeScript spreadsheet conversion engine",
-    async execute(context) {
-      context.signal.throwIfAborted();
-      const owner = createOutputOperation(context, { async write() {
-      } });
-      const inputBytes = Math.min(
-        binding.limits.inputBytes,
-        context.inputBudget?.maxBytes ?? Infinity
-      );
-      let stdout;
-      const standardOutput = { async write(bytes) {
-        stdout ??= owner.child(context.stdout);
-        await stdout.output.write(bytes);
-      } };
-      let stderr;
-      const standardError = { async write(bytes) {
-        stderr ??= owner.child(context.stderr);
-        await stderr.output.write(bytes);
-      } };
-      const openOutput = createVfsOutput(context.fs, async (path2, bytes, signal) => {
-        await owner.acquire(() => writeFileOutput(
-          context,
-          bytes,
-          async (data3) => {
-            const capabilities = await context.fs.capabilitiesFor?.(path2, { signal }) ?? context.fs.capabilities;
-            signal.throwIfAborted();
-            if (context.fs.writeStream && capabilities.streamingWrite !== false)
-              await context.fs.writeStream(path2, (async function* () {
-                yield data3;
-              })(), { signal });
-            else await context.fs.writeFile(path2, data3, { signal });
-          }
-        ), () => {
-        });
-      }, (cleanup) => retainFileSystemCleanup(
-        context.fs,
-        (view2) => cleanup((path2) => view2.rm(path2)),
-        { maxOperations: 1 }
-      ));
-      let engine;
-      try {
-        const cwd = await owner.acquire(() => resolveVfsCwd(context.cwd, context.env.PWD, context.fs, owner.signal), () => {
-        });
-        engine = createEngine2({
-          ...binding,
-          environment: {
-            ...binding.environment,
-            cwd,
-            env: Object.freeze({ ...context.env })
-          },
-          limits: { ...binding.limits, inputBytes },
-          filesystem: createResourceIO({
-            ...binding.io,
-            cwd,
-            descriptors: {
-              ...binding.io?.descriptors,
-              0: { source: context.stdin },
-              1: { sink: standardOutput }
+function createCommandBindings(createEngine3, compatibilityDefaults = false) {
+  function createSsconvertCommand2(options = {}) {
+    const configured = { ...options };
+    if (configured.replace !== void 0 && typeof configured.replace !== "boolean")
+      throw new TypeError("ssconvert replace must be boolean");
+    const binding = {
+      ...configured,
+      ...configured.io === void 0 ? {} : { io: Object.freeze({
+        ...configured.io.descriptors === void 0 ? {} : { descriptors: Object.freeze(Object.fromEntries(
+          Object.entries(configured.io.descriptors).map(([key, descriptor3]) => [key, Object.freeze({ ...descriptor3 })])
+        )) },
+        ...configured.io.adapters === void 0 ? {} : { adapters: Object.freeze({ ...configured.io.adapters }) },
+        ...configured.io.transport === void 0 ? {} : { transport: Object.freeze({
+          authorize: configured.io.transport.authorize.bind(configured.io.transport),
+          request: configured.io.transport.request.bind(configured.io.transport),
+          redirects: configured.io.transport.redirects
+        }) }
+      }) },
+      ...configured.runtimeFunctions === void 0 ? {} : { runtimeFunctions: snapshotRuntimeFunctions(configured.runtimeFunctions) },
+      ...configured.profile === void 0 ? {} : { profile: Object.freeze({
+        ...configured.profile,
+        ...configured.profile.groups === void 0 ? {} : { groups: Object.freeze({ ...configured.profile.groups }) },
+        ...configured.profile.configurationRoots === void 0 ? {} : {
+          configurationRoots: Object.freeze({ ...configured.profile.configurationRoots })
+        }
+      }) },
+      codecs: Object.freeze([...configured.codecs ?? []]),
+      ...configured.formats === void 0 ? {} : { formats: snapshotFormats(configured.formats) },
+      limits: Object.freeze({ ...defaultSsconvertLimits, ...configured.limits }),
+      environment: Object.freeze({
+        locale: "C",
+        timezone: "UTC",
+        ...configured.environment,
+        env: Object.freeze({ ...configured.environment?.env })
+      })
+    };
+    const command = {
+      name: "ssconvert",
+      description: "Explicitly bound TypeScript spreadsheet conversion engine",
+      async execute(context) {
+        context.signal.throwIfAborted();
+        const owner = createOutputOperation(context, { async write() {
+        } });
+        const inputBytes = Math.min(
+          binding.limits.inputBytes,
+          context.inputBudget?.maxBytes ?? Infinity
+        );
+        let stdout;
+        const standardOutput = { async write(bytes) {
+          stdout ??= owner.child(context.stdout);
+          await stdout.output.write(bytes);
+        } };
+        let stderr;
+        const standardError = { async write(bytes) {
+          stderr ??= owner.child(context.stderr);
+          await stderr.output.write(bytes);
+        } };
+        const openOutput = createVfsOutput(context.fs, async (path2, bytes, signal) => {
+          await owner.acquire(() => writeFileOutput(
+            context,
+            bytes,
+            async (data3) => {
+              const capabilities = await context.fs.capabilitiesFor?.(path2, { signal }) ?? context.fs.capabilities;
+              signal.throwIfAborted();
+              if (context.fs.writeStream && capabilities.streamingWrite !== false)
+                await context.fs.writeStream(path2, (async function* () {
+                  yield data3;
+                })(), { signal });
+              else await context.fs.writeFile(path2, data3, { signal });
+            }
+          ), () => {
+          });
+        }, (cleanup) => retainFileSystemCleanup(
+          context.fs,
+          (view2) => cleanup((path2) => view2.rm(path2)),
+          { maxOperations: 1 }
+        ));
+        let engine;
+        try {
+          const cwd = await owner.acquire(() => resolveVfsCwd(context.cwd, context.env.PWD, context.fs, owner.signal), () => {
+          });
+          engine = createEngine3({
+            ...binding,
+            environment: {
+              ...binding.environment,
+              cwd,
+              env: Object.freeze({ ...context.env })
             },
-            filesystem: {
-              openOutput,
-              async read(uri, signal) {
-                try {
-                  const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
-                  signal.throwIfAborted();
-                  if (context.fs.readStream && capabilities.streamingRead !== false)
-                    return context.fs.readStream(uri, { signal });
-                  const bytes = await owner.acquire(
-                    () => context.fs.readFile(uri, {
-                      signal,
-                      ...inputBytes === Infinity ? {} : { maxBytes: inputBytes }
-                    }),
-                    () => {
-                    }
-                  );
-                  context.inputBudget?.check(bytes.byteLength);
-                  return [bytes];
-                } catch (error2) {
-                  signal.throwIfAborted();
-                  throw error2;
-                }
+            limits: { ...binding.limits, inputBytes },
+            filesystem: createResourceIO({
+              ...binding.io,
+              cwd,
+              descriptors: {
+                ...binding.io?.descriptors,
+                0: { source: context.stdin },
+                1: { sink: standardOutput }
               },
-              async write(uri, bytes, signal) {
-                try {
-                  await owner.acquire(
-                    () => writeFileOutput(context, bytes, async (data3) => {
-                      const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
-                      signal.throwIfAborted();
-                      if (context.fs.writeStream && capabilities.streamingWrite !== false)
-                        await context.fs.writeStream(uri, (async function* () {
-                          yield data3;
-                        })(), { signal });
-                      else await context.fs.writeFile(uri, data3, { signal });
-                    }),
-                    () => {
-                    }
-                  );
-                } catch (error2) {
-                  signal.throwIfAborted();
-                  throw error2;
+              filesystem: {
+                openOutput,
+                async read(uri, signal) {
+                  try {
+                    const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
+                    signal.throwIfAborted();
+                    if (context.fs.readStream && capabilities.streamingRead !== false)
+                      return context.fs.readStream(uri, { signal });
+                    const bytes = await owner.acquire(
+                      () => context.fs.readFile(uri, {
+                        signal,
+                        ...inputBytes === Infinity ? {} : { maxBytes: inputBytes }
+                      }),
+                      () => {
+                      }
+                    );
+                    context.inputBudget?.check(bytes.byteLength);
+                    return [bytes];
+                  } catch (error2) {
+                    signal.throwIfAborted();
+                    throw error2;
+                  }
+                },
+                async write(uri, bytes, signal) {
+                  try {
+                    await owner.acquire(
+                      () => writeFileOutput(context, bytes, async (data3) => {
+                        const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
+                        signal.throwIfAborted();
+                        if (context.fs.writeStream && capabilities.streamingWrite !== false)
+                          await context.fs.writeStream(uri, (async function* () {
+                            yield data3;
+                          })(), { signal });
+                        else await context.fs.writeFile(uri, data3, { signal });
+                      }),
+                      () => {
+                      }
+                    );
+                  } catch (error2) {
+                    signal.throwIfAborted();
+                    throw error2;
+                  }
                 }
               }
+            })
+          });
+          const maximumArguments = binding.limits.argumentBytes ?? Infinity;
+          const values2 = context.argumentValues?.values ?? context.args;
+          let argumentBytes = 0;
+          let refusal;
+          if (values2.length > maximumArguments) refusal = "ssconvert arguments limit exceeded";
+          for (const value3 of values2) {
+            if (refusal) break;
+            if (typeof value3 === "string" && value3.length > maximumArguments - argumentBytes) {
+              refusal = "ssconvert argument bytes limit exceeded";
+              break;
             }
-          })
-        });
-        const maximumArguments = binding.limits.argumentBytes ?? Infinity;
-        const values2 = context.argumentValues?.values ?? context.args;
-        let argumentBytes = 0;
-        let refusal;
-        if (values2.length > maximumArguments) refusal = "ssconvert arguments limit exceeded";
-        for (const value3 of values2) {
-          if (refusal) break;
-          if (typeof value3 === "string" && value3.length > maximumArguments - argumentBytes) {
-            refusal = "ssconvert argument bytes limit exceeded";
-            break;
+            argumentBytes += shellValueByteLength(value3);
+            if (argumentBytes > maximumArguments) refusal = "ssconvert argument bytes limit exceeded";
           }
-          argumentBytes += shellValueByteLength(value3);
-          if (argumentBytes > maximumArguments) refusal = "ssconvert argument bytes limit exceeded";
-        }
-        if (refusal) {
-          await standardError.write(new TextEncoder().encode(`${refusal}
+          if (refusal) {
+            await standardError.write(new TextEncoder().encode(`${refusal}
 `));
-          owner.signal.throwIfAborted();
-          return { exitCode: 1 };
-        }
-        const carrier = getCommandArguments(context);
-        return await runCommand(
-          carrier.args.map((_, index2) => carrier.bytes(index2)),
-          engine,
-          {
-            signal: owner.signal,
-            ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault },
-            stdout: standardOutput,
-            stderr: standardError,
-            registerCleanup: (cleanup) => owner.registerCleanup(cleanup)
-          },
-          binding.profile
-        );
-      } finally {
-        try {
-          await engine?.dispose();
+            owner.signal.throwIfAborted();
+            return { exitCode: 1 };
+          }
+          const carrier = getCommandArguments(context);
+          return await runCommand(
+            carrier.args.map((_, index2) => carrier.bytes(index2)),
+            engine,
+            {
+              signal: owner.signal,
+              ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault },
+              stdout: standardOutput,
+              stderr: standardError,
+              registerCleanup: (cleanup) => owner.registerCleanup(cleanup)
+            },
+            binding.profile
+          );
         } finally {
-          await owner.close();
+          try {
+            await engine?.dispose();
+          } finally {
+            await owner.close();
+          }
         }
       }
+    };
+    if (compatibilityDefaults && Object.entries(configured).every(([key, value3]) => key === "replace" || value3 === void 0)) {
+      builtInDirectContextExecutors.add(command.execute);
     }
-  };
-  if (Object.entries(configured).every(([key, value3]) => key === "replace" || value3 === void 0)) {
-    builtInDirectContextExecutors.add(command.execute);
+    return command;
   }
-  return command;
-}
-function ssconvertCommands(options = {}) {
-  const commands = createSsconvertCommands(options), replace = options.replace ?? false;
-  return {
-    name: "ssconvert-commands",
-    setup(host) {
-      if (!replace && commands.some((command) => host.commands.has(command.name)))
-        throw new Error("Command already registered: ssconvert");
-      for (const command of commands) host.commands.register(command, { replace });
-    }
-  };
-}
-function createSsconvertCommands(options = {}) {
-  return Object.freeze([createSsconvertCommand(options)]);
+  function ssconvertCommands2(options = {}) {
+    const commands = createSsconvertCommands2(options), replace = options.replace ?? false;
+    return {
+      name: "ssconvert-commands",
+      setup(host) {
+        if (!replace && commands.some((command) => host.commands.has(command.name)))
+          throw new Error("Command already registered: ssconvert");
+        for (const command of commands) host.commands.register(command, { replace });
+      }
+    };
+  }
+  function createSsconvertCommands2(options = {}) {
+    return Object.freeze([createSsconvertCommand2(options)]);
+  }
+  return { createSsconvertCommand: createSsconvertCommand2, createSsconvertCommands: createSsconvertCommands2, ssconvertCommands: ssconvertCommands2 };
 }
+var bindings = createCommandBindings(createEngine2, true);
+var createSsconvertCommand = bindings.createSsconvertCommand;
+var createSsconvertCommands = bindings.createSsconvertCommands;
+var ssconvertCommands = bindings.ssconvertCommands;
 function parseSimpleSeparatedRows(text2, sep) {
   const rows = [];
   let row = [];