kordoc 1.7.0 → 1.7.2

package/dist/index.js

@@ -254,7 +254,7 @@ function tableToMarkdown(table) {
 }
 
 // src/utils.ts
-var VERSION = true ? "1.7.0" : "0.0.0-dev";
+var VERSION = true ? "1.7.2" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -1573,6 +1573,20 @@ function extractLines(fnArray, argsArray) {
   let currentPath = [];
   let pathStartX = 0, pathStartY = 0;
   let curX = 0, curY = 0;
+  function pushRectangle(path, rx, ry, rw, rh) {
+    if (Math.abs(rh) < ORIENTATION_TOL * 2) {
+      path.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
+    } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
+      path.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
+    } else {
+      path.push(
+        { x1: rx, y1: ry, x2: rx + rw, y2: ry },
+        { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
+        { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
+        { x1: rx, y1: ry + rh, x2: rx, y2: ry }
+      );
+    }
+  }
   function flushPath(isStroke) {
     if (!isStroke) {
       currentPath = [];
@@ -1591,49 +1605,78 @@ function extractLines(fnArray, argsArray) {
         lineWidth = args[0] || 1;
         break;
       case OPS.constructPath: {
-        const subOps = args[0];
-        const coords = args[1];
-        let ci = 0;
-        for (const subOp of subOps) {
-          if (subOp === OPS.moveTo) {
-            curX = coords[ci++];
-            curY = coords[ci++];
-            pathStartX = curX;
-            pathStartY = curY;
-          } else if (subOp === OPS.lineTo) {
-            const x2 = coords[ci++], y2 = coords[ci++];
-            currentPath.push({ x1: curX, y1: curY, x2, y2 });
-            curX = x2;
-            curY = y2;
-          } else if (subOp === OPS.rectangle) {
-            const rx = coords[ci++], ry = coords[ci++];
-            const rw = coords[ci++], rh = coords[ci++];
-            if (Math.abs(rh) < ORIENTATION_TOL * 2) {
-              currentPath.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
-            } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
-              currentPath.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
-            } else {
-              currentPath.push(
-                { x1: rx, y1: ry, x2: rx + rw, y2: ry },
-                // bottom
-                { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
-                // right
-                { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
-                // top
-                { x1: rx, y1: ry + rh, x2: rx, y2: ry }
-                // left
-              );
+        const arg0 = args[0];
+        if (Array.isArray(arg0)) {
+          const subOps = arg0;
+          const coords = args[1];
+          let ci = 0;
+          for (const subOp of subOps) {
+            if (subOp === OPS.moveTo) {
+              curX = coords[ci++];
+              curY = coords[ci++];
+              pathStartX = curX;
+              pathStartY = curY;
+            } else if (subOp === OPS.lineTo) {
+              const x2 = coords[ci++], y2 = coords[ci++];
+              currentPath.push({ x1: curX, y1: curY, x2, y2 });
+              curX = x2;
+              curY = y2;
+            } else if (subOp === OPS.rectangle) {
+              const rx = coords[ci++], ry = coords[ci++];
+              const rw = coords[ci++], rh = coords[ci++];
+              pushRectangle(currentPath, rx, ry, rw, rh);
+            } else if (subOp === OPS.closePath) {
+              if (curX !== pathStartX || curY !== pathStartY) {
+                currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+              }
+              curX = pathStartX;
+              curY = pathStartY;
+            } else if (subOp === OPS.curveTo) {
+              ci += 6;
+            } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
+              ci += 4;
             }
-          } else if (subOp === OPS.closePath) {
-            if (curX !== pathStartX || curY !== pathStartY) {
-              currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+          }
+        } else {
+          const afterOp = arg0;
+          const dataArr = args[1];
+          const pathData = dataArr?.[0];
+          if (pathData && typeof pathData === "object") {
+            const len = Object.keys(pathData).length;
+            let di = 0;
+            while (di < len) {
+              const drawOp = pathData[di++];
+              if (drawOp === 0 /* moveTo */) {
+                curX = pathData[di++];
+                curY = pathData[di++];
+                pathStartX = curX;
+                pathStartY = curY;
+              } else if (drawOp === 1 /* lineTo */) {
+                const x2 = pathData[di++], y2 = pathData[di++];
+                currentPath.push({ x1: curX, y1: curY, x2, y2 });
+                curX = x2;
+                curY = y2;
+              } else if (drawOp === 2 /* curveTo */) {
+                di += 6;
+              } else if (drawOp === 3 /* quadraticCurveTo */) {
+                di += 4;
+              } else if (drawOp === 4 /* closePath */) {
+                if (curX !== pathStartX || curY !== pathStartY) {
+                  currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+                }
+                curX = pathStartX;
+                curY = pathStartY;
+              } else {
+                break;
+              }
             }
-            curX = pathStartX;
-            curY = pathStartY;
-          } else if (subOp === OPS.curveTo) {
-            ci += 6;
-          } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
-            ci += 4;
+          }
+          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
+            flushPath(true);
+          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill || afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
+            flushPath(true);
+          } else if (afterOp === OPS.endPath) {
+            flushPath(false);
           }
         }
         break;