easyeda 0.0.31 → 0.0.33

package/dist/cli/main.cjs

@@ -1,2377 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// cli/main.ts
-var import_commander = require("commander");
-
-// lib/fetch-easyeda-json.ts
-async function fetchEasyEDAComponent(jlcpcbPartNumber) {
-  const searchUrl = "https://easyeda.com/api/components/search";
-  const componentUrl = (uuid) => `https://easyeda.com/api/components/${uuid}?version=6.4.7&uuid=${uuid}&datastrid=`;
-  const searchHeaders = {
-    authority: "easyeda.com",
-    pragma: "no-cache",
-    "cache-control": "no-cache",
-    accept: "application/json, text/javascript, */*; q=0.01",
-    "x-requested-with": "XMLHttpRequest",
-    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
-    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
-    origin: "https://easyeda.com",
-    "sec-fetch-site": "same-origin",
-    "sec-fetch-mode": "cors",
-    "sec-fetch-dest": "empty",
-    referer: "https://easyeda.com/editor",
-    "accept-language": "cs,en;q=0.9,sk;q=0.8,en-GB;q=0.7",
-    cookie: "<PUT your cookies here>"
-  };
-  const searchData = `type=3&doctype%5B%5D=2&uid=0819f05c4eef4c71ace90d822a990e87&returnListStyle=classifyarr&wd=${jlcpcbPartNumber}&version=6.4.7`;
-  const searchResponse = await fetch(searchUrl, {
-    method: "POST",
-    headers: searchHeaders,
-    body: searchData
-  });
-  if (!searchResponse.ok) {
-    throw new Error("Failed to search for the component");
-  }
-  const searchResult = await searchResponse.json();
-  if (!searchResult.success || !searchResult.result.lists.lcsc.length) {
-    throw new Error("Component not found");
-  }
-  const componentUUID = searchResult.result.lists.lcsc[0].uuid;
-  const componentResponse = await fetch(componentUrl(componentUUID), {
-    method: "GET",
-    headers: {
-      ...searchHeaders,
-      referer: `https://easyeda.com/editor?uuid=${componentUUID}`
-    }
-  });
-  if (!componentResponse.ok) {
-    throw new Error("Failed to fetch the component details");
-  }
-  const componentResult = await componentResponse.json();
-  return componentResult.result;
-}
-
-// lib/schemas/package-detail-shape-schema.ts
-var import_zod = require("zod");
-var tenthmil = import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional().transform(
-  (n) => typeof n === "string" && n.endsWith("mil") ? n : `${Number.parseFloat(n) * 10}mil`
-).pipe(import_zod.z.string());
-var PointSchema = import_zod.z.any().transform((p) => {
-  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(
-  import_zod.z.object({
-    x: import_zod.z.number(),
-    y: import_zod.z.number()
-  })
-);
-var BaseShapeSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  id: import_zod.z.string().optional(),
-  layer: import_zod.z.coerce.number().optional()
-});
-var TrackSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("TRACK"),
-  width: import_zod.z.coerce.number(),
-  points: import_zod.z.array(PointSchema)
-});
-var PadSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("PAD"),
-  shape: import_zod.z.enum(["RECT", "ELLIPSE", "OVAL"]),
-  center: import_zod.z.object({
-    x: tenthmil,
-    y: tenthmil
-  }),
-  width: tenthmil,
-  height: tenthmil,
-  layermask: import_zod.z.number(),
-  net: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
-  number: import_zod.z.number(),
-  holeRadius: tenthmil,
-  points: import_zod.z.array(PointSchema).optional(),
-  rotation: import_zod.z.number().optional(),
-  plated: import_zod.z.boolean()
-});
-var ArcSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("ARC"),
-  width: import_zod.z.number(),
-  start: PointSchema,
-  end: PointSchema,
-  radiusX: import_zod.z.number(),
-  radiusY: import_zod.z.number(),
-  largeArc: import_zod.z.boolean(),
-  sweepDirection: import_zod.z.enum(["CW", "CCW"])
-});
-var CircleSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("CIRCLE"),
-  center: PointSchema,
-  radius: import_zod.z.number(),
-  width: import_zod.z.number()
-});
-var SolidRegionSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("SOLIDREGION"),
-  layermask: import_zod.z.number(),
-  points: import_zod.z.array(PointSchema),
-  fillStyle: import_zod.z.string()
-});
-var SVGNodeSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("SVGNODE"),
-  svgData: import_zod.z.object({
-    gId: import_zod.z.string(),
-    nodeName: import_zod.z.string(),
-    nodeType: import_zod.z.number(),
-    layerid: import_zod.z.string(),
-    attrs: import_zod.z.record(import_zod.z.string(), import_zod.z.string()),
-    childNodes: import_zod.z.array(import_zod.z.unknown())
-  })
-});
-var HoleSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("HOLE"),
-  center: PointSchema,
-  radius: import_zod.z.number()
-});
-var RectSchema = BaseShapeSchema.extend({
-  type: import_zod.z.literal("RECT"),
-  x: tenthmil,
-  y: tenthmil,
-  width: tenthmil,
-  height: tenthmil,
-  lineWidth: import_zod.z.number(),
-  fillStyle: import_zod.z.string(),
-  rotation: import_zod.z.number().optional()
-});
-var PackageDetailShapeSchema = import_zod.z.discriminatedUnion("type", [
-  TrackSchema,
-  PadSchema,
-  ArcSchema,
-  CircleSchema,
-  SolidRegionSchema,
-  SVGNodeSchema,
-  HoleSchema,
-  RectSchema
-]);
-var pairs = (arr) => {
-  const pairs2 = [];
-  for (let i = 0; i < arr.length; i += 2) {
-    pairs2.push([arr[i], arr[i + 1]]);
-  }
-  return pairs2;
-};
-var parsePoints = (pointsStr) => pairs(
-  pointsStr.trim().split(" ").map((n) => Number(n))
-);
-var ShapeItemSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  data: import_zod.z.string()
-}).transform((shape) => {
-  const [firstParam, ...restParams] = shape.data.split("~");
-  const lastParam = restParams.pop();
-  switch (shape.type) {
-    case "TRACK": {
-      const [width, layer, _, pointsStr, id, _n] = shape.data.split("~");
-      const points = parsePoints(pointsStr);
-      return TrackSchema.parse({ type: "TRACK", width, layer, points, id });
-    }
-    case "PAD": {
-      const [padShape, ...params] = shape.data.split("~");
-      const [
-        centerX,
-        centerY,
-        width,
-        height,
-        layermask,
-        net,
-        number,
-        holeRadius,
-        ...rest
-      ] = params.map((p) => isNaN(Number(p)) ? p : Number(p));
-      const center = { x: centerX, y: centerY };
-      let points, rotation2;
-      if (padShape === "RECT") {
-        points = parsePoints(rest[0]);
-        rotation2 = Number(rest[1]);
-      }
-      const padInputParams = {
-        type: "PAD",
-        shape: padShape,
-        center,
-        width,
-        height,
-        layermask,
-        net,
-        number,
-        holeRadius,
-        points,
-        rotation: rotation2,
-        plated: rest.includes("Y")
-      };
-      const pad = PadSchema.parse(padInputParams);
-      return pad;
-    }
-    case "ARC": {
-      const [width, layer, , arcData] = shape.data.split("~");
-      const [
-        ,
-        startX,
-        startY,
-        radiusX,
-        radiusY,
-        xAxisRotation,
-        largeArcFlag,
-        sweepFlag,
-        endX,
-        endY
-      ] = arcData.match(
-        /M\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*A\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)\s*([\d.]+)\s*([01])\s*([01])\s*([\d.]+)(?:\s*,\s*|\s+)([\d.]+)/
-      );
-      const start = [Number(startX), Number(startY)];
-      const end = [Number(endX), Number(endY)];
-      return ArcSchema.parse({
-        type: "ARC",
-        width: Number(width),
-        layer: Number(layer),
-        start,
-        end,
-        radiusX: Number(radiusX),
-        radiusY: Number(radiusY),
-        largeArc: largeArcFlag === "1",
-        sweepDirection: sweepFlag === "1" ? "CW" : "CCW"
-      });
-    }
-    case "CIRCLE": {
-      const [centerX, centerY, radius, width, layer, id] = shape.data.split("~");
-      const center = [Number(centerX), Number(centerY)];
-      return CircleSchema.parse({
-        type: "CIRCLE",
-        center,
-        radius: Number(radius),
-        width: Number(width),
-        layer: Number(layer),
-        id
-      });
-    }
-    case "HOLE": {
-      const [centerX, centerY, radius, id] = shape.data.split("~");
-      const center = [Number(centerX), Number(centerY)];
-      return HoleSchema.parse({
-        type: "HOLE",
-        center,
-        radius: Number(radius),
-        id
-      });
-    }
-    case "SOLIDREGION": {
-      const [layermask, , pathData, fillStyle, id] = shape.data.split("~");
-      const points = pathData.match(/[ML] ?(-?[\d.]+)[ ,](-?[\d.]+)/g)?.map((point2) => {
-        const [, x, y] = point2.match(/[ML]? ?(-?[\d.]+)[ ,](-?[\d.]+)/) || [];
-        return [Number(x), Number(y)];
-      }) || [];
-      return SolidRegionSchema.parse({
-        type: "SOLIDREGION",
-        layermask: Number(layermask),
-        points,
-        fillStyle,
-        id
-      });
-    }
-    case "SVGNODE": {
-      const svgData = JSON.parse(shape.data);
-      return SVGNodeSchema.parse({ type: "SVGNODE", svgData });
-    }
-    case "RECT": {
-      const [x, y, width, height, lineWidth, id, rotation2, layer, fillStyle] = shape.data.split("~");
-      return RectSchema.parse({
-        type: "RECT",
-        x,
-        y,
-        width,
-        height,
-        lineWidth: Number(lineWidth),
-        id,
-        rotation: rotation2 ? Number(rotation2) : void 0,
-        layer: layer ? Number(layer) : void 0,
-        fillStyle: fillStyle || void 0
-      });
-    }
-    default:
-      throw new Error(`Unknown shape type: ${shape.type}`);
-      return BaseShapeSchema.parse({ type: shape.type });
-  }
-}).pipe(PackageDetailShapeSchema);
-var ShapesArraySchema = import_zod.z.array(ShapeItemSchema);
-
-// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_zod60 = require("zod");
-
-// node_modules/circuit-json/dist/index.mjs
-var dist_exports = {};
-__export(dist_exports, {
-  all_layers: () => all_layers,
-  any_circuit_element: () => any_circuit_element,
-  any_soup_element: () => any_soup_element,
-  any_source_component: () => any_source_component,
-  cad_component: () => cad_component,
-  capacitance: () => capacitance,
-  current: () => current,
-  distance: () => distance,
-  getZodPrefixedIdWithDefault: () => getZodPrefixedIdWithDefault,
-  inductance: () => inductance,
-  layer_ref: () => layer_ref,
-  layer_string: () => layer_string,
-  length: () => length,
-  pcb_board: () => pcb_board,
-  pcb_component: () => pcb_component,
-  pcb_fabrication_note_path: () => pcb_fabrication_note_path,
-  pcb_fabrication_note_text: () => pcb_fabrication_note_text,
-  pcb_hole: () => pcb_hole,
-  pcb_hole_circle_or_square_shape: () => pcb_hole_circle_or_square_shape,
-  pcb_hole_oval_shape: () => pcb_hole_oval_shape,
-  pcb_keepout: () => pcb_keepout,
-  pcb_placement_error: () => pcb_placement_error,
-  pcb_plated_hole: () => pcb_plated_hole,
-  pcb_port: () => pcb_port,
-  pcb_port_not_matched_error: () => pcb_port_not_matched_error,
-  pcb_route_hint: () => pcb_route_hint,
-  pcb_route_hints: () => pcb_route_hints,
-  pcb_silkscreen_circle: () => pcb_silkscreen_circle,
-  pcb_silkscreen_line: () => pcb_silkscreen_line,
-  pcb_silkscreen_oval: () => pcb_silkscreen_oval,
-  pcb_silkscreen_path: () => pcb_silkscreen_path,
-  pcb_silkscreen_rect: () => pcb_silkscreen_rect,
-  pcb_silkscreen_text: () => pcb_silkscreen_text,
-  pcb_smtpad: () => pcb_smtpad,
-  pcb_solder_paste: () => pcb_solder_paste,
-  pcb_text: () => pcb_text,
-  pcb_trace: () => pcb_trace,
-  pcb_trace_error: () => pcb_trace_error,
-  pcb_trace_hint: () => pcb_trace_hint,
-  pcb_trace_route_point: () => pcb_trace_route_point,
-  pcb_trace_route_point_via: () => pcb_trace_route_point_via,
-  pcb_trace_route_point_wire: () => pcb_trace_route_point_wire,
-  pcb_via: () => pcb_via,
-  point: () => point,
-  point3: () => point3,
-  position: () => position,
-  position3: () => position3,
-  resistance: () => resistance,
-  rotation: () => rotation,
-  route_hint_point: () => route_hint_point,
-  schematic_box: () => schematic_box,
-  schematic_component: () => schematic_component,
-  schematic_error: () => schematic_error,
-  schematic_line: () => schematic_line,
-  schematic_net_label: () => schematic_net_label,
-  schematic_path: () => schematic_path,
-  schematic_pin_styles: () => schematic_pin_styles,
-  schematic_port: () => schematic_port,
-  schematic_text: () => schematic_text,
-  schematic_trace: () => schematic_trace,
-  size: () => size,
-  source_component_base: () => source_component_base,
-  source_group: () => source_group,
-  source_led: () => source_led,
-  source_net: () => source_net,
-  source_port: () => source_port,
-  source_simple_bug: () => source_simple_bug,
-  source_simple_capacitor: () => source_simple_capacitor,
-  source_simple_chip: () => source_simple_chip,
-  source_simple_diode: () => source_simple_diode,
-  source_simple_ground: () => source_simple_ground,
-  source_simple_power_source: () => source_simple_power_source,
-  source_simple_resistor: () => source_simple_resistor,
-  source_trace: () => source_trace,
-  supplier_name: () => supplier_name,
-  time: () => time,
-  visible_layer: () => visible_layer,
-  voltage: () => voltage
-});
-var import_zod2 = require("zod");
-var import_zod3 = require("zod");
-var import_zod4 = require("zod");
-var import_zod5 = require("zod");
-var import_zod6 = require("zod");
-
-// node_modules/nanoid/index.js
-var import_node_crypto = require("crypto");
-
-// node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-
-// node_modules/nanoid/index.js
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    import_node_crypto.webcrypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    import_node_crypto.webcrypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function nanoid(size2 = 21) {
-  fillPool(size2 -= 0);
-  let id = "";
-  for (let i = poolOffset - size2; i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id;
-}
-
-// node_modules/circuit-json/dist/index.mjs
-var import_zod7 = require("zod");
-var import_zod8 = require("zod");
-var import_zod9 = require("zod");
-var import_zod10 = require("zod");
-var import_zod11 = require("zod");
-var import_zod12 = require("zod");
-var import_zod13 = require("zod");
-var import_zod14 = require("zod");
-var import_zod15 = require("zod");
-var import_zod16 = require("zod");
-var import_zod17 = require("zod");
-var import_zod18 = require("zod");
-var import_zod19 = require("zod");
-var import_zod20 = require("zod");
-var import_zod21 = require("zod");
-var import_zod22 = require("zod");
-var import_zod23 = require("zod");
-var import_zod24 = require("zod");
-var import_zod25 = require("zod");
-var import_zod26 = require("zod");
-var import_zod27 = require("zod");
-var import_zod28 = require("zod");
-var import_zod29 = require("zod");
-var import_zod30 = require("zod");
-var import_zod31 = require("zod");
-var import_zod32 = require("zod");
-var import_zod33 = require("zod");
-var import_zod34 = require("zod");
-var import_zod35 = require("zod");
-var import_zod36 = require("zod");
-var import_zod37 = require("zod");
-var import_zod38 = require("zod");
-var import_zod39 = require("zod");
-var import_zod40 = require("zod");
-var import_zod41 = require("zod");
-var import_zod42 = require("zod");
-var import_zod43 = require("zod");
-var import_zod44 = require("zod");
-var import_zod45 = require("zod");
-var import_zod46 = require("zod");
-var import_zod47 = require("zod");
-var import_zod48 = require("zod");
-var import_zod49 = require("zod");
-var import_zod50 = require("zod");
-var import_zod51 = require("zod");
-var import_zod52 = require("zod");
-var import_zod53 = require("zod");
-var import_zod54 = require("zod");
-var import_zod55 = require("zod");
-var import_zod56 = require("zod");
-var import_zod57 = require("zod");
-var import_zod58 = require("zod");
-var import_zod59 = require("zod");
-var unitMappings = {
-  Hz: {
-    baseUnit: "Hz",
-    variants: {
-      MHz: 1e6,
-      kHz: 1e3,
-      Hz: 1
-    }
-  },
-  g: {
-    baseUnit: "g",
-    variants: {
-      kg: 1e3,
-      g: 1
-    }
-  },
-  \u03A9: {
-    baseUnit: "\u03A9",
-    variants: {
-      m\u03A9: 1e-3,
-      \u03A9: 1,
-      k\u03A9: 1e3,
-      M\u03A9: 1e6,
-      G\u03A9: 1e9,
-      T\u03A9: 1e12
-    }
-  },
-  V: {
-    baseUnit: "V",
-    variants: {
-      mV: 1e-3,
-      V: 1,
-      kV: 1e3,
-      MV: 1e6,
-      GV: 1e9,
-      TV: 1e12
-    }
-  },
-  A: {
-    baseUnit: "A",
-    variants: {
-      \u00B5A: 1e-6,
-      mA: 1e-3,
-      ma: 1e-3,
-      A: 1,
-      kA: 1e3,
-      MA: 1e6
-    }
-  },
-  F: {
-    baseUnit: "F",
-    variants: {
-      pF: 1e-12,
-      nF: 1e-9,
-      \u00B5F: 1e-6,
-      mF: 1e-3,
-      F: 1
-    }
-  },
-  ml: {
-    baseUnit: "ml",
-    variants: {
-      ml: 1,
-      mL: 1,
-      l: 1e3,
-      L: 1e3
-    }
-  },
-  deg: {
-    baseUnit: "deg",
-    variants: {
-      rad: 180 / Math.PI
-    }
-  },
-  ms: {
-    baseUnit: "ms",
-    variants: {
-      s: 1e3
-    }
-  },
-  mm: {
-    baseUnit: "mm",
-    variants: {
-      nm: 1e-6,
-      \u00B5m: 1e-3,
-      um: 1e-3,
-      mm: 1,
-      cm: 10,
-      dm: 100,
-      m: 1e3,
-      km: 1e6,
-      in: 25.4,
-      ft: 304.8,
-      IN: 25.4,
-      FT: 304.8,
-      yd: 914.4,
-      mi: 1609344
-    }
-  }
-};
-function getBaseTscircuitUnit(unit) {
-  for (const [baseUnit, info] of Object.entries(unitMappings)) {
-    if (unit in info.variants) {
-      return {
-        baseUnit: info.baseUnit,
-        conversionFactor: info.variants[unit]
-      };
-    }
-  }
-  return {
-    baseUnit: unit,
-    conversionFactor: 1
-  };
-}
-var parseAndConvertSiUnit = (v) => {
-  if (typeof v === "undefined")
-    return { parsedUnit: null, unitOfValue: null, value: null };
-  if (typeof v === "string" && v.match(/^[\d\.]+$/))
-    return {
-      value: Number.parseFloat(v),
-      parsedUnit: null,
-      unitOfValue: null
-    };
-  if (typeof v === "number")
-    return { value: v, parsedUnit: null, unitOfValue: null };
-  if (typeof v === "object" && "x" in v && "y" in v) {
-    const { parsedUnit, unitOfValue } = parseAndConvertSiUnit(v.x);
-    return {
-      parsedUnit,
-      unitOfValue,
-      value: {
-        x: parseAndConvertSiUnit(v.x).value,
-        y: parseAndConvertSiUnit(v.y).value
-      }
-    };
-  }
-  const unit_reversed = v.split("").reverse().join("").match(/[a-zA-Z]+/)?.[0];
-  if (!unit_reversed) {
-    throw new Error(`Could not determine unit: "${v}"`);
-  }
-  const unit = unit_reversed.split("").reverse().join("");
-  const value = v.slice(0, -unit.length);
-  const { baseUnit, conversionFactor } = getBaseTscircuitUnit(unit);
-  return {
-    parsedUnit: unit,
-    unitOfValue: baseUnit,
-    value: conversionFactor * Number.parseFloat(value)
-  };
-};
-var resistance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var capacitance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var inductance = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var voltage = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var length = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var distance = length;
-var current = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var time = import_zod2.z.string().or(import_zod2.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var rotation = import_zod2.z.string().or(import_zod2.z.number()).transform((arg) => {
-  if (typeof arg === "number") return arg;
-  if (arg.endsWith("deg")) {
-    return Number.parseFloat(arg.split("deg")[0]);
-  }
-  if (arg.endsWith("rad")) {
-    return Number.parseFloat(arg.split("rad")[0]) * 180 / Math.PI;
-  }
-  return Number.parseFloat(arg);
-});
-var point = import_zod3.z.object({
-  x: distance,
-  y: distance
-});
-var position = point;
-var point3 = import_zod4.z.object({
-  x: distance,
-  y: distance,
-  z: distance
-});
-var position3 = point3;
-var size = import_zod5.z.object({
-  width: import_zod5.z.number(),
-  height: import_zod5.z.number()
-});
-var getZodPrefixedIdWithDefault = (prefix) => {
-  return import_zod6.z.string().optional().default(() => `${prefix}_${nanoid(10)}`);
-};
-var supplier_name = import_zod8.z.enum([
-  "jlcpcb",
-  "macrofab",
-  "pcbway",
-  "digikey",
-  "mouser",
-  "lcsc"
-]);
-var source_component_base = import_zod9.z.object({
-  type: import_zod9.z.literal("source_component"),
-  ftype: import_zod9.z.string().optional(),
-  source_component_id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  manufacturer_part_number: import_zod9.z.string().optional(),
-  supplier_part_numbers: import_zod9.z.record(supplier_name, import_zod9.z.array(import_zod9.z.string())).optional()
-});
-var source_simple_capacitor = source_component_base.extend({
-  ftype: import_zod7.z.literal("simple_capacitor"),
-  capacitance
-});
-var source_simple_resistor = source_component_base.extend({
-  ftype: import_zod10.z.literal("simple_resistor"),
-  resistance
-});
-var source_simple_diode = source_component_base.extend({
-  ftype: import_zod11.z.literal("simple_diode")
-});
-var source_simple_ground = source_component_base.extend({
-  ftype: import_zod12.z.literal("simple_ground")
-});
-var source_simple_bug = source_component_base.extend({
-  ftype: import_zod13.z.literal("simple_bug")
-}).describe("@deprecated");
-var source_simple_chip = source_component_base.extend({
-  ftype: import_zod14.z.literal("simple_chip")
-});
-var source_simple_inductor = source_component_base.extend({
-  ftype: import_zod15.z.literal("simple_inductor"),
-  inductance
-});
-var source_led = source_simple_diode.extend({
-  ftype: import_zod16.z.literal("led")
-});
-var source_simple_power_source = source_component_base.extend({
-  ftype: import_zod17.z.literal("simple_power_source"),
-  voltage
-});
-var any_source_component = import_zod18.z.union([
-  source_simple_resistor,
-  source_simple_capacitor,
-  source_simple_diode,
-  source_simple_ground,
-  source_simple_chip,
-  source_simple_bug,
-  source_led,
-  source_simple_power_source
-]);
-var source_port = import_zod19.z.object({
-  type: import_zod19.z.literal("source_port"),
-  pin_number: import_zod19.z.number().optional(),
-  port_hints: import_zod19.z.array(import_zod19.z.string()).optional(),
-  name: import_zod19.z.string(),
-  source_port_id: import_zod19.z.string(),
-  source_component_id: import_zod19.z.string()
-});
-var source_trace = import_zod20.z.object({
-  type: import_zod20.z.literal("source_trace"),
-  source_trace_id: import_zod20.z.string(),
-  connected_source_port_ids: import_zod20.z.array(import_zod20.z.string()),
-  connected_source_net_ids: import_zod20.z.array(import_zod20.z.string())
-});
-var source_group = import_zod21.z.object({
-  type: import_zod21.z.literal("source_group"),
-  source_group_id: import_zod21.z.string(),
-  name: import_zod21.z.string().optional()
-});
-var source_net = import_zod22.z.object({
-  type: import_zod22.z.literal("source_net"),
-  source_net_id: import_zod22.z.string(),
-  name: import_zod22.z.string(),
-  member_source_group_ids: import_zod22.z.array(import_zod22.z.string()),
-  is_power: import_zod22.z.boolean().optional(),
-  is_ground: import_zod22.z.boolean().optional(),
-  is_digital_signal: import_zod22.z.boolean().optional(),
-  is_analog_signal: import_zod22.z.boolean().optional(),
-  trace_width: import_zod22.z.number().optional()
-});
-var schematic_box = import_zod23.z.object({
-  type: import_zod23.z.literal("schematic_box"),
-  schematic_component_id: import_zod23.z.string(),
-  width: distance,
-  height: distance,
-  x: distance,
-  y: distance
-}).describe("Draws a box on the schematic");
-var schematic_path = import_zod24.z.object({
-  type: import_zod24.z.literal("schematic_path"),
-  schematic_component_id: import_zod24.z.string(),
-  fill_color: import_zod24.z.enum(["red", "blue"]).optional(),
-  is_filled: import_zod24.z.boolean().optional(),
-  points: import_zod24.z.array(point)
-});
-var schematic_pin_styles = import_zod25.z.record(
-  import_zod25.z.object({
-    left_margin: length.optional(),
-    right_margin: length.optional(),
-    top_margin: length.optional(),
-    bottom_margin: length.optional()
-  })
-);
-var schematic_component = import_zod25.z.object({
-  type: import_zod25.z.literal("schematic_component"),
-  rotation: rotation.default(0),
-  size,
-  center: point,
-  source_component_id: import_zod25.z.string(),
-  schematic_component_id: import_zod25.z.string(),
-  pin_spacing: length.optional(),
-  pin_styles: schematic_pin_styles.optional(),
-  box_width: length.optional(),
-  symbol_name: import_zod25.z.string().optional(),
-  port_arrangement: import_zod25.z.union([
-    import_zod25.z.object({
-      left_size: import_zod25.z.number(),
-      right_size: import_zod25.z.number(),
-      top_size: import_zod25.z.number().optional(),
-      bottom_size: import_zod25.z.number().optional()
-    }),
-    import_zod25.z.object({
-      left_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
-      }).optional(),
-      right_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
-      }).optional(),
-      top_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["left-to-right", "right-to-left"]).optional()
-      }).optional(),
-      bottom_side: import_zod25.z.object({
-        pins: import_zod25.z.array(import_zod25.z.number()),
-        direction: import_zod25.z.enum(["left-to-right", "right-to-left"]).optional()
-      }).optional()
-    })
-  ]).optional(),
-  port_labels: import_zod25.z.record(import_zod25.z.string()).optional()
-});
-var schematic_line = import_zod26.z.object({
-  type: import_zod26.z.literal("schematic_line"),
-  schematic_component_id: import_zod26.z.string(),
-  x1: distance,
-  x2: distance,
-  y1: distance,
-  y2: distance
-});
-var schematic_trace = import_zod27.z.object({
-  type: import_zod27.z.literal("schematic_trace"),
-  schematic_trace_id: import_zod27.z.string(),
-  source_trace_id: import_zod27.z.string(),
-  edges: import_zod27.z.array(
-    import_zod27.z.object({
-      from: import_zod27.z.object({
-        x: import_zod27.z.number(),
-        y: import_zod27.z.number()
-      }),
-      to: import_zod27.z.object({
-        x: import_zod27.z.number(),
-        y: import_zod27.z.number()
-      }),
-      from_schematic_port_id: import_zod27.z.string().optional(),
-      to_schematic_port_id: import_zod27.z.string().optional()
-    })
-  )
-});
-var schematic_text = import_zod28.z.object({
-  type: import_zod28.z.literal("schematic_text"),
-  schematic_component_id: import_zod28.z.string(),
-  schematic_text_id: import_zod28.z.string(),
-  text: import_zod28.z.string(),
-  position: import_zod28.z.object({
-    x: distance,
-    y: distance
-  }),
-  rotation: import_zod28.z.number().default(0),
-  anchor: import_zod28.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
-});
-var schematic_port = import_zod29.z.object({
-  type: import_zod29.z.literal("schematic_port"),
-  schematic_port_id: import_zod29.z.string(),
-  source_port_id: import_zod29.z.string(),
-  schematic_component_id: import_zod29.z.string().optional(),
-  center: point,
-  facing_direction: import_zod29.z.enum(["up", "down", "left", "right"]).optional()
-}).describe("Defines a port on a schematic component");
-var schematic_net_label = import_zod30.z.object({
-  type: import_zod30.z.literal("schematic_net_label"),
-  source_net_id: import_zod30.z.string(),
-  center: point,
-  anchor_side: import_zod30.z.enum(["top", "bottom", "left", "right"]),
-  text: import_zod30.z.string()
-});
-var schematic_error = import_zod31.z.object({
-  schematic_error_id: import_zod31.z.string(),
-  type: import_zod31.z.literal("schematic_error"),
-  // eventually each error type should be broken out into a dir of files
-  error_type: import_zod31.z.literal("schematic_port_not_found"),
-  message: import_zod31.z.string()
-}).describe("Defines a schematic error on the schematic");
-var all_layers = [
-  "top",
-  "bottom",
-  "inner1",
-  "inner2",
-  "inner3",
-  "inner4",
-  "inner5",
-  "inner6"
-];
-var layer_string = import_zod32.z.enum(all_layers);
-var layer_ref = layer_string.or(
-  import_zod32.z.object({
-    name: layer_string
-  })
-).transform((layer) => {
-  if (typeof layer === "string") {
-    return layer;
-  }
-  return layer.name;
-});
-var visible_layer = import_zod32.z.enum(["top", "bottom"]);
-var pcb_route_hint = import_zod33.z.object({
-  x: distance,
-  y: distance,
-  via: import_zod33.z.boolean().optional(),
-  via_to_layer: layer_ref.optional()
-});
-var pcb_route_hints = import_zod33.z.array(pcb_route_hint);
-var route_hint_point = import_zod34.z.object({
-  x: distance,
-  y: distance,
-  via: import_zod34.z.boolean().optional(),
-  to_layer: layer_ref.optional(),
-  trace_width: distance.optional()
-});
-var expectTypesMatch = (shouldBe) => {
-};
-var pcb_component = import_zod35.z.object({
-  type: import_zod35.z.literal("pcb_component"),
-  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
-  source_component_id: import_zod35.z.string(),
-  center: point,
-  layer: layer_ref,
-  rotation,
-  width: length,
-  height: length
-}).describe("Defines a component on the PCB");
-expectTypesMatch(true);
-var pcb_hole_circle_or_square = import_zod36.z.object({
-  type: import_zod36.z.literal("pcb_hole"),
-  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  hole_shape: import_zod36.z.enum(["circle", "square"]),
-  hole_diameter: import_zod36.z.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 = import_zod36.z.object({
-  type: import_zod36.z.literal("pcb_hole"),
-  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  hole_shape: import_zod36.z.literal("oval"),
-  hole_width: import_zod36.z.number(),
-  hole_height: import_zod36.z.number(),
-  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 = import_zod37.z.object({
-  type: import_zod37.z.literal("pcb_plated_hole"),
-  shape: import_zod37.z.literal("circle"),
-  outer_diameter: import_zod37.z.number(),
-  hole_diameter: import_zod37.z.number(),
-  x: distance,
-  y: distance,
-  layers: import_zod37.z.array(layer_ref),
-  port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-  pcb_component_id: import_zod37.z.string().optional(),
-  pcb_port_id: import_zod37.z.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_plated_hole_oval = import_zod37.z.object({
-  type: import_zod37.z.literal("pcb_plated_hole"),
-  shape: import_zod37.z.enum(["oval", "pill"]),
-  outer_width: import_zod37.z.number(),
-  outer_height: import_zod37.z.number(),
-  hole_width: import_zod37.z.number(),
-  hole_height: import_zod37.z.number(),
-  x: distance,
-  y: distance,
-  layers: import_zod37.z.array(layer_ref),
-  port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-  pcb_component_id: import_zod37.z.string().optional(),
-  pcb_port_id: import_zod37.z.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_plated_hole = import_zod37.z.union([
-  pcb_plated_hole_circle,
-  pcb_plated_hole_oval
-]);
-expectTypesMatch(
-  true
-);
-expectTypesMatch(true);
-var pcb_port = import_zod38.z.object({
-  type: import_zod38.z.literal("pcb_port"),
-  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
-  source_port_id: import_zod38.z.string(),
-  pcb_component_id: import_zod38.z.string(),
-  x: distance,
-  y: distance,
-  layers: import_zod38.z.array(layer_ref)
-}).describe("Defines a port on the PCB");
-expectTypesMatch(true);
-var pcb_smtpad_circle = import_zod39.z.object({
-  type: import_zod39.z.literal("pcb_smtpad"),
-  shape: import_zod39.z.literal("circle"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  x: distance,
-  y: distance,
-  radius: import_zod39.z.number(),
-  layer: layer_ref,
-  port_hints: import_zod39.z.array(import_zod39.z.string()).optional(),
-  pcb_component_id: import_zod39.z.string().optional(),
-  pcb_port_id: import_zod39.z.string().optional()
-});
-var pcb_smtpad_rect = import_zod39.z.object({
-  type: import_zod39.z.literal("pcb_smtpad"),
-  shape: import_zod39.z.literal("rect"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  x: distance,
-  y: distance,
-  width: import_zod39.z.number(),
-  height: import_zod39.z.number(),
-  layer: layer_ref,
-  port_hints: import_zod39.z.array(import_zod39.z.string()).optional(),
-  pcb_component_id: import_zod39.z.string().optional(),
-  pcb_port_id: import_zod39.z.string().optional()
-});
-var pcb_smtpad = import_zod39.z.union([pcb_smtpad_circle, pcb_smtpad_rect]).describe("Defines an SMT pad on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_solder_paste_circle = import_zod40.z.object({
-  type: import_zod40.z.literal("pcb_solder_paste"),
-  shape: import_zod40.z.literal("circle"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  x: distance,
-  y: distance,
-  radius: import_zod40.z.number(),
-  layer: layer_ref,
-  pcb_component_id: import_zod40.z.string().optional(),
-  pcb_smtpad_id: import_zod40.z.string().optional()
-});
-var pcb_solder_paste_rect = import_zod40.z.object({
-  type: import_zod40.z.literal("pcb_solder_paste"),
-  shape: import_zod40.z.literal("rect"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  x: distance,
-  y: distance,
-  width: import_zod40.z.number(),
-  height: import_zod40.z.number(),
-  layer: layer_ref,
-  pcb_component_id: import_zod40.z.string().optional(),
-  pcb_smtpad_id: import_zod40.z.string().optional()
-});
-var pcb_solder_paste = import_zod40.z.union([pcb_solder_paste_circle, pcb_solder_paste_rect]).describe("Defines solderpaste on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_text = import_zod41.z.object({
-  type: import_zod41.z.literal("pcb_text"),
-  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
-  text: import_zod41.z.string(),
-  center: point,
-  layer: layer_ref,
-  width: length,
-  height: length,
-  lines: import_zod41.z.number(),
-  align: import_zod41.z.enum(["bottom-left"])
-}).describe("Defines text on the PCB");
-expectTypesMatch(true);
-var pcb_trace_route_point_wire = import_zod42.z.object({
-  route_type: import_zod42.z.literal("wire"),
-  x: distance,
-  y: distance,
-  width: distance,
-  start_pcb_port_id: import_zod42.z.string().optional(),
-  end_pcb_port_id: import_zod42.z.string().optional(),
-  layer: layer_ref
-});
-var pcb_trace_route_point_via = import_zod42.z.object({
-  route_type: import_zod42.z.literal("via"),
-  x: distance,
-  y: distance,
-  from_layer: import_zod42.z.string(),
-  to_layer: import_zod42.z.string()
-});
-var pcb_trace_route_point = import_zod42.z.union([
-  pcb_trace_route_point_wire,
-  pcb_trace_route_point_via
-]);
-var pcb_trace = import_zod42.z.object({
-  type: import_zod42.z.literal("pcb_trace"),
-  source_trace_id: import_zod42.z.string().optional(),
-  pcb_component_id: import_zod42.z.string().optional(),
-  pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
-  route_thickness_mode: import_zod42.z.enum(["constant", "interpolated"]).default("constant").optional(),
-  route_order_index: import_zod42.z.number().optional(),
-  should_round_corners: import_zod42.z.boolean().optional(),
-  route: import_zod42.z.array(
-    import_zod42.z.union([
-      import_zod42.z.object({
-        route_type: import_zod42.z.literal("wire"),
-        x: distance,
-        y: distance,
-        width: distance,
-        start_pcb_port_id: import_zod42.z.string().optional(),
-        end_pcb_port_id: import_zod42.z.string().optional(),
-        layer: layer_ref
-      }),
-      import_zod42.z.object({
-        route_type: import_zod42.z.literal("via"),
-        x: distance,
-        y: distance,
-        from_layer: import_zod42.z.string(),
-        to_layer: import_zod42.z.string()
-      })
-    ])
-  )
-}).describe("Defines a trace on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_trace_error = import_zod43.z.object({
-  type: import_zod43.z.literal("pcb_trace_error"),
-  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
-  error_type: import_zod43.z.literal("pcb_trace_error"),
-  message: import_zod43.z.string(),
-  center: point.optional(),
-  pcb_trace_id: import_zod43.z.string(),
-  source_trace_id: import_zod43.z.string(),
-  pcb_component_ids: import_zod43.z.array(import_zod43.z.string()),
-  pcb_port_ids: import_zod43.z.array(import_zod43.z.string())
-}).describe("Defines a trace error on the PCB");
-expectTypesMatch(true);
-var pcb_port_not_matched_error = import_zod44.z.object({
-  type: import_zod44.z.literal("pcb_port_not_matched_error"),
-  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
-  message: import_zod44.z.string(),
-  pcb_component_ids: import_zod44.z.array(import_zod44.z.string())
-}).describe("Defines a trace error on the PCB where a port is not matched");
-expectTypesMatch(true);
-var pcb_via = import_zod45.z.object({
-  type: import_zod45.z.literal("pcb_via"),
-  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
-  x: distance,
-  y: distance,
-  outer_diameter: distance.default("0.6mm"),
-  hole_diameter: distance.default("0.25mm"),
-  /** @deprecated */
-  from_layer: layer_ref.optional(),
-  /** @deprecated */
-  to_layer: layer_ref.optional(),
-  layers: import_zod45.z.array(layer_ref),
-  pcb_trace_id: import_zod45.z.string().optional()
-}).describe("Defines a via on the PCB");
-expectTypesMatch(true);
-var pcb_board = import_zod46.z.object({
-  type: import_zod46.z.literal("pcb_board"),
-  pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
-  width: length,
-  height: length,
-  center: point,
-  thickness: length.optional().default(1.4),
-  num_layers: import_zod46.z.number().optional().default(4),
-  outline: import_zod46.z.array(point).optional()
-}).describe("Defines the board outline of the PCB");
-expectTypesMatch(true);
-var pcb_placement_error = import_zod47.z.object({
-  type: import_zod47.z.literal("pcb_placement_error"),
-  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
-  message: import_zod47.z.string()
-}).describe("Defines a placement error on the PCB");
-expectTypesMatch(true);
-var pcb_trace_hint = import_zod48.z.object({
-  type: import_zod48.z.literal("pcb_trace_hint"),
-  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
-  pcb_port_id: import_zod48.z.string(),
-  pcb_component_id: import_zod48.z.string(),
-  route: import_zod48.z.array(route_hint_point)
-}).describe("A hint that can be used during generation of a PCB trace");
-expectTypesMatch(true);
-var pcb_silkscreen_line = import_zod49.z.object({
-  type: import_zod49.z.literal("pcb_silkscreen_line"),
-  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
-  pcb_component_id: import_zod49.z.string(),
-  stroke_width: distance.default("0.1mm"),
-  x1: distance,
-  y1: distance,
-  x2: distance,
-  y2: distance,
-  layer: visible_layer
-}).describe("Defines a silkscreen line on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_path = import_zod50.z.object({
-  type: import_zod50.z.literal("pcb_silkscreen_path"),
-  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
-  pcb_component_id: import_zod50.z.string(),
-  layer: visible_layer,
-  route: import_zod50.z.array(point),
-  stroke_width: length
-}).describe("Defines a silkscreen path on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_text = import_zod51.z.object({
-  type: import_zod51.z.literal("pcb_silkscreen_text"),
-  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
-  font: import_zod51.z.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance.default("0.2mm"),
-  pcb_component_id: import_zod51.z.string(),
-  text: import_zod51.z.string(),
-  layer: layer_ref,
-  is_mirrored: import_zod51.z.boolean().default(false).optional(),
-  anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod51.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
-}).describe("Defines silkscreen text on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_rect = import_zod52.z.object({
-  type: import_zod52.z.literal("pcb_silkscreen_rect"),
-  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
-  pcb_component_id: import_zod52.z.string(),
-  center: point,
-  width: length,
-  height: length,
-  layer: layer_ref
-}).describe("Defines a silkscreen rect on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_circle = import_zod53.z.object({
-  type: import_zod53.z.literal("pcb_silkscreen_circle"),
-  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
-    "pcb_silkscreen_circle"
-  ),
-  pcb_component_id: import_zod53.z.string(),
-  center: point,
-  radius: length,
-  layer: visible_layer
-}).describe("Defines a silkscreen circle on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_oval = import_zod54.z.object({
-  type: import_zod54.z.literal("pcb_silkscreen_oval"),
-  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
-  pcb_component_id: import_zod54.z.string(),
-  center: point,
-  radius_x: distance,
-  radius_y: distance,
-  layer: visible_layer
-}).describe("Defines a silkscreen oval on the PCB");
-expectTypesMatch(true);
-var pcb_fabrication_note_text = import_zod55.z.object({
-  type: import_zod55.z.literal("pcb_fabrication_note_text"),
-  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
-    "pcb_fabrication_note_text"
-  ),
-  font: import_zod55.z.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance.default("1mm"),
-  pcb_component_id: import_zod55.z.string(),
-  text: import_zod55.z.string(),
-  layer: visible_layer,
-  anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod55.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  color: import_zod55.z.string().optional()
-}).describe(
-  "Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators"
-);
-expectTypesMatch(true);
-var pcb_fabrication_note_path = import_zod56.z.object({
-  type: import_zod56.z.literal("pcb_fabrication_note_path"),
-  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
-    "pcb_fabrication_note_path"
-  ),
-  pcb_component_id: import_zod56.z.string(),
-  layer: layer_ref,
-  route: import_zod56.z.array(point),
-  stroke_width: length,
-  color: import_zod56.z.string().optional()
-}).describe(
-  "Defines a fabrication path on the PCB for fabricators or assemblers"
-);
-expectTypesMatch(true);
-var pcb_keepout = import_zod57.z.object({
-  type: import_zod57.z.literal("pcb_keepout"),
-  shape: import_zod57.z.literal("rect"),
-  center: point,
-  width: distance,
-  height: distance,
-  pcb_keepout_id: import_zod57.z.string(),
-  layers: import_zod57.z.array(import_zod57.z.string()),
-  // Specify layers where the keepout applies
-  description: import_zod57.z.string().optional()
-  // Optional description of the keepout
-}).or(
-  import_zod57.z.object({
-    type: import_zod57.z.literal("pcb_keepout"),
-    shape: import_zod57.z.literal("circle"),
-    center: point,
-    radius: distance,
-    pcb_keepout_id: import_zod57.z.string(),
-    layers: import_zod57.z.array(import_zod57.z.string()),
-    // Specify layers where the keepout applies
-    description: import_zod57.z.string().optional()
-    // Optional description of the keepout
-  })
-);
-var cad_component = import_zod58.z.object({
-  type: import_zod58.z.literal("cad_component"),
-  cad_component_id: import_zod58.z.string(),
-  pcb_component_id: import_zod58.z.string(),
-  source_component_id: import_zod58.z.string(),
-  position: point3,
-  rotation: point3.optional(),
-  size: point3.optional(),
-  layer: layer_ref.optional(),
-  // These are all ways to generate/load the 3d model
-  footprinter_string: import_zod58.z.string().optional(),
-  model_obj_url: import_zod58.z.string().optional(),
-  model_stl_url: import_zod58.z.string().optional(),
-  model_3mf_url: import_zod58.z.string().optional(),
-  model_jscad: import_zod58.z.any().optional()
-}).describe("Defines a component on the PCB");
-var any_circuit_element = import_zod59.z.union([
-  source_trace,
-  source_port,
-  any_source_component,
-  source_led,
-  source_net,
-  source_group,
-  source_simple_bug,
-  source_simple_chip,
-  source_simple_capacitor,
-  source_simple_diode,
-  source_simple_resistor,
-  source_simple_power_source,
-  pcb_component,
-  pcb_hole,
-  pcb_plated_hole,
-  pcb_keepout,
-  pcb_port,
-  pcb_text,
-  pcb_trace,
-  pcb_via,
-  pcb_smtpad,
-  pcb_solder_paste,
-  pcb_board,
-  pcb_trace_hint,
-  pcb_silkscreen_line,
-  pcb_silkscreen_path,
-  pcb_silkscreen_text,
-  pcb_silkscreen_rect,
-  pcb_silkscreen_circle,
-  pcb_silkscreen_oval,
-  pcb_trace_error,
-  pcb_placement_error,
-  pcb_port_not_matched_error,
-  pcb_fabrication_note_path,
-  pcb_fabrication_note_text,
-  schematic_box,
-  schematic_text,
-  schematic_line,
-  schematic_component,
-  schematic_port,
-  schematic_trace,
-  schematic_path,
-  schematic_error,
-  schematic_net_label,
-  cad_component
-]);
-var any_soup_element = any_circuit_element;
-
-// lib/math/arc-utils.ts
-function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag, sweepFlag) {
-  const start = { x: startX, y: startY };
-  const end = { x: endX, y: endY };
-  const midX = (startX + endX) / 2;
-  const midY = (startY + endY) / 2;
-  const dx = endX - startX;
-  const dy = endY - startY;
-  const distance2 = Math.sqrt(dx * dx + dy * dy);
-  if (distance2 === 0 || radius < distance2 / 2) {
-    return [start, end];
-  }
-  const h = Math.sqrt(radius * radius - distance2 * distance2 / 4);
-  const angle = Math.atan2(dy, dx);
-  const centerX = midX + h * Math.sin(angle) * (sweepFlag ? 1 : -1);
-  const centerY = midY - h * Math.cos(angle) * (sweepFlag ? 1 : -1);
-  const startAngle = Math.atan2(startY - centerY, startX - centerX);
-  let endAngle = Math.atan2(endY - centerY, endX - centerX);
-  if (!sweepFlag && endAngle > startAngle) {
-    endAngle -= 2 * Math.PI;
-  } else if (sweepFlag && endAngle < startAngle) {
-    endAngle += 2 * Math.PI;
-  }
-  if (!largeArcFlag && Math.abs(endAngle - startAngle) > Math.PI || largeArcFlag && Math.abs(endAngle - startAngle) < Math.PI) {
-    if (endAngle > startAngle) {
-      endAngle -= 2 * Math.PI;
-    } else {
-      endAngle += 2 * Math.PI;
-    }
-  }
-  const numPoints = Math.max(
-    2,
-    Math.ceil(Math.abs(endAngle - startAngle) * radius)
-  );
-  const path2 = [];
-  for (let i = 0; i <= numPoints; i++) {
-    const t = i / numPoints;
-    const angle2 = startAngle + t * (endAngle - startAngle);
-    const x = centerX + radius * Math.cos(angle2);
-    const y = centerY + radius * Math.sin(angle2);
-    path2.push({ x, y });
-  }
-  return path2;
-}
-
-// node_modules/@tscircuit/soup-util/dist/index.js
-var import_transformation_matrix = require("transformation-matrix");
-var su = (soup, options = {}) => {
-  let internalStore = soup._internal_store;
-  if (!internalStore) {
-    internalStore = {
-      counts: {}
-    };
-    soup._internal_store = internalStore;
-    for (const elm of soup) {
-      const type = elm.type;
-      const idVal = elm[`${type}_id`];
-      if (!idVal)
-        continue;
-      const idNum = Number.parseInt(idVal.split("_").pop());
-      if (!Number.isNaN(idNum)) {
-        internalStore.counts[type] = Math.max(
-          internalStore.counts[type] ?? 0,
-          idNum
-        );
-      }
-    }
-  }
-  const su22 = new Proxy(
-    {},
-    {
-      get: (proxy_target, component_type) => {
-        if (component_type === "toArray") {
-          return () => soup;
-        }
-        return {
-          get: (id) => soup.find(
-            (e) => e.type === component_type && e[`${component_type}_id`] === id
-          ),
-          getUsing: (using) => {
-            const keys = Object.keys(using);
-            if (keys.length !== 1) {
-              throw new Error(
-                "getUsing requires exactly one key, e.g. { pcb_component_id }"
-              );
-            }
-            const join_key = keys[0];
-            const join_type = join_key.replace("_id", "");
-            const joiner = soup.find(
-              (e) => e.type === join_type && e[join_key] === using[join_key]
-            );
-            if (!joiner)
-              return null;
-            return soup.find(
-              (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
-            );
-          },
-          getWhere: (where) => {
-            const keys = Object.keys(where);
-            return soup.find(
-              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
-            );
-          },
-          list: (where) => {
-            const keys = !where ? [] : Object.keys(where);
-            return soup.filter(
-              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
-            );
-          },
-          insert: (elm) => {
-            internalStore.counts[component_type] ??= -1;
-            internalStore.counts[component_type]++;
-            const index = internalStore.counts[component_type];
-            const newElm = {
-              type: component_type,
-              [`${component_type}_id`]: `${component_type}_${index}`,
-              ...elm
-            };
-            if (options.validateInserts) {
-              const parser = dist_exports[component_type] ?? any_soup_element;
-              parser.parse(newElm);
-            }
-            soup.push(newElm);
-            return newElm;
-          },
-          delete: (id) => {
-            const elm = soup.find(
-              (e) => e[`${component_type}_id`] === id
-            );
-            if (!elm)
-              return;
-            soup.splice(soup.indexOf(elm), 1);
-          },
-          update: (id, newProps) => {
-            const elm = soup.find(
-              (e) => e[`${component_type}_id`] === id
-            );
-            if (!elm)
-              return;
-            Object.assign(elm, newProps);
-            return elm;
-          },
-          select: (selector) => {
-            if (component_type === "source_component") {
-              return soup.find(
-                (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
-              );
-            } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
-              const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
-              const source_component = soup.find(
-                (e) => e.type === "source_component" && e.name === component_name
-              );
-              if (!source_component)
-                return null;
-              const source_port2 = soup.find(
-                (e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector))
-              );
-              if (!source_port2)
-                return null;
-              if (component_type === "source_port")
-                return source_port2;
-              if (component_type === "pcb_port") {
-                return soup.find(
-                  (e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id
-                );
-              } else if (component_type === "schematic_port") {
-                return soup.find(
-                  (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
-                );
-              }
-            }
-          }
-        };
-      }
-    }
-  );
-  return su22;
-};
-su.unparsed = su;
-var su_default = su;
-var transformPCBElement = (elm, matrix) => {
-  if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-    const { x, y } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x, y: elm.y });
-    elm.x = x;
-    elm.y = y;
-  } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
-  } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
-    elm.anchor_position = (0, import_transformation_matrix.applyToPoint)(matrix, elm.anchor_position);
-  } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
-    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
-  } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
-    elm.route = elm.route.map((rp) => {
-      const tp = (0, import_transformation_matrix.applyToPoint)(matrix, rp);
-      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 = (0, import_transformation_matrix.applyToPoint)(matrix, p1);
-    const p2t = (0, import_transformation_matrix.applyToPoint)(matrix, p2);
-    elm.x1 = p1t.x;
-    elm.y1 = p1t.y;
-    elm.x2 = p2t.x;
-    elm.y2 = p2t.y;
-  } else if (elm.type === "cad_component") {
-    const newPos = (0, import_transformation_matrix.applyToPoint)(matrix, {
-      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 = (0, import_transformation_matrix.decomposeTSR)(matrix);
-  const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
-  let transformedElms = elms.map((elm) => transformPCBElement(elm, matrix));
-  if (flipPadWidthHeight) {
-    transformedElms = transformedElms.map((elm) => {
-      if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
-        ;
-        [elm.width, elm.height] = [elm.height, elm.width];
-      }
-      return elm;
-    });
-  }
-  return transformedElms;
-};
-
-// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_transformation_matrix2 = require("transformation-matrix");
-
-// lib/compute-center-offset.ts
-var import_mm = require("@tscircuit/mm");
-var computeCenterOffset = (easyeda) => {
-  const pads = easyeda.packageDetail.dataStr.shape.filter(
-    (shape) => shape.type === "PAD"
-  );
-  const minX = Math.min(...pads.map((pad) => (0, import_mm.mm)(pad.center.x)));
-  const maxX = Math.max(...pads.map((pad) => (0, import_mm.mm)(pad.center.x)));
-  const minY = Math.min(...pads.map((pad) => (0, import_mm.mm)(pad.center.y)));
-  const maxY = Math.max(...pads.map((pad) => (0, import_mm.mm)(pad.center.y)));
-  const centerX = (minX + maxX) / 2;
-  const centerY = (minY + maxY) / 2;
-  return {
-    x: centerX,
-    y: centerY
-  };
-};
-
-// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-var import_mm2 = require("@tscircuit/mm");
-var handleSilkscreenPath = (track, index) => {
-  return pcb_silkscreen_path.parse({
-    type: "pcb_silkscreen_path",
-    pcb_silkscreen_path_id: `pcb_silkscreen_path_${index + 1}`,
-    pcb_component_id: "pcb_component_1",
-    layer: "top",
-    // Assuming all silkscreen is on top layer
-    route: track.points.map((point2) => ({ x: point2.x, y: point2.y })),
-    stroke_width: track.width
-  });
-};
-var handleSilkscreenArc = (arc, index) => {
-  const arcPath = generateArcFromSweep(
-    arc.start.x,
-    arc.start.y,
-    arc.end.x,
-    arc.end.y,
-    arc.radiusX,
-    arc.largeArc,
-    arc.sweepDirection === "CW"
-  );
-  return pcb_silkscreen_path.parse({
-    type: "pcb_silkscreen_path",
-    pcb_silkscreen_path_id: `pcb_silkscreen_arc_${index + 1}`,
-    pcb_component_id: "pcb_component_1",
-    layer: "top",
-    // Assuming all silkscreen is on top layer
-    route: arcPath,
-    stroke_width: arc.width
-  });
-};
-var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
-  const soupElements = [];
-  const centerOffset = computeCenterOffset(easyEdaJson);
-  const source_component = any_source_component.parse({
-    type: "source_component",
-    source_component_id: "source_component_1",
-    name: "U1",
-    ftype: "simple_bug"
-  });
-  const pcb_component2 = pcb_component.parse({
-    type: "pcb_component",
-    pcb_component_id: "pcb_component_1",
-    source_component_id: "source_component_1",
-    name: "U1",
-    ftype: "simple_bug",
-    width: 0,
-    // TODO compute width
-    height: 0,
-    // TODO compute height
-    rotation: 0,
-    center: { x: centerOffset.x, y: centerOffset.y },
-    layer: "top"
-  });
-  soupElements.push(source_component, pcb_component2);
-  easyEdaJson.packageDetail.dataStr.shape.filter((shape) => shape.type === "PAD").forEach((pad, index) => {
-    const portNumber = pad.number.toString();
-    soupElements.push({
-      type: "source_port",
-      source_port_id: `source_port_${index + 1}`,
-      source_component_id: "source_component_1",
-      name: portNumber
-    });
-    if (pad.holeRadius !== void 0 && (0, import_mm2.mm)(pad.holeRadius) !== 0) {
-      soupElements.push(
-        pcb_plated_hole.parse({
-          type: "pcb_plated_hole",
-          pcb_plated_hole_id: `pcb_plated_hole_${index + 1}`,
-          shape: "circle",
-          x: (0, import_mm2.mm)(pad.center.x),
-          y: (0, import_mm2.mm)(pad.center.y),
-          hole_diameter: (0, import_mm2.mm)(pad.holeRadius) * 2,
-          outer_diameter: (0, import_mm2.mm)(pad.width),
-          radius: (0, import_mm2.mm)(pad.holeRadius),
-          port_hints: [portNumber],
-          pcb_component_id: "pcb_component_1",
-          pcb_port_id: `pcb_port_${index + 1}`,
-          layers: ["top"]
-        })
-      );
-    } else {
-      let soupShape;
-      if (pad.shape === "RECT") {
-        soupShape = "rect";
-      } else if (pad.shape === "ELLIPSE") {
-        soupShape = "rect";
-      } else if (pad.shape === "OVAL") {
-        soupShape = "rect";
-      }
-      if (!soupShape) {
-        throw new Error(`unknown pad.shape: "${pad.shape}"`);
-      }
-      soupElements.push(
-        pcb_smtpad.parse({
-          type: "pcb_smtpad",
-          pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
-          shape: soupShape,
-          x: (0, import_mm2.mm)(pad.center.x),
-          y: (0, import_mm2.mm)(pad.center.y),
-          ...soupShape === "rect" ? { width: (0, import_mm2.mm)(pad.width), height: (0, import_mm2.mm)(pad.height) } : { radius: Math.min((0, import_mm2.mm)(pad.width), (0, import_mm2.mm)(pad.height)) / 2 },
-          layer: "top",
-          port_hints: [portNumber],
-          pcb_component_id: "pcb_component_1",
-          pcb_port_id: `pcb_port_${index + 1}`
-        })
-      );
-    }
-  });
-  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
-    if (shape.type === "TRACK") {
-      soupElements.push(handleSilkscreenPath(shape, index));
-    } else if (shape.type === "ARC") {
-      soupElements.push(handleSilkscreenArc(shape, index));
-    }
-  });
-  transformPCBElements(soupElements, (0, import_transformation_matrix2.scale)(1, -1));
-  const svgNode = easyEdaJson.packageDetail.dataStr.shape.find(
-    (a) => Boolean(a.type === "SVGNODE" && a.svgData.attrs?.uuid)
-  );
-  const objFileUuid = svgNode?.svgData?.attrs?.uuid;
-  const objFileUrl = objFileUuid ? useModelCdn ? `https://modelcdn.tscircuit.com/easyeda_models/download?uuid=${objFileUuid}&pn=${easyEdaJson.lcsc.number}` : `https://modules.easyeda.com/3dmodel/${objFileUuid}` : void 0;
-  if (objFileUrl !== void 0) {
-    const [rx, ry, rz] = (svgNode?.svgData.attrs?.c_rotation ?? "0,0,0").split(",").map(Number);
-    soupElements.push(
-      cad_component.parse({
-        type: "cad_component",
-        cad_component_id: "cad_component_1",
-        source_component_id: "source_component_1",
-        pcb_component_id: "pcb_component_1",
-        position: { x: 0, y: 0, z: 0 },
-        rotation: { x: rx, y: ry, z: rz },
-        model_obj_url: objFileUrl
-      })
-    );
-  }
-  if (shouldRecenter) {
-    transformPCBElements(
-      soupElements,
-      (0, import_transformation_matrix2.translate)(-centerOffset.x, centerOffset.y)
-    );
-  }
-  return soupElements;
-};
-var convertEasyEdaJsonToTscircuitSoupJson = convertEasyEdaJsonToCircuitJson;
-
-// cli/main.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-
-// package.json
-var package_default = {
-  name: "easyeda",
-  type: "module",
-  version: "0.0.30",
-  files: [
-    "dist"
-  ],
-  repository: {
-    type: "git",
-    url: "https://github.com/tscircuit/easyeda-converter"
-  },
-  scripts: {
-    test: "bun test",
-    build: "tsup lib/index.ts cli/main.ts --dts --sourcemap",
-    aider: "aider",
-    "format:check": "biome format .",
-    format: "biome format . --write"
-  },
-  main: "./dist/lib/index.cjs",
-  bin: {
-    "easyeda-converter": "./dist/cli/main.cjs",
-    easyeda: "./dist/cli/main.cjs"
-  },
-  devDependencies: {
-    "@biomejs/biome": "^1.8.3",
-    "@tscircuit/log-soup": "1.0.2",
-    "@tscircuit/props": "^0.0.68",
-    "@tscircuit/soup-util": "^0.0.31",
-    "@types/bun": "latest",
-    "circuit-json": "^0.0.83",
-    tsup: "^8.1.0"
-  },
-  peerDependencies: {
-    typescript: "^5.5.2"
-  },
-  dependencies: {
-    "@tscircuit/mm": "^0.0.8",
-    commander: "^12.1.0",
-    "transformation-matrix": "^2.16.1",
-    zod: "^3.23.8"
-  }
-};
-
-// lib/schemas/easy-eda-json-schema.ts
-var import_zod62 = require("zod");
-
-// lib/schemas/single-letter-shape-schema.ts
-var import_zod61 = require("zod");
-var PointSchema2 = import_zod61.z.object({
-  x: import_zod61.z.number(),
-  y: import_zod61.z.number()
-});
-var RectangleShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("RECTANGLE"),
-  position: PointSchema2,
-  width: import_zod61.z.number(),
-  height: import_zod61.z.number(),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
-});
-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 = import_zod61.z.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
-var EllipseShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("ELLIPSE"),
-  center: PointSchema2,
-  radiusX: import_zod61.z.number(),
-  radiusY: import_zod61.z.number(),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
-});
-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 = import_zod61.z.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
-var PinShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("PIN"),
-  visibility: import_zod61.z.enum(["show", "hide"]),
-  pinNumber: import_zod61.z.number(),
-  x: import_zod61.z.number(),
-  y: import_zod61.z.number(),
-  rotation: import_zod61.z.number(),
-  id: import_zod61.z.string(),
-  label: import_zod61.z.string(),
-  labelColor: import_zod61.z.string(),
-  path: import_zod61.z.string(),
-  arrow: import_zod61.z.string()
-});
-var parsePin = (pinString) => {
-  const parts = pinString.split("~");
-  const [, visibility, , pinNumber, x, y, rotation2, id] = parts;
-  const nameMatch = pinString.match(/~(\w+)~start~/);
-  const label = nameMatch ? nameMatch[1] : "";
-  const colorMatch = pinString.match(/#[0-9A-F]{6}/);
-  const labelColor = colorMatch ? colorMatch[0] : "";
-  const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path2 = pathMatch ? pathMatch[1] : "";
-  const arrowMatch = pinString.match(/\^\^0~(.+)$/);
-  const arrow = arrowMatch ? arrowMatch[1] : "";
-  return {
-    type: "PIN",
-    visibility,
-    id,
-    pinNumber: parseInt(pinNumber),
-    x: parseFloat(x),
-    y: parseFloat(y),
-    rotation: parseFloat(rotation2),
-    label,
-    labelColor,
-    path: path2,
-    arrow
-  };
-};
-var PinShapeSchema = import_zod61.z.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
-var PolylineShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("POLYLINE"),
-  points: import_zod61.z.array(PointSchema2),
-  color: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  id: import_zod61.z.string()
-});
-var 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 = import_zod61.z.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
-var PolygonShapeOutputSchema = import_zod61.z.object({
-  type: import_zod61.z.literal("POLYGON"),
-  points: import_zod61.z.array(PointSchema2),
-  fillColor: import_zod61.z.string(),
-  lineWidth: import_zod61.z.number(),
-  lineColor: import_zod61.z.string(),
-  id: import_zod61.z.string()
-});
-var 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 = import_zod61.z.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
-var SingleLetterShapeSchema = import_zod61.z.string().transform((x) => {
-  if (x.startsWith("R~")) return RectangleShapeSchema.parse(x);
-  if (x.startsWith("E~")) return EllipseShapeSchema.parse(x);
-  if (x.startsWith("P~")) return PinShapeSchema.parse(x);
-  if (x.startsWith("PL~")) return PolylineShapeSchema.parse(x);
-  if (x.startsWith("PG~")) return PolygonShapeSchema.parse(x);
-  throw new Error(`Invalid shape type: ${x}`);
-}).pipe(
-  import_zod61.z.union([
-    RectangleShapeOutputSchema,
-    EllipseShapeOutputSchema,
-    PinShapeOutputSchema,
-    PolylineShapeOutputSchema,
-    PolygonShapeOutputSchema
-  ])
-);
-
-// lib/schemas/easy-eda-json-schema.ts
-var maybeNumber = import_zod62.z.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(import_zod62.z.number().nullable().optional());
-var SzlcscSchema = import_zod62.z.object({
-  id: import_zod62.z.number(),
-  number: import_zod62.z.string(),
-  step: import_zod62.z.number().optional(),
-  min: import_zod62.z.number().optional(),
-  price: import_zod62.z.number().optional(),
-  stock: import_zod62.z.number().optional(),
-  url: import_zod62.z.string().url().optional(),
-  image: import_zod62.z.string().optional().optional()
-});
-var LcscSchema = import_zod62.z.object({
-  id: import_zod62.z.number(),
-  number: import_zod62.z.string(),
-  step: import_zod62.z.number().optional(),
-  min: import_zod62.z.number().optional(),
-  price: import_zod62.z.number().optional(),
-  stock: import_zod62.z.number().optional(),
-  url: import_zod62.z.string().url().optional()
-});
-var OwnerSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  username: import_zod62.z.string(),
-  nickname: import_zod62.z.string(),
-  avatar: import_zod62.z.string()
-});
-var HeadSchema = import_zod62.z.object({
-  docType: import_zod62.z.string(),
-  editorVersion: import_zod62.z.string(),
-  c_para: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.string()),
-  x: import_zod62.z.number(),
-  y: import_zod62.z.number(),
-  puuid: import_zod62.z.string().optional(),
-  uuid: import_zod62.z.string(),
-  utime: import_zod62.z.number(),
-  importFlag: import_zod62.z.number(),
-  c_spiceCmd: import_zod62.z.any().optional(),
-  hasIdFlag: import_zod62.z.boolean()
-});
-var BBoxSchema = import_zod62.z.object({
-  x: import_zod62.z.number(),
-  y: import_zod62.z.number(),
-  width: import_zod62.z.number(),
-  height: import_zod62.z.number()
-});
-var LayerItemSchema = import_zod62.z.object({
-  name: import_zod62.z.string(),
-  color: import_zod62.z.string(),
-  visible: import_zod62.z.boolean(),
-  active: import_zod62.z.boolean(),
-  config: import_zod62.z.boolean(),
-  transparency: import_zod62.z.boolean()
-});
-var ObjectItemSchema = import_zod62.z.object({
-  name: import_zod62.z.string(),
-  visible: import_zod62.z.boolean(),
-  locked: import_zod62.z.boolean()
-});
-var DataStrSchema = import_zod62.z.object({
-  head: HeadSchema,
-  canvas: import_zod62.z.string(),
-  shape: import_zod62.z.array(SingleLetterShapeSchema),
-  BBox: BBoxSchema,
-  colors: import_zod62.z.array(import_zod62.z.unknown())
-});
-var PackageDetailDataStrSchema = import_zod62.z.object({
-  head: HeadSchema,
-  canvas: import_zod62.z.string(),
-  shape: import_zod62.z.array(import_zod62.z.string()).transform(
-    (shapes) => shapes.map((shape) => {
-      const [type, ...data] = shape.split("~");
-      return ShapeItemSchema.parse({ type, data: data.join("~") });
-    })
-  ).pipe(import_zod62.z.array(PackageDetailShapeSchema)),
-  layers: import_zod62.z.array(import_zod62.z.string()).transform(
-    (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: import_zod62.z.array(import_zod62.z.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: import_zod62.z.array(import_zod62.z.unknown()).optional()
-});
-var PackageDetailSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  title: import_zod62.z.string(),
-  docType: import_zod62.z.number(),
-  updateTime: import_zod62.z.number(),
-  owner: OwnerSchema,
-  datastrid: import_zod62.z.string(),
-  writable: import_zod62.z.boolean(),
-  dataStr: PackageDetailDataStrSchema
-});
-var EasyEdaJsonSchema = import_zod62.z.object({
-  uuid: import_zod62.z.string(),
-  title: import_zod62.z.string(),
-  description: import_zod62.z.string(),
-  docType: import_zod62.z.number(),
-  type: import_zod62.z.number(),
-  szlcsc: SzlcscSchema,
-  lcsc: LcscSchema,
-  owner: OwnerSchema,
-  tags: import_zod62.z.array(import_zod62.z.string()),
-  updateTime: import_zod62.z.number(),
-  updated_at: import_zod62.z.string(),
-  dataStr: DataStrSchema,
-  verify: import_zod62.z.boolean(),
-  SMT: import_zod62.z.boolean().optional(),
-  datastrid: import_zod62.z.string(),
-  jlcOnSale: import_zod62.z.number().optional(),
-  writable: import_zod62.z.boolean(),
-  isFavorite: import_zod62.z.boolean(),
-  packageDetail: PackageDetailSchema
-});
-
-// lib/generate-footprint-tsx.ts
-var import_zod63 = require("zod");
-var import_mm3 = require("@tscircuit/mm");
-var generateFootprintTsx = (easyEdaJson) => {
-  const pads = easyEdaJson.packageDetail.dataStr.shape.filter(
-    (shape) => shape.type === "PAD"
-  );
-  const centerOffset = computeCenterOffset(easyEdaJson);
-  const centerX = centerOffset.x;
-  const centerY = centerOffset.y;
-  const footprintElements = pads.map((pad) => {
-    const { center, width, height, holeRadius, number } = pad;
-    const isPlatedHole = holeRadius !== void 0 && (0, import_mm3.mm)(holeRadius) > 0;
-    const normalizedX = (0, import_mm3.mm)(center.x) - centerX;
-    const normalizedY = (0, import_mm3.mm)(center.y) - centerY;
-    if (isPlatedHole) {
-      return `
-        <platedhole
-          pcbX="${normalizedX.toFixed(2)}mm"
-          pcbY="${normalizedY.toFixed(2)}mm"
-          hole_diameter="${(0, import_mm3.mm)(holeRadius) * 2}mm"
-          outer_diameter="${(0, import_mm3.mm)(width)}mm"
-          portHints={["${number}"]}
-        />`.replace(/\n/, "");
-    } else {
-      return `
-        <smtpad
-          pcbX="${normalizedX.toFixed(2)}mm"
-          pcbY="${normalizedY.toFixed(2)}mm"
-          width="${(0, import_mm3.mm)(width)}mm"
-          height="${(0, import_mm3.mm)(height)}mm"
-          shape="rect"
-          portHints={["${number}"]}
-        />`.replace(/\n/, "");
-    }
-  });
-  return `
-      <footprint>
-        ${footprintElements.join("\n")}
-      </footprint>
-  `.trim();
-};
-
-// lib/convert-to-typescript-component/soup-typescript-component-template.ts
-var soupTypescriptComponentTemplate = ({
-  pinLabels,
-  componentName,
-  schPinArrangement,
-  objUrl,
-  easyEdaJson
-}) => {
-  const footprintTsx = generateFootprintTsx(easyEdaJson);
-  return `
-import { createUseComponent } from "tscircuit"
-import type { CommonLayoutProps } from "@tscircuit/props"
-
-const pinLabels = ${JSON.stringify(pinLabels, null, "  ")} as const
-const pinNames = Object.values(pinLabels)
-
-interface Props extends CommonLayoutProps {
-  name: string
-}
-
-export const ${componentName} = (props: Props) => {
-  return (
-    <bug
-      {...props}
-      footprint={${footprintTsx}}
-      ${objUrl ? `cadModel={{
-        objUrl: "${objUrl}"
-      }}` : ""}
-      pinLabels={pinLabels}
-      schPinSpacing={0.75}
-      schPortArrangement={${JSON.stringify(schPinArrangement, null, "  ")}}
-    />
-  )
-}
-
-export const use${componentName} = createUseComponent(${componentName}, pinNames)
-
-`.trim();
-};
-
-// lib/utils/normalize-manufacturer-part-number.ts
-function normalizeManufacturerPartNumber(partNumber) {
-  let normalized = partNumber.replace(/[-]/g, "_").replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^\d/.test(normalized)) {
-    normalized = "A_" + normalized;
-  }
-  return normalized;
-}
-
-// lib/convert-to-typescript-component/index.tsx
-var convertRawEasyEdaToTs = async (rawEasy) => {
-  const easyeda = EasyEdaJsonSchema.parse(rawEasy);
-  const soup = convertEasyEdaJsonToTscircuitSoupJson(easyeda, {
-    useModelCdn: true
-  });
-  const result = await convertToTypescriptComponent({
-    easyeda,
-    soup
-  });
-  return result;
-};
-var convertToTypescriptComponent = async ({
-  soup,
-  easyeda: easyEdaJson
-}) => {
-  const rawPn = easyEdaJson.dataStr.head.c_para["Manufacturer Part"];
-  const pn = normalizeManufacturerPartNumber(rawPn);
-  const [cad_component2] = su_default(soup).cad_component.list();
-  const pinLabels = {};
-  easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN").forEach((pin) => {
-    const isPinLabelNumeric = /^\d+$/.test(pin.label);
-    const label = isPinLabelNumeric ? `pin${pin.label}` : pin.label;
-    pinLabels[pin.pinNumber.toString()] = label;
-  });
-  const pins = easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN");
-  const leftPins = pins.filter((pin) => pin.rotation === 180);
-  const rightPins = pins.filter((pin) => pin.rotation === 0);
-  const schPinArrangement = {
-    leftSide: {
-      direction: "top-to-bottom",
-      pins: leftPins.map((pin) => pin.pinNumber)
-    },
-    rightSide: {
-      direction: "bottom-to-top",
-      pins: rightPins.map((pin) => pin.pinNumber).reverse()
-    }
-  };
-  let modelObjUrl;
-  if (cad_component2.model_obj_url) {
-    const isValidUrl = await checkModelObjUrlValidity(
-      cad_component2.model_obj_url
-    );
-    if (isValidUrl) {
-      modelObjUrl = cad_component2.model_obj_url;
-    }
-  }
-  return soupTypescriptComponentTemplate({
-    componentName: pn,
-    pinLabels,
-    schPinArrangement,
-    objUrl: modelObjUrl,
-    easyEdaJson
-  });
-};
-var checkModelObjUrlValidity = async (url) => {
-  try {
-    const response = await fetch(url, { method: "HEAD" });
-    return response.status === 200;
-  } catch (error) {
-    console.error(`Error checking model object URL ${url}:`, error);
-    return false;
-  }
-};
-
-// lib/convert-easyeda-json-to-various-formats.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var convertEasyEdaJsonToVariousFormats = async ({
-  jlcpcbPartNumberOrFilepath,
-  outputFilename,
-  formatType
-}) => {
-  let rawEasyEdaJson;
-  if (jlcpcbPartNumberOrFilepath.includes(".") || jlcpcbPartNumberOrFilepath.includes("/")) {
-    rawEasyEdaJson = JSON.parse(
-      await import_promises.default.readFile(jlcpcbPartNumberOrFilepath, "utf-8")
-    );
-  } else {
-    rawEasyEdaJson = await fetchEasyEDAComponent(jlcpcbPartNumberOrFilepath);
-  }
-  const tsxExtension = "tsx";
-  if (formatType === "ts") formatType = tsxExtension;
-  if (!outputFilename && formatType) {
-    let filename = path.basename(jlcpcbPartNumberOrFilepath).split(".")[0];
-    if (formatType === tsxExtension) {
-      const {
-        dataStr: {
-          head: {
-            c_para: { "Manufacturer Part": manufacturerPartNumber }
-          }
-        }
-      } = rawEasyEdaJson;
-      filename = normalizeManufacturerPartNumber(manufacturerPartNumber);
-    }
-    outputFilename = `${filename}.${formatType}`;
-  }
-  if (!outputFilename) {
-    console.log("specify --output file (-o) or --type (-t)");
-    process.exit(1);
-  }
-  if (outputFilename.endsWith(".raweasy.json")) {
-    await import_promises.default.writeFile(outputFilename, JSON.stringify(rawEasyEdaJson, null, 2));
-    console.log(`Saved raw EasyEDA JSON: ${outputFilename}`);
-    return;
-  }
-  try {
-    const betterEasy = EasyEdaJsonSchema.parse(rawEasyEdaJson);
-    const tscircuitSoup = convertEasyEdaJsonToTscircuitSoupJson(betterEasy);
-    if (outputFilename.endsWith(".soup.json")) {
-      await import_promises.default.writeFile(outputFilename, JSON.stringify(tscircuitSoup, null, 2));
-      console.log(`Converted to tscircuit soup JSON: ${outputFilename}`);
-    } else if (outputFilename.endsWith(".kicad_mod")) {
-      console.log("Conversion to KiCad footprint not yet implemented");
-    } else if (outputFilename.endsWith(".bettereasy.json")) {
-      await import_promises.default.writeFile(outputFilename, JSON.stringify(betterEasy, null, 2));
-      console.log(`Saved better EasyEDA JSON: ${outputFilename}`);
-    } else if (outputFilename.endsWith(".tsx") || outputFilename.endsWith(".ts")) {
-      const tsComp = await convertRawEasyEdaToTs(rawEasyEdaJson);
-      await import_promises.default.writeFile(outputFilename, tsComp);
-      console.log(`Saved TypeScript component: ${outputFilename}`);
-    } else {
-      console.error("Unsupported output format");
-    }
-  } catch (error) {
-    console.error("Error:", error.message);
-  }
-};
-
-// cli/main.ts
-var program = new import_commander.Command();
-program.name("easyeda-converter").description("Convert EasyEDA JSON PCB footprints into tscircuit json soup").version(package_default.version);
-program.command("convert").description("Convert EasyEDA JSON to various formats").option("-i, --input <jlcpcbPartNumber>", "JLCPCB part number").option("-o, --output <filename>", "Output filename").option(
-  "-t, --type <type>",
-  "Output type: soup.json, kicad_mod, raweasy.json, bettereasy.json, tsx"
-).action(async (options) => {
-  await convertEasyEdaJsonToVariousFormats({
-    jlcpcbPartNumberOrFilepath: options.input,
-    outputFilename: options.output,
-    formatType: options.type
-  });
-});
-program.command("download").description("Download JSON for footprint").requiredOption("-i, --input <jlcpcbPartNumber>", "JLCPCB part number").option("-o, --output <filename>", "Output filename").action(async (options) => {
-  if (!options.output) {
-    options.output = `${options.input}.raweasy.json`;
-  }
-  try {
-    const easyEdaJsonRes = await fetchEasyEDAComponent(options.input);
-    await import_promises2.default.writeFile(
-      options.output,
-      JSON.stringify(easyEdaJsonRes, null, 2)
-    );
-    console.log(`Downloaded JSON footprint: ${options.output}`);
-  } catch (error) {
-    console.error("Error:", error.message);
-  }
-});
-program.parse(process.argv);
-//# sourceMappingURL=main.cjs.map