@amplib/color 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2024-2026 Another Machine
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,69 @@
+# @amplib/color
+
+Color analysis utilities.
+
+```ts
+import { toPerceptual, fromPerceptual } from "@amplib/color";
+
+toPerceptual(210); // 256.22 — display blue is much further round than it looks
+fromPerceptual(180); // 172.88 — the display hue that reads as halfway to cyan
+```
+
+Divide a hue wheel into six equal slices in HSV and the slices do not look
+equal. Divide it in oklch and they do. That is the entire purpose of this
+package: a bijection between the hue you write down and the hue people see.
+
+```ts
+// Six hues that actually look evenly spaced.
+const spaced = Array.from({ length: 6 }, (_, i) => fromPerceptual(i * 60));
+// 328.0, 33.8, 68.9, 172.9, 198.9, 274.6 — not 0, 60, 120, 180, 240, 300
+```
+
+Note where that list starts. Perceptual 0° is display **328°**, not 0° — the
+angle vision reads as the origin of the wheel sits in magenta, some way before
+display red. The two wheels do not share a zero, so there is no offset you
+could apply instead of the mapping.
+
+## Modules
+
+| Module                 | Description                                          |
+| ---------------------- | ---------------------------------------------------- |
+| `toPerceptual`         | Display (HSV) hue → perceptual (oklch) hue           |
+| `fromPerceptual`       | Perceptual (oklch) hue → display (HSV) hue           |
+| `worstRoundTripError`  | Measured disagreement between the two directions     |
+
+## Design
+
+**The wheel is severely non-linear, and not in the direction most descriptions
+suggest.** Measured as perceptual degrees per display degree:
+
+| red   | orange | yellow | green | cyan  | blue  | deep blue | magenta |
+| ----- | ------ | ------ | ----- | ----- | ----- | --------- | ------- |
+| 0.21× | 1.76×  | 1.29×  | 0.05× | 2.23× | 0.14× | 0.01×     | 0.94×   |
+
+Green and deep blue barely move — a wide sweep of display hue is almost one
+perceptual color — while cyan and orange stretch. Over two hundredfold between
+the extremes.
+
+**The round-trip is measured, not assumed.** The forward table samples oklch
+once per display degree; the inverse searches it backwards at twenty times that
+resolution, because the deep-blue zone squeezes roughly 16 display degrees into
+half a perceptual degree and would otherwise collapse to a single bin. The two
+are built by different methods and only approximately invert each other, so
+`worstRoundTripError()` measures the disagreement and `npm test` fails the
+build above 1.5°.
+
+Raw oklch hue also steps *backwards* by a fraction of a degree around display
+231–240°, which would make the mapping non-invertible exactly there. Every
+backward run is replaced with a straight interpolation across it.
+
+**The error check is exported, not run on import.** A library that asserts at
+load time charges every consumer for the check whether they want it or not, and
+still cannot fail a build when it matters.
+
+**Hue only, saturation and lightness untouched.** Full-saturation, full-value
+HSV is the sampling line, so this answers "which angle" and says nothing about
+how light or vivid the result is. Anything needing the other two axes wants a
+full color-space conversion, not this.
+
+Matrix constants from Björn Ottosson's oklab reference implementation (2020).

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A bijective mapping between display hue and perceptual hue.
+ *
+ * HSV hue is what a camera reports and what people use to name a color on a
+ * screen. Oklch hue — atan2(b, a) of oklab — is the angle human vision reads
+ * as evenly spaced. Both run 0–360°, but the mapping between them is severely
+ * non-linear, and not in the direction most descriptions of it suggest.
+ * Measured as perceptual degrees per display degree:
+ *
+ *   red 0.21×   orange 1.76×   yellow 1.29×   green 0.05×
+ *   cyan 2.23×  blue 0.14×     deep blue 0.01×  magenta 0.94×
+ *
+ * Green and deep blue barely move at all — a wide sweep of display hue is
+ * almost one perceptual color — while cyan and orange stretch. The spread
+ * between the extremes is over two hundredfold.
+ *
+ * That is the whole reason this file exists. Divide a hue wheel into equal
+ * slices in HSV and the slices do not look equal; divide it in oklch and they
+ * do.
+ */
+/** Display (HSV) hue → perceptual (oklch) hue. */
+declare function toPerceptual(hue: number): number;
+/** Perceptual (oklch) hue → display (HSV) hue. */
+declare function fromPerceptual(hue: number): number;
+/**
+ * Worst round-trip error in degrees, sampled every `step` degrees.
+ *
+ * The two tables are built by different methods and only approximately invert
+ * each other, so this is the number that says whether they still agree. It is
+ * exported rather than run on import: a library that asserts at load time
+ * costs every consumer the check whether or not they care, and cannot fail the
+ * build when it matters. See `npm test`.
+ */
+declare function worstRoundTripError(step?: number): number;
+
+export { fromPerceptual, toPerceptual, worstRoundTripError };

