easyeda 0.0.198 → 0.0.199

package/dist/chunk-E6OHT5YV.js

@@ -1,4253 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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,
-  ninePointAnchor: () => ninePointAnchor,
-  pcb_autorouting_error: () => pcb_autorouting_error,
-  pcb_board: () => pcb_board,
-  pcb_breakout_point: () => pcb_breakout_point,
-  pcb_component: () => pcb_component,
-  pcb_cutout: () => pcb_cutout,
-  pcb_cutout_circle: () => pcb_cutout_circle,
-  pcb_cutout_polygon: () => pcb_cutout_polygon,
-  pcb_cutout_rect: () => pcb_cutout_rect,
-  pcb_fabrication_note_path: () => pcb_fabrication_note_path,
-  pcb_fabrication_note_text: () => pcb_fabrication_note_text,
-  pcb_ground_plane: () => pcb_ground_plane,
-  pcb_ground_plane_region: () => pcb_ground_plane_region,
-  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_warning: () => pcb_manual_edit_conflict_warning,
-  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_thermal_spoke: () => pcb_thermal_spoke,
-  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_group: () => schematic_group,
-  schematic_layout_error: () => schematic_layout_error,
-  schematic_line: () => schematic_line,
-  schematic_manual_edit_conflict_warning: () => schematic_manual_edit_conflict_warning,
-  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_failed_to_create_component_error: () => source_failed_to_create_component_error,
-  source_group: () => source_group,
-  source_missing_property_error: () => source_missing_property_error,
-  source_net: () => source_net,
-  source_pcb_ground_plane: () => source_pcb_ground_plane,
-  source_port: () => source_port,
-  source_project_metadata: () => source_project_metadata,
-  source_simple_battery: () => source_simple_battery,
-  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_led: () => source_simple_led,
-  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_test_point: () => source_simple_test_point,
-  source_simple_transistor: () => source_simple_transistor,
-  source_trace: () => source_trace,
-  supplier_name: () => supplier_name,
-  time: () => time,
-  visible_layer: () => visible_layer,
-  voltage: () => voltage
-});
-import { z } from "zod";
-import { z as z2 } from "zod";
-import { z as z3 } from "zod";
-import { z as z4 } from "zod";
-import { z as z5 } from "zod";
-
-// node_modules/nanoid/index.js
-import { webcrypto as crypto } from "crypto";
-
-// node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-
-// node_modules/nanoid/index.js
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function nanoid(size2 = 21) {
-  fillPool(size2 -= 0);
-  let id = "";
-  for (let i = poolOffset - size2; i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id;
-}
-
-// node_modules/circuit-json/dist/index.mjs
-import { z as z6 } from "zod";
-import { z as z9 } from "zod";
-import { z as z7 } from "zod";
-import { z as z8 } 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 z31 } 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 z22 } from "zod";
-import { z as z23 } from "zod";
-import { z as z24 } from "zod";
-import { z as z25 } from "zod";
-import { z as z26 } from "zod";
-import { z as z27 } from "zod";
-import { z as z28 } from "zod";
-import { z as z29 } from "zod";
-import { z as z30 } from "zod";
-import { z as z32 } from "zod";
-import { z as z33 } from "zod";
-import { z as z34 } from "zod";
-import { z as z35 } from "zod";
-import { z as z36 } from "zod";
-import { z as z37 } from "zod";
-import { z as z38 } from "zod";
-import { z as z39 } from "zod";
-import { z as z40 } from "zod";
-import { z as z41 } from "zod";
-import { z as z43 } from "zod";
-import { z as z42 } 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";
-import { z as z75 } from "zod";
-import { z as z76 } from "zod";
-import { z as z77 } from "zod";
-import { z as z78 } from "zod";
-import { z as z79 } from "zod";
-import { z as z80 } from "zod";
-import { z as z81 } from "zod";
-import { z as z82 } from "zod";
-import { z as z83 } from "zod";
-import { z as z84 } from "zod";
-import { z as z85 } from "zod";
-import { z as z86 } from "zod";
-import { z as z87 } from "zod";
-import { z as z88 } 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 = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var capacitance = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value).transform((value) => {
-  return Number.parseFloat(value.toPrecision(12));
-});
-var inductance = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var voltage = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var length = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var frequency = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var distance = length;
-var current = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var time = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var rotation = z.string().or(z.number()).transform((arg) => {
-  if (typeof arg === "number") return arg;
-  if (arg.endsWith("deg")) {
-    return Number.parseFloat(arg.split("deg")[0]);
-  }
-  if (arg.endsWith("rad")) {
-    return Number.parseFloat(arg.split("rad")[0]) * 180 / Math.PI;
-  }
-  return Number.parseFloat(arg);
-});
-var battery_capacity = z.number().or(z.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 expectTypesMatch = (shouldBe) => {
-};
-expectTypesMatch("extra props b");
-expectTypesMatch("missing props b");
-expectTypesMatch(true);
-expectTypesMatch("mismatched prop types: a");
-var expectStringUnionsMatch = (shouldBe) => {
-};
-expectStringUnionsMatch(true);
-expectStringUnionsMatch(
-  'T1 has extra: "c", T2 has extra: "d"'
-);
-expectStringUnionsMatch('T1 has extra: "c"');
-expectStringUnionsMatch('T2 has extra: "c"');
-expectStringUnionsMatch(
-  'T1 has extra: "d", T2 has extra: "c"'
-);
-expectStringUnionsMatch(true);
-var point = z2.object({
-  x: distance,
-  y: distance
-});
-var position = point;
-expectTypesMatch(true);
-expectTypesMatch(true);
-var point3 = z3.object({
-  x: distance,
-  y: distance,
-  z: distance
-});
-var position3 = point3;
-expectTypesMatch(true);
-var size = z4.object({
-  width: z4.number(),
-  height: z4.number()
-});
-expectTypesMatch(true);
-var getZodPrefixedIdWithDefault = (prefix) => {
-  return z5.string().optional().default(() => `${prefix}_${nanoid(10)}`);
-};
-var ninePointAnchor = z6.enum([
-  "top_left",
-  "top_center",
-  "top_right",
-  "center_left",
-  "center",
-  "center_right",
-  "bottom_left",
-  "bottom_center",
-  "bottom_right"
-]);
-expectTypesMatch(true);
-var supplier_name = z7.enum([
-  "jlcpcb",
-  "macrofab",
-  "pcbway",
-  "digikey",
-  "mouser",
-  "lcsc"
-]);
-expectTypesMatch(true);
-var source_component_base = z8.object({
-  type: z8.literal("source_component"),
-  ftype: z8.string().optional(),
-  source_component_id: z8.string(),
-  name: z8.string(),
-  manufacturer_part_number: z8.string().optional(),
-  supplier_part_numbers: z8.record(supplier_name, z8.array(z8.string())).optional(),
-  display_value: z8.string().optional(),
-  are_pins_interchangeable: z8.boolean().optional(),
-  internally_connected_source_port_ids: z8.array(z8.array(z8.string())).optional(),
-  source_group_id: z8.string().optional(),
-  subcircuit_id: z8.string().optional()
-});
-expectTypesMatch(true);
-var source_simple_capacitor = source_component_base.extend({
-  ftype: z9.literal("simple_capacitor"),
-  capacitance,
-  max_voltage_rating: voltage.optional(),
-  display_capacitance: z9.string().optional(),
-  max_decoupling_trace_length: distance.optional()
-});
-expectTypesMatch(true);
-var source_simple_resistor = source_component_base.extend({
-  ftype: z10.literal("simple_resistor"),
-  resistance,
-  display_resistance: z10.string().optional()
-});
-expectTypesMatch(true);
-var source_simple_diode = source_component_base.extend({
-  ftype: z11.literal("simple_diode")
-});
-expectTypesMatch(true);
-var source_simple_led = source_simple_diode.extend({
-  ftype: z12.literal("simple_led"),
-  color: z12.string().optional(),
-  wavelength: z12.string().optional()
-});
-expectTypesMatch(true);
-var source_simple_ground = source_component_base.extend({
-  ftype: z13.literal("simple_ground")
-});
-expectTypesMatch(true);
-var source_simple_chip = source_component_base.extend({
-  ftype: z14.literal("simple_chip")
-});
-expectTypesMatch(true);
-var source_simple_power_source = source_component_base.extend({
-  ftype: z15.literal("simple_power_source"),
-  voltage
-});
-expectTypesMatch(true);
-var source_simple_fuse = source_component_base.extend({
-  ftype: z16.literal("simple_fuse"),
-  current_rating_amps: z16.number().describe("Nominal current in amps the fuse is rated for"),
-  voltage_rating_volts: z16.number().describe("Voltage rating in volts, e.g. \xB15V would be 5")
-});
-expectTypesMatch(true);
-var source_simple_battery = source_component_base.extend({
-  ftype: z17.literal("simple_battery"),
-  capacity: battery_capacity
-});
-expectTypesMatch(true);
-var source_simple_inductor = source_component_base.extend({
-  ftype: z18.literal("simple_inductor"),
-  inductance,
-  max_current_rating: z18.number().optional()
-});
-expectTypesMatch(true);
-var source_simple_push_button = source_component_base.extend({
-  ftype: z19.literal("simple_push_button")
-});
-expectTypesMatch(true);
-var source_simple_potentiometer = source_component_base.extend({
-  ftype: z20.literal("simple_potentiometer"),
-  max_resistance: resistance
-});
-expectTypesMatch(
-  true
-);
-var source_simple_crystal = source_component_base.extend({
-  ftype: z21.literal("simple_crystal"),
-  frequency: z21.number().describe("Frequency in Hz"),
-  load_capacitance: z21.number().optional().describe("Load capacitance in pF")
-});
-expectTypesMatch(true);
-var source_simple_pin_header = source_component_base.extend({
-  ftype: z22.literal("simple_pin_header"),
-  pin_count: z22.number(),
-  gender: z22.enum(["male", "female"]).optional().default("male")
-});
-expectTypesMatch(true);
-var source_simple_resonator = source_component_base.extend({
-  ftype: z23.literal("simple_resonator"),
-  load_capacitance: capacitance,
-  equivalent_series_resistance: resistance.optional(),
-  frequency
-});
-expectTypesMatch(true);
-var source_simple_transistor = source_component_base.extend({
-  ftype: z24.literal("simple_transistor"),
-  transistor_type: z24.enum(["npn", "pnp"])
-});
-expectTypesMatch(true);
-var source_simple_test_point = source_component_base.extend({
-  ftype: z25.literal("simple_test_point"),
-  footprint_variant: z25.enum(["pad", "through_hole"]).optional(),
-  pad_shape: z25.enum(["rect", "circle"]).optional(),
-  pad_diameter: z25.union([z25.number(), z25.string()]).optional(),
-  hole_diameter: z25.union([z25.number(), z25.string()]).optional(),
-  width: z25.union([z25.number(), z25.string()]).optional(),
-  height: z25.union([z25.number(), z25.string()]).optional()
-});
-expectTypesMatch(true);
-var source_simple_mosfet = source_component_base.extend({
-  ftype: z26.literal("simple_mosfet"),
-  channel_type: z26.enum(["n", "p"]),
-  mosfet_mode: z26.enum(["enhancement", "depletion"])
-});
-expectTypesMatch(true);
-var source_simple_switch = source_component_base.extend({
-  ftype: z27.literal("simple_switch")
-});
-expectTypesMatch(true);
-var source_project_metadata = z28.object({
-  type: z28.literal("source_project_metadata"),
-  name: z28.string().optional(),
-  software_used_string: z28.string().optional(),
-  project_url: z28.string().optional(),
-  created_at: z28.string().datetime().optional()
-});
-expectTypesMatch(true);
-var source_missing_property_error = z29.object({
-  type: z29.literal("source_missing_property_error"),
-  source_missing_property_error_id: getZodPrefixedIdWithDefault(
-    "source_missing_property_error"
-  ),
-  source_component_id: z29.string(),
-  property_name: z29.string(),
-  subcircuit_id: z29.string().optional(),
-  error_type: z29.literal("source_missing_property_error").default("source_missing_property_error"),
-  message: z29.string()
-}).describe("The source code is missing a property");
-expectTypesMatch(true);
-var source_failed_to_create_component_error = z30.object({
-  type: z30.literal("source_failed_to_create_component_error"),
-  source_failed_to_create_component_error_id: getZodPrefixedIdWithDefault(
-    "source_failed_to_create_component_error"
-  ),
-  error_type: z30.literal("source_failed_to_create_component_error").default("source_failed_to_create_component_error"),
-  component_name: z30.string().optional(),
-  subcircuit_id: z30.string().optional(),
-  parent_source_component_id: z30.string().optional(),
-  message: z30.string(),
-  pcb_center: z30.object({
-    x: z30.number().optional(),
-    y: z30.number().optional()
-  }).optional(),
-  schematic_center: z30.object({
-    x: z30.number().optional(),
-    y: z30.number().optional()
-  }).optional()
-}).describe("Error emitted when a component fails to be constructed");
-expectTypesMatch(true);
-var any_source_component = z31.union([
-  source_simple_resistor,
-  source_simple_capacitor,
-  source_simple_diode,
-  source_simple_led,
-  source_simple_ground,
-  source_simple_chip,
-  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_test_point,
-  source_simple_mosfet,
-  source_simple_fuse,
-  source_project_metadata,
-  source_missing_property_error,
-  source_failed_to_create_component_error
-]);
-expectTypesMatch(true);
-var source_port = z32.object({
-  type: z32.literal("source_port"),
-  pin_number: z32.number().optional(),
-  port_hints: z32.array(z32.string()).optional(),
-  name: z32.string(),
-  source_port_id: z32.string(),
-  source_component_id: z32.string(),
-  subcircuit_id: z32.string().optional(),
-  subcircuit_connectivity_map_key: z32.string().optional()
-});
-expectTypesMatch(true);
-var source_trace = z33.object({
-  type: z33.literal("source_trace"),
-  source_trace_id: z33.string(),
-  connected_source_port_ids: z33.array(z33.string()),
-  connected_source_net_ids: z33.array(z33.string()),
-  subcircuit_id: z33.string().optional(),
-  subcircuit_connectivity_map_key: z33.string().optional(),
-  max_length: z33.number().optional(),
-  min_trace_thickness: z33.number().optional(),
-  display_name: z33.string().optional()
-});
-expectTypesMatch(true);
-var source_group = z34.object({
-  type: z34.literal("source_group"),
-  source_group_id: z34.string(),
-  subcircuit_id: z34.string().optional(),
-  parent_subcircuit_id: z34.string().optional(),
-  is_subcircuit: z34.boolean().optional(),
-  name: z34.string().optional()
-});
-expectTypesMatch(true);
-var source_net = z35.object({
-  type: z35.literal("source_net"),
-  source_net_id: z35.string(),
-  name: z35.string(),
-  member_source_group_ids: z35.array(z35.string()),
-  is_power: z35.boolean().optional(),
-  is_ground: z35.boolean().optional(),
-  is_digital_signal: z35.boolean().optional(),
-  is_analog_signal: z35.boolean().optional(),
-  trace_width: z35.number().optional(),
-  subcircuit_id: z35.string().optional(),
-  subcircuit_connectivity_map_key: z35.string().optional()
-});
-expectTypesMatch(true);
-var source_pcb_ground_plane = z36.object({
-  type: z36.literal("source_pcb_ground_plane"),
-  source_pcb_ground_plane_id: z36.string(),
-  source_group_id: z36.string(),
-  source_net_id: z36.string(),
-  subcircuit_id: z36.string().optional()
-}).describe("Defines a ground plane in the source domain");
-expectTypesMatch(true);
-var schematic_box = z37.object({
-  type: z37.literal("schematic_box"),
-  schematic_component_id: z37.string().optional(),
-  width: distance,
-  height: distance,
-  is_dashed: z37.boolean().default(false),
-  x: distance,
-  y: distance,
-  subcircuit_id: z37.string().optional()
-}).describe("Draws a box on the schematic");
-expectTypesMatch(true);
-var schematic_path = z38.object({
-  type: z38.literal("schematic_path"),
-  schematic_component_id: z38.string(),
-  fill_color: z38.enum(["red", "blue"]).optional(),
-  is_filled: z38.boolean().optional(),
-  points: z38.array(point),
-  subcircuit_id: z38.string().optional()
-});
-expectTypesMatch(true);
-var schematic_pin_styles = z39.record(
-  z39.object({
-    left_margin: length.optional(),
-    right_margin: length.optional(),
-    top_margin: length.optional(),
-    bottom_margin: length.optional()
-  })
-);
-var schematic_component_port_arrangement_by_size = z39.object({
-  left_size: z39.number(),
-  right_size: z39.number(),
-  top_size: z39.number().optional(),
-  bottom_size: z39.number().optional()
-});
-expectTypesMatch(true);
-var schematic_component_port_arrangement_by_sides = z39.object({
-  left_side: z39.object({
-    pins: z39.array(z39.number()),
-    // @ts-ignore
-    direction: z39.enum(["top-to-bottom", "bottom-to-top"]).optional()
-  }).optional(),
-  right_side: z39.object({
-    pins: z39.array(z39.number()),
-    // @ts-ignore
-    direction: z39.enum(["top-to-bottom", "bottom-to-top"]).optional()
-  }).optional(),
-  top_side: z39.object({
-    pins: z39.array(z39.number()),
-    // @ts-ignore
-    direction: z39.enum(["left-to-right", "right-to-left"]).optional()
-  }).optional(),
-  bottom_side: z39.object({
-    pins: z39.array(z39.number()),
-    // @ts-ignore
-    direction: z39.enum(["left-to-right", "right-to-left"]).optional()
-  }).optional()
-});
-expectTypesMatch(true);
-var port_arrangement = z39.union([
-  schematic_component_port_arrangement_by_size,
-  schematic_component_port_arrangement_by_sides
-]);
-var schematic_component = z39.object({
-  type: z39.literal("schematic_component"),
-  size,
-  center: point,
-  source_component_id: z39.string(),
-  schematic_component_id: z39.string(),
-  pin_spacing: length.optional(),
-  pin_styles: schematic_pin_styles.optional(),
-  box_width: length.optional(),
-  symbol_name: z39.string().optional(),
-  port_arrangement: port_arrangement.optional(),
-  port_labels: z39.record(z39.string()).optional(),
-  symbol_display_value: z39.string().optional(),
-  subcircuit_id: z39.string().optional(),
-  schematic_group_id: z39.string().optional()
-});
-expectTypesMatch(true);
-var schematic_line = z40.object({
-  type: z40.literal("schematic_line"),
-  schematic_component_id: z40.string(),
-  x1: distance,
-  x2: distance,
-  y1: distance,
-  y2: distance,
-  subcircuit_id: z40.string().optional()
-});
-expectTypesMatch(true);
-var schematic_trace = z41.object({
-  type: z41.literal("schematic_trace"),
-  schematic_trace_id: z41.string(),
-  source_trace_id: z41.string(),
-  junctions: z41.array(
-    z41.object({
-      x: z41.number(),
-      y: z41.number()
-    })
-  ),
-  edges: z41.array(
-    z41.object({
-      from: z41.object({
-        x: z41.number(),
-        y: z41.number()
-      }),
-      to: z41.object({
-        x: z41.number(),
-        y: z41.number()
-      }),
-      is_crossing: z41.boolean().optional(),
-      from_schematic_port_id: z41.string().optional(),
-      to_schematic_port_id: z41.string().optional()
-    })
-  ),
-  subcircuit_id: z41.string().optional()
-});
-expectTypesMatch(true);
-var fivePointAnchor = z42.enum([
-  "center",
-  "left",
-  "right",
-  "top",
-  "bottom"
-]);
-expectTypesMatch(true);
-var schematic_text = z43.object({
-  type: z43.literal("schematic_text"),
-  schematic_component_id: z43.string().optional(),
-  schematic_text_id: z43.string(),
-  text: z43.string(),
-  font_size: z43.number().default(0.18),
-  position: z43.object({
-    x: distance,
-    y: distance
-  }),
-  rotation: z43.number().default(0),
-  anchor: z43.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
-  color: z43.string().default("#000000"),
-  subcircuit_id: z43.string().optional()
-});
-expectTypesMatch(true);
-var schematic_port = z44.object({
-  type: z44.literal("schematic_port"),
-  schematic_port_id: z44.string(),
-  source_port_id: z44.string(),
-  schematic_component_id: z44.string().optional(),
-  center: point,
-  facing_direction: z44.enum(["up", "down", "left", "right"]).optional(),
-  distance_from_component_edge: z44.number().optional(),
-  side_of_component: z44.enum(["top", "bottom", "left", "right"]).optional(),
-  true_ccw_index: z44.number().optional(),
-  pin_number: z44.number().optional(),
-  display_pin_label: z44.string().optional(),
-  subcircuit_id: z44.string().optional(),
-  is_connected: z44.boolean().optional()
-}).describe("Defines a port on a schematic component");
-expectTypesMatch(true);
-var schematic_net_label = z45.object({
-  type: z45.literal("schematic_net_label"),
-  schematic_net_label_id: getZodPrefixedIdWithDefault("schematic_net_label"),
-  schematic_trace_id: z45.string().optional(),
-  source_trace_id: z45.string().optional(),
-  source_net_id: z45.string(),
-  center: point,
-  anchor_position: point.optional(),
-  anchor_side: z45.enum(["top", "bottom", "left", "right"]),
-  text: z45.string(),
-  symbol_name: z45.string().optional(),
-  is_movable: z45.boolean().optional(),
-  subcircuit_id: z45.string().optional()
-});
-expectTypesMatch(true);
-var schematic_error = z46.object({
-  type: z46.literal("schematic_error"),
-  schematic_error_id: z46.string(),
-  // eventually each error type should be broken out into a dir of files
-  error_type: z46.literal("schematic_port_not_found").default("schematic_port_not_found"),
-  message: z46.string(),
-  subcircuit_id: z46.string().optional()
-}).describe("Defines a schematic error on the schematic");
-expectTypesMatch(true);
-var schematic_layout_error = z47.object({
-  type: z47.literal("schematic_layout_error"),
-  schematic_layout_error_id: getZodPrefixedIdWithDefault(
-    "schematic_layout_error"
-  ),
-  error_type: z47.literal("schematic_layout_error").default("schematic_layout_error"),
-  message: z47.string(),
-  source_group_id: z47.string(),
-  schematic_group_id: z47.string(),
-  subcircuit_id: z47.string().optional()
-}).describe("Error emitted when schematic layout fails for a group");
-expectTypesMatch(true);
-var schematic_debug_object_base = z48.object({
-  type: z48.literal("schematic_debug_object"),
-  label: z48.string().optional(),
-  subcircuit_id: z48.string().optional()
-});
-var schematic_debug_rect = schematic_debug_object_base.extend({
-  shape: z48.literal("rect"),
-  center: point,
-  size
-});
-var schematic_debug_line = schematic_debug_object_base.extend({
-  shape: z48.literal("line"),
-  start: point,
-  end: point
-});
-var schematic_debug_point = schematic_debug_object_base.extend({
-  shape: z48.literal("point"),
-  center: point
-});
-var schematic_debug_object = z48.discriminatedUnion("shape", [
-  schematic_debug_rect,
-  schematic_debug_line,
-  schematic_debug_point
-]);
-expectTypesMatch(true);
-var schematic_voltage_probe = z49.object({
-  type: z49.literal("schematic_voltage_probe"),
-  schematic_voltage_probe_id: z49.string(),
-  position: point,
-  schematic_trace_id: z49.string(),
-  voltage: voltage.optional(),
-  subcircuit_id: z49.string().optional()
-}).describe("Defines a voltage probe measurement point on a schematic trace");
-expectTypesMatch(true);
-var schematic_manual_edit_conflict_warning = z50.object({
-  type: z50.literal("schematic_manual_edit_conflict_warning"),
-  schematic_manual_edit_conflict_warning_id: getZodPrefixedIdWithDefault(
-    "schematic_manual_edit_conflict_warning"
-  ),
-  warning_type: z50.literal("schematic_manual_edit_conflict_warning").default("schematic_manual_edit_conflict_warning"),
-  message: z50.string(),
-  schematic_component_id: z50.string(),
-  schematic_group_id: z50.string().optional(),
-  subcircuit_id: z50.string().optional(),
-  source_component_id: z50.string()
-}).describe(
-  "Warning emitted when a component has both manual placement and explicit schX/schY coordinates"
-);
-expectTypesMatch(true);
-var schematic_group = z51.object({
-  type: z51.literal("schematic_group"),
-  schematic_group_id: getZodPrefixedIdWithDefault("schematic_group"),
-  source_group_id: z51.string(),
-  is_subcircuit: z51.boolean().optional(),
-  subcircuit_id: z51.string().optional(),
-  width: length,
-  height: length,
-  center: point,
-  schematic_component_ids: z51.array(z51.string()),
-  name: z51.string().optional(),
-  description: z51.string().optional()
-}).describe("Defines a group of components on the schematic");
-expectTypesMatch(true);
-var all_layers = [
-  "top",
-  "bottom",
-  "inner1",
-  "inner2",
-  "inner3",
-  "inner4",
-  "inner5",
-  "inner6"
-];
-var layer_string = z52.enum(all_layers);
-var layer_ref = layer_string.or(
-  z52.object({
-    name: layer_string
-  })
-).transform((layer) => {
-  if (typeof layer === "string") {
-    return layer;
-  }
-  return layer.name;
-});
-expectTypesMatch(true);
-var visible_layer = z52.enum(["top", "bottom"]);
-var pcb_route_hint = z53.object({
-  x: distance,
-  y: distance,
-  via: z53.boolean().optional(),
-  via_to_layer: layer_ref.optional()
-});
-var pcb_route_hints = z53.array(pcb_route_hint);
-expectTypesMatch(true);
-expectTypesMatch(true);
-var route_hint_point = z54.object({
-  x: distance,
-  y: distance,
-  via: z54.boolean().optional(),
-  to_layer: layer_ref.optional(),
-  trace_width: distance.optional()
-});
-expectTypesMatch(true);
-var pcb_component = z55.object({
-  type: z55.literal("pcb_component"),
-  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
-  source_component_id: z55.string(),
-  center: point,
-  layer: layer_ref,
-  rotation,
-  width: length,
-  height: length,
-  subcircuit_id: z55.string().optional(),
-  pcb_group_id: z55.string().optional()
-}).describe("Defines a component on the PCB");
-expectTypesMatch(true);
-var pcb_hole_circle_or_square = z56.object({
-  type: z56.literal("pcb_hole"),
-  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  pcb_group_id: z56.string().optional(),
-  subcircuit_id: z56.string().optional(),
-  hole_shape: z56.enum(["circle", "square"]),
-  hole_diameter: z56.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 = z56.object({
-  type: z56.literal("pcb_hole"),
-  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
-  pcb_group_id: z56.string().optional(),
-  subcircuit_id: z56.string().optional(),
-  hole_shape: z56.literal("oval"),
-  hole_width: z56.number(),
-  hole_height: z56.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 = z57.object({
-  type: z57.literal("pcb_plated_hole"),
-  shape: z57.literal("circle"),
-  pcb_group_id: z57.string().optional(),
-  subcircuit_id: z57.string().optional(),
-  outer_diameter: z57.number(),
-  hole_diameter: z57.number(),
-  x: distance,
-  y: distance,
-  layers: z57.array(layer_ref),
-  port_hints: z57.array(z57.string()).optional(),
-  pcb_component_id: z57.string().optional(),
-  pcb_port_id: z57.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_plated_hole_oval = z57.object({
-  type: z57.literal("pcb_plated_hole"),
-  shape: z57.enum(["oval", "pill"]),
-  pcb_group_id: z57.string().optional(),
-  subcircuit_id: z57.string().optional(),
-  outer_width: z57.number(),
-  outer_height: z57.number(),
-  hole_width: z57.number(),
-  hole_height: z57.number(),
-  x: distance,
-  y: distance,
-  layers: z57.array(layer_ref),
-  port_hints: z57.array(z57.string()).optional(),
-  pcb_component_id: z57.string().optional(),
-  pcb_port_id: z57.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_circular_hole_with_rect_pad = z57.object({
-  type: z57.literal("pcb_plated_hole"),
-  shape: z57.literal("circular_hole_with_rect_pad"),
-  pcb_group_id: z57.string().optional(),
-  subcircuit_id: z57.string().optional(),
-  hole_shape: z57.literal("circle"),
-  pad_shape: z57.literal("rect"),
-  hole_diameter: z57.number(),
-  rect_pad_width: z57.number(),
-  rect_pad_height: z57.number(),
-  x: distance,
-  y: distance,
-  layers: z57.array(layer_ref),
-  port_hints: z57.array(z57.string()).optional(),
-  pcb_component_id: z57.string().optional(),
-  pcb_port_id: z57.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_pill_hole_with_rect_pad = z57.object({
-  type: z57.literal("pcb_plated_hole"),
-  shape: z57.literal("pill_hole_with_rect_pad"),
-  pcb_group_id: z57.string().optional(),
-  subcircuit_id: z57.string().optional(),
-  hole_shape: z57.literal("pill"),
-  pad_shape: z57.literal("rect"),
-  hole_width: z57.number(),
-  hole_height: z57.number(),
-  rect_pad_width: z57.number(),
-  rect_pad_height: z57.number(),
-  x: distance,
-  y: distance,
-  layers: z57.array(layer_ref),
-  port_hints: z57.array(z57.string()).optional(),
-  pcb_component_id: z57.string().optional(),
-  pcb_port_id: z57.string().optional(),
-  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
-});
-var pcb_plated_hole = z57.union([
-  pcb_plated_hole_circle,
-  pcb_plated_hole_oval,
-  pcb_circular_hole_with_rect_pad,
-  pcb_pill_hole_with_rect_pad
-]);
-expectTypesMatch(
-  true
-);
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_port = z58.object({
-  type: z58.literal("pcb_port"),
-  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
-  pcb_group_id: z58.string().optional(),
-  subcircuit_id: z58.string().optional(),
-  source_port_id: z58.string(),
-  pcb_component_id: z58.string(),
-  x: distance,
-  y: distance,
-  layers: z58.array(layer_ref)
-}).describe("Defines a port on the PCB");
-expectTypesMatch(true);
-var pcb_smtpad_circle = z59.object({
-  type: z59.literal("pcb_smtpad"),
-  shape: z59.literal("circle"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  pcb_group_id: z59.string().optional(),
-  subcircuit_id: z59.string().optional(),
-  x: distance,
-  y: distance,
-  radius: z59.number(),
-  layer: layer_ref,
-  port_hints: z59.array(z59.string()).optional(),
-  pcb_component_id: z59.string().optional(),
-  pcb_port_id: z59.string().optional()
-});
-var pcb_smtpad_rect = z59.object({
-  type: z59.literal("pcb_smtpad"),
-  shape: z59.literal("rect"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  pcb_group_id: z59.string().optional(),
-  subcircuit_id: z59.string().optional(),
-  x: distance,
-  y: distance,
-  width: z59.number(),
-  height: z59.number(),
-  layer: layer_ref,
-  port_hints: z59.array(z59.string()).optional(),
-  pcb_component_id: z59.string().optional(),
-  pcb_port_id: z59.string().optional()
-});
-var pcb_smtpad_rotated_rect = z59.object({
-  type: z59.literal("pcb_smtpad"),
-  shape: z59.literal("rotated_rect"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  pcb_group_id: z59.string().optional(),
-  subcircuit_id: z59.string().optional(),
-  x: distance,
-  y: distance,
-  width: z59.number(),
-  height: z59.number(),
-  ccw_rotation: rotation,
-  layer: layer_ref,
-  port_hints: z59.array(z59.string()).optional(),
-  pcb_component_id: z59.string().optional(),
-  pcb_port_id: z59.string().optional()
-});
-var pcb_smtpad_pill = z59.object({
-  type: z59.literal("pcb_smtpad"),
-  shape: z59.literal("pill"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  pcb_group_id: z59.string().optional(),
-  subcircuit_id: z59.string().optional(),
-  x: distance,
-  y: distance,
-  width: z59.number(),
-  height: z59.number(),
-  radius: z59.number(),
-  layer: layer_ref,
-  port_hints: z59.array(z59.string()).optional(),
-  pcb_component_id: z59.string().optional(),
-  pcb_port_id: z59.string().optional()
-});
-var pcb_smtpad_polygon = z59.object({
-  type: z59.literal("pcb_smtpad"),
-  shape: z59.literal("polygon"),
-  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
-  pcb_group_id: z59.string().optional(),
-  subcircuit_id: z59.string().optional(),
-  points: z59.array(point),
-  layer: layer_ref,
-  port_hints: z59.array(z59.string()).optional(),
-  pcb_component_id: z59.string().optional(),
-  pcb_port_id: z59.string().optional()
-});
-var pcb_smtpad = z59.discriminatedUnion("shape", [
-  pcb_smtpad_circle,
-  pcb_smtpad_rect,
-  pcb_smtpad_rotated_rect,
-  pcb_smtpad_pill,
-  pcb_smtpad_polygon
-]).describe("Defines an SMT pad on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_solder_paste_circle = z60.object({
-  type: z60.literal("pcb_solder_paste"),
-  shape: z60.literal("circle"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  pcb_group_id: z60.string().optional(),
-  subcircuit_id: z60.string().optional(),
-  x: distance,
-  y: distance,
-  radius: z60.number(),
-  layer: layer_ref,
-  pcb_component_id: z60.string().optional(),
-  pcb_smtpad_id: z60.string().optional()
-});
-var pcb_solder_paste_rect = z60.object({
-  type: z60.literal("pcb_solder_paste"),
-  shape: z60.literal("rect"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  pcb_group_id: z60.string().optional(),
-  subcircuit_id: z60.string().optional(),
-  x: distance,
-  y: distance,
-  width: z60.number(),
-  height: z60.number(),
-  layer: layer_ref,
-  pcb_component_id: z60.string().optional(),
-  pcb_smtpad_id: z60.string().optional()
-});
-var pcb_solder_paste_pill = z60.object({
-  type: z60.literal("pcb_solder_paste"),
-  shape: z60.literal("pill"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  pcb_group_id: z60.string().optional(),
-  subcircuit_id: z60.string().optional(),
-  x: distance,
-  y: distance,
-  width: z60.number(),
-  height: z60.number(),
-  radius: z60.number(),
-  layer: layer_ref,
-  pcb_component_id: z60.string().optional(),
-  pcb_smtpad_id: z60.string().optional()
-});
-var pcb_solder_paste_rotated_rect = z60.object({
-  type: z60.literal("pcb_solder_paste"),
-  shape: z60.literal("rotated_rect"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  pcb_group_id: z60.string().optional(),
-  subcircuit_id: z60.string().optional(),
-  x: distance,
-  y: distance,
-  width: z60.number(),
-  height: z60.number(),
-  ccw_rotation: distance,
-  layer: layer_ref,
-  pcb_component_id: z60.string().optional(),
-  pcb_smtpad_id: z60.string().optional()
-});
-var pcb_solder_paste_oval = z60.object({
-  type: z60.literal("pcb_solder_paste"),
-  shape: z60.literal("oval"),
-  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
-  pcb_group_id: z60.string().optional(),
-  subcircuit_id: z60.string().optional(),
-  x: distance,
-  y: distance,
-  width: z60.number(),
-  height: z60.number(),
-  layer: layer_ref,
-  pcb_component_id: z60.string().optional(),
-  pcb_smtpad_id: z60.string().optional()
-});
-var pcb_solder_paste = z60.union([
-  pcb_solder_paste_circle,
-  pcb_solder_paste_rect,
-  pcb_solder_paste_pill,
-  pcb_solder_paste_rotated_rect,
-  pcb_solder_paste_oval
-]).describe("Defines solderpaste on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(true);
-expectTypesMatch(
-  true
-);
-expectTypesMatch(true);
-var pcb_text = z61.object({
-  type: z61.literal("pcb_text"),
-  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
-  pcb_group_id: z61.string().optional(),
-  subcircuit_id: z61.string().optional(),
-  text: z61.string(),
-  center: point,
-  layer: layer_ref,
-  width: length,
-  height: length,
-  lines: z61.number(),
-  // @ts-ignore
-  align: z61.enum(["bottom-left"])
-}).describe("Defines text on the PCB");
-expectTypesMatch(true);
-var pcb_trace_route_point_wire = z62.object({
-  route_type: z62.literal("wire"),
-  x: distance,
-  y: distance,
-  width: distance,
-  start_pcb_port_id: z62.string().optional(),
-  end_pcb_port_id: z62.string().optional(),
-  layer: layer_ref
-});
-var pcb_trace_route_point_via = z62.object({
-  route_type: z62.literal("via"),
-  x: distance,
-  y: distance,
-  hole_diameter: distance.optional(),
-  outer_diameter: distance.optional(),
-  from_layer: z62.string(),
-  to_layer: z62.string()
-});
-var pcb_trace_route_point = z62.union([
-  pcb_trace_route_point_wire,
-  pcb_trace_route_point_via
-]);
-var pcb_trace = z62.object({
-  type: z62.literal("pcb_trace"),
-  source_trace_id: z62.string().optional(),
-  pcb_component_id: z62.string().optional(),
-  pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
-  pcb_group_id: z62.string().optional(),
-  subcircuit_id: z62.string().optional(),
-  route_thickness_mode: z62.enum(["constant", "interpolated"]).default("constant").optional(),
-  route_order_index: z62.number().optional(),
-  should_round_corners: z62.boolean().optional(),
-  trace_length: z62.number().optional(),
-  route: z62.array(pcb_trace_route_point)
-}).describe("Defines a trace on the PCB");
-expectTypesMatch(true);
-expectTypesMatch(true);
-var pcb_trace_error = z63.object({
-  type: z63.literal("pcb_trace_error"),
-  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
-  error_type: z63.literal("pcb_trace_error").default("pcb_trace_error"),
-  message: z63.string(),
-  center: point.optional(),
-  pcb_trace_id: z63.string(),
-  source_trace_id: z63.string(),
-  pcb_component_ids: z63.array(z63.string()),
-  pcb_port_ids: z63.array(z63.string()),
-  subcircuit_id: z63.string().optional()
-}).describe("Defines a trace error on the PCB");
-expectTypesMatch(true);
-var pcb_port_not_matched_error = z64.object({
-  type: z64.literal("pcb_port_not_matched_error"),
-  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
-  error_type: z64.literal("pcb_port_not_matched_error").default("pcb_port_not_matched_error"),
-  message: z64.string(),
-  pcb_component_ids: z64.array(z64.string()),
-  subcircuit_id: z64.string().optional()
-}).describe("Defines a trace error on the PCB where a port is not matched");
-expectTypesMatch(true);
-var pcb_via = z65.object({
-  type: z65.literal("pcb_via"),
-  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
-  pcb_group_id: z65.string().optional(),
-  subcircuit_id: z65.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: z65.array(layer_ref),
-  pcb_trace_id: z65.string().optional()
-}).describe("Defines a via on the PCB");
-expectTypesMatch(true);
-var pcb_board = z66.object({
-  type: z66.literal("pcb_board"),
-  pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
-  is_subcircuit: z66.boolean().optional(),
-  subcircuit_id: z66.string().optional(),
-  width: length,
-  height: length,
-  center: point,
-  thickness: length.optional().default(1.4),
-  num_layers: z66.number().optional().default(4),
-  outline: z66.array(point).optional(),
-  material: z66.enum(["fr4", "fr1"]).default("fr4")
-}).describe("Defines the board outline of the PCB");
-expectTypesMatch(true);
-var pcb_placement_error = z67.object({
-  type: z67.literal("pcb_placement_error"),
-  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
-  error_type: z67.literal("pcb_placement_error").default("pcb_placement_error"),
-  message: z67.string(),
-  subcircuit_id: z67.string().optional()
-}).describe("Defines a placement error on the PCB");
-expectTypesMatch(true);
-var pcb_trace_hint = z68.object({
-  type: z68.literal("pcb_trace_hint"),
-  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
-  pcb_port_id: z68.string(),
-  pcb_component_id: z68.string(),
-  route: z68.array(route_hint_point),
-  subcircuit_id: z68.string().optional()
-}).describe("A hint that can be used during generation of a PCB trace");
-expectTypesMatch(true);
-var pcb_silkscreen_line = z69.object({
-  type: z69.literal("pcb_silkscreen_line"),
-  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
-  pcb_component_id: z69.string(),
-  pcb_group_id: z69.string().optional(),
-  subcircuit_id: z69.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 = z70.object({
-  type: z70.literal("pcb_silkscreen_path"),
-  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
-  pcb_component_id: z70.string(),
-  pcb_group_id: z70.string().optional(),
-  subcircuit_id: z70.string().optional(),
-  layer: visible_layer,
-  route: z70.array(point),
-  stroke_width: length
-}).describe("Defines a silkscreen path on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_text = z71.object({
-  type: z71.literal("pcb_silkscreen_text"),
-  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
-  pcb_group_id: z71.string().optional(),
-  subcircuit_id: z71.string().optional(),
-  font: z71.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance.default("0.2mm"),
-  pcb_component_id: z71.string(),
-  text: z71.string(),
-  ccw_rotation: z71.number().optional(),
-  layer: layer_ref,
-  is_mirrored: z71.boolean().default(false).optional(),
-  anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: ninePointAnchor.default("center")
-}).describe("Defines silkscreen text on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_rect = z72.object({
-  type: z72.literal("pcb_silkscreen_rect"),
-  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
-  pcb_component_id: z72.string(),
-  pcb_group_id: z72.string().optional(),
-  subcircuit_id: z72.string().optional(),
-  center: point,
-  width: length,
-  height: length,
-  layer: layer_ref,
-  stroke_width: length.default("1mm"),
-  is_filled: z72.boolean().default(true).optional(),
-  has_stroke: z72.boolean().optional(),
-  is_stroke_dashed: z72.boolean().optional()
-}).describe("Defines a silkscreen rect on the PCB");
-expectTypesMatch(true);
-var pcb_silkscreen_circle = z73.object({
-  type: z73.literal("pcb_silkscreen_circle"),
-  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
-    "pcb_silkscreen_circle"
-  ),
-  pcb_component_id: z73.string(),
-  pcb_group_id: z73.string().optional(),
-  subcircuit_id: z73.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 = z74.object({
-  type: z74.literal("pcb_silkscreen_oval"),
-  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
-  pcb_component_id: z74.string(),
-  pcb_group_id: z74.string().optional(),
-  subcircuit_id: z74.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 = z75.object({
-  type: z75.literal("pcb_fabrication_note_text"),
-  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
-    "pcb_fabrication_note_text"
-  ),
-  subcircuit_id: z75.string().optional(),
-  pcb_group_id: z75.string().optional(),
-  font: z75.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance.default("1mm"),
-  pcb_component_id: z75.string(),
-  text: z75.string(),
-  layer: visible_layer,
-  anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: z75.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  color: z75.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 = z76.object({
-  type: z76.literal("pcb_fabrication_note_path"),
-  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
-    "pcb_fabrication_note_path"
-  ),
-  pcb_component_id: z76.string(),
-  subcircuit_id: z76.string().optional(),
-  layer: layer_ref,
-  route: z76.array(point),
-  stroke_width: length,
-  color: z76.string().optional()
-}).describe(
-  "Defines a fabrication path on the PCB for fabricators or assemblers"
-);
-expectTypesMatch(true);
-var pcb_keepout = z77.object({
-  type: z77.literal("pcb_keepout"),
-  shape: z77.literal("rect"),
-  pcb_group_id: z77.string().optional(),
-  subcircuit_id: z77.string().optional(),
-  center: point,
-  width: distance,
-  height: distance,
-  pcb_keepout_id: z77.string(),
-  layers: z77.array(z77.string()),
-  // Specify layers where the keepout applies
-  description: z77.string().optional()
-  // Optional description of the keepout
-}).or(
-  z77.object({
-    type: z77.literal("pcb_keepout"),
-    shape: z77.literal("circle"),
-    pcb_group_id: z77.string().optional(),
-    subcircuit_id: z77.string().optional(),
-    center: point,
-    radius: distance,
-    pcb_keepout_id: z77.string(),
-    layers: z77.array(z77.string()),
-    // Specify layers where the keepout applies
-    description: z77.string().optional()
-    // Optional description of the keepout
-  })
-);
-expectTypesMatch(true);
-var pcb_cutout_base = z78.object({
-  type: z78.literal("pcb_cutout"),
-  pcb_cutout_id: getZodPrefixedIdWithDefault("pcb_cutout"),
-  pcb_group_id: z78.string().optional(),
-  subcircuit_id: z78.string().optional()
-});
-var pcb_cutout_rect = pcb_cutout_base.extend({
-  shape: z78.literal("rect"),
-  center: point,
-  width: length,
-  height: length,
-  rotation: rotation.optional()
-});
-expectTypesMatch(true);
-var pcb_cutout_circle = pcb_cutout_base.extend({
-  shape: z78.literal("circle"),
-  center: point,
-  radius: length
-});
-expectTypesMatch(true);
-var pcb_cutout_polygon = pcb_cutout_base.extend({
-  shape: z78.literal("polygon"),
-  points: z78.array(point)
-});
-expectTypesMatch(true);
-var pcb_cutout = z78.discriminatedUnion("shape", [
-  pcb_cutout_rect,
-  pcb_cutout_circle,
-  pcb_cutout_polygon
-]).describe("Defines a cutout on the PCB, removing board material.");
-expectTypesMatch(true);
-var pcb_missing_footprint_error = z79.object({
-  type: z79.literal("pcb_missing_footprint_error"),
-  pcb_missing_footprint_error_id: getZodPrefixedIdWithDefault(
-    "pcb_missing_footprint_error"
-  ),
-  pcb_group_id: z79.string().optional(),
-  subcircuit_id: z79.string().optional(),
-  error_type: z79.literal("pcb_missing_footprint_error").default("pcb_missing_footprint_error"),
-  source_component_id: z79.string(),
-  message: z79.string()
-}).describe("Defines a missing footprint error on the PCB");
-expectTypesMatch(
-  true
-);
-var pcb_group = z80.object({
-  type: z80.literal("pcb_group"),
-  pcb_group_id: getZodPrefixedIdWithDefault("pcb_group"),
-  source_group_id: z80.string(),
-  is_subcircuit: z80.boolean().optional(),
-  subcircuit_id: z80.string().optional(),
-  width: length,
-  height: length,
-  center: point,
-  pcb_component_ids: z80.array(z80.string()),
-  name: z80.string().optional(),
-  description: z80.string().optional(),
-  autorouter_configuration: z80.object({
-    trace_clearance: length
-  }).optional(),
-  autorouter_used_string: z80.string().optional()
-}).describe("Defines a group of components on the PCB");
-expectTypesMatch(true);
-var pcb_autorouting_error = z81.object({
-  type: z81.literal("pcb_autorouting_error"),
-  pcb_error_id: getZodPrefixedIdWithDefault("pcb_autorouting_error"),
-  error_type: z81.literal("pcb_autorouting_error").default("pcb_autorouting_error"),
-  message: z81.string(),
-  subcircuit_id: z81.string().optional()
-}).describe("The autorouting has failed to route a portion of the board");
-expectTypesMatch(true);
-var pcb_manual_edit_conflict_warning = z82.object({
-  type: z82.literal("pcb_manual_edit_conflict_warning"),
-  pcb_manual_edit_conflict_warning_id: getZodPrefixedIdWithDefault(
-    "pcb_manual_edit_conflict_warning"
-  ),
-  warning_type: z82.literal("pcb_manual_edit_conflict_warning").default("pcb_manual_edit_conflict_warning"),
-  message: z82.string(),
-  pcb_component_id: z82.string(),
-  pcb_group_id: z82.string().optional(),
-  subcircuit_id: z82.string().optional(),
-  source_component_id: z82.string()
-}).describe(
-  "Warning emitted when a component has both manual placement and explicit pcbX/pcbY coordinates"
-);
-expectTypesMatch(true);
-var pcb_breakout_point = z83.object({
-  type: z83.literal("pcb_breakout_point"),
-  pcb_breakout_point_id: getZodPrefixedIdWithDefault("pcb_breakout_point"),
-  pcb_group_id: z83.string(),
-  subcircuit_id: z83.string().optional(),
-  source_trace_id: z83.string().optional(),
-  source_port_id: z83.string().optional(),
-  source_net_id: z83.string().optional(),
-  x: distance,
-  y: distance
-}).describe(
-  "Defines a routing target within a pcb_group for a source_trace or source_net"
-);
-expectTypesMatch(true);
-var pcb_ground_plane = z84.object({
-  type: z84.literal("pcb_ground_plane"),
-  pcb_ground_plane_id: getZodPrefixedIdWithDefault("pcb_ground_plane"),
-  source_pcb_ground_plane_id: z84.string(),
-  source_net_id: z84.string(),
-  pcb_group_id: z84.string().optional(),
-  subcircuit_id: z84.string().optional()
-}).describe("Defines a ground plane on the PCB");
-expectTypesMatch(true);
-var pcb_ground_plane_region = z85.object({
-  type: z85.literal("pcb_ground_plane_region"),
-  pcb_ground_plane_region_id: getZodPrefixedIdWithDefault(
-    "pcb_ground_plane_region"
-  ),
-  pcb_ground_plane_id: z85.string(),
-  pcb_group_id: z85.string().optional(),
-  subcircuit_id: z85.string().optional(),
-  layer: layer_ref,
-  points: z85.array(point)
-}).describe("Defines a polygon region of a ground plane");
-expectTypesMatch(true);
-var pcb_thermal_spoke = z86.object({
-  type: z86.literal("pcb_thermal_spoke"),
-  pcb_thermal_spoke_id: getZodPrefixedIdWithDefault("pcb_thermal_spoke"),
-  pcb_ground_plane_id: z86.string(),
-  shape: z86.string(),
-  spoke_count: z86.number(),
-  spoke_thickness: distance,
-  spoke_inner_diameter: distance,
-  spoke_outer_diameter: distance,
-  pcb_plated_hole_id: z86.string().optional(),
-  subcircuit_id: z86.string().optional()
-}).describe("Pattern for connecting a ground plane to a plated hole");
-expectTypesMatch(true);
-var cad_component = z87.object({
-  type: z87.literal("cad_component"),
-  cad_component_id: z87.string(),
-  pcb_component_id: z87.string(),
-  source_component_id: z87.string(),
-  position: point3,
-  rotation: point3.optional(),
-  size: point3.optional(),
-  layer: layer_ref.optional(),
-  subcircuit_id: z87.string().optional(),
-  // These are all ways to generate/load the 3d model
-  footprinter_string: z87.string().optional(),
-  model_obj_url: z87.string().optional(),
-  model_stl_url: z87.string().optional(),
-  model_3mf_url: z87.string().optional(),
-  model_jscad: z87.any().optional()
-}).describe("Defines a component on the PCB");
-expectTypesMatch(true);
-var any_circuit_element = z88.union([
-  source_trace,
-  source_port,
-  any_source_component,
-  source_net,
-  source_group,
-  source_simple_chip,
-  source_simple_capacitor,
-  source_simple_diode,
-  source_simple_led,
-  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_test_point,
-  source_simple_mosfet,
-  source_simple_potentiometer,
-  source_simple_push_button,
-  source_pcb_ground_plane,
-  source_project_metadata,
-  pcb_component,
-  pcb_hole,
-  pcb_missing_footprint_error,
-  pcb_manual_edit_conflict_warning,
-  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,
-  pcb_breakout_point,
-  pcb_cutout,
-  pcb_ground_plane,
-  pcb_ground_plane_region,
-  pcb_thermal_spoke,
-  schematic_box,
-  schematic_text,
-  schematic_line,
-  schematic_component,
-  schematic_port,
-  schematic_trace,
-  schematic_path,
-  schematic_error,
-  schematic_layout_error,
-  schematic_net_label,
-  schematic_debug_object,
-  schematic_voltage_probe,
-  schematic_manual_edit_conflict_warning,
-  schematic_group,
-  cad_component
-]);
-var any_soup_element = any_circuit_element;
-expectTypesMatch(true);
-expectStringUnionsMatch(true);
-
-// 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/circuit-json-util/dist/index.js
-import { applyToPoint, decomposeTSR } from "transformation-matrix";
-function connect(map, a, b) {
-  if (!a || !b)
-    return;
-  let setA = map.get(a);
-  if (!setA) {
-    setA = /* @__PURE__ */ new Set();
-    map.set(a, setA);
-  }
-  setA.add(b);
-  let setB = map.get(b);
-  if (!setB) {
-    setB = /* @__PURE__ */ new Set();
-    map.set(b, setB);
-  }
-  setB.add(a);
-}
-function buildSubtree(soup, opts) {
-  if (!opts.subcircuit_id && !opts.source_group_id)
-    return [...soup];
-  const idMap = /* @__PURE__ */ new Map();
-  for (const elm of soup) {
-    const idVal = elm[`${elm.type}_id`];
-    if (typeof idVal === "string") {
-      idMap.set(idVal, elm);
-    }
-  }
-  const adj = /* @__PURE__ */ new Map();
-  for (const elm of soup) {
-    const entries = Object.entries(elm);
-    for (const [key, val] of entries) {
-      if (key.endsWith("_id") && typeof val === "string") {
-        const other = idMap.get(val);
-        connect(adj, elm, other);
-      } else if (key.endsWith("_ids") && Array.isArray(val)) {
-        for (const v of val) {
-          if (typeof v === "string") {
-            const other = idMap.get(v);
-            connect(adj, elm, other);
-          }
-        }
-      }
-    }
-  }
-  const queue = [];
-  const included = /* @__PURE__ */ new Set();
-  for (const elm of soup) {
-    if (opts.subcircuit_id && elm.subcircuit_id === opts.subcircuit_id || opts.source_group_id && (elm.source_group_id === opts.source_group_id || Array.isArray(elm.member_source_group_ids) && elm.member_source_group_ids.includes(
-      opts.source_group_id
-    ))) {
-      queue.push(elm);
-      included.add(elm);
-    }
-  }
-  while (queue.length > 0) {
-    const elm = queue.shift();
-    const neighbors = adj.get(elm);
-    if (!neighbors)
-      continue;
-    for (const n of neighbors) {
-      if (!included.has(n)) {
-        included.add(n);
-        queue.push(n);
-      }
-    }
-  }
-  return soup.filter((e) => included.has(e));
-}
-var cju = (circuitJsonInput, options = {}) => {
-  const circuitJson = circuitJsonInput;
-  let internalStore = circuitJson._internal_store;
-  if (!internalStore) {
-    internalStore = {
-      counts: {},
-      editCount: 0
-    };
-    circuitJson._internal_store = internalStore;
-    for (const elm of circuitJson) {
-      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, prop) => {
-        if (prop === "toArray") {
-          return () => {
-            ;
-            circuitJson.editCount = internalStore.editCount;
-            return circuitJson;
-          };
-        }
-        if (prop === "editCount") {
-          return internalStore.editCount;
-        }
-        if (prop === "subtree") {
-          return (opts) => cju(buildSubtree(circuitJson, opts), options);
-        }
-        const component_type = prop;
-        return {
-          get: (id) => circuitJson.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 = circuitJson.find(
-              (e) => e.type === join_type && e[join_key] === using[join_key]
-            );
-            if (!joiner)
-              return null;
-            return circuitJson.find(
-              (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
-            );
-          },
-          getWhere: (where) => {
-            const keys = Object.keys(where);
-            return circuitJson.find(
-              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
-            );
-          },
-          list: (where) => {
-            const keys = !where ? [] : Object.keys(where);
-            return circuitJson.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);
-            }
-            circuitJson.push(newElm);
-            internalStore.editCount++;
-            return newElm;
-          },
-          delete: (id) => {
-            const elm = circuitJson.find(
-              (e) => e[`${component_type}_id`] === id
-            );
-            if (!elm)
-              return;
-            circuitJson.splice(circuitJson.indexOf(elm), 1);
-            internalStore.editCount++;
-          },
-          update: (id, newProps) => {
-            const elm = circuitJson.find(
-              (e) => e.type === component_type && e[`${component_type}_id`] === id
-            );
-            if (!elm)
-              return null;
-            Object.assign(elm, newProps);
-            internalStore.editCount++;
-            return elm;
-          },
-          select: (selector) => {
-            if (component_type === "source_component") {
-              return circuitJson.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 = circuitJson.find(
-                (e) => e.type === "source_component" && e.name === component_name
-              );
-              if (!source_component)
-                return null;
-              const source_port2 = circuitJson.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 circuitJson.find(
-                  (e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id
-                );
-              } else if (component_type === "schematic_port") {
-                return circuitJson.find(
-                  (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
-                );
-              }
-            }
-          }
-        };
-      }
-    }
-  );
-  return su2;
-};
-cju.unparsed = cju;
-var su = cju;
-function createIdKey(element) {
-  const type = element.type;
-  return `${type}:${element[`${type}_id`]}`;
-}
-var cjuIndexed = (soup, options = {}) => {
-  let internalStore = soup._internal_store_indexed;
-  if (!internalStore) {
-    internalStore = {
-      counts: {},
-      editCount: 0,
-      indexes: {}
-    };
-    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 indexConfig = options.indexConfig || {};
-    const indexes = internalStore.indexes;
-    if (indexConfig.byId) {
-      indexes.byId = /* @__PURE__ */ new Map();
-    }
-    if (indexConfig.byType) {
-      indexes.byType = /* @__PURE__ */ new Map();
-    }
-    if (indexConfig.byRelation) {
-      indexes.byRelation = /* @__PURE__ */ new Map();
-    }
-    if (indexConfig.bySubcircuit) {
-      indexes.bySubcircuit = /* @__PURE__ */ new Map();
-    }
-    if (indexConfig.byCustomField && indexConfig.byCustomField.length > 0) {
-      indexes.byCustomField = /* @__PURE__ */ new Map();
-      for (const field of indexConfig.byCustomField) {
-        indexes.byCustomField.set(field, /* @__PURE__ */ new Map());
-      }
-    }
-    for (const element of soup) {
-      if (indexConfig.byId) {
-        const idKey = createIdKey(element);
-        indexes.byId.set(idKey, element);
-      }
-      if (indexConfig.byType) {
-        const elementsOfType = indexes.byType.get(element.type) || [];
-        elementsOfType.push(element);
-        indexes.byType.set(element.type, elementsOfType);
-      }
-      if (indexConfig.byRelation) {
-        const elementEntries = Object.entries(element);
-        for (const [key, value] of elementEntries) {
-          if (key.endsWith("_id") && key !== `${element.type}_id` && typeof value === "string") {
-            const relationTypeMap = indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
-            const relatedElements = relationTypeMap.get(value) || [];
-            relatedElements.push(element);
-            relationTypeMap.set(value, relatedElements);
-            indexes.byRelation.set(key, relationTypeMap);
-          }
-        }
-      }
-      if (indexConfig.bySubcircuit && "subcircuit_id" in element) {
-        const subcircuitId = element.subcircuit_id;
-        if (subcircuitId && typeof subcircuitId === "string") {
-          const subcircuitElements = indexes.bySubcircuit.get(subcircuitId) || [];
-          subcircuitElements.push(element);
-          indexes.bySubcircuit.set(subcircuitId, subcircuitElements);
-        }
-      }
-      if (indexConfig.byCustomField && indexes.byCustomField) {
-        for (const field of indexConfig.byCustomField) {
-          if (field in element) {
-            const fieldValue = element[field];
-            if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
-              const fieldValueStr = String(fieldValue);
-              const fieldMap = indexes.byCustomField.get(field);
-              const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
-              elementsWithFieldValue.push(element);
-              fieldMap.set(fieldValueStr, elementsWithFieldValue);
-            }
-          }
-        }
-      }
-    }
-    ;
-    soup._internal_store_indexed = internalStore;
-  }
-  const suIndexed = new Proxy(
-    {},
-    {
-      get: (proxy_target, prop) => {
-        if (prop === "toArray") {
-          return () => {
-            ;
-            soup.editCount = internalStore.editCount;
-            return soup;
-          };
-        }
-        if (prop === "editCount") {
-          return internalStore.editCount;
-        }
-        const component_type = prop;
-        return {
-          get: (id) => {
-            const indexConfig = options.indexConfig || {};
-            if (indexConfig.byId && internalStore.indexes.byId) {
-              return internalStore.indexes.byId.get(
-                `${component_type}:${id}`
-              ) || null;
-            }
-            if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              return elementsOfType.find(
-                (e) => e[`${component_type}_id`] === id
-              ) || null;
-            }
-            return soup.find(
-              (e) => e.type === component_type && e[`${component_type}_id`] === id
-            ) || null;
-          },
-          getUsing: (using) => {
-            const indexConfig = options.indexConfig || {};
-            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", "");
-            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
-              const relationMap = internalStore.indexes.byRelation.get(join_key);
-              if (relationMap) {
-                const relatedElements = relationMap.get(using[join_key]) || [];
-                const joiner2 = relatedElements.find((e) => e.type === join_type);
-                if (!joiner2)
-                  return null;
-                const joinerId = joiner2[`${component_type}_id`];
-                if (indexConfig.byId && internalStore.indexes.byId) {
-                  return internalStore.indexes.byId.get(
-                    `${component_type}:${joinerId}`
-                  ) || null;
-                }
-                if (indexConfig.byType && internalStore.indexes.byType) {
-                  const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-                  return elementsOfType.find(
-                    (e) => e[`${component_type}_id`] === joinerId
-                  ) || null;
-                }
-                return soup.find(
-                  (e) => e.type === component_type && e[`${component_type}_id`] === joinerId
-                ) || null;
-              }
-            }
-            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`]
-            ) || null;
-          },
-          getWhere: (where) => {
-            const indexConfig = options.indexConfig || {};
-            const keys = Object.keys(where);
-            if (keys.length === 1 && indexConfig.byCustomField && internalStore.indexes.byCustomField) {
-              const field = keys[0];
-              const fieldMap = internalStore.indexes.byCustomField.get(field);
-              if (fieldMap) {
-                const fieldValue = String(where[field]);
-                const elementsWithFieldValue = fieldMap.get(fieldValue) || [];
-                return elementsWithFieldValue.find(
-                  (e) => e.type === component_type
-                ) || null;
-              }
-            }
-            if ("subcircuit_id" in where && indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit) {
-              const subcircuitId = where.subcircuit_id;
-              const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
-              return subcircuitElements.find(
-                (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
-              ) || null;
-            }
-            if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              return elementsOfType.find(
-                (e) => keys.every((key) => e[key] === where[key])
-              ) || null;
-            }
-            return soup.find(
-              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
-            ) || null;
-          },
-          list: (where) => {
-            const indexConfig = options.indexConfig || {};
-            const keys = !where ? [] : Object.keys(where);
-            if (keys.length === 0 && indexConfig.byType && internalStore.indexes.byType) {
-              return internalStore.indexes.byType.get(component_type) || [];
-            }
-            if (keys.length === 1 && keys[0] === "subcircuit_id" && indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit) {
-              const subcircuitId = where.subcircuit_id;
-              const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
-              return subcircuitElements.filter(
-                (e) => e.type === component_type
-              );
-            }
-            let elementsToFilter;
-            if (indexConfig.byType && internalStore.indexes.byType) {
-              elementsToFilter = internalStore.indexes.byType.get(component_type) || [];
-            } else {
-              elementsToFilter = soup.filter((e) => e.type === component_type);
-            }
-            if (keys.length > 0) {
-              return elementsToFilter.filter(
-                (e) => keys.every((key) => e[key] === where[key])
-              );
-            }
-            return elementsToFilter;
-          },
-          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);
-            internalStore.editCount++;
-            const indexConfig = options.indexConfig || {};
-            if (indexConfig.byId && internalStore.indexes.byId) {
-              const idKey = createIdKey(newElm);
-              internalStore.indexes.byId.set(idKey, newElm);
-            }
-            if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              elementsOfType.push(newElm);
-              internalStore.indexes.byType.set(component_type, elementsOfType);
-            }
-            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
-              const elementEntries = Object.entries(newElm);
-              for (const [key, value] of elementEntries) {
-                if (key.endsWith("_id") && key !== `${newElm.type}_id` && typeof value === "string") {
-                  const relationTypeMap = internalStore.indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
-                  const relatedElements = relationTypeMap.get(value) || [];
-                  relatedElements.push(newElm);
-                  relationTypeMap.set(value, relatedElements);
-                  internalStore.indexes.byRelation.set(key, relationTypeMap);
-                }
-              }
-            }
-            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in newElm) {
-              const subcircuitId = newElm.subcircuit_id;
-              if (subcircuitId && typeof subcircuitId === "string") {
-                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
-                subcircuitElements.push(newElm);
-                internalStore.indexes.bySubcircuit.set(
-                  subcircuitId,
-                  subcircuitElements
-                );
-              }
-            }
-            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
-              for (const field of indexConfig.byCustomField) {
-                if (field in newElm) {
-                  const fieldValue = newElm[field];
-                  if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
-                    const fieldValueStr = String(fieldValue);
-                    const fieldMap = internalStore.indexes.byCustomField.get(field);
-                    const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
-                    elementsWithFieldValue.push(newElm);
-                    fieldMap.set(fieldValueStr, elementsWithFieldValue);
-                  }
-                }
-              }
-            }
-            return newElm;
-          },
-          delete: (id) => {
-            const indexConfig = options.indexConfig || {};
-            let elm;
-            if (indexConfig.byId && internalStore.indexes.byId) {
-              elm = internalStore.indexes.byId.get(`${component_type}:${id}`);
-            } else if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              elm = elementsOfType.find(
-                (e) => e[`${component_type}_id`] === id
-              );
-            } else {
-              elm = soup.find((e) => e[`${component_type}_id`] === id);
-            }
-            if (!elm)
-              return;
-            const elmIndex = soup.indexOf(elm);
-            if (elmIndex >= 0) {
-              soup.splice(elmIndex, 1);
-              internalStore.editCount++;
-            }
-            if (indexConfig.byId && internalStore.indexes.byId) {
-              const idKey = createIdKey(elm);
-              internalStore.indexes.byId.delete(idKey);
-            }
-            if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              const filteredElements = elementsOfType.filter(
-                (e) => e[`${component_type}_id`] !== id
-              );
-              internalStore.indexes.byType.set(component_type, filteredElements);
-            }
-            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
-              for (const [
-                relationKey,
-                relationMap
-              ] of internalStore.indexes.byRelation.entries()) {
-                for (const [relationValue, elements] of relationMap.entries()) {
-                  const updatedElements = elements.filter((e) => e !== elm);
-                  if (updatedElements.length === 0) {
-                    relationMap.delete(relationValue);
-                  } else {
-                    relationMap.set(relationValue, updatedElements);
-                  }
-                }
-              }
-            }
-            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm) {
-              const subcircuitId = elm.subcircuit_id;
-              if (subcircuitId) {
-                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
-                const updatedElements = subcircuitElements.filter(
-                  (e) => e !== elm
-                );
-                if (updatedElements.length === 0) {
-                  internalStore.indexes.bySubcircuit.delete(subcircuitId);
-                } else {
-                  internalStore.indexes.bySubcircuit.set(
-                    subcircuitId,
-                    updatedElements
-                  );
-                }
-              }
-            }
-            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
-              for (const fieldMap of internalStore.indexes.byCustomField.values()) {
-                for (const [fieldValue, elements] of fieldMap.entries()) {
-                  const updatedElements = elements.filter((e) => e !== elm);
-                  if (updatedElements.length === 0) {
-                    fieldMap.delete(fieldValue);
-                  } else {
-                    fieldMap.set(fieldValue, updatedElements);
-                  }
-                }
-              }
-            }
-          },
-          update: (id, newProps) => {
-            const indexConfig = options.indexConfig || {};
-            let elm;
-            if (indexConfig.byId && internalStore.indexes.byId) {
-              elm = internalStore.indexes.byId.get(`${component_type}:${id}`);
-            } else if (indexConfig.byType && internalStore.indexes.byType) {
-              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
-              elm = elementsOfType.find(
-                (e) => e[`${component_type}_id`] === id
-              );
-            } else {
-              elm = soup.find(
-                (e) => e.type === component_type && e[`${component_type}_id`] === id
-              );
-            }
-            if (!elm)
-              return null;
-            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
-              const elementEntries = Object.entries(elm);
-              for (const [key, value] of elementEntries) {
-                if (key.endsWith("_id") && key !== `${elm.type}_id` && typeof value === "string") {
-                  if (key in newProps && newProps[key] !== value) {
-                    const relationTypeMap = internalStore.indexes.byRelation.get(key);
-                    if (relationTypeMap) {
-                      const relatedElements = relationTypeMap.get(value) || [];
-                      const updatedElements = relatedElements.filter(
-                        (e) => e !== elm
-                      );
-                      if (updatedElements.length === 0) {
-                        relationTypeMap.delete(value);
-                      } else {
-                        relationTypeMap.set(value, updatedElements);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm && "subcircuit_id" in newProps) {
-              const oldSubcircuitId = elm.subcircuit_id;
-              const newSubcircuitId = newProps.subcircuit_id;
-              if (oldSubcircuitId !== newSubcircuitId) {
-                const subcircuitElements = internalStore.indexes.bySubcircuit.get(oldSubcircuitId) || [];
-                const updatedElements = subcircuitElements.filter(
-                  (e) => e !== elm
-                );
-                if (updatedElements.length === 0) {
-                  internalStore.indexes.bySubcircuit.delete(oldSubcircuitId);
-                } else {
-                  internalStore.indexes.bySubcircuit.set(
-                    oldSubcircuitId,
-                    updatedElements
-                  );
-                }
-              }
-            }
-            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
-              for (const field of indexConfig.byCustomField) {
-                if (field in elm && field in newProps && elm[field] !== newProps[field]) {
-                  const fieldMap = internalStore.indexes.byCustomField.get(field);
-                  if (fieldMap) {
-                    const oldValue = String(elm[field]);
-                    const elements = fieldMap.get(oldValue) || [];
-                    const updatedElements = elements.filter((e) => e !== elm);
-                    if (updatedElements.length === 0) {
-                      fieldMap.delete(oldValue);
-                    } else {
-                      fieldMap.set(oldValue, updatedElements);
-                    }
-                  }
-                }
-              }
-            }
-            Object.assign(elm, newProps);
-            internalStore.editCount++;
-            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
-              const elementEntries = Object.entries(elm);
-              for (const [key, value] of elementEntries) {
-                if (key.endsWith("_id") && key !== `${elm.type}_id` && typeof value === "string") {
-                  if (key in newProps) {
-                    const relationTypeMap = internalStore.indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
-                    const relatedElements = relationTypeMap.get(value) || [];
-                    if (!relatedElements.includes(elm)) {
-                      relatedElements.push(elm);
-                      relationTypeMap.set(value, relatedElements);
-                      internalStore.indexes.byRelation.set(key, relationTypeMap);
-                    }
-                  }
-                }
-              }
-            }
-            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm && "subcircuit_id" in newProps) {
-              const subcircuitId = elm.subcircuit_id;
-              if (subcircuitId && typeof subcircuitId === "string") {
-                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
-                if (!subcircuitElements.includes(elm)) {
-                  subcircuitElements.push(elm);
-                  internalStore.indexes.bySubcircuit.set(
-                    subcircuitId,
-                    subcircuitElements
-                  );
-                }
-              }
-            }
-            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
-              for (const field of indexConfig.byCustomField) {
-                if (field in elm && field in newProps) {
-                  const fieldValue = elm[field];
-                  if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
-                    const fieldValueStr = String(fieldValue);
-                    const fieldMap = internalStore.indexes.byCustomField.get(field);
-                    const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
-                    if (!elementsWithFieldValue.includes(elm)) {
-                      elementsWithFieldValue.push(elm);
-                      fieldMap.set(fieldValueStr, elementsWithFieldValue);
-                    }
-                  }
-                }
-              }
-            }
-            return elm;
-          },
-          select: (selector) => {
-            if (component_type === "source_component") {
-              return soup.find(
-                (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
-              ) || null;
-            } 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
-                ) || null;
-              } else if (component_type === "schematic_port") {
-                return soup.find(
-                  (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
-                ) || null;
-              }
-            }
-            return null;
-          }
-        };
-      }
-    }
-  );
-  return suIndexed;
-};
-cjuIndexed.unparsed = cjuIndexed;
-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: Number(elm.x),
-      y: Number(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/convert-easyeda-json-to-tscircuit-soup-json.ts
-import { compose, scale, translate, applyToPoint as applyToPoint2 } from "transformation-matrix";
-import { mm } from "@tscircuit/mm";
-
-// lib/utils/easyeda-unit-to-mm.ts
-var mil10ToMm = (value) => value * 10 * 0.0254;
-
-// lib/convert-easyeda-json-to-tscircuit-soup-json.ts
-import { normalizePinLabels } from "@tscircuit/core";
-var mil2mm = (mil) => {
-  if (typeof mil === "number") return mm(`${mil}mil`);
-  if (mil.match(/^\d+$/)) return mm(`${mil}mil`);
-  return mm(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 handleHoleCutout = (hole, index) => {
-  return pcb_cutout.parse({
-    type: "pcb_cutout",
-    pcb_cutout_id: `pcb_cutout_from_hole_${index + 1}`,
-    shape: "circle",
-    center: { x: milx10(hole.center.x), y: milx10(hole.center.y) },
-    radius: milx10(hole.radius)
-  });
-};
-var handleVia = (via, index) => {
-  return pcb_via.parse({
-    type: "pcb_via",
-    pcb_via_id: `pcb_via_${index + 1}`,
-    x: milx10(via.center.x),
-    y: milx10(via.center.y),
-    outer_diameter: milx10(via.outerDiameter),
-    hole_diameter: milx10(via.holeDiameter),
-    layers: ["top", "bottom"]
-  });
-};
-var handleCutout = (solidRegion, index) => {
-  return pcb_cutout.parse({
-    type: "pcb_cutout",
-    pcb_cutout_id: `pcb_cutout_${index + 1}`,
-    shape: "polygon",
-    points: solidRegion.points.map((p) => ({
-      x: milx10(p.x),
-      y: milx10(p.y)
-    }))
-  });
-};
-var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
-  const circuitElements = [];
-  const source_component = any_source_component.parse({
-    type: "source_component",
-    source_component_id: "source_component_1",
-    name: "U1",
-    ftype: "simple_chip"
-  });
-  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_chip",
-    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"
-  });
-  circuitElements.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", "")
-    );
-    circuitElements.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)
-        };
-      }
-      circuitElements.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}`
-      });
-      circuitElements.push(parsedPcbSmtpad);
-    }
-  });
-  easyEdaJson.packageDetail.dataStr.shape.filter(
-    (shape) => shape.type === "HOLE"
-  ).forEach((h, index) => {
-    circuitElements.push(handleHole(h, index));
-    circuitElements.push(handleHoleCutout(h, index));
-  });
-  easyEdaJson.packageDetail.dataStr.shape.filter((shape) => shape.type === "VIA").forEach((v, index) => {
-    circuitElements.push(handleVia(v, index));
-  });
-  easyEdaJson.packageDetail.dataStr.shape.filter(
-    (shape) => shape.type === "SOLIDREGION" && shape.fillStyle === "cutout"
-  ).forEach((sr, index) => {
-    circuitElements.push(handleCutout(sr, index));
-  });
-  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
-    if (shape.type === "TRACK") {
-      circuitElements.push(handleSilkscreenPath(shape, index));
-    } else if (shape.type === "ARC") {
-      circuitElements.push(handleSilkscreenArc(shape, index));
-    } else if (shape.type === "TEXT") {
-      circuitElements.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);
-    circuitElements.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)
-      circuitElements.filter((e) => e.type !== "pcb_component")
-    );
-    const matrix = compose(
-      translate(-bounds.center.x, bounds.center.y),
-      scale(1, -1)
-    );
-    transformPCBElements(circuitElements, matrix);
-    for (const e of circuitElements) {
-      if (e.type === "pcb_cutout") {
-        if (e.shape === "polygon") {
-          e.points = e.points.map((p) => applyToPoint2(matrix, p));
-        } else {
-          e.center = applyToPoint2(matrix, e.center);
-        }
-      }
-    }
-    pcb_component2.center = { x: 0, y: 0 };
-  }
-  return circuitElements;
-};
-var convertEasyEdaJsonToTscircuitSoupJson = convertEasyEdaJsonToCircuitJson;
-
-// 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/schemas/easy-eda-json-schema.ts
-import { z as z91 } from "zod";
-
-// lib/schemas/package-detail-shape-schema.ts
-import { z as z89 } from "zod";
-var tenthmil = z89.union([z89.number(), z89.string()]).optional().transform(
-  (n) => typeof n === "string" && n.endsWith("mil") ? n : `${Number.parseFloat(n) * 10}mil`
-).pipe(z89.string());
-var PointSchema = z89.any().transform((p) => {
-  if (Array.isArray(p)) {
-    const [x, y] = p;
-    return { x, y };
-  }
-  if (typeof p === "object") {
-    return p;
-  }
-  throw new Error(`Invalid point: ${p}`);
-}).pipe(
-  z89.object({
-    x: z89.number(),
-    y: z89.number()
-  })
-);
-var BaseShapeSchema = z89.object({
-  type: z89.string(),
-  id: z89.string().optional(),
-  layer: z89.coerce.number().optional()
-});
-var TrackSchema = BaseShapeSchema.extend({
-  type: z89.literal("TRACK"),
-  width: z89.coerce.number(),
-  points: z89.array(PointSchema)
-});
-var PadSchema = BaseShapeSchema.extend({
-  type: z89.literal("PAD"),
-  shape: z89.enum(["RECT", "ELLIPSE", "OVAL"]),
-  center: z89.object({
-    x: tenthmil,
-    y: tenthmil
-  }),
-  width: tenthmil,
-  height: tenthmil,
-  layermask: z89.number(),
-  net: z89.union([z89.string(), z89.number()]).optional(),
-  number: z89.union([z89.string(), z89.number()]),
-  holeRadius: tenthmil,
-  points: z89.array(PointSchema).optional(),
-  rotation: z89.number().optional(),
-  plated: z89.boolean()
-});
-var ArcSchema = BaseShapeSchema.extend({
-  type: z89.literal("ARC"),
-  width: z89.number(),
-  start: PointSchema,
-  end: PointSchema,
-  radiusX: z89.number(),
-  radiusY: z89.number(),
-  largeArc: z89.boolean(),
-  sweepDirection: z89.enum(["CW", "CCW"])
-});
-var CircleSchema = BaseShapeSchema.extend({
-  type: z89.literal("CIRCLE"),
-  center: PointSchema,
-  radius: z89.number(),
-  width: z89.number()
-});
-var SolidRegionSchema = BaseShapeSchema.extend({
-  type: z89.literal("SOLIDREGION"),
-  layermask: z89.number(),
-  points: z89.array(PointSchema),
-  fillStyle: z89.string()
-});
-var SVGNodeSchema = BaseShapeSchema.extend({
-  type: z89.literal("SVGNODE"),
-  svgData: z89.object({
-    gId: z89.string(),
-    nodeName: z89.string(),
-    nodeType: z89.number(),
-    layerid: z89.string(),
-    attrs: z89.record(z89.string(), z89.string()),
-    childNodes: z89.array(z89.unknown())
-  })
-});
-var HoleSchema = BaseShapeSchema.extend({
-  type: z89.literal("HOLE"),
-  center: PointSchema,
-  radius: z89.number()
-});
-var ViaSchema = BaseShapeSchema.extend({
-  type: z89.literal("VIA"),
-  center: PointSchema,
-  outerDiameter: z89.number(),
-  holeDiameter: z89.number()
-});
-var RectSchema = BaseShapeSchema.extend({
-  type: z89.literal("RECT"),
-  x: tenthmil,
-  y: tenthmil,
-  width: tenthmil,
-  height: tenthmil,
-  lineWidth: z89.number(),
-  fillStyle: z89.string(),
-  rotation: z89.number().optional()
-});
-var TextSchema = BaseShapeSchema.extend({
-  type: z89.literal("TEXT"),
-  text: z89.string(),
-  x: tenthmil,
-  y: tenthmil,
-  size_mm: z89.number(),
-  rotation: z89.number().optional(),
-  layer: z89.number().optional(),
-  textAnchor: z89.enum(["L", "C", "R", ""]).optional().transform((val) => val === "" ? void 0 : val),
-  font: z89.string().optional()
-});
-var PackageDetailShapeSchema = z89.discriminatedUnion("type", [
-  TrackSchema,
-  PadSchema,
-  ArcSchema,
-  CircleSchema,
-  SolidRegionSchema,
-  SVGNodeSchema,
-  HoleSchema,
-  ViaSchema,
-  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 = z89.object({
-  type: z89.string(),
-  data: z89.string()
-}).transform((shape) => {
-  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) => Number.isNaN(Number(p)) ? p : Number(p));
-      const center = { x: centerX, y: centerY };
-      let points;
-      if (padShape === "RECT") {
-        points = parsePoints(rest[0]);
-      }
-      const r = Number(rest[1]);
-      const rotation2 = Number.isNaN(r) ? void 0 : r;
-      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",
-        // sweepFlag=1 means clockwise (CW), sweepFlag=0 means counter-clockwise (CCW)
-        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 "VIA": {
-      const [x, y, outerDiameter, , holeDiameter, id] = shape.data.split("~");
-      const center = [Number(x), Number(y)];
-      return ViaSchema.parse({
-        type: "VIA",
-        center,
-        outerDiameter: Number(outerDiameter),
-        holeDiameter: Number(holeDiameter),
-        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("~");
-      const r = rotation2 ? Number(rotation2) : void 0;
-      return RectSchema.parse({
-        type: "RECT",
-        x,
-        y,
-        width,
-        height,
-        lineWidth: Number(lineWidth),
-        id,
-        rotation: Number.isNaN(r) ? void 0 : r,
-        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("~");
-      const r = rotation2 ? Number(rotation2) : void 0;
-      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: Number.isNaN(r) ? void 0 : r,
-        textAnchor,
-        font: font || void 0
-      });
-    }
-    default:
-      throw new Error(`Unknown shape type: ${shape.type}`);
-  }
-}).pipe(PackageDetailShapeSchema);
-var ShapesArraySchema = z89.array(ShapeItemSchema);
-
-// lib/schemas/single-letter-shape-schema.ts
-import { z as z90 } from "zod";
-var PointSchema2 = z90.object({
-  x: z90.number(),
-  y: z90.number()
-});
-var RectangleShapeOutputSchema = z90.object({
-  type: z90.literal("RECTANGLE"),
-  position: PointSchema2,
-  width: z90.number(),
-  height: z90.number(),
-  color: z90.string(),
-  lineWidth: z90.number(),
-  id: z90.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 = z90.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
-var EllipseShapeOutputSchema = z90.object({
-  type: z90.literal("ELLIPSE"),
-  center: PointSchema2,
-  radiusX: z90.number(),
-  radiusY: z90.number(),
-  color: z90.string(),
-  lineWidth: z90.number(),
-  id: z90.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 = z90.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
-var ArcShapeOutputSchema = z90.object({
-  type: z90.literal("ARC"),
-  start: PointSchema2,
-  end: PointSchema2,
-  radius: z90.number(),
-  sweepFlag: z90.boolean(),
-  color: z90.string(),
-  lineWidth: z90.number(),
-  id: z90.string()
-});
-var parseArc = (str) => {
-  const [, pathData, color, lineWidth, , , id] = str.split("~");
-  const parts = pathData.split(" ");
-  const x1 = Number(parts[1]) || 0;
-  const y1 = Number(parts[2]) || 0;
-  const radius = Number(parts[4]) || 0;
-  const sweepFlag = parts[7] === "1";
-  const x2 = Number(parts[8]) || 0;
-  const y2 = Number(parts[9]) || 0;
-  const parsedLineWidth = Number(lineWidth);
-  const finalLineWidth = Number.isNaN(parsedLineWidth) ? 1 : parsedLineWidth;
-  return {
-    type: "ARC",
-    start: { x: x1, y: y1 },
-    end: { x: x2, y: y2 },
-    radius,
-    sweepFlag,
-    color: color || "#880000",
-    // Default color
-    lineWidth: finalLineWidth,
-    id: id || "gge1"
-  };
-};
-var ArcShapeSchema = z90.string().startsWith("A~").transform(parseArc).pipe(ArcShapeOutputSchema);
-var PinShapeOutputSchema = z90.object({
-  type: z90.literal("PIN"),
-  visibility: z90.enum(["show", "hide"]),
-  pinNumber: z90.union([z90.string(), z90.number()]),
-  x: z90.number(),
-  y: z90.number(),
-  rotation: z90.number(),
-  id: z90.string(),
-  label: z90.string(),
-  labelColor: z90.string(),
-  path: z90.string(),
-  arrow: z90.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 path2 = pathMatch ? pathMatch[1] : "";
-  const arrowMatch = pinString.match(/\^\^0~(.+)$/);
-  const arrow = arrowMatch ? arrowMatch[1] : "";
-  const r = Number.parseFloat(rotation2);
-  return {
-    type: "PIN",
-    visibility,
-    id,
-    pinNumber: Number.isNaN(Number(pinNumber)) ? pinNumber : Number(pinNumber),
-    x: Number.parseFloat(x),
-    y: Number.parseFloat(y),
-    rotation: Number.isNaN(r) ? 0 : r,
-    label,
-    labelColor,
-    path: path2,
-    arrow
-  };
-};
-var PinShapeSchema = z90.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
-var PolylineShapeOutputSchema = z90.object({
-  type: z90.literal("POLYLINE"),
-  points: z90.array(PointSchema2),
-  color: z90.string(),
-  lineWidth: z90.number(),
-  id: z90.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 = z90.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
-var PolygonShapeOutputSchema = z90.object({
-  type: z90.literal("POLYGON"),
-  points: z90.array(PointSchema2),
-  fillColor: z90.string(),
-  lineWidth: z90.number(),
-  lineColor: z90.string(),
-  id: z90.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 = z90.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
-var PathShapeOutputSchema = z90.object({
-  type: z90.literal("PATH"),
-  pathData: z90.string(),
-  fillColor: z90.string(),
-  strokeWidth: z90.number(),
-  strokeColor: z90.string(),
-  id: z90.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 = z90.string().startsWith("PT~").transform(parsePath).pipe(PathShapeOutputSchema);
-var TextShapeOutputSchema = z90.object({
-  type: z90.literal("TEXT"),
-  alignment: z90.enum(["L", "C", "R"]),
-  x: z90.number(),
-  y: z90.number(),
-  rotation: z90.number(),
-  fontColor: z90.string(),
-  backgroundColor: z90.string().optional(),
-  fontSize: z90.string(),
-  fontWeight: z90.enum(["normal", "bold"]).optional().default("normal"),
-  fontStyle: z90.enum(["normal", "italic"]).optional().default("normal"),
-  fontDecoration: z90.enum(["", "underline"]),
-  content: z90.string(),
-  textType: z90.string(),
-  visibility: z90.enum(["0", "1"]),
-  mirror: z90.string(),
-  id: z90.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 = z90.string().startsWith("T~").transform(parseText).pipe(TextShapeOutputSchema);
-var SingleLetterShapeSchema = z90.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);
-  if (x.startsWith("A~")) return ArcShapeSchema.parse(x);
-  throw new Error(`Invalid shape type: ${x}`);
-}).pipe(
-  z90.union([
-    RectangleShapeOutputSchema,
-    EllipseShapeOutputSchema,
-    PinShapeOutputSchema,
-    PolylineShapeOutputSchema,
-    PolygonShapeOutputSchema,
-    PathShapeOutputSchema,
-    TextShapeOutputSchema,
-    ArcShapeOutputSchema
-  ])
-);
-
-// lib/schemas/easy-eda-json-schema.ts
-var maybeNumber = z91.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(z91.number().nullable().optional());
-var SzlcscSchema = z91.object({
-  id: z91.number(),
-  number: z91.string(),
-  step: z91.number().optional(),
-  min: z91.number().optional(),
-  price: z91.number().optional(),
-  stock: z91.number().optional(),
-  url: z91.string().url().optional(),
-  image: z91.string().optional().optional()
-});
-var LcscSchema = z91.object({
-  id: z91.number(),
-  number: z91.string(),
-  step: z91.number().optional(),
-  min: z91.number().optional(),
-  price: z91.number().optional(),
-  stock: z91.number().optional(),
-  url: z91.string().url().optional()
-});
-var OwnerSchema = z91.object({
-  uuid: z91.string(),
-  username: z91.string(),
-  nickname: z91.string(),
-  avatar: z91.string()
-});
-var HeadSchema = z91.object({
-  docType: z91.preprocess((val) => val == null ? val : String(val), z91.string()),
-  editorVersion: z91.string(),
-  c_para: z91.record(z91.string(), z91.string().nullable()),
-  x: z91.number(),
-  y: z91.number(),
-  puuid: z91.string().optional(),
-  uuid: z91.string(),
-  utime: z91.preprocess((val) => {
-    if (val === "") return 0;
-    if (typeof val === "string") return Number(val);
-    return val;
-  }, z91.number()),
-  importFlag: z91.number().optional(),
-  c_spiceCmd: z91.any().optional(),
-  hasIdFlag: z91.boolean()
-});
-var BBoxSchema = z91.object({
-  x: z91.number(),
-  y: z91.number(),
-  width: z91.number(),
-  height: z91.number()
-});
-var LayerItemSchema = z91.object({
-  name: z91.string(),
-  color: z91.string(),
-  visible: z91.boolean(),
-  active: z91.boolean(),
-  config: z91.boolean(),
-  transparency: z91.boolean()
-});
-var ObjectItemSchema = z91.object({
-  name: z91.string(),
-  visible: z91.boolean(),
-  locked: z91.boolean()
-});
-var DataStrSchema = z91.object({
-  head: HeadSchema,
-  canvas: z91.string(),
-  shape: z91.array(SingleLetterShapeSchema),
-  BBox: BBoxSchema,
-  colors: z91.array(z91.unknown())
-});
-var PackageDetailDataStrSchema = z91.object({
-  head: HeadSchema,
-  canvas: z91.string(),
-  shape: z91.array(z91.string()).transform(
-    (shapes) => shapes.map((shape) => {
-      const [type, ...data] = shape.split("~");
-      return ShapeItemSchema.parse({ type, data: data.join("~") });
-    })
-  ).pipe(z91.array(PackageDetailShapeSchema)),
-  layers: z91.array(z91.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: z91.array(z91.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: z91.array(z91.unknown()).optional()
-});
-var PackageDetailSchema = z91.object({
-  uuid: z91.string(),
-  title: z91.string(),
-  docType: z91.number(),
-  updateTime: z91.number(),
-  owner: OwnerSchema,
-  datastrid: z91.string(),
-  writable: z91.boolean(),
-  dataStr: PackageDetailDataStrSchema
-});
-var EasyEdaJsonSchema = z91.object({
-  uuid: z91.string(),
-  title: z91.string(),
-  description: z91.string(),
-  docType: z91.number(),
-  type: z91.number(),
-  szlcsc: SzlcscSchema,
-  lcsc: LcscSchema,
-  owner: OwnerSchema,
-  tags: z91.array(z91.string()),
-  updateTime: z91.number(),
-  updated_at: z91.string(),
-  dataStr: DataStrSchema,
-  verify: z91.boolean(),
-  SMT: z91.boolean().optional(),
-  datastrid: z91.string(),
-  jlcOnSale: z91.number().optional(),
-  writable: z91.boolean(),
-  isFavorite: z91.boolean(),
-  packageDetail: PackageDetailSchema
-});
-
-// lib/websafe/generate-footprint-tsx.ts
-import { mmStr } from "@tscircuit/mm";
-var generateFootprintTsx = (circuitJson) => {
-  const holes = su(circuitJson).pcb_hole.list();
-  const platedHoles = su(circuitJson).pcb_plated_hole.list();
-  const smtPads = su(circuitJson).pcb_smtpad.list();
-  const vias = su(circuitJson).pcb_via.list();
-  const silkscreenPaths = su(circuitJson).pcb_silkscreen_path.list();
-  const silkscreenTexts = su(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 via of vias) {
-    elementStrings.push(
-      `<via pcbX="${mmStr(via.x)}" pcbY="${mmStr(via.y)}" outerDiameter="${mmStr(via.outer_diameter)}" holeDiameter="${mmStr(via.hole_diameter)}" layers={${JSON.stringify(via.layers)}} />`
-    );
-  }
-  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 cadComponent = circuitJson.find((item) => item.type === "cad_component");
-  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: ${cadComponent?.rotation?.z ?? 0} },
-        positionOffset: { x: 0, y: 0, z: 0 },
-      }}` : ""}
-      {...props}
-    />
-  )
-}
-`.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/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 = rawPn ? normalizeManufacturerPartNumber(rawPn) : "unknown";
-  const sourcePorts = su(circuitJson).source_port.list();
-  const pinLabels = {};
-  const sortedPorts = sourcePorts.sort((a, b) => {
-    const aNum = Number.parseInt(a.name.replace("pin", ""));
-    const bNum = Number.parseInt(b.name.replace("pin", ""));
-    return aNum - bNum;
-  });
-  for (const sourcePort of sortedPorts) {
-    pinLabels[sourcePort.name] = [
-      sourcePort.name,
-      ...sourcePort.port_hints ?? []
-    ];
-  }
-  const [cadComponent] = su(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/convert-easyeda-json-to-various-formats.ts
-import fs from "fs/promises";
-import * as path from "path";
-var convertEasyEdaJsonToVariousFormats = async ({
-  jlcpcbPartNumberOrFilepath,
-  outputFilename,
-  outputFormat
-}) => {
-  let rawEasyEdaJson;
-  if (jlcpcbPartNumberOrFilepath.includes(".") || jlcpcbPartNumberOrFilepath.includes("/")) {
-    rawEasyEdaJson = JSON.parse(
-      await fs.readFile(jlcpcbPartNumberOrFilepath, "utf-8")
-    );
-  } else {
-    rawEasyEdaJson = await fetchEasyEDAComponent(jlcpcbPartNumberOrFilepath);
-  }
-  const tsxExtension = "tsx";
-  if (outputFormat === "ts") outputFormat = tsxExtension;
-  if (!outputFilename && outputFormat) {
-    let filename = path.basename(jlcpcbPartNumberOrFilepath).split(".")[0];
-    if (outputFormat === tsxExtension) {
-      const {
-        dataStr: {
-          head: {
-            c_para: { "Manufacturer Part": manufacturerPartNumber }
-          }
-        }
-      } = rawEasyEdaJson;
-      filename = normalizeManufacturerPartNumber(manufacturerPartNumber);
-    }
-    outputFilename = `${filename}.${outputFormat}`;
-  }
-  if (!outputFilename) {
-    console.log("specify --output file (-o) or --output-format");
-    process.exit(1);
-  }
-  if (outputFilename.endsWith(".raweasy.json")) {
-    await fs.writeFile(outputFilename, JSON.stringify(rawEasyEdaJson, null, 2));
-    console.log(`Saved raw EasyEDA JSON: ${outputFilename}`);
-    return;
-  }
-  try {
-    const betterEasy = EasyEdaJsonSchema.parse(rawEasyEdaJson);
-    const tscircuitSoup = convertEasyEdaJsonToTscircuitSoupJson(betterEasy);
-    if (outputFilename.endsWith(".soup.json") || outputFilename.endsWith(".circuit.json")) {
-      await fs.writeFile(outputFilename, JSON.stringify(tscircuitSoup, null, 2));
-      console.log(
-        `[${jlcpcbPartNumberOrFilepath}]  Converted to circuit json: ${outputFilename}`
-      );
-    } else if (outputFilename.endsWith(".kicad_mod")) {
-      console.log("Conversion to KiCad footprint not yet implemented");
-    } else if (outputFilename.endsWith(".bettereasy.json")) {
-      await fs.writeFile(outputFilename, JSON.stringify(betterEasy, null, 2));
-      console.log(
-        `[${jlcpcbPartNumberOrFilepath}]  Saved better EasyEDA JSON: ${outputFilename}`
-      );
-    } else if (outputFilename.endsWith(".tsx") || outputFilename.endsWith(".ts")) {
-      const tsComp = await convertRawEasyToTsx(rawEasyEdaJson);
-      await fs.writeFile(outputFilename, tsComp);
-      console.log(
-        `[${jlcpcbPartNumberOrFilepath}] Saved TypeScript component: ${outputFilename}`
-      );
-    } else {
-      console.error("Unsupported output format");
-    }
-  } catch (error) {
-    console.error("Error:", error.message);
-    throw error;
-  }
-};
-
-export {
-  fetchEasyEDAComponent,
-  convertEasyEdaJsonToCircuitJson,
-  convertEasyEdaJsonToTscircuitSoupJson,
-  maybeNumber,
-  SzlcscSchema,
-  LcscSchema,
-  OwnerSchema,
-  HeadSchema,
-  BBoxSchema,
-  LayerItemSchema,
-  ObjectItemSchema,
-  DataStrSchema,
-  PackageDetailDataStrSchema,
-  PackageDetailSchema,
-  EasyEdaJsonSchema,
-  normalizeManufacturerPartNumber,
-  convertRawEasyToTsx,
-  convertEasyEdaJsonToVariousFormats
-};
-//# sourceMappingURL=chunk-E6OHT5YV.js.map