easyeda 0.0.30 → 0.0.32

package/dist/chunk-3ZPJFTXV.js

@@ -0,0 +1,2295 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in 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.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, {
+  all_layers: () => all_layers,
+  any_circuit_element: () => any_circuit_element,
+  any_soup_element: () => any_soup_element,
+  any_source_component: () => any_source_component,
+  cad_component: () => cad_component,
+  capacitance: () => capacitance,
+  current: () => current,
+  distance: () => distance,
+  getZodPrefixedIdWithDefault: () => getZodPrefixedIdWithDefault,
+  inductance: () => inductance,
+  layer_ref: () => layer_ref,
+  layer_string: () => layer_string,
+  length: () => length,
+  pcb_board: () => pcb_board,
+  pcb_component: () => pcb_component,
+  pcb_fabrication_note_path: () => pcb_fabrication_note_path,
+  pcb_fabrication_note_text: () => pcb_fabrication_note_text,
+  pcb_hole: () => pcb_hole,
+  pcb_hole_circle_or_square_shape: () => pcb_hole_circle_or_square_shape,
+  pcb_hole_oval_shape: () => pcb_hole_oval_shape,
+  pcb_keepout: () => pcb_keepout,
+  pcb_placement_error: () => pcb_placement_error,
+  pcb_plated_hole: () => pcb_plated_hole,
+  pcb_port: () => pcb_port,
+  pcb_port_not_matched_error: () => pcb_port_not_matched_error,
+  pcb_route_hint: () => pcb_route_hint,
+  pcb_route_hints: () => pcb_route_hints,
+  pcb_silkscreen_circle: () => pcb_silkscreen_circle,
+  pcb_silkscreen_line: () => pcb_silkscreen_line,
+  pcb_silkscreen_oval: () => pcb_silkscreen_oval,
+  pcb_silkscreen_path: () => pcb_silkscreen_path,
+  pcb_silkscreen_rect: () => pcb_silkscreen_rect,
+  pcb_silkscreen_text: () => pcb_silkscreen_text,
+  pcb_smtpad: () => pcb_smtpad,
+  pcb_solder_paste: () => pcb_solder_paste,
+  pcb_text: () => pcb_text,
+  pcb_trace: () => pcb_trace,
+  pcb_trace_error: () => pcb_trace_error,
+  pcb_trace_hint: () => pcb_trace_hint,
+  pcb_trace_route_point: () => pcb_trace_route_point,
+  pcb_trace_route_point_via: () => pcb_trace_route_point_via,
+  pcb_trace_route_point_wire: () => pcb_trace_route_point_wire,
+  pcb_via: () => pcb_via,
+  point: () => point,
+  point3: () => point3,
+  position: () => position,
+  position3: () => position3,
+  resistance: () => resistance,
+  rotation: () => rotation,
+  route_hint_point: () => route_hint_point,
+  schematic_box: () => schematic_box,
+  schematic_component: () => schematic_component,
+  schematic_error: () => schematic_error,
+  schematic_line: () => schematic_line,
+  schematic_net_label: () => schematic_net_label,
+  schematic_path: () => schematic_path,
+  schematic_pin_styles: () => schematic_pin_styles,
+  schematic_port: () => schematic_port,
+  schematic_text: () => schematic_text,
+  schematic_trace: () => schematic_trace,
+  size: () => size,
+  source_component_base: () => source_component_base,
+  source_group: () => source_group,
+  source_led: () => source_led,
+  source_net: () => source_net,
+  source_port: () => source_port,
+  source_simple_bug: () => source_simple_bug,
+  source_simple_capacitor: () => source_simple_capacitor,
+  source_simple_chip: () => source_simple_chip,
+  source_simple_diode: () => source_simple_diode,
+  source_simple_ground: () => source_simple_ground,
+  source_simple_power_source: () => source_simple_power_source,
+  source_simple_resistor: () => source_simple_resistor,
+  source_trace: () => source_trace,
+  supplier_name: () => supplier_name,
+  time: () => time,
+  visible_layer: () => visible_layer,
+  voltage: () => voltage
+});
+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
+import { webcrypto as crypto } from "node:crypto";
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size2 = 21) {
+  fillPool(size2 -= 0);
+  let id = "";
+  for (let i = poolOffset - size2; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// node_modules/circuit-json/dist/index.mjs
+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",
+    variants: {
+      MHz: 1e6,
+      kHz: 1e3,
+      Hz: 1
+    }
+  },
+  g: {
+    baseUnit: "g",
+    variants: {
+      kg: 1e3,
+      g: 1
+    }
+  },
+  \u03A9: {
+    baseUnit: "\u03A9",
+    variants: {
+      m\u03A9: 1e-3,
+      \u03A9: 1,
+      k\u03A9: 1e3,
+      M\u03A9: 1e6,
+      G\u03A9: 1e9,
+      T\u03A9: 1e12
+    }
+  },
+  V: {
+    baseUnit: "V",
+    variants: {
+      mV: 1e-3,
+      V: 1,
+      kV: 1e3,
+      MV: 1e6,
+      GV: 1e9,
+      TV: 1e12
+    }
+  },
+  A: {
+    baseUnit: "A",
+    variants: {
+      \u00B5A: 1e-6,
+      mA: 1e-3,
+      ma: 1e-3,
+      A: 1,
+      kA: 1e3,
+      MA: 1e6
+    }
+  },
+  F: {
+    baseUnit: "F",
+    variants: {
+      pF: 1e-12,
+      nF: 1e-9,
+      \u00B5F: 1e-6,
+      mF: 1e-3,
+      F: 1
+    }
+  },
+  ml: {
+    baseUnit: "ml",
+    variants: {
+      ml: 1,
+      mL: 1,
+      l: 1e3,
+      L: 1e3
+    }
+  },
+  deg: {
+    baseUnit: "deg",
+    variants: {
+      rad: 180 / Math.PI
+    }
+  },
+  ms: {
+    baseUnit: "ms",
+    variants: {
+      s: 1e3
+    }
+  },
+  mm: {
+    baseUnit: "mm",
+    variants: {
+      nm: 1e-6,
+      \u00B5m: 1e-3,
+      um: 1e-3,
+      mm: 1,
+      cm: 10,
+      dm: 100,
+      m: 1e3,
+      km: 1e6,
+      in: 25.4,
+      ft: 304.8,
+      IN: 25.4,
+      FT: 304.8,
+      yd: 914.4,
+      mi: 1609344
+    }
+  }
+};
+function getBaseTscircuitUnit(unit) {
+  for (const [baseUnit, info] of Object.entries(unitMappings)) {
+    if (unit in info.variants) {
+      return {
+        baseUnit: info.baseUnit,
+        conversionFactor: info.variants[unit]
+      };
+    }
+  }
+  return {
+    baseUnit: unit,
+    conversionFactor: 1
+  };
+}
+var parseAndConvertSiUnit = (v) => {
+  if (typeof v === "undefined")
+    return { parsedUnit: null, unitOfValue: null, value: null };
+  if (typeof v === "string" && v.match(/^[\d\.]+$/))
+    return {
+      value: Number.parseFloat(v),
+      parsedUnit: null,
+      unitOfValue: null
+    };
+  if (typeof v === "number")
+    return { value: v, parsedUnit: null, unitOfValue: null };
+  if (typeof v === "object" && "x" in v && "y" in v) {
+    const { parsedUnit, unitOfValue } = parseAndConvertSiUnit(v.x);
+    return {
+      parsedUnit,
+      unitOfValue,
+      value: {
+        x: parseAndConvertSiUnit(v.x).value,
+        y: parseAndConvertSiUnit(v.y).value
+      }
+    };
+  }
+  const unit_reversed = v.split("").reverse().join("").match(/[a-zA-Z]+/)?.[0];
+  if (!unit_reversed) {
+    throw new Error(`Could not determine unit: "${v}"`);
+  }
+  const unit = unit_reversed.split("").reverse().join("");
+  const value = v.slice(0, -unit.length);
+  const { baseUnit, conversionFactor } = getBaseTscircuitUnit(unit);
+  return {
+    parsedUnit: unit,
+    unitOfValue: baseUnit,
+    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 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) => {
+  if (typeof arg === "number") return arg;
+  if (arg.endsWith("deg")) {
+    return Number.parseFloat(arg.split("deg")[0]);
+  }
+  if (arg.endsWith("rad")) {
+    return Number.parseFloat(arg.split("rad")[0]) * 180 / Math.PI;
+  }
+  return Number.parseFloat(arg);
+});
+var point = z22.object({
+  x: distance,
+  y: distance
+});
+var position = point;
+var point3 = z3.object({
+  x: distance,
+  y: distance,
+  z: distance
+});
+var position3 = point3;
+var size = z4.object({
+  width: z4.number(),
+  height: z4.number()
+});
+var getZodPrefixedIdWithDefault = (prefix) => {
+  return z5.string().optional().default(() => `${prefix}_${nanoid(10)}`);
+};
+var supplier_name = z6.enum([
+  "jlcpcb",
+  "macrofab",
+  "pcbway",
+  "digikey",
+  "mouser",
+  "lcsc"
+]);
+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: z8.literal("simple_capacitor"),
+  capacitance
+});
+var source_simple_resistor = source_component_base.extend({
+  ftype: z9.literal("simple_resistor"),
+  resistance
+});
+var source_simple_diode = source_component_base.extend({
+  ftype: z10.literal("simple_diode")
+});
+var source_simple_ground = source_component_base.extend({
+  ftype: z11.literal("simple_ground")
+});
+var source_simple_bug = source_component_base.extend({
+  ftype: z12.literal("simple_bug")
+}).describe("@deprecated");
+var source_simple_chip = source_component_base.extend({
+  ftype: z13.literal("simple_chip")
+});
+var source_simple_inductor = source_component_base.extend({
+  ftype: z14.literal("simple_inductor"),
+  inductance
+});
+var source_led = source_simple_diode.extend({
+  ftype: z15.literal("led")
+});
+var source_simple_power_source = source_component_base.extend({
+  ftype: z16.literal("simple_power_source"),
+  voltage
+});
+var any_source_component = z17.union([
+  source_simple_resistor,
+  source_simple_capacitor,
+  source_simple_diode,
+  source_simple_ground,
+  source_simple_chip,
+  source_simple_bug,
+  source_led,
+  source_simple_power_source
+]);
+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 = 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 = z24.object({
+  type: z24.literal("schematic_component"),
+  rotation: rotation.default(0),
+  size,
+  center: point,
+  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: 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()
+    }),
+    z24.object({
+      left_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["top-to-bottom", "bottom-to-top"]).optional()
+      }).optional(),
+      right_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["top-to-bottom", "bottom-to-top"]).optional()
+      }).optional(),
+      top_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["left-to-right", "right-to-left"]).optional()
+      }).optional(),
+      bottom_side: z24.object({
+        pins: z24.array(z24.number()),
+        direction: z24.enum(["left-to-right", "right-to-left"]).optional()
+      }).optional()
+    })
+  ]).optional(),
+  port_labels: z24.record(z24.string()).optional()
+});
+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 = 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: z26.object({
+        x: z26.number(),
+        y: z26.number()
+      }),
+      from_schematic_port_id: z26.string().optional(),
+      to_schematic_port_id: z26.string().optional()
+    })
+  )
+});
+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: 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: z28.enum(["up", "down", "left", "right"]).optional()
+}).describe("Defines a port on a schematic component");
+var schematic_net_label = z29.object({
+  type: z29.literal("schematic_net_label"),
+  source_net_id: z29.string(),
+  center: point,
+  anchor_side: z29.enum(["top", "bottom", "left", "right"]),
+  text: z29.string()
+});
+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: z30.literal("schematic_port_not_found"),
+  message: z30.string()
+}).describe("Defines a schematic error on the schematic");
+var all_layers = [
+  "top",
+  "bottom",
+  "inner1",
+  "inner2",
+  "inner3",
+  "inner4",
+  "inner5",
+  "inner6"
+];
+var layer_string = z31.enum(all_layers);
+var layer_ref = layer_string.or(
+  z31.object({
+    name: layer_string
+  })
+).transform((layer) => {
+  if (typeof layer === "string") {
+    return layer;
+  }
+  return layer.name;
+});
+var visible_layer = z31.enum(["top", "bottom"]);
+var pcb_route_hint = z32.object({
+  x: distance,
+  y: distance,
+  via: z32.boolean().optional(),
+  via_to_layer: layer_ref.optional()
+});
+var pcb_route_hints = z32.array(pcb_route_hint);
+var route_hint_point = z33.object({
+  x: distance,
+  y: distance,
+  via: z33.boolean().optional(),
+  to_layer: layer_ref.optional(),
+  trace_width: distance.optional()
+});
+var expectTypesMatch = (shouldBe) => {
+};
+var pcb_component = z34.object({
+  type: z34.literal("pcb_component"),
+  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
+  source_component_id: z34.string(),
+  center: point,
+  layer: layer_ref,
+  rotation,
+  width: length,
+  height: length
+}).describe("Defines a component on the PCB");
+expectTypesMatch(true);
+var pcb_hole_circle_or_square = z35.object({
+  type: z35.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  hole_shape: z35.enum(["circle", "square"]),
+  hole_diameter: z35.number(),
+  x: distance,
+  y: distance
+});
+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 = z35.object({
+  type: z35.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  hole_shape: z35.literal("oval"),
+  hole_width: z35.number(),
+  hole_height: z35.number(),
+  x: distance,
+  y: distance
+});
+var pcb_hole_oval_shape = pcb_hole_oval.describe(
+  "Defines an oval hole on the PCB"
+);
+expectTypesMatch(true);
+var pcb_hole = pcb_hole_circle_or_square.or(pcb_hole_oval);
+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: 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 = 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: 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 = z36.union([
+  pcb_plated_hole_circle,
+  pcb_plated_hole_oval
+]);
+expectTypesMatch(
+  true
+);
+expectTypesMatch(true);
+var pcb_port = z37.object({
+  type: z37.literal("pcb_port"),
+  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
+  source_port_id: z37.string(),
+  pcb_component_id: z37.string(),
+  x: distance,
+  y: distance,
+  layers: z37.array(layer_ref)
+}).describe("Defines a port on the PCB");
+expectTypesMatch(true);
+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: z38.number(),
+  layer: layer_ref,
+  port_hints: z38.array(z38.string()).optional(),
+  pcb_component_id: z38.string().optional(),
+  pcb_port_id: z38.string().optional()
+});
+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: z38.number(),
+  height: z38.number(),
+  layer: layer_ref,
+  port_hints: z38.array(z38.string()).optional(),
+  pcb_component_id: z38.string().optional(),
+  pcb_port_id: z38.string().optional()
+});
+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 = 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: z39.number(),
+  layer: layer_ref,
+  pcb_component_id: z39.string().optional(),
+  pcb_smtpad_id: z39.string().optional()
+});
+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: z39.number(),
+  height: z39.number(),
+  layer: layer_ref,
+  pcb_component_id: z39.string().optional(),
+  pcb_smtpad_id: z39.string().optional()
+});
+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 = z40.object({
+  type: z40.literal("pcb_text"),
+  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
+  text: z40.string(),
+  center: point,
+  layer: layer_ref,
+  width: length,
+  height: length,
+  lines: z40.number(),
+  align: z40.enum(["bottom-left"])
+}).describe("Defines text on the PCB");
+expectTypesMatch(true);
+var pcb_trace_route_point_wire = z41.object({
+  route_type: z41.literal("wire"),
+  x: distance,
+  y: distance,
+  width: distance,
+  start_pcb_port_id: z41.string().optional(),
+  end_pcb_port_id: z41.string().optional(),
+  layer: layer_ref
+});
+var pcb_trace_route_point_via = z41.object({
+  route_type: z41.literal("via"),
+  x: distance,
+  y: distance,
+  from_layer: z41.string(),
+  to_layer: z41.string()
+});
+var pcb_trace_route_point = z41.union([
+  pcb_trace_route_point_wire,
+  pcb_trace_route_point_via
+]);
+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: 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: z41.string().optional(),
+        end_pcb_port_id: z41.string().optional(),
+        layer: layer_ref
+      }),
+      z41.object({
+        route_type: z41.literal("via"),
+        x: distance,
+        y: distance,
+        from_layer: z41.string(),
+        to_layer: z41.string()
+      })
+    ])
+  )
+}).describe("Defines a trace on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_trace_error = z42.object({
+  type: z42.literal("pcb_trace_error"),
+  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
+  error_type: z42.literal("pcb_trace_error"),
+  message: z42.string(),
+  center: point.optional(),
+  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 = z43.object({
+  type: z43.literal("pcb_port_not_matched_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
+  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 = z44.object({
+  type: z44.literal("pcb_via"),
+  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
+  x: distance,
+  y: distance,
+  outer_diameter: distance.default("0.6mm"),
+  hole_diameter: distance.default("0.25mm"),
+  /** @deprecated */
+  from_layer: layer_ref.optional(),
+  /** @deprecated */
+  to_layer: layer_ref.optional(),
+  layers: z44.array(layer_ref),
+  pcb_trace_id: z44.string().optional()
+}).describe("Defines a via on the PCB");
+expectTypesMatch(true);
+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: z45.number().optional().default(4),
+  outline: z45.array(point).optional()
+}).describe("Defines the board outline of the PCB");
+expectTypesMatch(true);
+var pcb_placement_error = z46.object({
+  type: z46.literal("pcb_placement_error"),
+  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
+  message: z46.string()
+}).describe("Defines a placement error on the PCB");
+expectTypesMatch(true);
+var pcb_trace_hint = z47.object({
+  type: z47.literal("pcb_trace_hint"),
+  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
+  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 = z48.object({
+  type: z48.literal("pcb_silkscreen_line"),
+  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
+  pcb_component_id: z48.string(),
+  stroke_width: distance.default("0.1mm"),
+  x1: distance,
+  y1: distance,
+  x2: distance,
+  y2: distance,
+  layer: visible_layer
+}).describe("Defines a silkscreen line on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_path = z49.object({
+  type: z49.literal("pcb_silkscreen_path"),
+  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
+  pcb_component_id: z49.string(),
+  layer: visible_layer,
+  route: z49.array(point),
+  stroke_width: length
+}).describe("Defines a silkscreen path on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_text = z50.object({
+  type: z50.literal("pcb_silkscreen_text"),
+  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
+  font: z50.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("0.2mm"),
+  pcb_component_id: z50.string(),
+  text: z50.string(),
+  layer: layer_ref,
+  is_mirrored: z50.boolean().default(false).optional(),
+  anchor_position: point.default({ x: 0, y: 0 }),
+  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 = z51.object({
+  type: z51.literal("pcb_silkscreen_rect"),
+  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
+  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 = z52.object({
+  type: z52.literal("pcb_silkscreen_circle"),
+  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
+    "pcb_silkscreen_circle"
+  ),
+  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 = z53.object({
+  type: z53.literal("pcb_silkscreen_oval"),
+  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
+  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 = z54.object({
+  type: z54.literal("pcb_fabrication_note_text"),
+  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_text"
+  ),
+  font: z54.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("1mm"),
+  pcb_component_id: z54.string(),
+  text: z54.string(),
+  layer: visible_layer,
+  anchor_position: point.default({ x: 0, y: 0 }),
+  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 = z55.object({
+  type: z55.literal("pcb_fabrication_note_path"),
+  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_path"
+  ),
+  pcb_component_id: z55.string(),
+  layer: layer_ref,
+  route: z55.array(point),
+  stroke_width: length,
+  color: z55.string().optional()
+}).describe(
+  "Defines a fabrication path on the PCB for fabricators or assemblers"
+);
+expectTypesMatch(true);
+var pcb_keepout = z56.object({
+  type: z56.literal("pcb_keepout"),
+  shape: z56.literal("rect"),
+  center: point,
+  width: distance,
+  height: distance,
+  pcb_keepout_id: z56.string(),
+  layers: z56.array(z56.string()),
+  // Specify layers where the keepout applies
+  description: z56.string().optional()
+  // Optional description of the keepout
+}).or(
+  z56.object({
+    type: z56.literal("pcb_keepout"),
+    shape: z56.literal("circle"),
+    center: point,
+    radius: distance,
+    pcb_keepout_id: z56.string(),
+    layers: z56.array(z56.string()),
+    // Specify layers where the keepout applies
+    description: z56.string().optional()
+    // Optional description of the keepout
+  })
+);
+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: 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 = z58.union([
+  source_trace,
+  source_port,
+  any_source_component,
+  source_led,
+  source_net,
+  source_group,
+  source_simple_bug,
+  source_simple_chip,
+  source_simple_capacitor,
+  source_simple_diode,
+  source_simple_resistor,
+  source_simple_power_source,
+  pcb_component,
+  pcb_hole,
+  pcb_plated_hole,
+  pcb_keepout,
+  pcb_port,
+  pcb_text,
+  pcb_trace,
+  pcb_via,
+  pcb_smtpad,
+  pcb_solder_paste,
+  pcb_board,
+  pcb_trace_hint,
+  pcb_silkscreen_line,
+  pcb_silkscreen_path,
+  pcb_silkscreen_text,
+  pcb_silkscreen_rect,
+  pcb_silkscreen_circle,
+  pcb_silkscreen_oval,
+  pcb_trace_error,
+  pcb_placement_error,
+  pcb_port_not_matched_error,
+  pcb_fabrication_note_path,
+  pcb_fabrication_note_text,
+  schematic_box,
+  schematic_text,
+  schematic_line,
+  schematic_component,
+  schematic_port,
+  schematic_trace,
+  schematic_path,
+  schematic_error,
+  schematic_net_label,
+  cad_component
+]);
+var any_soup_element = any_circuit_element;
+
+// lib/math/arc-utils.ts
+function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag, sweepFlag) {
+  const start = { x: startX, y: startY };
+  const end = { x: endX, y: endY };
+  const midX = (startX + endX) / 2;
+  const midY = (startY + endY) / 2;
+  const dx = endX - startX;
+  const dy = endY - startY;
+  const distance2 = Math.sqrt(dx * dx + dy * dy);
+  if (distance2 === 0 || radius < distance2 / 2) {
+    return [start, end];
+  }
+  const h = Math.sqrt(radius * radius - distance2 * distance2 / 4);
+  const angle = Math.atan2(dy, dx);
+  const centerX = midX + h * Math.sin(angle) * (sweepFlag ? 1 : -1);
+  const centerY = midY - h * Math.cos(angle) * (sweepFlag ? 1 : -1);
+  const startAngle = Math.atan2(startY - centerY, startX - centerX);
+  let endAngle = Math.atan2(endY - centerY, endX - centerX);
+  if (!sweepFlag && endAngle > startAngle) {
+    endAngle -= 2 * Math.PI;
+  } else if (sweepFlag && endAngle < startAngle) {
+    endAngle += 2 * Math.PI;
+  }
+  if (!largeArcFlag && Math.abs(endAngle - startAngle) > Math.PI || largeArcFlag && Math.abs(endAngle - startAngle) < Math.PI) {
+    if (endAngle > startAngle) {
+      endAngle -= 2 * Math.PI;
+    } else {
+      endAngle += 2 * Math.PI;
+    }
+  }
+  const numPoints = Math.max(
+    2,
+    Math.ceil(Math.abs(endAngle - startAngle) * radius)
+  );
+  const path2 = [];
+  for (let i = 0; i <= numPoints; i++) {
+    const t = i / numPoints;
+    const angle2 = startAngle + t * (endAngle - startAngle);
+    const x = centerX + radius * Math.cos(angle2);
+    const y = centerY + radius * Math.sin(angle2);
+    path2.push({ x, y });
+  }
+  return path2;
+}
+
+// node_modules/@tscircuit/soup-util/dist/index.js
+import { applyToPoint, decomposeTSR } from "transformation-matrix";
+var su = (soup, options = {}) => {
+  let internalStore = soup._internal_store;
+  if (!internalStore) {
+    internalStore = {
+      counts: {}
+    };
+    soup._internal_store = internalStore;
+    for (const elm of soup) {
+      const type = elm.type;
+      const idVal = elm[`${type}_id`];
+      if (!idVal)
+        continue;
+      const idNum = Number.parseInt(idVal.split("_").pop());
+      if (!Number.isNaN(idNum)) {
+        internalStore.counts[type] = Math.max(
+          internalStore.counts[type] ?? 0,
+          idNum
+        );
+      }
+    }
+  }
+  const su22 = new Proxy(
+    {},
+    {
+      get: (proxy_target, component_type) => {
+        if (component_type === "toArray") {
+          return () => soup;
+        }
+        return {
+          get: (id) => soup.find(
+            (e) => e.type === component_type && e[`${component_type}_id`] === id
+          ),
+          getUsing: (using) => {
+            const keys = Object.keys(using);
+            if (keys.length !== 1) {
+              throw new Error(
+                "getUsing requires exactly one key, e.g. { pcb_component_id }"
+              );
+            }
+            const join_key = keys[0];
+            const join_type = join_key.replace("_id", "");
+            const joiner = soup.find(
+              (e) => e.type === join_type && e[join_key] === using[join_key]
+            );
+            if (!joiner)
+              return null;
+            return soup.find(
+              (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
+            );
+          },
+          getWhere: (where) => {
+            const keys = Object.keys(where);
+            return soup.find(
+              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+            );
+          },
+          list: (where) => {
+            const keys = !where ? [] : Object.keys(where);
+            return soup.filter(
+              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+            );
+          },
+          insert: (elm) => {
+            internalStore.counts[component_type] ??= -1;
+            internalStore.counts[component_type]++;
+            const index = internalStore.counts[component_type];
+            const newElm = {
+              type: component_type,
+              [`${component_type}_id`]: `${component_type}_${index}`,
+              ...elm
+            };
+            if (options.validateInserts) {
+              const parser = dist_exports[component_type] ?? any_soup_element;
+              parser.parse(newElm);
+            }
+            soup.push(newElm);
+            return newElm;
+          },
+          delete: (id) => {
+            const elm = soup.find(
+              (e) => e[`${component_type}_id`] === id
+            );
+            if (!elm)
+              return;
+            soup.splice(soup.indexOf(elm), 1);
+          },
+          update: (id, newProps) => {
+            const elm = soup.find(
+              (e) => e[`${component_type}_id`] === id
+            );
+            if (!elm)
+              return;
+            Object.assign(elm, newProps);
+            return elm;
+          },
+          select: (selector) => {
+            if (component_type === "source_component") {
+              return soup.find(
+                (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
+              );
+            } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
+              const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
+              const source_component = soup.find(
+                (e) => e.type === "source_component" && e.name === component_name
+              );
+              if (!source_component)
+                return null;
+              const source_port2 = soup.find(
+                (e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector))
+              );
+              if (!source_port2)
+                return null;
+              if (component_type === "source_port")
+                return source_port2;
+              if (component_type === "pcb_port") {
+                return soup.find(
+                  (e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id
+                );
+              } else if (component_type === "schematic_port") {
+                return soup.find(
+                  (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
+                );
+              }
+            }
+          }
+        };
+      }
+    }
+  );
+  return su22;
+};
+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 } = 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 = applyToPoint(matrix, elm.center);
+  } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
+    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 = 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 = applyToPoint(matrix, rp);
+      rp.x = tp.x;
+      rp.y = tp.y;
+      return rp;
+    });
+  } 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 = 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 = applyToPoint(matrix, {
+      x: elm.position.x,
+      y: elm.position.y
+    });
+    elm.position.x = newPos.x;
+    elm.position.y = newPos.y;
+  }
+  return elm;
+};
+var transformPCBElements = (elms, 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) {
+    transformedElms = transformedElms.map((elm) => {
+      if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
+        ;
+        [elm.width, elm.height] = [elm.height, elm.width];
+      }
+      return elm;
+    });
+  }
+  return transformedElms;
+};
+
+// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
+import { scale, translate } from "transformation-matrix";
+
+// lib/compute-center-offset.ts
+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) => 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 {
+    x: centerX,
+    y: centerY
+  };
+};
+
+// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
+import { mm as mm2 } from "@tscircuit/mm";
+var handleSilkscreenPath = (track, index) => {
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_path_${index + 1}`,
+    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 })),
+    stroke_width: track.width
+  });
+};
+var handleSilkscreenArc = (arc, index) => {
+  const arcPath = generateArcFromSweep(
+    arc.start.x,
+    arc.start.y,
+    arc.end.x,
+    arc.end.y,
+    arc.radiusX,
+    arc.largeArc,
+    arc.sweepDirection === "CW"
+  );
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_arc_${index + 1}`,
+    pcb_component_id: "pcb_component_1",
+    layer: "top",
+    // Assuming all silkscreen is on top layer
+    route: arcPath,
+    stroke_width: arc.width
+  });
+};
+var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
+  const soupElements = [];
+  const centerOffset = computeCenterOffset(easyEdaJson);
+  const source_component = any_source_component.parse({
+    type: "source_component",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug"
+  });
+  const pcb_component2 = pcb_component.parse({
+    type: "pcb_component",
+    pcb_component_id: "pcb_component_1",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug",
+    width: 0,
+    // TODO compute width
+    height: 0,
+    // TODO compute height
+    rotation: 0,
+    center: { x: centerOffset.x, y: centerOffset.y },
+    layer: "top"
+  });
+  soupElements.push(source_component, pcb_component2);
+  easyEdaJson.packageDetail.dataStr.shape.filter((shape) => shape.type === "PAD").forEach((pad, index) => {
+    const portNumber = pad.number.toString();
+    soupElements.push({
+      type: "source_port",
+      source_port_id: `source_port_${index + 1}`,
+      source_component_id: "source_component_1",
+      name: portNumber
+    });
+    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: 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}`,
+          layers: ["top"]
+        })
+      );
+    } else {
+      let soupShape;
+      if (pad.shape === "RECT") {
+        soupShape = "rect";
+      } else if (pad.shape === "ELLIPSE") {
+        soupShape = "rect";
+      } else if (pad.shape === "OVAL") {
+        soupShape = "rect";
+      }
+      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}`
+        })
+      );
+    }
+  });
+  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
+    if (shape.type === "TRACK") {
+      soupElements.push(handleSilkscreenPath(shape, index));
+    } else if (shape.type === "ARC") {
+      soupElements.push(handleSilkscreenArc(shape, index));
+    }
+  });
+  transformPCBElements(soupElements, scale(1, -1));
+  const svgNode = easyEdaJson.packageDetail.dataStr.shape.find(
+    (a) => Boolean(a.type === "SVGNODE" && a.svgData.attrs?.uuid)
+  );
+  const objFileUuid = svgNode?.svgData?.attrs?.uuid;
+  const objFileUrl = objFileUuid ? useModelCdn ? `https://modelcdn.tscircuit.com/easyeda_models/download?uuid=${objFileUuid}&pn=${easyEdaJson.lcsc.number}` : `https://modules.easyeda.com/3dmodel/${objFileUuid}` : void 0;
+  if (objFileUrl !== void 0) {
+    const [rx, ry, rz] = (svgNode?.svgData.attrs?.c_rotation ?? "0,0,0").split(",").map(Number);
+    soupElements.push(
+      cad_component.parse({
+        type: "cad_component",
+        cad_component_id: "cad_component_1",
+        source_component_id: "source_component_1",
+        pcb_component_id: "pcb_component_1",
+        position: { x: 0, y: 0, z: 0 },
+        rotation: { x: rx, y: ry, z: rz },
+        model_obj_url: objFileUrl
+      })
+    );
+  }
+  if (shouldRecenter) {
+    transformPCBElements(
+      soupElements,
+      translate(-centerOffset.x, centerOffset.y)
+    );
+  }
+  return soupElements;
+};
+var convertEasyEdaJsonToTscircuitSoupJson = convertEasyEdaJsonToCircuitJson;
+
+// lib/fetch-easyeda-json.ts
+async function fetchEasyEDAComponent(jlcpcbPartNumber) {
+  const searchUrl = "https://easyeda.com/api/components/search";
+  const componentUrl = (uuid) => `https://easyeda.com/api/components/${uuid}?version=6.4.7&uuid=${uuid}&datastrid=`;
+  const searchHeaders = {
+    authority: "easyeda.com",
+    pragma: "no-cache",
+    "cache-control": "no-cache",
+    accept: "application/json, text/javascript, */*; q=0.01",
+    "x-requested-with": "XMLHttpRequest",
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
+    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+    origin: "https://easyeda.com",
+    "sec-fetch-site": "same-origin",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-dest": "empty",
+    referer: "https://easyeda.com/editor",
+    "accept-language": "cs,en;q=0.9,sk;q=0.8,en-GB;q=0.7",
+    cookie: "<PUT your cookies here>"
+  };
+  const searchData = `type=3&doctype%5B%5D=2&uid=0819f05c4eef4c71ace90d822a990e87&returnListStyle=classifyarr&wd=${jlcpcbPartNumber}&version=6.4.7`;
+  const searchResponse = await fetch(searchUrl, {
+    method: "POST",
+    headers: searchHeaders,
+    body: searchData
+  });
+  if (!searchResponse.ok) {
+    throw new Error("Failed to search for the component");
+  }
+  const searchResult = await searchResponse.json();
+  if (!searchResult.success || !searchResult.result.lists.lcsc.length) {
+    throw new Error("Component not found");
+  }
+  const componentUUID = searchResult.result.lists.lcsc[0].uuid;
+  const componentResponse = await fetch(componentUrl(componentUUID), {
+    method: "GET",
+    headers: {
+      ...searchHeaders,
+      referer: `https://easyeda.com/editor?uuid=${componentUUID}`
+    }
+  });
+  if (!componentResponse.ok) {
+    throw new Error("Failed to fetch the component details");
+  }
+  const componentResult = await componentResponse.json();
+  return componentResult.result;
+}
+
+// lib/schemas/easy-eda-json-schema.ts
+import { z as z61 } from "zod";
+
+// lib/schemas/single-letter-shape-schema.ts
+import { z as z60 } from "zod";
+var PointSchema2 = z60.object({
+  x: z60.number(),
+  y: z60.number()
+});
+var RectangleShapeOutputSchema = z60.object({
+  type: z60.literal("RECTANGLE"),
+  position: PointSchema2,
+  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("~");
+  return {
+    type: "RECTANGLE",
+    position: { x: Number(x), y: Number(y) },
+    width: Number(width),
+    height: Number(height),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+var RectangleShapeSchema = z60.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
+var EllipseShapeOutputSchema = z60.object({
+  type: z60.literal("ELLIPSE"),
+  center: PointSchema2,
+  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("~");
+  return {
+    type: "ELLIPSE",
+    center: { x: Number(x), y: Number(y) },
+    radiusX: Number(radiusX),
+    radiusY: Number(radiusY),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+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("~");
+  const [, visibility, , pinNumber, x, y, rotation2, id] = parts;
+  const nameMatch = pinString.match(/~(\w+)~start~/);
+  const label = nameMatch ? nameMatch[1] : "";
+  const colorMatch = pinString.match(/#[0-9A-F]{6}/);
+  const labelColor = colorMatch ? colorMatch[0] : "";
+  const pathMatch = pinString.match(/\^\^([^~]+)/);
+  const path2 = pathMatch ? pathMatch[1] : "";
+  const arrowMatch = pinString.match(/\^\^0~(.+)$/);
+  const arrow = arrowMatch ? arrowMatch[1] : "";
+  return {
+    type: "PIN",
+    visibility,
+    id,
+    pinNumber: parseInt(pinNumber),
+    x: parseFloat(x),
+    y: parseFloat(y),
+    rotation: parseFloat(rotation2),
+    label,
+    labelColor,
+    path: path2,
+    arrow
+  };
+};
+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) => {
+    if (index % 2 === 0) {
+      acc.push({ x: Number(value), y: 0 });
+    } else {
+      acc[acc.length - 1].y = Number(value);
+    }
+    return acc;
+  }, []);
+};
+var parsePolyline = (str) => {
+  const [, ...rest] = str.split("~");
+  const [pointsStr, color, lineWidth, , , id] = rest;
+  return {
+    type: "POLYLINE",
+    points: parsePoints2(pointsStr),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+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("~");
+  const [pointsStr, fillColor, lineWidth, lineColor, , id] = rest;
+  return {
+    type: "POLYGON",
+    points: parsePoints2(pointsStr),
+    fillColor,
+    lineWidth: Number(lineWidth),
+    lineColor,
+    id
+  };
+};
+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);
+  if (x.startsWith("PL~")) return PolylineShapeSchema.parse(x);
+  if (x.startsWith("PG~")) return PolygonShapeSchema.parse(x);
+  throw new Error(`Invalid shape type: ${x}`);
+}).pipe(
+  z60.union([
+    RectangleShapeOutputSchema,
+    EllipseShapeOutputSchema,
+    PinShapeOutputSchema,
+    PolylineShapeOutputSchema,
+    PolygonShapeOutputSchema
+  ])
+);
+
+// lib/schemas/easy-eda-json-schema.ts
+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: z61.string(),
+  shape: z61.array(SingleLetterShapeSchema),
+  BBox: BBoxSchema,
+  colors: z61.array(z61.unknown())
+});
+var PackageDetailDataStrSchema = z61.object({
+  head: HeadSchema,
+  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(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({
+        name,
+        color,
+        visible: visible === "true",
+        active: active === "true",
+        config: config === "true",
+        transparency: transparency === "true"
+      });
+    })
+  ),
+  objects: z61.array(z61.string()).transform(
+    (objects) => objects.map((obj) => {
+      const [name, visible, locked] = obj.split("~");
+      return ObjectItemSchema.parse({
+        name,
+        visible: visible === "true",
+        locked: locked === "true"
+      });
+    })
+  ),
+  BBox: BBoxSchema,
+  netColors: z61.array(z61.unknown()).optional()
+});
+var PackageDetailSchema = z61.object({
+  uuid: z61.string(),
+  title: z61.string(),
+  docType: z61.number(),
+  updateTime: z61.number(),
+  owner: OwnerSchema,
+  datastrid: z61.string(),
+  writable: z61.boolean(),
+  dataStr: PackageDetailDataStrSchema
+});
+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: z61.array(z61.string()),
+  updateTime: z61.number(),
+  updated_at: z61.string(),
+  dataStr: DataStrSchema,
+  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
+import "zod";
+import { mm as mm3 } from "@tscircuit/mm";
+var generateFootprintTsx = (easyEdaJson) => {
+  const pads = easyEdaJson.packageDetail.dataStr.shape.filter(
+    (shape) => shape.type === "PAD"
+  );
+  const centerOffset = computeCenterOffset(easyEdaJson);
+  const centerX = centerOffset.x;
+  const centerY = centerOffset.y;
+  const footprintElements = pads.map((pad) => {
+    const { center, width, height, holeRadius, number } = pad;
+    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="${mm3(holeRadius) * 2}mm"
+          outer_diameter="${mm3(width)}mm"
+          portHints={["${number}"]}
+        />`.replace(/\n/, "");
+    } else {
+      return `
+        <smtpad
+          pcbX="${normalizedX.toFixed(2)}mm"
+          pcbY="${normalizedY.toFixed(2)}mm"
+          width="${mm3(width)}mm"
+          height="${mm3(height)}mm"
+          shape="rect"
+          portHints={["${number}"]}
+        />`.replace(/\n/, "");
+    }
+  });
+  return `
+      <footprint>
+        ${footprintElements.join("\n")}
+      </footprint>
+  `.trim();
+};
+
+// lib/convert-to-typescript-component/soup-typescript-component-template.ts
+var soupTypescriptComponentTemplate = ({
+  pinLabels,
+  componentName,
+  schPinArrangement,
+  objUrl,
+  easyEdaJson
+}) => {
+  const footprintTsx = generateFootprintTsx(easyEdaJson);
+  return `
+import { createUseComponent } from "tscircuit"
+import type { CommonLayoutProps } from "@tscircuit/props"
+
+const pinLabels = ${JSON.stringify(pinLabels, null, "  ")} as const
+const pinNames = Object.values(pinLabels)
+
+interface Props extends CommonLayoutProps {
+  name: string
+}
+
+export const ${componentName} = (props: Props) => {
+  return (
+    <bug
+      {...props}
+      footprint={${footprintTsx}}
+      ${objUrl ? `cadModel={{
+        objUrl: "${objUrl}"
+      }}` : ""}
+      pinLabels={pinLabels}
+      schPinSpacing={0.75}
+      schPortArrangement={${JSON.stringify(schPinArrangement, null, "  ")}}
+    />
+  )
+}
+
+export const use${componentName} = createUseComponent(${componentName}, pinNames)
+
+`.trim();
+};
+
+// lib/utils/normalize-manufacturer-part-number.ts
+function normalizeManufacturerPartNumber(partNumber) {
+  let normalized = partNumber.replace(/[-]/g, "_").replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(normalized)) {
+    normalized = "A_" + normalized;
+  }
+  return normalized;
+}
+
+// lib/convert-to-typescript-component/index.tsx
+var convertRawEasyEdaToTs = async (rawEasy) => {
+  const easyeda = EasyEdaJsonSchema.parse(rawEasy);
+  const soup = convertEasyEdaJsonToTscircuitSoupJson(easyeda, {
+    useModelCdn: true
+  });
+  const result = await convertToTypescriptComponent({
+    easyeda,
+    soup
+  });
+  return result;
+};
+var convertToTypescriptComponent = async ({
+  soup,
+  easyeda: easyEdaJson
+}) => {
+  const rawPn = easyEdaJson.dataStr.head.c_para["Manufacturer Part"];
+  const pn = normalizeManufacturerPartNumber(rawPn);
+  const [cad_component2] = su_default(soup).cad_component.list();
+  const pinLabels = {};
+  easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN").forEach((pin) => {
+    const isPinLabelNumeric = /^\d+$/.test(pin.label);
+    const label = isPinLabelNumeric ? `pin${pin.label}` : pin.label;
+    pinLabels[pin.pinNumber.toString()] = label;
+  });
+  const pins = easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN");
+  const leftPins = pins.filter((pin) => pin.rotation === 180);
+  const rightPins = pins.filter((pin) => pin.rotation === 0);
+  const schPinArrangement = {
+    leftSide: {
+      direction: "top-to-bottom",
+      pins: leftPins.map((pin) => pin.pinNumber)
+    },
+    rightSide: {
+      direction: "bottom-to-top",
+      pins: rightPins.map((pin) => pin.pinNumber).reverse()
+    }
+  };
+  let modelObjUrl;
+  if (cad_component2.model_obj_url) {
+    const isValidUrl = await checkModelObjUrlValidity(
+      cad_component2.model_obj_url
+    );
+    if (isValidUrl) {
+      modelObjUrl = cad_component2.model_obj_url;
+    }
+  }
+  return soupTypescriptComponentTemplate({
+    componentName: pn,
+    pinLabels,
+    schPinArrangement,
+    objUrl: modelObjUrl,
+    easyEdaJson
+  });
+};
+var checkModelObjUrlValidity = async (url) => {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    return response.status === 200;
+  } catch (error) {
+    console.error(`Error checking model object URL ${url}:`, error);
+    return false;
+  }
+};
+
+// lib/convert-easyeda-json-to-various-formats.ts
+import fs from "fs/promises";
+import * as path from "path";
+var convertEasyEdaJsonToVariousFormats = async ({
+  jlcpcbPartNumberOrFilepath,
+  outputFilename,
+  formatType
+}) => {
+  let rawEasyEdaJson;
+  if (jlcpcbPartNumberOrFilepath.includes(".") || jlcpcbPartNumberOrFilepath.includes("/")) {
+    rawEasyEdaJson = JSON.parse(
+      await fs.readFile(jlcpcbPartNumberOrFilepath, "utf-8")
+    );
+  } else {
+    rawEasyEdaJson = await fetchEasyEDAComponent(jlcpcbPartNumberOrFilepath);
+  }
+  const tsxExtension = "tsx";
+  if (formatType === "ts") formatType = tsxExtension;
+  if (!outputFilename && formatType) {
+    let filename = path.basename(jlcpcbPartNumberOrFilepath).split(".")[0];
+    if (formatType === tsxExtension) {
+      const {
+        dataStr: {
+          head: {
+            c_para: { "Manufacturer Part": manufacturerPartNumber }
+          }
+        }
+      } = rawEasyEdaJson;
+      filename = normalizeManufacturerPartNumber(manufacturerPartNumber);
+    }
+    outputFilename = `${filename}.${formatType}`;
+  }
+  if (!outputFilename) {
+    console.log("specify --output file (-o) or --type (-t)");
+    process.exit(1);
+  }
+  if (outputFilename.endsWith(".raweasy.json")) {
+    await fs.writeFile(outputFilename, JSON.stringify(rawEasyEdaJson, null, 2));
+    console.log(`Saved raw EasyEDA JSON: ${outputFilename}`);
+    return;
+  }
+  try {
+    const betterEasy = EasyEdaJsonSchema.parse(rawEasyEdaJson);
+    const tscircuitSoup = convertEasyEdaJsonToTscircuitSoupJson(betterEasy);
+    if (outputFilename.endsWith(".soup.json")) {
+      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 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 fs.writeFile(outputFilename, tsComp);
+      console.log(`Saved TypeScript component: ${outputFilename}`);
+    } else {
+      console.error("Unsupported output format");
+    }
+  } catch (error) {
+    console.error("Error:", error.message);
+  }
+};
+
+export {
+  convertEasyEdaJsonToCircuitJson,
+  convertEasyEdaJsonToTscircuitSoupJson,
+  fetchEasyEDAComponent,
+  maybeNumber,
+  SzlcscSchema,
+  LcscSchema,
+  OwnerSchema,
+  HeadSchema,
+  BBoxSchema,
+  LayerItemSchema,
+  ObjectItemSchema,
+  DataStrSchema,
+  PackageDetailDataStrSchema,
+  PackageDetailSchema,
+  EasyEdaJsonSchema,
+  normalizeManufacturerPartNumber,
+  convertRawEasyEdaToTs,
+  convertEasyEdaJsonToVariousFormats
+};
+//# sourceMappingURL=chunk-3ZPJFTXV.js.map