package/dist/index.js

@@ -0,0 +1,143 @@
+// src/huePerception.ts
+function linearize(channel) {
+  return channel <= 0.04045 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+}
+function hsvToLinearRgb(hue) {
+  const x = 1 - Math.abs(hue / 60 % 2 - 1);
+  let r, g, b;
+  if (hue < 60) {
+    r = 1;
+    g = x;
+    b = 0;
+  } else if (hue < 120) {
+    r = x;
+    g = 1;
+    b = 0;
+  } else if (hue < 180) {
+    r = 0;
+    g = 1;
+    b = x;
+  } else if (hue < 240) {
+    r = 0;
+    g = x;
+    b = 1;
+  } else if (hue < 300) {
+    r = x;
+    g = 0;
+    b = 1;
+  } else {
+    r = 1;
+    g = 0;
+    b = x;
+  }
+  return [linearize(r), linearize(g), linearize(b)];
+}
+function linearRgbToOklchHue(r, g, b) {
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  const lRoot = Math.cbrt(l);
+  const mRoot = Math.cbrt(m);
+  const sRoot = Math.cbrt(s);
+  const a = 1.9779984951 * lRoot - 2.428592205 * mRoot + 0.4505937099 * sRoot;
+  const bAxis = 0.0259040371 * lRoot + 0.7827717662 * mRoot - 0.808675766 * sRoot;
+  let hue = Math.atan2(bAxis, a) * (180 / Math.PI);
+  if (hue < 0) hue += 360;
+  return hue;
+}
+var forward = new Float64Array(360);
+for (let hue = 0; hue < 360; hue++) {
+  const [r, g, b] = hsvToLinearRgb(hue);
+  forward[hue] = linearRgbToOklchHue(r, g, b);
+}
+for (let i = 0; i < 360; i++) {
+  let delta = forward[(i + 1) % 360] - forward[i];
+  if (delta < 0) delta += 360;
+  if (delta > 180) {
+    const start = forward[i];
+    let j = i + 1;
+    while (j < i + 360) {
+      let ahead = forward[j % 360] - start;
+      if (ahead < 0) ahead += 360;
+      if (ahead > 0 && ahead <= 180) break;
+      j++;
+    }
+    let span = forward[j % 360] - start;
+    if (span < 0) span += 360;
+    const steps = j - i;
+    for (let k = 1; k < steps; k++) {
+      forward[(i + k) % 360] = (start + span * k / steps) % 360;
+    }
+    i = j - 1;
+  }
+}
+var INVERSE_RESOLUTION = 7200;
+var inverse = new Float64Array(INVERSE_RESOLUTION);
+for (let index = 0; index < INVERSE_RESOLUTION; index++) {
+  const degrees = index * (360 / INVERSE_RESOLUTION);
+  let found = false;
+  for (let hue = 0; hue < 360; hue++) {
+    const start = forward[hue];
+    const end = forward[(hue + 1) % 360];
+    let delta = end - start;
+    if (delta < 0) delta += 360;
+    if (delta < 1e-9 || delta > 180) continue;
+    let offset = degrees - start;
+    if (offset < 0) offset += 360;
+    if (offset < delta) {
+      inverse[index] = hue + offset / delta;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    let best = 0;
+    let bestDistance = 360;
+    for (let hue = 0; hue < 360; hue++) {
+      let distance = Math.abs(forward[hue] - degrees);
+      if (distance > 180) distance = 360 - distance;
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = hue;
+      }
+    }
+    inverse[index] = best;
+  }
+}
+function lerpAngle(from, to, t) {
+  let delta = to - from;
+  if (delta > 180) delta -= 360;
+  if (delta < -180) delta += 360;
+  return ((from + t * delta) % 360 + 360) % 360;
+}
+function toPerceptual(hue) {
+  const wrapped = (hue % 360 + 360) % 360;
+  const index = Math.floor(wrapped) % 360;
+  return lerpAngle(forward[index], forward[(index + 1) % 360], wrapped - index);
+}
+function fromPerceptual(hue) {
+  const wrapped = (hue % 360 + 360) % 360;
+  const scaled = wrapped * (INVERSE_RESOLUTION / 360);
+  const index = Math.floor(scaled) % INVERSE_RESOLUTION;
+  return lerpAngle(
+    inverse[index],
+    inverse[(index + 1) % INVERSE_RESOLUTION],
+    scaled - index
+  );
+}
+function worstRoundTripError(step = 0.25) {
+  let worst = 0;
+  for (let hue = 0; hue < 360; hue += step) {
+    const returned = fromPerceptual(toPerceptual(hue));
+    let error = Math.abs(returned - hue);
+    if (error > 180) error = 360 - error;
+    if (error > worst) worst = error;
+  }
+  return worst;
+}
+export {
+  fromPerceptual,
+  toPerceptual,
+  worstRoundTripError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/huePerception.ts"],"sourcesContent":["/**\n * A bijective mapping between display hue and perceptual hue.\n *\n * HSV hue is what a camera reports and what people use to name a color on a\n * screen. Oklch hue — atan2(b, a) of oklab — is the angle human vision reads\n * as evenly spaced. Both run 0–360°, but the mapping between them is severely\n * non-linear, and not in the direction most descriptions of it suggest.\n * Measured as perceptual degrees per display degree:\n *\n *   red 0.21×   orange 1.76×   yellow 1.29×   green 0.05×\n *   cyan 2.23×  blue 0.14×     deep blue 0.01×  magenta 0.94×\n *\n * Green and deep blue barely move at all — a wide sweep of display hue is\n * almost one perceptual color — while cyan and orange stretch. The spread\n * between the extremes is over two hundredfold.\n *\n * That is the whole reason this file exists. Divide a hue wheel into equal\n * slices in HSV and the slices do not look equal; divide it in oklch and they\n * do.\n */\n\n/** sRGB gamma decode. */\nfunction linearize(channel: number): number {\n  return channel <= 0.04045\n    ? channel / 12.92\n    : Math.pow((channel + 0.055) / 1.055, 2.4);\n}\n\n/** HSV(hue, 1, 1) → linear sRGB. */\nfunction hsvToLinearRgb(hue: number): [number, number, number] {\n  const x = 1 - Math.abs(((hue / 60) % 2) - 1);\n  let r: number, g: number, b: number;\n  if (hue < 60) {\n    r = 1;\n    g = x;\n    b = 0;\n  } else if (hue < 120) {\n    r = x;\n    g = 1;\n    b = 0;\n  } else if (hue < 180) {\n    r = 0;\n    g = 1;\n    b = x;\n  } else if (hue < 240) {\n    r = 0;\n    g = x;\n    b = 1;\n  } else if (hue < 300) {\n    r = x;\n    g = 0;\n    b = 1;\n  } else {\n    r = 1;\n    g = 0;\n    b = x;\n  }\n  return [linearize(r), linearize(g), linearize(b)];\n}\n\n/**\n * Linear sRGB → oklch hue in degrees.\n * Matrix constants from Björn Ottosson's reference implementation (2020).\n */\nfunction linearRgbToOklchHue(r: number, g: number, b: number): number {\n  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;\n  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;\n  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;\n  const lRoot = Math.cbrt(l);\n  const mRoot = Math.cbrt(m);\n  const sRoot = Math.cbrt(s);\n  const a = 1.9779984951 * lRoot - 2.428592205 * mRoot + 0.4505937099 * sRoot;\n  const bAxis =\n    0.0259040371 * lRoot + 0.7827717662 * mRoot - 0.808675766 * sRoot;\n  let hue = Math.atan2(bAxis, a) * (180 / Math.PI);\n  if (hue < 0) hue += 360;\n  return hue;\n}\n\n/** Forward table: display hue → perceptual hue, one entry per degree. */\nconst forward = new Float64Array(360);\nfor (let hue = 0; hue < 360; hue++) {\n  const [r, g, b] = hsvToLinearRgb(hue);\n  forward[hue] = linearRgbToOklchHue(r, g, b);\n}\n\n// Raw oklch hue is not quite monotonic in display hue: around display 231–240°\n// it steps backwards by a fraction of a degree. Left alone that makes the\n// mapping non-invertible right there, so every backward run is replaced with a\n// straight interpolation across it.\nfor (let i = 0; i < 360; i++) {\n  let delta = forward[(i + 1) % 360] - forward[i];\n  if (delta < 0) delta += 360;\n  if (delta > 180) {\n    const start = forward[i];\n    let j = i + 1;\n    while (j < i + 360) {\n      let ahead = forward[j % 360] - start;\n      if (ahead < 0) ahead += 360;\n      if (ahead > 0 && ahead <= 180) break;\n      j++;\n    }\n    let span = forward[j % 360] - start;\n    if (span < 0) span += 360;\n    const steps = j - i;\n    for (let k = 1; k < steps; k++) {\n      forward[(i + k) % 360] = (start + (span * k) / steps) % 360;\n    }\n    i = j - 1;\n  }\n}\n\n/**\n * Inverse table: perceptual hue → display hue.\n *\n * 7200 entries rather than 360 because the deep-blue zone squeezes roughly 16\n * display degrees into half a perceptual degree. At one entry per degree that\n * whole region would collapse to a single bin; at 0.05° per bin the worst\n * round-trip error is about 0.8°.\n */\nconst INVERSE_RESOLUTION = 7200;\nconst inverse = new Float64Array(INVERSE_RESOLUTION);\nfor (let index = 0; index < INVERSE_RESOLUTION; index++) {\n  const degrees = index * (360 / INVERSE_RESOLUTION);\n  let found = false;\n  for (let hue = 0; hue < 360; hue++) {\n    const start = forward[hue];\n    const end = forward[(hue + 1) % 360];\n    let delta = end - start;\n    if (delta < 0) delta += 360;\n    if (delta < 1e-9 || delta > 180) continue;\n    let offset = degrees - start;\n    if (offset < 0) offset += 360;\n    if (offset < delta) {\n      inverse[index] = hue + offset / delta;\n      found = true;\n      break;\n    }\n  }\n  if (!found) {\n    let best = 0;\n    let bestDistance = 360;\n    for (let hue = 0; hue < 360; hue++) {\n      let distance = Math.abs(forward[hue] - degrees);\n      if (distance > 180) distance = 360 - distance;\n      if (distance < bestDistance) {\n        bestDistance = distance;\n        best = hue;\n      }\n    }\n    inverse[index] = best;\n  }\n}\n\n/** Interpolate between two angles along the shorter arc. */\nfunction lerpAngle(from: number, to: number, t: number): number {\n  let delta = to - from;\n  if (delta > 180) delta -= 360;\n  if (delta < -180) delta += 360;\n  return (((from + t * delta) % 360) + 360) % 360;\n}\n\n/** Display (HSV) hue → perceptual (oklch) hue. */\nexport function toPerceptual(hue: number): number {\n  const wrapped = ((hue % 360) + 360) % 360;\n  const index = Math.floor(wrapped) % 360;\n  return lerpAngle(forward[index], forward[(index + 1) % 360], wrapped - index);\n}\n\n/** Perceptual (oklch) hue → display (HSV) hue. */\nexport function fromPerceptual(hue: number): number {\n  const wrapped = ((hue % 360) + 360) % 360;\n  const scaled = wrapped * (INVERSE_RESOLUTION / 360);\n  const index = Math.floor(scaled) % INVERSE_RESOLUTION;\n  return lerpAngle(\n    inverse[index],\n    inverse[(index + 1) % INVERSE_RESOLUTION],\n    scaled - index\n  );\n}\n\n/**\n * Worst round-trip error in degrees, sampled every `step` degrees.\n *\n * The two tables are built by different methods and only approximately invert\n * each other, so this is the number that says whether they still agree. It is\n * exported rather than run on import: a library that asserts at load time\n * costs every consumer the check whether or not they care, and cannot fail the\n * build when it matters. See `npm test`.\n */\nexport function worstRoundTripError(step = 0.25): number {\n  let worst = 0;\n  for (let hue = 0; hue < 360; hue += step) {\n    const returned = fromPerceptual(toPerceptual(hue));\n    let error = Math.abs(returned - hue);\n    if (error > 180) error = 360 - error;\n    if (error > worst) worst = error;\n  }\n  return worst;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@amplib/color",
+  "description": "Color analysis utilities",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://amplib.app/color",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/another-machine/public-library.git",
+    "directory": "packages/amplib-color"
+  },
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "clean": true,
+    "dts": true,
+    "format": "esm",
+    "minify": false,
+    "sourcemap": true,
+    "splitting": false
+  },
+  "scripts": {
+    "build": "tsup",
+    "watch": "tsup --watch",
+    "test": "tsx test/run.ts",
+    "prepack": "npm run build"
+  },
+  "author": "Another Machine",
+  "license": "Apache-2.0",
+  "type": "module",
+  "devDependencies": {
+    "tsx": "^4.19.2"
+  }
+}