@weasel-js/paint 1.9.3 → 1.10.0

package/dist/index.js

@@ -1,3 +1,80 @@
+// src/commandPaint.ts
+function isSolidPaint(paint) {
+  return paint != null && (paint.kind === void 0 || paint.kind === "solid");
+}
+
+// src/paintKey.ts
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (typeof value !== "object" || value === null) return JSON.stringify(value) ?? "null";
+  const fields = Object.keys(value).sort().filter((k) => value[k] !== void 0).map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`);
+  return `{${fields.join(",")}}`;
+}
+var structuralKeys = /* @__PURE__ */ new WeakMap();
+var strokeShapeKeys = /* @__PURE__ */ new WeakMap();
+function paintKey(paint) {
+  if (paint == null) return "none";
+  if (isSolidPaint(paint)) return `solid:${paint.color}:${paint.opacity ?? 1}`;
+  let key = structuralKeys.get(paint);
+  if (key === void 0) {
+    key = canonical(paint);
+    structuralKeys.set(paint, key);
+  }
+  return key;
+}
+function fillHasInk(fill) {
+  return fill?.paint !== void 0;
+}
+function strokeHasInk(stroke) {
+  if (stroke?.paint === void 0) return false;
+  const width = stroke.width ?? 1;
+  return (typeof width === "number" ? width : width.px) > 0;
+}
+function strokeKey(stroke) {
+  if (!strokeHasInk(stroke)) return "none";
+  let shape = strokeShapeKeys.get(stroke);
+  if (shape === void 0) {
+    const { paint: _paint, width, join, cap, miterLimit, align, dash, ...rest } = stroke;
+    shape = canonical({
+      ...rest,
+      width: width ?? 1,
+      join: join ?? "miter",
+      cap: cap ?? "butt",
+      miterLimit: miterLimit ?? 4,
+      align: align ?? "center",
+      dash: dash ?? []
+    });
+    strokeShapeKeys.set(stroke, shape);
+  }
+  return `${shape}|${paintKey(stroke.paint)}`;
+}
+
+// src/patternPaint.ts
+var TILE_KINDS = ["hatch", "crosshatch", "dots", "chunks"];
+var TILE_KIND_SET = new Set(TILE_KINDS);
+function isTileKind(kind) {
+  return kind !== void 0 && TILE_KIND_SET.has(kind);
+}
+function isTilePaint(paint) {
+  return isTileKind(paint.kind);
+}
+function isPatternPaint(paint) {
+  return paint.kind === "texture" || isTileKind(paint.kind);
+}
+function patternPlacementOf(paint) {
+  const { units, origin, transform, opacity } = paint;
+  return {
+    ...units !== void 0 ? { units } : {},
+    ...origin !== void 0 ? { origin } : {},
+    ...transform !== void 0 ? { transform } : {},
+    ...opacity !== void 0 ? { opacity } : {}
+  };
+}
+function tileSpecOf(paint) {
+  const { units: _units, origin: _origin, transform: _transform, opacity: _opacity, ...spec } = paint;
+  return spec;
+}
+
 // src/patternTransform.ts
 function composePatternTransform(parts) {
   const { rotation = 0, scaleX = 1, scaleY = 1, skewX = 0 } = parts;
@@ -66,6 +143,21 @@ function strokeDashStyleOf(dash, width) {
   return "custom";
 }
 
+// src/hex.ts
+var HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function parseHexBytes(input) {
+  if (!HEX.test(input)) return null;
+  const digits = input.slice(1);
+  const long = digits.length <= 4 ? digits.replace(/./g, "$&$&") : digits;
+  const byte = (i) => Number.parseInt(long.slice(i, i + 2), 16);
+  return [byte(0), byte(2), byte(4), long.length === 8 ? byte(6) : 255];
+}
+function hexToRgbBytes(input) {
+  const bytes = parseHexBytes(input);
+  if (!bytes) throw new Error(`not a hex color: "${input}"`);
+  return [bytes[0], bytes[1], bytes[2]];
+}
+
 // src/colorSpaces.ts
 var SRGB_TO_LINEAR = (() => {
   const lut = new Float64Array(256);
@@ -229,8 +321,7 @@ function oklchDegToHex(L, C, hueDeg) {
   return `#${hex2(r)}${hex2(g)}${hex2(bl)}`;
 }
 function hexToOklchDeg(hex) {
-  const n = Number.parseInt(hex.slice(1), 16);
-  const [L, A, B] = srgbU8ToOklab(n >> 16 & 255, n >> 8 & 255, n & 255);
+  const [L, A, B] = srgbU8ToOklab(...hexToRgbBytes(hex));
   const [l, c, h] = oklabToOklch(L, A, B);
   return { L: l, C: c, H: (h * 180 / Math.PI % 360 + 360) % 360 };
 }
