@luntta/swatch 3.0.0

package/src/spaces/lch.js

@@ -0,0 +1,65 @@
+// CIE LCh — polar form of CIE Lab.
+//
+// Two variants are registered matching the Lab variants:
+//   lch      (D65, our default)
+//   lch-d50  (CSS Color 4 variant)
+
+import { registerSpace, convert } from "../core/registry.js";
+import { labToLchPolar, lchToLabRect } from "../util/math.js";
+
+function lchToXyz(coords, labSpaceId) {
+	const lab = lchToLabRect({ l: coords[0], c: coords[1], h: coords[2] });
+	return convert([lab.l, lab.a, lab.b], labSpaceId, "xyz");
+}
+
+function xyzToLch(xyz, labSpaceId) {
+	const [l, a, b] = convert(xyz, "xyz", labSpaceId);
+	const lch = labToLchPolar({ l, a, b });
+	return [lch.l, lch.c, lch.h];
+}
+
+registerSpace({
+	id: "lch",
+	channels: ["l", "c", "h"],
+	ranges: [
+		[0, 100],
+		[0, 150],
+		[0, 360]
+	],
+	white: "D65",
+	toXYZ: (coords) => lchToXyz(coords, "lab"),
+	fromXYZ: (xyz) => xyzToLch(xyz, "lab"),
+	shortcuts: {
+		lab: (coords) => {
+			const { l, a, b } = lchToLabRect({
+				l: coords[0],
+				c: coords[1],
+				h: coords[2]
+			});
+			return [l, a, b];
+		}
+	}
+});
+
+registerSpace({
+	id: "lch-d50",
+	channels: ["l", "c", "h"],
+	ranges: [
+		[0, 100],
+		[0, 150],
+		[0, 360]
+	],
+	white: "D50",
+	toXYZ: (coords) => lchToXyz(coords, "lab-d50"),
+	fromXYZ: (xyz) => xyzToLch(xyz, "lab-d50"),
+	shortcuts: {
+		"lab-d50": (coords) => {
+			const { l, a, b } = lchToLabRect({
+				l: coords[0],
+				c: coords[1],
+				h: coords[2]
+			});
+			return [l, a, b];
+		}
+	}
+});

package/src/spaces/oklab.js

@@ -0,0 +1,79 @@
+// OKLab — Björn Ottosson (2020), "A perceptual color space for image processing".
+//
+// L is on 0..1 (roughly maps to L* 0..100 perceptually). a and b are signed,
+// typically in [-0.4, 0.4].
+//
+// The transform is defined from linear sRGB directly, so we register a
+// direct shortcut `srgb-linear ↔ oklab` that bypasses the XYZ hub for
+// accuracy and speed. v2's `_linearRGBToOklab` (src/swatch.js:1495-1516)
+// and `_oklabToRGB` (src/swatch.js:1131-1150) supply the exact same
+// coefficients.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+
+// Linear sRGB → OKLab.
+export function linearSrgbToOklab(lin) {
+	const l =
+		0.4122214708 * lin[0] +
+		0.5363325363 * lin[1] +
+		0.0514459929 * lin[2];
+	const m =
+		0.2119034982 * lin[0] +
+		0.6806995451 * lin[1] +
+		0.1073969566 * lin[2];
+	const s =
+		0.0883024619 * lin[0] +
+		0.2817188376 * lin[1] +
+		0.6299787005 * lin[2];
+	const lp = Math.cbrt(l);
+	const mp = Math.cbrt(m);
+	const sp = Math.cbrt(s);
+	return [
+		0.2104542553 * lp + 0.793617785 * mp - 0.0040720468 * sp,
+		1.9779984951 * lp - 2.428592205 * mp + 0.4505937099 * sp,
+		0.0259040371 * lp + 0.7827717662 * mp - 0.808675766 * sp
+	];
+}
+
+// OKLab → linear sRGB. Inverse of the transform above.
+export function oklabToLinearSrgb(ok) {
+	const lp = ok[0] + 0.3963377774 * ok[1] + 0.2158037573 * ok[2];
+	const mp = ok[0] - 0.1055613458 * ok[1] - 0.0638541728 * ok[2];
+	const sp = ok[0] - 0.0894841775 * ok[1] - 1.291485548 * ok[2];
+	const l = lp * lp * lp;
+	const m = mp * mp * mp;
+	const s = sp * sp * sp;
+	return [
+		4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+		-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+		-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+	];
+}
+
+registerSpace({
+	id: "oklab",
+	channels: ["l", "a", "b"],
+	ranges: [
+		[0, 1],
+		[-0.4, 0.4],
+		[-0.4, 0.4]
+	],
+	white: "D65",
+	toXYZ: (coords) => {
+		const lin = oklabToLinearSrgb(coords);
+		return getSpace("srgb-linear").toXYZ(lin);
+	},
+	fromXYZ: (xyz) => {
+		const lin = getSpace("srgb-linear").fromXYZ(xyz);
+		return linearSrgbToOklab(lin);
+	},
+	shortcuts: {
+		"srgb-linear": (coords) => oklabToLinearSrgb(coords)
+	}
+});
+
+// Add the reverse shortcut on srgb-linear. We can't do this at the
+// srgb-linear registration site without a circular dependency, so we
+// patch it here after both spaces exist.
+getSpace("srgb-linear").shortcuts.oklab = (coords) =>
+	linearSrgbToOklab(coords);

