easyeda 0.0.127 → 0.0.128

package/dist/browser/index.js

@@ -0,0 +1,3154 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// lib/schemas/easy-eda-json-schema.ts
+import { z as z3 } from "zod";
+
+// lib/schemas/package-detail-shape-schema.ts
+import { z } from "zod";
+var tenthmil = z.union([z.number(), z.string()]).optional().transform(
+  (n) => typeof n === "string" && n.endsWith("mil") ? n : `${Number.parseFloat(n) * 10}mil`
+).pipe(z.string());
+var PointSchema = z.any().transform((p) => {
+  if (Array.isArray(p)) {
+    const [x, y] = p;
+    return { x, y };
+  } else if (typeof p === "object") {
+    return p;
+  }
+  throw new Error(`Invalid point: ${p}`);
+}).pipe(
+  z.object({
+    x: z.number(),
+    y: z.number()
+  })
+);
+var BaseShapeSchema = z.object({
+  type: z.string(),
+  id: z.string().optional(),
+  layer: z.coerce.number().optional()
+});
+var TrackSchema = BaseShapeSchema.extend({
+  type: z.literal("TRACK"),
+  width: z.coerce.number(),
+  points: z.array(PointSchema)
+});
+var PadSchema = BaseShapeSchema.extend({
+  type: z.literal("PAD"),
+  shape: z.enum(["RECT", "ELLIPSE", "OVAL"]),
+  center: z.object({
+    x: tenthmil,
+    y: tenthmil
+  }),
+  width: tenthmil,
+  height: tenthmil,
+  layermask: z.number(),
+  net: z.union([z.string(), z.number()]).optional(),
+  number: z.union([z.string(), z.number()]),
+  holeRadius: tenthmil,
+  points: z.array(PointSchema).optional(),
+  rotation: z.number().optional(),
+  plated: z.boolean()
+});
+var ArcSchema = BaseShapeSchema.extend({
+  type: z.literal("ARC"),
+  width: z.number(),
+  start: PointSchema,
+  end: PointSchema,
+  radiusX: z.number(),
+  radiusY: z.number(),
+  largeArc: z.boolean(),
+  sweepDirection: z.enum(["CW", "CCW"])
+});
+var CircleSchema = BaseShapeSchema.extend({
+  type: z.literal("CIRCLE"),
+  center: PointSchema,
+  radius: z.number(),
+  width: z.number()
+});
+var SolidRegionSchema = BaseShapeSchema.extend({
+  type: z.literal("SOLIDREGION"),
+  layermask: z.number(),
+  points: z.array(PointSchema),
+  fillStyle: z.string()
+});
+var SVGNodeSchema = BaseShapeSchema.extend({
+  type: z.literal("SVGNODE"),
+  svgData: z.object({
+    gId: z.string(),
+    nodeName: z.string(),
+    nodeType: z.number(),
+    layerid: z.string(),
+    attrs: z.record(z.string(), z.string()),
+    childNodes: z.array(z.unknown())
+  })
+});
+var HoleSchema = BaseShapeSchema.extend({
+  type: z.literal("HOLE"),
+  center: PointSchema,
+  radius: z.number()
+});
+var RectSchema = BaseShapeSchema.extend({
+  type: z.literal("RECT"),
+  x: tenthmil,
+  y: tenthmil,
+  width: tenthmil,
+  height: tenthmil,
+  lineWidth: z.number(),
+  fillStyle: z.string(),
+  rotation: z.number().optional()
+});
+var TextSchema = BaseShapeSchema.extend({
+  type: z.literal("TEXT"),
+  text: z.string(),
+  x: tenthmil,
+  y: tenthmil,
+  size_mm: z.number(),
+  rotation: z.number().optional(),
+  layer: z.number().optional(),
+  textAnchor: z.enum(["L", "C", "R", ""]).optional().transform((val) => val === "" ? void 0 : val),
+  font: z.string().optional()
+});
+var PackageDetailShapeSchema = z.discriminatedUnion("type", [
+  TrackSchema,
+  PadSchema,
+  ArcSchema,
+  CircleSchema,
+  SolidRegionSchema,
+  SVGNodeSchema,
+  HoleSchema,
+  RectSchema,
+  TextSchema
+]);
+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 match = arcData.match(
+        /M\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)\s*A\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)/
+      );
+      if (!match) {
+        throw new Error(`Invalid arc data: ${arcData}`);
+      }
+      const [
+        ,
+        startX,
+        startY,
+        radiusX,
+        radiusY,
+        xAxisRotation,
+        largeArcFlag,
+        sweepFlag,
+        endX,
+        endY
+      ] = match;
+      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
+      });
+    }
+    case "TEXT": {
+      const [textAnchor, x, y, size2, layer, id, rotation2, , font, text] = shape.data.split("~");
+      return TextSchema.parse({
+        type: "TEXT",
+        text,
+        x,
+        y,
+        size_mm: Number(size2) * 2.54,
+        // empirically this seems to match, C5248081 is a good test case
+        layer: layer ? Number(layer) : void 0,
+        id,
+        rotation: rotation2 ? Number(rotation2) : void 0,
+        textAnchor,
+        font: font || 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/schemas/single-letter-shape-schema.ts
+import { z as z2 } from "zod";
+import "@tscircuit/mm";
+
+// lib/utils/easyeda-unit-to-mm.ts
+var mil10ToMm = (value) => value * 10 * 0.0254;
+
+// lib/schemas/single-letter-shape-schema.ts
+var PointSchema2 = z2.object({
+  x: z2.number(),
+  y: z2.number()
+});
+var RectangleShapeOutputSchema = z2.object({
+  type: z2.literal("RECTANGLE"),
+  position: PointSchema2,
+  width: z2.number(),
+  height: z2.number(),
+  color: z2.string(),
+  lineWidth: z2.number(),
+  id: z2.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 = z2.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
+var EllipseShapeOutputSchema = z2.object({
+  type: z2.literal("ELLIPSE"),
+  center: PointSchema2,
+  radiusX: z2.number(),
+  radiusY: z2.number(),
+  color: z2.string(),
+  lineWidth: z2.number(),
+  id: z2.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 = z2.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
+var PinShapeOutputSchema = z2.object({
+  type: z2.literal("PIN"),
+  visibility: z2.enum(["show", "hide"]),
+  pinNumber: z2.union([z2.string(), z2.number()]),
+  x: z2.number(),
+  y: z2.number(),
+  rotation: z2.number(),
+  id: z2.string(),
+  label: z2.string(),
+  labelColor: z2.string(),
+  path: z2.string(),
+  arrow: z2.string()
+});
+var parsePin = (pinString) => {
+  const parts = pinString.split("~");
+  const [, visibility, , pinNumber, x, y, rotation2, id] = parts;
+  const nameMatch = pinString.match(/~(\w+)~(start|end)~/);
+  const label = nameMatch ? nameMatch[1] : "";
+  const colorMatch = pinString.match(/#[0-9A-F]{6}/);
+  const labelColor = colorMatch ? colorMatch[0] : "";
+  const pathMatch = pinString.match(/\^\^([^~]+)/);
+  const path = pathMatch ? pathMatch[1] : "";
+  const arrowMatch = pinString.match(/\^\^0~(.+)$/);
+  const arrow = arrowMatch ? arrowMatch[1] : "";
+  return {
+    type: "PIN",
+    visibility,
+    id,
+    pinNumber: isNaN(Number(pinNumber)) ? pinNumber : Number(pinNumber),
+    x: parseFloat(x),
+    y: parseFloat(y),
+    rotation: parseFloat(rotation2),
+    label,
+    labelColor,
+    path,
+    arrow
+  };
+};
+var PinShapeSchema = z2.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
+var PolylineShapeOutputSchema = z2.object({
+  type: z2.literal("POLYLINE"),
+  points: z2.array(PointSchema2),
+  color: z2.string(),
+  lineWidth: z2.number(),
+  id: z2.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 = z2.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
+var PolygonShapeOutputSchema = z2.object({
+  type: z2.literal("POLYGON"),
+  points: z2.array(PointSchema2),
+  fillColor: z2.string(),
+  lineWidth: z2.number(),
+  lineColor: z2.string(),
+  id: z2.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 = z2.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
+var PathShapeOutputSchema = z2.object({
+  type: z2.literal("PATH"),
+  pathData: z2.string(),
+  fillColor: z2.string(),
+  strokeWidth: z2.number(),
+  strokeColor: z2.string(),
+  id: z2.string()
+});
+var parsePath = (str) => {
+  const [, pathData, fillColor, strokeWidth, strokeColor, , id] = str.split("~");
+  return {
+    type: "PATH",
+    pathData,
+    fillColor,
+    strokeWidth: mil10ToMm(Number(strokeWidth)),
+    strokeColor,
+    id
+  };
+};
+var PathShapeSchema = z2.string().startsWith("PT~").transform(parsePath).pipe(PathShapeOutputSchema);
+var TextShapeOutputSchema = z2.object({
+  type: z2.literal("TEXT"),
+  alignment: z2.enum(["L", "C", "R"]),
+  x: z2.number(),
+  y: z2.number(),
+  rotation: z2.number(),
+  fontColor: z2.string(),
+  backgroundColor: z2.string().optional(),
+  fontSize: z2.string(),
+  fontWeight: z2.enum(["normal", "bold"]).optional().default("normal"),
+  fontStyle: z2.enum(["normal", "italic"]).optional().default("normal"),
+  fontDecoration: z2.enum(["", "underline"]),
+  content: z2.string(),
+  textType: z2.string(),
+  visibility: z2.enum(["0", "1"]),
+  mirror: z2.string(),
+  id: z2.string()
+});
+var parseText = (str) => {
+  const [
+    ,
+    alignment,
+    x,
+    y,
+    rotation2,
+    fontColor,
+    backgroundColor,
+    fontSize,
+    fontWeight,
+    fontStyle,
+    fontDecoration,
+    content,
+    textType,
+    visibility,
+    mirror,
+    id
+  ] = str.split("~");
+  return {
+    type: "TEXT",
+    alignment,
+    x: Number(x),
+    y: Number(y),
+    rotation: Number(rotation2),
+    fontColor,
+    backgroundColor: backgroundColor || void 0,
+    fontSize,
+    fontWeight: fontWeight || "normal",
+    fontStyle: fontStyle || "normal",
+    fontDecoration,
+    content,
+    textType,
+    visibility,
+    mirror,
+    id
+  };
+};
+var TextShapeSchema = z2.string().startsWith("T~").transform(parseText).pipe(TextShapeOutputSchema);
+var SingleLetterShapeSchema = z2.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);
+  if (x.startsWith("PT~")) return PathShapeSchema.parse(x);
+  if (x.startsWith("T~")) return TextShapeSchema.parse(x);
+  throw new Error(`Invalid shape type: ${x}`);
+}).pipe(
+  z2.union([
+    RectangleShapeOutputSchema,
+    EllipseShapeOutputSchema,
+    PinShapeOutputSchema,
+    PolylineShapeOutputSchema,
+    PolygonShapeOutputSchema,
+    PathShapeOutputSchema,
+    TextShapeOutputSchema
+  ])
+);
+
+// lib/schemas/easy-eda-json-schema.ts
+var maybeNumber = z3.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(z3.number().nullable().optional());
+var SzlcscSchema = z3.object({
+  id: z3.number(),
+  number: z3.string(),
+  step: z3.number().optional(),
+  min: z3.number().optional(),
+  price: z3.number().optional(),
+  stock: z3.number().optional(),
+  url: z3.string().url().optional(),
+  image: z3.string().optional().optional()
+});
+var LcscSchema = z3.object({
+  id: z3.number(),
+  number: z3.string(),
+  step: z3.number().optional(),
+  min: z3.number().optional(),
+  price: z3.number().optional(),
+  stock: z3.number().optional(),
+  url: z3.string().url().optional()
+});
+var OwnerSchema = z3.object({
+  uuid: z3.string(),
+  username: z3.string(),
+  nickname: z3.string(),
+  avatar: z3.string()
+});
+var HeadSchema = z3.object({
+  docType: z3.string(),
+  editorVersion: z3.string(),
+  c_para: z3.record(z3.string(), z3.string()),
+  x: z3.number(),
+  y: z3.number(),
+  puuid: z3.string().optional(),
+  uuid: z3.string(),
+  utime: z3.number(),
+  importFlag: z3.number().optional(),
+  c_spiceCmd: z3.any().optional(),
+  hasIdFlag: z3.boolean()
+});
+var BBoxSchema = z3.object({
+  x: z3.number(),
+  y: z3.number(),
+  width: z3.number(),
+  height: z3.number()
+});
+var LayerItemSchema = z3.object({
+  name: z3.string(),
+  color: z3.string(),
+  visible: z3.boolean(),
+  active: z3.boolean(),
+  config: z3.boolean(),
+  transparency: z3.boolean()
+});
+var ObjectItemSchema = z3.object({
+  name: z3.string(),
+  visible: z3.boolean(),
+  locked: z3.boolean()
+});
+var DataStrSchema = z3.object({
+  head: HeadSchema,
+  canvas: z3.string(),
+  shape: z3.array(SingleLetterShapeSchema),
+  BBox: BBoxSchema,
+  colors: z3.array(z3.unknown())
+});
+var PackageDetailDataStrSchema = z3.object({
+  head: HeadSchema,
+  canvas: z3.string(),
+  shape: z3.array(z3.string()).transform(
+    (shapes) => shapes.map((shape) => {
+      const [type, ...data] = shape.split("~");
+      return ShapeItemSchema.parse({ type, data: data.join("~") });
+    })
+  ).pipe(z3.array(PackageDetailShapeSchema)),
+  layers: z3.array(z3.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: z3.array(z3.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: z3.array(z3.unknown()).optional()
+});
+var PackageDetailSchema = z3.object({
+  uuid: z3.string(),
+  title: z3.string(),
+  docType: z3.number(),
+  updateTime: z3.number(),
+  owner: OwnerSchema,
+  datastrid: z3.string(),
+  writable: z3.boolean(),
+  dataStr: PackageDetailDataStrSchema
+});
+var EasyEdaJsonSchema = z3.object({
+  uuid: z3.string(),
+  title: z3.string(),
+  description: z3.string(),
+  docType: z3.number(),
+  type: z3.number(),
+  szlcsc: SzlcscSchema,
+  lcsc: LcscSchema,
+  owner: OwnerSchema,
+  tags: z3.array(z3.string()),
+  updateTime: z3.number(),
+  updated_at: z3.string(),
+  dataStr: DataStrSchema,
+  verify: z3.boolean(),
+  SMT: z3.boolean().optional(),
+  datastrid: z3.string(),
+  jlcOnSale: z3.number().optional(),
+  writable: z3.boolean(),
+  isFavorite: z3.boolean(),
+  packageDetail: PackageDetailSchema
+});
+
+// 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,
+  battery_capacity: () => battery_capacity,
+  cad_component: () => cad_component,
+  capacitance: () => capacitance,
+  current: () => current,
+  distance: () => distance,
+  frequency: () => frequency,
+  getZodPrefixedIdWithDefault: () => getZodPrefixedIdWithDefault,
+  inductance: () => inductance,
+  layer_ref: () => layer_ref,
+  layer_string: () => layer_string,
+  length: () => length,
+  pcb_autorouting_error: () => pcb_autorouting_error,
+  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_group: () => pcb_group,
+  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_manual_edit_conflict_error: () => pcb_manual_edit_conflict_error,
+  pcb_missing_footprint_error: () => pcb_missing_footprint_error,
+  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_smtpad_pill: () => pcb_smtpad_pill,
+  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,
+  port_arrangement: () => port_arrangement,
+  position: () => position,
+  position3: () => position3,
+  resistance: () => resistance,
+  rotation: () => rotation,
+  route_hint_point: () => route_hint_point,
+  schematic_box: () => schematic_box,
+  schematic_component: () => schematic_component,
+  schematic_component_port_arrangement_by_sides: () => schematic_component_port_arrangement_by_sides,
+  schematic_component_port_arrangement_by_size: () => schematic_component_port_arrangement_by_size,
+  schematic_debug_line: () => schematic_debug_line,
+  schematic_debug_object: () => schematic_debug_object,
+  schematic_debug_object_base: () => schematic_debug_object_base,
+  schematic_debug_point: () => schematic_debug_point,
+  schematic_debug_rect: () => schematic_debug_rect,
+  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,
+  schematic_voltage_probe: () => schematic_voltage_probe,
+  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_project_metadata: () => source_project_metadata,
+  source_simple_battery: () => source_simple_battery,
+  source_simple_bug: () => source_simple_bug,
+  source_simple_capacitor: () => source_simple_capacitor,
+  source_simple_chip: () => source_simple_chip,
+  source_simple_crystal: () => source_simple_crystal,
+  source_simple_diode: () => source_simple_diode,
+  source_simple_ground: () => source_simple_ground,
+  source_simple_inductor: () => source_simple_inductor,
+  source_simple_mosfet: () => source_simple_mosfet,
+  source_simple_pin_header: () => source_simple_pin_header,
+  source_simple_potentiometer: () => source_simple_potentiometer,
+  source_simple_power_source: () => source_simple_power_source,
+  source_simple_push_button: () => source_simple_push_button,
+  source_simple_resistor: () => source_simple_resistor,
+  source_simple_resonator: () => source_simple_resonator,
+  source_simple_switch: () => source_simple_switch,
+  source_simple_transistor: () => source_simple_transistor,
+  source_trace: () => source_trace,
+  supplier_name: () => supplier_name,
+  time: () => time,
+  visible_layer: () => visible_layer,
+  voltage: () => voltage
+});
+import { z as z4 } from "zod";
+import { z as z22 } from "zod";
+import { z as z32 } from "zod";
+import { z as z42 } from "zod";
+import { z as z5 } from "zod";
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.browser.js
+var nanoid = (size2 = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size2));
+  while (size2--) {
+    id += urlAlphabet[bytes[size2] & 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 z27 } 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 z28 } from "zod";
+import { z as z29 } from "zod";
+import { z as z30 } from "zod";
+import { z as z31 } from "zod";
+import { z as z322 } 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 z422 } 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";
+import { z as z59 } from "zod";
+import { z as z60 } from "zod";
+import { z as z61 } from "zod";
+import { z as z62 } from "zod";
+import { z as z63 } from "zod";
+import { z as z64 } from "zod";
+import { z as z65 } from "zod";
+import { z as z66 } from "zod";
+import { z as z67 } from "zod";
+import { z as z68 } from "zod";
+import { z as z69 } from "zod";
+import { z as z70 } from "zod";
+import { z as z71 } from "zod";
+import { z as z72 } from "zod";
+import { z as z73 } from "zod";
+import { z as z74 } 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,
+      K\u03A9: 1e3,
+      kohm: 1e3,
+      M\u03A9: 1e6,
+      G\u03A9: 1e9,
+      T\u03A9: 1e12
+    }
+  },
+  V: {
+    baseUnit: "V",
+    variants: {
+      mV: 1e-3,
+      V: 1,
+      kV: 1e3,
+      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,
+      uF: 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,
+      mil: 0.0254
+    }
+  }
+};
+var unitMappingAndVariantSuffixes = /* @__PURE__ */ new Set();
+for (const [baseUnit, info] of Object.entries(unitMappings)) {
+  unitMappingAndVariantSuffixes.add(baseUnit);
+  for (const variant of Object.keys(info.variants)) {
+    unitMappingAndVariantSuffixes.add(variant);
+  }
+}
+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 si_prefix_multiplier = {
+  tera: 1e12,
+  T: 1e12,
+  giga: 1e9,
+  G: 1e9,
+  mega: 1e6,
+  M: 1e6,
+  kilo: 1e3,
+  k: 1e3,
+  deci: 0.1,
+  d: 0.1,
+  centi: 0.01,
+  c: 0.01,
+  milli: 1e-3,
+  m: 1e-3,
+  micro: 1e-6,
+  u: 1e-6,
+  \u00B5: 1e-6,
+  nano: 1e-9,
+  n: 1e-9,
+  pico: 1e-12,
+  p: 1e-12
+};
+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 reversed_input_string = v.toString().split("").reverse().join("");
+  const unit_reversed = reversed_input_string.match(/[^\d\s]+/)?.[0];
+  if (!unit_reversed) {
+    throw new Error(`Could not determine unit: "${v}"`);
+  }
+  const unit = unit_reversed.split("").reverse().join("");
+  const numberPart = v.slice(0, -unit.length);
+  if (unit in si_prefix_multiplier && !unitMappingAndVariantSuffixes.has(unit)) {
+    const siMultiplier = si_prefix_multiplier[unit];
+    return {
+      parsedUnit: null,
+      unitOfValue: null,
+      value: Number.parseFloat(numberPart) * siMultiplier
+    };
+  }
+  const { baseUnit, conversionFactor } = getBaseTscircuitUnit(unit);
+  return {
+    parsedUnit: unit,
+    unitOfValue: baseUnit,
+    value: conversionFactor * Number.parseFloat(numberPart)
+  };
+};
+var resistance = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var capacitance = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value).transform((value) => {
+  return Number.parseFloat(value.toPrecision(12));
+});
+var inductance = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var voltage = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var length = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var frequency = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var distance = length;
+var current = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var time = z4.string().or(z4.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var rotation = z4.string().or(z4.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 battery_capacity = z4.number().or(z4.string().endsWith("mAh")).transform((v) => {
+  if (typeof v === "string") {
+    const valString = v.replace("mAh", "");
+    const num = Number.parseFloat(valString);
+    if (Number.isNaN(num)) {
+      throw new Error("Invalid capacity");
+    }
+    return num;
+  }
+  return v;
+}).describe("Battery capacity in mAh");
+var point = z22.object({
+  x: distance,
+  y: distance
+});
+var position = point;
+var point3 = z32.object({
+  x: distance,
+  y: distance,
+  z: distance
+});
+var position3 = point3;
+var size = z42.object({
+  width: z42.number(),
+  height: z42.number()
+});
+var getZodPrefixedIdWithDefault = (prefix) => {
+  return z5.string().optional().default(() => `${prefix}_${nanoid(10)}`);
+};
+var supplier_name = z6.enum([
+  "jlcpcb",
+  "macrofab",
+  "pcbway",
+  "digikey",
+  "mouser",
+  "lcsc"
+]);
+var expectTypesMatch = (shouldBe) => {
+};
+expectTypesMatch("extra props b");
+expectTypesMatch("missing props b");
+expectTypesMatch(true);
+expectTypesMatch("mismatched prop types: a");
+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(),
+  display_value: z7.string().optional()
+});
+expectTypesMatch(true);
+var source_simple_capacitor = source_component_base.extend({
+  ftype: z8.literal("simple_capacitor"),
+  capacitance,
+  max_voltage_rating: voltage.optional(),
+  display_capacitance: z8.string().optional(),
+  max_decoupling_trace_length: distance.optional()
+});
+expectTypesMatch(true);
+var source_simple_resistor = source_component_base.extend({
+  ftype: z9.literal("simple_resistor"),
+  resistance,
+  display_resistance: z9.string().optional()
+});
+expectTypesMatch(true);
+var source_simple_diode = source_component_base.extend({
+  ftype: z10.literal("simple_diode")
+});
+expectTypesMatch(true);
+var source_simple_ground = source_component_base.extend({
+  ftype: z11.literal("simple_ground")
+});
+expectTypesMatch(true);
+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")
+});
+expectTypesMatch(true);
+var source_led = source_simple_diode.extend({
+  ftype: z14.literal("led")
+});
+expectTypesMatch(true);
+var source_simple_power_source = source_component_base.extend({
+  ftype: z15.literal("simple_power_source"),
+  voltage
+});
+expectTypesMatch(true);
+var source_simple_battery = source_component_base.extend({
+  ftype: z16.literal("simple_battery"),
+  capacity: battery_capacity
+});
+expectTypesMatch(true);
+var source_simple_inductor = source_component_base.extend({
+  ftype: z17.literal("simple_inductor"),
+  inductance
+});
+expectTypesMatch(true);
+var source_simple_push_button = source_component_base.extend({
+  ftype: z18.literal("simple_push_button")
+});
+expectTypesMatch(true);
+var source_simple_potentiometer = source_component_base.extend({
+  ftype: z19.literal("simple_potentiometer"),
+  max_resistance: resistance
+});
+var source_simple_crystal = source_component_base.extend({
+  ftype: z20.literal("simple_crystal"),
+  frequency: z20.number().describe("Frequency in Hz"),
+  load_capacitance: z20.number().optional().describe("Load capacitance in pF")
+});
+expectTypesMatch(true);
+var source_simple_pin_header = source_component_base.extend({
+  ftype: z21.literal("simple_pin_header"),
+  pin_count: z21.number(),
+  gender: z21.enum(["male", "female"]).optional().default("male")
+});
+var source_simple_resonator = source_component_base.extend({
+  ftype: z222.literal("simple_resonator"),
+  load_capacitance: capacitance,
+  equivalent_series_resistance: resistance.optional(),
+  frequency
+});
+expectTypesMatch(true);
+var source_simple_transistor = source_component_base.extend({
+  ftype: z23.literal("simple_transistor"),
+  transistor_type: z23.enum(["npn", "pnp"])
+});
+expectTypesMatch(true);
+var source_simple_mosfet = source_component_base.extend({
+  ftype: z24.literal("simple_mosfet"),
+  channel_type: z24.enum(["n", "p"]),
+  mosfet_mode: z24.enum(["enhancement", "depletion"])
+});
+expectTypesMatch(true);
+var source_simple_switch = source_component_base.extend({
+  ftype: z25.literal("simple_switch")
+});
+expectTypesMatch(true);
+var source_project_metadata = z26.object({
+  type: z26.literal("source_project_metadata"),
+  name: z26.string().optional(),
+  software_used_string: z26.string().optional(),
+  created_at: z26.string().datetime().optional()
+});
+expectTypesMatch(true);
+var any_source_component = z27.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,
+  source_simple_battery,
+  source_simple_inductor,
+  source_simple_push_button,
+  source_simple_potentiometer,
+  source_simple_crystal,
+  source_simple_pin_header,
+  source_simple_resonator,
+  source_simple_switch,
+  source_simple_transistor,
+  source_simple_mosfet,
+  source_project_metadata
+]);
+var source_port = z28.object({
+  type: z28.literal("source_port"),
+  pin_number: z28.number().optional(),
+  port_hints: z28.array(z28.string()).optional(),
+  name: z28.string(),
+  source_port_id: z28.string(),
+  source_component_id: z28.string(),
+  subcircuit_id: z28.string().optional()
+});
+expectTypesMatch(true);
+var source_trace = z29.object({
+  type: z29.literal("source_trace"),
+  source_trace_id: z29.string(),
+  connected_source_port_ids: z29.array(z29.string()),
+  connected_source_net_ids: z29.array(z29.string()),
+  subcircuit_id: z29.string().optional(),
+  subcircuit_connectivity_map_key: z29.string().optional(),
+  max_length: z29.number().optional(),
+  min_trace_thickness: z29.number().optional(),
+  display_name: z29.string().optional()
+});
+expectTypesMatch(true);
+var source_group = z30.object({
+  type: z30.literal("source_group"),
+  source_group_id: z30.string(),
+  subcircuit_id: z30.string().optional(),
+  parent_subcircuit_id: z30.string().optional(),
+  is_subcircuit: z30.boolean().optional(),
+  name: z30.string().optional()
+});
+var source_net = z31.object({
+  type: z31.literal("source_net"),
+  source_net_id: z31.string(),
+  name: z31.string(),
+  member_source_group_ids: z31.array(z31.string()),
+  is_power: z31.boolean().optional(),
+  is_ground: z31.boolean().optional(),
+  is_digital_signal: z31.boolean().optional(),
+  is_analog_signal: z31.boolean().optional(),
+  trace_width: z31.number().optional(),
+  subcircuit_id: z31.string().optional()
+});
+var schematic_box = z322.object({
+  type: z322.literal("schematic_box"),
+  schematic_component_id: z322.string(),
+  width: distance,
+  height: distance,
+  x: distance,
+  y: distance
+}).describe("Draws a box on the schematic");
+expectTypesMatch(true);
+var schematic_path = z33.object({
+  type: z33.literal("schematic_path"),
+  schematic_component_id: z33.string(),
+  fill_color: z33.enum(["red", "blue"]).optional(),
+  is_filled: z33.boolean().optional(),
+  points: z33.array(point)
+});
+expectTypesMatch(true);
+var schematic_pin_styles = z34.record(
+  z34.object({
+    left_margin: length.optional(),
+    right_margin: length.optional(),
+    top_margin: length.optional(),
+    bottom_margin: length.optional()
+  })
+);
+var schematic_component_port_arrangement_by_size = z34.object({
+  left_size: z34.number(),
+  right_size: z34.number(),
+  top_size: z34.number().optional(),
+  bottom_size: z34.number().optional()
+});
+expectTypesMatch(true);
+var schematic_component_port_arrangement_by_sides = z34.object({
+  left_side: z34.object({
+    pins: z34.array(z34.number()),
+    // @ts-ignore
+    direction: z34.enum(["top-to-bottom", "bottom-to-top"]).optional()
+  }).optional(),
+  right_side: z34.object({
+    pins: z34.array(z34.number()),
+    // @ts-ignore
+    direction: z34.enum(["top-to-bottom", "bottom-to-top"]).optional()
+  }).optional(),
+  top_side: z34.object({
+    pins: z34.array(z34.number()),
+    // @ts-ignore
+    direction: z34.enum(["left-to-right", "right-to-left"]).optional()
+  }).optional(),
+  bottom_side: z34.object({
+    pins: z34.array(z34.number()),
+    // @ts-ignore
+    direction: z34.enum(["left-to-right", "right-to-left"]).optional()
+  }).optional()
+});
+expectTypesMatch(true);
+var port_arrangement = z34.union([
+  schematic_component_port_arrangement_by_size,
+  schematic_component_port_arrangement_by_sides
+]);
+var schematic_component = z34.object({
+  type: z34.literal("schematic_component"),
+  size,
+  center: point,
+  source_component_id: z34.string(),
+  schematic_component_id: z34.string(),
+  pin_spacing: length.optional(),
+  pin_styles: schematic_pin_styles.optional(),
+  box_width: length.optional(),
+  symbol_name: z34.string().optional(),
+  port_arrangement: port_arrangement.optional(),
+  port_labels: z34.record(z34.string()).optional(),
+  symbol_display_value: z34.string().optional()
+});
+expectTypesMatch(true);
+var schematic_line = z35.object({
+  type: z35.literal("schematic_line"),
+  schematic_component_id: z35.string(),
+  x1: distance,
+  x2: distance,
+  y1: distance,
+  y2: distance
+});
+expectTypesMatch(true);
+var schematic_trace = z36.object({
+  type: z36.literal("schematic_trace"),
+  schematic_trace_id: z36.string(),
+  source_trace_id: z36.string(),
+  junctions: z36.array(
+    z36.object({
+      x: z36.number(),
+      y: z36.number()
+    })
+  ),
+  edges: z36.array(
+    z36.object({
+      from: z36.object({
+        x: z36.number(),
+        y: z36.number()
+      }),
+      to: z36.object({
+        x: z36.number(),
+        y: z36.number()
+      }),
+      is_crossing: z36.boolean().optional(),
+      from_schematic_port_id: z36.string().optional(),
+      to_schematic_port_id: z36.string().optional()
+    })
+  )
+});
+expectTypesMatch(true);
+var schematic_text = z37.object({
+  type: z37.literal("schematic_text"),
+  schematic_component_id: z37.string(),
+  schematic_text_id: z37.string(),
+  text: z37.string(),
+  position: z37.object({
+    x: distance,
+    y: distance
+  }),
+  rotation: z37.number().default(0),
+  anchor: z37.enum(["center", "left", "right", "top", "bottom"]).default("center"),
+  color: z37.string().default("#000000")
+});
+expectTypesMatch(true);
+var schematic_port = z38.object({
+  type: z38.literal("schematic_port"),
+  schematic_port_id: z38.string(),
+  source_port_id: z38.string(),
+  schematic_component_id: z38.string().optional(),
+  center: point,
+  facing_direction: z38.enum(["up", "down", "left", "right"]).optional(),
+  distance_from_component_edge: z38.number().optional(),
+  side_of_component: z38.enum(["top", "bottom", "left", "right"]).optional(),
+  true_ccw_index: z38.number().optional(),
+  pin_number: z38.number().optional(),
+  display_pin_label: z38.string().optional()
+}).describe("Defines a port on a schematic component");
+expectTypesMatch(true);
+var schematic_net_label = z39.object({
+  type: z39.literal("schematic_net_label"),
+  source_net_id: z39.string(),
+  center: point,
+  anchor_position: point.optional(),
+  anchor_side: z39.enum(["top", "bottom", "left", "right"]),
+  text: z39.string(),
+  symbol_name: z39.string().optional()
+});
+var schematic_error = z40.object({
+  type: z40.literal("schematic_error"),
+  schematic_error_id: z40.string(),
+  // eventually each error type should be broken out into a dir of files
+  error_type: z40.literal("schematic_port_not_found"),
+  message: z40.string()
+}).describe("Defines a schematic error on the schematic");
+expectTypesMatch(true);
+var schematic_debug_object_base = z41.object({
+  type: z41.literal("schematic_debug_object"),
+  label: z41.string().optional()
+});
+var schematic_debug_rect = schematic_debug_object_base.extend({
+  shape: z41.literal("rect"),
+  center: point,
+  size
+});
+var schematic_debug_line = schematic_debug_object_base.extend({
+  shape: z41.literal("line"),
+  start: point,
+  end: point
+});
+var schematic_debug_point = schematic_debug_object_base.extend({
+  shape: z41.literal("point"),
+  center: point
+});
+var schematic_debug_object = z41.discriminatedUnion("shape", [
+  schematic_debug_rect,
+  schematic_debug_line,
+  schematic_debug_point
+]);
+expectTypesMatch(true);
+var schematic_voltage_probe = z422.object({
+  type: z422.literal("schematic_voltage_probe"),
+  schematic_voltage_probe_id: z422.string(),
+  position: point,
+  schematic_trace_id: z422.string(),
+  voltage: voltage.optional()
+}).describe("Defines a voltage probe measurement point on a schematic trace");
+expectTypesMatch(true);
+var all_layers = [
+  "top",
+  "bottom",
+  "inner1",
+  "inner2",
+  "inner3",
+  "inner4",
+  "inner5",
+  "inner6"
+];
+var layer_string = z43.enum(all_layers);
+var layer_ref = layer_string.or(
+  z43.object({
+    name: layer_string
+  })
+).transform((layer) => {
+  if (typeof layer === "string") {
+    return layer;
+  }
+  return layer.name;
+});
+var visible_layer = z43.enum(["top", "bottom"]);
+var pcb_route_hint = z44.object({
+  x: distance,
+  y: distance,
+  via: z44.boolean().optional(),
+  via_to_layer: layer_ref.optional()
+});
+var pcb_route_hints = z44.array(pcb_route_hint);
+var route_hint_point = z45.object({
+  x: distance,
+  y: distance,
+  via: z45.boolean().optional(),
+  to_layer: layer_ref.optional(),
+  trace_width: distance.optional()
+});
+var pcb_component = z46.object({
+  type: z46.literal("pcb_component"),
+  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
+  source_component_id: z46.string(),
+  center: point,
+  layer: layer_ref,
+  rotation,
+  width: length,
+  height: length,
+  subcircuit_id: z46.string().optional()
+}).describe("Defines a component on the PCB");
+expectTypesMatch(true);
+var pcb_hole_circle_or_square = z47.object({
+  type: z47.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  pcb_group_id: z47.string().optional(),
+  subcircuit_id: z47.string().optional(),
+  hole_shape: z47.enum(["circle", "square"]),
+  hole_diameter: z47.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 = z47.object({
+  type: z47.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  pcb_group_id: z47.string().optional(),
+  subcircuit_id: z47.string().optional(),
+  hole_shape: z47.literal("oval"),
+  hole_width: z47.number(),
+  hole_height: z47.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 = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("circle"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  outer_diameter: z48.number(),
+  hole_diameter: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole_oval = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.enum(["oval", "pill"]),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  outer_width: z48.number(),
+  outer_height: z48.number(),
+  hole_width: z48.number(),
+  hole_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_circular_hole_with_rect_pad = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("circular_hole_with_rect_pad"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  hole_shape: z48.literal("circle"),
+  pad_shape: z48.literal("rect"),
+  hole_diameter: z48.number(),
+  rect_pad_width: z48.number(),
+  rect_pad_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_pill_hole_with_rect_pad = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("pill_hole_with_rect_pad"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  hole_shape: z48.literal("pill"),
+  pad_shape: z48.literal("rect"),
+  hole_width: z48.number(),
+  hole_height: z48.number(),
+  rect_pad_width: z48.number(),
+  rect_pad_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole = z48.union([
+  pcb_plated_hole_circle,
+  pcb_plated_hole_oval,
+  pcb_circular_hole_with_rect_pad
+]);
+expectTypesMatch(
+  true
+);
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_port = z49.object({
+  type: z49.literal("pcb_port"),
+  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
+  pcb_group_id: z49.string().optional(),
+  subcircuit_id: z49.string().optional(),
+  source_port_id: z49.string(),
+  pcb_component_id: z49.string(),
+  x: distance,
+  y: distance,
+  layers: z49.array(layer_ref)
+}).describe("Defines a port on the PCB");
+expectTypesMatch(true);
+var pcb_smtpad_circle = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("circle"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  radius: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_rect = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("rect"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_rotated_rect = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("rotated_rect"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  ccw_rotation: rotation,
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_pill = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("pill"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  radius: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad = z50.union([
+  pcb_smtpad_circle,
+  pcb_smtpad_rect,
+  pcb_smtpad_rotated_rect,
+  pcb_smtpad_pill
+]).describe("Defines an SMT pad on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_solder_paste_circle = z51.object({
+  type: z51.literal("pcb_solder_paste"),
+  shape: z51.literal("circle"),
+  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+  pcb_group_id: z51.string().optional(),
+  subcircuit_id: z51.string().optional(),
+  x: distance,
+  y: distance,
+  radius: z51.number(),
+  layer: layer_ref,
+  pcb_component_id: z51.string().optional(),
+  pcb_smtpad_id: z51.string().optional()
+});
+var pcb_solder_paste_rect = z51.object({
+  type: z51.literal("pcb_solder_paste"),
+  shape: z51.literal("rect"),
+  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+  pcb_group_id: z51.string().optional(),
+  subcircuit_id: z51.string().optional(),
+  x: distance,
+  y: distance,
+  width: z51.number(),
+  height: z51.number(),
+  layer: layer_ref,
+  pcb_component_id: z51.string().optional(),
+  pcb_smtpad_id: z51.string().optional()
+});
+var pcb_solder_paste = z51.union([pcb_solder_paste_circle, pcb_solder_paste_rect]).describe("Defines solderpaste on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_text = z52.object({
+  type: z52.literal("pcb_text"),
+  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
+  pcb_group_id: z52.string().optional(),
+  subcircuit_id: z52.string().optional(),
+  text: z52.string(),
+  center: point,
+  layer: layer_ref,
+  width: length,
+  height: length,
+  lines: z52.number(),
+  // @ts-ignore
+  align: z52.enum(["bottom-left"])
+}).describe("Defines text on the PCB");
+expectTypesMatch(true);
+var pcb_trace_route_point_wire = z53.object({
+  route_type: z53.literal("wire"),
+  x: distance,
+  y: distance,
+  width: distance,
+  start_pcb_port_id: z53.string().optional(),
+  end_pcb_port_id: z53.string().optional(),
+  layer: layer_ref
+});
+var pcb_trace_route_point_via = z53.object({
+  route_type: z53.literal("via"),
+  x: distance,
+  y: distance,
+  from_layer: z53.string(),
+  to_layer: z53.string()
+});
+var pcb_trace_route_point = z53.union([
+  pcb_trace_route_point_wire,
+  pcb_trace_route_point_via
+]);
+var pcb_trace = z53.object({
+  type: z53.literal("pcb_trace"),
+  source_trace_id: z53.string().optional(),
+  pcb_component_id: z53.string().optional(),
+  pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
+  pcb_group_id: z53.string().optional(),
+  subcircuit_id: z53.string().optional(),
+  route_thickness_mode: z53.enum(["constant", "interpolated"]).default("constant").optional(),
+  route_order_index: z53.number().optional(),
+  should_round_corners: z53.boolean().optional(),
+  trace_length: z53.number().optional(),
+  route: z53.array(
+    z53.union([
+      z53.object({
+        route_type: z53.literal("wire"),
+        x: distance,
+        y: distance,
+        width: distance,
+        start_pcb_port_id: z53.string().optional(),
+        end_pcb_port_id: z53.string().optional(),
+        layer: layer_ref
+      }),
+      z53.object({
+        route_type: z53.literal("via"),
+        x: distance,
+        y: distance,
+        from_layer: z53.string(),
+        to_layer: z53.string()
+      })
+    ])
+  )
+}).describe("Defines a trace on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_trace_error = z54.object({
+  type: z54.literal("pcb_trace_error"),
+  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
+  error_type: z54.literal("pcb_trace_error"),
+  message: z54.string(),
+  center: point.optional(),
+  pcb_trace_id: z54.string(),
+  source_trace_id: z54.string(),
+  pcb_component_ids: z54.array(z54.string()),
+  pcb_port_ids: z54.array(z54.string())
+}).describe("Defines a trace error on the PCB");
+expectTypesMatch(true);
+var pcb_port_not_matched_error = z55.object({
+  type: z55.literal("pcb_port_not_matched_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
+  message: z55.string(),
+  pcb_component_ids: z55.array(z55.string())
+}).describe("Defines a trace error on the PCB where a port is not matched");
+expectTypesMatch(true);
+var pcb_via = z56.object({
+  type: z56.literal("pcb_via"),
+  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
+  pcb_group_id: z56.string().optional(),
+  subcircuit_id: z56.string().optional(),
+  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: z56.array(layer_ref),
+  pcb_trace_id: z56.string().optional()
+}).describe("Defines a via on the PCB");
+expectTypesMatch(true);
+var pcb_board = z57.object({
+  type: z57.literal("pcb_board"),
+  pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
+  is_subcircuit: z57.boolean().optional(),
+  subcircuit_id: z57.string().optional(),
+  width: length,
+  height: length,
+  center: point,
+  thickness: length.optional().default(1.4),
+  num_layers: z57.number().optional().default(4),
+  outline: z57.array(point).optional()
+}).describe("Defines the board outline of the PCB");
+expectTypesMatch(true);
+var pcb_placement_error = z58.object({
+  type: z58.literal("pcb_placement_error"),
+  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
+  message: z58.string()
+}).describe("Defines a placement error on the PCB");
+expectTypesMatch(true);
+var pcb_trace_hint = z59.object({
+  type: z59.literal("pcb_trace_hint"),
+  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
+  pcb_port_id: z59.string(),
+  pcb_component_id: z59.string(),
+  route: z59.array(route_hint_point)
+}).describe("A hint that can be used during generation of a PCB trace");
+expectTypesMatch(true);
+var pcb_silkscreen_line = z60.object({
+  type: z60.literal("pcb_silkscreen_line"),
+  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
+  pcb_component_id: z60.string(),
+  pcb_group_id: z60.string().optional(),
+  subcircuit_id: z60.string().optional(),
+  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 = z61.object({
+  type: z61.literal("pcb_silkscreen_path"),
+  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
+  pcb_component_id: z61.string(),
+  pcb_group_id: z61.string().optional(),
+  subcircuit_id: z61.string().optional(),
+  layer: visible_layer,
+  route: z61.array(point),
+  stroke_width: length
+}).describe("Defines a silkscreen path on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_text = z62.object({
+  type: z62.literal("pcb_silkscreen_text"),
+  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
+  pcb_group_id: z62.string().optional(),
+  subcircuit_id: z62.string().optional(),
+  font: z62.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("0.2mm"),
+  pcb_component_id: z62.string(),
+  text: z62.string(),
+  ccw_rotation: z62.number().optional(),
+  layer: layer_ref,
+  is_mirrored: z62.boolean().default(false).optional(),
+  anchor_position: point.default({ x: 0, y: 0 }),
+  anchor_alignment: z62.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 = z63.object({
+  type: z63.literal("pcb_silkscreen_rect"),
+  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
+  pcb_component_id: z63.string(),
+  pcb_group_id: z63.string().optional(),
+  subcircuit_id: z63.string().optional(),
+  center: point,
+  width: length,
+  height: length,
+  layer: layer_ref,
+  stroke_width: length.default("1mm")
+}).describe("Defines a silkscreen rect on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_circle = z64.object({
+  type: z64.literal("pcb_silkscreen_circle"),
+  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
+    "pcb_silkscreen_circle"
+  ),
+  pcb_component_id: z64.string(),
+  pcb_group_id: z64.string().optional(),
+  subcircuit_id: z64.string().optional(),
+  center: point,
+  radius: length,
+  layer: visible_layer,
+  stroke_width: length.default("1mm")
+}).describe("Defines a silkscreen circle on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_oval = z65.object({
+  type: z65.literal("pcb_silkscreen_oval"),
+  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
+  pcb_component_id: z65.string(),
+  pcb_group_id: z65.string().optional(),
+  subcircuit_id: z65.string().optional(),
+  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 = z66.object({
+  type: z66.literal("pcb_fabrication_note_text"),
+  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_text"
+  ),
+  subcircuit_id: z66.string().optional(),
+  pcb_group_id: z66.string().optional(),
+  font: z66.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("1mm"),
+  pcb_component_id: z66.string(),
+  text: z66.string(),
+  layer: visible_layer,
+  anchor_position: point.default({ x: 0, y: 0 }),
+  anchor_alignment: z66.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  color: z66.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 = z67.object({
+  type: z67.literal("pcb_fabrication_note_path"),
+  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_path"
+  ),
+  pcb_component_id: z67.string(),
+  subcircuit_id: z67.string().optional(),
+  layer: layer_ref,
+  route: z67.array(point),
+  stroke_width: length,
+  color: z67.string().optional()
+}).describe(
+  "Defines a fabrication path on the PCB for fabricators or assemblers"
+);
+expectTypesMatch(true);
+var pcb_keepout = z68.object({
+  type: z68.literal("pcb_keepout"),
+  shape: z68.literal("rect"),
+  pcb_group_id: z68.string().optional(),
+  subcircuit_id: z68.string().optional(),
+  center: point,
+  width: distance,
+  height: distance,
+  pcb_keepout_id: z68.string(),
+  layers: z68.array(z68.string()),
+  // Specify layers where the keepout applies
+  description: z68.string().optional()
+  // Optional description of the keepout
+}).or(
+  z68.object({
+    type: z68.literal("pcb_keepout"),
+    shape: z68.literal("circle"),
+    pcb_group_id: z68.string().optional(),
+    subcircuit_id: z68.string().optional(),
+    center: point,
+    radius: distance,
+    pcb_keepout_id: z68.string(),
+    layers: z68.array(z68.string()),
+    // Specify layers where the keepout applies
+    description: z68.string().optional()
+    // Optional description of the keepout
+  })
+);
+var pcb_missing_footprint_error = z69.object({
+  type: z69.literal("pcb_missing_footprint_error"),
+  pcb_missing_footprint_error_id: getZodPrefixedIdWithDefault(
+    "pcb_missing_footprint_error"
+  ),
+  pcb_group_id: z69.string().optional(),
+  subcircuit_id: z69.string().optional(),
+  error_type: z69.literal("pcb_missing_footprint_error"),
+  source_component_id: z69.string(),
+  message: z69.string()
+}).describe("Defines a missing footprint error on the PCB");
+expectTypesMatch(
+  true
+);
+var pcb_manual_edit_conflict_error = z70.object({
+  type: z70.literal("pcb_manual_edit_conflict_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_manual_edit_conflict_error"),
+  message: z70.string(),
+  pcb_component_id: z70.string(),
+  pcb_group_id: z70.string().optional(),
+  subcircuit_id: z70.string().optional(),
+  source_component_id: z70.string()
+}).describe(
+  "Error emitted when a component has both manual placement and explicit pcbX/pcbY coordinates"
+);
+expectTypesMatch(true);
+var pcb_group = z71.object({
+  type: z71.literal("pcb_group"),
+  pcb_group_id: getZodPrefixedIdWithDefault("pcb_group"),
+  source_group_id: z71.string(),
+  is_subcircuit: z71.boolean().optional(),
+  subcircuit_id: z71.string().optional(),
+  width: length,
+  height: length,
+  center: point,
+  pcb_component_ids: z71.array(z71.string()),
+  name: z71.string().optional(),
+  description: z71.string().optional()
+}).describe("Defines a group of components on the PCB");
+expectTypesMatch(true);
+var pcb_autorouting_error = z72.object({
+  type: z72.literal("pcb_autorouting_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_autorouting_error"),
+  message: z72.string()
+}).describe("The autorouting has failed to route a portion of the board");
+expectTypesMatch(true);
+var cad_component = z73.object({
+  type: z73.literal("cad_component"),
+  cad_component_id: z73.string(),
+  pcb_component_id: z73.string(),
+  source_component_id: z73.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: z73.string().optional(),
+  model_obj_url: z73.string().optional(),
+  model_stl_url: z73.string().optional(),
+  model_3mf_url: z73.string().optional(),
+  model_jscad: z73.any().optional()
+}).describe("Defines a component on the PCB");
+var any_circuit_element = z74.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,
+  source_simple_battery,
+  source_simple_inductor,
+  source_simple_pin_header,
+  source_simple_resonator,
+  source_simple_switch,
+  source_simple_transistor,
+  source_simple_mosfet,
+  source_simple_potentiometer,
+  source_simple_push_button,
+  source_project_metadata,
+  pcb_component,
+  pcb_hole,
+  pcb_missing_footprint_error,
+  pcb_manual_edit_conflict_error,
+  pcb_plated_hole,
+  pcb_keepout,
+  pcb_port,
+  pcb_text,
+  pcb_trace,
+  pcb_via,
+  pcb_smtpad,
+  pcb_solder_paste,
+  pcb_board,
+  pcb_group,
+  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,
+  pcb_autorouting_error,
+  schematic_box,
+  schematic_text,
+  schematic_line,
+  schematic_component,
+  schematic_port,
+  schematic_trace,
+  schematic_path,
+  schematic_error,
+  schematic_net_label,
+  schematic_debug_object,
+  schematic_voltage_probe,
+  cad_component
+]);
+var any_soup_element = any_circuit_element;
+
+// 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 su2 = 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.type === component_type && 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 su2;
+};
+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;
+};
+function stringHash(str) {
+  let hash = 0;
+  if (str.length == 0)
+    return hash;
+  for (var i = 0; i < str.length; i++) {
+    var char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+var nice_color_palettes = [
+  ["#69d2e7", "#a7dbd8", "#e0e4cc", "#f38630", "#fa6900"],
+  ["#fe4365", "#fc9d9a", "#f9cdad", "#c8c8a9", "#83af9b"],
+  ["#ecd078", "#d95b43", "#c02942", "#542437", "#53777a"],
+  ["#556270", "#4ecdc4", "#c7f464", "#ff6b6b", "#c44d58"],
+  ["#774f38", "#e08e79", "#f1d4af", "#ece5ce", "#c5e0dc"],
+  ["#e8ddcb", "#cdb380", "#036564", "#033649", "#031634"],
+  ["#490a3d", "#bd1550", "#e97f02", "#f8ca00", "#8a9b0f"],
+  ["#594f4f", "#547980", "#45ada8", "#9de0ad", "#e5fcc2"],
+  ["#00a0b0", "#6a4a3c", "#cc333f", "#eb6841", "#edc951"],
+  ["#e94e77", "#d68189", "#c6a49a", "#c6e5d9", "#f4ead5"],
+  ["#3fb8af", "#7fc7af", "#dad8a7", "#ff9e9d", "#ff3d7f"],
+  ["#d9ceb2", "#948c75", "#d5ded9", "#7a6a53", "#99b2b7"],
+  ["#ffffff", "#cbe86b", "#f2e9e1", "#1c140d", "#cbe86b"],
+  ["#efffcd", "#dce9be", "#555152", "#2e2633", "#99173c"],
+  ["#343838", "#005f6b", "#008c9e", "#00b4cc", "#00dffc"],
+  ["#413e4a", "#73626e", "#b38184", "#f0b49e", "#f7e4be"],
+  ["#ff4e50", "#fc913a", "#f9d423", "#ede574", "#e1f5c4"],
+  ["#99b898", "#fecea8", "#ff847c", "#e84a5f", "#2a363b"],
+  ["#655643", "#80bca3", "#f6f7bd", "#e6ac27", "#bf4d28"],
+  ["#00a8c6", "#40c0cb", "#f9f2e7", "#aee239", "#8fbe00"],
+  ["#351330", "#424254", "#64908a", "#e8caa4", "#cc2a41"],
+  ["#554236", "#f77825", "#d3ce3d", "#f1efa5", "#60b99a"],
+  ["#5d4157", "#838689", "#a8caba", "#cad7b2", "#ebe3aa"],
+  ["#8c2318", "#5e8c6a", "#88a65e", "#bfb35a", "#f2c45a"],
+  ["#fad089", "#ff9c5b", "#f5634a", "#ed303c", "#3b8183"],
+  ["#ff4242", "#f4fad2", "#d4ee5e", "#e1edb9", "#f0f2eb"],
+  ["#f8b195", "#f67280", "#c06c84", "#6c5b7b", "#355c7d"],
+  ["#d1e751", "#ffffff", "#000000", "#4dbce9", "#26ade4"],
+  ["#1b676b", "#519548", "#88c425", "#bef202", "#eafde6"],
+  ["#5e412f", "#fcebb6", "#78c0a8", "#f07818", "#f0a830"],
+  ["#bcbdac", "#cfbe27", "#f27435", "#f02475", "#3b2d38"],
+  ["#452632", "#91204d", "#e4844a", "#e8bf56", "#e2f7ce"],
+  ["#eee6ab", "#c5bc8e", "#696758", "#45484b", "#36393b"],
+  ["#f0d8a8", "#3d1c00", "#86b8b1", "#f2d694", "#fa2a00"],
+  ["#2a044a", "#0b2e59", "#0d6759", "#7ab317", "#a0c55f"],
+  ["#f04155", "#ff823a", "#f2f26f", "#fff7bd", "#95cfb7"],
+  ["#b9d7d9", "#668284", "#2a2829", "#493736", "#7b3b3b"],
+  ["#bbbb88", "#ccc68d", "#eedd99", "#eec290", "#eeaa88"],
+  ["#b3cc57", "#ecf081", "#ffbe40", "#ef746f", "#ab3e5b"],
+  ["#a3a948", "#edb92e", "#f85931", "#ce1836", "#009989"],
+  ["#300030", "#480048", "#601848", "#c04848", "#f07241"],
+  ["#67917a", "#170409", "#b8af03", "#ccbf82", "#e33258"],
+  ["#aab3ab", "#c4cbb7", "#ebefc9", "#eee0b7", "#e8caaf"],
+  ["#e8d5b7", "#0e2430", "#fc3a51", "#f5b349", "#e8d5b9"],
+  ["#ab526b", "#bca297", "#c5ceae", "#f0e2a4", "#f4ebc3"],
+  ["#607848", "#789048", "#c0d860", "#f0f0d8", "#604848"],
+  ["#b6d8c0", "#c8d9bf", "#dadabd", "#ecdbbc", "#fedcba"],
+  ["#a8e6ce", "#dcedc2", "#ffd3b5", "#ffaaa6", "#ff8c94"],
+  ["#3e4147", "#fffedf", "#dfba69", "#5a2e2e", "#2a2c31"],
+  ["#fc354c", "#29221f", "#13747d", "#0abfbc", "#fcf7c5"],
+  ["#cc0c39", "#e6781e", "#c8cf02", "#f8fcc1", "#1693a7"],
+  ["#1c2130", "#028f76", "#b3e099", "#ffeaad", "#d14334"],
+  ["#a7c5bd", "#e5ddcb", "#eb7b59", "#cf4647", "#524656"],
+  ["#dad6ca", "#1bb0ce", "#4f8699", "#6a5e72", "#563444"],
+  ["#5c323e", "#a82743", "#e15e32", "#c0d23e", "#e5f04c"],
+  ["#edebe6", "#d6e1c7", "#94c7b6", "#403b33", "#d3643b"],
+  ["#fdf1cc", "#c6d6b8", "#987f69", "#e3ad40", "#fcd036"],
+  ["#230f2b", "#f21d41", "#ebebbc", "#bce3c5", "#82b3ae"],
+  ["#b9d3b0", "#81bda4", "#b28774", "#f88f79", "#f6aa93"],
+  ["#3a111c", "#574951", "#83988e", "#bcdea5", "#e6f9bc"],
+  ["#5e3929", "#cd8c52", "#b7d1a3", "#dee8be", "#fcf7d3"],
+  ["#1c0113", "#6b0103", "#a30006", "#c21a01", "#f03c02"],
+  ["#000000", "#9f111b", "#b11623", "#292c37", "#cccccc"],
+  ["#382f32", "#ffeaf2", "#fcd9e5", "#fbc5d8", "#f1396d"],
+  ["#e3dfba", "#c8d6bf", "#93ccc6", "#6cbdb5", "#1a1f1e"],
+  ["#f6f6f6", "#e8e8e8", "#333333", "#990100", "#b90504"],
+  ["#1b325f", "#9cc4e4", "#e9f2f9", "#3a89c9", "#f26c4f"],
+  ["#a1dbb2", "#fee5ad", "#faca66", "#f7a541", "#f45d4c"],
+  ["#c1b398", "#605951", "#fbeec2", "#61a6ab", "#accec0"],
+  ["#5e9fa3", "#dcd1b4", "#fab87f", "#f87e7b", "#b05574"],
+  ["#951f2b", "#f5f4d7", "#e0dfb1", "#a5a36c", "#535233"],
+  ["#8dccad", "#988864", "#fea6a2", "#f9d6ac", "#ffe9af"],
+  ["#2d2d29", "#215a6d", "#3ca2a2", "#92c7a3", "#dfece6"],
+  ["#413d3d", "#040004", "#c8ff00", "#fa023c", "#4b000f"],
+  ["#eff3cd", "#b2d5ba", "#61ada0", "#248f8d", "#605063"],
+  ["#ffefd3", "#fffee4", "#d0ecea", "#9fd6d2", "#8b7a5e"],
+  ["#cfffdd", "#b4dec1", "#5c5863", "#a85163", "#ff1f4c"],
+  ["#9dc9ac", "#fffec7", "#f56218", "#ff9d2e", "#919167"],
+  ["#4e395d", "#827085", "#8ebe94", "#ccfc8e", "#dc5b3e"],
+  ["#a8a7a7", "#cc527a", "#e8175d", "#474747", "#363636"],
+  ["#f8edd1", "#d88a8a", "#474843", "#9d9d93", "#c5cfc6"],
+  ["#046d8b", "#309292", "#2fb8ac", "#93a42a", "#ecbe13"],
+  ["#f38a8a", "#55443d", "#a0cab5", "#cde9ca", "#f1edd0"],
+  ["#a70267", "#f10c49", "#fb6b41", "#f6d86b", "#339194"],
+  ["#ff003c", "#ff8a00", "#fabe28", "#88c100", "#00c176"],
+  ["#ffedbf", "#f7803c", "#f54828", "#2e0d23", "#f8e4c1"],
+  ["#4e4d4a", "#353432", "#94ba65", "#2790b0", "#2b4e72"],
+  ["#0ca5b0", "#4e3f30", "#fefeeb", "#f8f4e4", "#a5b3aa"],
+  ["#4d3b3b", "#de6262", "#ffb88c", "#ffd0b3", "#f5e0d3"],
+  ["#fffbb7", "#a6f6af", "#66b6ab", "#5b7c8d", "#4f2958"],
+  ["#edf6ee", "#d1c089", "#b3204d", "#412e28", "#151101"],
+  ["#9d7e79", "#ccac95", "#9a947c", "#748b83", "#5b756c"],
+  ["#fcfef5", "#e9ffe1", "#cdcfb7", "#d6e6c3", "#fafbe3"],
+  ["#9cddc8", "#bfd8ad", "#ddd9ab", "#f7af63", "#633d2e"],
+  ["#30261c", "#403831", "#36544f", "#1f5f61", "#0b8185"],
+  ["#aaff00", "#ffaa00", "#ff00aa", "#aa00ff", "#00aaff"],
+  ["#d1313d", "#e5625c", "#f9bf76", "#8eb2c5", "#615375"],
+  ["#ffe181", "#eee9e5", "#fad3b2", "#ffba7f", "#ff9c97"],
+  ["#73c8a9", "#dee1b6", "#e1b866", "#bd5532", "#373b44"],
+  ["#805841", "#dcf7f3", "#fffcdd", "#ffd8d8", "#f5a2a2"]
+];
+var getDebugLayoutObject = (lo) => {
+  let {
+    x,
+    y,
+    width,
+    height
+  } = {
+    ...lo,
+    ...lo.size,
+    ...lo.center,
+    ...lo.position
+  };
+  if (lo.x1 !== void 0 && lo.x2 !== void 0 && lo.y1 !== void 0 && lo.y2 !== void 0) {
+    x = (lo.x1 + lo.x2) / 2;
+    y = (lo.y1 + lo.y2) / 2;
+    width = Math.abs(lo.x1 - lo.x2);
+    height = Math.abs(lo.y1 - lo.y2);
+  }
+  const title = lo.text || lo.name || lo.source?.text || lo.source?.name || "?";
+  const content = lo;
+  if (x === void 0 || y === void 0)
+    return null;
+  if (width === void 0) {
+    if ("outer_diameter" in lo) {
+      width = lo.outer_diameter;
+      height = lo.outer_diameter;
+    }
+  }
+  if (width === void 0 || height === void 0) {
+    width = 0.1;
+    height = 0.1;
+  }
+  return {
+    x,
+    y,
+    width,
+    height,
+    title,
+    content,
+    bg_color: nice_color_palettes[stringHash(lo.type || title) % nice_color_palettes.length]?.[4] ?? "#f00"
+  };
+};
+var isTruthy = (value) => Boolean(value);
+var findBoundsAndCenter = (elements) => {
+  const debugObjects = elements.filter((elm) => elm.type.startsWith("pcb_")).concat(
+    elements.filter((elm) => elm.type === "pcb_trace").flatMap((elm) => elm.route)
+  ).map((elm) => getDebugLayoutObject(elm)).filter(isTruthy);
+  if (debugObjects.length === 0)
+    return { center: { x: 0, y: 0 }, width: 0, height: 0 };
+  let minX = debugObjects[0].x - debugObjects[0].width / 2;
+  let maxX = debugObjects[0].x + debugObjects[0].width / 2;
+  let minY = debugObjects[0].y - debugObjects[0].height / 2;
+  let maxY = debugObjects[0].y + debugObjects[0].height / 2;
+  for (const obj of debugObjects.slice(1)) {
+    minX = Math.min(minX, obj.x - obj.width / 2);
+    maxX = Math.max(maxX, obj.x + obj.width / 2);
+    minY = Math.min(minY, obj.y - obj.height / 2);
+    maxY = Math.max(maxY, obj.y + obj.height / 2);
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const center = { x: minX + width / 2, y: minY + height / 2 };
+  return { center, width, height };
+};
+
+// lib/websafe/generate-footprint-tsx.ts
+import { mmStr } from "@tscircuit/mm";
+var generateFootprintTsx = (circuitJson) => {
+  const holes = su_default(circuitJson).pcb_hole.list();
+  const platedHoles = su_default(circuitJson).pcb_plated_hole.list();
+  const smtPads = su_default(circuitJson).pcb_smtpad.list();
+  const silkscreenPaths = su_default(circuitJson).pcb_silkscreen_path.list();
+  const silkscreenTexts = su_default(circuitJson).pcb_silkscreen_text.list();
+  const elementStrings = [];
+  for (const hole of holes) {
+    if (hole.hole_shape === "circle") {
+      elementStrings.push(
+        `<hole pcbX="${mmStr(hole.x)}" pcbY="${mmStr(hole.y)}" diameter="${mmStr(hole.hole_diameter)}" />`
+      );
+    } else if (hole.hole_shape === "oval") {
+      console.warn("Unhandled oval hole in conversion (needs implementation)");
+    }
+  }
+  for (const platedHole of platedHoles) {
+    if (platedHole.shape === "oval" || platedHole.shape === "pill") {
+      elementStrings.push(
+        `<platedhole  portHints={${JSON.stringify(platedHole.port_hints)}} pcbX="${mmStr(platedHole.x)}" pcbY="${mmStr(platedHole.y)}" outerHeight="${mmStr(platedHole.outer_height)}" outerWidth="${mmStr(platedHole.outer_width)}" holeHeight="${mmStr(platedHole.hole_height)}" holeWidth="${mmStr(platedHole.hole_width)}" shape="${platedHole.shape}" />`
+      );
+    } else if (platedHole.shape === "circle") {
+      elementStrings.push(
+        `<platedhole  portHints={${JSON.stringify(platedHole.port_hints)}} pcbX="${mmStr(platedHole.x)}" pcbY="${mmStr(platedHole.y)}" outerDiameter="${mmStr(platedHole.outer_diameter)}" holeDiameter="${mmStr(platedHole.hole_diameter)}" shape="circle" />`
+      );
+    }
+  }
+  for (const smtPad of smtPads) {
+    if (smtPad.shape === "circle") {
+      elementStrings.push(
+        `<smtpad portHints={${JSON.stringify(smtPad.port_hints)}} pcbX="${mmStr(smtPad.x)}" pcbY="${mmStr(smtPad.y)}" radius="${mmStr(smtPad.radius)}" shape="circle" />`
+      );
+    } else if (smtPad.shape === "rect") {
+      elementStrings.push(
+        `<smtpad portHints={${JSON.stringify(smtPad.port_hints)}} pcbX="${mmStr(smtPad.x)}" pcbY="${mmStr(smtPad.y)}" width="${mmStr(smtPad.width)}" height="${mmStr(smtPad.height)}" shape="rect" />`
+      );
+    }
+  }
+  for (const silkscreenPath of silkscreenPaths) {
+    elementStrings.push(
+      `<silkscreenpath route={${JSON.stringify(silkscreenPath.route)}} />`
+    );
+  }
+  for (const silkscreenText of silkscreenTexts) {
+    elementStrings.push(
+      `<silkscreentext text="${silkscreenText.text}" pcbX="${mmStr(silkscreenText.anchor_position.x)}" pcbY="${mmStr(silkscreenText.anchor_position.y)}" anchorAlignment="${silkscreenText.anchor_alignment}" ${silkscreenText.font_size ? `fontSize="${mmStr(silkscreenText.font_size)}"` : ""} />`
+    );
+  }
+  return `
+      <footprint>
+        ${elementStrings.join("\n")}
+      </footprint>
+  `.trim();
+};
+
+// lib/websafe/convert-to-typescript-component/generate-typescript-component.ts
+var generateTypescriptComponent = ({
+  pinLabels,
+  componentName,
+  objUrl,
+  circuitJson,
+  supplierPartNumbers,
+  manufacturerPartNumber
+}) => {
+  const safePinLabels = pinLabels ?? {};
+  const footprintTsx = generateFootprintTsx(circuitJson);
+  const simplifiedPinLabels = Object.fromEntries(
+    Object.entries(safePinLabels).map(([pin, labels]) => {
+      if (Array.isArray(labels) && labels.length > 1) {
+        return [pin, [labels[1]]];
+      }
+      return [pin, labels];
+    })
+  );
+  const pinLabelsString = Object.entries(simplifiedPinLabels).map(([pin, labels]) => `  ${pin}: ${JSON.stringify(labels)}`).join(",\n");
+  return `
+import type { ChipProps } from "@tscircuit/props"
+
+const pinLabels = {
+${pinLabelsString}
+} as const
+
+export const ${componentName} = (props: ChipProps<typeof pinLabels>) => {
+  return (
+    <chip
+      pinLabels={pinLabels}
+      supplierPartNumbers={${JSON.stringify(supplierPartNumbers, null, "  ")}}
+      manufacturerPartNumber="${manufacturerPartNumber}"
+      footprint={${footprintTsx}}
+      ${objUrl ? `cadModel={{
+        objUrl: "${objUrl}",
+        rotationOffset: { x: 0, y: 0, z: 0 },
+        positionOffset: { x: 0, y: 0, z: 0 },
+      }}` : ""}
+      {...props}
+    />
+  )
+}
+`.trim();
+};
+
+// 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 path = [];
+  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);
+    path.push({ x, y });
+  }
+  return path;
+}
+
+// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
+import { compose, scale, translate } from "transformation-matrix";
+
+// lib/compute-center-offset.ts
+import { mm as mm2 } from "@tscircuit/mm";
+var computeCenterOffset = (easyeda) => {
+  const pads = easyeda.packageDetail.dataStr.shape.filter(
+    (shape) => shape.type === "PAD"
+  );
+  const minX = Math.min(...pads.map((pad) => mm2(pad.center.x)));
+  const maxX = Math.max(...pads.map((pad) => mm2(pad.center.x)));
+  const minY = Math.min(...pads.map((pad) => mm2(pad.center.y)));
+  const maxY = Math.max(...pads.map((pad) => mm2(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 mm3 } from "@tscircuit/mm";
+
+// lib/websafe/normalize-pin-labels.ts
+var normalizePinLabels = (inputPinLabels) => {
+  const unqInputPinLabels = inputPinLabels.map((labels) => [...new Set(labels)]);
+  const result = unqInputPinLabels.map(() => []);
+  const desiredNumbers = unqInputPinLabels.map(() => null);
+  for (let i = 0; i < unqInputPinLabels.length; i++) {
+    for (const label of unqInputPinLabels[i]) {
+      if (/^\d+$/.test(label)) {
+        desiredNumbers[i] = Number.parseInt(label);
+        break;
+      }
+    }
+  }
+  let highestPinNumber = 0;
+  const alreadyAcceptedDesiredNumbers = /* @__PURE__ */ new Set();
+  for (let i = 0; i < desiredNumbers.length; i++) {
+    const desiredNumber = desiredNumbers[i];
+    if (desiredNumber === null || desiredNumber < 1) {
+      continue;
+    }
+    if (!alreadyAcceptedDesiredNumbers.has(desiredNumber)) {
+      alreadyAcceptedDesiredNumbers.add(desiredNumber);
+      result[i].push(`pin${desiredNumber}`);
+      highestPinNumber = Math.max(highestPinNumber, desiredNumber);
+      continue;
+    }
+    let existingAltsForPin = 0;
+    for (const label of result[i]) {
+      if (label.startsWith(`pin${desiredNumber}_alt`)) {
+        existingAltsForPin++;
+      }
+    }
+    result[i].push(`pin${desiredNumber}_alt${existingAltsForPin + 1}`);
+  }
+  for (let i = 0; i < result.length; i++) {
+    const firstLabel = result[i][0];
+    if (firstLabel?.includes("_alt")) {
+      highestPinNumber++;
+      result[i].unshift(`pin${highestPinNumber}`);
+    }
+  }
+  for (let i = 0; i < result.length; i++) {
+    if (result[i].length === 0) {
+      highestPinNumber++;
+      result[i].push(`pin${highestPinNumber}`);
+    }
+  }
+  const totalLabelCounts = {};
+  for (const inputLabels of unqInputPinLabels) {
+    for (const label of inputLabels) {
+      if (/^\d+$/.test(label)) {
+        continue;
+      }
+      totalLabelCounts[label] = (totalLabelCounts[label] ?? 0) + 1;
+    }
+  }
+  const incrementalLabelCounts = {};
+  for (let i = 0; i < unqInputPinLabels.length; i++) {
+    const inputLabels = unqInputPinLabels[i];
+    for (const label of inputLabels) {
+      if (/^\d+$/.test(label)) {
+        continue;
+      }
+      if (totalLabelCounts[label] === 1) {
+        result[i].push(label);
+      } else {
+        incrementalLabelCounts[label] = (incrementalLabelCounts[label] ?? 0) + 1;
+        result[i].push(`${label}${incrementalLabelCounts[label]}`);
+      }
+    }
+  }
+  return result;
+};
+
+// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
+var mil2mm = (mil) => {
+  if (typeof mil === "number") return mm3(`${mil}mil`);
+  if (mil.match(/^\d+$/)) return mm3(`${mil}mil`);
+  return mm3(mil);
+};
+var milx10 = (mil10) => {
+  if (typeof mil10 === "number") return mil2mm(mil10) * 10;
+  if (mil10.match(/^\d+$/)) return mil2mm(mil10) * 10;
+  return mil2mm(mil10);
+};
+var handleSilkscreenPath = (track, index) => {
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    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: milx10(point2.x),
+      y: milx10(point2.y)
+    })),
+    stroke_width: mil10ToMm(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.map((p) => ({
+      x: milx10(p.x),
+      y: milx10(p.y)
+    })),
+    stroke_width: mil10ToMm(arc.width)
+  });
+};
+var handleHole = (hole, index) => {
+  return pcb_hole.parse({
+    type: "pcb_hole",
+    x: milx10(hole.center.x),
+    y: milx10(hole.center.y),
+    hole_diameter: milx10(hole.radius) * 2,
+    hole_shape: "circle",
+    pcb_hole_id: `pcb_hole_${index + 1}`
+  });
+};
+var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
+  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,
+    // we update this at the end
+    height: 0,
+    // we update this at the end
+    rotation: 0,
+    center: { x: 0, y: 0 },
+    layer: "top"
+  });
+  soupElements.push(source_component, pcb_component2);
+  const pads = easyEdaJson.packageDetail.dataStr.shape.filter(
+    (shape) => shape.type === "PAD"
+  );
+  const pins = easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN");
+  const pinLabelSets = pads.map((pad) => {
+    const labels = [];
+    if (pad.number) labels.push(pad.number.toString());
+    const pin = pins.find((p) => p.pinNumber === pad.number);
+    if (pin) labels.push(pin.label);
+    return labels;
+  });
+  const normalizedPinLabels = normalizePinLabels(pinLabelSets);
+  pads.forEach((pad, index) => {
+    const portHints = normalizedPinLabels[index];
+    const pinNumber = Number.parseInt(
+      portHints.find((hint) => hint.match(/pin\d+/)).replace("pin", "")
+    );
+    soupElements.push({
+      type: "source_port",
+      source_port_id: `source_port_${index + 1}`,
+      source_component_id: "source_component_1",
+      name: `pin${pinNumber}`,
+      pin_number: pinNumber,
+      port_hints: portHints.filter((hint) => hint !== `pin${pinNumber}`)
+    });
+    if (pad.holeRadius !== void 0 && mil2mm(pad.holeRadius) !== 0) {
+      const commonPlatedHoleProps = {
+        type: "pcb_plated_hole",
+        pcb_plated_hole_id: `pcb_plated_hole_${index + 1}`,
+        x: mil2mm(pad.center.x),
+        y: mil2mm(pad.center.y),
+        layers: ["top"],
+        port_hints: [`pin${pinNumber}`],
+        pcb_component_id: "pcb_component_1",
+        pcb_port_id: `pcb_port_${index + 1}`
+      };
+      let additionalPlatedHoleProps;
+      if (pad.shape === "OVAL") {
+        const largestOuterDimensionName = mil2mm(pad.width) > mil2mm(pad.height) ? "width" : "height";
+        const smallestOuterDimension = Math.min(
+          mil2mm(pad.width),
+          mil2mm(pad.height)
+        );
+        const largestOuterDimension = Math.max(
+          mil2mm(pad.width),
+          mil2mm(pad.height)
+        );
+        const distanceFromOuterPlatingToHole = smallestOuterDimension / 2 - mil2mm(pad.holeRadius);
+        const largestInnerDimension = largestOuterDimension - distanceFromOuterPlatingToHole * 2;
+        const smallestInnerDimension = mil2mm(pad.holeRadius) * 2;
+        const innerWidth = largestOuterDimensionName === "width" ? largestInnerDimension : smallestInnerDimension;
+        const innerHeight = largestOuterDimensionName === "height" ? largestInnerDimension : smallestInnerDimension;
+        additionalPlatedHoleProps = {
+          shape: "pill",
+          outer_width: mil2mm(pad.width),
+          outer_height: mil2mm(pad.height),
+          hole_width: innerWidth,
+          hole_height: innerHeight
+        };
+      } else {
+        additionalPlatedHoleProps = {
+          shape: "circle",
+          hole_diameter: mil2mm(pad.holeRadius) * 2,
+          outer_diameter: mil2mm(pad.width),
+          radius: mil2mm(pad.holeRadius)
+        };
+      }
+      soupElements.push(
+        pcb_plated_hole.parse({
+          ...commonPlatedHoleProps,
+          ...additionalPlatedHoleProps
+        })
+      );
+    } 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}"`);
+      }
+      const rectSize = { width: mil2mm(pad.width), height: mil2mm(pad.height) };
+      if (pad.rotation === 90 || pad.rotation === 270) {
+        rectSize.width = mil2mm(pad.height);
+        rectSize.height = mil2mm(pad.width);
+      }
+      const parsedPcbSmtpad = pcb_smtpad.parse({
+        type: "pcb_smtpad",
+        pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
+        shape: soupShape,
+        x: mil2mm(pad.center.x),
+        y: mil2mm(pad.center.y),
+        ...soupShape === "rect" ? rectSize : { radius: Math.min(mil2mm(pad.width), mil2mm(pad.height)) / 2 },
+        layer: "top",
+        port_hints: [`pin${pinNumber}`],
+        pcb_component_id: "pcb_component_1",
+        pcb_port_id: `pcb_port_${index + 1}`
+      });
+      soupElements.push(parsedPcbSmtpad);
+    }
+  });
+  easyEdaJson.packageDetail.dataStr.shape.filter(
+    (shape) => shape.type === "HOLE"
+  ).forEach((h, index) => {
+    soupElements.push(handleHole(h, index));
+  });
+  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
+    if (shape.type === "TRACK") {
+      soupElements.push(handleSilkscreenPath(shape, index));
+    } else if (shape.type === "ARC") {
+      soupElements.push(handleSilkscreenArc(shape, index));
+    } else if (shape.type === "TEXT") {
+      soupElements.push(
+        pcb_silkscreen_text.parse({
+          type: "pcb_silkscreen_text",
+          pcb_silkscreen_text_id: `pcb_silkscreen_text_${index + 1}`,
+          pcb_component_id: "pcb_component_1",
+          text: shape.text,
+          anchor_position: {
+            x: mil2mm(shape.x),
+            y: mil2mm(shape.y)
+          },
+          anchor_alignment: {
+            L: "bottom_left",
+            C: "center",
+            R: "bottom_right"
+          }[shape.textAnchor ?? "L"],
+          font_size: shape.size_mm ? shape.size_mm : void 0,
+          layer: "top"
+        })
+      );
+    }
+  });
+  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) {
+    const bounds = findBoundsAndCenter(
+      // exclude the pcb_component because it's center is currently incorrect,
+      // we set it to (0,0)
+      soupElements.filter((e) => e.type !== "pcb_component")
+    );
+    transformPCBElements(
+      soupElements,
+      compose(translate(-bounds.center.x, bounds.center.y), scale(1, -1))
+    );
+    pcb_component2.center = { x: 0, y: 0 };
+  }
+  return soupElements;
+};
+
+// 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/websafe/convert-to-typescript-component/index.tsx
+var convertRawEasyToTsx = async (rawEasy) => {
+  const betterEasy = EasyEdaJsonSchema.parse(rawEasy);
+  const result = await convertBetterEasyToTsx({
+    betterEasy
+  });
+  return result;
+};
+var convertBetterEasyToTsx = async ({
+  betterEasy
+}) => {
+  const circuitJson = convertEasyEdaJsonToCircuitJson(betterEasy, {
+    useModelCdn: true,
+    shouldRecenter: true
+  });
+  const rawPn = betterEasy.dataStr.head.c_para["Manufacturer Part"];
+  const pn = normalizeManufacturerPartNumber(rawPn);
+  const sourcePorts = su_default(circuitJson).source_port.list();
+  const pinLabels = {};
+  const sortedPorts = sourcePorts.sort((a, b) => {
+    const aNum = parseInt(a.name.replace("pin", ""));
+    const bNum = parseInt(b.name.replace("pin", ""));
+    return aNum - bNum;
+  });
+  for (const sourcePort of sortedPorts) {
+    pinLabels[sourcePort.name] = [
+      sourcePort.name,
+      ...sourcePort.port_hints ?? []
+    ];
+  }
+  const [cadComponent] = su_default(circuitJson).cad_component.list();
+  let modelObjUrl;
+  if (cadComponent?.model_obj_url) {
+    const isValidUrl = await checkModelObjUrlValidity(
+      cadComponent.model_obj_url
+    );
+    if (isValidUrl) {
+      modelObjUrl = cadComponent.model_obj_url;
+    }
+  }
+  const supplierPartNumbers = {
+    jlcpcb: [betterEasy.lcsc.number]
+  };
+  return generateTypescriptComponent({
+    componentName: pn,
+    manufacturerPartNumber: pn,
+    pinLabels,
+    objUrl: modelObjUrl,
+    circuitJson,
+    supplierPartNumbers
+  });
+};
+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/websafe/fetch-easyeda-json.ts
+async function fetchEasyEDAComponent(jlcpcbPartNumber, { fetch: fetch2 = globalThis.fetch } = {}) {
+  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 fetch2(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 bestMatchComponent = searchResult.result.lists.lcsc.find(
+    (component) => component.dataStr.head.c_para["Supplier Part"] === jlcpcbPartNumber
+  ) ?? searchResult.result.lists.lcsc[0];
+  const componentUUID = bestMatchComponent.uuid;
+  const componentResponse = await fetch2(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/websafe/get-model-cdn-url.ts
+var getModelCdnUrl = ({
+  easyedaModelUuid,
+  easyedaPartNumber
+}) => {
+  return `https://modelcdn.tscircuit.com/easyeda_models/download?uuid=${easyedaModelUuid}&pn=${easyedaPartNumber}`;
+};
+export {
+  convertBetterEasyToTsx,
+  convertRawEasyToTsx,
+  fetchEasyEDAComponent,
+  generateFootprintTsx,
+  getModelCdnUrl
+};
+//# sourceMappingURL=index.js.map