circuit-to-svg 0.0.164 → 0.0.166

package/dist/index.js

@@ -1442,6 +1442,72 @@ function getSoftwareUsedString(circuitJson) {
   return metadata?.software_used_string;
 }
 
+// package.json
+var package_default = {
+  name: "circuit-to-svg",
+  type: "module",
+  version: "0.0.165",
+  description: "Convert Circuit JSON to SVG",
+  main: "dist/index.js",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    start: "storybook dev -p 6006",
+    prepublish: "npm run build",
+    build: "tsup-node ./lib/index.ts --format esm --dts --sourcemap",
+    format: "biome format . --write",
+    "format:check": "biome format .",
+    storybook: "storybook dev -p 6006",
+    "build-storybook": "storybook build"
+  },
+  license: "ISC",
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@chromatic-com/storybook": "^1.6.1",
+    "@storybook/addon-essentials": "^8.2.5",
+    "@storybook/addon-interactions": "^8.2.5",
+    "@storybook/addon-links": "^8.2.5",
+    "@storybook/addon-onboarding": "^8.2.5",
+    "@storybook/blocks": "^8.2.5",
+    "@storybook/react": "^8.2.5",
+    "@storybook/react-vite": "^8.2.5",
+    "@storybook/test": "^8.2.5",
+    "@tscircuit/core": "0.0.477",
+    "@tscircuit/plop": "^0.0.10",
+    "@types/bun": "^1.2.8",
+    biome: "^0.3.3",
+    "bun-match-svg": "^0.0.6",
+    "circuit-json": "^0.0.218",
+    esbuild: "^0.20.2",
+    "performance-now": "^2.1.0",
+    react: "^18.3.1",
+    "schematic-symbols": "^0.0.153",
+    storybook: "^8.2.5",
+    tsup: "^8.0.2",
+    typescript: "^5.4.5",
+    "vite-tsconfig-paths": "^5.0.1",
+    "@tscircuit/checks": "^0.0.44",
+    "@tscircuit/circuit-json-util": "^0.0.47",
+    "@tscircuit/footprinter": "^0.0.91"
+  },
+  peerDependencies: {
+    "circuit-json": "*",
+    "@tscircuit/circuit-json-util": "*",
+    "@tscircuit/footprinter": "*",
+    "schematic-symbols": "*"
+  },
+  dependencies: {
+    "@types/node": "^22.5.5",
+    "bun-types": "^1.1.40",
+    svgson: "^5.3.1",
+    "transformation-matrix": "^2.16.1"
+  }
+};
+
+// lib/package-version.ts
+var CIRCUIT_TO_SVG_VERSION = package_default.version;
+
 // lib/pcb/convert-circuit-json-to-pcb-svg.ts
 var OBJECT_ORDER = [
   "pcb_trace_error",
@@ -1641,6 +1707,7 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   }
   children.push(...svgObjects);
   const softwareUsedString = getSoftwareUsedString(circuitJson);
+  const version = CIRCUIT_TO_SVG_VERSION;
   const svgObject = {
     name: "svg",
     type: "element",
@@ -1650,6 +1717,9 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       height: svgHeight.toString(),
       ...softwareUsedString && {
         "data-software-used-string": softwareUsedString
+      },
+      ...options?.includeVersion && {
+        "data-circuit-to-svg-version": version
       }
     },
     value: "",
@@ -2470,6 +2540,7 @@ function convertCircuitJsonToAssemblySvg(soup, options) {
     (a, b) => (OBJECT_ORDER2.indexOf(b.type) ?? 9999) - (OBJECT_ORDER2.indexOf(a.type) ?? 9999)
   ).flatMap((item) => createSvgObjects2(item, ctx, soup));
   const softwareUsedString = getSoftwareUsedString(soup);
+  const version = CIRCUIT_TO_SVG_VERSION;
   const svgObject = {
     name: "svg",
     type: "element",
@@ -2479,6 +2550,9 @@ function convertCircuitJsonToAssemblySvg(soup, options) {
       height: svgHeight.toString(),
       ...softwareUsedString && {
         "data-software-used-string": softwareUsedString
+      },
+      ...options?.includeVersion && {
+        "data-circuit-to-svg-version": version
       }
     },
     value: "",
@@ -2987,69 +3061,6 @@ function drawSchematicLabeledPoints(params) {
   };
 }
 
