@luntta/swatch 3.0.0

package/src/parse/legacy.js

@@ -0,0 +1,88 @@
+// Legacy CSS string parsers: rgb()/rgba()/hsl()/hsla().
+//
+// Accepts both the comma-separated (legacy) and whitespace + slash (modern)
+// syntaxes, because v2 accepted both and existing tests depend on it.
+// Modern CSS Color 4 extras like the `none` keyword and `<percentage>`
+// alpha are handled in parse/css.js (Phase 4).
+//
+// Hue units supported: bare number (deg), `deg`, `rad`, `turn`. Mirrors
+// v2's behavior in `_HSLToRGB` (src/swatch.js:546-613) and `_HSLAToRGBA`
+// (src/swatch.js:625-730).
+
+const RGB_FN = /^rgba?\(([^)]+)\)$/i;
+const HSL_FN = /^hsla?\(([^)]+)\)$/i;
+
+function splitArgs(body) {
+	// Split on slashes, commas, or runs of whitespace. The slash is
+	// always a separator for the alpha argument.
+	const slashParts = body.split("/").map((s) => s.trim());
+	const main = slashParts[0];
+	const alphaStr = slashParts[1];
+	const parts = main.split(/[\s,]+/).filter(Boolean);
+	if (alphaStr != null && alphaStr !== "") parts.push(alphaStr);
+	return parts;
+}
+
+function parsePercentOrNumber(token) {
+	if (token.endsWith("%")) {
+		return parseFloat(token.slice(0, -1)) / 100;
+	}
+	return parseFloat(token);
+}
+
+function parseAlpha(token) {
+	if (token == null) return 1;
+	if (token.endsWith("%")) return parseFloat(token.slice(0, -1)) / 100;
+	const n = parseFloat(token);
+	return isNaN(n) ? 1 : n;
+}
+
+function parseHue(token) {
+	// Bare number is degrees.
+	if (/turn$/i.test(token)) return parseFloat(token.slice(0, -4)) * 360;
+	if (/rad$/i.test(token)) return (parseFloat(token.slice(0, -3)) * 180) / Math.PI;
+	if (/deg$/i.test(token)) return parseFloat(token.slice(0, -3));
+	return parseFloat(token);
+}
+
+export function parseRgbFn(input) {
+	if (typeof input !== "string") return null;
+	const match = RGB_FN.exec(input.trim());
+	if (!match) return null;
+	const parts = splitArgs(match[1]);
+	if (parts.length !== 3 && parts.length !== 4) return null;
+
+	// Each of r, g, b may be a number in 0..255 or a percentage 0..100%.
+	const parseChannel = (token) => {
+		if (token.endsWith("%")) {
+			return parseFloat(token.slice(0, -1)) / 100;
+		}
+		const n = parseFloat(token);
+		return n / 255;
+	};
+	const r = parseChannel(parts[0]);
+	const g = parseChannel(parts[1]);
+	const b = parseChannel(parts[2]);
+	const a = parts.length === 4 ? parseAlpha(parts[3]) : 1;
+	if (isNaN(r) || isNaN(g) || isNaN(b) || isNaN(a)) return null;
+	return { space: "srgb", coords: [r, g, b], alpha: a };
+}
+
+export function parseHslFn(input) {
+	if (typeof input !== "string") return null;
+	const match = HSL_FN.exec(input.trim());
+	if (!match) return null;
+	const parts = splitArgs(match[1]);
+	if (parts.length !== 3 && parts.length !== 4) return null;
+
+	const h = parseHue(parts[0]);
+	const s = parsePercentOrNumber(parts[1]) * 100;
+	const l = parsePercentOrNumber(parts[2]) * 100;
+	const a = parts.length === 4 ? parseAlpha(parts[3]) : 1;
+	if (isNaN(h) || isNaN(s) || isNaN(l) || isNaN(a)) return null;
+	return { space: "hsl", coords: [h, s, l], alpha: a };
+}
+
+export function parseLegacy(input) {
+	return parseRgbFn(input) || parseHslFn(input);
+}

package/src/parse/named.js