package/src/spaces/oklch.js

@@ -0,0 +1,53 @@
+// OKLCh — polar form of OKLab. Direct shortcut converters to/from OKLab
+// avoid a round-trip through XYZ or linear sRGB.
+
+import { registerSpace } from "../core/registry.js";
+import { labToLchPolar, lchToLabRect } from "../util/math.js";
+import { linearSrgbToOklab, oklabToLinearSrgb } from "./oklab.js";
+import { getSpace } from "../core/registry.js";
+
+registerSpace({
+	id: "oklch",
+	channels: ["l", "c", "h"],
+	ranges: [
+		[0, 1],
+		[0, 0.4],
+		[0, 360]
+	],
+	white: "D65",
+	toXYZ: (coords) => {
+		const { l, a, b } = lchToLabRect({
+			l: coords[0],
+			c: coords[1],
+			h: coords[2]
+		});
+		const lin = oklabToLinearSrgb([l, a, b]);
+		return getSpace("srgb-linear").toXYZ(lin);
+	},
+	fromXYZ: (xyz) => {
+		const lin = getSpace("srgb-linear").fromXYZ(xyz);
+		const ok = linearSrgbToOklab(lin);
+		const { l, c, h } = labToLchPolar({ l: ok[0], a: ok[1], b: ok[2] });
+		return [l, c, h];
+	},
+	shortcuts: {
+		oklab: (coords) => {
+			const { l, a, b } = lchToLabRect({
+				l: coords[0],
+				c: coords[1],
+				h: coords[2]
+			});
+			return [l, a, b];
+		}
+	}
+});
+
+// Reverse shortcut from oklab → oklch.
+getSpace("oklab").shortcuts.oklch = (coords) => {
+	const { l, c, h } = labToLchPolar({
+		l: coords[0],
+		a: coords[1],
+		b: coords[2]
+	});
+	return [l, c, h];
+};

package/src/spaces/prophoto.js