-// lib/utils/get-unit-vector-from-outside-to-edge.ts
-var getUnitVectorFromOutsideToEdge = (side) => {
-  switch (side) {
-    case "top":
-      return { x: 0, y: -1 };
-    case "bottom":
-      return { x: 0, y: 1 };
-    case "left":
-      return { x: 1, y: 0 };
-    case "right":
-      return { x: -1, y: 0 };
-  }
-  throw new Error(`Invalid side: ${side}`);
-};
-
-// lib/utils/net-label-utils.ts
-import "transformation-matrix";
-import "schematic-symbols";
-var ARROW_POINT_WIDTH_FSR = 0.3;
-var END_PADDING_FSR = 0.3;
-var END_PADDING_EXTRA_PER_CHARACTER_FSR = 0.06;
-var ninePointAnchorToTextAnchor = {
-  top_left: "start",
-  top_right: "end",
-  middle_left: "start",
-  middle_right: "end",
-  bottom_left: "start",
-  bottom_right: "end",
-  center: "middle",
-  middle_top: "middle",
-  middle_bottom: "middle"
-};
-var ninePointAnchorToDominantBaseline = {
-  top_left: "hanging",
-  top_right: "hanging",
-  bottom_left: "ideographic",
-  bottom_right: "ideographic",
-  center: "middle",
-  middle_left: "middle",
-  middle_right: "middle",
-  middle_top: "hanging",
-  middle_bottom: "ideographic"
-};
-function getPathRotation(anchorSide) {
-  const rotationMap = {
-    left: 180,
-    top: 90,
-    bottom: -90,
-    right: 0
-  };
-  return rotationMap[anchorSide] ?? 0;
-}
-function calculateAnchorPosition(schNetLabel, fontSizeMm, textWidthFSR) {
-  const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * schNetLabel.text.length + END_PADDING_FSR;
-  const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
-    schNetLabel.anchor_side
-  );
-  return schNetLabel.anchor_position ?? {
-    x: schNetLabel.center.x - realTextGrowthVec.x * fullWidthFsr * fontSizeMm / 2,
-    y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
-  };
-}
-
 // lib/sch/arial-text-metrics.ts
 var arialTextMetrics = {
   "0": {
@@ -3829,6 +3840,149 @@ var estimateTextWidth = (text) => {
   return totalWidth / 27;
 };
 
+// lib/sch/get-table-dimensions.ts
+var getTableDimensions = (schematicTable, circuitJson) => {
+  if (schematicTable.column_widths && schematicTable.column_widths.length > 0 && schematicTable.row_heights && schematicTable.row_heights.length > 0) {
+    const unitToMm = (v) => {
+      if (typeof v === "number") return v;
+      if (v.endsWith("mm")) return parseFloat(v);
+      if (v.endsWith("in")) return parseFloat(v) * 25.4;
+      return parseFloat(v);
+    };
+    return {
+      column_widths: schematicTable.column_widths.map(unitToMm),
+      row_heights: schematicTable.row_heights.map(unitToMm)
+    };
+  }
+  const cells = circuitJson.filter(
+    (elm) => elm.type === "schematic_table_cell" && elm.schematic_table_id === schematicTable.schematic_table_id
+  );
+  if (cells.length === 0) {
+    return { column_widths: [], row_heights: [] };
+  }
+  const numColumns = cells.reduce((max, c) => Math.max(max, c.end_column_index), -1) + 1;
+  const numRows = cells.reduce((max, c) => Math.max(max, c.end_row_index), -1) + 1;
+  const { cell_padding = 0.2 } = schematicTable;
+  const column_widths = new Array(numColumns).fill(0);
+  const row_heights = new Array(numRows).fill(0);
+  const cell_widths = {};
+  const cell_heights = {};
+  for (const cell of cells) {
+    const fontSizeMm = getSchMmFontSize("reference_designator", cell.font_size);
+    const textWidthMm = estimateTextWidth(cell.text ?? "") * fontSizeMm;
+    const requiredWidth = textWidthMm + 2 * cell_padding;
+    const requiredHeight = fontSizeMm * 1.2 + 2 * cell_padding;
+    const key = `${cell.start_row_index}-${cell.start_column_index}`;
+    cell_widths[key] = requiredWidth;
+    cell_heights[key] = requiredHeight;
+  }
+  for (let i = 0; i < numRows; i++) {
+    for (let j = 0; j < numColumns; j++) {
+      const key = `${i}-${j}`;
+      if (cell_widths[key] && cell_widths[key] > column_widths[j]) {
+        column_widths[j] = cell_widths[key];
+      }
+      if (cell_heights[key] && cell_heights[key] > row_heights[i]) {
+        row_heights[i] = cell_heights[key];
+      }
+    }
+  }
+  for (const cell of cells) {
+    if (cell.start_column_index === cell.end_column_index && cell.start_row_index === cell.end_row_index)
+      continue;
+    const key = `${cell.start_row_index}-${cell.start_column_index}`;
+    const requiredWidth = cell_widths[key];
+    const requiredHeight = cell_heights[key];
+    if (requiredWidth === void 0 || requiredHeight === void 0) continue;
+    let currentWidth = 0;
+    for (let i = cell.start_column_index; i <= cell.end_column_index; i++) {
+      currentWidth += column_widths[i];
+    }
+    if (requiredWidth > currentWidth) {
+      const diff = requiredWidth - currentWidth;
+      const extraPerColumn = diff / (cell.end_column_index - cell.start_column_index + 1);
+      for (let i = cell.start_column_index; i <= cell.end_column_index; i++) {
+        column_widths[i] += extraPerColumn;
+      }
+    }
+    let currentHeight = 0;
+    for (let i = cell.start_row_index; i <= cell.end_row_index; i++) {
+      currentHeight += row_heights[i];
+    }
+    if (requiredHeight > currentHeight) {
+      const diff = requiredHeight - currentHeight;
+      const extraPerRow = diff / (cell.end_row_index - cell.start_row_index + 1);
+      for (let i = cell.start_row_index; i <= cell.end_row_index; i++) {
+        row_heights[i] += extraPerRow;
+      }
+    }
+  }
+  return { column_widths, row_heights };
+};
+
+// lib/utils/get-unit-vector-from-outside-to-edge.ts
+var getUnitVectorFromOutsideToEdge = (side) => {
+  switch (side) {
+    case "top":
+      return { x: 0, y: -1 };
+    case "bottom":
+      return { x: 0, y: 1 };
+    case "left":
+      return { x: 1, y: 0 };
+    case "right":
+      return { x: -1, y: 0 };
+  }
+  throw new Error(`Invalid side: ${side}`);
+};
+
+// lib/utils/net-label-utils.ts
+import "transformation-matrix";
+import "schematic-symbols";
+var ARROW_POINT_WIDTH_FSR = 0.3;
+var END_PADDING_FSR = 0.3;
+var END_PADDING_EXTRA_PER_CHARACTER_FSR = 0.06;
+var ninePointAnchorToTextAnchor = {
+  top_left: "start",
+  top_right: "end",
+  middle_left: "start",
+  middle_right: "end",
+  bottom_left: "start",
+  bottom_right: "end",
+  center: "middle",
+  middle_top: "middle",
+  middle_bottom: "middle"
+};
+var ninePointAnchorToDominantBaseline = {
+  top_left: "hanging",
+  top_right: "hanging",
+  bottom_left: "ideographic",
+  bottom_right: "ideographic",
+  center: "middle",
+  middle_left: "middle",
+  middle_right: "middle",
+  middle_top: "hanging",
+  middle_bottom: "ideographic"
+};
+function getPathRotation(anchorSide) {
+  const rotationMap = {
+    left: 180,
+    top: 90,
+    bottom: -90,
+    right: 0
+  };
+  return rotationMap[anchorSide] ?? 0;
+}
+function calculateAnchorPosition(schNetLabel, fontSizeMm, textWidthFSR) {
+  const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * schNetLabel.text.length + END_PADDING_FSR;
+  const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
+    schNetLabel.anchor_side
+  );
+  return schNetLabel.anchor_position ?? {
+    x: schNetLabel.center.x - realTextGrowthVec.x * fullWidthFsr * fontSizeMm / 2,
+    y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
+  };
+}
+
 // lib/sch/get-schematic-bounds-from-circuit-json.ts
 function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
   let minX = Number.POSITIVE_INFINITY;
@@ -3889,6 +4043,30 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
         { width: item.width, height: item.height },
         0
       );