@@ -0,0 +1,11 @@
+// CSS named color lookup (148 names + `transparent`). Case-insensitive.
+
+import namedColors from "../data/named-colors.js";
+import { parseHex } from "./hex.js";
+
+export function parseNamed(input) {
+	if (typeof input !== "string") return null;
+	const key = input.trim().toLowerCase();
+	if (!Object.prototype.hasOwnProperty.call(namedColors, key)) return null;
+	return parseHex("#" + namedColors[key]);
+}

package/src/parse/objects.js

@@ -0,0 +1,125 @@
+// Object-literal input parsing.
+//
+// Accepts:
+//
+//   { space, coords, alpha? }        — canonical v3 form
+//   { r, g, b, a? }                  — sRGB-255 object (legacy v2)
+//   { h, s, l, a? }                  — HSL object (legacy v2)
+//   { h, s, v, a? }                  — HSV object
+//   { h, w, b, a? }                  — HWB object
+//   { l, a, b, alpha? }              — CIE Lab D65
+//   { l, c, h, alpha? }              — generic LCh — ambiguous between CIE
+//                                      and OK until disambiguated by the
+//                                      `space` hint; defaults to OKLCh
+//                                      when L ≤ 1 and CIE LCh when L > 1
+//
+// Returns a v3 state object or null if the input shape doesn't match.
+
+const HAS = Object.prototype.hasOwnProperty;
+
+export function parseObject(input) {
+	if (input === null || typeof input !== "object") return null;
+
+	// Canonical v3 form.
+	if (HAS.call(input, "space") && HAS.call(input, "coords")) {
+		const coords = input.coords;
+		if (!Array.isArray(coords) || coords.length !== 3) return null;
+		const alpha =
+			input.alpha != null ? input.alpha : input.a != null ? input.a : 1;
+		return {
+			space: String(input.space),
+			coords: [+coords[0], +coords[1], +coords[2]],
+			alpha: +alpha
+		};
+	}
+
+	// Legacy RGB-255 object.
+	if (HAS.call(input, "r") && HAS.call(input, "g") && HAS.call(input, "b")) {
+		const alpha = input.a != null ? +input.a : 1;
+		return {
+			space: "srgb",
+			coords: [+input.r / 255, +input.g / 255, +input.b / 255],
+			alpha
+		};
+	}
+
+	// HSL legacy object (also supports HSLuv later when that space registers,
+	// but the built-in HSL is the common case).
+	if (HAS.call(input, "h") && HAS.call(input, "s") && HAS.call(input, "l")) {
+		const alpha = input.a != null ? +input.a : 1;
+		return {
+			space: "hsl",
+			coords: [+input.h, +input.s, +input.l],
+			alpha
+		};
+	}
+
+	// HSV object.
+	if (HAS.call(input, "h") && HAS.call(input, "s") && HAS.call(input, "v")) {
+		const alpha = input.a != null ? +input.a : 1;
+		return {
+			space: "hsv",
+			coords: [+input.h, +input.s, +input.v],
+			alpha
+		};
+	}
+
+	// HWB object. Collision with { h, s, b } for HSB isn't a real problem
+	// because HWB's key order is h/w/b and HSB is spelled h/s/v in practice.
+	if (HAS.call(input, "h") && HAS.call(input, "w") && HAS.call(input, "b")) {
+		const alpha = input.a != null ? +input.a : 1;
+		return {
+			space: "hwb",
+			coords: [+input.h, +input.w, +input.b],
+			alpha
+		};
+	}
+
+	// CIE Lab D65 (L/a/b). Ambiguous vs OKLab; we pick CIE Lab here because
+	// OKLab users should use the explicit { space: 'oklab', coords: [...] }
+	// form (OKLab L is in 0..1, CIE Lab L in 0..100 — enforcing that via
+	// this parser would be surprising).
+	if (HAS.call(input, "l") && HAS.call(input, "a") && HAS.call(input, "b")) {
+		const alpha = input.alpha != null ? +input.alpha : 1;
+		return {
+			space: "lab",
+			coords: [+input.l, +input.a, +input.b],
+			alpha
+		};
+	}
+
+	// CIE LCh / OKLCh. Disambiguate by L magnitude: CIE LCh has L in 0..100,
+	// OKLCh L in 0..1. Callers who want to force a choice should pass the
+	// explicit { space, coords } form.
+	if (HAS.call(input, "l") && HAS.call(input, "c") && HAS.call(input, "h")) {
+		const alpha = input.alpha != null ? +input.alpha : 1;
+		const space = +input.l > 1 ? "lch" : "oklch";
+		return {
+			space,
+			coords: [+input.l, +input.c, +input.h],
+			alpha
+		};
+	}
+
+	// CMYK object. Stored as the 3-channel "folded K" representation so it
+	// fits the canonical state shape; see src/spaces/cmyk.js.
+	if (
+		HAS.call(input, "c") &&
+		HAS.call(input, "m") &&
+		HAS.call(input, "y") &&
+		HAS.call(input, "k")
+	) {
+		const alpha = input.alpha != null ? +input.alpha : input.a != null ? +input.a : 1;
+		const c = +input.c;
+		const m = +input.m;
+		const y = +input.y;
+		const k = +input.k;
+		return {
+			space: "cmyk",
+			coords: [c + k - c * k, m + k - m * k, y + k - y * k],
+			alpha
+		};
+	}
+
+	return null;
+}

