@pixerate/editor 0.136.0 → 0.137.0

package/dist/chunk-64PYNEHJ.js

@@ -1,340 +0,0 @@
-import {
-  CoverageMap,
-  PaintGradientSampler,
-  TIP_GRADIENT_STEPS,
-  applyStrokeToTile,
-  dabRect,
-  gradientDabColor,
-  hexToPaintRgb,
-  normalizeBrush,
-  rasterizeDab,
-  resolvePaintGradient,
-  scalePaintGradient
-} from "./chunk-EM3FMJWE.js";
-import {
-  BRUSHSTROKE_MAX_SCALE,
-  BRUSHSTROKE_MIN_SCALE
-} from "./chunk-63AZAUSN.js";
-import {
-  TILE,
-  TiledSurface,
-  emptySurface,
-  finishTile,
-  readRegion,
-  tileKey,
-  tilesInRect
-} from "./chunk-BR7EKQUP.js";
-import {
-  pngDataUrl
-} from "./chunk-7QN76ESJ.js";
-
-// src/paint/path-stroke.ts
-function lean(s) {
-  if (typeof s.altitude === "number" && Number.isFinite(s.altitude)) {
-    return { amount: 1 - Math.min(1, Math.max(0, s.altitude / (Math.PI / 2))), azimuth: s.azimuth ?? 0 };
-  }
-  if (typeof s.tiltX === "number" || typeof s.tiltY === "number") {
-    const tx = (s.tiltX ?? 0) * Math.PI / 180;
-    const ty = (s.tiltY ?? 0) * Math.PI / 180;
-    if (tx === 0 && ty === 0) return { amount: 0, azimuth: 0 };
-    const az = Math.atan2(Math.tan(ty), Math.tan(tx));
-    const alt = Math.atan(1 / Math.hypot(Math.tan(tx), Math.tan(ty)));
-    return { amount: 1 - alt / (Math.PI / 2), azimuth: az };
-  }
-  return null;
-}
-function pathStrokeDabs(samples, options) {
-  const brush = normalizeBrush(options.brush);
-  const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];
-  if (!pts.length) return [];
-  const tilt = options.tilt ?? {};
-  const minSize = Math.min(1, Math.max(0, options.minSize ?? 0));
-  let index = 0;
-  const t0 = pts.find((s) => typeof s.t === "number" && Number.isFinite(s.t))?.t ?? null;
-  const dab = (x, y, p, l, dir, travel = 0, time = null, speed = null) => {
-    const pr = Math.min(1, Math.max(0, p));
-    const lean0 = l?.amount ?? 0;
-    const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * pr : 1) * (1 + 1.5 * (tilt.size ?? 0) * lean0);
-    let angle = brush.angle * Math.PI / 180;
-    if (options.followPath) angle += dir;
-    if (tilt.followAzimuth && l) angle = -l.azimuth;
-    const roundness = Math.max(0.05, brush.roundness * (1 - 0.85 * (tilt.roundness ?? 0) * lean0));
-    const op = brush.pressureOpacity ? pr : 1;
-    const params = { travel, index: index++, pressure: pr, lean: lean0, speed, direction: dir, time: time === null || t0 === null ? null : time - t0 };
-    return { x, y, radius: Math.max(0.5, size / 2), alpha: brush.flow, opacity: brush.opacity * op, angle, roundness, params };
-  };
-  const out = [];
-  const pressure = (s) => typeof s.pressure === "number" && Number.isFinite(s.pressure) ? s.pressure : 1;
-  if (pts.length === 1) {
-    out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), 0));
-    return out;
-  }
-  let carry = 0;
-  let along = 0;
-  const timeOf = (s) => typeof s.t === "number" && Number.isFinite(s.t) ? s.t : null;
-  out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), Math.atan2(-(pts[1].y - pts[0].y), pts[1].x - pts[0].x), 0, timeOf(pts[0])));
-  for (let i = 0; i + 1 < pts.length; i++) {
-    const a = pts[i];
-    const b = pts[i + 1];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const len = Math.hypot(dx, dy);
-    if (len === 0) continue;
-    const dir = Math.atan2(-dy, dx);
-    const la = lean(a);
-    const lb = lean(b);
-    const ta = timeOf(a);
-    const tb = timeOf(b);
-    const speed = ta !== null && tb !== null && tb > ta ? len / (tb - ta) : null;
-    let t = carry;
-    for (; ; ) {
-      const f = t / len;
-      if (f > 1) break;
-      const p = pressure(a) + (pressure(b) - pressure(a)) * f;
-      const l = la && lb ? { amount: la.amount + (lb.amount - la.amount) * f, azimuth: la.azimuth + (lb.azimuth - la.azimuth) * f } : la ?? lb;
-      const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * p : 1);
-      const step = Math.max(0.5, size * brush.spacing);
-      if (t > 0 || i > 0) out.push(dab(a.x + dx * f, a.y + dy * f, p, l, dir, along + t, ta !== null && tb !== null ? ta + (tb - ta) * f : null, speed));
-      t += step;
-    }
-    carry = t - len;
-    along += len;
-  }
-  return out;
-}
-function pathStrokeCoverage(samples, options) {
-  const brush = normalizeBrush(options.brush);
-  const coverage = new CoverageMap();
-  const dabs = pathStrokeDabs(samples, options);
-  const g = options.gradient?.paint.type === "gradient" ? options.gradient : null;
-  const sampler = g ? new PaintGradientSampler(resolvePaintGradient(g.paint, g.colors ?? { paint: "#000000", secondary: "#ffffff" }), g.seed ?? 0) : null;
-  const tipTable = sampler?.acrossTip ? sampler.tipTable(TIP_GRADIENT_STEPS) : null;
-  const scratch = { field: new Float32Array(0), sample: { rgb: [0, 0, 0], alpha: 1 } };
-  let buf = new Float32Array(0);
-  let bounds = null;
-  for (const d of dabs) {
-    const rect = dabRect(d, brush.hardness);
-    const n = rect.width * rect.height;
-    if (n <= 0) continue;
-    if (buf.length < n) buf = new Float32Array(n);
-    const vals = buf.subarray(0, n);
-    rasterizeDab(d, brush.hardness, rect, vals);
-    if (sampler) {
-      const { color, field } = gradientDabColor(sampler, tipTable, d, d.params, rect, vals, scratch);
-      coverage.accumulate(rect, vals, d.opacity, color, field);
-    } else coverage.accumulate(rect, vals, d.opacity);
-    if (!bounds) bounds = { ...rect };
-    else {
-      const x = Math.min(bounds.x, rect.x);
-      const y = Math.min(bounds.y, rect.y);
-      bounds = { x, y, width: Math.max(bounds.x + bounds.width, rect.x + rect.width) - x, height: Math.max(bounds.y + bounds.height, rect.y + rect.height) - y };
-    }
-  }
-  return { coverage, bounds, dabs: dabs.length };
-}
-function paintPathStroke(surface, samples, options) {
-  if (surface.channels !== 4) throw new Error("paintPathStroke paints RGBA surfaces (4 channels).");
-  const brush = normalizeBrush(options.brush);
-  const hex = (c) => "#" + [0, 1, 2].map((i) => Math.round(Math.min(255, Math.max(0, c[i]))).toString(16).padStart(2, "0")).join("");
-  let color = options.color;
-  if (options.paint?.paint.type === "color") {
-    const rgb = hexToPaintRgb(options.paint.paint.color).map((v) => Math.round(v * 255));
-    color = [rgb[0], rgb[1], rgb[2], color[3]];
-  }
-  const gradient = options.paint?.paint.type === "gradient" ? { ...options.paint, colors: options.paint.colors ?? { paint: hex(color), secondary: "#ffffff" } } : null;
-  const { coverage, bounds, dabs } = pathStrokeCoverage(samples, { ...options, gradient });
-  if (!bounds) return { surface, bounds: null, dabs };
-  const offset = options.offset ?? { x: 0, y: 0 };
-  const apply = {
-    mode: options.mode ?? "paint",
-    color,
-    background: [0, 0, 0, 0],
-    opacity: brush.opacity,
-    blend: options.blend ?? brush.blend,
-    lockTransparency: options.lockTransparency ?? false,
-    selection: options.selection ?? null,
-    offset
-  };
-  const tiles = new Map(surface.tiles);
-  for (const { tx, ty } of tilesInRect({ x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {
-    const key = tileKey(tx, ty);
-    const src = surface.tiles.get(key)?.data;
-    const base = src && src.length === TILE * TILE * 4 ? src : new Uint8ClampedArray(TILE * TILE * 4);
-    const t = finishTile(applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
-    if (t) tiles.set(key, t);
-    else tiles.delete(key);
-  }
-  return { surface: new TiledSurface(4, tiles, surface.defaultValue), bounds, dabs };
-}
-
-// src/paint/brushstroke.ts
-var DEFAULT_MAX_PIXELS = 4096 * 4096;
-var isProfilePath = (input) => !Array.isArray(input) && typeof input === "object" && input !== null && "points" in input;
-function profileAt(profile, f) {
-  if (!profile || !profile.length) return void 0;
-  if (profile.length === 1) return profile[0];
-  const u = Math.min(1, Math.max(0, f)) * (profile.length - 1);
-  const i = Math.min(profile.length - 2, Math.floor(u));
-  return profile[i] + (profile[i + 1] - profile[i]) * (u - i);
-}
-function brushstrokeSamples(input) {
-  if (!isProfilePath(input)) return input.map((s) => ({ ...s }));
-  const pts = input.points;
-  const lengths = [0];
-  for (let i = 1; i < pts.length; i++) lengths.push(lengths[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
-  const total = lengths.at(-1) ?? 0;
-  return pts.map((p, i) => {
-    const f = total > 0 ? lengths[i] / total : pts.length > 1 ? i / (pts.length - 1) : 0;
-    const s = { x: p.x, y: p.y };
-    const pressure = profileAt(input.pressure, f);
-    const tiltX = profileAt(input.tiltX, f);
-    const tiltY = profileAt(input.tiltY, f);
-    if (pressure !== void 0) s.pressure = pressure;
-    if (tiltX !== void 0) s.tiltX = tiltX;
-    if (tiltY !== void 0) s.tiltY = tiltY;
-    return s;
-  });
-}
-var REFUSED_ENGINES = {
-  wet: "is a wet brush, and wet paint needs an area to flow in (paint it on a wet layer in the paint editor)",
-  mixer: "is a Mixer Brush, which picks up paint from under the tip and has none on a standalone stroke",
-  blender: "is a blender, which only moves paint that is already there",
-  smudge: "is a smudge brush, which only moves paint that is already there",
-  eraser: "is an eraser, which has nothing to remove on a standalone stroke"
-};
-function brushstrokeStrokeOptions(brush) {
-  if (!brush || typeof brush !== "object") throw new Error("A brushstroke needs a brush: tip settings ({ size, hardness, \u2026 }) or a paint brush preset.");
-  if (!("tip" in brush) || !brush.tip) return { brush: normalizeBrush(brush) };
-  const engine = brush.engine ?? "dab";
-  if (engine !== "dab") {
-    const label = brush.name ?? brush.id ?? "This brush";
-    const why = REFUSED_ENGINES[engine] ?? `uses the '${engine}' engine, which renderBrushstroke does not draw`;
-    throw new Error(`Brushstrokes render dry media only: '${label}' ${why}. Pick a dry brush (a dab-engine preset such as a pencil, pastel, charcoal, marker, ink or airbrush) or plain tip settings.`);
-  }
-  const d = brush.dynamics ?? {};
-  const tilt = { size: d.tiltSize ?? 0, roundness: d.tiltRoundness ?? 0 };
-  return {
-    brush: normalizeBrush(brush.tip),
-    followPath: brush.rotation === "stroke",
-    minSize: d.minSize ?? 0,
-    ...tilt.size || tilt.roundness ? { tilt } : {}
-  };
-}
-function isBrushstrokeBrush(brush) {
-  return !("tip" in brush) || !brush.tip || (brush.engine ?? "dab") === "dab";
-}
-var finite = (v) => typeof v === "number" && Number.isFinite(v);
-function renderBrushstroke(input, brush, options = {}) {
-  const strokeOptions = brushstrokeStrokeOptions(brush);
-  const samples = brushstrokeSamples(input);
-  for (const s of samples) if (!finite(s.x) || !finite(s.y)) throw new Error("Brushstroke samples need finite x and y.");
-  const solid = options.paint && !("type" in options.paint) ? options.paint.color : null;
-  const source = options.paint && "type" in options.paint ? options.paint : null;
-  const color = solid ?? options.color ?? [0, 0, 0, 255];
-  let scale = finite(options.scale) && options.scale > 0 ? Math.min(BRUSHSTROKE_MAX_SCALE, Math.max(BRUSHSTROKE_MIN_SCALE, options.scale)) : 1;
-  if (!samples.length) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs: 0 };
-  const tip = strokeOptions.brush;
-  const reach = tip.size * (1 + 1.5 * (strokeOptions.tilt?.size ?? 0)) + 4;
-  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
-  for (const s of samples) {
-    x0 = Math.min(x0, s.x);
-    y0 = Math.min(y0, s.y);
-    x1 = Math.max(x1, s.x);
-    y1 = Math.max(y1, s.y);
-  }
-  const maxPixels = finite(options.maxPixels) && options.maxPixels > 0 ? options.maxPixels : DEFAULT_MAX_PIXELS;
-  const area = (x1 - x0 + reach) * (y1 - y0 + reach);
-  if (area * scale * scale > maxPixels) scale = Math.max(BRUSHSTROKE_MIN_SCALE, Math.sqrt(maxPixels / area));
-  const scaled = samples.map((s) => ({ ...s, x: s.x * scale, y: s.y * scale }));
-  const { surface, bounds, dabs } = paintPathStroke(emptySurface(4), scaled, {
-    ...strokeOptions,
-    brush: { ...tip, size: tip.size * scale },
-    closed: options.closed ?? strokeOptions.closed,
-    color,
-    // Gradient lengths are in path units: scale them with the image.
-    ...source ? { paint: { paint: source.type === "gradient" ? scalePaintGradient(source, scale) : source, seed: options.seed ?? 0 } } : {}
-  });
-  if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };
-  const rect = bounds;
-  const data = readRegion(surface, rect);
-  return {
-    image: { width: rect.width, height: rect.height, data },
-    bounds: { x: rect.x / scale, y: rect.y / scale, width: rect.width / scale, height: rect.height / scale },
-    scale,
-    dabs
-  };
-}
-function brushstrokeDataUrl(stroke) {
-  const { width, height, data } = stroke.image;
-  return width && height ? pngDataUrl(width, height, data) : "";
-}
-function brushstrokeToCanvas(stroke, createCanvas) {
-  const { width, height, data } = stroke.image;
-  if (!width || !height) return null;
-  const canvas = createCanvas(width, height);
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return null;
-  const img = ctx.createImageData(width, height);
-  img.data.set(data);
-  ctx.putImageData(img, 0, 0);
-  return canvas;
-}
-function hashString(s, h = 2166136261) {
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619) >>> 0;
-  }
-  return h;
-}
-function brushstrokeKey(input, brush, options = {}) {
-  const path = JSON.stringify(input);
-  const { brush: tip, ...rest } = brushstrokeStrokeOptions(brush);
-  const rest2 = JSON.stringify([tip, rest, options.paint ?? options.color ?? null, options.seed ?? 0, options.closed ?? false, options.maxPixels ?? null]);
-  const scale = finite(options.scale) ? options.scale : 1;
-  return `${hashString(path).toString(16)}:${path.length}:${hashString(rest2).toString(16)}:${scale}`;
-}
-var BrushstrokeCache = class {
-  constructor(capacity = 64) {
-    this.capacity = capacity;
-  }
-  capacity;
-  entries = /* @__PURE__ */ new Map();
-  /** Renders that missed the cache (for tests and stats). */
-  misses = 0;
-  get size() {
-    return this.entries.size;
-  }
-  /** The cached stroke for these arguments, rendering (and caching) it on a miss. */
-  render(input, brush, options = {}) {
-    const key = brushstrokeKey(input, brush, options);
-    const hit = this.entries.get(key);
-    if (hit) {
-      this.entries.delete(key);
-      this.entries.set(key, hit);
-      return hit;
-    }
-    this.misses++;
-    const out = renderBrushstroke(input, brush, options);
-    this.entries.set(key, out);
-    while (this.entries.size > Math.max(1, this.capacity)) this.entries.delete(this.entries.keys().next().value);
-    return out;
-  }
-  clear() {
-    this.entries.clear();
-  }
-};
-
-export {
-  pathStrokeDabs,
-  pathStrokeCoverage,
-  paintPathStroke,
-  brushstrokeSamples,
-  brushstrokeStrokeOptions,
-  isBrushstrokeBrush,
-  renderBrushstroke,
-  brushstrokeDataUrl,
-  brushstrokeToCanvas,
-  brushstrokeKey,
-  BrushstrokeCache
-};
-//# sourceMappingURL=chunk-64PYNEHJ.js.map

package/dist/chunk-64PYNEHJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/paint/path-stroke.ts","../src/paint/brushstroke.ts"],"sourcesContent":["/**\n * A brush stroke along a path: polyline samples, each with an optional pressure and pen tilt, are\n * walked at the brush's spacing (pressure and tilt interpolated between samples) into dabs, built\n * up in a coverage map and composited onto a layer. This is what a vector editor calls to draw a\n * path with a natural-media brush (\"brushstrokes on vector paths\"): the path is the data, the\n * pixels are rendered from it.\n *\n * - Pressure scales size and / or opacity as the brush says.\n * - Tilt (`tiltX` / `tiltY` in degrees, or `altitude` / `azimuth` in radians, as Pointer Events give\n *   them) widens the tip (`tilt.size`), flattens it along the lean (`tilt.roundness`), and with\n *   `tilt.followAzimuth` turns the tip to the lean, as a pen laid on its side does.\n * - With `followPath` the tip turns with the path (a calligraphic nib along a curve).\n *\n * Deterministic and DOM-free: the same samples and brush give the same pixels everywhere.\n */\n\nimport { applyStrokeToTile, CoverageMap, dabRect, gradientDabColor, normalizeBrush, rasterizeDab, TIP_GRADIENT_STEPS, type BrushSettings, type Dab } from './brush';\nimport { hexToPaintRgb, PaintGradientSampler, resolvePaintGradient, type PaintGradientSample, type PaintSource } from './gradient-paint';\nimport { TiledSurface, finishTile, tileKey, tilesInRect, TILE, type RasterRect } from '../raster/surface';\nimport type { BlendMode } from '../raster/blend';\n\n/** One sample of the path (document pixels). */\nexport interface PathSample {\n  x: number;\n  y: number;\n  /** 0..1 (default 1). */\n  pressure?: number;\n  /** Pointer Events tilt in degrees (−90..90). */\n  tiltX?: number;\n  tiltY?: number;\n  /** Radians above the surface (π/2 upright); overrides tiltX / tiltY. */\n  altitude?: number;\n  /** Radians clockwise from +x: where the pen leans (with altitude). */\n  azimuth?: number;\n  /** Milliseconds (gradient paint mapped by speed or time reads it). */\n  t?: number;\n}\n\nexport interface PathStrokeOptions {\n  brush: Partial<BrushSettings>;\n  /** How tilt shapes the tip (each 0..1; default none). */\n  tilt?: { size?: number; roundness?: number; followAzimuth?: boolean };\n  /** Turn the tip with the direction of the path (added to the brush angle). */\n  followPath?: boolean;\n  /** Size at zero pressure as a fraction of the full size, when pressure controls size (default 0). */\n  minSize?: number;\n  /** Join the last sample back to the first. */\n  closed?: boolean;\n}\n\n/** A pen's lean from a sample: 0 upright .. 1 flat, and the direction it leans (radians, clockwise from +x). */\nfunction lean(s: PathSample): { amount: number; azimuth: number } | null {\n  if (typeof s.altitude === 'number' && Number.isFinite(s.altitude)) {\n    return { amount: 1 - Math.min(1, Math.max(0, s.altitude / (Math.PI / 2))), azimuth: s.azimuth ?? 0 };\n  }\n  if (typeof s.tiltX === 'number' || typeof s.tiltY === 'number') {\n    const tx = ((s.tiltX ?? 0) * Math.PI) / 180;\n    const ty = ((s.tiltY ?? 0) * Math.PI) / 180;\n    if (tx === 0 && ty === 0) return { amount: 0, azimuth: 0 };\n    const az = Math.atan2(Math.tan(ty), Math.tan(tx));\n    const alt = Math.atan(1 / Math.hypot(Math.tan(tx), Math.tan(ty)));\n    return { amount: 1 - alt / (Math.PI / 2), azimuth: az };\n  }\n  return null;\n}\n\n/** The dabs of a brush stroke along `samples`, with pressure and tilt interpolated between them. */\nexport function pathStrokeDabs(samples: readonly PathSample[], options: PathStrokeOptions): Dab[] {\n  const brush = normalizeBrush(options.brush);\n  const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];\n  if (!pts.length) return [];\n  const tilt = options.tilt ?? {};\n  const minSize = Math.min(1, Math.max(0, options.minSize ?? 0));\n  let index = 0;\n  const t0 = pts.find((s) => typeof s.t === 'number' && Number.isFinite(s.t))?.t ?? null;\n  const dab = (x: number, y: number, p: number, l: { amount: number; azimuth: number } | null, dir: number, travel = 0, time: number | null = null, speed: number | null = null): Dab => {\n    const pr = Math.min(1, Math.max(0, p));\n    const lean0 = l?.amount ?? 0;\n    const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * pr : 1) * (1 + 1.5 * (tilt.size ?? 0) * lean0);\n    let angle = (brush.angle * Math.PI) / 180;\n    if (options.followPath) angle += dir;\n    if (tilt.followAzimuth && l) angle = -l.azimuth;\n    const roundness = Math.max(0.05, brush.roundness * (1 - 0.85 * (tilt.roundness ?? 0) * lean0));\n    const op = brush.pressureOpacity ? pr : 1;\n    const params = { travel, index: index++, pressure: pr, lean: lean0, speed, direction: dir, time: time === null || t0 === null ? null : time - t0 };\n    return { x, y, radius: Math.max(0.5, size / 2), alpha: brush.flow, opacity: brush.opacity * op, angle, roundness, params };\n  };\n  const out: Dab[] = [];\n  const pressure = (s: PathSample) => (typeof s.pressure === 'number' && Number.isFinite(s.pressure) ? s.pressure : 1);\n  if (pts.length === 1) {\n    out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), 0));\n    return out;\n  }\n  let carry = 0;\n  let along = 0;\n  const timeOf = (s: PathSample) => (typeof s.t === 'number' && Number.isFinite(s.t) ? s.t : null);\n  out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), Math.atan2(-(pts[1].y - pts[0].y), pts[1].x - pts[0].x), 0, timeOf(pts[0])));\n  for (let i = 0; i + 1 < pts.length; i++) {\n    const a = pts[i];\n    const b = pts[i + 1];\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    const len = Math.hypot(dx, dy);\n    if (len === 0) continue;\n    // Dab angles are counter-clockwise with y up, as the shared rasterizer reads them.\n    const dir = Math.atan2(-dy, dx);\n    const la = lean(a);\n    const lb = lean(b);\n    const ta = timeOf(a);\n    const tb = timeOf(b);\n    const speed = ta !== null && tb !== null && tb > ta ? len / (tb - ta) : null;\n    let t = carry;\n    for (;;) {\n      const f = t / len;\n      if (f > 1) break;\n      const p = pressure(a) + (pressure(b) - pressure(a)) * f;\n      const l = la && lb ? { amount: la.amount + (lb.amount - la.amount) * f, azimuth: la.azimuth + (lb.azimuth - la.azimuth) * f } : (la ?? lb);\n      const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * p : 1);\n      const step = Math.max(0.5, size * brush.spacing);\n      if (t > 0 || i > 0) out.push(dab(a.x + dx * f, a.y + dy * f, p, l, dir, along + t, ta !== null && tb !== null ? ta + (tb - ta) * f : null, speed));\n      t += step;\n    }\n    carry = t - len;\n    along += len;\n  }\n  return out;\n}\n\n/**\n * Gradient paint for a path stroke: a `PaintSource` gradient sampled dab by dab (by distance along\n * the path, pressure, tilt, speed, direction, time, across the tip or at random). `paint` /\n * `secondary` stops resolve to `colors` (default: the stroke colour and white).\n */\nexport interface PathStrokePaint {\n  paint: PaintSource;\n  /** Seed of the `random` mapping (default 0). */\n  seed?: number;\n  colors?: { paint: string; secondary: string };\n}\n\n/** The coverage of a brush stroke along `samples` (build-up towards each dab's opacity) and its bounds. */\nexport function pathStrokeCoverage(samples: readonly PathSample[], options: PathStrokeOptions & { gradient?: PathStrokePaint | null }): { coverage: CoverageMap; bounds: RasterRect | null; dabs: number } {\n  const brush = normalizeBrush(options.brush);\n  const coverage = new CoverageMap();\n  const dabs = pathStrokeDabs(samples, options);\n  const g = options.gradient?.paint.type === 'gradient' ? options.gradient : null;\n  const sampler = g ? new PaintGradientSampler(resolvePaintGradient(g.paint as Extract<PaintSource, { type: 'gradient' }>, g.colors ?? { paint: '#000000', secondary: '#ffffff' }), g.seed ?? 0) : null;\n  const tipTable = sampler?.acrossTip ? sampler.tipTable(TIP_GRADIENT_STEPS) : null;\n  const scratch: { field: Float32Array; sample: PaintGradientSample } = { field: new Float32Array(0), sample: { rgb: [0, 0, 0], alpha: 1 } };\n  let buf = new Float32Array(0);\n  let bounds: RasterRect | null = null;\n  for (const d of dabs) {\n    const rect = dabRect(d, brush.hardness);\n    const n = rect.width * rect.height;\n    if (n <= 0) continue;\n    if (buf.length < n) buf = new Float32Array(n);\n    const vals = buf.subarray(0, n);\n    rasterizeDab(d, brush.hardness, rect, vals);\n    if (sampler) {\n      const { color, field } = gradientDabColor(sampler, tipTable, d, d.params!, rect, vals, scratch);\n      coverage.accumulate(rect, vals, d.opacity, color, field);\n    } else coverage.accumulate(rect, vals, d.opacity);\n    if (!bounds) bounds = { ...rect };\n    else {\n      const x = Math.min(bounds.x, rect.x);\n      const y = Math.min(bounds.y, rect.y);\n      bounds = { x, y, width: Math.max(bounds.x + bounds.width, rect.x + rect.width) - x, height: Math.max(bounds.y + bounds.height, rect.y + rect.height) - y };\n    }\n  }\n  return { coverage, bounds, dabs: dabs.length };\n}\n\nexport interface PaintPathOptions extends PathStrokeOptions {\n  /** RGBA 0..255 of the paint (with gradient paint: its alpha, and the colour of `paint` stops). */\n  color: readonly [number, number, number, number];\n  /** Gradient paint (a `PaintSource`); a colour source replaces `color`'s RGB. */\n  paint?: PathStrokePaint | null;\n  /** `erase` removes paint instead (default `paint`). */\n  mode?: 'paint' | 'erase';\n  /** Blend mode (default the brush's). */\n  blend?: BlendMode;\n  /** Layer offset: layer pixel = document pixel − offset (default 0, 0). */\n  offset?: { x: number; y: number };\n  lockTransparency?: boolean;\n  /** Where paint may land (canvas-sized coverage 0..255), or none. */\n  selection?: { width: number; height: number; data: ArrayLike<number> } | null;\n}\n\n/**\n * Paints a brush stroke along `samples` onto an RGBA layer surface and returns the new surface\n * (the input is not changed; untouched tiles are shared) with the bounds it touched.\n */\nexport function paintPathStroke(surface: TiledSurface, samples: readonly PathSample[], options: PaintPathOptions): { surface: TiledSurface; bounds: RasterRect | null; dabs: number } {\n  if (surface.channels !== 4) throw new Error('paintPathStroke paints RGBA surfaces (4 channels).');\n  const brush = normalizeBrush(options.brush);\n  const hex = (c: readonly number[]) => '#' + [0, 1, 2].map((i) => Math.round(Math.min(255, Math.max(0, c[i]))).toString(16).padStart(2, '0')).join('');\n  let color = options.color;\n  if (options.paint?.paint.type === 'color') {\n    const rgb = hexToPaintRgb(options.paint.paint.color).map((v) => Math.round(v * 255));\n    color = [rgb[0], rgb[1], rgb[2], color[3]];\n  }\n  const gradient = options.paint?.paint.type === 'gradient' ? { ...options.paint, colors: options.paint.colors ?? { paint: hex(color), secondary: '#ffffff' } } : null;\n  const { coverage, bounds, dabs } = pathStrokeCoverage(samples, { ...options, gradient });\n  if (!bounds) return { surface, bounds: null, dabs };\n  const offset = options.offset ?? { x: 0, y: 0 };\n  const apply = {\n    mode: options.mode ?? 'paint',\n    color,\n    background: [0, 0, 0, 0] as const,\n    opacity: brush.opacity,\n    blend: options.blend ?? brush.blend,\n    lockTransparency: options.lockTransparency ?? false,\n    selection: options.selection ?? null,\n    offset,\n  };\n  const tiles = new Map(surface.tiles);\n  for (const { tx, ty } of tilesInRect({ x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {\n    const key = tileKey(tx, ty);\n    const src = surface.tiles.get(key)?.data;\n    const base = src && src.length === TILE * TILE * 4 ? src : new Uint8ClampedArray(TILE * TILE * 4);\n    const t = finishTile(applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);\n    if (t) tiles.set(key, t);\n    else tiles.delete(key);\n  }\n  return { surface: new TiledSurface(4, tiles, surface.defaultValue), bounds, dabs };\n}\n","/**\n * A brushstroke rendered on its own: a path (polyline samples with pressure, tilt and time, or\n * points plus pressure / tilt profiles along the length) and a dry brush in, an RGBA image and its\n * bounds out. The canvas renders brushed freehand strokes with it, and the vector editor\n * brushstrokes on vector paths; both keep the path as the data and the pixels as a cache.\n *\n * - Built on {@link paintPathStroke}: the same dabs, coverage and build-up as everywhere else.\n * - Rendered at `scale` image pixels per path unit (both the samples and the brush size scale), so\n *   a stroke looks the same at any zoom with more or fewer pixels. Snap zooms to\n *   {@link brushstrokeScaleBucket} so panning and small zoom changes reuse the same image.\n * - Dry media only. A wet brush needs an area to flow in (the paint editor's wet layer); mixer,\n *   blender and smudge brushes need paint under them. Those are refused with an error.\n * - Deterministic and DOM-free: the image is plain RGBA bytes. Turn it into a PNG data URL with\n *   {@link brushstrokeDataUrl}, or into a canvas through an injected factory\n *   ({@link brushstrokeToCanvas}).\n */\n\nimport { normalizeBrush, type BrushSettings } from './brush';\nimport { paintPathStroke, type PathSample, type PathStrokeOptions } from './path-stroke';\nimport { scalePaintGradient, type PaintSource } from './gradient-paint';\nimport { emptySurface, readRegion, type RasterRect } from '../raster/surface';\nimport { pngDataUrl } from '../raster/png';\nimport { BRUSHSTROKE_MAX_SCALE as MAX_SCALE, BRUSHSTROKE_MIN_SCALE as MIN_SCALE } from './brushstroke-scale';\n\nexport { brushstrokeScaleBucket, BRUSHSTROKE_MAX_SCALE, BRUSHSTROKE_MIN_SCALE } from './brushstroke-scale';\n\n/** One sample of a brushstroke: a {@link PathSample} plus an optional time stamp (milliseconds). */\nexport interface BrushstrokeSample extends PathSample {\n  t?: number;\n}\n\n/**\n * A path plus pen profiles along it. Each profile is a list of values spread evenly over the\n * path's length (first at the start, last at the end) and interpolated in between; one value is\n * constant. Missing profiles leave the samples upright at full pressure.\n */\nexport interface BrushstrokeProfilePath {\n  points: ReadonlyArray<{ x: number; y: number }>;\n  /** Pressure 0..1 along the length. */\n  pressure?: readonly number[];\n  /** Pointer Events tilt in degrees (−90..90) along the length. */\n  tiltX?: readonly number[];\n  tiltY?: readonly number[];\n}\n\nexport type BrushstrokeInput = readonly BrushstrokeSample[] | BrushstrokeProfilePath;\n\n/**\n * A brush for a brushstroke: plain tip settings, or a paint-editor brush (`PaintBrush` matches this\n * shape structurally). Only dab-engine brushes render; `rotation: 'stroke'` turns the tip with the\n * path, and `dynamics` give the size at zero pressure and how tilt shapes the tip. Grain, jitter and\n * velocity dynamics are not applied (there is no paper, and the result must be deterministic).\n */\nexport type BrushstrokeBrush =\n  | Partial<BrushSettings>\n  | {\n      id?: string;\n      name?: string;\n      engine?: string;\n      tip: Partial<BrushSettings>;\n      rotation?: string;\n      dynamics?: { minSize?: number; tiltSize?: number; tiltRoundness?: number };\n    };\n\n/**\n * What the stroke is painted with: a solid RGBA colour, or a `PaintSource` (one `#rrggbb` colour,\n * or gradient paint sampled dab by dab along the path: by distance, pressure, tilt, speed,\n * direction, time, across the tip or at random).\n */\nexport type BrushstrokePaint = { color: readonly [number, number, number, number] } | PaintSource;\n\nexport interface BrushstrokeOptions {\n  /** Image pixels per path unit (default 1). Use {@link brushstrokeScaleBucket} for a zoom. */\n  scale?: number;\n  /** RGBA 0..255 (default opaque black). Shorthand for `paint: { color }`. */\n  color?: readonly [number, number, number, number];\n  /** What to paint with (wins over `color`; with gradient paint, `color` fills `paint` stops and gives the alpha). */\n  paint?: BrushstrokePaint;\n  /** Seed of gradient paint's `random` mapping (default 0). */\n  seed?: number;\n  /** Join the last sample back to the first. */\n  closed?: boolean;\n  /**\n   * The largest image to render, in pixels (default 16 777 216, 4096²). A stroke that would be\n   * bigger at `scale` renders at a lower scale instead; the result's `scale` says which.\n   */\n  maxPixels?: number;\n}\n\n/** A rendered brushstroke. */\nexport interface BrushstrokeImage {\n  /** Straight-alpha RGBA bytes, `width × height × 4` (the same layout as `ImageData`). */\n  image: { width: number; height: number; data: Uint8ClampedArray };\n  /** Where the image goes, in path units: draw `image` stretched over this rectangle. Null for an empty stroke. */\n  bounds: { x: number; y: number; width: number; height: number } | null;\n  /** Image pixels per path unit it was rendered at. */\n  scale: number;\n  /** How many dabs the stroke laid down. */\n  dabs: number;\n}\n\nconst DEFAULT_MAX_PIXELS = 4096 * 4096;\n\nconst isProfilePath = (input: BrushstrokeInput): input is BrushstrokeProfilePath => !Array.isArray(input) && typeof input === 'object' && input !== null && 'points' in input;\n\n/** A profile's value at `f` (0..1 along the length), or undefined without one. */\nfunction profileAt(profile: readonly number[] | undefined, f: number): number | undefined {\n  if (!profile || !profile.length) return undefined;\n  if (profile.length === 1) return profile[0];\n  const u = Math.min(1, Math.max(0, f)) * (profile.length - 1);\n  const i = Math.min(profile.length - 2, Math.floor(u));\n  return profile[i] + (profile[i + 1] - profile[i]) * (u - i);\n}\n\n/** The samples of a brushstroke input: profile paths are sampled at their points by arc length. */\nexport function brushstrokeSamples(input: BrushstrokeInput): BrushstrokeSample[] {\n  if (!isProfilePath(input)) return input.map((s) => ({ ...s }));\n  const pts = input.points;\n  const lengths = [0];\n  for (let i = 1; i < pts.length; i++) lengths.push(lengths[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));\n  const total = lengths.at(-1) ?? 0;\n  return pts.map((p, i) => {\n    const f = total > 0 ? lengths[i] / total : pts.length > 1 ? i / (pts.length - 1) : 0;\n    const s: BrushstrokeSample = { x: p.x, y: p.y };\n    const pressure = profileAt(input.pressure, f);\n    const tiltX = profileAt(input.tiltX, f);\n    const tiltY = profileAt(input.tiltY, f);\n    if (pressure !== undefined) s.pressure = pressure;\n    if (tiltX !== undefined) s.tiltX = tiltX;\n    if (tiltY !== undefined) s.tiltY = tiltY;\n    return s;\n  });\n}\n\n/** Engines that cannot render a brushstroke on its own, and why. */\nconst REFUSED_ENGINES: Record<string, string> = {\n  wet: 'is a wet brush, and wet paint needs an area to flow in (paint it on a wet layer in the paint editor)',\n  mixer: 'is a Mixer Brush, which picks up paint from under the tip and has none on a standalone stroke',\n  blender: 'is a blender, which only moves paint that is already there',\n  smudge: 'is a smudge brush, which only moves paint that is already there',\n  eraser: 'is an eraser, which has nothing to remove on a standalone stroke',\n};\n\n/**\n * The tip settings and path-stroke options of a brushstroke brush. Throws for brushes that are not\n * dry dab brushes (wet, mixer, blender, smudge, eraser, impasto and the procedural engines).\n */\nexport function brushstrokeStrokeOptions(brush: BrushstrokeBrush): PathStrokeOptions {\n  if (!brush || typeof brush !== 'object') throw new Error('A brushstroke needs a brush: tip settings ({ size, hardness, … }) or a paint brush preset.');\n  if (!('tip' in brush) || !brush.tip) return { brush: normalizeBrush(brush as Partial<BrushSettings>) };\n  const engine = brush.engine ?? 'dab';\n  if (engine !== 'dab') {\n    const label = brush.name ?? brush.id ?? 'This brush';\n    const why = REFUSED_ENGINES[engine] ?? `uses the '${engine}' engine, which renderBrushstroke does not draw`;\n    throw new Error(`Brushstrokes render dry media only: '${label}' ${why}. Pick a dry brush (a dab-engine preset such as a pencil, pastel, charcoal, marker, ink or airbrush) or plain tip settings.`);\n  }\n  const d = brush.dynamics ?? {};\n  const tilt = { size: d.tiltSize ?? 0, roundness: d.tiltRoundness ?? 0 };\n  return {\n    brush: normalizeBrush(brush.tip),\n    followPath: brush.rotation === 'stroke',\n    minSize: d.minSize ?? 0,\n    ...(tilt.size || tilt.roundness ? { tilt } : {}),\n  };\n}\n\n/** Whether a brush renders as a brushstroke (a dry dab brush, or plain tip settings). */\nexport function isBrushstrokeBrush(brush: BrushstrokeBrush): boolean {\n  return !('tip' in brush) || !brush.tip || (brush.engine ?? 'dab') === 'dab';\n}\n\nconst finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);\n\n/**\n * Renders a dry brushstroke along `input` with `brush` to an RGBA image. The same input, brush and\n * options always give the same bytes. Throws for a wet (or other non-dry) brush and for samples\n * that are not finite.\n */\nexport function renderBrushstroke(input: BrushstrokeInput, brush: BrushstrokeBrush, options: BrushstrokeOptions = {}): BrushstrokeImage {\n  const strokeOptions = brushstrokeStrokeOptions(brush);\n  const samples = brushstrokeSamples(input);\n  for (const s of samples) if (!finite(s.x) || !finite(s.y)) throw new Error('Brushstroke samples need finite x and y.');\n  const solid = options.paint && !('type' in options.paint) ? options.paint.color : null;\n  const source = options.paint && 'type' in options.paint ? options.paint : null;\n  const color = solid ?? options.color ?? [0, 0, 0, 255];\n  let scale = finite(options.scale) && options.scale > 0 ? Math.min(MAX_SCALE, Math.max(MIN_SCALE, options.scale)) : 1;\n  if (!samples.length) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs: 0 };\n\n  // Keep the image under maxPixels: estimate it from the samples and the widest the tip can get.\n  const tip = strokeOptions.brush as BrushSettings;\n  const reach = tip.size * (1 + 1.5 * (strokeOptions.tilt?.size ?? 0)) + 4;\n  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;\n  for (const s of samples) {\n    x0 = Math.min(x0, s.x); y0 = Math.min(y0, s.y); x1 = Math.max(x1, s.x); y1 = Math.max(y1, s.y);\n  }\n  const maxPixels = finite(options.maxPixels) && options.maxPixels > 0 ? options.maxPixels : DEFAULT_MAX_PIXELS;\n  const area = (x1 - x0 + reach) * (y1 - y0 + reach);\n  if (area * scale * scale > maxPixels) scale = Math.max(MIN_SCALE, Math.sqrt(maxPixels / area));\n\n  const scaled = samples.map((s) => ({ ...s, x: s.x * scale, y: s.y * scale }));\n  const { surface, bounds, dabs } = paintPathStroke(emptySurface(4), scaled, {\n    ...strokeOptions,\n    brush: { ...tip, size: tip.size * scale },\n    closed: options.closed ?? strokeOptions.closed,\n    color,\n    // Gradient lengths are in path units: scale them with the image.\n    ...(source ? { paint: { paint: source.type === 'gradient' ? scalePaintGradient(source, scale) : source, seed: options.seed ?? 0 } } : {}),\n  });\n  if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };\n  const rect: RasterRect = bounds;\n  const data = readRegion(surface, rect);\n  return {\n    image: { width: rect.width, height: rect.height, data },\n    bounds: { x: rect.x / scale, y: rect.y / scale, width: rect.width / scale, height: rect.height / scale },\n    scale,\n    dabs,\n  };\n}\n\n/** A rendered brushstroke as a PNG data URL (for an SVG `<image>`, an `<img>` or an export). Empty strokes give ''. */\nexport function brushstrokeDataUrl(stroke: BrushstrokeImage): string {\n  const { width, height, data } = stroke.image;\n  return width && height ? pngDataUrl(width, height, data) : '';\n}\n\n/** The 2D-canvas surface {@link brushstrokeToCanvas} draws on (an `HTMLCanvasElement` or `OffscreenCanvas`). */\nexport interface BrushstrokeCanvasLike {\n  getContext(type: '2d'): { createImageData(w: number, h: number): { data: Uint8ClampedArray }; putImageData(img: never, x: number, y: number): void } | null;\n}\n\n/**\n * A rendered brushstroke on a canvas made by `createCanvas(width, height)` (injected, so this\n * module stays DOM-free). Returns null for an empty stroke or a canvas without a 2D context.\n */\nexport function brushstrokeToCanvas<C extends BrushstrokeCanvasLike>(stroke: BrushstrokeImage, createCanvas: (width: number, height: number) => C): C | null {\n  const { width, height, data } = stroke.image;\n  if (!width || !height) return null;\n  const canvas = createCanvas(width, height);\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return null;\n  const img = ctx.createImageData(width, height);\n  img.data.set(data);\n  ctx.putImageData(img as never, 0, 0);\n  return canvas;\n}\n\n// ---------------------------------------------------------------------------\n// Cache\n// ---------------------------------------------------------------------------\n\n/** FNV-1a over a string, as 8 hex digits. */\nfunction hashString(s: string, h = 0x811c9dc5): number {\n  for (let i = 0; i < s.length; i++) {\n    h ^= s.charCodeAt(i);\n    h = Math.imul(h, 0x01000193) >>> 0;\n  }\n  return h;\n}\n\n/**\n * A key for a brushstroke: the path (samples or profiles), the brush, the colour and the scale.\n * Two calls with equal arguments give equal keys; any change to them changes the key.\n */\nexport function brushstrokeKey(input: BrushstrokeInput, brush: BrushstrokeBrush, options: BrushstrokeOptions = {}): string {\n  const path = JSON.stringify(input);\n  const { brush: tip, ...rest } = brushstrokeStrokeOptions(brush);\n  const rest2 = JSON.stringify([tip, rest, options.paint ?? options.color ?? null, options.seed ?? 0, options.closed ?? false, options.maxPixels ?? null]);\n  const scale = finite(options.scale) ? options.scale : 1;\n  return `${hashString(path).toString(16)}:${path.length}:${hashString(rest2).toString(16)}:${scale}`;\n}\n\n/**\n * A small least-recently-used cache of rendered brushstrokes keyed by {@link brushstrokeKey}: path,\n * brush, colour and scale. Pass a bucketed scale ({@link brushstrokeScaleBucket}) so zooming inside\n * a bucket hits the cache, and a changed path, brush or bucket re-renders.\n */\nexport class BrushstrokeCache {\n  private readonly entries = new Map<string, BrushstrokeImage>();\n  /** Renders that missed the cache (for tests and stats). */\n  misses = 0;\n\n  constructor(readonly capacity = 64) {}\n\n  get size(): number {\n    return this.entries.size;\n  }\n\n  /** The cached stroke for these arguments, rendering (and caching) it on a miss. */\n  render(input: BrushstrokeInput, brush: BrushstrokeBrush, options: BrushstrokeOptions = {}): BrushstrokeImage {\n    const key = brushstrokeKey(input, brush, options);\n    const hit = this.entries.get(key);\n    if (hit) {\n      this.entries.delete(key);\n      this.entries.set(key, hit);\n      return hit;\n    }\n    this.misses++;\n    const out = renderBrushstroke(input, brush, options);\n    this.entries.set(key, out);\n    while (this.entries.size > Math.max(1, this.capacity)) this.entries.delete(this.entries.keys().next().value as string);\n    return out;\n  }\n\n  clear(): void {\n    this.entries.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAS,KAAK,GAA2D;AACvE,MAAI,OAAO,EAAE,aAAa,YAAY,OAAO,SAAS,EAAE,QAAQ,GAAG;AACjE,WAAO,EAAE,QAAQ,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,EAAE,YAAY,KAAK,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,WAAW,EAAE;AAAA,EACrG;AACA,MAAI,OAAO,EAAE,UAAU,YAAY,OAAO,EAAE,UAAU,UAAU;AAC9D,UAAM,MAAO,EAAE,SAAS,KAAK,KAAK,KAAM;AACxC,UAAM,MAAO,EAAE,SAAS,KAAK,KAAK,KAAM;AACxC,QAAI,OAAO,KAAK,OAAO,EAAG,QAAO,EAAE,QAAQ,GAAG,SAAS,EAAE;AACzD,UAAM,KAAK,KAAK,MAAM,KAAK,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,CAAC;AAChD,UAAM,MAAM,KAAK,KAAK,IAAI,KAAK,MAAM,KAAK,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,CAAC,CAAC;AAChE,WAAO,EAAE,QAAQ,IAAI,OAAO,KAAK,KAAK,IAAI,SAAS,GAAG;AAAA,EACxD;AACA,SAAO;AACT;AAGO,SAAS,eAAe,SAAgC,SAAmC;AAChG,QAAM,QAAQ,eAAe,QAAQ,KAAK;AAC1C,QAAM,MAAM,QAAQ,UAAU,QAAQ,SAAS,IAAI,CAAC,GAAG,SAAS,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO;AACzF,MAAI,CAAC,IAAI,OAAQ,QAAO,CAAC;AACzB,QAAM,OAAO,QAAQ,QAAQ,CAAC;AAC9B,QAAM,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,QAAQ,WAAW,CAAC,CAAC;AAC7D,MAAI,QAAQ;AACZ,QAAM,KAAK,IAAI,KAAK,CAAC,MAAM,OAAO,EAAE,MAAM,YAAY,OAAO,SAAS,EAAE,CAAC,CAAC,GAAG,KAAK;AAClF,QAAM,MAAM,CAAC,GAAW,GAAW,GAAW,GAA+C,KAAa,SAAS,GAAG,OAAsB,MAAM,QAAuB,SAAc;AACrL,UAAM,KAAK,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC;AACrC,UAAM,QAAQ,GAAG,UAAU;AAC3B,UAAM,OAAO,MAAM,QAAQ,MAAM,eAAe,WAAW,IAAI,WAAW,KAAK,MAAM,IAAI,OAAO,KAAK,QAAQ,KAAK;AAClH,QAAI,QAAS,MAAM,QAAQ,KAAK,KAAM;AACtC,QAAI,QAAQ,WAAY,UAAS;AACjC,QAAI,KAAK,iBAAiB,EAAG,SAAQ,CAAC,EAAE;AACxC,UAAM,YAAY,KAAK,IAAI,MAAM,MAAM,aAAa,IAAI,QAAQ,KAAK,aAAa,KAAK,MAAM;AAC7F,UAAM,KAAK,MAAM,kBAAkB,KAAK;AACxC,UAAM,SAAS,EAAE,QAAQ,OAAO,SAAS,UAAU,IAAI,MAAM,OAAO,OAAO,WAAW,KAAK,MAAM,SAAS,QAAQ,OAAO,OAAO,OAAO,OAAO,GAAG;AACjJ,WAAO,EAAE,GAAG,GAAG,QAAQ,KAAK,IAAI,KAAK,OAAO,CAAC,GAAG,OAAO,MAAM,MAAM,SAAS,MAAM,UAAU,IAAI,OAAO,WAAW,OAAO;AAAA,EAC3H;AACA,QAAM,MAAa,CAAC;AACpB,QAAM,WAAW,CAAC,MAAmB,OAAO,EAAE,aAAa,YAAY,OAAO,SAAS,EAAE,QAAQ,IAAI,EAAE,WAAW;AAClH,MAAI,IAAI,WAAW,GAAG;AACpB,QAAI,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,IAAI,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACnE,WAAO;AAAA,EACT;AACA,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,QAAM,SAAS,CAAC,MAAmB,OAAO,EAAE,MAAM,YAAY,OAAO,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI;AAC3F,MAAI,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,IAAI,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,GAAG,KAAK,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;AAC5I,WAAS,IAAI,GAAG,IAAI,IAAI,IAAI,QAAQ,KAAK;AACvC,UAAM,IAAI,IAAI,CAAC;AACf,UAAM,IAAI,IAAI,IAAI,CAAC;AACnB,UAAM,KAAK,EAAE,IAAI,EAAE;AACnB,UAAM,KAAK,EAAE,IAAI,EAAE;AACnB,UAAM,MAAM,KAAK,MAAM,IAAI,EAAE;AAC7B,QAAI,QAAQ,EAAG;AAEf,UAAM,MAAM,KAAK,MAAM,CAAC,IAAI,EAAE;AAC9B,UAAM,KAAK,KAAK,CAAC;AACjB,UAAM,KAAK,KAAK,CAAC;AACjB,UAAM,KAAK,OAAO,CAAC;AACnB,UAAM,KAAK,OAAO,CAAC;AACnB,UAAM,QAAQ,OAAO,QAAQ,OAAO,QAAQ,KAAK,KAAK,OAAO,KAAK,MAAM;AACxE,QAAI,IAAI;AACR,eAAS;AACP,YAAM,IAAI,IAAI;AACd,UAAI,IAAI,EAAG;AACX,YAAM,IAAI,SAAS,CAAC,KAAK,SAAS,CAAC,IAAI,SAAS,CAAC,KAAK;AACtD,YAAM,IAAI,MAAM,KAAK,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,EAAE,IAAK,MAAM;AACvI,YAAM,OAAO,MAAM,QAAQ,MAAM,eAAe,WAAW,IAAI,WAAW,IAAI;AAC9E,YAAM,OAAO,KAAK,IAAI,KAAK,OAAO,MAAM,OAAO;AAC/C,UAAI,IAAI,KAAK,IAAI,EAAG,KAAI,KAAK,IAAI,EAAE,IAAI,KAAK,GAAG,EAAE,IAAI,KAAK,GAAG,GAAG,GAAG,KAAK,QAAQ,GAAG,OAAO,QAAQ,OAAO,OAAO,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,CAAC;AACjJ,WAAK;AAAA,IACP;AACA,YAAQ,IAAI;AACZ,aAAS;AAAA,EACX;AACA,SAAO;AACT;AAeO,SAAS,mBAAmB,SAAgC,SAAwI;AACzM,QAAM,QAAQ,eAAe,QAAQ,KAAK;AAC1C,QAAM,WAAW,IAAI,YAAY;AACjC,QAAM,OAAO,eAAe,SAAS,OAAO;AAC5C,QAAM,IAAI,QAAQ,UAAU,MAAM,SAAS,aAAa,QAAQ,WAAW;AAC3E,QAAM,UAAU,IAAI,IAAI,qBAAqB,qBAAqB,EAAE,OAAqD,EAAE,UAAU,EAAE,OAAO,WAAW,WAAW,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI;AACjM,QAAM,WAAW,SAAS,YAAY,QAAQ,SAAS,kBAAkB,IAAI;AAC7E,QAAM,UAAgE,EAAE,OAAO,IAAI,aAAa,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,OAAO,EAAE,EAAE;AACzI,MAAI,MAAM,IAAI,aAAa,CAAC;AAC5B,MAAI,SAA4B;AAChC,aAAW,KAAK,MAAM;AACpB,UAAM,OAAO,QAAQ,GAAG,MAAM,QAAQ;AACtC,UAAM,IAAI,KAAK,QAAQ,KAAK;AAC5B,QAAI,KAAK,EAAG;AACZ,QAAI,IAAI,SAAS,EAAG,OAAM,IAAI,aAAa,CAAC;AAC5C,UAAM,OAAO,IAAI,SAAS,GAAG,CAAC;AAC9B,iBAAa,GAAG,MAAM,UAAU,MAAM,IAAI;AAC1C,QAAI,SAAS;AACX,YAAM,EAAE,OAAO,MAAM,IAAI,iBAAiB,SAAS,UAAU,GAAG,EAAE,QAAS,MAAM,MAAM,OAAO;AAC9F,eAAS,WAAW,MAAM,MAAM,EAAE,SAAS,OAAO,KAAK;AAAA,IACzD,MAAO,UAAS,WAAW,MAAM,MAAM,EAAE,OAAO;AAChD,QAAI,CAAC,OAAQ,UAAS,EAAE,GAAG,KAAK;AAAA,SAC3B;AACH,YAAM,IAAI,KAAK,IAAI,OAAO,GAAG,KAAK,CAAC;AACnC,YAAM,IAAI,KAAK,IAAI,OAAO,GAAG,KAAK,CAAC;AACnC,eAAS,EAAE,GAAG,GAAG,OAAO,KAAK,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,GAAG,QAAQ,KAAK,IAAI,OAAO,IAAI,OAAO,QAAQ,KAAK,IAAI,KAAK,MAAM,IAAI,EAAE;AAAA,IAC3J;AAAA,EACF;AACA,SAAO,EAAE,UAAU,QAAQ,MAAM,KAAK,OAAO;AAC/C;AAsBO,SAAS,gBAAgB,SAAuB,SAAgC,SAA+F;AACpL,MAAI,QAAQ,aAAa,EAAG,OAAM,IAAI,MAAM,oDAAoD;AAChG,QAAM,QAAQ,eAAe,QAAQ,KAAK;AAC1C,QAAM,MAAM,CAAC,MAAyB,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,KAAK,MAAM,KAAK,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AACpJ,MAAI,QAAQ,QAAQ;AACpB,MAAI,QAAQ,OAAO,MAAM,SAAS,SAAS;AACzC,UAAM,MAAM,cAAc,QAAQ,MAAM,MAAM,KAAK,EAAE,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC;AACnF,YAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;AAAA,EAC3C;AACA,QAAM,WAAW,QAAQ,OAAO,MAAM,SAAS,aAAa,EAAE,GAAG,QAAQ,OAAO,QAAQ,QAAQ,MAAM,UAAU,EAAE,OAAO,IAAI,KAAK,GAAG,WAAW,UAAU,EAAE,IAAI;AAChK,QAAM,EAAE,UAAU,QAAQ,KAAK,IAAI,mBAAmB,SAAS,EAAE,GAAG,SAAS,SAAS,CAAC;AACvF,MAAI,CAAC,OAAQ,QAAO,EAAE,SAAS,QAAQ,MAAM,KAAK;AAClD,QAAM,SAAS,QAAQ,UAAU,EAAE,GAAG,GAAG,GAAG,EAAE;AAC9C,QAAM,QAAQ;AAAA,IACZ,MAAM,QAAQ,QAAQ;AAAA,IACtB;AAAA,IACA,YAAY,CAAC,GAAG,GAAG,GAAG,CAAC;AAAA,IACvB,SAAS,MAAM;AAAA,IACf,OAAO,QAAQ,SAAS,MAAM;AAAA,IAC9B,kBAAkB,QAAQ,oBAAoB;AAAA,IAC9C,WAAW,QAAQ,aAAa;AAAA,IAChC;AAAA,EACF;AACA,QAAM,QAAQ,IAAI,IAAI,QAAQ,KAAK;AACnC,aAAW,EAAE,IAAI,GAAG,KAAK,YAAY,EAAE,GAAG,OAAO,IAAI,OAAO,GAAG,GAAG,OAAO,IAAI,OAAO,GAAG,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO,CAAC,GAAG;AACpI,UAAM,MAAM,QAAQ,IAAI,EAAE;AAC1B,UAAM,MAAM,QAAQ,MAAM,IAAI,GAAG,GAAG;AACpC,UAAM,OAAO,OAAO,IAAI,WAAW,OAAO,OAAO,IAAI,MAAM,IAAI,kBAAkB,OAAO,OAAO,CAAC;AAChG,UAAM,IAAI,WAAW,kBAAkB,UAAU,MAAM,GAAG,IAAI,IAAI,KAAK,GAAG,GAAG,QAAQ,YAAY;AACjG,QAAI,EAAG,OAAM,IAAI,KAAK,CAAC;AAAA,QAClB,OAAM,OAAO,GAAG;AAAA,EACvB;AACA,SAAO,EAAE,SAAS,IAAI,aAAa,GAAG,OAAO,QAAQ,YAAY,GAAG,QAAQ,KAAK;AACnF;;;AC5HA,IAAM,qBAAqB,OAAO;AAElC,IAAM,gBAAgB,CAAC,UAA6D,CAAC,MAAM,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAY,UAAU,QAAQ,YAAY;AAGxK,SAAS,UAAU,SAAwC,GAA+B;AACxF,MAAI,CAAC,WAAW,CAAC,QAAQ,OAAQ,QAAO;AACxC,MAAI,QAAQ,WAAW,EAAG,QAAO,QAAQ,CAAC;AAC1C,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,KAAK,QAAQ,SAAS;AAC1D,QAAM,IAAI,KAAK,IAAI,QAAQ,SAAS,GAAG,KAAK,MAAM,CAAC,CAAC;AACpD,SAAO,QAAQ,CAAC,KAAK,QAAQ,IAAI,CAAC,IAAI,QAAQ,CAAC,MAAM,IAAI;AAC3D;AAGO,SAAS,mBAAmB,OAA8C;AAC/E,MAAI,CAAC,cAAc,KAAK,EAAG,QAAO,MAAM,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;AAC7D,QAAM,MAAM,MAAM;AAClB,QAAM,UAAU,CAAC,CAAC;AAClB,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,IAAK,SAAQ,KAAK,QAAQ,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC;AAC/H,QAAM,QAAQ,QAAQ,GAAG,EAAE,KAAK;AAChC,SAAO,IAAI,IAAI,CAAC,GAAG,MAAM;AACvB,UAAM,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,QAAQ,IAAI,SAAS,IAAI,KAAK,IAAI,SAAS,KAAK;AACnF,UAAM,IAAuB,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE;AAC9C,UAAM,WAAW,UAAU,MAAM,UAAU,CAAC;AAC5C,UAAM,QAAQ,UAAU,MAAM,OAAO,CAAC;AACtC,UAAM,QAAQ,UAAU,MAAM,OAAO,CAAC;AACtC,QAAI,aAAa,OAAW,GAAE,WAAW;AACzC,QAAI,UAAU,OAAW,GAAE,QAAQ;AACnC,QAAI,UAAU,OAAW,GAAE,QAAQ;AACnC,WAAO;AAAA,EACT,CAAC;AACH;AAGA,IAAM,kBAA0C;AAAA,EAC9C,KAAK;AAAA,EACL,OAAO;AAAA,EACP,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AACV;AAMO,SAAS,yBAAyB,OAA4C;AACnF,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,OAAM,IAAI,MAAM,iGAA4F;AACrJ,MAAI,EAAE,SAAS,UAAU,CAAC,MAAM,IAAK,QAAO,EAAE,OAAO,eAAe,KAA+B,EAAE;AACrG,QAAM,SAAS,MAAM,UAAU;AAC/B,MAAI,WAAW,OAAO;AACpB,UAAM,QAAQ,MAAM,QAAQ,MAAM,MAAM;AACxC,UAAM,MAAM,gBAAgB,MAAM,KAAK,aAAa,MAAM;AAC1D,UAAM,IAAI,MAAM,wCAAwC,KAAK,KAAK,GAAG,6HAA6H;AAAA,EACpM;AACA,QAAM,IAAI,MAAM,YAAY,CAAC;AAC7B,QAAM,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,WAAW,EAAE,iBAAiB,EAAE;AACtE,SAAO;AAAA,IACL,OAAO,eAAe,MAAM,GAAG;AAAA,IAC/B,YAAY,MAAM,aAAa;AAAA,IAC/B,SAAS,EAAE,WAAW;AAAA,IACtB,GAAI,KAAK,QAAQ,KAAK,YAAY,EAAE,KAAK,IAAI,CAAC;AAAA,EAChD;AACF;AAGO,SAAS,mBAAmB,OAAkC;AACnE,SAAO,EAAE,SAAS,UAAU,CAAC,MAAM,QAAQ,MAAM,UAAU,WAAW;AACxE;AAEA,IAAM,SAAS,CAAC,MAA4B,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC;AAO/E,SAAS,kBAAkB,OAAyB,OAAyB,UAA8B,CAAC,GAAqB;AACtI,QAAM,gBAAgB,yBAAyB,KAAK;AACpD,QAAM,UAAU,mBAAmB,KAAK;AACxC,aAAW,KAAK,QAAS,KAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAAG,OAAM,IAAI,MAAM,0CAA0C;AACrH,QAAM,QAAQ,QAAQ,SAAS,EAAE,UAAU,QAAQ,SAAS,QAAQ,MAAM,QAAQ;AAClF,QAAM,SAAS,QAAQ,SAAS,UAAU,QAAQ,QAAQ,QAAQ,QAAQ;AAC1E,QAAM,QAAQ,SAAS,QAAQ,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG;AACrD,MAAI,QAAQ,OAAO,QAAQ,KAAK,KAAK,QAAQ,QAAQ,IAAI,KAAK,IAAI,uBAAW,KAAK,IAAI,uBAAW,QAAQ,KAAK,CAAC,IAAI;AACnH,MAAI,CAAC,QAAQ,OAAQ,QAAO,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,IAAI,kBAAkB,CAAC,EAAE,GAAG,QAAQ,MAAM,OAAO,MAAM,EAAE;AAG3H,QAAM,MAAM,cAAc;AAC1B,QAAM,QAAQ,IAAI,QAAQ,IAAI,OAAO,cAAc,MAAM,QAAQ,MAAM;AACvE,MAAI,KAAK,UAAU,KAAK,UAAU,KAAK,WAAW,KAAK;AACvD,aAAW,KAAK,SAAS;AACvB,SAAK,KAAK,IAAI,IAAI,EAAE,CAAC;AAAG,SAAK,KAAK,IAAI,IAAI,EAAE,CAAC;AAAG,SAAK,KAAK,IAAI,IAAI,EAAE,CAAC;AAAG,SAAK,KAAK,IAAI,IAAI,EAAE,CAAC;AAAA,EAC/F;AACA,QAAM,YAAY,OAAO,QAAQ,SAAS,KAAK,QAAQ,YAAY,IAAI,QAAQ,YAAY;AAC3F,QAAM,QAAQ,KAAK,KAAK,UAAU,KAAK,KAAK;AAC5C,MAAI,OAAO,QAAQ,QAAQ,UAAW,SAAQ,KAAK,IAAI,uBAAW,KAAK,KAAK,YAAY,IAAI,CAAC;AAE7F,QAAM,SAAS,QAAQ,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,OAAO,GAAG,EAAE,IAAI,MAAM,EAAE;AAC5E,QAAM,EAAE,SAAS,QAAQ,KAAK,IAAI,gBAAgB,aAAa,CAAC,GAAG,QAAQ;AAAA,IACzE,GAAG;AAAA,IACH,OAAO,EAAE,GAAG,KAAK,MAAM,IAAI,OAAO,MAAM;AAAA,IACxC,QAAQ,QAAQ,UAAU,cAAc;AAAA,IACxC;AAAA;AAAA,IAEA,GAAI,SAAS,EAAE,OAAO,EAAE,OAAO,OAAO,SAAS,aAAa,mBAAmB,QAAQ,KAAK,IAAI,QAAQ,MAAM,QAAQ,QAAQ,EAAE,EAAE,IAAI,CAAC;AAAA,EACzI,CAAC;AACD,MAAI,CAAC,OAAQ,QAAO,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,IAAI,kBAAkB,CAAC,EAAE,GAAG,QAAQ,MAAM,OAAO,KAAK;AAChH,QAAM,OAAmB;AACzB,QAAM,OAAO,WAAW,SAAS,IAAI;AACrC,SAAO;AAAA,IACL,OAAO,EAAE,OAAO,KAAK,OAAO,QAAQ,KAAK,QAAQ,KAAK;AAAA,IACtD,QAAQ,EAAE,GAAG,KAAK,IAAI,OAAO,GAAG,KAAK,IAAI,OAAO,OAAO,KAAK,QAAQ,OAAO,QAAQ,KAAK,SAAS,MAAM;AAAA,IACvG;AAAA,IACA;AAAA,EACF;AACF;AAGO,SAAS,mBAAmB,QAAkC;AACnE,QAAM,EAAE,OAAO,QAAQ,KAAK,IAAI,OAAO;AACvC,SAAO,SAAS,SAAS,WAAW,OAAO,QAAQ,IAAI,IAAI;AAC7D;AAWO,SAAS,oBAAqD,QAA0B,cAA8D;AAC3J,QAAM,EAAE,OAAO,QAAQ,KAAK,IAAI,OAAO;AACvC,MAAI,CAAC,SAAS,CAAC,OAAQ,QAAO;AAC9B,QAAM,SAAS,aAAa,OAAO,MAAM;AACzC,QAAM,MAAM,OAAO,WAAW,IAAI;AAClC,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,MAAM,IAAI,gBAAgB,OAAO,MAAM;AAC7C,MAAI,KAAK,IAAI,IAAI;AACjB,MAAI,aAAa,KAAc,GAAG,CAAC;AACnC,SAAO;AACT;AAOA,SAAS,WAAW,GAAW,IAAI,YAAoB;AACrD,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,SAAK,EAAE,WAAW,CAAC;AACnB,QAAI,KAAK,KAAK,GAAG,QAAU,MAAM;AAAA,EACnC;AACA,SAAO;AACT;AAMO,SAAS,eAAe,OAAyB,OAAyB,UAA8B,CAAC,GAAW;AACzH,QAAM,OAAO,KAAK,UAAU,KAAK;AACjC,QAAM,EAAE,OAAO,KAAK,GAAG,KAAK,IAAI,yBAAyB,KAAK;AAC9D,QAAM,QAAQ,KAAK,UAAU,CAAC,KAAK,MAAM,QAAQ,SAAS,QAAQ,SAAS,MAAM,QAAQ,QAAQ,GAAG,QAAQ,UAAU,OAAO,QAAQ,aAAa,IAAI,CAAC;AACvJ,QAAM,QAAQ,OAAO,QAAQ,KAAK,IAAI,QAAQ,QAAQ;AACtD,SAAO,GAAG,WAAW,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,WAAW,KAAK,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK;AACnG;AAOO,IAAM,mBAAN,MAAuB;AAAA,EAK5B,YAAqB,WAAW,IAAI;AAAf;AAAA,EAAgB;AAAA,EAAhB;AAAA,EAJJ,UAAU,oBAAI,IAA8B;AAAA;AAAA,EAE7D,SAAS;AAAA,EAIT,IAAI,OAAe;AACjB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA,EAGA,OAAO,OAAyB,OAAyB,UAA8B,CAAC,GAAqB;AAC3G,UAAM,MAAM,eAAe,OAAO,OAAO,OAAO;AAChD,UAAM,MAAM,KAAK,QAAQ,IAAI,GAAG;AAChC,QAAI,KAAK;AACP,WAAK,QAAQ,OAAO,GAAG;AACvB,WAAK,QAAQ,IAAI,KAAK,GAAG;AACzB,aAAO;AAAA,IACT;AACA,SAAK;AACL,UAAM,MAAM,kBAAkB,OAAO,OAAO,OAAO;AACnD,SAAK,QAAQ,IAAI,KAAK,GAAG;AACzB,WAAO,KAAK,QAAQ,OAAO,KAAK,IAAI,GAAG,KAAK,QAAQ,EAAG,MAAK,QAAQ,OAAO,KAAK,QAAQ,KAAK,EAAE,KAAK,EAAE,KAAe;AACrH,WAAO;AAAA,EACT;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ,MAAM;AAAA,EACrB;AACF;","names":[]}