+    } else if (item.type === "schematic_table") {
+      const { column_widths, row_heights } = getTableDimensions(item, soup);
+      const totalWidth = column_widths.reduce((a, b) => a + b, 0);
+      const totalHeight = row_heights.reduce((a, b) => a + b, 0);
+      const anchor = item.anchor ?? "center";
+      let topLeftX = item.anchor_position.x;
+      let topLeftY = item.anchor_position.y;
+      if (anchor.includes("center")) {
+        topLeftX -= totalWidth / 2;
+      } else if (anchor.includes("right")) {
+        topLeftX -= totalWidth;
+      }
+      if (anchor.includes("center")) {
+        topLeftY += totalHeight / 2;
+      } else if (anchor.includes("bottom")) {
+        topLeftY += totalHeight;
+      }
+      const centerX = topLeftX + totalWidth / 2;
+      const centerY = topLeftY - totalHeight / 2;
+      updateBounds(
+        { x: centerX, y: centerY },
+        { width: totalWidth, height: totalHeight },
+        0
+      );
     }
   }
   minX -= padding;
@@ -5412,6 +5590,206 @@ var createSvgObjectsFromSchematicBox = ({
   ];
 };
 
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-table.ts
+import { applyToPoint as applyToPoint42 } from "transformation-matrix";
+var createSvgObjectsFromSchematicTable = ({
+  schematicTable,
+  transform,
+  colorMap: colorMap2,
+  circuitJson
+}) => {
+  const {
+    anchor_position,
+    border_width = 0.05,
+    anchor = "center"
+  } = schematicTable;
+  const { column_widths, row_heights } = getTableDimensions(
+    schematicTable,
+    circuitJson
+  );
+  const totalWidth = column_widths.reduce((a, b) => a + b, 0);
+  const totalHeight = row_heights.reduce((a, b) => a + b, 0);
+  let topLeftX = anchor_position.x;
+  let topLeftY = anchor_position.y;
+  if (anchor.includes("center")) {
+    topLeftX -= totalWidth / 2;
+  } else if (anchor.includes("right")) {
+    topLeftX -= totalWidth;
+  }
+  if (anchor.includes("center")) {
+    topLeftY += totalHeight / 2;
+  } else if (anchor.includes("bottom")) {
+    topLeftY += totalHeight;
+  }
+  const svgObjects = [];
+  const borderStrokeWidth = border_width * Math.abs(transform.a);
+  const gridStrokeWidth = getSchStrokeSize(transform);
+  const [screenTopLeftX, screenTopLeftY] = applyToPoint42(transform, [
+    topLeftX,
+    topLeftY
+  ]);
+  const [screenBottomRightX, screenBottomRightY] = applyToPoint42(transform, [
+    topLeftX + totalWidth,
+    topLeftY - totalHeight
+  ]);
+  svgObjects.push({
+    name: "rect",
+    type: "element",
+    attributes: {
+      x: screenTopLeftX.toString(),
+      y: screenTopLeftY.toString(),
+      width: (screenBottomRightX - screenTopLeftX).toString(),
+      height: (screenBottomRightY - screenTopLeftY).toString(),
+      fill: "none",
+      stroke: "#666",
+      "stroke-width": borderStrokeWidth.toString()
+    },
+    children: [],
+    value: ""
+  });
+  const cells = circuitJson.filter(
+    (elm) => elm.type === "schematic_table_cell" && elm.schematic_table_id === schematicTable.schematic_table_id
+  );
+  let currentX = topLeftX;
+  for (let i = 0; i < column_widths.length - 1; i++) {
+    currentX += column_widths[i];
+    let segmentStartY = topLeftY;
+    for (let j = 0; j < row_heights.length; j++) {
+      const segmentEndY = segmentStartY - row_heights[j];
+      const isMerged = cells.some(
+        (cell) => cell.start_column_index <= i && cell.end_column_index > i && cell.start_row_index <= j && cell.end_row_index >= j
+      );
+      if (!isMerged) {
+        const start = applyToPoint42(transform, { x: currentX, y: segmentStartY });
+        const end = applyToPoint42(transform, { x: currentX, y: segmentEndY });
+        svgObjects.push({
+          name: "line",
+          type: "element",
+          attributes: {
+            x1: start.x.toString(),
+            y1: start.y.toString(),
+            x2: end.x.toString(),
+            y2: end.y.toString(),
+            stroke: "#666",
+            "stroke-width": gridStrokeWidth.toString()
+          },
+          children: [],
+          value: ""
+        });
+      }
+      segmentStartY = segmentEndY;
+    }
+  }
+  let currentY = topLeftY;
+  for (let i = 0; i < row_heights.length - 1; i++) {
+    currentY -= row_heights[i];
+    let segmentStartX = topLeftX;
+    for (let j = 0; j < column_widths.length; j++) {
+      const segmentEndX = segmentStartX + column_widths[j];
+      const isMerged = cells.some(
+        (cell) => cell.start_row_index <= i && cell.end_row_index > i && cell.start_column_index <= j && cell.end_column_index >= j
+      );
+      if (!isMerged) {
+        const start = applyToPoint42(transform, {
+          x: segmentStartX,
+          y: currentY
+        });
+        const end = applyToPoint42(transform, { x: segmentEndX, y: currentY });
+        svgObjects.push({
+          name: "line",
+          type: "element",
+          attributes: {
+            x1: start.x.toString(),
+            y1: start.y.toString(),
+            x2: end.x.toString(),
+            y2: end.y.toString(),
+            stroke: "#666",
+            "stroke-width": gridStrokeWidth.toString()
+          },
+          children: [],
+          value: ""
+        });
+      }
+      segmentStartX = segmentEndX;
+    }
+  }
+  for (const cell of cells) {
+    if (cell.text) {
+      const cellWidth = column_widths.slice(cell.start_column_index, cell.end_column_index + 1).reduce((a, b) => a + b, 0);
+      const cellHeight = row_heights.slice(cell.start_row_index, cell.end_row_index + 1).reduce((a, b) => a + b, 0);
+      const cellTopLeftX = topLeftX + column_widths.slice(0, cell.start_column_index).reduce((a, b) => a + b, 0);
+      const cellTopLeftY = topLeftY - row_heights.slice(0, cell.start_row_index).reduce((a, b) => a + b, 0);
+      const { cell_padding = 0.2 } = schematicTable;
+      const horizontal_align = cell.horizontal_align ?? "center";
+      const vertical_align = cell.vertical_align ?? "middle";
+      let realTextAnchorPos = {
+        x: cellTopLeftX + cellWidth / 2,
+        y: cellTopLeftY - cellHeight / 2
+      };
+      if (horizontal_align === "left") {
+        realTextAnchorPos.x = cellTopLeftX + cell_padding;
+      } else if (horizontal_align === "right") {
+        realTextAnchorPos.x = cellTopLeftX + cellWidth - cell_padding;
+      }
+      if (vertical_align === "top") {
+        realTextAnchorPos.y = cellTopLeftY - cell_padding;
+      } else if (vertical_align === "bottom") {
+        realTextAnchorPos.y = cellTopLeftY - cellHeight + cell_padding;
+      }
+      const screenTextAnchorPos = applyToPoint42(transform, realTextAnchorPos);
+      const fontSize = getSchScreenFontSize(
+        transform,
+        "reference_designator",
+        cell.font_size
+      );
+      const textAnchorMap = {
+        left: "start",
+        center: "middle",
+        right: "end"
+      };
+      const dominantBaselineMap = {
+        top: "hanging",
+        middle: "middle",
+        bottom: "ideographic"
+      };
+      svgObjects.push({
+        name: "text",
+        type: "element",
+        attributes: {
+          x: screenTextAnchorPos.x.toString(),
+          y: screenTextAnchorPos.y.toString(),
+          "font-size": `${fontSize}px`,
+          "text-anchor": textAnchorMap[horizontal_align],
+          "dominant-baseline": dominantBaselineMap[vertical_align],
+          fill: colorMap2.schematic.sheet_label,
+          "font-family": "sans-serif"
+        },
+        children: [
+          {
+            type: "text",
+            value: cell.text,
+            name: "",
+            attributes: {},
+            children: []
+          }
+        ],
+        value: ""
+      });
+    }
+  }
+  return [
+    {
+      name: "g",
+      type: "element",
+      attributes: {
+        "data-schematic-table-id": schematicTable.schematic_table_id
+      },
+      children: svgObjects,
+      value: ""
+    }
+  ];
+};
+
 // lib/sch/convert-circuit-json-to-schematic-svg.ts
 function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const realBounds = getSchematicBoundsFromCircuitJson(circuitJson);