package/src/scale/index.js

@@ -0,0 +1,382 @@
+// Color scales — chroma.js-style.
+//
+//   swatch.scale([c0, c1, c2, ...])        // fixed stops
+//   swatch.scale('viridis')                // built-in palette (Phase 18)
+//
+// Returns a `Scale` function you can call with a number in [0, 1]
+// (the default domain) to interpolate between the stops. The scale
+// also carries methods for reshaping the curve:
+//
+//   .domain([a, b])       — map input through this domain before lerp
+//   .classes(n | [...])   — bucket the output into n (or explicit) bins
+//   .padding(p | [l, r])  — trim fractional amounts off each end
+//   .gamma(g)             — pow the normalized t by g (emphasis curve)
+//   .mode(space)          — interpolation color space (default 'oklab')
+//   .correctLightness()   — resample t so the output Lab L is linear
+//   .cache(on)            — toggle result memoization
+//
+// Calling pattern:
+//   scale(t)                — Swatch at position t
+//   scale.colors(n, fmt?)   — array of n Swatches or formatted strings
+//
+// Also:
+//   swatch.bezier([colors])     — returns a fn that can be passed to scale
+//   swatch.cubehelix({start, rotations, hue, gamma, lightness}) — ditto
+
+import { Swatch, swatch } from "../core/swatch-class.js";
+import { mix } from "../operations/mix.js";
+import { getPalette, listPalettes } from "../palettes/index.js";
+import { appendSuggestion } from "../util/suggest.js";
+
+function toSwatch(input) {
+	return input instanceof Swatch ? input : swatch(input);
+}
+
+function clamp01(x) {
+	return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+
+// Interpolate directly between two Swatches in `space`. This is the
+// same math as mix(a, b, t, {space}); we bypass the toSwatch dance
+// inside the hot path.
+function interp(a, b, t, space) {
+	return mix(a, b, t, { space });
+}
+
+function buildScale(stops, state) {
+	const arr = stops.map(toSwatch);
+	if (arr.length < 2) {
+		// Single-stop: always that color.
+		arr.push(arr[0]);
+	}
+
+	function sampleRaw(t) {
+		// Input t is in state.domain coords; normalize to [0, 1].
+		const [d0, d1] = state.domain;
+		let u = d0 === d1 ? 0 : (t - d0) / (d1 - d0);
+		u = clamp01(u);
+
+		// Padding: compress [0,1] to [pl, 1-pr] *before* other shaping.
+		const [pl, pr] = state.padding;
+		u = pl + u * (1 - pl - pr);
+
+		// Gamma: emphasis curve on the normalized position.
+		if (state.gamma !== 1) u = Math.pow(u, state.gamma);
+
+		// correctLightness: resample via the precomputed L lookup.
+		if (state.lightnessCorrection) {
+			u = state.lightnessCorrection(u);
+		}
+
+		// Classes: bucket output into bins (step-function).
+		if (state.classes) {
+			u = bucketize(u, state.classes);
+		}
+
+		// Map u onto the piecewise-linear sequence of stops.
+		const n = arr.length - 1;
+		const p = u * n;
+		const i = Math.min(Math.floor(p), n - 1);
+		const localT = p - i;
+		return interp(arr[i], arr[i + 1], localT, state.space);
+	}
+
+	function sample(t) {
+		if (state.cache) {
+			const key = t;
+			if (state.cacheMap.has(key)) return state.cacheMap.get(key);
+			const v = sampleRaw(t);
+			state.cacheMap.set(key, v);
+			return v;
+		}
+		return sampleRaw(t);
+	}
+
+	function scale(t) {
+		return sample(t);
+	}
+
+	scale.colors = function (n, format) {
+		const out = [];
+		const [d0, d1] = state.domain;
+		if (n <= 0) return out;
+		if (n === 1) {
+			out.push(sample((d0 + d1) / 2));
+		} else {
+			for (let i = 0; i < n; i++) {
+				const t = d0 + (d1 - d0) * (i / (n - 1));
+				out.push(sample(t));
+			}
+		}
+		if (format) {
+			return out.map((c) => c.toString({ format }));
+		}
+		return out;
+	};
+
+	function clearCache() {
+		state.cacheMap = new Map();
+	}
+
+	scale.domain = function (d) {
+		if (d === undefined) return state.domain.slice();
+		state.domain = [d[0], d[1]];
+		clearCache();
+		return scale;
+	};
+
+	scale.classes = function (n) {
+		if (n === undefined) return state.classes;
+		if (typeof n === "number") {
+			// Build n+1 evenly-spaced breakpoints in normalized [0, 1].
+			const breaks = [];
+			for (let i = 0; i <= n; i++) breaks.push(i / n);
+			state.classes = breaks;
+		} else if (Array.isArray(n)) {
+			// Caller provided explicit domain-space breakpoints; convert
+			// to normalized positions via the *current* domain.
+			const [d0, d1] = state.domain;
+			state.classes = n.map((v) => clamp01((v - d0) / (d1 - d0)));
+			state.classes.sort((a, b) => a - b);
+		} else {
+			state.classes = null;
+		}
+		clearCache();
+		return scale;
+	};
+
+	scale.padding = function (p) {
+		if (p === undefined) return state.padding.slice();
+		if (typeof p === "number") state.padding = [p, p];
+		else state.padding = [p[0], p[1]];
+		clearCache();
+		return scale;
+	};
+
+	scale.gamma = function (g) {
+		if (g === undefined) return state.gamma;
+		state.gamma = g;
+		clearCache();
+		return scale;
+	};
+
+	scale.mode = function (space) {
+		if (space === undefined) return state.space;
+		state.space = space;
+		clearCache();
+		return scale;
+	};
+
+	scale.correctLightness = function (enable = true) {
+		if (!enable) {
+			state.lightnessCorrection = null;
+		} else {
+			// Precompute: sample the raw scale at uniform t, record Lab L,
+			// then build an inverse lookup from desired-L to actual-t.
+			const samples = 64;
+			const ts = new Array(samples + 1);
+			const ls = new Array(samples + 1);
+			const saved = state.lightnessCorrection;
+			state.lightnessCorrection = null;
+			for (let i = 0; i <= samples; i++) {
+				const t = i / samples;
+				ts[i] = t;
+				ls[i] = sampleRaw(normalizedToDomain(t, state.domain)).lab.l;
+			}
+			state.lightnessCorrection = saved;
+			const lStart = ls[0];
+			const lEnd = ls[samples];
+			state.lightnessCorrection = function (u) {
+				// Desired L at position u (linear in L).
+				const targetL = lStart + (lEnd - lStart) * u;
+				// Find the two sample indices bracketing targetL.
+				// (Monotonic-in-t but not necessarily monotonic-in-L,
+				// so we take the segment whose endpoints straddle it.)
+				for (let i = 0; i < samples; i++) {
+					const la = ls[i];
+					const lb = ls[i + 1];
+					if (
+						(la <= targetL && targetL <= lb) ||
+						(lb <= targetL && targetL <= la)
+					) {
+						const frac =
+							lb === la ? 0 : (targetL - la) / (lb - la);
+						return ts[i] + frac * (ts[i + 1] - ts[i]);
+					}
+				}
+				return u;
+			};
+		}
+		clearCache();
+		return scale;
+	};
+
+	scale.cache = function (on) {
+		if (on === undefined) return state.cache;
+		state.cache = !!on;
+		if (!state.cache) state.cacheMap = new Map();
+		return scale;
+	};
+
+	return scale;
+}
+
+function normalizedToDomain(u, domain) {
+	const [d0, d1] = domain;
+	return d0 + u * (d1 - d0);
+}
+
+function bucketize(u, breaks) {
+	// Classes are normalized breakpoints in [0, 1]; find the bin
+	// index, return the midpoint of its normalized bin.
+	for (let i = 0; i < breaks.length - 1; i++) {
+		if (u >= breaks[i] && u <= breaks[i + 1]) {
+			return (breaks[i] + breaks[i + 1]) / 2;
+		}
+	}
+	return u;
+}
+
+// Public entry: swatch.scale(stops or palette name)
+export function scale(stops) {
+	let resolved;
+	if (typeof stops === "string") {
+		const palette = getPalette(stops);
+		if (!palette) {
+			throw new Error(
+				appendSuggestion(
+					`scale: unknown palette "${stops}"`,
+					stops,
+					listPalettes()
+				)
+			);
+		}
+		resolved = palette;
+	} else if (typeof stops === "function") {
+		// Caller passed a bezier/cubehelix function: wrap it as a
+		// pre-built sampler. It already takes t in [0,1] and returns a
+		// Swatch, so we just expose it with the same surface API.
+		return wrapFunctionScale(stops);
+	} else {
+		resolved = stops;
+	}
+
+	const state = {
+		domain: [0, 1],
+		padding: [0, 0],
+		gamma: 1,
+		classes: null,
+		space: "oklab",
+		lightnessCorrection: null,
+		cache: true,
+		cacheMap: new Map()
+	};
+	return buildScale(resolved, state);
+}
+
+function wrapFunctionScale(fn) {
+	const state = {
+		domain: [0, 1],
+		padding: [0, 0],
+		gamma: 1,
+		classes: null,
+		space: "oklab",
+		lightnessCorrection: null,
+		cache: true,
+		cacheMap: new Map()
+	};
+
+	function sampleRaw(t) {
+		const [d0, d1] = state.domain;
+		let u = d0 === d1 ? 0 : (t - d0) / (d1 - d0);
+		u = clamp01(u);
+		const [pl, pr] = state.padding;
+		u = pl + u * (1 - pl - pr);
+		if (state.gamma !== 1) u = Math.pow(u, state.gamma);
+		if (state.lightnessCorrection) u = state.lightnessCorrection(u);
+		if (state.classes) u = bucketize(u, state.classes);
+		return fn(u);
+	}
+
+	function sample(t) {
+		if (state.cache) {
+			if (state.cacheMap.has(t)) return state.cacheMap.get(t);
+			const v = sampleRaw(t);
+			state.cacheMap.set(t, v);
+			return v;
+		}
+		return sampleRaw(t);
+	}
+
+	function scale(t) {
+		return sample(t);
+	}
+
+	scale.colors = function (n, format) {
+		const out = [];
+		const [d0, d1] = state.domain;
+		if (n <= 0) return out;
+		if (n === 1) {
+			out.push(sample((d0 + d1) / 2));
+		} else {
+			for (let i = 0; i < n; i++) {
+				const t = d0 + (d1 - d0) * (i / (n - 1));
+				out.push(sample(t));
+			}
+		}
+		if (format) return out.map((c) => c.toString({ format }));
+		return out;
+	};
+	scale.domain = function (d) {
+		if (d === undefined) return state.domain.slice();
+		state.domain = [d[0], d[1]];
+		state.cacheMap = new Map();
+		return scale;
+	};
+	scale.classes = function (n) {
+		if (n === undefined) return state.classes;
+		if (typeof n === "number") {
+			const breaks = [];
+			for (let i = 0; i <= n; i++) breaks.push(i / n);
+			state.classes = breaks;
+		} else if (Array.isArray(n)) {
+			const [d0, d1] = state.domain;
+			state.classes = n
+				.map((v) => clamp01((v - d0) / (d1 - d0)))
+				.sort((a, b) => a - b);
+		} else state.classes = null;
+		state.cacheMap = new Map();
+		return scale;
+	};
+	scale.padding = function (p) {
+		if (p === undefined) return state.padding.slice();
+		state.padding = typeof p === "number" ? [p, p] : [p[0], p[1]];
+		state.cacheMap = new Map();
+		return scale;
+	};
+	scale.gamma = function (g) {
+		if (g === undefined) return state.gamma;
+		state.gamma = g;
+		state.cacheMap = new Map();
+		return scale;
+	};
+	scale.mode = function (space) {
+		if (space === undefined) return state.space;
+		state.space = space;
+		state.cacheMap = new Map();
+		return scale;
+	};
+	scale.correctLightness = function (enable = true) {
+		// Not implemented for wrapped function scales — the semantics
+		// are the same but would require resampling through the input
+		// fn, and bezier/cubehelix usually already control L explicitly.
+		return scale;
+	};
+	scale.cache = function (on) {
+		if (on === undefined) return state.cache;
+		state.cache = !!on;
+		if (!state.cache) state.cacheMap = new Map();
+		return scale;
+	};
+	return scale;
+}

package/src/scale/interpolators.js

@@ -0,0 +1,83 @@
+// Scale interpolators.
+//
+//   bezier([c0, c1, c2, ...])
+//     chroma.js-style Bezier-smoothed interpolation through Lab stops.
+//     Returns a function t∈[0,1] → Swatch that can be passed to
+//     swatch.scale(...) and then reshaped with .domain(), .classes(),
+//     .padding(), .gamma() like any other scale.
+//
+//   cubehelix({ start, rotations, hue, gamma, lightness })
+//     Green & Dave's cubehelix interpolation — a one-dimensional
+//     colormap that spirals through RGB space with monotonically
+//     varying lightness. Arguments match chroma.js's cubehelix.
+//     Returns the same t∈[0,1] → Swatch function shape.
+
+import { Swatch, swatch } from "../core/swatch-class.js";
+
+function toSwatch(input) {
+	return input instanceof Swatch ? input : swatch(input);
+}
+
+// De Casteljau's algorithm on Lab coords. Returns a Lab triple.
+function bezierLab(stops, t) {
+	const n = stops.length;
+	if (n === 1) return stops[0];
+	const work = stops.map((s) => [s[0], s[1], s[2]]);
+	for (let r = 1; r < n; r++) {
+		for (let i = 0; i < n - r; i++) {
+			for (let k = 0; k < 3; k++) {
+				work[i][k] = work[i][k] * (1 - t) + work[i + 1][k] * t;
+			}
+		}
+	}
+	return work[0];
+}
+
+export function bezier(colors) {
+	const stops = colors.map(toSwatch);
+	const labs = stops.map((s) => {
+		const { l, a, b } = s.lab;
+		return [l, a, b];
+	});
+	return function (t) {
+		const [l, a, b] = bezierLab(labs, t);
+		return new Swatch({ space: "lab", coords: [l, a, b], alpha: 1 });
+	};
+}
+
+// Cubehelix — reference: D. A. Green (2011), "A colour scheme for
+// the display of astronomical intensity images", Bulletin of the
+// Astronomical Society of India, 39, 289.
+//
+// t∈[0,1] → Swatch (sRGB). gamma shapes the lightness ramp; hue
+// controls chroma amplitude; start/rotations define the spiral.
+export function cubehelix(opts = {}) {
+	const start = opts.start != null ? opts.start : 300;
+	const rotations = opts.rotations != null ? opts.rotations : -1.5;
+	const hue = opts.hue != null ? opts.hue : 1;
+	const gamma = opts.gamma != null ? opts.gamma : 1;
+	const lightness =
+		opts.lightness != null ? opts.lightness : [0, 1];
+
+	return function (t) {
+		const lStart = lightness[0];
+		const lEnd = lightness[1];
+		const f = lStart + (lEnd - lStart) * t;
+		const l = Math.pow(f, gamma);
+		const angle =
+			2 * Math.PI * (start / 360 + 1 + rotations * t);
+		const amp = (hue * l * (1 - l)) / 2;
+		const cosA = Math.cos(angle);
+		const sinA = Math.sin(angle);
+		let r = l + amp * (-0.14861 * cosA + 1.78277 * sinA);
+		let g = l + amp * (-0.29227 * cosA - 0.90649 * sinA);
+		let b = l + amp * (1.97294 * cosA);
+		if (r < 0) r = 0;
+		if (r > 1) r = 1;
+		if (g < 0) g = 0;
+		if (g > 1) g = 1;
+		if (b < 0) b = 0;
+		if (b > 1) b = 1;
+		return new Swatch({ space: "srgb", coords: [r, g, b], alpha: 1 });
+	};
+}