@@ -333,16 +424,8 @@ function interpolateSrgb(from, to, t, space = "oklch", hue = "shorter") {
 
 // src/contrast.ts
 var hex22 = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
-function readHex(color) {
-  const m = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(color.trim());
-  if (!m) return null;
-  let h = m[1];
-  if (h.length === 3) h = h.replace(/./g, (c) => c + c);
-  const n = Number.parseInt(h.slice(0, 6), 16);
-  return [n >> 16 & 255, n >> 8 & 255, n & 255];
-}
 function contrastLineColor(background, strength) {
-  const rgb = readHex(background);
+  const rgb = parseHexBytes(background.trim());
   if (!rgb) return `rgba(0, 0, 0, ${strength})`;
   const [L, A, B] = srgbU8ToOklab(rgb[0], rgb[1], rgb[2]);
   const next = L > 0.5 ? Math.max(0, L - strength) : Math.min(1, L + strength);
@@ -350,6 +433,420 @@ function contrastLineColor(background, strength) {
   return `#${hex22(r)}${hex22(g)}${hex22(b)}`;
 }
 
+// src/color.ts
+function parseColor(input) {
+  const cached = CACHE.get(input);
+  if (cached !== void 0) return cached;
+  const result = parseColorUncached(input);
+  if (CACHE.size >= CACHE_MAX) CACHE.clear();
+  CACHE.set(input, result);
+  return result;
+}
+var CACHE = /* @__PURE__ */ new Map();
+var CACHE_MAX = 1024;
+function parseColorUncached(input) {
+  const s = input.trim();
+  if (s.startsWith("#")) return parseHex(s);
+  const lower = s.toLowerCase();
+  const named = NAMED_COLORS[lower];
+  if (named !== void 0) return named;
+  if (lower.startsWith("rgb")) {
+    const parsed = parseRgbFunction(lower);
+    if (parsed) return parsed;
+  }
+  if (lower.startsWith("hsl")) {
+    const parsed = parseHslFunction(lower);
+    if (parsed) return parsed;
+  }
+  throw new Error(`parseColor: unrecognized color "${input}"`);
+}
+var RESOLVE_COLOR_CACHE_CAP = 1024;
+var resolveColorCache = /* @__PURE__ */ new Map();
+function resolveColor(input) {
+  const hit = resolveColorCache.get(input);
+  if (hit) return hit;
+  if (resolveColorCache.size >= RESOLVE_COLOR_CACHE_CAP) {
+    resolveColorCache.clear();
+  }
+  const parsed = parseColor(input);
+  const frozen = parsed;
+  resolveColorCache.set(input, frozen);
+  return frozen;
+}
+function parseColorToRgba255(input) {
+  const [r, g, b, a] = parseColor(input);
+  return [
+    Math.round(r * 255),
+    Math.round(g * 255),
+    Math.round(b * 255),
+    Math.round(a * 255)
+  ];
+}
+function normalizeHex(input) {
+  const trimmed = input.trim();
+  const hashed = trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+  const bytes = parseHexBytes(hashed);
+  if (!bytes) throw new Error(`normalizeHex: invalid hex "${input}"`);
+  const digits = bytes.map((n) => n.toString(16).padStart(2, "0")).join("");
+  const namesAlpha = hashed.length === 5 || hashed.length === 9;
+  return `#${namesAlpha ? digits : digits.slice(0, 6)}`;
+}
+function hexToRgba(input) {
+  return parseHex(normalizeHex(input));
+}
+function rgbaToHex(rgba) {
+  const [r, g, b] = rgba;
+  const a = rgba.length === 4 ? rgba[3] : 1;
+  const f = (n) => Math.max(0, Math.min(255, Math.round(n * 255))).toString(16).padStart(2, "0");
+  const base = `#${f(r)}${f(g)}${f(b)}`;
+  return a >= 1 ? base : `${base}${f(a)}`;
+}
+function parseHex(s) {
+  const bytes = parseHexBytes(s);
+  if (!bytes) throw new Error(`parseColor: invalid hex "${s}"`);
+  return [bytes[0] / 255, bytes[1] / 255, bytes[2] / 255, bytes[3] / 255];
+}
+function unwrapFn(s, name) {
+  if (!s.startsWith(name + "(") || !s.endsWith(")")) return null;
+  return s.slice(name.length + 1, -1).trim();
+}
+function splitChannels(body) {
+  if (body.includes(",")) {
+    const parts2 = body.split(",").map((p) => p.trim());
+    if (parts2.length !== 3 && parts2.length !== 4) return null;
+    return {
+      rgb: [parts2[0], parts2[1], parts2[2]],
+      alpha: parts2.length === 4 ? parts2[3] : null
+    };
+  }
+  const slash = body.indexOf("/");
+  const head = (slash === -1 ? body : body.slice(0, slash)).trim();
+  const alpha = slash === -1 ? null : body.slice(slash + 1).trim();
+  const parts = head.split(/\s+/);
+  if (parts.length !== 3) return null;
+  if (alpha !== null && alpha === "") return null;
+  return { rgb: [parts[0], parts[1], parts[2]], alpha };
+}
+function parseChannel(tok, max) {
+  if (tok.endsWith("%")) {
+    const n2 = Number(tok.slice(0, -1));
+    if (!Number.isFinite(n2)) return null;
+    return clamp012(n2 / 100);
+  }
+  const n = Number(tok);
+  if (!Number.isFinite(n)) return null;
+  return clamp012(n / max);
+}
+function parseAlpha(tok) {
+  if (tok === null) return 1;
+  if (tok.endsWith("%")) {
+    const n2 = Number(tok.slice(0, -1));
+    return Number.isFinite(n2) ? clamp012(n2 / 100) : 1;
+  }
+  const n = Number(tok);
+  return Number.isFinite(n) ? clamp012(n) : 1;
+}
+function parseRgbFunction(s) {
+  const body = unwrapFn(s, "rgba") ?? unwrapFn(s, "rgb");
+  if (body === null) return null;
+  const channels = splitChannels(body);
+  if (!channels) return null;
+  const r = parseChannel(channels.rgb[0], 255);
+  const g = parseChannel(channels.rgb[1], 255);
+  const b = parseChannel(channels.rgb[2], 255);
+  if (r === null || g === null || b === null) return null;
+  return [r, g, b, parseAlpha(channels.alpha)];
+}
+function parseHslFunction(s) {
+  const body = unwrapFn(s, "hsla") ?? unwrapFn(s, "hsl");
+  if (body === null) return null;
+  const channels = splitChannels(body);
+  if (!channels) return null;
+  const h = parseHue(channels.rgb[0]);
+  const sat = parsePercentOrNumber(channels.rgb[1]);
+  const lit = parsePercentOrNumber(channels.rgb[2]);
+  if (h === null || sat === null || lit === null) return null;
+  const [r, g, b] = hslToSrgb(h, sat, lit);
+  return [r, g, b, parseAlpha(channels.alpha)];
+}
+function parseHue(tok) {
+  let n;
+  if (tok.endsWith("deg")) n = Number(tok.slice(0, -3));
+  else if (tok.endsWith("grad")) n = Number(tok.slice(0, -4)) * 0.9;
+  else if (tok.endsWith("rad")) n = Number(tok.slice(0, -3)) * (180 / Math.PI);
+  else if (tok.endsWith("turn")) n = Number(tok.slice(0, -4)) * 360;
+  else n = Number(tok);
+  if (!Number.isFinite(n)) return null;
+  return (n % 360 + 360) % 360;
+}
+function parsePercentOrNumber(tok) {
+  if (tok.endsWith("%")) {
+    const n2 = Number(tok.slice(0, -1));
+    return Number.isFinite(n2) ? clamp012(n2 / 100) : null;
+  }
+  const n = Number(tok);
+  return Number.isFinite(n) ? clamp012(n) : null;
+}
+function clamp012(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+var NAMED_COLORS = (() => {
+  const hex = {
+    aliceblue: 15792383,
+    antiquewhite: 16444375,
+    aqua: 65535,
+    aquamarine: 8388564,
+    azure: 15794175,
+    beige: 16119260,
+    bisque: 16770244,
+    black: 0,
+    blanchedalmond: 16772045,
+    blue: 255,
+    blueviolet: 9055202,
+    brown: 10824234,
+    burlywood: 14596231,
+    cadetblue: 6266528,
+    chartreuse: 8388352,
+    chocolate: 13789470,
+    coral: 16744272,
+    cornflowerblue: 6591981,
+    cornsilk: 16775388,
+    crimson: 14423100,
+    cyan: 65535,
+    darkblue: 139,
+    darkcyan: 35723,
+    darkgoldenrod: 12092939,
+    darkgray: 11119017,
+    darkgreen: 25600,
+    darkgrey: 11119017,
+    darkkhaki: 12433259,
+    darkmagenta: 9109643,
+    darkolivegreen: 5597999,
+    darkorange: 16747520,
+    darkorchid: 10040012,
+    darkred: 9109504,
+    darksalmon: 15308410,
+    darkseagreen: 9419919,
+    darkslateblue: 4734347,
+    darkslategray: 3100495,
+    darkslategrey: 3100495,
+    darkturquoise: 52945,
+    darkviolet: 9699539,
+    deeppink: 16716947,
+    deepskyblue: 49151,
+    dimgray: 6908265,
+    dimgrey: 6908265,
+    dodgerblue: 2003199,
+    firebrick: 11674146,
+    floralwhite: 16775920,
+    forestgreen: 2263842,
+    fuchsia: 16711935,
+    gainsboro: 14474460,
+    ghostwhite: 16316671,
+    gold: 16766720,
+    goldenrod: 14329120,
+    gray: 8421504,
+    green: 32768,
+    greenyellow: 11403055,
+    grey: 8421504,
+    honeydew: 15794160,
+    hotpink: 16738740,
+    indianred: 13458524,
+    indigo: 4915330,
+    ivory: 16777200,
+    khaki: 15787660,
+    lavender: 15132410,
+    lavenderblush: 16773365,
+    lawngreen: 8190976,
+    lemonchiffon: 16775885,
+    lightblue: 11393254,
+    lightcoral: 15761536,
+    lightcyan: 14745599,
+    lightgoldenrodyellow: 16448210,
+    lightgray: 13882323,
+    lightgreen: 9498256,
+    lightgrey: 13882323,
+    lightpink: 16758465,
+    lightsalmon: 16752762,
+    lightseagreen: 2142890,
+    lightskyblue: 8900346,
+    lightslategray: 7833753,
+    lightslategrey: 7833753,
+    lightsteelblue: 11584734,
+    lightyellow: 16777184,
+    lime: 65280,
+    limegreen: 3329330,
+    linen: 16445670,
+    magenta: 16711935,
+    maroon: 8388608,
+    mediumaquamarine: 6737322,
+    mediumblue: 205,
+    mediumorchid: 12211667,
+    mediumpurple: 9662683,
+    mediumseagreen: 3978097,
+    mediumslateblue: 8087790,
+    mediumspringgreen: 64154,
+    mediumturquoise: 4772300,
+    mediumvioletred: 13047173,
+    midnightblue: 1644912,
+    mintcream: 16121850,
+    mistyrose: 16770273,
+    moccasin: 16770229,
+    navajowhite: 16768685,
+    navy: 128,
+    oldlace: 16643558,
+    olive: 8421376,
+    olivedrab: 7048739,
+    orange: 16753920,
+    orangered: 16729344,
+    orchid: 14315734,
+    palegoldenrod: 15657130,
+    palegreen: 10025880,
+    paleturquoise: 11529966,
+    palevioletred: 14381203,
+    papayawhip: 16773077,
+    peachpuff: 16767673,
+    peru: 13468991,
+    pink: 16761035,
+    plum: 14524637,
+    powderblue: 11591910,
+    purple: 8388736,
+    rebeccapurple: 6697881,
+    red: 16711680,
+    rosybrown: 12357519,
+    royalblue: 4286945,
+    saddlebrown: 9127187,
+    salmon: 16416882,
+    sandybrown: 16032864,
+    seagreen: 3050327,
+    seashell: 16774638,
+    sienna: 10506797,
+    silver: 12632256,
+    skyblue: 8900331,
+    slateblue: 6970061,
+    slategray: 7372944,
+    slategrey: 7372944,
+    snow: 16775930,
+    springgreen: 65407,
+    steelblue: 4620980,
+    tan: 13808780,
+    teal: 32896,
+    thistle: 14204888,
+    tomato: 16737095,
+    turquoise: 4251856,
+    violet: 15631086,
+    wheat: 16113331,
+    white: 16777215,
+    whitesmoke: 16119285,
+    yellow: 16776960,
+    yellowgreen: 10145074
+  };
+  const out = {
+    transparent: [0, 0, 0, 0]
+  };
+  for (const name in hex) {
+    const n = hex[name];
+    out[name] = [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255, 1];
+  }
+  return out;
+})();
+
+// src/gradient.ts
+function isGradientPaint(fill) {
+  if (fill == null) return false;
+  return fill.kind === "linear-gradient" || fill.kind === "radial-gradient" || fill.kind === "conic-gradient";
+}
+function resolveGradientStops(stops) {
+  return [...stops].sort((a, b) => a.offset - b.offset).map((s) => ({ offset: s.offset, rgba: resolveColor(s.color) }));
+}
+function sampleResolvedStops(stops, t, space = "rgb") {
+  if (stops.length === 0) return TRANSPARENT;
+  const first = stops[0];
+  const last = stops[stops.length - 1];
+  if (t <= first.offset) return first.rgba;
+  if (t >= last.offset) return last.rgba;
+  for (let i = 0; i < stops.length - 1; i++) {
+    const lo = stops[i];
+    const hi = stops[i + 1];
+    if (t < lo.offset || t > hi.offset) continue;
+    const span = hi.offset - lo.offset;
+    if (span <= 0) return hi.rgba;
+    const f = (t - lo.offset) / span;
+    const [r, g, b, a] = lerpColorArray(lo.rgba, hi.rgba, f, space);
+    return [r, g, b, a];
+  }
+  return last.rgba;
+}
+var TRANSPARENT = [0, 0, 0, 0];
+function sampleGradientStops(stops, t, space = "rgb") {
+  if (stops.length === 0) return "rgba(0,0,0,0)";
+  return rgbaToHex(sampleResolvedStops(resolveGradientStops(stops), t, space));
+}
+function withGradientKind(fill, kind) {
+  if (fill.kind === kind) return fill;
+  const common = {
+    stops: fill.stops,
+    units: fill.units,
+    interpolate: fill.interpolate,
+    opacity: fill.opacity
+  };
+  const { center, radius, angle } = gradientGeometry(fill);
+  if (kind === "linear-gradient") {
+    const dx = Math.cos(angle) * radius;
+    const dy = Math.sin(angle) * radius;
+    return {
+      kind: "linear-gradient",
+      from: { x: center.x - dx, y: center.y - dy },
+      to: { x: center.x + dx, y: center.y + dy },
+      ...common
+    };
+  }
+  if (kind === "radial-gradient") {
+    return { kind: "radial-gradient", center, radius, ...common };
+  }
+  return { kind: "conic-gradient", center, angle, ...common };
+}
+function gradientGeometry(fill) {
+  if (fill.kind === "linear-gradient") {
+    const dx = fill.to.x - fill.from.x;
+    const dy = fill.to.y - fill.from.y;
+    return {
+      center: { x: (fill.from.x + fill.to.x) / 2, y: (fill.from.y + fill.to.y) / 2 },
+      radius: Math.hypot(dx, dy) / 2,
+      angle: Math.atan2(dy, dx)
+    };
+  }
+  if (fill.kind === "radial-gradient") {
+    return { center: fill.center, radius: fill.radius, angle: 0 };
+  }
+  return { center: fill.center, radius: conicArmRadius(fill.units), angle: fill.angle };
+}
+function conicArmRadius(units) {
+  return units === "bounds" ? 0.5 : 50;
+}
+function gradientForBounds(kind, bounds, stops, units) {
+  const center = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
+  if (kind === "linear-gradient") {
+    return {
+      kind: "linear-gradient",
+      from: { x: bounds.x, y: center.y },
+      to: { x: bounds.x + bounds.width, y: center.y },
+      stops,
+      units
+    };
+  }
+  if (kind === "radial-gradient") {
+    return {
+      kind: "radial-gradient",
+      center,
+      radius: Math.max(bounds.width, bounds.height) / 2,
+      stops,
+      units
+    };
+  }
+  return { kind: "conic-gradient", center, angle: 0, stops, units };
+}
+
 // src/palette.ts
 function nth(items, n) {
   if (!Number.isInteger(n) || n < 0) return void 0;
@@ -414,13 +911,26 @@ function colorLiteralToHex(color) {
   const a = color.alpha ?? 1;
   return `#${rgb.map(hex23).join("")}${a < 1 ? hex23(a * 255) : ""}`;
 }
+function colorLiteralToCss(color) {
+  if (color.coords.length < 3) return null;
+  const hex = colorLiteralToHex(color);
+  if (hex) return hex;
+  const a = color.alpha ?? 1;
+  return `color(${color.space} ${color.coords.join(" ")}${a < 1 ? ` / ${a}` : ""})`;
+}
+function cssColorLiteral(css) {
+  const [r, g, b, a] = parseColor(css);
+  const coords = [r, g, b];
+  return a < 1 ? { space: "srgb", coords, alpha: a } : { space: "srgb", coords };
+}
 function hexToColorLiteral(hex) {
-  if (!/^#(?:[0-9a-f]{6}|[0-9a-f]{8})$/i.test(hex)) return null;
-  const byte = (i) => Number.parseInt(hex.slice(i, i + 2), 16) / 255;
-  const coords = [byte(1), byte(3), byte(5)];
-  return hex.length === 9 ? { space: "srgb", coords, alpha: byte(7) } : { space: "srgb", coords };
+  const bytes = hex.length === 7 || hex.length === 9 ? parseHexBytes(hex) : null;
+  if (!bytes) return null;
+  const [r, g, b, a] = bytes.map((v) => v / 255);
+  const coords = [r, g, b];
+  return hex.length === 9 ? { space: "srgb", coords, alpha: a } : { space: "srgb", coords };
 }
 
-export { STROKE_DASH_RATIOS, alignedStrokeRect, colorLiteralToHex, composePatternTransform, contrastLineColor, dashForStrokeStyle, decomposePatternTransform, hexToColorLiteral, hexToOklchDeg, hslToSrgb, interpolateSrgb, lerpColorArray, lerpOklab, lerpOklch, linearSrgbToOklab, linearToSrgb, mixOklab, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, resolvePaletteColor, resolvePaletteColors, resolveScreenLength, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf };
+export { STROKE_DASH_RATIOS, TILE_KINDS, alignedStrokeRect, colorLiteralToCss, colorLiteralToHex, composePatternTransform, contrastLineColor, cssColorLiteral, dashForStrokeStyle, decomposePatternTransform, fillHasInk, gradientForBounds, gradientGeometry, hexToColorLiteral, hexToOklchDeg, hexToRgbBytes, hexToRgba, hslToSrgb, interpolateSrgb, isGradientPaint, isPatternPaint, isSolidPaint, isTileKind, isTilePaint, lerpColorArray, lerpOklab, lerpOklch, linearSrgbToOklab, linearToSrgb, mixOklab, normalizeHex, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, paintKey, parseColor, parseColorToRgba255, parseHexBytes, patternPlacementOf, resolveColor, resolveGradientStops, resolvePaletteColor, resolvePaletteColors, resolveScreenLength, rgbaToHex, sampleGradientStops, sampleResolvedStops, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf, strokeHasInk, strokeKey, tileSpecOf, withGradientKind };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map