@@ -0,0 +1,72 @@
+// ProPhoto RGB color space.
+//
+// D50 white with a piecewise transfer function (linear near zero,
+// gamma 1.8 above). ProPhoto has the widest gamut of the common RGB
+// spaces — large enough to cover colors outside the human visual
+// system, which is why it ships with a caveat in pipelines.
+//
+// Because ProPhoto is natively D50 we apply the Bradford chromatic
+// adaptation transform on the way to/from the canonical D65 XYZ hub.
+//
+// Matrices from the CSS Color 4 sample code; transfer function from
+// the ROMM RGB spec (ISO 22028-2).
+
+import { multiplyMatrixVector } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+import { adaptD50ToD65, adaptD65ToD50 } from "./xyz.js";
+
+const ET = 1 / 512;
+const ET_LINEAR = 16 / 512;
+
+export function prophotoToLinear(coords) {
+	const f = (v) => {
+		const abs = Math.abs(v);
+		if (abs < ET_LINEAR) return v / 16;
+		return Math.sign(v) * Math.pow(abs, 1.8);
+	};
+	return [f(coords[0]), f(coords[1]), f(coords[2])];
+}
+
+export function linearToProphoto(lin) {
+	const f = (v) => {
+		const abs = Math.abs(v);
+		if (abs < ET) return 16 * v;
+		return Math.sign(v) * Math.pow(abs, 1 / 1.8);
+	};
+	return [f(lin[0]), f(lin[1]), f(lin[2])];
+}
+
+// Linear ProPhoto → XYZ D50.
+export const LINEAR_PROPHOTO_TO_XYZ_D50 = [
+	[0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
+	[0.2880748288194013, 0.711835234241873, 0.00008993693872564],
+	[0.0, 0.0, 0.8251046025104602]
+];
+
+// XYZ D50 → Linear ProPhoto.
+export const XYZ_D50_TO_LINEAR_PROPHOTO = [
+	[1.3457868816471585, -0.25557208737979464, -0.05110186497554526],
+	[-0.5446307051249019, 1.5082477428451468, 0.02052744743642139],
+	[0.0, 0.0, 1.2119675456389452]
+];
+
+export function linearProphotoToXyzD50(lin) {
+	return multiplyMatrixVector(LINEAR_PROPHOTO_TO_XYZ_D50, lin);
+}
+
+export function xyzD50ToLinearProphoto(xyz) {
+	return multiplyMatrixVector(XYZ_D50_TO_LINEAR_PROPHOTO, xyz);
+}
+
+registerSpace({
+	id: "prophoto",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D50",
+	toXYZ: (coords) => adaptD50ToD65(linearProphotoToXyzD50(prophotoToLinear(coords))),
+	fromXYZ: (xyz) => linearToProphoto(xyzD50ToLinearProphoto(adaptD65ToD50(xyz)))
+});

package/src/spaces/rec2020.js

@@ -0,0 +1,65 @@
+// ITU-R BT.2020 (Rec2020) wide-gamut space.
+//
+// Primaries + D65 white, with its own transfer function (α ≈ 1.09929,
+// β ≈ 0.01806). Rec2020 is the UHDTV standard and the reference
+// wide-gamut space for video/HDR workflows.
+//
+// Matrices from the CSS Color 4 sample code; transfer function from
+// ITU-R BT.2020-2.
+
+import { multiplyMatrixVector } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+
+const ALPHA = 1.09929682680944;
+const BETA = 0.018053968510807;
+
+export function rec2020ToLinear(coords) {
+	const f = (v) => {
+		const abs = Math.abs(v);
+		if (abs < BETA * 4.5) return v / 4.5;
+		return Math.sign(v) * Math.pow((abs + ALPHA - 1) / ALPHA, 1 / 0.45);
+	};
+	return [f(coords[0]), f(coords[1]), f(coords[2])];
+}
+
+export function linearToRec2020(lin) {
+	const f = (v) => {
+		const abs = Math.abs(v);
+		if (abs < BETA) return 4.5 * v;
+		return Math.sign(v) * (ALPHA * Math.pow(abs, 0.45) - (ALPHA - 1));
+	};
+	return [f(lin[0]), f(lin[1]), f(lin[2])];
+}
+
+export const LINEAR_REC2020_TO_XYZ_D65 = [
+	[0.6369580483012914, 0.14461690358620832, 0.1688809751641721],
+	[0.26270021201126703, 0.6779980715188708, 0.05930171646986196],
+	[0.0, 0.028072693049087428, 1.060985057710791]
+];
+
+export const XYZ_D65_TO_LINEAR_REC2020 = [
+	[1.7166511879712674, -0.35567078377639233, -0.25336628137365974],
+	[-0.6666843518324892, 1.6164812366349395, 0.01576854581391113],
+	[0.017639857445310783, -0.042770613257808524, 0.9421031212354738]
+];
+
+export function linearRec2020ToXyz(lin) {
+	return multiplyMatrixVector(LINEAR_REC2020_TO_XYZ_D65, lin);
+}
+
+export function xyzToLinearRec2020(xyz) {
+	return multiplyMatrixVector(XYZ_D65_TO_LINEAR_REC2020, xyz);
+}
+
+registerSpace({
+	id: "rec2020",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => linearRec2020ToXyz(rec2020ToLinear(coords)),
+	fromXYZ: (xyz) => linearToRec2020(xyzToLinearRec2020(xyz))
+});

package/src/spaces/srgb.js

@@ -0,0 +1,85 @@
+// sRGB and linear-light sRGB spaces.
+//
+// Two spaces are registered:
+//
+//   srgb         — gamma-encoded sRGB, coords in [0, 1] (not 0..255).
+//   srgb-linear  — linear-light sRGB (gamma removed), coords in [0, 1].
+//
+// Keeping the coords in [0, 1] rather than 0..255 is the CSS Color 4 /
+// colorjs.io convention; 0..255 is a *view* exposed by the legacy `.rgb`
+// getter on the Swatch class, not the canonical storage.
+//
+// The sRGB transfer function uses the piecewise approximation with the
+// standard 0.03928 knee. The primaries matrix (sRGB linear → XYZ D65) is the
+// BT.709 reference, identical to what v2 used in _tMatrixRGBToXYZ.
+
+import { multiplyMatrixVector, invertMatrix } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+
+// sRGB inverse EOTF: gamma-encoded → linear light.
+export function srgbToLinear(rgb) {
+	const f = (v) =>
+		Math.abs(v) <= 0.04045
+			? v / 12.92
+			: Math.sign(v) * Math.pow((Math.abs(v) + 0.055) / 1.055, 2.4);
+	return [f(rgb[0]), f(rgb[1]), f(rgb[2])];
+}
+
+// sRGB EOTF: linear light → gamma-encoded.
+export function linearToSrgb(lin) {
+	const f = (v) =>
+		Math.abs(v) <= 0.0031308
+			? 12.92 * v
+			: Math.sign(v) * (1.055 * Math.pow(Math.abs(v), 1 / 2.4) - 0.055);
+	return [f(lin[0]), f(lin[1]), f(lin[2])];
+}
+
+// Linear sRGB → CIE XYZ D65. BT.709 primaries, same values as v2's
+// _tMatrixRGBToXYZ (src/swatch.js:1737-1743).
+export const LINEAR_SRGB_TO_XYZ_D65 = [
+	[0.4124564, 0.3575761, 0.1804375],
+	[0.2126729, 0.7151522, 0.072175],
+	[0.0193339, 0.119192, 0.9503041]
+];
+
+export const XYZ_D65_TO_LINEAR_SRGB = invertMatrix(LINEAR_SRGB_TO_XYZ_D65);
+
+export function linearSrgbToXyz(lin) {
+	return multiplyMatrixVector(LINEAR_SRGB_TO_XYZ_D65, lin);
+}
+
+export function xyzToLinearSrgb(xyz) {
+	return multiplyMatrixVector(XYZ_D65_TO_LINEAR_SRGB, xyz);
+}
+
+registerSpace({
+	id: "srgb-linear",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => linearSrgbToXyz(coords),
+	fromXYZ: (xyz) => xyzToLinearSrgb(xyz),
+	shortcuts: {
+		srgb: (coords) => linearToSrgb(coords)
+	}
+});
+
+registerSpace({
+	id: "srgb",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => linearSrgbToXyz(srgbToLinear(coords)),
+	fromXYZ: (xyz) => linearToSrgb(xyzToLinearSrgb(xyz)),
+	shortcuts: {
+		"srgb-linear": (coords) => srgbToLinear(coords)
+	}
+});

package/src/spaces/xyz.js

@@ -0,0 +1,71 @@
+// CIE XYZ color space and chromatic adaptation transforms.
+//
+// Two whites are registered:
+//
+//   xyz / xyz-d65 — D65 reference white. This is the canonical hub for the
+//                   conversion graph. All other spaces convert to/from this.
+//   xyz-d50       — D50 reference white. Used by spaces that are natively
+//                   defined under D50 (CIE Lab D50, ProPhoto). The Bradford
+//                   chromatic adaptation transform converts between D50 and
+//                   D65 with very low error.
+//
+// Reference white tristimulus values (Y normalized to 1):
+//   D65 ≈ (0.95047, 1.0,    1.08883)
+//   D50 ≈ (0.96422, 1.0,    0.82521)
+
+import { multiplyMatrixVector } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+
+export const D65 = [0.95047, 1.0, 1.08883];
+export const D50 = [0.96422, 1.0, 0.82521];
+
+// Bradford chromatic adaptation transforms.
+//
+// Source: https://www.w3.org/TR/css-color-4/#color-conversion-code
+// (the W3C-recommended Bradford CAT used in CSS Color 4 conversions).
+export const BRADFORD_D50_TO_D65 = [
+	[0.9554734527042182, -0.023098536874261423, 0.0632593086610217],
+	[-0.028369706963208136, 1.0099954580058226, 0.021041398966943008],
+	[0.012314001688319899, -0.020507696433477912, 1.3303659366080753]
+];
+
+export const BRADFORD_D65_TO_D50 = [
+	[1.0479298208405488, 0.022946793341019434, -0.05019222954313557],
+	[0.029627815688159608, 0.990434484573249, -0.01707382502938514],
+	[-0.009243058152591178, 0.015055144896577895, 0.7518742899580008]
+];
+
+export function adaptD50ToD65(xyz) {
+	return multiplyMatrixVector(BRADFORD_D50_TO_D65, xyz);
+}
+
+export function adaptD65ToD50(xyz) {
+	return multiplyMatrixVector(BRADFORD_D65_TO_D50, xyz);
+}
+
+// XYZ D65 — the hub. toXYZ / fromXYZ are identity.
+registerSpace({
+	id: "xyz",
+	channels: ["x", "y", "z"],
+	white: "D65",
+	toXYZ: (coords) => [coords[0], coords[1], coords[2]],
+	fromXYZ: (xyz) => [xyz[0], xyz[1], xyz[2]]
+});
+
+// Alias.
+registerSpace({
+	id: "xyz-d65",
+	channels: ["x", "y", "z"],
+	white: "D65",
+	toXYZ: (coords) => [coords[0], coords[1], coords[2]],
+	fromXYZ: (xyz) => [xyz[0], xyz[1], xyz[2]]
+});
+
+// XYZ D50 — Bradford-adapted on the way to/from the hub.
+registerSpace({
+	id: "xyz-d50",
+	channels: ["x", "y", "z"],
+	white: "D50",
+	toXYZ: (coords) => adaptD50ToD65(coords),
+	fromXYZ: (xyz) => adaptD65ToD50(xyz)
+});

package/src/swatch.js

@@ -0,0 +1,57 @@
+// swatch — main entry point.
+//
+// Importing this module has two effects:
+//
+//   1. Side effects from `./bootstrap.js`: every registered color space
+//      is loaded, the CSS Color 4 parser is attached, and the operations
+//      (channels, gamut, manipulation, tint/shade, mix, blend, ΔE,
+//      naming, temperature, accessibility, APCA, CVD, scales, palettes)
+//      are wired onto the Swatch prototype and the factory.
+//
+//   2. Re-exports: the `swatch` factory function (callable, with statics
+//      for temperature, random, scale, bezier, cubehelix, palettes,
+//      contrast, isReadable, ensureContrast, apcaContrast, simulate,
+//      daltonize, checkPalette, nearestDistinguishable, mostReadable),
+//      the `Swatch` class, and the default export.
+//
+// Typical usage:
+//
+//   import swatch from "@luntta/swatch";
+//   swatch("oklch(0.7 0.15 240)").lighten(0.05).toString({ format: "hex" });
+
+import "./bootstrap.js";
+import { swatch, Swatch } from "./core/swatch-class.js";
+
+export { swatch, Swatch };
+export default swatch;
+
+// Named re-exports of the factory statics, so bundlers can tree-shake unused
+// helpers and editors can autocomplete them directly:
+//
+//   import { scale, contrast, spaces } from "@luntta/swatch";
+//
+// `swatch.try` stays on the factory only — `try` is a reserved word and
+// cannot be a named export.
+export const {
+	temperature,
+	random,
+	contrast,
+	isReadable,
+	ensureContrast,
+	apcaContrast,
+	simulate,
+	daltonize,
+	simulateImageData,
+	daltonizeImageData,
+	image,
+	checkPalette,
+	nearestDistinguishable,
+	mostReadable,
+	scale,
+	bezier,
+	cubehelix,
+	palettes,
+	isColor,
+	spaces,
+	cvd
+} = swatch;

package/src/util/math.js

@@ -0,0 +1,53 @@
+// Generic numeric helpers used by multiple modules.
+
+export function clamp(value, lo, hi) {
+	return value < lo ? lo : value > hi ? hi : value;
+}
+
+export function lerp(a, b, t) {
+	return a + (b - a) * t;
+}
+
+// Shortest-arc hue interpolation in degrees.
+export function lerpHue(a, b, t) {
+	let dh = b - a;
+	if (dh > 180) dh -= 360;
+	else if (dh < -180) dh += 360;
+	let h = a + dh * t;
+	if (h < 0) h += 360;
+	else if (h >= 360) h -= 360;
+	return h;
+}
+
+export function degToRad(deg) {
+	return (deg * Math.PI) / 180;
+}
+
+export function radToDeg(rad) {
+	return (rad * 180) / Math.PI;
+}
+
+// Wrap a hue into [0, 360).
+export function normalizeHue(h) {
+	h = h % 360;
+	if (h < 0) h += 360;
+	return h;
+}
+
+// Lab-style {l, a, b} → polar {l, c, h}. Used by both CIE LCh and OKLCh.
+export function labToLchPolar(lab) {
+	const c = Math.hypot(lab.a, lab.b);
+	let h = Math.atan2(lab.b, lab.a) * (180 / Math.PI);
+	if (h < 0) h += 360;
+	return { l: lab.l, c, h };
+}
+
+// Polar {l, c, h} → {l, a, b}.
+export function lchToLabRect(lch) {
+	const hRad = (lch.h * Math.PI) / 180;
+	return {
+		l: lch.l,
+		a: lch.c * Math.cos(hRad),
+		b: lch.c * Math.sin(hRad)
+	};
+}

package/src/util/matrix.js

@@ -0,0 +1,92 @@
+// 3×3 matrix helpers extracted from src/swatch.js (the v2 monolith).
+// Generic in dimension; the consumers in v3 only ever use 3×3.
+
+export function multiplyMatrices(mA, mB) {
+	const result = new Array(mA.length)
+		.fill(0)
+		.map(() => new Array(mB[0].length).fill(0));
+
+	return result.map((row, i) =>
+		row.map((_, j) => mA[i].reduce((sum, _v, k) => sum + mA[i][k] * mB[k][j], 0))
+	);
+}
+
+// Apply a 3×3 matrix to a length-3 vector.
+export function multiplyMatrixVector(M, v) {
+	return [
+		M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2],
+		M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2],
+		M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2]
+	];
+}
+
+// Square-matrix inversion via Gauss–Jordan.
+// Adapted from Andrew Ippoliti, http://blog.acipo.com/matrix-inversion-in-javascript/
+export function invertMatrix(matrix) {
+	if (matrix.length !== matrix[0].length) {
+		return undefined;
+	}
+	let i = 0,
+		ii = 0,
+		j = 0,
+		e = 0;
+	const dim = matrix.length;
+	const I = [];
+	const C = [];
+	for (i = 0; i < dim; i += 1) {
+		I[I.length] = [];
+		C[C.length] = [];
+		for (j = 0; j < dim; j += 1) {
+			I[i][j] = i === j ? 1 : 0;
+			C[i][j] = matrix[i][j];
+		}
+	}
+
+	for (i = 0; i < dim; i += 1) {
+		e = C[i][i];
+
+		if (e === 0) {
+			for (ii = i + 1; ii < dim; ii += 1) {
+				if (C[ii][i] !== 0) {
+					for (j = 0; j < dim; j++) {
+						e = C[i][j];
+						C[i][j] = C[ii][j];
+						C[ii][j] = e;
+						e = I[i][j];
+						I[i][j] = I[ii][j];
+						I[ii][j] = e;
+					}
+					break;
+				}
+			}
+			e = C[i][i];
+			if (e === 0) {
+				return undefined;
+			}
+		}
+
+		for (j = 0; j < dim; j++) {
+			C[i][j] = C[i][j] / e;
+			I[i][j] = I[i][j] / e;
+		}
+
+		for (ii = 0; ii < dim; ii++) {
+			if (ii === i) continue;
+			e = C[ii][i];
+			for (j = 0; j < dim; j++) {
+				C[ii][j] -= e * C[i][j];
+				I[ii][j] -= e * I[i][j];
+			}
+		}
+	}
+
+	return I;
+}
+
+export function identity3() {
+	return [
+		[1, 0, 0],
+		[0, 1, 0],
+		[0, 0, 1]
+	];
+}