@@ -5482,6 +5860,7 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const schText = [];
   const voltageProbeSvgs = [];
   const schBoxSvgs = [];
+  const schTableSvgs = [];
   for (const elm of circuitJson) {
     if (elm.type === "schematic_debug_object") {
       schDebugObjectSvgs.push(
@@ -5539,6 +5918,15 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
           colorMap: colorMap2
         })
       );
+    } else if (elm.type === "schematic_table") {
+      schTableSvgs.push(
+        ...createSvgObjectsFromSchematicTable({
+          schematicTable: elm,
+          transform,
+          colorMap: colorMap2,
+          circuitJson
+        })
+      );
     }
   }
   svgChildren.push(
@@ -5548,7 +5936,8 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     ...schNetLabel,
     ...schText,
     ...schBoxSvgs,
-    ...voltageProbeSvgs
+    ...voltageProbeSvgs,
+    ...schTableSvgs
   );
   if (options?.labeledPoints) {
     svgChildren.push(
@@ -5559,6 +5948,7 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     );
   }
   const softwareUsedString = getSoftwareUsedString(circuitJson);
+  const version = CIRCUIT_TO_SVG_VERSION;
   const svgObject = {
     name: "svg",
     type: "element",
@@ -5570,6 +5960,9 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
       "data-real-to-screen-transform": toSVG(transform),
       ...softwareUsedString && {
         "data-software-used-string": softwareUsedString
+      },
+      ...options?.includeVersion && {
+        "data-circuit-to-svg-version": version
       }
     },
     children: [
@@ -5621,18 +6014,18 @@ var circuitJsonToSchematicSvg = convertCircuitJsonToSchematicSvg;
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
 import { stringify as stringify4 } from "svgson";
 import {
-  applyToPoint as applyToPoint44,
+  applyToPoint as applyToPoint45,
   compose as compose11,
   scale as scale8,
   translate as translate11
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/convert-circuit-json-to-solder-paste-mask.ts
-import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint44 } from "transformation-matrix";
 function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
   const { transform, layer: layerFilter } = ctx;
   if (layerFilter && solderPaste.layer !== layerFilter) return [];
-  const [x, y] = applyToPoint43(transform, [solderPaste.x, solderPaste.y]);
+  const [x, y] = applyToPoint44(transform, [solderPaste.x, solderPaste.y]);
   if (solderPaste.shape === "rect" || solderPaste.shape === "rotated_rect") {
     const width = solderPaste.width * Math.abs(transform.a);
     const height = solderPaste.height * Math.abs(transform.d);
@@ -5757,6 +6150,7 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
     (a, b) => (OBJECT_ORDER3.indexOf(b.type) ?? 9999) - (OBJECT_ORDER3.indexOf(a.type) ?? 9999)
   ).flatMap((item) => createSvgObjects3({ elm: item, ctx }));
   const softwareUsedString = getSoftwareUsedString(circuitJson);
+  const version = CIRCUIT_TO_SVG_VERSION;
   const svgObject = {
     name: "svg",
     type: "element",
@@ -5766,6 +6160,9 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
       height: svgHeight.toString(),
       ...softwareUsedString && {
         "data-software-used-string": softwareUsedString
+      },
+      ...options.includeVersion && {
+        "data-circuit-to-svg-version": version
       }
     },
     value: "",
@@ -5831,8 +6228,8 @@ function createSvgObjects3({ elm, ctx }) {
   }
 }
 function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint44(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint44(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint45(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint45(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);
@@ -5855,6 +6252,7 @@ function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
   };
 }
 export {
+  CIRCUIT_TO_SVG_VERSION,
   circuitJsonToPcbSvg,
   circuitJsonToSchematicSvg,
   convertCircuitJsonToAssemblySvg,