easyeda 0.0.31 → 0.0.32

package/dist/{lib/index.cjs → chunk-3ZPJFTXV.js}

@@ -1,62 +1,15 @@
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// lib/index.ts
-var lib_exports = {};
-__export(lib_exports, {
-  BBoxSchema: () => BBoxSchema,
-  DataStrSchema: () => DataStrSchema,
-  EasyEdaJsonSchema: () => EasyEdaJsonSchema,
-  HeadSchema: () => HeadSchema,
-  LayerItemSchema: () => LayerItemSchema,
-  LcscSchema: () => LcscSchema,
-  ObjectItemSchema: () => ObjectItemSchema,
-  OwnerSchema: () => OwnerSchema,
-  PackageDetailDataStrSchema: () => PackageDetailDataStrSchema,
-  PackageDetailSchema: () => PackageDetailSchema,
-  SzlcscSchema: () => SzlcscSchema,
-  convertEasyEdaJsonToCircuitJson: () => convertEasyEdaJsonToCircuitJson,
-  convertEasyEdaJsonToTscircuitSoupJson: () => convertEasyEdaJsonToTscircuitSoupJson,
-  convertEasyEdaJsonToVariousFormats: () => convertEasyEdaJsonToVariousFormats,
-  convertRawEasyEdaToTs: () => convertRawEasyEdaToTs,
-  fetchEasyEDAComponent: () => fetchEasyEDAComponent,
-  maybeNumber: () => maybeNumber,
-  normalizeManufacturerPartNumber: () => normalizeManufacturerPartNumber
-});
-module.exports = __toCommonJS(lib_exports);
 
 // lib/schemas/package-detail-shape-schema.ts
-var import_zod = require("zod");
-var tenthmil = import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional().transform(
+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(import_zod.z.string());
-var PointSchema = import_zod.z.any().transform((p) => {
+).pipe(z.string());
+var PointSchema = z.any().transform((p) => {
   if (Array.isArray(p)) {
     const [x, y] = p;
     return { x, y };
@@ -65,87 +18,87 @@ var PointSchema = import_zod.z.any().transform((p) => {
   }
   throw new Error(`Invalid point: ${p}`);
 }).pipe(
-  import_zod.z.object({
-    x: import_zod.z.number(),
-    y: import_zod.z.number()
+  z.object({
+    x: z.number(),
+    y: z.number()
   })
 );
-var BaseShapeSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  id: import_zod.z.string().optional(),
-  layer: import_zod.z.coerce.number().optional()
+var BaseShapeSchema = z.object({
+  type: z.string(),
+  id: z.string().optional(),
+  layer: z.coerce.number().optional()
 });
 var TrackSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("TRACK"),
-  width: import_zod.z.coerce.number(),
-  points: import_zod.z.array(PointSchema)
+  type: z.literal("TRACK"),
+  width: z.coerce.number(),
+  points: z.array(PointSchema)
 });
 var PadSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("PAD"),
-  shape: import_zod.z.enum(["RECT", "ELLIPSE", "OVAL"]),
-  center: import_zod.z.object({
+  type: z.literal("PAD"),
+  shape: z.enum(["RECT", "ELLIPSE", "OVAL"]),
+  center: z.object({
     x: tenthmil,
     y: tenthmil
   }),
   width: tenthmil,
   height: tenthmil,
-  layermask: import_zod.z.number(),
-  net: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
-  number: import_zod.z.number(),
+  layermask: z.number(),
+  net: z.union([z.string(), z.number()]).optional(),
+  number: z.number(),
   holeRadius: tenthmil,
-  points: import_zod.z.array(PointSchema).optional(),
-  rotation: import_zod.z.number().optional(),
-  plated: import_zod.z.boolean()
+  points: z.array(PointSchema).optional(),
+  rotation: z.number().optional(),
+  plated: z.boolean()
 });
 var ArcSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("ARC"),
-  width: import_zod.z.number(),
+  type: z.literal("ARC"),
+  width: z.number(),
   start: PointSchema,
   end: PointSchema,
-  radiusX: import_zod.z.number(),
-  radiusY: import_zod.z.number(),
-  largeArc: import_zod.z.boolean(),
-  sweepDirection: import_zod.z.enum(["CW", "CCW"])
+  radiusX: z.number(),
+  radiusY: z.number(),
+  largeArc: z.boolean(),
+  sweepDirection: z.enum(["CW", "CCW"])
 });
 var CircleSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("CIRCLE"),
+  type: z.literal("CIRCLE"),
   center: PointSchema,
-  radius: import_zod.z.number(),
-  width: import_zod.z.number()
+  radius: z.number(),
+  width: z.number()
 });
 var SolidRegionSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("SOLIDREGION"),
-  layermask: import_zod.z.number(),
-  points: import_zod.z.array(PointSchema),
-  fillStyle: import_zod.z.string()
+  type: z.literal("SOLIDREGION"),
+  layermask: z.number(),
+  points: z.array(PointSchema),
+  fillStyle: z.string()
 });
 var SVGNodeSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("SVGNODE"),
-  svgData: import_zod.z.object({
-    gId: import_zod.z.string(),
-    nodeName: import_zod.z.string(),
-    nodeType: import_zod.z.number(),
-    layerid: import_zod.z.string(),
-    attrs: import_zod.z.record(import_zod.z.string(), import_zod.z.string()),
-    childNodes: import_zod.z.array(import_zod.z.unknown())
+  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: import_zod.z.literal("HOLE"),
+  type: z.literal("HOLE"),
   center: PointSchema,
-  radius: import_zod.z.number()
+  radius: z.number()
 });
 var RectSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("RECT"),
+  type: z.literal("RECT"),
   x: tenthmil,
   y: tenthmil,
   width: tenthmil,
   height: tenthmil,
-  lineWidth: import_zod.z.number(),
-  fillStyle: import_zod.z.string(),
-  rotation: import_zod.z.number().optional()
+  lineWidth: z.number(),
+  fillStyle: z.string(),
+  rotation: z.number().optional()
 });
