easyeda 0.0.39 → 0.0.41

package/dist/{chunk-PIHMKST6.js → chunk-RNEHSTL4.js}

@@ -4,263 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// lib/schemas/package-detail-shape-schema.ts
-import { z } from "zod";
-var tenthmil = z.union([z.number(), z.string()]).optional().transform(
-  (n) => typeof n === "string" && n.endsWith("mil") ? n : `${Number.parseFloat(n) * 10}mil`
-).pipe(z.string());
-var PointSchema = z.any().transform((p) => {
-  if (Array.isArray(p)) {
-    const [x, y] = p;
-    return { x, y };
-  } else if (typeof p === "object") {
-    return p;
-  }
-  throw new Error(`Invalid point: ${p}`);
-}).pipe(
-  z.object({
-    x: z.number(),
-    y: z.number()
-  })
-);
-var BaseShapeSchema = z.object({
-  type: z.string(),
-  id: z.string().optional(),
-  layer: z.coerce.number().optional()
-});
-var TrackSchema = BaseShapeSchema.extend({
-  type: z.literal("TRACK"),
-  width: z.coerce.number(),
-  points: z.array(PointSchema)
-});
-var PadSchema = BaseShapeSchema.extend({
-  type: z.literal("PAD"),
-  shape: z.enum(["RECT", "ELLIPSE", "OVAL"]),
-  center: z.object({
-    x: tenthmil,
-    y: tenthmil
-  }),
-  width: tenthmil,
-  height: tenthmil,
-  layermask: z.number(),
-  net: z.union([z.string(), z.number()]).optional(),
-  number: z.union([z.string(), z.number()]),
-  holeRadius: tenthmil,
-  points: z.array(PointSchema).optional(),
-  rotation: z.number().optional(),
-  plated: z.boolean()
-});
-var ArcSchema = BaseShapeSchema.extend({
-  type: z.literal("ARC"),
-  width: z.number(),
-  start: PointSchema,
-  end: PointSchema,
-  radiusX: z.number(),
-  radiusY: z.number(),
-  largeArc: z.boolean(),
-  sweepDirection: z.enum(["CW", "CCW"])
-});
-var CircleSchema = BaseShapeSchema.extend({
-  type: z.literal("CIRCLE"),
-  center: PointSchema,
-  radius: z.number(),
-  width: z.number()
-});
-var SolidRegionSchema = BaseShapeSchema.extend({
-  type: z.literal("SOLIDREGION"),
-  layermask: z.number(),
-  points: z.array(PointSchema),
-  fillStyle: z.string()
-});
-var SVGNodeSchema = BaseShapeSchema.extend({
-  type: z.literal("SVGNODE"),
-  svgData: z.object({
-    gId: z.string(),
-    nodeName: z.string(),
-    nodeType: z.number(),
-    layerid: z.string(),
-    attrs: z.record(z.string(), z.string()),
-    childNodes: z.array(z.unknown())
-  })
-});
-var HoleSchema = BaseShapeSchema.extend({
-  type: z.literal("HOLE"),
-  center: PointSchema,
-  radius: z.number()
-});
-var RectSchema = BaseShapeSchema.extend({
-  type: z.literal("RECT"),
-  x: tenthmil,
-  y: tenthmil,
-  width: tenthmil,
-  height: tenthmil,
-  lineWidth: z.number(),
-  fillStyle: z.string(),
-  rotation: z.number().optional()
-});
-var PackageDetailShapeSchema = z.discriminatedUnion("type", [
-  TrackSchema,
-  PadSchema,
-  ArcSchema,
-  CircleSchema,
-  SolidRegionSchema,
-  SVGNodeSchema,
-  HoleSchema,
-  RectSchema
-]);
-var pairs = (arr) => {
-  const pairs2 = [];
-  for (let i = 0; i < arr.length; i += 2) {
-    pairs2.push([arr[i], arr[i + 1]]);
-  }
-  return pairs2;
-};
-var parsePoints = (pointsStr) => pairs(
-  pointsStr.trim().split(" ").map((n) => Number(n))
-);
-var ShapeItemSchema = z.object({
-  type: z.string(),
-  data: z.string()
-}).transform((shape) => {
-  const [firstParam, ...restParams] = shape.data.split("~");
-  const lastParam = restParams.pop();
-  switch (shape.type) {
-    case "TRACK": {
-      const [width, layer, _, pointsStr, id, _n] = shape.data.split("~");
-      const points = parsePoints(pointsStr);
-      return TrackSchema.parse({ type: "TRACK", width, layer, points, id });
-    }
-    case "PAD": {
-      const [padShape, ...params] = shape.data.split("~");
-      const [
-        centerX,
-        centerY,
-        width,
-        height,
-        layermask,
-        net,
-        number,
-        holeRadius,
-        ...rest
-      ] = params.map((p) => isNaN(Number(p)) ? p : Number(p));
-      const center = { x: centerX, y: centerY };
-      let points, rotation2;
-      if (padShape === "RECT") {
-        points = parsePoints(rest[0]);
-        rotation2 = Number(rest[1]);
-      }
-      const padInputParams = {
-        type: "PAD",
-        shape: padShape,
-        center,
-        width,
-        height,
-        layermask,
-        net,
-        number,
-        holeRadius,
-        points,
-        rotation: rotation2,
-        plated: rest.includes("Y")
-      };
-      const pad = PadSchema.parse(padInputParams);
-      return pad;
-    }
-    case "ARC": {
-      const [width, layer, , arcData] = shape.data.split("~");
-      const [
-        ,
-        startX,
-        startY,
-        radiusX,
-        radiusY,
-        xAxisRotation,
-        largeArcFlag,
-        sweepFlag,
-        endX,
-        endY
-      ] = arcData.match(
-        /M\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*A\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*([\d.]+)\s*([01])\s*([01])\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)/
-      );
-      const start = [Number(startX), Number(startY)];
-      const end = [Number(endX), Number(endY)];
-      return ArcSchema.parse({
-        type: "ARC",
-        width: Number(width),
-        layer: Number(layer),
-        start,
-        end,
-        radiusX: Number(radiusX),
-        radiusY: Number(radiusY),
-        largeArc: largeArcFlag === "1",
-        sweepDirection: sweepFlag === "1" ? "CW" : "CCW"
-      });
-    }
-    case "CIRCLE": {
-      const [centerX, centerY, radius, width, layer, id] = shape.data.split("~");
-      const center = [Number(centerX), Number(centerY)];
-      return CircleSchema.parse({
-        type: "CIRCLE",
-        center,
-        radius: Number(radius),
-        width: Number(width),
-        layer: Number(layer),
-        id
-      });
-    }
-    case "HOLE": {
-      const [centerX, centerY, radius, id] = shape.data.split("~");
-      const center = [Number(centerX), Number(centerY)];
-      return HoleSchema.parse({
-        type: "HOLE",
-        center,
-        radius: Number(radius),
-        id
-      });
-    }
-    case "SOLIDREGION": {
-      const [layermask, , pathData, fillStyle, id] = shape.data.split("~");
-      const points = pathData.match(/[ML] ?(-?[\d.]+)[ ,](-?[\d.]+)/g)?.map((point2) => {
-        const [, x, y] = point2.match(/[ML]? ?(-?[\d.]+)[ ,](-?[\d.]+)/) || [];
-        return [Number(x), Number(y)];
-      }) || [];
-      return SolidRegionSchema.parse({
-        type: "SOLIDREGION",
-        layermask: Number(layermask),
-        points,
-        fillStyle,
-        id
-      });
-    }
-    case "SVGNODE": {
-      const svgData = JSON.parse(shape.data);
-      return SVGNodeSchema.parse({ type: "SVGNODE", svgData });
-    }
-    case "RECT": {
-      const [x, y, width, height, lineWidth, id, rotation2, layer, fillStyle] = shape.data.split("~");
-      return RectSchema.parse({
-        type: "RECT",
-        x,
-        y,
-        width,
-        height,
-        lineWidth: Number(lineWidth),
-        id,
-        rotation: rotation2 ? Number(rotation2) : void 0,
-        layer: layer ? Number(layer) : void 0,
-        fillStyle: fillStyle || void 0
-      });
-    }
-    default:
-      throw new Error(`Unknown shape type: ${shape.type}`);
-      return BaseShapeSchema.parse({ type: shape.type });
-  }
-}).pipe(PackageDetailShapeSchema);
-var ShapesArraySchema = z.array(ShapeItemSchema);
-
-// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-import "zod";
-
 // node_modules/circuit-json/dist/index.mjs
 var dist_exports = {};
 __export(dist_exports, {
@@ -343,8 +86,8 @@ __export(dist_exports, {
   visible_layer: () => visible_layer,
   voltage: () => voltage
 });
+import { z } from "zod";
 import { z as z2 } from "zod";
-import { z as z22 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
 import { z as z5 } from "zod";
@@ -396,7 +139,7 @@ import { z as z18 } from "zod";
 import { z as z19 } from "zod";
 import { z as z20 } from "zod";
 import { z as z21 } from "zod";
-import { z as z222 } from "zod";
+import { z as z22 } from "zod";
 import { z as z23 } from "zod";
 import { z as z24 } from "zod";
 import { z as z25 } from "zod";
@@ -582,15 +325,15 @@ var parseAndConvertSiUnit = (v) => {
     value: conversionFactor * Number.parseFloat(value)
   };
 };
-var resistance = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var capacitance = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var inductance = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var voltage = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var length = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var resistance = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var capacitance = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var inductance = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var voltage = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var length = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
 var distance = length;
-var current = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var time = z2.string().or(z2.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var rotation = z2.string().or(z2.number()).transform((arg) => {
+var current = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var time = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var rotation = z.string().or(z.number()).transform((arg) => {
   if (typeof arg === "number") return arg;
   if (arg.endsWith("deg")) {
     return Number.parseFloat(arg.split("deg")[0]);
@@ -600,7 +343,7 @@ var rotation = z2.string().or(z2.number()).transform((arg) => {
   }
   return Number.parseFloat(arg);
 });
-var point = z22.object({
+var point = z2.object({
   x: distance,
   y: distance
 });
@@ -705,9 +448,9 @@ var source_net = z21.object({
   is_analog_signal: z21.boolean().optional(),
   trace_width: z21.number().optional()
 });
-var schematic_box = z222.object({
-  type: z222.literal("schematic_box"),
-  schematic_component_id: z222.string(),
+var schematic_box = z22.object({
+  type: z22.literal("schematic_box"),
+  schematic_component_id: z22.string(),
   width: distance,
   height: distance,
   x: distance,
@@ -1544,7 +1287,7 @@ var transformPCBElements = (elms, matrix) => {
 };
 
 // lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-import { scale, translate } from "transformation-matrix";
+import { compose, scale, translate } from "transformation-matrix";
 
 // lib/compute-center-offset.ts
 import { mm } from "@tscircuit/mm";
@@ -1566,6 +1309,16 @@ var computeCenterOffset = (easyeda) => {
 
 // lib/convert-easyeda-json-to-tscircuit-soup-json.ts
 import { mm as mm2 } from "@tscircuit/mm";
+var mil2mm = (mil) => {
+  if (typeof mil === "number") return mm2(`${mil}mil`);
+  if (mil.match(/^\d+$/)) return mm2(`${mil}mil`);
+  return mm2(mil);
+};
+var milx10 = (mil10) => {
+  if (typeof mil10 === "number") return mil2mm(mil10) * 10;
+  if (mil10.match(/^\d+$/)) return mil2mm(mil10) * 10;
+  return mil2mm(mil10);
+};
 var handleSilkscreenPath = (track, index) => {
   return pcb_silkscreen_path.parse({
     type: "pcb_silkscreen_path",
@@ -1573,7 +1326,10 @@ var handleSilkscreenPath = (track, index) => {
     pcb_component_id: "pcb_component_1",
     layer: "top",
     // Assuming all silkscreen is on top layer
-    route: track.points.map((point2) => ({ x: point2.x, y: point2.y })),
+    route: track.points.map((point2) => ({
+      x: milx10(point2.x),
+      y: milx10(point2.y)
+    })),
     stroke_width: track.width
   });
 };
@@ -1593,8 +1349,21 @@ var handleSilkscreenArc = (arc, index) => {
     pcb_component_id: "pcb_component_1",
     layer: "top",
     // Assuming all silkscreen is on top layer
-    route: arcPath,
-    stroke_width: arc.width
+    route: arcPath.map((p) => ({
+      x: milx10(p.x),
+      y: milx10(p.y)
+    })),
+    stroke_width: mm2(arc.width)
+  });
+};
+var handleHole = (hole, index) => {
+  return pcb_hole.parse({
+    type: "pcb_hole",
+    x: milx10(hole.center.x),
+    y: milx10(hole.center.y),
+    hole_diameter: milx10(hole.radius) * 2,
+    hole_shape: "circle",
+    pcb_hole_id: `pcb_hole_${index + 1}`
   });
 };
 var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
@@ -1629,17 +1398,17 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
       source_component_id: "source_component_1",
       name: portNumber
     });
-    if (pad.holeRadius !== void 0 && mm2(pad.holeRadius) !== 0) {
+    if (pad.holeRadius !== void 0 && mil2mm(pad.holeRadius) !== 0) {
       soupElements.push(
         pcb_plated_hole.parse({
           type: "pcb_plated_hole",
           pcb_plated_hole_id: `pcb_plated_hole_${index + 1}`,
           shape: "circle",
-          x: mm2(pad.center.x),
-          y: mm2(pad.center.y),
-          hole_diameter: mm2(pad.holeRadius) * 2,
-          outer_diameter: mm2(pad.width),
-          radius: mm2(pad.holeRadius),
+          x: mil2mm(pad.center.x),
+          y: mil2mm(pad.center.y),
+          hole_diameter: mil2mm(pad.holeRadius) * 2,
+          outer_diameter: mil2mm(pad.width),
+          radius: mil2mm(pad.holeRadius),
           port_hints: [portNumber],
           pcb_component_id: "pcb_component_1",
           pcb_port_id: `pcb_port_${index + 1}`,
@@ -1658,22 +1427,26 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
       if (!soupShape) {
         throw new Error(`unknown pad.shape: "${pad.shape}"`);
       }
-      soupElements.push(
-        pcb_smtpad.parse({
-          type: "pcb_smtpad",
-          pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
-          shape: soupShape,
-          x: mm2(pad.center.x),
-          y: mm2(pad.center.y),
-          ...soupShape === "rect" ? { width: mm2(pad.width), height: mm2(pad.height) } : { radius: Math.min(mm2(pad.width), mm2(pad.height)) / 2 },
-          layer: "top",
-          port_hints: [portNumber],
-          pcb_component_id: "pcb_component_1",
-          pcb_port_id: `pcb_port_${index + 1}`
-        })
-      );
+      const parsedPcbSmtpad = pcb_smtpad.parse({
+        type: "pcb_smtpad",
+        pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
+        shape: soupShape,
+        x: mil2mm(pad.center.x),
+        y: mil2mm(pad.center.y),
+        ...soupShape === "rect" ? { width: mil2mm(pad.width), height: mil2mm(pad.height) } : { radius: Math.min(mil2mm(pad.width), mil2mm(pad.height)) / 2 },
+        layer: "top",
+        port_hints: [portNumber],
+        pcb_component_id: "pcb_component_1",
+        pcb_port_id: `pcb_port_${index + 1}`
+      });
+      soupElements.push(parsedPcbSmtpad);
     }
   });
+  easyEdaJson.packageDetail.dataStr.shape.filter(
+    (shape) => shape.type === "HOLE"
+  ).forEach((h, index) => {
+    soupElements.push(handleHole(h, index));
+  });
   easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
     if (shape.type === "TRACK") {
       soupElements.push(handleSilkscreenPath(shape, index));
@@ -1704,7 +1477,7 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
   if (shouldRecenter) {
     transformPCBElements(
       soupElements,
-      translate(-centerOffset.x, centerOffset.y)
+      compose(translate(-centerOffset.x, centerOffset.y), scale(1, -1))
     );
   }
   return soupElements;
@@ -1762,6 +1535,260 @@ async function fetchEasyEDAComponent(jlcpcbPartNumber) {
 // lib/schemas/easy-eda-json-schema.ts
 import { z as z61 } from "zod";
 
+// lib/schemas/package-detail-shape-schema.ts
+import { z as z59 } from "zod";
+var tenthmil = z59.union([z59.number(), z59.string()]).optional().transform(
+  (n) => typeof n === "string" && n.endsWith("mil") ? n : `${Number.parseFloat(n) * 10}mil`
+).pipe(z59.string());
+var PointSchema = z59.any().transform((p) => {
+  if (Array.isArray(p)) {
+    const [x, y] = p;
+    return { x, y };
+  } else if (typeof p === "object") {
+    return p;
+  }
+  throw new Error(`Invalid point: ${p}`);
+}).pipe(
+  z59.object({
+    x: z59.number(),
+    y: z59.number()
+  })
+);
+var BaseShapeSchema = z59.object({
+  type: z59.string(),
+  id: z59.string().optional(),
+  layer: z59.coerce.number().optional()
+});
+var TrackSchema = BaseShapeSchema.extend({
+  type: z59.literal("TRACK"),
+  width: z59.coerce.number(),
+  points: z59.array(PointSchema)
+});
+var PadSchema = BaseShapeSchema.extend({
+  type: z59.literal("PAD"),
+  shape: z59.enum(["RECT", "ELLIPSE", "OVAL"]),
+  center: z59.object({
+    x: tenthmil,
+    y: tenthmil
+  }),
+  width: tenthmil,
+  height: tenthmil,
+  layermask: z59.number(),
+  net: z59.union([z59.string(), z59.number()]).optional(),
+  number: z59.union([z59.string(), z59.number()]),
+  holeRadius: tenthmil,
+  points: z59.array(PointSchema).optional(),
+  rotation: z59.number().optional(),
+  plated: z59.boolean()
+});
+var ArcSchema = BaseShapeSchema.extend({
+  type: z59.literal("ARC"),
+  width: z59.number(),
+  start: PointSchema,
+  end: PointSchema,
+  radiusX: z59.number(),
+  radiusY: z59.number(),
+  largeArc: z59.boolean(),
+  sweepDirection: z59.enum(["CW", "CCW"])
+});
+var CircleSchema = BaseShapeSchema.extend({
+  type: z59.literal("CIRCLE"),
+  center: PointSchema,
+  radius: z59.number(),
+  width: z59.number()
+});
+var SolidRegionSchema = BaseShapeSchema.extend({
+  type: z59.literal("SOLIDREGION"),
+  layermask: z59.number(),
+  points: z59.array(PointSchema),
+  fillStyle: z59.string()
+});
+var SVGNodeSchema = BaseShapeSchema.extend({
+  type: z59.literal("SVGNODE"),
+  svgData: z59.object({
+    gId: z59.string(),
+    nodeName: z59.string(),
+    nodeType: z59.number(),
+    layerid: z59.string(),
+    attrs: z59.record(z59.string(), z59.string()),
+    childNodes: z59.array(z59.unknown())
+  })
+});
+var HoleSchema = BaseShapeSchema.extend({
+  type: z59.literal("HOLE"),
+  center: PointSchema,
+  radius: z59.number()
+});
+var RectSchema = BaseShapeSchema.extend({
+  type: z59.literal("RECT"),
+  x: tenthmil,
+  y: tenthmil,
+  width: tenthmil,
+  height: tenthmil,
+  lineWidth: z59.number(),
+  fillStyle: z59.string(),
+  rotation: z59.number().optional()
+});
+var PackageDetailShapeSchema = z59.discriminatedUnion("type", [
+  TrackSchema,
+  PadSchema,
+  ArcSchema,
+  CircleSchema,
+  SolidRegionSchema,
+  SVGNodeSchema,
+  HoleSchema,
+  RectSchema
+]);
+var pairs = (arr) => {
+  const pairs2 = [];
+  for (let i = 0; i < arr.length; i += 2) {
+    pairs2.push([arr[i], arr[i + 1]]);
+  }
+  return pairs2;
+};
+var parsePoints = (pointsStr) => pairs(
+  pointsStr.trim().split(" ").map((n) => Number(n))
+);
+var ShapeItemSchema = z59.object({
+  type: z59.string(),
+  data: z59.string()
+}).transform((shape) => {
+  const [firstParam, ...restParams] = shape.data.split("~");
+  const lastParam = restParams.pop();
+  switch (shape.type) {
+    case "TRACK": {
+      const [width, layer, _, pointsStr, id, _n] = shape.data.split("~");
+      const points = parsePoints(pointsStr);
+      return TrackSchema.parse({ type: "TRACK", width, layer, points, id });
+    }
+    case "PAD": {
+      const [padShape, ...params] = shape.data.split("~");
+      const [
+        centerX,
+        centerY,
+        width,
+        height,
+        layermask,
+        net,
+        number,
+        holeRadius,
+        ...rest
+      ] = params.map((p) => isNaN(Number(p)) ? p : Number(p));
+      const center = { x: centerX, y: centerY };
+      let points, rotation2;
+      if (padShape === "RECT") {
+        points = parsePoints(rest[0]);
+        rotation2 = Number(rest[1]);
+      }
+      const padInputParams = {
+        type: "PAD",
+        shape: padShape,
+        center,
+        width,
+        height,
+        layermask,
+        net,
+        number,
+        holeRadius,
+        points,
+        rotation: rotation2,
+        plated: rest.includes("Y")
+      };
+      const pad = PadSchema.parse(padInputParams);
+      return pad;
+    }
+    case "ARC": {
+      const [width, layer, , arcData] = shape.data.split("~");
+      const [
+        ,
+        startX,
+        startY,
+        radiusX,
+        radiusY,
+        xAxisRotation,
+        largeArcFlag,
+        sweepFlag,
+        endX,
+        endY
+      ] = arcData.match(
+        /M\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*A\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*([\d.]+)\s*([01])\s*([01])\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)/
+      );
+      const start = [Number(startX), Number(startY)];
+      const end = [Number(endX), Number(endY)];
+      return ArcSchema.parse({
+        type: "ARC",
+        width: Number(width),
+        layer: Number(layer),
+        start,
+        end,
+        radiusX: Number(radiusX),
+        radiusY: Number(radiusY),
+        largeArc: largeArcFlag === "1",
+        sweepDirection: sweepFlag === "1" ? "CW" : "CCW"
+      });
+    }
+    case "CIRCLE": {
+      const [centerX, centerY, radius, width, layer, id] = shape.data.split("~");
+      const center = [Number(centerX), Number(centerY)];
+      return CircleSchema.parse({
+        type: "CIRCLE",
+        center,
+        radius: Number(radius),
+        width: Number(width),
+        layer: Number(layer),
+        id
+      });
+    }
+    case "HOLE": {
+      const [centerX, centerY, radius, id] = shape.data.split("~");
+      const center = [Number(centerX), Number(centerY)];
+      return HoleSchema.parse({
+        type: "HOLE",
+        center,
+        radius: Number(radius),
+        id
+      });
+    }
+    case "SOLIDREGION": {
+      const [layermask, , pathData, fillStyle, id] = shape.data.split("~");
+      const points = pathData.match(/[ML] ?(-?[\d.]+)[ ,](-?[\d.]+)/g)?.map((point2) => {
+        const [, x, y] = point2.match(/[ML]? ?(-?[\d.]+)[ ,](-?[\d.]+)/) || [];
+        return [Number(x), Number(y)];
+      }) || [];
+      return SolidRegionSchema.parse({
+        type: "SOLIDREGION",
+        layermask: Number(layermask),
+        points,
+        fillStyle,
+        id
+      });
+    }
+    case "SVGNODE": {
+      const svgData = JSON.parse(shape.data);
+      return SVGNodeSchema.parse({ type: "SVGNODE", svgData });
+    }
+    case "RECT": {
+      const [x, y, width, height, lineWidth, id, rotation2, layer, fillStyle] = shape.data.split("~");
+      return RectSchema.parse({
+        type: "RECT",
+        x,
+        y,
+        width,
+        height,
+        lineWidth: Number(lineWidth),
+        id,
+        rotation: rotation2 ? Number(rotation2) : void 0,
+        layer: layer ? Number(layer) : void 0,
+        fillStyle: fillStyle || void 0
+      });
+    }
+    default:
+      throw new Error(`Unknown shape type: ${shape.type}`);
+      return BaseShapeSchema.parse({ type: shape.type });
+  }
+}).pipe(PackageDetailShapeSchema);
+var ShapesArraySchema = z59.array(ShapeItemSchema);
+
 // lib/schemas/single-letter-shape-schema.ts
 import { z as z60 } from "zod";
 var PointSchema2 = z60.object({
@@ -2299,4 +2326,4 @@ export {
   convertRawEasyEdaToTs,
   convertEasyEdaJsonToVariousFormats
 };
-//# sourceMappingURL=chunk-PIHMKST6.js.map
+//# sourceMappingURL=chunk-RNEHSTL4.js.map