@xenosystem/blocks 0.22.0 → 0.23.0

package/dist/chunk-76V25B3E.js

@@ -0,0 +1,435 @@
+// src/edit/curve/scale.ts
+var DEFAULT_CURVE_ZOOM = { min: 5e-4, max: 64 };
+var XenoCurveScale = class _XenoCurveScale {
+  pxPerTick;
+  scrollTick;
+  minValue;
+  maxValue;
+  widthPx;
+  heightPx;
+  gutterPx;
+  rulerPx;
+  constructor(state, geometry) {
+    this.widthPx = Math.max(1, finiteOr(geometry.widthPx, 1));
+    this.heightPx = Math.max(1, finiteOr(geometry.heightPx, 1));
+    this.gutterPx = Math.max(0, Math.min(finiteOr(geometry.gutterPx, 0), this.widthPx - 1));
+    this.rulerPx = Math.max(0, Math.min(finiteOr(geometry.rulerPx, 0), this.heightPx - 1));
+    this.pxPerTick = Math.max(Number.MIN_VALUE, finiteOr(state.pxPerTick, 1));
+    this.scrollTick = finiteOr(state.scrollTick, 0);
+    const min = finiteOr(state.minValue, 0);
+    const max = finiteOr(state.maxValue, 1);
+    if (max - min < 1e-12) {
+      const centre = (max + min) / 2;
+      this.minValue = centre - 0.5;
+      this.maxValue = centre + 0.5;
+    } else {
+      this.minValue = min;
+      this.maxValue = max;
+    }
+  }
+  /** Width of the plot area. Always ≥ 1. */
+  get plotPx() {
+    return Math.max(1, this.widthPx - this.gutterPx);
+  }
+  /** Height of the plot area. Always ≥ 1. */
+  get plotHeightPx() {
+    return Math.max(1, this.heightPx - this.rulerPx);
+  }
+  /** Ticks visible. */
+  get spanTicks() {
+    return this.plotPx / this.pxPerTick;
+  }
+  /** Tick at the right edge. */
+  get endTick() {
+    return this.scrollTick + this.spanTicks;
+  }
+  /** Value units per pixel. */
+  get valuePerPx() {
+    return (this.maxValue - this.minValue) / this.plotHeightPx;
+  }
+  /** Container-relative x → tick. */
+  xToTick(x) {
+    return this.scrollTick + (finiteOr(x, 0) - this.gutterPx) / this.pxPerTick;
+  }
+  /** Tick → container-relative x. */
+  tickToX(tick) {
+    return this.gutterPx + (finiteOr(tick, 0) - this.scrollTick) * this.pxPerTick;
+  }
+  /**
+   * Container-relative y → value.
+   *
+   * **Inverted.** Screen y grows downward, value grows upward. Every sign error in a graph editor
+   * lives on this one line.
+   */
+  yToValue(y) {
+    const local = finiteOr(y, 0) - this.rulerPx;
+    return this.maxValue - local / this.plotHeightPx * (this.maxValue - this.minValue);
+  }
+  /** Value → container-relative y. */
+  valueToY(value) {
+    const fraction = (this.maxValue - finiteOr(value, 0)) / (this.maxValue - this.minValue);
+    return this.rulerPx + fraction * this.plotHeightPx;
+  }
+  /**
+   * A tick DURATION → a pixel width.
+   *
+   * Separate from {@link tickToX}, because rounding is not associative: mixing
+   * `durationToPx(b - a)` with `tickToX(b) - tickToX(a)` puts a curve's handle a pixel off its key
+   * at some zoom levels and not others.
+   */
+  durationToPx(ticks) {
+    return finiteOr(ticks, 0) * this.pxPerTick;
+  }
+  /** A value DELTA → a pixel height. Sign-preserving and NOT inverted. */
+  valueDeltaToPx(delta) {
+    return finiteOr(delta, 0) / (this.maxValue - this.minValue) * this.plotHeightPx;
+  }
+  /** A pixel distance → a tick distance. For screen-space thresholds. */
+  pxToTicks(px) {
+    return finiteOr(px, 0) / this.pxPerTick;
+  }
+  /** A pixel distance → a value distance. For screen-space thresholds. */
+  pxToValue(px) {
+    return finiteOr(px, 0) * this.valuePerPx;
+  }
+  /** Is this point inside the plot area? */
+  isInPlot(x, y) {
+    return x >= this.gutterPx && x <= this.widthPx && y >= this.rulerPx && y <= this.heightPx;
+  }
+  /** A copy with new state. */
+  with(state) {
+    return new _XenoCurveScale(
+      {
+        pxPerTick: state.pxPerTick ?? this.pxPerTick,
+        scrollTick: state.scrollTick ?? this.scrollTick,
+        minValue: state.minValue ?? this.minValue,
+        maxValue: state.maxValue ?? this.maxValue
+      },
+      {
+        widthPx: this.widthPx,
+        heightPx: this.heightPx,
+        gutterPx: this.gutterPx,
+        rulerPx: this.rulerPx
+      }
+    );
+  }
+  /** A copy with new geometry. */
+  resized(geometry) {
+    return new _XenoCurveScale(
+      {
+        pxPerTick: this.pxPerTick,
+        scrollTick: this.scrollTick,
+        minValue: this.minValue,
+        maxValue: this.maxValue
+      },
+      {
+        widthPx: geometry.widthPx ?? this.widthPx,
+        heightPx: geometry.heightPx ?? this.heightPx,
+        gutterPx: geometry.gutterPx ?? this.gutterPx,
+        rulerPx: geometry.rulerPx ?? this.rulerPx
+      }
+    );
+  }
+};
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function zoomTimeAboutCursor(scale, x, factor, bounds = DEFAULT_CURVE_ZOOM) {
+  const anchorTick = scale.xToTick(x);
+  const requested = scale.pxPerTick * (Number.isFinite(factor) && factor > 0 ? factor : 1);
+  const pxPerTick = Math.min(bounds.max, Math.max(bounds.min, requested));
+  return {
+    pxPerTick,
+    scrollTick: anchorTick - (x - scale.gutterPx) / pxPerTick,
+    minValue: scale.minValue,
+    maxValue: scale.maxValue
+  };
+}
+function zoomValueAboutCursor(scale, y, factor) {
+  const anchorValue = scale.yToValue(y);
+  const safeFactor = Number.isFinite(factor) && factor > 0 ? factor : 1;
+  const span = (scale.maxValue - scale.minValue) / safeFactor;
+  const fraction = (scale.maxValue - anchorValue) / (scale.maxValue - scale.minValue);
+  const maxValue = anchorValue + span * fraction;
+  return {
+    pxPerTick: scale.pxPerTick,
+    scrollTick: scale.scrollTick,
+    minValue: maxValue - span,
+    maxValue
+  };
+}
+function wheelZoomFactor(deltaY, sensitivity = 0.01) {
+  const raw = Number.isFinite(deltaY) ? deltaY : 0;
+  const clamped = Math.max(-10, Math.min(10, raw));
+  return Math.pow(2, -clamped * sensitivity * 10);
+}
+function fitValueRange(extent, marginFraction = 0.1) {
+  if (!extent || !Number.isFinite(extent.min) || !Number.isFinite(extent.max)) {
+    return { minValue: 0, maxValue: 1 };
+  }
+  const span = extent.max - extent.min;
+  const margin = Math.max(span * marginFraction, 0.5);
+  return { minValue: extent.min - margin, maxValue: extent.max + margin };
+}
+
+// src/edit/nodegraph/scale.ts
+var DEFAULT_GRAPH_ZOOM = { min: 0.05, max: 4 };
+var XenoGraphScale = class _XenoGraphScale {
+  zoom;
+  x;
+  y;
+  widthPx;
+  heightPx;
+  constructor(state, geometry) {
+    this.widthPx = Math.max(1, finiteOr2(geometry.widthPx, 1));
+    this.heightPx = Math.max(1, finiteOr2(geometry.heightPx, 1));
+    this.zoom = Math.max(Number.MIN_VALUE, finiteOr2(state.zoom, 1));
+    this.x = finiteOr2(state.x, 0);
+    this.y = finiteOr2(state.y, 0);
+  }
+  /** Graph-space width of the viewport. */
+  get graphWidth() {
+    return this.widthPx / this.zoom;
+  }
+  /** Graph-space height of the viewport. */
+  get graphHeight() {
+    return this.heightPx / this.zoom;
+  }
+  /** The visible rectangle in graph space. */
+  get viewport() {
+    return { x: this.x, y: this.y, width: this.graphWidth, height: this.graphHeight };
+  }
+  /** Container-relative screen point → graph point. */
+  screenToGraph(px, py) {
+    return { x: this.x + finiteOr2(px, 0) / this.zoom, y: this.y + finiteOr2(py, 0) / this.zoom };
+  }
+  /** Graph point → container-relative screen point. */
+  graphToScreen(gx, gy) {
+    return { x: (finiteOr2(gx, 0) - this.x) * this.zoom, y: (finiteOr2(gy, 0) - this.y) * this.zoom };
+  }
+  /** A graph-space distance → pixels. */
+  toPx(distance) {
+    return finiteOr2(distance, 0) * this.zoom;
+  }
+  /** A pixel distance → graph space. Used for screen-space hit thresholds. */
+  toGraph(px) {
+    return finiteOr2(px, 0) / this.zoom;
+  }
+  /** A copy with new state. */
+  with(state) {
+    return new _XenoGraphScale(
+      { zoom: state.zoom ?? this.zoom, x: state.x ?? this.x, y: state.y ?? this.y },
+      { widthPx: this.widthPx, heightPx: this.heightPx }
+    );
+  }
+  /** A copy with new geometry. */
+  resized(geometry) {
+    return new _XenoGraphScale(
+      { zoom: this.zoom, x: this.x, y: this.y },
+      { widthPx: geometry.widthPx ?? this.widthPx, heightPx: geometry.heightPx ?? this.heightPx }
+    );
+  }
+};
+function finiteOr2(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function zoomAboutCursor(scale, px, py, factor, bounds = DEFAULT_GRAPH_ZOOM) {
+  const anchor = scale.screenToGraph(px, py);
+  const requested = scale.zoom * (Number.isFinite(factor) && factor > 0 ? factor : 1);
+  const zoom = Math.min(bounds.max, Math.max(bounds.min, requested));
+  return { zoom, x: anchor.x - px / zoom, y: anchor.y - py / zoom };
+}
+function fitToBounds(bounds, widthPx, heightPx, zoomBounds = DEFAULT_GRAPH_ZOOM, paddingPx = 40) {
+  if (!bounds || bounds.width <= 0 || bounds.height <= 0) return { zoom: 1, x: 0, y: 0 };
+  const usableW = Math.max(1, widthPx - paddingPx * 2);
+  const usableH = Math.max(1, heightPx - paddingPx * 2);
+  const zoom = Math.min(
+    zoomBounds.max,
+    Math.max(zoomBounds.min, Math.min(usableW / bounds.width, usableH / bounds.height))
+  );
+  const x = bounds.x + bounds.width / 2 - widthPx / zoom / 2;
+  const y = bounds.y + bounds.height / 2 - heightPx / zoom / 2;
+  return { zoom, x, y };
+}
+function graphBounds(nodes) {
+  if (nodes.length === 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const node of nodes) {
+    if (!Number.isFinite(node.x) || !Number.isFinite(node.y)) continue;
+    minX = Math.min(minX, node.x);
+    minY = Math.min(minY, node.y);
+    maxX = Math.max(maxX, node.x + Math.max(1, node.width));
+    maxY = Math.max(maxY, node.y + Math.max(1, node.height));
+  }
+  if (!Number.isFinite(minX)) return null;
+  return { x: minX, y: minY, width: Math.max(1, maxX - minX), height: Math.max(1, maxY - minY) };
+}
+
+// src/edit/nodegraph/types.ts
+function portRefId(ref) {
+  return `${ref.nodeId}${ref.portId}`;
+}
+function edgeKey(edge) {
+  return `${edge.fromNodeId}${edge.fromPortId}${edge.toNodeId}${edge.toPortId}`;
+}
+function findPort(node, portId) {
+  return node.inputs.find((p) => p.id === portId) ?? node.outputs.find((p) => p.id === portId) ?? null;
+}
+function portHasRoom(port, existingCount) {
+  if (port.multiple !== void 0) return port.multiple || existingCount === 0;
+  return port.direction === "out" ? true : existingCount === 0;
+}
+function nodeBounds(node) {
+  return { x: node.x, y: node.y, width: Math.max(1, node.width), height: Math.max(1, node.height) };
+}
+function boxesIntersect(a, b) {
+  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+
+// src/edit/nodegraph/spatial.ts
+var XenoNodeIndex = class {
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  all;
+  constructor(nodes) {
+    this.all = nodes;
+    this.cellSize = chooseCellSize(nodes);
+    for (const node of nodes) {
+      const x0 = Math.floor(node.x / this.cellSize);
+      const y0 = Math.floor(node.y / this.cellSize);
+      const x1 = Math.floor((node.x + Math.max(1, node.width)) / this.cellSize);
+      const y1 = Math.floor((node.y + Math.max(1, node.height)) / this.cellSize);
+      for (let cx = x0; cx <= x1; cx += 1) {
+        for (let cy = y0; cy <= y1; cy += 1) {
+          const key = `${cx},${cy}`;
+          const bucket = this.cells.get(key);
+          if (bucket) bucket.push(node);
+          else this.cells.set(key, [node]);
+        }
+      }
+    }
+  }
+  /** Bucket size, for tests. */
+  get bucketSize() {
+    return this.cellSize;
+  }
+  /**
+   * Nodes intersecting a box.
+   *
+   * @param box - The query rectangle in graph space.
+   * @returns Matching nodes, each at most once.
+   */
+  query(box) {
+    const x0 = Math.floor(box.x / this.cellSize);
+    const y0 = Math.floor(box.y / this.cellSize);
+    const x1 = Math.floor((box.x + box.width) / this.cellSize);
+    const y1 = Math.floor((box.y + box.height) / this.cellSize);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (let cx = x0; cx <= x1; cx += 1) {
+      for (let cy = y0; cy <= y1; cy += 1) {
+        for (const node of this.cells.get(`${cx},${cy}`) ?? []) {
+          if (seen.has(node.id)) continue;
+          seen.add(node.id);
+          if (boxesIntersect(node, { ...box, width: Math.max(0, box.width), height: Math.max(0, box.height) })) {
+            out.push(node);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /** The topmost node containing a point, or `null`. */
+  hit(x, y) {
+    const candidates = this.query({ x, y, width: 1e-3, height: 1e-3 });
+    if (candidates.length === 0) return null;
+    let best = null;
+    for (const node of candidates) {
+      if (x >= node.x && x <= node.x + node.width && y >= node.y && y <= node.y + node.height) {
+        if (!best || this.all.indexOf(node) > this.all.indexOf(best)) best = node;
+      }
+    }
+    return best;
+  }
+};
+function chooseCellSize(nodes) {
+  if (nodes.length === 0) return 256;
+  const sizes = [];
+  for (const node of nodes) {
+    const size = Math.max(node.width || 1, node.height || 1);
+    if (Number.isFinite(size) && size > 0) sizes.push(size);
+  }
+  if (sizes.length === 0) return 256;
+  sizes.sort((a, b) => a - b);
+  const median = sizes[Math.floor(sizes.length / 2)];
+  return Math.max(32, Math.min(4096, median * 2));
+}
+function edgeBounds(from, to, slack = 64) {
+  const x = Math.min(from.x, to.x) - slack;
+  const y = Math.min(from.y, to.y) - slack;
+  return {
+    x,
+    y,
+    width: Math.abs(to.x - from.x) + slack * 2,
+    height: Math.abs(to.y - from.y) + slack * 2
+  };
+}
+function visibleEdges(edges, portPosition, viewport) {
+  const out = [];
+  for (const edge of edges) {
+    const from = portPosition(edge.fromNodeId, edge.fromPortId);
+    const to = portPosition(edge.toNodeId, edge.toPortId);
+    if (!from || !to) continue;
+    if (!boxesIntersect(edgeBounds(from, to), viewport)) continue;
+    out.push({ edge, from, to });
+  }
+  return out;
+}
+function edgePath(from, to) {
+  const dx = Math.abs(to.x - from.x);
+  const reach = Math.max(40, Math.min(dx * 0.6, 240));
+  return `M${from.x},${from.y} C${from.x + reach},${from.y} ${to.x - reach},${to.y} ${to.x},${to.y}`;
+}
+function distanceToEdge(point, from, to, samples = 16) {
+  const dx = Math.abs(to.x - from.x);
+  const reach = Math.max(40, Math.min(dx * 0.6, 240));
+  const c1 = { x: from.x + reach, y: from.y };
+  const c2 = { x: to.x - reach, y: to.y };
+  let best = Number.POSITIVE_INFINITY;
+  for (let i = 0; i <= samples; i += 1) {
+    const t = i / samples;
+    const mt = 1 - t;
+    const x = mt * mt * mt * from.x + 3 * mt * mt * t * c1.x + 3 * mt * t * t * c2.x + t * t * t * to.x;
+    const y = mt * mt * mt * from.y + 3 * mt * mt * t * c1.y + 3 * mt * t * t * c2.y + t * t * t * to.y;
+    best = Math.min(best, Math.hypot(x - point.x, y - point.y));
+  }
+  return best;
+}
+
+export {
+  DEFAULT_CURVE_ZOOM,
+  XenoCurveScale,
+  zoomTimeAboutCursor,
+  zoomValueAboutCursor,
+  wheelZoomFactor,
+  fitValueRange,
+  DEFAULT_GRAPH_ZOOM,
+  XenoGraphScale,
+  zoomAboutCursor,
+  fitToBounds,
+  graphBounds,
+  portRefId,
+  edgeKey,
+  findPort,
+  portHasRoom,
+  nodeBounds,
+  boxesIntersect,
+  XenoNodeIndex,
+  edgeBounds,
+  visibleEdges,
+  edgePath,
+  distanceToEdge
+};

package/dist/chunk-YSMDUREC.js

@@ -0,0 +1,238 @@
+// src/icons/glyphs.tsx
+import Copy from "@xenosystem/elements/elements/copy";
+import Download from "@xenosystem/elements/elements/download";
+import Plus from "@xenosystem/elements/elements/plus";
+import Minus from "@xenosystem/elements/elements/minus";
+import Refresh from "@xenosystem/elements/elements/refresh";
+import X from "@xenosystem/elements/elements/x";
+
+// src/icons/elements.tsx
+import { XenoElement } from "@xenosystem/elements-react";
+import { jsx } from "react/jsx-runtime";
+var GLYPH_STROKE_WIDTH = 1.5;
+function fromElement(decl, defaultSize = 11, state) {
+  const Glyph = ({ size = defaultSize, className }) => /* @__PURE__ */ jsx(XenoElement, { decl, state, size, strokeWidth: GLYPH_STROKE_WIDTH, className, "aria-hidden": "true", role: void 0, "aria-label": void 0 });
+  Glyph.displayName = `Element(${decl.id})`;
+  return Glyph;
+}
+
+// src/icons/glyphs.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Svg({ children, size = 11 }) {
+  return /* @__PURE__ */ jsx2("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children });
+}
+var RefreshGlyph = fromElement(Refresh);
+var XGlyph = fromElement(X);
+var PlusGlyph = fromElement(Plus);
+var MinusGlyph = fromElement(Minus);
+function ChevronGlyph({ direction = "right", size } = {}) {
+  const d = direction === "left" ? "m15 18-6-6 6-6" : direction === "up" ? "m18 15-6-6-6 6" : direction === "down" ? "m6 9 6 6 6-6" : "m9 18 6-6-6-6";
+  return /* @__PURE__ */ jsx2(Svg, { size, children: /* @__PURE__ */ jsx2("path", { d }) });
+}
+var DownloadGlyph = fromElement(Download);
+function PlugGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 22v-5" }),
+    /* @__PURE__ */ jsx2("path", { d: "M9 8V2M15 8V2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M18 8v3a6 6 0 0 1-12 0V8Z" })
+  ] });
+}
+function SortAscGlyph({ size = 9 } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "m5 12 7-7 7 7" }),
+    /* @__PURE__ */ jsx2("path", { d: "M12 19V5" })
+  ] });
+}
+function SortDescGlyph({ size = 9 } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 5v14" }),
+    /* @__PURE__ */ jsx2("path", { d: "m19 12-7 7-7-7" })
+  ] });
+}
+function ExpandGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 22v-6" }),
+    /* @__PURE__ */ jsx2("path", { d: "M12 8V2" }),
+    /* @__PURE__ */ jsx2("path", { d: "m9 5 3-3 3 3" }),
+    /* @__PURE__ */ jsx2("path", { d: "m9 19 3 3 3-3" }),
+    /* @__PURE__ */ jsx2("path", { d: "M4 12H2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M10 12H8" }),
+    /* @__PURE__ */ jsx2("path", { d: "M16 12h-2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 12h-2" })
+  ] });
+}
+function CollapseGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 22v-6" }),
+    /* @__PURE__ */ jsx2("path", { d: "M12 8V2" }),
+    /* @__PURE__ */ jsx2("path", { d: "m9 13 3 3 3-3" }),
+    /* @__PURE__ */ jsx2("path", { d: "m9 11 3-3 3 3" }),
+    /* @__PURE__ */ jsx2("path", { d: "M4 12H2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 12h-2" })
+  ] });
+}
+var CopyGlyph = fromElement(Copy);
+function ClearGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "3", y: "3", width: "18", height: "18", rx: "3" }),
+    /* @__PURE__ */ jsx2("path", { d: "m6 6 12 12" })
+  ] });
+}
+function CancelGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsx2(Svg, { size, children: /* @__PURE__ */ jsx2("rect", { x: "5", y: "5", width: "14", height: "14", rx: "2" }) });
+}
+function RetryGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M21 12a9 9 0 1 1-3.36-7" }),
+    /* @__PURE__ */ jsx2("path", { d: "M21 3v6h-6" })
+  ] });
+}
+function CaseGlyph({ size = 12 } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "m3 15 4-8 4 8" }),
+    /* @__PURE__ */ jsx2("path", { d: "M4 13h6" }),
+    /* @__PURE__ */ jsx2("rect", { x: "15", y: "9", width: "6", height: "6", rx: "1.5" }),
+    /* @__PURE__ */ jsx2("path", { d: "M21 9v6" })
+  ] });
+}
+function WholeWordGlyph({ size = 12 } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M7 12h10" }),
+    /* @__PURE__ */ jsx2("path", { d: "M3 7v10" }),
+    /* @__PURE__ */ jsx2("path", { d: "M21 7v10" })
+  ] });
+}
+function RegexGlyph({ size = 12 } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 4v8" }),
+    /* @__PURE__ */ jsx2("path", { d: "m8.5 6 7 4" }),
+    /* @__PURE__ */ jsx2("path", { d: "m8.5 10 7-4" }),
+    /* @__PURE__ */ jsx2("path", { d: "M5 18h2" })
+  ] });
+}
+function AlignLeftGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "6", y: "14", width: "9", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "6", y: "4", width: "16", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M2 2v20" })
+  ] });
+}
+function AlignHCenterGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 2v20" }),
+    /* @__PURE__ */ jsx2("path", { d: "M8 10H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h4" }),
+    /* @__PURE__ */ jsx2("path", { d: "M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4" }),
+    /* @__PURE__ */ jsx2("path", { d: "M8 20H7a2 2 0 0 1-2-2v-2a2 2 0 0 1 2-2h1" }),
+    /* @__PURE__ */ jsx2("path", { d: "M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1" })
+  ] });
+}
+function AlignRightGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "2", y: "4", width: "16", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "9", y: "14", width: "9", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 22V2" })
+  ] });
+}
+function AlignTopGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "4", y: "6", width: "6", height: "16", rx: "2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "14", y: "6", width: "6", height: "9", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 2H2" })
+  ] });
+}
+function AlignVCenterGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M2 12h20" }),
+    /* @__PURE__ */ jsx2("path", { d: "M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4" }),
+    /* @__PURE__ */ jsx2("path", { d: "M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4" }),
+    /* @__PURE__ */ jsx2("path", { d: "M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1" }),
+    /* @__PURE__ */ jsx2("path", { d: "M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1" })
+  ] });
+}
+function AlignBottomGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "4", y: "2", width: "6", height: "16", rx: "2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "14", y: "9", width: "6", height: "9", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 22H2" })
+  ] });
+}
+function DistributeHGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "9", y: "9", width: "6", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M4 22V2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M20 22V2" })
+  ] });
+}
+function DistributeVGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "9", y: "9", width: "6", height: "6", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 20H2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M22 4H2" })
+  ] });
+}
+function BringToFrontGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "8", y: "8", width: "8", height: "8", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M4 10a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M14 20a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2" })
+  ] });
+}
+function SendToBackGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "14", y: "14", width: "8", height: "8", rx: "2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "2", y: "2", width: "8", height: "8", rx: "2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M7 14v1a2 2 0 0 0 2 2h1" }),
+    /* @__PURE__ */ jsx2("path", { d: "M14 7h1a2 2 0 0 1 2 2v1" })
+  ] });
+}
+function GroupGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("path", { d: "M3 7V5a2 2 0 0 1 2-2h2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M17 3h2a2 2 0 0 1 2 2v2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M21 17v2a2 2 0 0 1-2 2h-2" }),
+    /* @__PURE__ */ jsx2("path", { d: "M7 21H5a2 2 0 0 1-2-2v-2" }),
+    /* @__PURE__ */ jsx2("rect", { x: "7", y: "7", width: "5", height: "5", rx: "1" }),
+    /* @__PURE__ */ jsx2("rect", { x: "12", y: "12", width: "5", height: "5", rx: "1" })
+  ] });
+}
+function UngroupGlyph({ size } = {}) {
+  return /* @__PURE__ */ jsxs(Svg, { size, children: [
+    /* @__PURE__ */ jsx2("rect", { x: "2", y: "4", width: "8", height: "6", rx: "1" }),
+    /* @__PURE__ */ jsx2("rect", { x: "14", y: "14", width: "8", height: "6", rx: "1" })
+  ] });
+}
+
+export {
+  fromElement,
+  Svg,
+  RefreshGlyph,
+  XGlyph,
+  PlusGlyph,
+  MinusGlyph,
+  ChevronGlyph,
+  DownloadGlyph,
+  PlugGlyph,
+  SortAscGlyph,
+  SortDescGlyph,
+  ExpandGlyph,
+  CollapseGlyph,
+  CopyGlyph,
+  ClearGlyph,
+  CancelGlyph,
+  RetryGlyph,
+  CaseGlyph,
+  WholeWordGlyph,
+  RegexGlyph,
+  AlignLeftGlyph,
+  AlignHCenterGlyph,
+  AlignRightGlyph,
+  AlignTopGlyph,
+  AlignVCenterGlyph,
+  AlignBottomGlyph,
+  DistributeHGlyph,
+  DistributeVGlyph,
+  BringToFrontGlyph,
+  SendToBackGlyph,
+  GroupGlyph,
+  UngroupGlyph
+};