-var PackageDetailShapeSchema = import_zod.z.discriminatedUnion("type", [
+var PackageDetailShapeSchema = z.discriminatedUnion("type", [
   TrackSchema,
   PadSchema,
   ArcSchema,
@@ -165,9 +118,9 @@ var pairs = (arr) => {
 var parsePoints = (pointsStr) => pairs(
   pointsStr.trim().split(" ").map((n) => Number(n))
 );
-var ShapeItemSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  data: import_zod.z.string()
+var ShapeItemSchema = z.object({
+  type: z.string(),
+  data: z.string()
 }).transform((shape) => {
   const [firstParam, ...restParams] = shape.data.split("~");
   const lastParam = restParams.pop();
@@ -303,10 +256,10 @@ var ShapeItemSchema = import_zod.z.object({
       return BaseShapeSchema.parse({ type: shape.type });
   }
 }).pipe(PackageDetailShapeSchema);
-var ShapesArraySchema = import_zod.z.array(ShapeItemSchema);
+var ShapesArraySchema = z.array(ShapeItemSchema);
 
 // lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_zod60 = require("zod");
+import "zod";
 
 // node_modules/circuit-json/dist/index.mjs
 var dist_exports = {};
@@ -390,14 +343,14 @@ __export(dist_exports, {
   visible_layer: () => visible_layer,
   voltage: () => voltage
 });
-var import_zod2 = require("zod");
-var import_zod3 = require("zod");
-var import_zod4 = require("zod");
-var import_zod5 = require("zod");
-var import_zod6 = require("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";
 
 // node_modules/nanoid/index.js
-var import_node_crypto = require("crypto");
+import { webcrypto as crypto } from "node:crypto";
 
 // node_modules/nanoid/url-alphabet/index.js
 var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
@@ -409,10 +362,10 @@ var poolOffset;
 function fillPool(bytes) {
   if (!pool || pool.length < bytes) {
     pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    import_node_crypto.webcrypto.getRandomValues(pool);
+    crypto.getRandomValues(pool);
     poolOffset = 0;
   } else if (poolOffset + bytes > pool.length) {
-    import_node_crypto.webcrypto.getRandomValues(pool);
+    crypto.getRandomValues(pool);
     poolOffset = 0;
   }
   poolOffset += bytes;
@@ -427,59 +380,59 @@ function nanoid(size2 = 21) {
 }
 
 // node_modules/circuit-json/dist/index.mjs
-var import_zod7 = require("zod");
-var import_zod8 = require("zod");
-var import_zod9 = require("zod");
-var import_zod10 = require("zod");
-var import_zod11 = require("zod");
-var import_zod12 = require("zod");
-var import_zod13 = require("zod");
-var import_zod14 = require("zod");
-var import_zod15 = require("zod");
-var import_zod16 = require("zod");
-var import_zod17 = require("zod");
-var import_zod18 = require("zod");
-var import_zod19 = require("zod");
-var import_zod20 = require("zod");
-var import_zod21 = require("zod");
-var import_zod22 = require("zod");
-var import_zod23 = require("zod");
-var import_zod24 = require("zod");
-var import_zod25 = require("zod");
-var import_zod26 = require("zod");
-var import_zod27 = require("zod");
-var import_zod28 = require("zod");
-var import_zod29 = require("zod");
-var import_zod30 = require("zod");
-var import_zod31 = require("zod");
-var import_zod32 = require("zod");
-var import_zod33 = require("zod");
-var import_zod34 = require("zod");
-var import_zod35 = require("zod");
-var import_zod36 = require("zod");
-var import_zod37 = require("zod");
-var import_zod38 = require("zod");
-var import_zod39 = require("zod");
-var import_zod40 = require("zod");
-var import_zod41 = require("zod");
-var import_zod42 = require("zod");
-var import_zod43 = require("zod");
-var import_zod44 = require("zod");
-var import_zod45 = require("zod");
-var import_zod46 = require("zod");
-var import_zod47 = require("zod");
-var import_zod48 = require("zod");
-var import_zod49 = require("zod");
-var import_zod50 = require("zod");
-var import_zod51 = require("zod");
-var import_zod52 = require("zod");
-var import_zod53 = require("zod");
-var import_zod54 = require("zod");
-var import_zod55 = require("zod");
-var import_zod56 = require("zod");
-var import_zod57 = require("zod");
-var import_zod58 = require("zod");
-var import_zod59 = require("zod");
+import { z as z8 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+import { z as z16 } from "zod";
+import { z as z17 } from "zod";
+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 z23 } from "zod";
+import { z as z24 } from "zod";
+import { z as z25 } from "zod";
+import { z as z26 } from "zod";
+import { z as z27 } from "zod";
+import { z as z28 } from "zod";
+import { z as z29 } from "zod";
+import { z as z30 } from "zod";
+import { z as z31 } from "zod";
+import { z as z32 } from "zod";
+import { z as z33 } from "zod";
+import { z as z34 } from "zod";
+import { z as z35 } from "zod";
+import { z as z36 } from "zod";
+import { z as z37 } from "zod";
+import { z as z38 } from "zod";
+import { z as z39 } from "zod";
+import { z as z40 } from "zod";
+import { z as z41 } from "zod";
+import { z as z42 } from "zod";
+import { z as z43 } from "zod";
+import { z as z44 } from "zod";
+import { z as z45 } from "zod";
+import { z as z46 } from "zod";
+import { z as z47 } from "zod";
+import { z as z48 } from "zod";
+import { z as z49 } from "zod";
+import { z as z50 } from "zod";
+import { z as z51 } from "zod";
+import { z as z52 } from "zod";
+import { z as z53 } from "zod";
+import { z as z54 } from "zod";
+import { z as z55 } from "zod";
+import { z as z56 } from "zod";
+import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var unitMappings = {
   Hz: {
     baseUnit: "Hz",
@@ -629,15 +582,15 @@ var parseAndConvertSiUnit = (v) => {
     value: conversionFactor * Number.parseFloat(value)
   };
 };
-var resistance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var capacitance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var inductance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var voltage = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var length = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).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 distance = length;
-var current = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var time = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var rotation = import_zod2.z.string().or(import_zod2.z.number()).transform((arg) => {
+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) => {
   if (typeof arg === "number") return arg;
   if (arg.endsWith("deg")) {
     return Number.parseFloat(arg.split("deg")[0]);
@@ -647,25 +600,25 @@ var rotation = import_zod2.z.string().or(import_zod2.z.number()).transform((arg)
   }
   return Number.parseFloat(arg);
 });
-var point = import_zod3.z.object({
+var point = z22.object({
   x: distance,
   y: distance
 });
 var position = point;
-var point3 = import_zod4.z.object({
+var point3 = z3.object({
   x: distance,
   y: distance,
   z: distance
 });
 var position3 = point3;
-var size = import_zod5.z.object({
-  width: import_zod5.z.number(),
-  height: import_zod5.z.number()
+var size = z4.object({
+  width: z4.number(),
+  height: z4.number()
 });
 var getZodPrefixedIdWithDefault = (prefix) => {
-  return import_zod6.z.string().optional().default(() => `${prefix}_${nanoid(10)}`);
+  return z5.string().optional().default(() => `${prefix}_${nanoid(10)}`);
 };
-var supplier_name = import_zod8.z.enum([
+var supplier_name = z6.enum([
   "jlcpcb",
   "macrofab",
   "pcbway",
@@ -673,46 +626,46 @@ var supplier_name = import_zod8.z.enum([
   "mouser",
   "lcsc"
 ]);
-var source_component_base = import_zod9.z.object({
-  type: import_zod9.z.literal("source_component"),
-  ftype: import_zod9.z.string().optional(),
-  source_component_id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  manufacturer_part_number: import_zod9.z.string().optional(),
-  supplier_part_numbers: import_zod9.z.record(supplier_name, import_zod9.z.array(import_zod9.z.string())).optional()
+var source_component_base = z7.object({
+  type: z7.literal("source_component"),
+  ftype: z7.string().optional(),
+  source_component_id: z7.string(),
+  name: z7.string(),
+  manufacturer_part_number: z7.string().optional(),
+  supplier_part_numbers: z7.record(supplier_name, z7.array(z7.string())).optional()
 });
 var source_simple_capacitor = source_component_base.extend({
-  ftype: import_zod7.z.literal("simple_capacitor"),
+  ftype: z8.literal("simple_capacitor"),
   capacitance
 });
 var source_simple_resistor = source_component_base.extend({
-  ftype: import_zod10.z.literal("simple_resistor"),
+  ftype: z9.literal("simple_resistor"),
   resistance
 });
 var source_simple_diode = source_component_base.extend({
-  ftype: import_zod11.z.literal("simple_diode")
+  ftype: z10.literal("simple_diode")
 });
 var source_simple_ground = source_component_base.extend({
-  ftype: import_zod12.z.literal("simple_ground")
+  ftype: z11.literal("simple_ground")
 });
 var source_simple_bug = source_component_base.extend({
-  ftype: import_zod13.z.literal("simple_bug")
+  ftype: z12.literal("simple_bug")
 }).describe("@deprecated");
 var source_simple_chip = source_component_base.extend({
-  ftype: import_zod14.z.literal("simple_chip")
+  ftype: z13.literal("simple_chip")
 });
 var source_simple_inductor = source_component_base.extend({
-  ftype: import_zod15.z.literal("simple_inductor"),
+  ftype: z14.literal("simple_inductor"),
   inductance
 });
 var source_led = source_simple_diode.extend({
-  ftype: import_zod16.z.literal("led")
+  ftype: z15.literal("led")
 });
 var source_simple_power_source = source_component_base.extend({
-  ftype: import_zod17.z.literal("simple_power_source"),
+  ftype: z16.literal("simple_power_source"),
   voltage
 });
-var any_source_component = import_zod18.z.union([
+var any_source_component = z17.union([
   source_simple_resistor,
   source_simple_capacitor,
   source_simple_diode,
@@ -722,158 +675,158 @@ var any_source_component = import_zod18.z.union([
   source_led,
   source_simple_power_source
 ]);
-var source_port = import_zod19.z.object({
-  type: import_zod19.z.literal("source_port"),
-  pin_number: import_zod19.z.number().optional(),
-  port_hints: import_zod19.z.array(import_zod19.z.string()).optional(),
-  name: import_zod19.z.string(),
-  source_port_id: import_zod19.z.string(),
-  source_component_id: import_zod19.z.string()
-});
-var source_trace = import_zod20.z.object({
-  type: import_zod20.z.literal("source_trace"),
-  source_trace_id: import_zod20.z.string(),
-  connected_source_port_ids: import_zod20.z.array(import_zod20.z.string()),
-  connected_source_net_ids: import_zod20.z.array(import_zod20.z.string())
-});
-var source_group = import_zod21.z.object({
-  type: import_zod21.z.literal("source_group"),
-  source_group_id: import_zod21.z.string(),
-  name: import_zod21.z.string().optional()
-});
-var source_net = import_zod22.z.object({
-  type: import_zod22.z.literal("source_net"),
-  source_net_id: import_zod22.z.string(),
-  name: import_zod22.z.string(),
-  member_source_group_ids: import_zod22.z.array(import_zod22.z.string()),
-  is_power: import_zod22.z.boolean().optional(),
-  is_ground: import_zod22.z.boolean().optional(),
-  is_digital_signal: import_zod22.z.boolean().optional(),
-  is_analog_signal: import_zod22.z.boolean().optional(),
-  trace_width: import_zod22.z.number().optional()
-});
-var schematic_box = import_zod23.z.object({
-  type: import_zod23.z.literal("schematic_box"),
-  schematic_component_id: import_zod23.z.string(),
+var source_port = z18.object({
+  type: z18.literal("source_port"),
+  pin_number: z18.number().optional(),
+  port_hints: z18.array(z18.string()).optional(),
+  name: z18.string(),
+  source_port_id: z18.string(),
+  source_component_id: z18.string()
+});
+var source_trace = z19.object({
+  type: z19.literal("source_trace"),
+  source_trace_id: z19.string(),
+  connected_source_port_ids: z19.array(z19.string()),
+  connected_source_net_ids: z19.array(z19.string())
+});
+var source_group = z20.object({
+  type: z20.literal("source_group"),
+  source_group_id: z20.string(),
+  name: z20.string().optional()
+});
+var source_net = z21.object({
+  type: z21.literal("source_net"),
+  source_net_id: z21.string(),
+  name: z21.string(),
+  member_source_group_ids: z21.array(z21.string()),
+  is_power: z21.boolean().optional(),
+  is_ground: z21.boolean().optional(),
+  is_digital_signal: z21.boolean().optional(),
+  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(),
   width: distance,
   height: distance,
   x: distance,
   y: distance
 }).describe("Draws a box on the schematic");
-var schematic_path = import_zod24.z.object({
-  type: import_zod24.z.literal("schematic_path"),
-  schematic_component_id: import_zod24.z.string(),
-  fill_color: import_zod24.z.enum(["red", "blue"]).optional(),
-  is_filled: import_zod24.z.boolean().optional(),
-  points: import_zod24.z.array(point)
-});
-var schematic_pin_styles = import_zod25.z.record(
-  import_zod25.z.object({
+var schematic_path = z23.object({
+  type: z23.literal("schematic_path"),
+  schematic_component_id: z23.string(),
+  fill_color: z23.enum(["red", "blue"]).optional(),
+  is_filled: z23.boolean().optional(),
+  points: z23.array(point)
+});
+var schematic_pin_styles = z24.record(
+  z24.object({
     left_margin: length.optional(),
     right_margin: length.optional(),
     top_margin: length.optional(),
     bottom_margin: length.optional()
   })
 );
-var schematic_component = import_zod25.z.object({
-  type: import_zod25.z.literal("schematic_component"),
+var schematic_component = z24.object({
+  type: z24.literal("schematic_component"),
   rotation: rotation.default(0),
   size,
   center: point,
-  source_component_id: import_zod25.z.string(),
-  schematic_component_id: import_zod25.z.string(),
+  source_component_id: z24.string(),
+  schematic_component_id: z24.string(),
   pin_spacing: length.optional(),
   pin_styles: schematic_pin_styles.optional(),
   box_width: length.optional(),
-  symbol_name: import_zod25.z.string().optional(),
-  port_arrangement: import_zod25.z.union([
-    import_zod25.z.object({
-      left_size: import_zod25.z.number(),
-      right_size: import_zod25.z.number(),
-      top_size: import_zod25.z.number().optional(),
-      bottom_size: import_zod25.z.number().optional()
+  symbol_name: z24.string().optional(),
+  port_arrangement: z24.union([
+    z24.object({
+      left_size: z24.number(),
+      right_size: z24.number(),
+      top_size: z24.number().optional(),
+      bottom_size: z24.number().optional()
     }),
-    import_zod25.z.object({
-      left_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+    z24.object({
+      left_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["top-to-bottom", "bottom-to-top"]).optional()
       }).optional(),
-      right_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+      right_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["top-to-bottom", "bottom-to-top"]).optional()
       }).optional(),
-      top_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["left-to-right", "right-to-left"]).optional()
+      top_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["left-to-right", "right-to-left"]).optional()
       }).optional(),
-      bottom_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["left-to-right", "right-to-left"]).optional()
+      bottom_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["left-to-right", "right-to-left"]).optional()
       }).optional()
     })
   ]).optional(),
-  port_labels: import_zod25.z.record(import_zod25.z.string()).optional()
+  port_labels: z24.record(z24.string()).optional()
 });
-var schematic_line = import_zod26.z.object({
-  type: import_zod26.z.literal("schematic_line"),
-  schematic_component_id: import_zod26.z.string(),
+var schematic_line = z25.object({
+  type: z25.literal("schematic_line"),
+  schematic_component_id: z25.string(),
   x1: distance,
   x2: distance,
   y1: distance,
   y2: distance
 });
-var schematic_trace = import_zod27.z.object({
-  type: import_zod27.z.literal("schematic_trace"),
-  schematic_trace_id: import_zod27.z.string(),
-  source_trace_id: import_zod27.z.string(),
-  edges: import_zod27.z.array(
-    import_zod27.z.object({
-      from: import_zod27.z.object({
-        x: import_zod27.z.number(),
-        y: import_zod27.z.number()
+var schematic_trace = z26.object({
+  type: z26.literal("schematic_trace"),
+  schematic_trace_id: z26.string(),
+  source_trace_id: z26.string(),
+  edges: z26.array(
+    z26.object({
+      from: z26.object({
+        x: z26.number(),
+        y: z26.number()
       }),
-      to: import_zod27.z.object({
-        x: import_zod27.z.number(),
-        y: import_zod27.z.number()
+      to: z26.object({
+        x: z26.number(),
+        y: z26.number()
       }),
-      from_schematic_port_id: import_zod27.z.string().optional(),
-      to_schematic_port_id: import_zod27.z.string().optional()
+      from_schematic_port_id: z26.string().optional(),
+      to_schematic_port_id: z26.string().optional()
     })
   )
 });
-var schematic_text = import_zod28.z.object({
-  type: import_zod28.z.literal("schematic_text"),
-  schematic_component_id: import_zod28.z.string(),
-  schematic_text_id: import_zod28.z.string(),
-  text: import_zod28.z.string(),
-  position: import_zod28.z.object({
+var schematic_text = z27.object({
+  type: z27.literal("schematic_text"),
+  schematic_component_id: z27.string(),
+  schematic_text_id: z27.string(),
+  text: z27.string(),
+  position: z27.object({
     x: distance,
     y: distance
   }),
-  rotation: import_zod28.z.number().default(0),
-  anchor: import_zod28.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
-});
-var schematic_port = import_zod29.z.object({
-  type: import_zod29.z.literal("schematic_port"),
-  schematic_port_id: import_zod29.z.string(),
-  source_port_id: import_zod29.z.string(),
-  schematic_component_id: import_zod29.z.string().optional(),
+  rotation: z27.number().default(0),
+  anchor: z27.enum(["center", "left", "right", "top", "bottom"]).default("center")
+});
+var schematic_port = z28.object({
+  type: z28.literal("schematic_port"),
+  schematic_port_id: z28.string(),
+  source_port_id: z28.string(),
+  schematic_component_id: z28.string().optional(),
   center: point,
-  facing_direction: import_zod29.z.enum(["up", "down", "left", "right"]).optional()
+  facing_direction: z28.enum(["up", "down", "left", "right"]).optional()
 }).describe("Defines a port on a schematic component");
-var schematic_net_label = import_zod30.z.object({
-  type: import_zod30.z.literal("schematic_net_label"),
-  source_net_id: import_zod30.z.string(),
+var schematic_net_label = z29.object({
+  type: z29.literal("schematic_net_label"),
+  source_net_id: z29.string(),
   center: point,
-  anchor_side: import_zod30.z.enum(["top", "bottom", "left", "right"]),
-  text: import_zod30.z.string()
+  anchor_side: z29.enum(["top", "bottom", "left", "right"]),
+  text: z29.string()
 });
-var schematic_error = import_zod31.z.object({
-  schematic_error_id: import_zod31.z.string(),
-  type: import_zod31.z.literal("schematic_error"),
+var schematic_error = z30.object({
+  schematic_error_id: z30.string(),
+  type: z30.literal("schematic_error"),
   // eventually each error type should be broken out into a dir of files
-  error_type: import_zod31.z.literal("schematic_port_not_found"),
-  message: import_zod31.z.string()
+  error_type: z30.literal("schematic_port_not_found"),
+  message: z30.string()
 }).describe("Defines a schematic error on the schematic");
 var all_layers = [
   "top",
@@ -885,9 +838,9 @@ var all_layers = [
   "inner5",
   "inner6"
 ];
-var layer_string = import_zod32.z.enum(all_layers);
+var layer_string = z31.enum(all_layers);
 var layer_ref = layer_string.or(
-  import_zod32.z.object({
+  z31.object({
     name: layer_string
   })
 ).transform((layer) => {
@@ -896,27 +849,27 @@ var layer_ref = layer_string.or(
   }
   return layer.name;
 });
-var visible_layer = import_zod32.z.enum(["top", "bottom"]);
-var pcb_route_hint = import_zod33.z.object({
+var visible_layer = z31.enum(["top", "bottom"]);
+var pcb_route_hint = z32.object({
   x: distance,
   y: distance,
-  via: import_zod33.z.boolean().optional(),
+  via: z32.boolean().optional(),
   via_to_layer: layer_ref.optional()
 });
-var pcb_route_hints = import_zod33.z.array(pcb_route_hint);
-var route_hint_point = import_zod34.z.object({
+var pcb_route_hints = z32.array(pcb_route_hint);
+var route_hint_point = z33.object({
   x: distance,
   y: distance,
-  via: import_zod34.z.boolean().optional(),
+  via: z33.boolean().optional(),
   to_layer: layer_ref.optional(),
   trace_width: distance.optional()
 });
 var expectTypesMatch = (shouldBe) => {
 };
-var pcb_component = import_zod35.z.object({
-  type: import_zod35.z.literal("pcb_component"),
+var pcb_component = z34.object({
+  type: z34.literal("pcb_component"),
   pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
-  source_component_id: import_zod35.z.string(),
+  source_component_id: z34.string(),
   center: point,
   layer: layer_ref,
   rotation,
@@ -924,11 +877,11 @@ var pcb_component = import_zod35.z.object({
   height: length
 }).describe("Defines a component on the PCB");
 expectTypesMatch(true);
-var pcb_hole_circle_or_square = import_zod36.z.object({
-  type: import_zod36.z.literal("pcb_hole"),
+var pcb_hole_circle_or_square = z35.object({
+  type: z35.literal("pcb_hole"),
   pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  hole_shape: import_zod36.z.enum(["circle", "square"]),
-  hole_diameter: import_zod36.z.number(),
+  hole_shape: z35.enum(["circle", "square"]),
+  hole_diameter: z35.number(),
   x: distance,
   y: distance
 });
@@ -936,12 +889,12 @@ var pcb_hole_circle_or_square_shape = pcb_hole_circle_or_square.describe(
   "Defines a circular or square hole on the PCB"
 );
 expectTypesMatch(true);
-var pcb_hole_oval = import_zod36.z.object({
-  type: import_zod36.z.literal("pcb_hole"),
+var pcb_hole_oval = z35.object({
+  type: z35.literal("pcb_hole"),
   pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  hole_shape: import_zod36.z.literal("oval"),
-  hole_width: import_zod36.z.number(),
-  hole_height: import_zod36.z.number(),
+  hole_shape: z35.literal("oval"),
+  hole_width: z35.number(),
+  hole_height: z35.number(),
   x: distance,
   y: distance
 });
@@ -950,35 +903,35 @@ var pcb_hole_oval_shape = pcb_hole_oval.describe(
 );
 expectTypesMatch(true);
 var pcb_hole = pcb_hole_circle_or_square.or(pcb_hole_oval);
-var pcb_plated_hole_circle = import_zod37.z.object({
-  type: import_zod37.z.literal("pcb_plated_hole"),
-  shape: import_zod37.z.literal("circle"),
-  outer_diameter: import_zod37.z.number(),
-  hole_diameter: import_zod37.z.number(),
+var pcb_plated_hole_circle = z36.object({
+  type: z36.literal("pcb_plated_hole"),
+  shape: z36.literal("circle"),
+  outer_diameter: z36.number(),
+  hole_diameter: z36.number(),
   x: distance,
   y: distance,
-  layers: import_zod37.z.array(layer_ref),
-  port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-  pcb_component_id: import_zod37.z.string().optional(),
-  pcb_port_id: import_zod37.z.string().optional(),
+  layers: z36.array(layer_ref),
+  port_hints: z36.array(z36.string()).optional(),
+  pcb_component_id: z36.string().optional(),
+  pcb_port_id: z36.string().optional(),
   pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
 });
-var pcb_plated_hole_oval = import_zod37.z.object({
-  type: import_zod37.z.literal("pcb_plated_hole"),
-  shape: import_zod37.z.enum(["oval", "pill"]),
-  outer_width: import_zod37.z.number(),
-  outer_height: import_zod37.z.number(),
-  hole_width: import_zod37.z.number(),
-  hole_height: import_zod37.z.number(),
+var pcb_plated_hole_oval = z36.object({
+  type: z36.literal("pcb_plated_hole"),
+  shape: z36.enum(["oval", "pill"]),
+  outer_width: z36.number(),
+  outer_height: z36.number(),
+  hole_width: z36.number(),
+  hole_height: z36.number(),
   x: distance,
   y: distance,
-  layers: import_zod37.z.array(layer_ref),
-  port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-  pcb_component_id: import_zod37.z.string().optional(),
-  pcb_port_id: import_zod37.z.string().optional(),
+  layers: z36.array(layer_ref),
+  port_hints: z36.array(z36.string()).optional(),
+  pcb_component_id: z36.string().optional(),
+  pcb_port_id: z36.string().optional(),
   pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
 });
-var pcb_plated_hole = import_zod37.z.union([
+var pcb_plated_hole = z36.union([
   pcb_plated_hole_circle,
   pcb_plated_hole_oval
 ]);
@@ -986,154 +939,154 @@ expectTypesMatch(
   true
 );
 expectTypesMatch(true);
-var pcb_port = import_zod38.z.object({
-  type: import_zod38.z.literal("pcb_port"),
+var pcb_port = z37.object({
+  type: z37.literal("pcb_port"),
   pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
-  source_port_id: import_zod38.z.string(),
-  pcb_component_id: import_zod38.z.string(),
+  source_port_id: z37.string(),
+  pcb_component_id: z37.string(),
   x: distance,
   y: distance,
-  layers: import_zod38.z.array(layer_ref)
+  layers: z37.array(layer_ref)
 }).describe("Defines a port on the PCB");
 expectTypesMatch(true);
-var pcb_smtpad_circle = import_zod39.z.object({
-  type: import_zod39.z.literal("pcb_smtpad"),
-  shape: import_zod39.z.literal("circle"),
+var pcb_smtpad_circle = z38.object({
+  type: z38.literal("pcb_smtpad"),
+  shape: z38.literal("circle"),
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   x: distance,
   y: distance,
-  radius: import_zod39.z.number(),
+  radius: z38.number(),
   layer: layer_ref,
-  port_hints: import_zod39.z.array(import_zod39.z.string()).optional(),
-  pcb_component_id: import_zod39.z.string().optional(),
-  pcb_port_id: import_zod39.z.string().optional()
+  port_hints: z38.array(z38.string()).optional(),
+  pcb_component_id: z38.string().optional(),
+  pcb_port_id: z38.string().optional()
 });
-var pcb_smtpad_rect = import_zod39.z.object({
-  type: import_zod39.z.literal("pcb_smtpad"),
-  shape: import_zod39.z.literal("rect"),
+var pcb_smtpad_rect = z38.object({
+  type: z38.literal("pcb_smtpad"),
+  shape: z38.literal("rect"),
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   x: distance,
   y: distance,
-  width: import_zod39.z.number(),
-  height: import_zod39.z.number(),
+  width: z38.number(),
+  height: z38.number(),
   layer: layer_ref,
-  port_hints: import_zod39.z.array(import_zod39.z.string()).optional(),
-  pcb_component_id: import_zod39.z.string().optional(),
-  pcb_port_id: import_zod39.z.string().optional()
+  port_hints: z38.array(z38.string()).optional(),
+  pcb_component_id: z38.string().optional(),
+  pcb_port_id: z38.string().optional()
 });
-var pcb_smtpad = import_zod39.z.union([pcb_smtpad_circle, pcb_smtpad_rect]).describe("Defines an SMT pad on the PCB");
+var pcb_smtpad = z38.union([pcb_smtpad_circle, pcb_smtpad_rect]).describe("Defines an SMT pad on the PCB");
 expectTypesMatch(true);
 expectTypesMatch(true);
-var pcb_solder_paste_circle = import_zod40.z.object({
-  type: import_zod40.z.literal("pcb_solder_paste"),
-  shape: import_zod40.z.literal("circle"),
+var pcb_solder_paste_circle = z39.object({
+  type: z39.literal("pcb_solder_paste"),
+  shape: z39.literal("circle"),
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   x: distance,
   y: distance,
-  radius: import_zod40.z.number(),
+  radius: z39.number(),
   layer: layer_ref,
-  pcb_component_id: import_zod40.z.string().optional(),
-  pcb_smtpad_id: import_zod40.z.string().optional()
+  pcb_component_id: z39.string().optional(),
+  pcb_smtpad_id: z39.string().optional()
 });
-var pcb_solder_paste_rect = import_zod40.z.object({
-  type: import_zod40.z.literal("pcb_solder_paste"),
-  shape: import_zod40.z.literal("rect"),
+var pcb_solder_paste_rect = z39.object({
+  type: z39.literal("pcb_solder_paste"),
+  shape: z39.literal("rect"),
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   x: distance,
   y: distance,
-  width: import_zod40.z.number(),
-  height: import_zod40.z.number(),
+  width: z39.number(),
+  height: z39.number(),
   layer: layer_ref,
-  pcb_component_id: import_zod40.z.string().optional(),
-  pcb_smtpad_id: import_zod40.z.string().optional()
+  pcb_component_id: z39.string().optional(),
+  pcb_smtpad_id: z39.string().optional()
 });
-var pcb_solder_paste = import_zod40.z.union([pcb_solder_paste_circle, pcb_solder_paste_rect]).describe("Defines solderpaste on the PCB");
+var pcb_solder_paste = z39.union([pcb_solder_paste_circle, pcb_solder_paste_rect]).describe("Defines solderpaste on the PCB");
 expectTypesMatch(true);
 expectTypesMatch(true);
-var pcb_text = import_zod41.z.object({
-  type: import_zod41.z.literal("pcb_text"),
+var pcb_text = z40.object({
+  type: z40.literal("pcb_text"),
   pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
-  text: import_zod41.z.string(),
+  text: z40.string(),
   center: point,
   layer: layer_ref,
   width: length,
   height: length,
-  lines: import_zod41.z.number(),
-  align: import_zod41.z.enum(["bottom-left"])
+  lines: z40.number(),
+  align: z40.enum(["bottom-left"])
 }).describe("Defines text on the PCB");
 expectTypesMatch(true);
-var pcb_trace_route_point_wire = import_zod42.z.object({
-  route_type: import_zod42.z.literal("wire"),
+var pcb_trace_route_point_wire = z41.object({
+  route_type: z41.literal("wire"),
   x: distance,
   y: distance,
   width: distance,
-  start_pcb_port_id: import_zod42.z.string().optional(),
-  end_pcb_port_id: import_zod42.z.string().optional(),
+  start_pcb_port_id: z41.string().optional(),
+  end_pcb_port_id: z41.string().optional(),
   layer: layer_ref
 });
-var pcb_trace_route_point_via = import_zod42.z.object({
-  route_type: import_zod42.z.literal("via"),
+var pcb_trace_route_point_via = z41.object({
+  route_type: z41.literal("via"),
   x: distance,
   y: distance,
-  from_layer: import_zod42.z.string(),
-  to_layer: import_zod42.z.string()
+  from_layer: z41.string(),
+  to_layer: z41.string()
 });
-var pcb_trace_route_point = import_zod42.z.union([
+var pcb_trace_route_point = z41.union([
   pcb_trace_route_point_wire,
   pcb_trace_route_point_via
 ]);
-var pcb_trace = import_zod42.z.object({
-  type: import_zod42.z.literal("pcb_trace"),
-  source_trace_id: import_zod42.z.string().optional(),
-  pcb_component_id: import_zod42.z.string().optional(),
+var pcb_trace = z41.object({
+  type: z41.literal("pcb_trace"),
+  source_trace_id: z41.string().optional(),
+  pcb_component_id: z41.string().optional(),
   pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
-  route_thickness_mode: import_zod42.z.enum(["constant", "interpolated"]).default("constant").optional(),
-  route_order_index: import_zod42.z.number().optional(),
-  should_round_corners: import_zod42.z.boolean().optional(),
-  route: import_zod42.z.array(
-    import_zod42.z.union([
-      import_zod42.z.object({
-        route_type: import_zod42.z.literal("wire"),
+  route_thickness_mode: z41.enum(["constant", "interpolated"]).default("constant").optional(),
+  route_order_index: z41.number().optional(),
+  should_round_corners: z41.boolean().optional(),
+  route: z41.array(
+    z41.union([
+      z41.object({
+        route_type: z41.literal("wire"),
         x: distance,
         y: distance,
         width: distance,
-        start_pcb_port_id: import_zod42.z.string().optional(),
-        end_pcb_port_id: import_zod42.z.string().optional(),
+        start_pcb_port_id: z41.string().optional(),
+        end_pcb_port_id: z41.string().optional(),
         layer: layer_ref
       }),
-      import_zod42.z.object({
-        route_type: import_zod42.z.literal("via"),
+      z41.object({
+        route_type: z41.literal("via"),
         x: distance,
         y: distance,
-        from_layer: import_zod42.z.string(),
-        to_layer: import_zod42.z.string()
+        from_layer: z41.string(),
+        to_layer: z41.string()
       })
     ])
   )
 }).describe("Defines a trace on the PCB");
 expectTypesMatch(true);
 expectTypesMatch(true);
-var pcb_trace_error = import_zod43.z.object({
-  type: import_zod43.z.literal("pcb_trace_error"),
+var pcb_trace_error = z42.object({
+  type: z42.literal("pcb_trace_error"),
   pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
-  error_type: import_zod43.z.literal("pcb_trace_error"),
-  message: import_zod43.z.string(),
+  error_type: z42.literal("pcb_trace_error"),
+  message: z42.string(),
   center: point.optional(),
-  pcb_trace_id: import_zod43.z.string(),
-  source_trace_id: import_zod43.z.string(),
-  pcb_component_ids: import_zod43.z.array(import_zod43.z.string()),
-  pcb_port_ids: import_zod43.z.array(import_zod43.z.string())
+  pcb_trace_id: z42.string(),
+  source_trace_id: z42.string(),
+  pcb_component_ids: z42.array(z42.string()),
+  pcb_port_ids: z42.array(z42.string())
 }).describe("Defines a trace error on the PCB");
 expectTypesMatch(true);
-var pcb_port_not_matched_error = import_zod44.z.object({
-  type: import_zod44.z.literal("pcb_port_not_matched_error"),
+var pcb_port_not_matched_error = z43.object({
+  type: z43.literal("pcb_port_not_matched_error"),
   pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
-  message: import_zod44.z.string(),
-  pcb_component_ids: import_zod44.z.array(import_zod44.z.string())
+  message: z43.string(),
+  pcb_component_ids: z43.array(z43.string())
 }).describe("Defines a trace error on the PCB where a port is not matched");
 expectTypesMatch(true);
-var pcb_via = import_zod45.z.object({
-  type: import_zod45.z.literal("pcb_via"),
+var pcb_via = z44.object({
+  type: z44.literal("pcb_via"),
   pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
   x: distance,
   y: distance,
@@ -1143,39 +1096,39 @@ var pcb_via = import_zod45.z.object({
   from_layer: layer_ref.optional(),
   /** @deprecated */
   to_layer: layer_ref.optional(),
-  layers: import_zod45.z.array(layer_ref),
-  pcb_trace_id: import_zod45.z.string().optional()
+  layers: z44.array(layer_ref),
+  pcb_trace_id: z44.string().optional()
 }).describe("Defines a via on the PCB");
 expectTypesMatch(true);
-var pcb_board = import_zod46.z.object({
-  type: import_zod46.z.literal("pcb_board"),
+var pcb_board = z45.object({
+  type: z45.literal("pcb_board"),
   pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
   width: length,
   height: length,
   center: point,
   thickness: length.optional().default(1.4),
-  num_layers: import_zod46.z.number().optional().default(4),
-  outline: import_zod46.z.array(point).optional()
+  num_layers: z45.number().optional().default(4),
+  outline: z45.array(point).optional()
 }).describe("Defines the board outline of the PCB");
 expectTypesMatch(true);
-var pcb_placement_error = import_zod47.z.object({
-  type: import_zod47.z.literal("pcb_placement_error"),
+var pcb_placement_error = z46.object({
+  type: z46.literal("pcb_placement_error"),
   pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
-  message: import_zod47.z.string()
+  message: z46.string()
 }).describe("Defines a placement error on the PCB");
 expectTypesMatch(true);
-var pcb_trace_hint = import_zod48.z.object({
-  type: import_zod48.z.literal("pcb_trace_hint"),
+var pcb_trace_hint = z47.object({
+  type: z47.literal("pcb_trace_hint"),
   pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
-  pcb_port_id: import_zod48.z.string(),
-  pcb_component_id: import_zod48.z.string(),
-  route: import_zod48.z.array(route_hint_point)
+  pcb_port_id: z47.string(),
+  pcb_component_id: z47.string(),
+  route: z47.array(route_hint_point)
 }).describe("A hint that can be used during generation of a PCB trace");
 expectTypesMatch(true);
-var pcb_silkscreen_line = import_zod49.z.object({
-  type: import_zod49.z.literal("pcb_silkscreen_line"),
+var pcb_silkscreen_line = z48.object({
+  type: z48.literal("pcb_silkscreen_line"),
   pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
-  pcb_component_id: import_zod49.z.string(),
+  pcb_component_id: z48.string(),
   stroke_width: distance.default("0.1mm"),
   x1: distance,
   y1: distance,
@@ -1184,131 +1137,131 @@ var pcb_silkscreen_line = import_zod49.z.object({
   layer: visible_layer
 }).describe("Defines a silkscreen line on the PCB");
 expectTypesMatch(true);
-var pcb_silkscreen_path = import_zod50.z.object({
-  type: import_zod50.z.literal("pcb_silkscreen_path"),
+var pcb_silkscreen_path = z49.object({
+  type: z49.literal("pcb_silkscreen_path"),
   pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
-  pcb_component_id: import_zod50.z.string(),
+  pcb_component_id: z49.string(),
   layer: visible_layer,
-  route: import_zod50.z.array(point),
+  route: z49.array(point),
   stroke_width: length
 }).describe("Defines a silkscreen path on the PCB");
 expectTypesMatch(true);
-var pcb_silkscreen_text = import_zod51.z.object({
-  type: import_zod51.z.literal("pcb_silkscreen_text"),
+var pcb_silkscreen_text = z50.object({
+  type: z50.literal("pcb_silkscreen_text"),
   pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
-  font: import_zod51.z.literal("tscircuit2024").default("tscircuit2024"),
+  font: z50.literal("tscircuit2024").default("tscircuit2024"),
   font_size: distance.default("0.2mm"),
-  pcb_component_id: import_zod51.z.string(),
-  text: import_zod51.z.string(),
+  pcb_component_id: z50.string(),
+  text: z50.string(),
   layer: layer_ref,
-  is_mirrored: import_zod51.z.boolean().default(false).optional(),
+  is_mirrored: z50.boolean().default(false).optional(),
   anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod51.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+  anchor_alignment: z50.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
 }).describe("Defines silkscreen text on the PCB");
 expectTypesMatch(true);
-var pcb_silkscreen_rect = import_zod52.z.object({
-  type: import_zod52.z.literal("pcb_silkscreen_rect"),
+var pcb_silkscreen_rect = z51.object({
+  type: z51.literal("pcb_silkscreen_rect"),
   pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
-  pcb_component_id: import_zod52.z.string(),
+  pcb_component_id: z51.string(),
   center: point,
   width: length,
   height: length,
   layer: layer_ref
 }).describe("Defines a silkscreen rect on the PCB");
 expectTypesMatch(true);
-var pcb_silkscreen_circle = import_zod53.z.object({
-  type: import_zod53.z.literal("pcb_silkscreen_circle"),
+var pcb_silkscreen_circle = z52.object({
+  type: z52.literal("pcb_silkscreen_circle"),
   pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
     "pcb_silkscreen_circle"
   ),
-  pcb_component_id: import_zod53.z.string(),
+  pcb_component_id: z52.string(),
   center: point,
   radius: length,
   layer: visible_layer
 }).describe("Defines a silkscreen circle on the PCB");
 expectTypesMatch(true);
-var pcb_silkscreen_oval = import_zod54.z.object({
-  type: import_zod54.z.literal("pcb_silkscreen_oval"),
+var pcb_silkscreen_oval = z53.object({
+  type: z53.literal("pcb_silkscreen_oval"),
   pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
-  pcb_component_id: import_zod54.z.string(),
+  pcb_component_id: z53.string(),
   center: point,
   radius_x: distance,
   radius_y: distance,
   layer: visible_layer
 }).describe("Defines a silkscreen oval on the PCB");
 expectTypesMatch(true);
-var pcb_fabrication_note_text = import_zod55.z.object({
-  type: import_zod55.z.literal("pcb_fabrication_note_text"),
+var pcb_fabrication_note_text = z54.object({
+  type: z54.literal("pcb_fabrication_note_text"),
   pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
     "pcb_fabrication_note_text"
   ),
-  font: import_zod55.z.literal("tscircuit2024").default("tscircuit2024"),
+  font: z54.literal("tscircuit2024").default("tscircuit2024"),
   font_size: distance.default("1mm"),
-  pcb_component_id: import_zod55.z.string(),
-  text: import_zod55.z.string(),
+  pcb_component_id: z54.string(),
+  text: z54.string(),
   layer: visible_layer,
   anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod55.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  color: import_zod55.z.string().optional()
+  anchor_alignment: z54.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  color: z54.string().optional()
 }).describe(
   "Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators"
 );
 expectTypesMatch(true);
-var pcb_fabrication_note_path = import_zod56.z.object({
-  type: import_zod56.z.literal("pcb_fabrication_note_path"),
+var pcb_fabrication_note_path = z55.object({
+  type: z55.literal("pcb_fabrication_note_path"),
   pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
     "pcb_fabrication_note_path"
   ),
-  pcb_component_id: import_zod56.z.string(),
+  pcb_component_id: z55.string(),
   layer: layer_ref,
-  route: import_zod56.z.array(point),
+  route: z55.array(point),
   stroke_width: length,
-  color: import_zod56.z.string().optional()
+  color: z55.string().optional()
 }).describe(
   "Defines a fabrication path on the PCB for fabricators or assemblers"
 );
 expectTypesMatch(true);
-var pcb_keepout = import_zod57.z.object({
-  type: import_zod57.z.literal("pcb_keepout"),
-  shape: import_zod57.z.literal("rect"),
+var pcb_keepout = z56.object({
+  type: z56.literal("pcb_keepout"),
+  shape: z56.literal("rect"),
   center: point,
   width: distance,
   height: distance,
-  pcb_keepout_id: import_zod57.z.string(),
-  layers: import_zod57.z.array(import_zod57.z.string()),
+  pcb_keepout_id: z56.string(),
+  layers: z56.array(z56.string()),
   // Specify layers where the keepout applies
-  description: import_zod57.z.string().optional()
+  description: z56.string().optional()
   // Optional description of the keepout
 }).or(
-  import_zod57.z.object({
-    type: import_zod57.z.literal("pcb_keepout"),
-    shape: import_zod57.z.literal("circle"),
+  z56.object({
+    type: z56.literal("pcb_keepout"),
+    shape: z56.literal("circle"),
     center: point,
     radius: distance,
-    pcb_keepout_id: import_zod57.z.string(),
-    layers: import_zod57.z.array(import_zod57.z.string()),
+    pcb_keepout_id: z56.string(),
+    layers: z56.array(z56.string()),
     // Specify layers where the keepout applies
-    description: import_zod57.z.string().optional()
+    description: z56.string().optional()
     // Optional description of the keepout
   })
 );
-var cad_component = import_zod58.z.object({
-  type: import_zod58.z.literal("cad_component"),
-  cad_component_id: import_zod58.z.string(),
-  pcb_component_id: import_zod58.z.string(),
-  source_component_id: import_zod58.z.string(),
+var cad_component = z57.object({
+  type: z57.literal("cad_component"),
+  cad_component_id: z57.string(),
+  pcb_component_id: z57.string(),
+  source_component_id: z57.string(),
   position: point3,
   rotation: point3.optional(),
   size: point3.optional(),
   layer: layer_ref.optional(),
   // These are all ways to generate/load the 3d model
-  footprinter_string: import_zod58.z.string().optional(),
-  model_obj_url: import_zod58.z.string().optional(),
-  model_stl_url: import_zod58.z.string().optional(),
-  model_3mf_url: import_zod58.z.string().optional(),
-  model_jscad: import_zod58.z.any().optional()
+  footprinter_string: z57.string().optional(),
+  model_obj_url: z57.string().optional(),
+  model_stl_url: z57.string().optional(),
+  model_3mf_url: z57.string().optional(),
+  model_jscad: z57.any().optional()
 }).describe("Defines a component on the PCB");
-var any_circuit_element = import_zod59.z.union([
+var any_circuit_element = z58.union([
   source_trace,
   source_port,
   any_source_component,
@@ -1403,7 +1356,7 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
 }
 
 // node_modules/@tscircuit/soup-util/dist/index.js
-var import_transformation_matrix = require("transformation-matrix");
+import { applyToPoint, decomposeTSR } from "transformation-matrix";
 var su = (soup, options = {}) => {
   let internalStore = soup._internal_store;
   if (!internalStore) {
@@ -1539,18 +1492,18 @@ su.unparsed = su;
 var su_default = su;
 var transformPCBElement = (elm, matrix) => {
   if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-    const { x, y } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x, y: elm.y });
+    const { x, y } = applyToPoint(matrix, { x: elm.x, y: elm.y });
     elm.x = x;
     elm.y = y;
   } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+    elm.center = applyToPoint(matrix, elm.center);
   } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
-    elm.anchor_position = (0, import_transformation_matrix.applyToPoint)(matrix, elm.anchor_position);
+    elm.anchor_position = applyToPoint(matrix, elm.anchor_position);
   } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
-    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+    elm.center = applyToPoint(matrix, elm.center);
   } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
     elm.route = elm.route.map((rp) => {
-      const tp = (0, import_transformation_matrix.applyToPoint)(matrix, rp);
+      const tp = applyToPoint(matrix, rp);
       rp.x = tp.x;
       rp.y = tp.y;
       return rp;
@@ -1558,14 +1511,14 @@ var transformPCBElement = (elm, matrix) => {
   } else if (elm.type === "pcb_silkscreen_line") {
     const p1 = { x: elm.x1, y: elm.y1 };
     const p2 = { x: elm.x2, y: elm.y2 };
-    const p1t = (0, import_transformation_matrix.applyToPoint)(matrix, p1);
-    const p2t = (0, import_transformation_matrix.applyToPoint)(matrix, p2);
+    const p1t = applyToPoint(matrix, p1);
+    const p2t = applyToPoint(matrix, p2);
     elm.x1 = p1t.x;
     elm.y1 = p1t.y;
     elm.x2 = p2t.x;
     elm.y2 = p2t.y;
   } else if (elm.type === "cad_component") {
-    const newPos = (0, import_transformation_matrix.applyToPoint)(matrix, {
+    const newPos = applyToPoint(matrix, {
       x: elm.position.x,
       y: elm.position.y
     });
@@ -1575,7 +1528,7 @@ var transformPCBElement = (elm, matrix) => {
   return elm;
 };
 var transformPCBElements = (elms, matrix) => {
-  const tsr = (0, import_transformation_matrix.decomposeTSR)(matrix);
+  const tsr = decomposeTSR(matrix);
   const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
   let transformedElms = elms.map((elm) => transformPCBElement(elm, matrix));
   if (flipPadWidthHeight) {
@@ -1591,18 +1544,18 @@ var transformPCBElements = (elms, matrix) => {
 };
 
 // lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_transformation_matrix2 = require("transformation-matrix");
+import { scale, translate } from "transformation-matrix";
 
 // lib/compute-center-offset.ts
-var import_mm = require("@tscircuit/mm");
+import { mm } from "@tscircuit/mm";
 var computeCenterOffset = (easyeda) => {
   const pads = easyeda.packageDetail.dataStr.shape.filter(
     (shape) => shape.type === "PAD"
   );
-  const minX = Math.min(...pads.map((pad) => (0, import_mm.mm)(pad.center.x)));
-  const maxX = Math.max(...pads.map((pad) => (0, import_mm.mm)(pad.center.x)));
-  const minY = Math.min(...pads.map((pad) => (0, import_mm.mm)(pad.center.y)));
-  const maxY = Math.max(...pads.map((pad) => (0, import_mm.mm)(pad.center.y)));
+  const minX = Math.min(...pads.map((pad) => mm(pad.center.x)));
+  const maxX = Math.max(...pads.map((pad) => mm(pad.center.x)));
+  const minY = Math.min(...pads.map((pad) => mm(pad.center.y)));
+  const maxY = Math.max(...pads.map((pad) => mm(pad.center.y)));
   const centerX = (minX + maxX) / 2;
   const centerY = (minY + maxY) / 2;
   return {
@@ -1612,7 +1565,7 @@ var computeCenterOffset = (easyeda) => {
 };
 
 // lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_mm2 = require("@tscircuit/mm");
+import { mm as mm2 } from "@tscircuit/mm";
 var handleSilkscreenPath = (track, index) => {
   return pcb_silkscreen_path.parse({
     type: "pcb_silkscreen_path",
@@ -1676,17 +1629,17 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
       source_component_id: "source_component_1",
       name: portNumber
     });
-    if (pad.holeRadius !== void 0 && (0, import_mm2.mm)(pad.holeRadius) !== 0) {
+    if (pad.holeRadius !== void 0 && mm2(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: (0, import_mm2.mm)(pad.center.x),
-          y: (0, import_mm2.mm)(pad.center.y),
-          hole_diameter: (0, import_mm2.mm)(pad.holeRadius) * 2,
-          outer_diameter: (0, import_mm2.mm)(pad.width),
-          radius: (0, import_mm2.mm)(pad.holeRadius),
+          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),
           port_hints: [portNumber],
           pcb_component_id: "pcb_component_1",
           pcb_port_id: `pcb_port_${index + 1}`,
@@ -1710,9 +1663,9 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
           type: "pcb_smtpad",
           pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
           shape: soupShape,
-          x: (0, import_mm2.mm)(pad.center.x),
-          y: (0, import_mm2.mm)(pad.center.y),
-          ...soupShape === "rect" ? { width: (0, import_mm2.mm)(pad.width), height: (0, import_mm2.mm)(pad.height) } : { radius: Math.min((0, import_mm2.mm)(pad.width), (0, import_mm2.mm)(pad.height)) / 2 },
+          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",
@@ -1728,7 +1681,7 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
       soupElements.push(handleSilkscreenArc(shape, index));
     }
   });
-  transformPCBElements(soupElements, (0, import_transformation_matrix2.scale)(1, -1));
+  transformPCBElements(soupElements, scale(1, -1));
   const svgNode = easyEdaJson.packageDetail.dataStr.shape.find(
     (a) => Boolean(a.type === "SVGNODE" && a.svgData.attrs?.uuid)
   );
@@ -1751,7 +1704,7 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
   if (shouldRecenter) {
     transformPCBElements(
       soupElements,
-      (0, import_transformation_matrix2.translate)(-centerOffset.x, centerOffset.y)
+      translate(-centerOffset.x, centerOffset.y)
     );
   }
   return soupElements;
@@ -1807,22 +1760,22 @@ async function fetchEasyEDAComponent(jlcpcbPartNumber) {
 }
 
 // lib/schemas/easy-eda-json-schema.ts
-var import_zod62 = require("zod");
+import { z as z61 } from "zod";
 
 // lib/schemas/single-letter-shape-schema.ts
-var import_zod61 = require("zod");
-var PointSchema2 = import_zod61.z.object({
-  x: import_zod61.z.number(),
-  y: import_zod61.z.number()
+import { z as z60 } from "zod";
+var PointSchema2 = z60.object({
+  x: z60.number(),
+  y: z60.number()
 });
-var RectangleShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("RECTANGLE"),
+var RectangleShapeOutputSchema = z60.object({
+  type: z60.literal("RECTANGLE"),
   position: PointSchema2,
-  width: import_zod61.z.number(),
-  height: import_zod61.z.number(),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
+  width: z60.number(),
+  height: z60.number(),
+  color: z60.string(),
+  lineWidth: z60.number(),
+  id: z60.string()
 });
 var parseRectangle = (str) => {
   const [, x, y, , , width, height, color, lineWidth, , , id] = str.split("~");
@@ -1836,15 +1789,15 @@ var parseRectangle = (str) => {
     id
   };
 };
-var RectangleShapeSchema = import_zod61.z.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
-var EllipseShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("ELLIPSE"),
+var RectangleShapeSchema = z60.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
+var EllipseShapeOutputSchema = z60.object({
+  type: z60.literal("ELLIPSE"),
   center: PointSchema2,
-  radiusX: import_zod61.z.number(),
-  radiusY: import_zod61.z.number(),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
+  radiusX: z60.number(),
+  radiusY: z60.number(),
+  color: z60.string(),
+  lineWidth: z60.number(),
+  id: z60.string()
 });
 var parseEllipse = (str) => {
   const [, x, y, radiusX, radiusY, color, lineWidth, , , id] = str.split("~");
@@ -1858,19 +1811,19 @@ var parseEllipse = (str) => {
     id
   };
 };
-var EllipseShapeSchema = import_zod61.z.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
-var PinShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("PIN"),
-  visibility: import_zod61.z.enum(["show", "hide"]),
-  pinNumber: import_zod61.z.number(),
-  x: import_zod61.z.number(),
-  y: import_zod61.z.number(),
-  rotation: import_zod61.z.number(),
-  id: import_zod61.z.string(),
-  label: import_zod61.z.string(),
-  labelColor: import_zod61.z.string(),
-  path: import_zod61.z.string(),
-  arrow: import_zod61.z.string()
+var EllipseShapeSchema = z60.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
+var PinShapeOutputSchema = z60.object({
+  type: z60.literal("PIN"),
+  visibility: z60.enum(["show", "hide"]),
+  pinNumber: z60.number(),
+  x: z60.number(),
+  y: z60.number(),
+  rotation: z60.number(),
+  id: z60.string(),
+  label: z60.string(),
+  labelColor: z60.string(),
+  path: z60.string(),
+  arrow: z60.string()
 });
 var parsePin = (pinString) => {
   const parts = pinString.split("~");
@@ -1897,13 +1850,13 @@ var parsePin = (pinString) => {
     arrow
   };
 };
-var PinShapeSchema = import_zod61.z.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
-var PolylineShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("POLYLINE"),
-  points: import_zod61.z.array(PointSchema2),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
+var PinShapeSchema = z60.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
+var PolylineShapeOutputSchema = z60.object({
+  type: z60.literal("POLYLINE"),
+  points: z60.array(PointSchema2),
+  color: z60.string(),
+  lineWidth: z60.number(),
+  id: z60.string()
 });
 var parsePoints2 = (pointsStr) => {
   return pointsStr.split(" ").reduce((acc, value, index) => {
@@ -1926,14 +1879,14 @@ var parsePolyline = (str) => {
     id
   };
 };
-var PolylineShapeSchema = import_zod61.z.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
-var PolygonShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("POLYGON"),
-  points: import_zod61.z.array(PointSchema2),
-  fillColor: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  lineColor: import_zod61.z.string(),
-  id: import_zod61.z.string()
+var PolylineShapeSchema = z60.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
+var PolygonShapeOutputSchema = z60.object({
+  type: z60.literal("POLYGON"),
+  points: z60.array(PointSchema2),
+  fillColor: z60.string(),
+  lineWidth: z60.number(),
+  lineColor: z60.string(),
+  id: z60.string()
 });
 var parsePolygon = (str) => {
   const [, ...rest] = str.split("~");
@@ -1947,8 +1900,8 @@ var parsePolygon = (str) => {
     id
   };
 };
-var PolygonShapeSchema = import_zod61.z.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
-var SingleLetterShapeSchema = import_zod61.z.string().transform((x) => {
+var PolygonShapeSchema = z60.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
+var SingleLetterShapeSchema = z60.string().transform((x) => {
   if (x.startsWith("R~")) return RectangleShapeSchema.parse(x);
   if (x.startsWith("E~")) return EllipseShapeSchema.parse(x);
   if (x.startsWith("P~")) return PinShapeSchema.parse(x);
@@ -1956,7 +1909,7 @@ var SingleLetterShapeSchema = import_zod61.z.string().transform((x) => {
   if (x.startsWith("PG~")) return PolygonShapeSchema.parse(x);
   throw new Error(`Invalid shape type: ${x}`);
 }).pipe(
-  import_zod61.z.union([
+  z60.union([
     RectangleShapeOutputSchema,
     EllipseShapeOutputSchema,
     PinShapeOutputSchema,
@@ -1966,81 +1919,81 @@ var SingleLetterShapeSchema = import_zod61.z.string().transform((x) => {
 );
 
 // lib/schemas/easy-eda-json-schema.ts
-var maybeNumber = import_zod62.z.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(import_zod62.z.number().nullable().optional());
-var SzlcscSchema = import_zod62.z.object({
-  id: import_zod62.z.number(),
-  number: import_zod62.z.string(),
-  step: import_zod62.z.number().optional(),
-  min: import_zod62.z.number().optional(),
-  price: import_zod62.z.number().optional(),
-  stock: import_zod62.z.number().optional(),
-  url: import_zod62.z.string().url().optional(),
-  image: import_zod62.z.string().optional().optional()
-});
-var LcscSchema = import_zod62.z.object({
-  id: import_zod62.z.number(),
-  number: import_zod62.z.string(),
-  step: import_zod62.z.number().optional(),
-  min: import_zod62.z.number().optional(),
-  price: import_zod62.z.number().optional(),
-  stock: import_zod62.z.number().optional(),
-  url: import_zod62.z.string().url().optional()
-});
-var OwnerSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  username: import_zod62.z.string(),
-  nickname: import_zod62.z.string(),
-  avatar: import_zod62.z.string()
-});
-var HeadSchema = import_zod62.z.object({
-  docType: import_zod62.z.string(),
-  editorVersion: import_zod62.z.string(),
-  c_para: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.string()),
-  x: import_zod62.z.number(),
-  y: import_zod62.z.number(),
-  puuid: import_zod62.z.string().optional(),
-  uuid: import_zod62.z.string(),
-  utime: import_zod62.z.number(),
-  importFlag: import_zod62.z.number(),
-  c_spiceCmd: import_zod62.z.any().optional(),
-  hasIdFlag: import_zod62.z.boolean()
-});
-var BBoxSchema = import_zod62.z.object({
-  x: import_zod62.z.number(),
-  y: import_zod62.z.number(),
-  width: import_zod62.z.number(),
-  height: import_zod62.z.number()
-});
-var LayerItemSchema = import_zod62.z.object({
-  name: import_zod62.z.string(),
-  color: import_zod62.z.string(),
-  visible: import_zod62.z.boolean(),
-  active: import_zod62.z.boolean(),
-  config: import_zod62.z.boolean(),
-  transparency: import_zod62.z.boolean()
-});
-var ObjectItemSchema = import_zod62.z.object({
-  name: import_zod62.z.string(),
-  visible: import_zod62.z.boolean(),
-  locked: import_zod62.z.boolean()
-});
-var DataStrSchema = import_zod62.z.object({
+var maybeNumber = z61.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(z61.number().nullable().optional());
+var SzlcscSchema = z61.object({
+  id: z61.number(),
+  number: z61.string(),
+  step: z61.number().optional(),
+  min: z61.number().optional(),
+  price: z61.number().optional(),
+  stock: z61.number().optional(),
+  url: z61.string().url().optional(),
+  image: z61.string().optional().optional()
+});
+var LcscSchema = z61.object({
+  id: z61.number(),
+  number: z61.string(),
+  step: z61.number().optional(),
+  min: z61.number().optional(),
+  price: z61.number().optional(),
+  stock: z61.number().optional(),
+  url: z61.string().url().optional()
+});
+var OwnerSchema = z61.object({
+  uuid: z61.string(),
+  username: z61.string(),
+  nickname: z61.string(),
+  avatar: z61.string()
+});
+var HeadSchema = z61.object({
+  docType: z61.string(),
+  editorVersion: z61.string(),
+  c_para: z61.record(z61.string(), z61.string()),
+  x: z61.number(),
+  y: z61.number(),
+  puuid: z61.string().optional(),
+  uuid: z61.string(),
+  utime: z61.number(),
+  importFlag: z61.number(),
+  c_spiceCmd: z61.any().optional(),
+  hasIdFlag: z61.boolean()
+});
+var BBoxSchema = z61.object({
+  x: z61.number(),
+  y: z61.number(),
+  width: z61.number(),
+  height: z61.number()
+});
+var LayerItemSchema = z61.object({
+  name: z61.string(),
+  color: z61.string(),
+  visible: z61.boolean(),
+  active: z61.boolean(),
+  config: z61.boolean(),
+  transparency: z61.boolean()
+});
+var ObjectItemSchema = z61.object({
+  name: z61.string(),
+  visible: z61.boolean(),
+  locked: z61.boolean()
+});
+var DataStrSchema = z61.object({
   head: HeadSchema,
-  canvas: import_zod62.z.string(),
-  shape: import_zod62.z.array(SingleLetterShapeSchema),
+  canvas: z61.string(),
+  shape: z61.array(SingleLetterShapeSchema),
   BBox: BBoxSchema,
-  colors: import_zod62.z.array(import_zod62.z.unknown())
+  colors: z61.array(z61.unknown())
 });
-var PackageDetailDataStrSchema = import_zod62.z.object({
+var PackageDetailDataStrSchema = z61.object({
   head: HeadSchema,
-  canvas: import_zod62.z.string(),
-  shape: import_zod62.z.array(import_zod62.z.string()).transform(
+  canvas: z61.string(),
+  shape: z61.array(z61.string()).transform(
     (shapes) => shapes.map((shape) => {
       const [type, ...data] = shape.split("~");
       return ShapeItemSchema.parse({ type, data: data.join("~") });
     })
-  ).pipe(import_zod62.z.array(PackageDetailShapeSchema)),
-  layers: import_zod62.z.array(import_zod62.z.string()).transform(
+  ).pipe(z61.array(PackageDetailShapeSchema)),
+  layers: z61.array(z61.string()).transform(
     (layers) => layers.map((layer) => {
       const [name, color, visible, active, config, transparency] = layer.split("~");
       return LayerItemSchema.parse({
@@ -2053,7 +2006,7 @@ var PackageDetailDataStrSchema = import_zod62.z.object({
       });
     })
   ),
-  objects: import_zod62.z.array(import_zod62.z.string()).transform(
+  objects: z61.array(z61.string()).transform(
     (objects) => objects.map((obj) => {
       const [name, visible, locked] = obj.split("~");
       return ObjectItemSchema.parse({
@@ -2064,43 +2017,43 @@ var PackageDetailDataStrSchema = import_zod62.z.object({
     })
   ),
   BBox: BBoxSchema,
-  netColors: import_zod62.z.array(import_zod62.z.unknown()).optional()
+  netColors: z61.array(z61.unknown()).optional()
 });
-var PackageDetailSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  title: import_zod62.z.string(),
-  docType: import_zod62.z.number(),
-  updateTime: import_zod62.z.number(),
+var PackageDetailSchema = z61.object({
+  uuid: z61.string(),
+  title: z61.string(),
+  docType: z61.number(),
+  updateTime: z61.number(),
   owner: OwnerSchema,
-  datastrid: import_zod62.z.string(),
-  writable: import_zod62.z.boolean(),
+  datastrid: z61.string(),
+  writable: z61.boolean(),
   dataStr: PackageDetailDataStrSchema
 });
-var EasyEdaJsonSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  title: import_zod62.z.string(),
-  description: import_zod62.z.string(),
-  docType: import_zod62.z.number(),
-  type: import_zod62.z.number(),
+var EasyEdaJsonSchema = z61.object({
+  uuid: z61.string(),
+  title: z61.string(),
+  description: z61.string(),
+  docType: z61.number(),
+  type: z61.number(),
   szlcsc: SzlcscSchema,
   lcsc: LcscSchema,
   owner: OwnerSchema,
-  tags: import_zod62.z.array(import_zod62.z.string()),
-  updateTime: import_zod62.z.number(),
-  updated_at: import_zod62.z.string(),
+  tags: z61.array(z61.string()),
+  updateTime: z61.number(),
+  updated_at: z61.string(),
   dataStr: DataStrSchema,
-  verify: import_zod62.z.boolean(),
-  SMT: import_zod62.z.boolean().optional(),
-  datastrid: import_zod62.z.string(),
-  jlcOnSale: import_zod62.z.number().optional(),
-  writable: import_zod62.z.boolean(),
-  isFavorite: import_zod62.z.boolean(),
+  verify: z61.boolean(),
+  SMT: z61.boolean().optional(),
+  datastrid: z61.string(),
+  jlcOnSale: z61.number().optional(),
+  writable: z61.boolean(),
+  isFavorite: z61.boolean(),
   packageDetail: PackageDetailSchema
 });
 
 // lib/generate-footprint-tsx.ts
-var import_zod63 = require("zod");
-var import_mm3 = require("@tscircuit/mm");
+import "zod";
+import { mm as mm3 } from "@tscircuit/mm";
 var generateFootprintTsx = (easyEdaJson) => {
   const pads = easyEdaJson.packageDetail.dataStr.shape.filter(
     (shape) => shape.type === "PAD"
@@ -2110,16 +2063,16 @@ var generateFootprintTsx = (easyEdaJson) => {
   const centerY = centerOffset.y;
   const footprintElements = pads.map((pad) => {
     const { center, width, height, holeRadius, number } = pad;
-    const isPlatedHole = holeRadius !== void 0 && (0, import_mm3.mm)(holeRadius) > 0;
-    const normalizedX = (0, import_mm3.mm)(center.x) - centerX;
-    const normalizedY = (0, import_mm3.mm)(center.y) - centerY;
+    const isPlatedHole = holeRadius !== void 0 && mm3(holeRadius) > 0;
+    const normalizedX = mm3(center.x) - centerX;
+    const normalizedY = mm3(center.y) - centerY;
     if (isPlatedHole) {
       return `
         <platedhole
           pcbX="${normalizedX.toFixed(2)}mm"
           pcbY="${normalizedY.toFixed(2)}mm"
-          hole_diameter="${(0, import_mm3.mm)(holeRadius) * 2}mm"
-          outer_diameter="${(0, import_mm3.mm)(width)}mm"
+          hole_diameter="${mm3(holeRadius) * 2}mm"
+          outer_diameter="${mm3(width)}mm"
           portHints={["${number}"]}
         />`.replace(/\n/, "");
     } else {
@@ -2127,8 +2080,8 @@ var generateFootprintTsx = (easyEdaJson) => {
         <smtpad
           pcbX="${normalizedX.toFixed(2)}mm"
           pcbY="${normalizedY.toFixed(2)}mm"
-          width="${(0, import_mm3.mm)(width)}mm"
-          height="${(0, import_mm3.mm)(height)}mm"
+          width="${mm3(width)}mm"
+          height="${mm3(height)}mm"
           shape="rect"
           portHints={["${number}"]}
         />`.replace(/\n/, "");
@@ -2256,8 +2209,8 @@ var checkModelObjUrlValidity = async (url) => {
 };
 
 // lib/convert-easyeda-json-to-various-formats.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
+import fs from "fs/promises";
+import * as path from "path";
 var convertEasyEdaJsonToVariousFormats = async ({
   jlcpcbPartNumberOrFilepath,
   outputFilename,
@@ -2266,7 +2219,7 @@ var convertEasyEdaJsonToVariousFormats = async ({
   let rawEasyEdaJson;
   if (jlcpcbPartNumberOrFilepath.includes(".") || jlcpcbPartNumberOrFilepath.includes("/")) {
     rawEasyEdaJson = JSON.parse(
-      await import_promises.default.readFile(jlcpcbPartNumberOrFilepath, "utf-8")
+      await fs.readFile(jlcpcbPartNumberOrFilepath, "utf-8")
     );
   } else {
     rawEasyEdaJson = await fetchEasyEDAComponent(jlcpcbPartNumberOrFilepath);
@@ -2292,7 +2245,7 @@ var convertEasyEdaJsonToVariousFormats = async ({
     process.exit(1);
   }
   if (outputFilename.endsWith(".raweasy.json")) {
-    await import_promises.default.writeFile(outputFilename, JSON.stringify(rawEasyEdaJson, null, 2));
+    await fs.writeFile(outputFilename, JSON.stringify(rawEasyEdaJson, null, 2));
     console.log(`Saved raw EasyEDA JSON: ${outputFilename}`);
     return;
   }
@@ -2300,16 +2253,16 @@ var convertEasyEdaJsonToVariousFormats = async ({
     const betterEasy = EasyEdaJsonSchema.parse(rawEasyEdaJson);
     const tscircuitSoup = convertEasyEdaJsonToTscircuitSoupJson(betterEasy);
     if (outputFilename.endsWith(".soup.json")) {
-      await import_promises.default.writeFile(outputFilename, JSON.stringify(tscircuitSoup, null, 2));
+      await fs.writeFile(outputFilename, JSON.stringify(tscircuitSoup, null, 2));
       console.log(`Converted to tscircuit soup JSON: ${outputFilename}`);
     } else if (outputFilename.endsWith(".kicad_mod")) {
       console.log("Conversion to KiCad footprint not yet implemented");
     } else if (outputFilename.endsWith(".bettereasy.json")) {
-      await import_promises.default.writeFile(outputFilename, JSON.stringify(betterEasy, null, 2));
+      await fs.writeFile(outputFilename, JSON.stringify(betterEasy, null, 2));
       console.log(`Saved better EasyEDA JSON: ${outputFilename}`);
     } else if (outputFilename.endsWith(".tsx") || outputFilename.endsWith(".ts")) {
       const tsComp = await convertRawEasyEdaToTs(rawEasyEdaJson);
-      await import_promises.default.writeFile(outputFilename, tsComp);
+      await fs.writeFile(outputFilename, tsComp);
       console.log(`Saved TypeScript component: ${outputFilename}`);
     } else {
       console.error("Unsupported output format");
@@ -2318,25 +2271,25 @@ var convertEasyEdaJsonToVariousFormats = async ({
     console.error("Error:", error.message);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BBoxSchema,
-  DataStrSchema,
-  EasyEdaJsonSchema,
+
+export {
+  convertEasyEdaJsonToCircuitJson,
+  convertEasyEdaJsonToTscircuitSoupJson,
+  fetchEasyEDAComponent,
+  maybeNumber,
+  SzlcscSchema,
+  LcscSchema,
+  OwnerSchema,
   HeadSchema,
+  BBoxSchema,
   LayerItemSchema,
-  LcscSchema,
   ObjectItemSchema,
-  OwnerSchema,
+  DataStrSchema,
   PackageDetailDataStrSchema,
   PackageDetailSchema,
-  SzlcscSchema,
-  convertEasyEdaJsonToCircuitJson,
-  convertEasyEdaJsonToTscircuitSoupJson,
-  convertEasyEdaJsonToVariousFormats,
+  EasyEdaJsonSchema,
+  normalizeManufacturerPartNumber,
   convertRawEasyEdaToTs,
-  fetchEasyEDAComponent,
-  maybeNumber,
-  normalizeManufacturerPartNumber
-});
-//# sourceMappingURL=index.cjs.map
+  convertEasyEdaJsonToVariousFormats
+};
+//# sourceMappingURL=chunk-3ZPJFTXV.js.map