@ttsalpha/mirra 0.0.0-stage → 1.0.0

package/dist/plugin/main.js

@@ -0,0 +1,1291 @@
+"use strict";
+(() => {
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+  // ../schema/dist/constants.js
+  var PROTOCOL_VERSION = 1;
+
+  // src/file-info.ts
+  function readFileKey() {
+    try {
+      return figma.fileKey ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  // src/figma/tokens.ts
+  function toRef(name) {
+    return `$${name}`;
+  }
+  function fromRef(ref) {
+    return ref.startsWith("$") ? ref.slice(1) : ref;
+  }
+  function isRef(value) {
+    return typeof value === "string" && value.startsWith("$");
+  }
+  var _variables, _textStyles;
+  var TokenIndex = class {
+    constructor() {
+      __privateAdd(this, _variables, null);
+      __privateAdd(this, _textStyles, null);
+    }
+    async variable(ref) {
+      if (!__privateGet(this, _variables)) {
+        const all = await figma.variables.getLocalVariablesAsync();
+        __privateSet(this, _variables, new Map(all.map((variable) => [variable.name, variable])));
+      }
+      const found = __privateGet(this, _variables).get(fromRef(ref));
+      if (!found) throw new Error(`No variable named "${fromRef(ref)}" in this file`);
+      return found;
+    }
+    async textStyle(ref) {
+      if (!__privateGet(this, _textStyles)) {
+        const all = await figma.getLocalTextStylesAsync();
+        __privateSet(this, _textStyles, new Map(all.map((style) => [style.name, style])));
+      }
+      const found = __privateGet(this, _textStyles).get(fromRef(ref));
+      if (!found) throw new Error(`No text style named "${fromRef(ref)}" in this file`);
+      return found;
+    }
+  };
+  _variables = new WeakMap();
+  _textStyles = new WeakMap();
+  var EMPTY_NAMES = { variable: () => void 0, style: () => void 0 };
+  async function buildNameIndex() {
+    const variables = /* @__PURE__ */ new Map();
+    const styles = /* @__PURE__ */ new Map();
+    for (const variable of await figma.variables.getLocalVariablesAsync()) {
+      variables.set(variable.id, toRef(variable.name));
+    }
+    for (const style of await figma.getLocalTextStylesAsync()) {
+      styles.set(style.id, toRef(style.name));
+    }
+    return { variable: (id) => variables.get(id), style: (id) => styles.get(id) };
+  }
+  async function readTokens() {
+    const variables = await figma.variables.getLocalVariablesAsync();
+    const byId = new Map(variables.map((variable) => [variable.id, variable]));
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+    return {
+      collections: collections.map((collection) => ({
+        name: collection.name,
+        modes: collection.modes.map((mode) => mode.name),
+        variables: variables.filter((variable) => variable.variableCollectionId === collection.id).map((variable) => ({
+          ref: toRef(variable.name),
+          type: variable.resolvedType,
+          values: valuesByMode(variable, collection, byId)
+        }))
+      })),
+      styles: {
+        paint: (await figma.getLocalPaintStylesAsync()).map((style) => ({
+          ref: toRef(style.name),
+          ...solidHex(style.paints) ? { fill: solidHex(style.paints) } : {}
+        })),
+        text: (await figma.getLocalTextStylesAsync()).map((style) => ({
+          ref: toRef(style.name),
+          font: `${style.fontName.family} ${style.fontName.style}`,
+          size: style.fontSize
+        })),
+        effect: (await figma.getLocalEffectStylesAsync()).map((style) => ({
+          ref: toRef(style.name)
+        }))
+      }
+    };
+  }
+  function valuesByMode(variable, collection, byId) {
+    const values = {};
+    for (const mode of collection.modes) {
+      const raw = variable.valuesByMode[mode.modeId];
+      if (raw === void 0) continue;
+      if (typeof raw === "object" && "type" in raw && raw.type === "VARIABLE_ALIAS") {
+        const alias = byId.get(raw.id);
+        values[mode.name] = alias ? toRef(alias.name) : `$unknown:${raw.id}`;
+      } else if (typeof raw === "object" && "r" in raw) {
+        values[mode.name] = hex(raw);
+      } else {
+        values[mode.name] = raw;
+      }
+    }
+    return values;
+  }
+  function solidHex(paints) {
+    const paint = paints[0];
+    return paint && paint.type === "SOLID" ? hex({ ...paint.color, a: paint.opacity ?? 1 }) : void 0;
+  }
+  function hex({ r, g, b, a = 1 }) {
+    const channel = (value) => Math.round(value * 255).toString(16).padStart(2, "0");
+    const rgb = `#${channel(r)}${channel(g)}${channel(b)}`;
+    return a >= 1 ? rgb : `${rgb}${channel(a)}`;
+  }
+
+  // src/figma/values.ts
+  function rgba(hex2) {
+    const digits = hex2.slice(1);
+    const full = digits.length === 3 ? digits.split("").map((digit) => digit + digit).join("") : digits;
+    const value = (start) => parseInt(full.slice(start, start + 2), 16) / 255;
+    return { r: value(0), g: value(2), b: value(4), a: full.length === 8 ? value(6) : 1 };
+  }
+  function toPaints(fill) {
+    if (typeof fill === "string") return [solid(fill)];
+    if (fill.type === "solid") return [solid(fill.color, fill.opacity)];
+    return [
+      {
+        type: fill.kind === "radial" ? "GRADIENT_RADIAL" : "GRADIENT_LINEAR",
+        gradientTransform: gradientTransform(fill.angle ?? 90),
+        gradientStops: fill.stops.map((stop) => ({ position: stop.at, color: rgba(stop.color) }))
+      }
+    ];
+  }
+  function solid(hex2, opacity) {
+    const { r, g, b, a } = rgba(hex2);
+    return { type: "SOLID", color: { r, g, b }, opacity: opacity ?? a };
+  }
+  function gradientTransform(angleDeg) {
+    const radians = angleDeg * Math.PI / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return [
+      [cos, -sin, 0.5 - 0.5 * cos + 0.5 * sin],
+      [sin, cos, 0.5 - 0.5 * sin - 0.5 * cos]
+    ];
+  }
+  function toStrokes(stroke) {
+    const align = (stroke.align ?? "inside").toUpperCase();
+    return {
+      paints: [solid(stroke.color)],
+      weight: stroke.width ?? 1,
+      align
+    };
+  }
+  function toEffects(effects) {
+    return effects.map((effect) => {
+      switch (effect.type) {
+        case "layer-blur":
+          return { type: "LAYER_BLUR", blurType: "NORMAL", radius: effect.radius, visible: true };
+        case "background-blur":
+          return {
+            type: "BACKGROUND_BLUR",
+            blurType: "NORMAL",
+            radius: effect.radius,
+            visible: true
+          };
+        case "shadow":
+          return { type: "DROP_SHADOW", ...shadow(effect) };
+        case "inner-shadow":
+          return { type: "INNER_SHADOW", ...shadow(effect) };
+      }
+    });
+  }
+  function shadow(effect) {
+    return {
+      color: rgba(effect.color ?? "#00000040"),
+      offset: { x: effect.x ?? 0, y: effect.y ?? 0 },
+      radius: effect.blur ?? 0,
+      spread: effect.spread ?? 0,
+      visible: true,
+      blendMode: "NORMAL"
+    };
+  }
+  function toPadding(pad) {
+    if (typeof pad === "number") return { top: pad, right: pad, bottom: pad, left: pad };
+    if (pad.length === 2) {
+      const [vertical, horizontal] = pad;
+      return { top: vertical, right: horizontal, bottom: vertical, left: horizontal };
+    }
+    const [top, right, bottom, left] = pad;
+    return { top, right, bottom, left };
+  }
+  function toRadius(radius) {
+    return typeof radius === "number" ? [radius, radius, radius, radius] : radius;
+  }
+  var PRIMARY_AXIS = {
+    start: "MIN",
+    center: "CENTER",
+    end: "MAX",
+    "space-between": "SPACE_BETWEEN",
+    "space-around": "SPACE_AROUND",
+    "space-evenly": "SPACE_EVENLY"
+  };
+  var COUNTER_AXIS = { start: "MIN", center: "CENTER", end: "MAX", baseline: "BASELINE" };
+  function toPrimaryAxisAlign(justify) {
+    return PRIMARY_AXIS[justify];
+  }
+  function toCounterAxisAlign(align) {
+    return COUNTER_AXIS[align];
+  }
+  function toHex({ r, g, b }, alpha = 1) {
+    const channel = (value) => Math.round(value * 255).toString(16).padStart(2, "0");
+    const rgb = `#${channel(r)}${channel(g)}${channel(b)}`;
+    return alpha >= 1 ? rgb : `${rgb}${channel(alpha)}`;
+  }
+  function fromPaints(paints, names = EMPTY_NAMES) {
+    if (!Array.isArray(paints)) return void 0;
+    const paint = paints.find((candidate) => candidate.visible !== false);
+    if (!paint) return void 0;
+    if (paint.type === "SOLID") {
+      const bound = paint.boundVariables?.color;
+      const ref = bound ? names.variable(bound.id) : void 0;
+      return ref ?? toHex(paint.color, paint.opacity ?? 1);
+    }
+    if (paint.type !== "GRADIENT_LINEAR" && paint.type !== "GRADIENT_RADIAL") return void 0;
+    return {
+      type: "gradient",
+      kind: paint.type === "GRADIENT_RADIAL" ? "radial" : "linear",
+      angle: fromGradientTransform(paint.gradientTransform),
+      stops: paint.gradientStops.map((stop) => ({
+        at: stop.position,
+        color: toHex(stop.color, stop.color.a)
+      }))
+    };
+  }
+  function fromGradientTransform(transform) {
+    const cos = transform[0][0];
+    const sin = transform[1][0];
+    const degrees = Math.atan2(sin, cos) * 180 / Math.PI;
+    return Math.round(degrees * 1e3) / 1e3;
+  }
+  function fromEffects(effects) {
+    const specs = effects.filter((effect) => effect.visible !== false).map(fromEffect);
+    return specs.length ? specs : void 0;
+  }
+  function fromEffect(effect) {
+    switch (effect.type) {
+      case "LAYER_BLUR":
+        return { type: "layer-blur", radius: effect.radius };
+      case "BACKGROUND_BLUR":
+        return { type: "background-blur", radius: effect.radius };
+      case "DROP_SHADOW":
+      case "INNER_SHADOW":
+        return {
+          type: effect.type === "DROP_SHADOW" ? "shadow" : "inner-shadow",
+          x: effect.offset.x,
+          y: effect.offset.y,
+          blur: effect.radius,
+          spread: effect.spread ?? 0,
+          color: toHex(effect.color, effect.color.a)
+        };
+      default:
+        return { type: "layer-blur", radius: 0 };
+    }
+  }
+  function fromPadding(sides) {
+    const { top, right, bottom, left } = sides;
+    if (top === right && right === bottom && bottom === left) return top === 0 ? void 0 : top;
+    if (top === bottom && left === right) return [top, right];
+    return [top, right, bottom, left];
+  }
+  function fromRadius(corners) {
+    const { topLeft, topRight, bottomRight, bottomLeft } = corners;
+    if (topLeft === topRight && topRight === bottomRight && bottomRight === bottomLeft) {
+      return topLeft === 0 ? void 0 : topLeft;
+    }
+    return [topLeft, topRight, bottomRight, bottomLeft];
+  }
+  var PRIMARY_AXIS_BACK = {
+    MIN: "start",
+    CENTER: "center",
+    MAX: "end",
+    SPACE_BETWEEN: "space-between",
+    SPACE_AROUND: "space-around",
+    SPACE_EVENLY: "space-evenly"
+  };
+  var COUNTER_AXIS_BACK = {
+    MIN: "start",
+    CENTER: "center",
+    MAX: "end",
+    BASELINE: "baseline"
+  };
+  function fromPrimaryAxisAlign(value) {
+    return PRIMARY_AXIS_BACK[value];
+  }
+  function fromCounterAxisAlign(value) {
+    return COUNTER_AXIS_BACK[value];
+  }
+
+  // src/ops/define.ts
+  var TYPES = {
+    color: "COLOR",
+    number: "FLOAT",
+    string: "STRING",
+    boolean: "BOOLEAN"
+  };
+  async function define(params) {
+    const styles = await defineStyles(params.styles);
+    if (!params.collection) {
+      return { modes: [], styles, created: [], updated: [], notes: [] };
+    }
+    const collection = await collectionNamed(params.collection);
+    const notes = addModes(collection, params.modes ?? []);
+    const existing = new Map(
+      (await figma.variables.getLocalVariablesAsync()).filter((variable) => variable.variableCollectionId === collection.id).map((variable) => [variable.name, variable])
+    );
+    const created = [];
+    const updated = [];
+    for (const spec of params.variables ?? []) {
+      let variable = existing.get(spec.name);
+      if (variable) {
+        updated.push(spec.name);
+      } else {
+        variable = figma.variables.createVariable(spec.name, collection, TYPES[spec.type]);
+        existing.set(spec.name, variable);
+        created.push(spec.name);
+      }
+      for (const mode of collection.modes) {
+        const raw = perMode(spec.value, mode.name);
+        if (raw === void 0) continue;
+        variable.setValueForMode(mode.modeId, await toValue(raw, spec.type, existing));
+      }
+    }
+    figma.commitUndo();
+    return {
+      collection: collection.name,
+      modes: collection.modes.map((mode) => mode.name),
+      styles,
+      created,
+      updated,
+      notes
+    };
+  }
+  async function collectionNamed(name) {
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+    return collections.find((candidate) => candidate.name === name) ?? figma.variables.createVariableCollection(name);
+  }
+  function addModes(collection, modes) {
+    const notes = [];
+    for (const [index, name] of modes.entries()) {
+      const existing = collection.modes[index];
+      if (existing) {
+        if (existing.name !== name) collection.renameMode(existing.modeId, name);
+        continue;
+      }
+      try {
+        collection.addMode(name);
+      } catch (error) {
+        notes.push(`mode "${name}" not added: ${error instanceof Error ? error.message : error}`);
+      }
+    }
+    return notes;
+  }
+  function perMode(value, mode) {
+    if (typeof value !== "object") return value;
+    return value[mode] ?? value["default"] ?? Object.values(value)[0];
+  }
+  async function defineStyles(defs) {
+    if (!defs) return [];
+    const touched = [];
+    for (const spec of defs.paint ?? []) {
+      const style = (await figma.getLocalPaintStylesAsync()).find((candidate) => candidate.name === spec.name) ?? figma.createPaintStyle();
+      style.name = spec.name;
+      style.paints = toPaints(spec.fill);
+      touched.push(toRef(spec.name));
+    }
+    for (const spec of defs.text ?? []) {
+      const style = (await figma.getLocalTextStylesAsync()).find((candidate) => candidate.name === spec.name) ?? figma.createTextStyle();
+      const font = { family: spec.font.family, style: spec.font.style ?? "Regular" };
+      await figma.loadFontAsync(font);
+      style.name = spec.name;
+      style.fontName = font;
+      style.fontSize = spec.size;
+      if (spec.lineHeight !== void 0) {
+        style.lineHeight = spec.lineHeight === "auto" ? { unit: "AUTO" } : { unit: "PIXELS", value: spec.lineHeight };
+      }
+      if (spec.letterSpacing !== void 0) {
+        style.letterSpacing = { unit: "PIXELS", value: spec.letterSpacing };
+      }
+      touched.push(toRef(spec.name));
+    }
+    for (const spec of defs.effect ?? []) {
+      const style = (await figma.getLocalEffectStylesAsync()).find((candidate) => candidate.name === spec.name) ?? figma.createEffectStyle();
+      style.name = spec.name;
+      style.effects = toEffects(spec.effects);
+      touched.push(toRef(spec.name));
+    }
+    return touched;
+  }
+  async function toValue(raw, type, known) {
+    if (isRef(raw)) {
+      const name = fromRef(raw);
+      const target = known.get(name) ?? (await figma.variables.getLocalVariablesAsync()).find((variable) => variable.name === name);
+      if (!target) throw new Error(`No variable named "${name}" to alias`);
+      return figma.variables.createVariableAlias(target);
+    }
+    if (type === "color") {
+      if (typeof raw !== "string")
+        throw new Error(`A colour variable needs a hex string, got ${raw}`);
+      return rgba(raw);
+    }
+    return raw;
+  }
+
+  // src/ops/exec.ts
+  var allowed = false;
+  function setExecAllowed(value) {
+    allowed = value;
+  }
+  async function exec(params) {
+    if (!allowed) {
+      throw new Error(
+        'Code execution is off. Tick "Allow code execution" in the Mirra panel in Figma.'
+      );
+    }
+    let run;
+    try {
+      run = new Function("figma", `"use strict"; return (async () => { ${params.code} })();`);
+    } catch (error) {
+      throw new Error(`Could not compile the code: ${message(error)}`);
+    }
+    const result = await run(figma);
+    figma.commitUndo();
+    return { result: describe(result) };
+  }
+  function describe(value) {
+    if (value === void 0) return "undefined";
+    try {
+      return JSON.stringify(value, replacer, 2) ?? String(value);
+    } catch {
+      return String(value);
+    }
+  }
+  function replacer(_key, value) {
+    if (value && typeof value === "object" && "id" in value && "type" in value) {
+      const node = value;
+      return `${node.type} ${node.id}${node.name ? ` (${node.name})` : ""}`;
+    }
+    return value;
+  }
+  function message(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
+  // src/figma/build.ts
+  var KEY_FIELD = "mirra:key";
+  var SVG_FIELD = "mirra:svg";
+  var SRC_FIELD = "mirra:src";
+  var COMPONENT_FIELD = "mirra:component";
+  var MAX_REMEMBERED_SOURCE = 5e4;
+  async function buildNode(spec, parent, keys, tokens2 = new TokenIndex(), deferred = []) {
+    const node = await createNode(spec, parent);
+    if (spec.key) {
+      node.setPluginData(KEY_FIELD, spec.key);
+      keys[spec.key] = node.id;
+    }
+    await applyProps(node, spec, tokens2);
+    if (spec.type === "frame") {
+      for (const child of spec.children ?? []) {
+        await buildNode(child, node, keys, tokens2, deferred);
+      }
+    }
+    applyBounds(node, spec);
+    applyConstraints(node, spec);
+    if (spec.at) deferred.push(() => pin(node, spec.at));
+    const fallback = spec.type === "frame" && spec.layout ? "hug" : void 0;
+    applySizing(node, spec.w ?? fallback, "Horizontal");
+    applySizing(node, spec.h ?? fallback, "Vertical");
+    return node;
+  }
+  async function createNode(spec, parent) {
+    const node = await make(spec);
+    parent.appendChild(node);
+    if (spec.type === "svg" || spec.type === "image") remember(node, spec);
+    if (spec.type === "instance") node.setPluginData(COMPONENT_FIELD, spec.component);
+    return node;
+  }
+  async function make(spec) {
+    switch (spec.type) {
+      case "frame":
+        return figma.createFrame();
+      case "text":
+        return figma.createText();
+      case "rect":
+        return figma.createRectangle();
+      case "ellipse":
+        return figma.createEllipse();
+      case "instance":
+        return (await findComponent(spec.component)).createInstance();
+      case "svg":
+        return figma.createNodeFromSvg(spec.src);
+      case "image":
+        return imageRect(spec.src, spec.fit);
+    }
+  }
+  async function imageRect(src, fit) {
+    const image = figma.createImage(figma.base64Decode(stripDataUri(src)));
+    const rect = figma.createRectangle();
+    rect.fills = [{ type: "IMAGE", imageHash: image.hash, scaleMode: SCALE_MODES[fit ?? "fill"] }];
+    const { width, height } = await image.getSizeAsync();
+    rect.resize(width, height);
+    return rect;
+  }
+  var SCALE_MODES = {
+    fill: "FILL",
+    fit: "FIT",
+    crop: "CROP",
+    tile: "TILE"
+  };
+  function stripDataUri(src) {
+    const comma = src.indexOf(",");
+    return src.startsWith("data:") && comma !== -1 ? src.slice(comma + 1) : src;
+  }
+  function remember(node, spec) {
+    const field = spec.type === "svg" ? SVG_FIELD : SRC_FIELD;
+    if (spec.srcRef) node.setPluginData(field, spec.srcRef);
+    else if (spec.src.length <= MAX_REMEMBERED_SOURCE) node.setPluginData(field, spec.src);
+  }
+  async function findComponent(name) {
+    const components = figma.currentPage.findAllWithCriteria({ types: ["COMPONENT"] });
+    const match = components.find((component) => componentPath(component) === name);
+    if (!match) {
+      const available = components.map(componentPath).slice(0, 10).join(", ");
+      throw new Error(
+        `No component named "${name}" on this page${available ? `. Found: ${available}` : ""}`
+      );
+    }
+    return match;
+  }
+  function componentPath(component) {
+    const parent = component.parent;
+    return parent && parent.type === "COMPONENT_SET" ? `${parent.name}/${component.name}` : component.name;
+  }
+  async function applyProps(node, props, tokens2 = new TokenIndex()) {
+    if (props.name !== void 0) node.name = props.name;
+    if (props.opacity !== void 0) node.opacity = props.opacity;
+    if (props.visible !== void 0) node.visible = props.visible;
+    if (props.layout !== void 0 || props.clip !== void 0) {
+      if (node.type !== "FRAME") {
+        throw new Error(`layout and clip only apply to a frame, not a ${low(node)}`);
+      }
+      applyLayout(node, props.layout, props.clip);
+    }
+    await applyPaint(node, props, tokens2);
+    if (props.properties) {
+      if (node.type !== "INSTANCE") {
+        throw new Error(`component properties only apply to an instance, not a ${low(node)}`);
+      }
+      node.setProperties(resolveProperties(node, props.properties));
+    }
+    const typography = props.text !== void 0 || props.font !== void 0 || props.size !== void 0 || props.lineHeight !== void 0 || props.letterSpacing !== void 0 || props.align !== void 0 || props.color !== void 0 || props.style !== void 0;
+    if (typography) {
+      if (node.type !== "TEXT") {
+        throw new Error(`text properties only apply to a text node, not a ${low(node)}`);
+      }
+      await applyText(node, props, tokens2);
+    }
+  }
+  async function applyText(text, props, tokens2) {
+    const style = props.style ? await tokens2.textStyle(props.style) : null;
+    if (style) {
+      await figma.loadFontAsync(style.fontName);
+      await text.setTextStyleIdAsync(style.id);
+    }
+    if (props.font) {
+      const fallback = text.fontName === figma.mixed ? "Regular" : text.fontName.style;
+      const font = { family: props.font.family, style: props.font.style ?? fallback };
+      await figma.loadFontAsync(font);
+      text.fontName = font;
+    } else if (!style) {
+      const current = text.fontName === figma.mixed ? { family: "Inter", style: "Regular" } : text.fontName;
+      await figma.loadFontAsync(current);
+    }
+    if (props.text !== void 0) text.characters = props.text;
+    if (props.size !== void 0) text.fontSize = props.size;
+    if (props.lineHeight !== void 0) {
+      text.lineHeight = props.lineHeight === "auto" ? { unit: "AUTO" } : { unit: "PIXELS", value: props.lineHeight };
+    }
+    if (props.letterSpacing !== void 0) {
+      text.letterSpacing = { unit: "PIXELS", value: props.letterSpacing };
+    }
+    if (props.align) {
+      text.textAlignHorizontal = props.align.toUpperCase();
+    }
+    if (props.color) {
+      text.fills = isRef(props.color) ? [await boundPaint(props.color, tokens2)] : toPaints(props.color);
+    }
+  }
+  function applyLayout(frame, layout, clip) {
+    if (clip !== void 0) frame.clipsContent = clip;
+    if (!layout) return;
+    const { dir, gap, pad, justify, align, wrap } = layout;
+    frame.layoutMode = dir === "horizontal" ? "HORIZONTAL" : "VERTICAL";
+    if (gap !== void 0) frame.itemSpacing = gap;
+    if (pad !== void 0) {
+      const { top, right, bottom, left } = toPadding(pad);
+      frame.paddingTop = top;
+      frame.paddingRight = right;
+      frame.paddingBottom = bottom;
+      frame.paddingLeft = left;
+    }
+    if (wrap !== void 0) frame.layoutWrap = wrap ? "WRAP" : "NO_WRAP";
+    if (justify) frame.primaryAxisAlignItems = toPrimaryAxisAlign(justify);
+    if (align) frame.counterAxisAlignItems = toCounterAxisAlign(align);
+  }
+  async function applyPaint(node, props, tokens2) {
+    const shape = node;
+    if (!props.fill && node.type === "FRAME") shape.fills = [];
+    if (props.fill && node.type !== "TEXT") {
+      shape.fills = isRef(props.fill) ? [await boundPaint(props.fill, tokens2)] : toPaints(props.fill);
+    }
+    if (props.stroke) {
+      const { paints, weight, align } = toStrokes(props.stroke);
+      shape.strokes = paints;
+      shape.strokeWeight = weight;
+      shape.strokeAlign = align;
+    }
+    if (props.radius !== void 0) applyRadius(shape, props.radius);
+    if (props.effects) shape.effects = toEffects(props.effects);
+  }
+  function resolveProperties(node, properties) {
+    const available = node.componentProperties;
+    const resolved = {};
+    for (const [name, value] of Object.entries(properties)) {
+      const match = name in available ? name : Object.keys(available).find((candidate) => candidate.split("#")[0] === name);
+      if (!match) {
+        const names = Object.keys(available).map((candidate) => candidate.split("#")[0]).join(", ");
+        throw new Error(
+          `"${node.name}" has no component property "${name}"${names ? `. It has: ${names}` : ""}`
+        );
+      }
+      resolved[match] = typeof value === "number" ? String(value) : value;
+    }
+    return resolved;
+  }
+  async function boundPaint(ref, tokens2) {
+    const variable = await tokens2.variable(ref);
+    const base = { type: "SOLID", color: { r: 0, g: 0, b: 0 } };
+    return figma.variables.setBoundVariableForPaint(base, "color", variable);
+  }
+  function low(node) {
+    return node.type.toLowerCase();
+  }
+  function applyRadius(node, radius) {
+    const [topLeft, topRight, bottomRight, bottomLeft] = toRadius(radius);
+    if (!("topLeftRadius" in node)) {
+      node.cornerRadius = topLeft;
+      return;
+    }
+    const corners = node;
+    corners.topLeftRadius = topLeft;
+    corners.topRightRadius = topRight;
+    corners.bottomRightRadius = bottomRight;
+    corners.bottomLeftRadius = bottomLeft;
+  }
+  var CONSTRAINTS = {
+    min: "MIN",
+    center: "CENTER",
+    max: "MAX",
+    stretch: "STRETCH",
+    scale: "SCALE"
+  };
+  function applyBounds(node, props) {
+    const box = node;
+    if (props.minW !== void 0) box.minWidth = props.minW;
+    if (props.maxW !== void 0) box.maxWidth = props.maxW;
+    if (props.minH !== void 0) box.minHeight = props.minH;
+    if (props.maxH !== void 0) box.maxHeight = props.maxH;
+  }
+  function applyConstraints(node, props) {
+    if (!props.constraints) return;
+    const target = node;
+    target.constraints = {
+      horizontal: CONSTRAINTS[props.constraints.h],
+      vertical: CONSTRAINTS[props.constraints.v]
+    };
+  }
+  function pin(node, at) {
+    if (!at) return;
+    const parent = node.parent;
+    const inFlow = parent !== null && "layoutMode" in parent && parent.layoutMode !== "NONE";
+    if (inFlow)
+      node.layoutPositioning = "ABSOLUTE";
+    const placed = node;
+    placed.x = at.x;
+    placed.y = at.y;
+  }
+  function applySizing(node, sizing2, axis) {
+    if (sizing2 === void 0) return;
+    if (typeof sizing2 === "number") {
+      const box = node;
+      if (axis === "Horizontal") box.resize(sizing2, box.height);
+      else box.resize(box.width, sizing2);
+      return;
+    }
+    const layoutNode = node;
+    const field = axis === "Horizontal" ? "layoutSizingHorizontal" : "layoutSizingVertical";
+    if (!(field in layoutNode)) {
+      throw new Error(`"${sizing2}" sizing is not available on a ${node.type.toLowerCase()} node`);
+    }
+    layoutNode[field] = sizing2 === "fill" ? "FILL" : "HUG";
+  }
+
+  // src/figma/target.ts
+  var _byKey, _NodeIndex_instances, index_fn;
+  var NodeIndex = class {
+    constructor() {
+      __privateAdd(this, _NodeIndex_instances);
+      __privateAdd(this, _byKey, null);
+    }
+    invalidate() {
+      __privateSet(this, _byKey, null);
+    }
+    async resolve(target) {
+      if ("id" in target) {
+        const node = await figma.getNodeByIdAsync(target.id);
+        if (!node) throw new Error(`No node with id ${target.id} in this file`);
+        if (node.type === "DOCUMENT" || node.type === "PAGE") {
+          throw new Error(`${node.type} is not a layer: target a frame or a shape`);
+        }
+        return node;
+      }
+      const found = __privateMethod(this, _NodeIndex_instances, index_fn).call(this).get(target.key);
+      if (!found) {
+        throw new Error(
+          `No node with key "${target.key}" on this page. Keys live on the nodes mirra rendered; mirra_read reports the ones that are there.`
+        );
+      }
+      return found;
+    }
+  };
+  _byKey = new WeakMap();
+  _NodeIndex_instances = new WeakSet();
+  index_fn = function() {
+    if (__privateGet(this, _byKey)) return __privateGet(this, _byKey);
+    const byKey = /* @__PURE__ */ new Map();
+    for (const node of figma.currentPage.findAllWithCriteria({
+      pluginData: { keys: [KEY_FIELD] }
+    })) {
+      byKey.set(node.getPluginData(KEY_FIELD), node);
+    }
+    __privateSet(this, _byKey, byKey);
+    return byKey;
+  };
+
+  // src/ops/export.ts
+  async function exportAssets(params) {
+    const index = new NodeIndex();
+    const format = params.format ?? "png";
+    const assets = [];
+    for (const target of params.targets) {
+      const node = await index.resolve(target);
+      const bytes = await node.exportAsync(
+        format === "svg" ? { format: "SVG" } : { format: "PNG", constraint: { type: "SCALE", value: params.scale ?? 1 } }
+      );
+      assets.push({
+        id: node.id,
+        name: node.name,
+        extension: format,
+        data: figma.base64Encode(bytes)
+      });
+    }
+    return { assets };
+  }
+
+  // src/ops/find.ts
+  var DEFAULT_LIMIT = 50;
+  var KINDS = {
+    frame: ["FRAME"],
+    text: ["TEXT"],
+    rect: ["RECTANGLE"],
+    ellipse: ["ELLIPSE"],
+    instance: ["INSTANCE"],
+    component: ["COMPONENT", "COMPONENT_SET"],
+    group: ["GROUP"],
+    vector: ["VECTOR"]
+  };
+  async function find(params) {
+    const pages2 = params.scope === "document" ? (await figma.loadAllPagesAsync(), figma.root.children) : [figma.currentPage];
+    const limit = params.limit ?? DEFAULT_LIMIT;
+    const needle = params.name?.toLowerCase();
+    const kinds = params.kind && params.kind !== "any" ? KINDS[params.kind] : void 0;
+    const matches = [];
+    let truncated = false;
+    for (const page of pages2) {
+      for (const node of page.findAll(() => true)) {
+        if (kinds && !kinds.includes(node.type)) continue;
+        if (needle && !node.name.toLowerCase().includes(needle)) continue;
+        const key = node.getPluginData(KEY_FIELD);
+        if (params.key && key !== params.key) continue;
+        if (matches.length >= limit) {
+          truncated = true;
+          break;
+        }
+        matches.push({
+          id: node.id,
+          name: node.name,
+          kind: node.type,
+          page: page.name,
+          ...key ? { key } : {}
+        });
+      }
+    }
+    if (params.select && matches.length) {
+      const selected = matches.map((match) => figma.currentPage.findOne((node) => node.id === match.id)).filter((node) => node !== null);
+      if (selected.length) {
+        figma.currentPage.selection = selected;
+        figma.viewport.scrollAndZoomIntoView(selected);
+      }
+    }
+    return { nodes: matches, truncated };
+  }
+
+  // src/ops/pages.ts
+  async function pages(params) {
+    await figma.loadAllPagesAsync();
+    if (params.select) {
+      const wanted = figma.root.children.find(
+        (page) => page.id === params.select || page.name === params.select
+      );
+      if (!wanted) {
+        const names = figma.root.children.map((page) => page.name).join(", ");
+        throw new Error(`No page called "${params.select}". This file has: ${names}`);
+      }
+      await figma.setCurrentPageAsync(wanted);
+    }
+    return {
+      pages: figma.root.children.map((page) => ({
+        id: page.id,
+        name: page.name,
+        current: page.id === figma.currentPage.id
+      }))
+    };
+  }
+
+  // src/ops/patch.ts
+  async function patch(params) {
+    const index = new NodeIndex();
+    const keys = {};
+    const touched = [];
+    const deferred = [];
+    for (const op of params.ops) {
+      const node = await index.resolve(op.target);
+      switch (op.op) {
+        case "set": {
+          await applyProps(node, op.props);
+          applyBounds(node, op.props);
+          applyConstraints(node, op.props);
+          applySizing(node, op.props.w, "Horizontal");
+          applySizing(node, op.props.h, "Vertical");
+          if (op.props.at) deferred.push(() => pin(node, op.props.at));
+          touched.push(node);
+          break;
+        }
+        case "append": {
+          const child = await buildNode(op.tree, asContainer(node), keys, void 0, deferred);
+          if (op.index !== void 0) asContainer(node).insertChild(op.index, child);
+          index.invalidate();
+          touched.push(child);
+          break;
+        }
+        case "replace": {
+          const parent = node.parent;
+          if (!parent || !("insertChild" in parent)) {
+            throw new Error(`${node.name} has no parent to replace it in`);
+          }
+          const at = parent.children.indexOf(node);
+          const created = await buildNode(op.tree, parent, keys, void 0, deferred);
+          parent.insertChild(at, created);
+          node.remove();
+          index.invalidate();
+          touched.push(created);
+          break;
+        }
+        case "move": {
+          const parent = op.parent ? await index.resolve(op.parent) : node.parent;
+          if (!parent || !("insertChild" in parent)) {
+            throw new Error(`${node.name} has nowhere to move to`);
+          }
+          const container = parent;
+          const at = op.index ?? container.children.length;
+          container.insertChild(Math.min(at, container.children.length), node);
+          index.invalidate();
+          touched.push(node);
+          break;
+        }
+        case "remove": {
+          node.remove();
+          index.invalidate();
+          break;
+        }
+      }
+    }
+    for (const place of deferred) place();
+    if (params.reveal) {
+      const alive = touched.filter((node) => !node.removed);
+      if (alive.length) {
+        figma.currentPage.selection = alive;
+        figma.viewport.scrollAndZoomIntoView(alive);
+      }
+    }
+    figma.commitUndo();
+    return { applied: params.ops.length, keys };
+  }
+  function asContainer(node) {
+    if (!("appendChild" in node)) {
+      throw new Error(`A ${node.type.toLowerCase()} cannot contain children`);
+    }
+    return node;
+  }
+
+  // src/ops/ping.ts
+  function ping() {
+    return {
+      fileName: figma.root.name,
+      fileKey: readFileKey(),
+      currentPage: figma.currentPage.name,
+      selectionCount: figma.currentPage.selection.length
+    };
+  }
+
+  // src/figma/read.ts
+  function readNode(node, depth, names = EMPTY_NAMES) {
+    const skipped = { count: 0 };
+    const tree = toSpec(node, depth, skipped, names);
+    return { tree, skipped: skipped.count };
+  }
+  function toSpec(node, depth, skipped, names) {
+    const svg = node.getPluginData(SVG_FIELD);
+    if (svg) return { type: "svg", ...common(node), src: svg };
+    const src = node.getPluginData(SRC_FIELD);
+    if (src) return { type: "image", ...common(node), ...painted(node, names), src };
+    switch (node.type) {
+      case "FRAME":
+        return frameSpec(node, depth, skipped, names);
+      case "TEXT":
+        return textSpec(node, names);
+      case "RECTANGLE":
+        return { type: "rect", ...common(node), ...painted(node, names) };
+      case "ELLIPSE":
+        return { type: "ellipse", ...common(node), ...painted(node, names) };
+      case "INSTANCE":
+        return instanceSpec(node);
+      default:
+        skipped.count += 1;
+        return null;
+    }
+  }
+  function frameSpec(node, depth, skipped, names) {
+    const children = [];
+    if (depth > 0) {
+      for (const child of node.children) {
+        const spec = toSpec(child, depth - 1, skipped, names);
+        if (spec) children.push(spec);
+      }
+    } else if (node.children.length) {
+      skipped.count += node.children.length;
+    }
+    return {
+      type: "frame",
+      ...common(node),
+      ...painted(node, names),
+      ...node.clipsContent ? {} : { clip: false },
+      ...layoutSpec(node) ? { layout: layoutSpec(node) } : {},
+      ...children.length ? { children } : {}
+    };
+  }
+  function layoutSpec(node) {
+    if (node.layoutMode === "NONE") return void 0;
+    const pad = fromPadding({
+      top: node.paddingTop,
+      right: node.paddingRight,
+      bottom: node.paddingBottom,
+      left: node.paddingLeft
+    });
+    return {
+      dir: node.layoutMode === "HORIZONTAL" ? "horizontal" : "vertical",
+      ...node.itemSpacing ? { gap: node.itemSpacing } : {},
+      ...pad === void 0 ? {} : { pad },
+      ...node.primaryAxisAlignItems === "MIN" ? {} : { justify: fromPrimaryAxisAlign(node.primaryAxisAlignItems) },
+      ...node.counterAxisAlignItems === "MIN" ? {} : { align: fromCounterAxisAlign(node.counterAxisAlignItems) },
+      ...node.layoutWrap === "WRAP" ? { wrap: true } : {}
+    };
+  }
+  function instanceSpec(node) {
+    const properties = {};
+    for (const [name, property] of Object.entries(node.componentProperties)) {
+      if (typeof property.value === "string" || typeof property.value === "boolean") {
+        properties[name.split("#")[0] ?? name] = property.value;
+      }
+    }
+    return {
+      type: "instance",
+      ...common(node),
+      component: node.getPluginData(COMPONENT_FIELD) || node.name,
+      ...Object.keys(properties).length ? { properties } : {}
+    };
+  }
+  function textSpec(node, names) {
+    const font = node.fontName === figma.mixed ? void 0 : node.fontName;
+    const lineHeight = node.lineHeight === figma.mixed ? void 0 : node.lineHeight;
+    const letterSpacing = node.letterSpacing === figma.mixed ? void 0 : node.letterSpacing;
+    const color = fromPaints(node.fills, names);
+    const style = typeof node.textStyleId === "string" ? names.style(node.textStyleId) : void 0;
+    return {
+      type: "text",
+      ...common(node),
+      text: node.characters,
+      ...style ? { style } : {},
+      ...font ? { font: { family: font.family, style: font.style } } : {},
+      ...node.fontSize === figma.mixed ? {} : { size: node.fontSize },
+      ...lineHeight && lineHeight.unit !== "PERCENT" ? { lineHeight: lineHeight.unit === "AUTO" ? "auto" : lineHeight.value } : {},
+      ...letterSpacing && letterSpacing.unit === "PIXELS" && letterSpacing.value !== 0 ? { letterSpacing: letterSpacing.value } : {},
+      ...node.textAlignHorizontal === "LEFT" ? {} : { align: node.textAlignHorizontal.toLowerCase() },
+      ...color ? { color } : {}
+    };
+  }
+  var CONSTRAINTS_BACK = {
+    MIN: "min",
+    CENTER: "center",
+    MAX: "max",
+    STRETCH: "stretch",
+    SCALE: "scale"
+  };
+  function bounds(node) {
+    const box = node;
+    return {
+      ...box.minWidth == null ? {} : { minW: box.minWidth },
+      ...box.maxWidth == null ? {} : { maxW: box.maxWidth },
+      ...box.minHeight == null ? {} : { minH: box.minHeight },
+      ...box.maxHeight == null ? {} : { maxH: box.maxHeight }
+    };
+  }
+  function placement(node) {
+    const placed = node;
+    const pinned = placed.layoutPositioning === "ABSOLUTE";
+    const constraints = placed.constraints;
+    const custom = constraints && (constraints.horizontal !== "MIN" || constraints.vertical !== "MIN");
+    return {
+      ...pinned ? { at: { x: round(placed.x), y: round(placed.y) } } : {},
+      ...custom && constraints ? {
+        constraints: {
+          h: CONSTRAINTS_BACK[constraints.horizontal],
+          v: CONSTRAINTS_BACK[constraints.vertical]
+        }
+      } : {}
+    };
+  }
+  function common(node) {
+    const key = node.getPluginData(KEY_FIELD);
+    const blend = node;
+    return {
+      ...key ? { key } : {},
+      name: node.name,
+      ...sizing(node),
+      ...bounds(node),
+      ...placement(node),
+      ...blend.opacity === 1 ? {} : { opacity: blend.opacity },
+      ...node.visible ? {} : { visible: false }
+    };
+  }
+  function sizing(node) {
+    const box = node;
+    const parent = node.parent;
+    const inAutoLayout = parent !== null && "layoutMode" in parent && parent.layoutMode !== "NONE";
+    const ownsLayout = node.type === "FRAME" && node.layoutMode !== "NONE";
+    const axis = (fixed, mode) => {
+      if (mode === "HUG" && (inAutoLayout || ownsLayout)) return "hug";
+      if (mode === "FILL" && inAutoLayout) return "fill";
+      return round(fixed);
+    };
+    return {
+      w: axis(box.width, box.layoutSizingHorizontal),
+      h: axis(box.height, box.layoutSizingVertical)
+    };
+  }
+  function painted(node, names) {
+    const shape = node;
+    const fill = fromPaints(shape.fills, names);
+    const effects = fromEffects(shape.effects ?? []);
+    const corners = node;
+    const radius = "topLeftRadius" in corners ? fromRadius({
+      topLeft: corners.topLeftRadius,
+      topRight: corners.topRightRadius,
+      bottomRight: corners.bottomRightRadius,
+      bottomLeft: corners.bottomLeftRadius
+    }) : void 0;
+    const stroke = strokeSpec(shape);
+    return {
+      ...fill ? { fill } : {},
+      ...stroke ? { stroke } : {},
+      ...radius === void 0 ? {} : { radius },
+      ...effects ? { effects } : {}
+    };
+  }
+  function strokeSpec(node) {
+    const paint = Array.isArray(node.strokes) ? node.strokes[0] : void 0;
+    if (!paint || paint.type !== "SOLID") return void 0;
+    const weight = typeof node.strokeWeight === "number" ? node.strokeWeight : 1;
+    const color = fromPaints([paint]);
+    if (typeof color !== "string") return void 0;
+    return {
+      color,
+      ...weight === 1 ? {} : { width: weight },
+      ...node.strokeAlign === "INSIDE" ? {} : { align: node.strokeAlign.toLowerCase() }
+    };
+  }
+  function round(value) {
+    return Math.round(value * 100) / 100;
+  }
+
+  // src/ops/read.ts
+  var DEFAULT_DEPTH = 6;
+  async function read(params) {
+    const targets = params.nodeId ? [await resolve(params.nodeId)] : [...figma.currentPage.selection];
+    if (!targets.length) {
+      throw new Error("Nothing is selected: select a layer in Figma, or pass a nodeId");
+    }
+    const names = await buildNameIndex();
+    const nodes = [];
+    let skipped = 0;
+    for (const target of targets) {
+      const outcome = readNode(target, params.depth ?? DEFAULT_DEPTH, names);
+      skipped += outcome.skipped;
+      if (outcome.tree) nodes.push({ id: target.id, tree: outcome.tree });
+      else skipped += 1;
+    }
+    return { nodes, skipped };
+  }
+  async function resolve(nodeId) {
+    const node = await figma.getNodeByIdAsync(nodeId);
+    if (!node) throw new Error(`No node with id ${nodeId} in this file`);
+    if (node.type === "DOCUMENT" || node.type === "PAGE") {
+      throw new Error(`${node.type} is not a layer: pass a frame or a shape`);
+    }
+    return node;
+  }
+
+  // src/ops/render.ts
+  async function render(params) {
+    const parent = params.parentId ? await resolveParent(params.parentId) : figma.currentPage;
+    const keys = {};
+    const deferred = [];
+    const root = await buildNode(params.tree, parent, keys, void 0, deferred);
+    for (const place of deferred) place();
+    const at = params.at ?? centreOfViewport(root);
+    if ("x" in root && "y" in root && parent.type === "PAGE") {
+      root.x = at.x;
+      root.y = at.y;
+    }
+    if (params.reveal !== false) {
+      figma.currentPage.selection = [root];
+      figma.viewport.scrollAndZoomIntoView([root]);
+    }
+    figma.commitUndo();
+    return { rootId: root.id, nodeCount: countNodes(params.tree), keys };
+  }
+  async function resolveParent(parentId) {
+    const node = await figma.getNodeByIdAsync(parentId);
+    if (!node) throw new Error(`No node with id ${parentId} in this file`);
+    if (!("appendChild" in node)) throw new Error(`${node.type} cannot contain children`);
+    return node;
+  }
+  function centreOfViewport(node) {
+    const { center } = figma.viewport;
+    return { x: Math.round(center.x - node.width / 2), y: Math.round(center.y - node.height / 2) };
+  }
+  function countNodes(spec) {
+    if (spec.type !== "frame") return 1;
+    return 1 + (spec.children ?? []).reduce((total, child) => total + countNodes(child), 0);
+  }
+
+  // src/ops/screenshot.ts
+  async function screenshot(params) {
+    const node = params.target ? await new NodeIndex().resolve(params.target) : figma.currentPage.selection[0];
+    if (!node) {
+      throw new Error("Nothing is selected: select a layer in Figma, or pass a target");
+    }
+    const bytes = await node.exportAsync({
+      format: "PNG",
+      constraint: { type: "SCALE", value: params.scale ?? 1 }
+    });
+    const box = node;
+    return {
+      id: node.id,
+      name: node.name,
+      width: Math.round(box.width),
+      height: Math.round(box.height),
+      png: figma.base64Encode(bytes)
+    };
+  }
+
+  // src/ops/tokens.ts
+  async function tokens() {
+    return readTokens();
+  }
+
+  // src/ops/index.ts
+  async function runOp(op, raw) {
+    const params = raw ?? {};
+    switch (op) {
+      case "ping":
+        return ping();
+      case "render":
+        return render(params);
+      case "read":
+        return read(params);
+      case "patch":
+        return patch(params);
+      case "screenshot":
+        return screenshot(params);
+      case "tokens":
+        return tokens();
+      case "export":
+        return exportAssets(params);
+      case "find":
+        return find(params);
+      case "pages":
+        return pages(params);
+      case "exec":
+        return exec(params);
+      case "define":
+        return define(params);
+      default: {
+        const exhaustive = op;
+        throw new Error(`Unknown op: ${String(exhaustive)}`);
+      }
+    }
+  }
+
+  // src/main.ts
+  var PLUGIN_VERSION = "1.0.0";
+  figma.showUI(__html__, { width: 300, height: 300, themeColors: true });
+  var queue = Promise.resolve();
+  figma.ui.onmessage = (message2) => {
+    if (message2.kind === "ready") return send(context());
+    if (message2.kind === "allow-exec") return setExecAllowed(message2.value);
+    if (message2.kind !== "request") return;
+    queue = queue.then(async () => {
+      try {
+        const result = await runOp(message2.op, message2.params);
+        send({ kind: "response", id: message2.id, ok: true, result });
+      } catch (error) {
+        send({
+          kind: "response",
+          id: message2.id,
+          ok: false,
+          error: {
+            code: "op_failed",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    });
+  };
+  function context() {
+    return {
+      kind: "context",
+      pluginVersion: PLUGIN_VERSION,
+      protocolVersion: PROTOCOL_VERSION,
+      fileName: figma.root.name,
+      fileKey: readFileKey()
+    };
+  }
+  function send(message2) {
+    figma.ui.postMessage(message2);
+  }
+})();