@nolwenture/formik-jsonschema-form 2.0.2 → 3.0.0-beta.1

package/dist/esm/v3/raw/sanitize/sanitizeHtml.js

@@ -0,0 +1,119 @@
+import createDOMPurify from "dompurify";
+/** Code of the error thrown when there is no DOM to sanitise with. */
+export const SANITIZER_UNAVAILABLE = "SANITIZER_UNAVAILABLE";
+export class SanitizerUnavailableError extends Error {
+    code = SANITIZER_UNAVAILABLE;
+    constructor() {
+        super(`${SANITIZER_UNAVAILABLE}: sanitizeHtml needs a DOM window. In Node, pass ` +
+            "one (e.g. from jsdom) as `options.window` or register it with " +
+            "`setSanitizerWindow`. Unsanitised HTML is never returned.");
+        this.name = "SanitizerUnavailableError";
+    }
+}
+// D5 (approved): formatting, links and images only. Everything that can
+// submit data, load code or styles, or restyle the page is forbidden, and
+// only absolute http(s) URLs survive.
+const STRICT = {
+    FORBID_TAGS: [
+        "form",
+        "input",
+        "button",
+        "select",
+        "textarea",
+        "label",
+        "style",
+        "svg",
+        "math",
+        "iframe",
+        "object",
+        "embed",
+        "link",
+        "meta",
+        "base",
+        // D5 (formatting, links, images): remote media is not formatting.
+        "video",
+        "audio",
+        "source",
+        "track",
+        // DOMPurify keeps a <template> nested in a forbidden parent (select, form,
+        // label...): inert and sanitised, but not idempotent.
+        "template",
+    ],
+    FORBID_ATTR: [
+        "style",
+        "id",
+        "name",
+        "action",
+        "formaction",
+        "srcset",
+        "xlink:href",
+    ],
+    ALLOWED_URI_REGEXP: /^https?:/i,
+    SANITIZE_NAMED_PROPS: true,
+    // Data must not forge the data-fjsf-* / data-keyword markers that pro3's
+    // persisted CSS and tests key off.
+    ALLOW_DATA_ATTR: false,
+    // The URI regex is applied to every attribute DOMPurify does not treat as
+    // URI-safe, which would strip these harmless table/text attributes (base
+    // decision). width/height/start/border stay stripped.
+    ADD_URI_SAFE_ATTR: ["colspan", "rowspan", "lang", "dir"],
+};
+export const STRICT_CONFIG = Object.freeze({
+    ...STRICT,
+    FORBID_TAGS: Object.freeze([...STRICT.FORBID_TAGS]),
+    FORBID_ATTR: Object.freeze([...STRICT.FORBID_ATTR]),
+    ADD_URI_SAFE_ATTR: Object.freeze([...STRICT.ADD_URI_SAFE_ATTR]),
+});
+const instances = new WeakMap();
+let registeredWindow;
+/**
+ * Registers the DOM window `sanitizeHtml` uses where there is no global one (Node).
+ *
+ * Remote `http(s)` images are kept by policy. In a browser that is a tracking
+ * pixel; if you sanitise on the server and render the result in a headless
+ * browser (e.g. PDF generation), it is also an egress/SSRF vector: apply an
+ * egress policy or request interception there (plan §8.4).
+ */
+export const setSanitizerWindow = (window) => {
+    registeredWindow = window;
+};
+const URL_ATTRIBUTES = ["href", "src", "xlink:href", "action", "formaction"];
+const createInstance = (window) => {
+    const purify = createDOMPurify(window);
+    if (!purify.isSupported)
+        throw new SanitizerUnavailableError();
+    purify.addHook("afterSanitizeAttributes", (node) => {
+        // ALLOWED_URI_REGEXP is bypassed by DOMPurify for data: images; the
+        // approved policy is http(s) only.
+        URL_ATTRIBUTES.forEach((attr) => {
+            if (/^\s*data:/i.test(node.getAttribute?.(attr) ?? "")) {
+                node.removeAttribute(attr);
+            }
+        });
+        if (node.nodeName === "A" && node.hasAttribute("href")) {
+            node.setAttribute("rel", "noopener noreferrer");
+        }
+    });
+    return purify;
+};
+const resolveWindow = (options) => options?.window ??
+    registeredWindow ??
+    // the browser's window, read through globalThis (the RAW layer reads no DOM global directly, §1.6)
+    globalThis.window;
+/**
+ * Sanitises untrusted HTML with the strict config. Isomorphic: uses the
+ * browser's window, or one supplied for Node. With no usable window it
+ * throws SanitizerUnavailableError (code SANITIZER_UNAVAILABLE): fail closed,
+ * never pass the input through.
+ */
+export const sanitizeHtml = (html, options) => {
+    const win = resolveWindow(options);
+    if (!win)
+        throw new SanitizerUnavailableError();
+    let purify = instances.get(win);
+    if (!purify) {
+        purify = createInstance(win);
+        instances.set(win, purify);
+    }
+    return purify.sanitize(String(html), STRICT_CONFIG);
+};

package/dist/esm/v3/raw/serialize/toDOM.js

@@ -0,0 +1,145 @@
+const SAFE_NAME = /^[a-zA-Z_:][-a-zA-Z0-9_:.]*$/;
+const SAFE_TAG = /^[a-z][a-z0-9-]*$/;
+const HANDLER = /^on/i;
+const BOOLEAN = new Set(["selected", "checked", "disabled", "readonly", "multiple", "hidden", "required"]);
+const SVG_NS = "http://www.w3.org/2000/svg";
+/** Fragments, holes and host replacements flattened into the list of children to draw. */
+const flatten = (children, env, out = []) => {
+    for (const child of children) {
+        if (child === null || child === undefined || child === false)
+            continue;
+        if (typeof child === "string" || typeof child === "number")
+            out.push(String(child));
+        else {
+            const replaced = child.host ? env.host?.(child) : undefined;
+            if (replaced)
+                flatten(replaced, env, out);
+            else if (child.tag === "#fragment")
+                flatten(child.children, env, out);
+            else if (child.tag === "#hole")
+                continue;
+            else if (SAFE_TAG.test(child.tag))
+                out.push(child);
+        }
+    }
+    return out;
+};
+const attributesOf = (node) => {
+    const out = new Map();
+    for (const [name, value] of Object.entries(node.attrs)) {
+        if (!SAFE_NAME.test(name) || HANDLER.test(name) || value === undefined || value === null || value === false)
+            continue;
+        // a textarea's / select's value is state, not an attribute (as React draws them)
+        if (Array.isArray(value) || (name === "value" && (node.tag === "textarea" || node.tag === "select")))
+            continue;
+        out.set(name, value === true ? (BOOLEAN.has(name) ? "" : "true") : String(value));
+    }
+    return out;
+};
+const isControl = (el) => el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT";
+/** Live state of form controls: set as properties, and only when it differs (no caret jumps). */
+const syncControl = (el, node) => {
+    const { value, checked } = node.attrs;
+    if (el.tagName === "INPUT" && (el.type === "checkbox" || el.type === "radio")) {
+        const want = checked === true;
+        if (el.checked !== want)
+            el.checked = want;
+    }
+    else if (el.tagName === "SELECT" && el.multiple) {
+        const want = new Set(Array.isArray(value) ? value.map(String) : []);
+        for (const option of el.options)
+            if (option.selected !== want.has(option.value))
+                option.selected = want.has(option.value);
+    }
+    else if (el.tagName === "SELECT" && value === undefined) {
+        // the option marked `selected` is the selection (React: the select's value), whatever the insertion order did
+        const marked = [...el.options].find((o) => o.hasAttribute("selected"));
+        if (marked)
+            for (const o of el.options)
+                if (o.selected !== (o === marked))
+                    o.selected = o === marked;
+    }
+    else if (el.tagName === "TEXTAREA") {
+        // React keeps a textarea's text (defaultValue) equal to its value
+        const want = value === undefined || value === null ? "" : String(value);
+        if (el.defaultValue !== want)
+            el.defaultValue = want;
+        if (el.value !== want)
+            el.value = want;
+    }
+    else if (el.type !== "file" && value !== undefined) {
+        const want = value === null ? "" : String(value);
+        if (el.value !== want)
+            el.value = want;
+    }
+};
+const create = (node, env, svg) => svg || node.tag === "svg" ? env.doc.createElementNS(SVG_NS, node.tag) : env.doc.createElement(node.tag);
+/** The style text each element was last given (the attribute holds the browser's serialisation). */
+const styles = new WeakMap();
+/** A style goes through the CSSOM, so the attribute reads as React writes it ("display: none;"). */
+const setStyle = (el, value) => {
+    if (styles.get(el) === value)
+        return;
+    styles.set(el, value);
+    const style = el.style;
+    if (style)
+        style.cssText = value;
+    else
+        el.setAttribute("style", value);
+};
+const patchElement = (el, node, env) => {
+    const want = attributesOf(node);
+    for (const attr of [...el.attributes])
+        if (!want.has(attr.name))
+            el.removeAttribute(attr.name);
+    if (!want.has("style"))
+        styles.delete(el);
+    for (const [name, value] of want) {
+        if (name === "style")
+            setStyle(el, value);
+        else if (el.getAttribute(name) !== value)
+            el.setAttribute(name, value);
+    }
+    if (node.on)
+        env.on.set(el, node.on);
+    else
+        env.on.delete(el);
+    const svg = el.namespaceURI === SVG_NS;
+    // A slot (§2.6) is filled by the host: its content is not ours to patch.
+    if (el.tagName !== "INPUT" && el.tagName !== "TEXTAREA" && node.attrs["data-fjsf-slot"] === undefined)
+        patchChildren(el, node.children, env, svg);
+    if (isControl(el))
+        syncControl(el, node);
+    env.drawn?.(el, node);
+};
+/** Makes `parent`'s children match `children` (in place where tags match). */
+export const patchChildren = (parent, children, env, svg = false) => {
+    const flat = flatten(children, env);
+    flat.forEach((child, i) => {
+        const existing = parent.childNodes[i];
+        if (typeof child === "string") {
+            if (existing && existing.nodeType === 3) {
+                if (existing.data !== child)
+                    existing.data = child;
+            }
+            else
+                insert(parent, env.doc.createTextNode(child), existing);
+            return;
+        }
+        const same = existing && existing.nodeType === 1 && existing.localName === child.tag;
+        const el = same ? existing : create(child, env, svg);
+        if (!same)
+            insert(parent, el, existing);
+        patchElement(el, child, env);
+    });
+    while (parent.childNodes.length > flat.length)
+        parent.removeChild(parent.lastChild);
+};
+const insert = (parent, node, existing) => {
+    if (existing)
+        parent.replaceChild(node, existing);
+    else
+        parent.appendChild(node);
+};
+/** Draws `node` as the only content of `target`. */
+export const toDOM = (target, node, env) => patchChildren(target, [node], env);

package/dist/esm/v3/raw/serialize/toString.js

@@ -0,0 +1,52 @@
+const VOID = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+const BOOLEAN = new Set(["selected", "checked", "disabled", "readonly", "multiple", "hidden", "required"]);
+const SAFE_NAME = /^[a-zA-Z_:][-a-zA-Z0-9_:.]*$/;
+const SAFE_TAG = /^[a-z][a-z0-9-]*$/;
+// Event handlers are never library output; dropped as defence in depth (TASK-063 review N3).
+const HANDLER = /^on/i;
+export const escapeText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+export const escapeAttr = (text) => escapeText(text).replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+const attrsOf = (node) => Object.entries(node.attrs)
+    .map(([name, value]) => {
+    if (!SAFE_NAME.test(name) || HANDLER.test(name) || value === undefined || value === null || value === false)
+        return "";
+    // a select's / textarea's value is state: React SSR marks the option or writes the text (below)
+    if (name === "value" && (node.tag === "select" || node.tag === "textarea"))
+        return "";
+    if (value === true)
+        return BOOLEAN.has(name) ? ` ${name}` : ` ${name}="true"`;
+    return ` ${name}="${escapeAttr(String(value))}"`;
+})
+    .join("");
+/** The values a select's `value` selects (React SSR: `selected` on those options), or undefined when it has none. */
+const selection = (node) => {
+    const value = node.attrs.value;
+    if (value === undefined || value === null)
+        return undefined;
+    return new Set((Array.isArray(value) ? value : [value]).map(String));
+};
+const childToString = (child, selected) => {
+    if (child === null || child === undefined || child === false)
+        return "";
+    if (typeof child === "string")
+        return escapeText(child);
+    if (typeof child === "number")
+        return String(child);
+    if (selected && child.tag === "option")
+        return toString({ ...child, attrs: { ...child.attrs, selected: selected.has(String(child.attrs.value ?? "")) } });
+    return toString(child, selected);
+};
+export const toString = (node, selected) => {
+    // A fragment (composite registry component) serialises its children only.
+    if (node.tag === "#fragment")
+        return node.children.map((c) => childToString(c, selected)).join("");
+    if (!SAFE_TAG.test(node.tag))
+        return "";
+    const open = `<${node.tag}${attrsOf(node)}>`;
+    if (VOID.has(node.tag))
+        return open;
+    if (node.tag === "textarea")
+        return `${open}${escapeText(node.attrs.value === undefined || node.attrs.value === null ? "" : String(node.attrs.value))}</textarea>`;
+    const inner = node.tag === "select" ? selection(node) : node.tag === "optgroup" ? selected : undefined;
+    return `${open}${node.children.map((c) => childToString(c, inner)).join("")}</${node.tag}>`;
+};

package/dist/esm/v3/raw/store/createStore.js

@@ -0,0 +1,126 @@
+// The RAW state store (S6, §2.7 S-A): the second StateAdapter next to the React layer's Formik adapter.
+// It follows Formik 2's semantics where the corpus and the scripts compare state: setFieldValue /
+// setFieldTouched validate the whole form (validateOnChange / validateOnBlur), "" is undefined for
+// validation, the first message per path wins, submit touches every value and keeps isSubmitting true
+// after a synchronous onSubmit (the consumer resets it, as with Formik).
+import { isPlainObject } from "../core/json";
+import { setIn } from "../core/paths";
+/** formik prepareDataForValidation: "" is undefined, nested objects and arrays included. */
+export const prepareForValidation = (values) => {
+    const out = Array.isArray(values) ? [] : {};
+    for (const key of Object.keys(values ?? {})) {
+        const v = values[key];
+        if (Array.isArray(v))
+            out[key] = v.map((x) => (Array.isArray(x) || isPlainObject(x) ? prepareForValidation(x) : x !== "" ? x : undefined));
+        else if (isPlainObject(v))
+            out[key] = prepareForValidation(v);
+        else
+            out[key] = v !== "" ? v : undefined;
+    }
+    return out;
+};
+/** formik yupToFormErrors: the first message per path. */
+export const toFormErrors = (error) => {
+    let errors = {};
+    const inner = error?.inner ?? [];
+    if (!inner.length)
+        return error?.path !== undefined ? setIn(errors, error.path, error.message) : errors;
+    for (const e of inner) {
+        if (e.path === undefined)
+            continue;
+        const segments = String(e.path).split(/[.[\]]+/).filter(Boolean);
+        let existing = errors;
+        for (const s of segments)
+            existing = existing?.[s];
+        if (!existing)
+            errors = setIn(errors, e.path, e.message);
+    }
+    return errors;
+};
+/** formik setNestedObjectValues(values, true): the touched map after a submit attempt. */
+export const touchAll = (values, seen = new WeakSet()) => {
+    const out = Array.isArray(values) ? [] : {};
+    for (const key of Object.keys(values ?? {})) {
+        const v = values[key];
+        if (v !== null && typeof v === "object") {
+            if (!seen.has(v)) {
+                seen.add(v);
+                out[key] = touchAll(v, seen);
+            }
+        }
+        else
+            out[key] = true;
+    }
+    return out;
+};
+const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const createStore = (options = {}) => {
+    let state = { values: options.initialValues ?? {}, errors: {}, touched: {}, isSubmitting: false, submitCount: 0 };
+    const listeners = new Set();
+    const set = (patch) => {
+        state = { ...state, ...patch };
+        listeners.forEach((l) => l(state));
+    };
+    const onChange = options.validateOnChange ?? true;
+    const onBlur = options.validateOnBlur ?? true;
+    const validateForm = async (values = state.values) => {
+        if (!options.validationSchema)
+            return {};
+        try {
+            await options.validationSchema.validate(prepareForValidation(values), { abortEarly: false });
+            return {};
+        }
+        catch (error) {
+            return toFormErrors(error);
+        }
+    };
+    const validate = async (values) => {
+        const errors = await validateForm(values);
+        if (!equal(errors, state.errors))
+            set({ errors });
+        if (options.validationSchema)
+            options.onValidated?.(errors);
+        return errors;
+    };
+    const store = {
+        getState: () => state,
+        setState: (patch) => set(patch),
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => void listeners.delete(listener);
+        },
+        async setValues(values, shouldValidate = onChange) {
+            set({ values });
+            if (shouldValidate)
+                await validate(values);
+        },
+        async setFieldValue(path, value, shouldValidate = onChange) {
+            const values = path ? setIn(state.values, path, value) : value;
+            set({ values });
+            if (shouldValidate)
+                await validate(values);
+        },
+        async setFieldTouched(path, touched = true, shouldValidate = onBlur) {
+            set({ touched: setIn(state.touched, path, touched) });
+            if (shouldValidate)
+                await validate(state.values);
+        },
+        setFieldError(path, message) {
+            set({ errors: setIn(state.errors, path, message) });
+        },
+        setSubmitting: (isSubmitting) => set({ isSubmitting }),
+        validateForm: (values) => validateForm(values),
+        async submitForm() {
+            set({ touched: touchAll(state.values), isSubmitting: true, submitCount: state.submitCount + 1 });
+            const errors = await validate(state.values);
+            if (Object.keys(errors).length)
+                return set({ isSubmitting: false });
+            const result = options.onSubmit?.(state.values, store);
+            // formik: a synchronous onSubmit leaves isSubmitting true; a promise resets it when it settles.
+            if (result && typeof result.then === "function") {
+                await Promise.resolve(result).finally(() => set({ isSubmitting: false }));
+            }
+        },
+    };
+    return store;
+};

package/dist/esm/v3/raw/styles/color.js

@@ -0,0 +1,104 @@
+// polished 4.3 readableColor / lighten / darken as a RAW port (§4.3 (3): themeToCssVars computes the
+// derived colours of the 2.x styles from the theme). Same parsing, rounding and output format as polished on
+// the colours it accepts (unit-tested against polished); a value it cannot parse (a token theme's
+// `var(--x)`) returns undefined instead of throwing, and the caller decides the fallback.
+import { NAMED_COLORS } from "./colorNames";
+const HEX = /^#[a-fA-F0-9]{6}$/;
+const HEX_ALPHA = /^#[a-fA-F0-9]{8}$/;
+const SHORT_HEX = /^#[a-fA-F0-9]{3}$/;
+const SHORT_HEX_ALPHA = /^#[a-fA-F0-9]{4}$/;
+const RGB = /^rgb\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*\)$/i;
+const RGBA = /^rgb(?:a)?\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+const HSL = /^hsl\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*\)$/i;
+const HSLA = /^hsl(?:a)?\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+const int = (s, radix = 10) => parseInt(s, radix);
+const alphaOf = (s) => (parseFloat(s) > 1 ? parseFloat(s) / 100 : parseFloat(s));
+const hslToChannels = (hue, saturation, lightness) => {
+    if (saturation === 0)
+        return [lightness, lightness, lightness];
+    const huePrime = (((hue % 360) + 360) % 360) / 60;
+    const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+    const second = chroma * (1 - Math.abs((huePrime % 2) - 1));
+    const sextant = [[chroma, second, 0], [second, chroma, 0], [0, chroma, second], [0, second, chroma], [second, 0, chroma], [chroma, 0, second]];
+    const [r, g, b] = sextant[Math.floor(huePrime)] ?? [0, 0, 0];
+    const m = lightness - chroma / 2;
+    return [r + m, g + m, b + m];
+};
+const toInts = (channels) => channels.map((c) => Math.round(c * 255));
+/** polished parseToRgb; undefined where polished throws. */
+export const parseToRgb = (color) => {
+    if (typeof color !== "string")
+        return undefined;
+    const c = NAMED_COLORS[color.toLowerCase()] ? `#${NAMED_COLORS[color.toLowerCase()]}` : color;
+    const pair = (i, j = i + 1) => int(`${c[i]}${c[j]}`, 16);
+    if (HEX.test(c))
+        return { red: pair(1), green: pair(3), blue: pair(5) };
+    if (HEX_ALPHA.test(c))
+        return { red: pair(1), green: pair(3), blue: pair(5), alpha: parseFloat((pair(7) / 255).toFixed(2)) };
+    if (SHORT_HEX.test(c))
+        return { red: pair(1, 1), green: pair(2, 2), blue: pair(3, 3) };
+    if (SHORT_HEX_ALPHA.test(c))
+        return { red: pair(1, 1), green: pair(2, 2), blue: pair(3, 3), alpha: parseFloat((pair(4, 4) / 255).toFixed(2)) };
+    let m = RGB.exec(c);
+    if (m)
+        return { red: int(m[1]), green: int(m[2]), blue: int(m[3]) };
+    m = RGBA.exec(c.substring(0, 50));
+    if (m)
+        return { red: int(m[1]), green: int(m[2]), blue: int(m[3]), alpha: alphaOf(m[4]) };
+    m = HSL.exec(c) ?? HSLA.exec(c.substring(0, 50));
+    if (!m)
+        return undefined;
+    const [red, green, blue] = toInts(hslToChannels(int(m[1]), int(m[2]) / 100, int(m[3]) / 100));
+    return m[4] === undefined ? { red, green, blue } : { red, green, blue, alpha: alphaOf(m[4]) };
+};
+const rgbToHsl = (c) => {
+    const [r, g, b] = [c.red / 255, c.green / 255, c.blue / 255];
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const lightness = (max + min) / 2;
+    const alpha = c.alpha !== undefined ? { alpha: c.alpha } : {};
+    if (max === min)
+        return { hue: 0, saturation: 0, lightness, ...alpha };
+    const delta = max - min;
+    const saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+    const hue = (max === r ? (g - b) / delta + (g < b ? 6 : 0) : max === g ? (b - r) / delta + 2 : (r - g) / delta + 4) * 60;
+    return { hue, saturation, lightness, ...alpha };
+};
+const reduceHex = (hex) => (hex.length === 7 && hex[1] === hex[2] && hex[3] === hex[4] && hex[5] === hex[6] ? `#${hex[1]}${hex[3]}${hex[5]}` : hex);
+const toHex = (n) => n.toString(16).padStart(2, "0");
+/** polished toColorString of an HSL colour: reduced hex, or rgba() with an alpha below 1. */
+const hslToString = ({ hue, saturation, lightness, alpha }) => {
+    const ints = toInts(hslToChannels(hue, saturation, lightness));
+    if (alpha !== undefined && alpha < 1)
+        return `rgba(${ints.join(",")},${alpha})`;
+    return reduceHex(`#${ints.map(toHex).join("")}`.toLowerCase());
+};
+const shift = (amount, color) => {
+    if (color === "transparent")
+        return color;
+    const rgb = parseToRgb(color);
+    if (!rgb)
+        return undefined;
+    const hsl = rgbToHsl(rgb);
+    return hslToString({ ...hsl, lightness: Math.max(0, Math.min(1, hsl.lightness + amount)) });
+};
+export const lighten = (amount, color) => shift(amount, color);
+export const darken = (amount, color) => shift(-amount, color);
+/** polished getLuminance (relative luminance, 3 decimals). */
+export const getLuminance = (color) => {
+    if (color === "transparent")
+        return 0;
+    const rgb = parseToRgb(color);
+    if (!rgb)
+        return undefined;
+    const [r, g, b] = [rgb.red, rgb.green, rgb.blue].map((v) => {
+        const c = v / 255;
+        return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+    });
+    return parseFloat((0.2126 * r + 0.7152 * g + 0.0722 * b).toFixed(3));
+};
+/** polished readableColor(color) with its defaults: "#000" on light colours, "#fff" on dark ones. */
+export const readableColor = (color) => {
+    const luminance = getLuminance(color);
+    return luminance === undefined ? undefined : luminance > 0.179 ? "#000" : "#fff";
+};

package/dist/esm/v3/raw/styles/colorNames.js

@@ -0,0 +1,27 @@
+// The CSS named colours polished 4.3 accepts (name:hex), for the colour port (color.ts).
+const TABLE = "aliceblue:f0f8ff,antiquewhite:faebd7,aqua:00ffff,aquamarine:7fffd4,azure:f0ffff,beige:f5f5dc,bisque:ffe4c4," +
+    "black:000,blanchedalmond:ffebcd,blue:0000ff,blueviolet:8a2be2,brown:a52a2a,burlywood:deb887,cadetblue:5f9ea0," +
+    "chartreuse:7fff00,chocolate:d2691e,coral:ff7f50,cornflowerblue:6495ed,cornsilk:fff8dc,crimson:dc143c," +
+    "cyan:00ffff,darkblue:00008b,darkcyan:008b8b,darkgoldenrod:b8860b,darkgray:a9a9a9,darkgreen:006400," +
+    "darkgrey:a9a9a9,darkkhaki:bdb76b,darkmagenta:8b008b,darkolivegreen:556b2f,darkorange:ff8c00,darkorchid:9932cc," +
+    "darkred:8b0000,darksalmon:e9967a,darkseagreen:8fbc8f,darkslateblue:483d8b,darkslategray:2f4f4f," +
+    "darkslategrey:2f4f4f,darkturquoise:00ced1,darkviolet:9400d3,deeppink:ff1493,deepskyblue:00bfff,dimgray:696969," +
+    "dimgrey:696969,dodgerblue:1e90ff,firebrick:b22222,floralwhite:fffaf0,forestgreen:228b22,fuchsia:ff00ff," +
+    "gainsboro:dcdcdc,ghostwhite:f8f8ff,gold:ffd700,goldenrod:daa520,gray:808080,green:008000,greenyellow:adff2f," +
+    "grey:808080,honeydew:f0fff0,hotpink:ff69b4,indianred:cd5c5c,indigo:4b0082,ivory:fffff0,khaki:f0e68c," +
+    "lavender:e6e6fa,lavenderblush:fff0f5,lawngreen:7cfc00,lemonchiffon:fffacd,lightblue:add8e6,lightcoral:f08080," +
+    "lightcyan:e0ffff,lightgoldenrodyellow:fafad2,lightgray:d3d3d3,lightgreen:90ee90,lightgrey:d3d3d3," +
+    "lightpink:ffb6c1,lightsalmon:ffa07a,lightseagreen:20b2aa,lightskyblue:87cefa,lightslategray:789," +
+    "lightslategrey:789,lightsteelblue:b0c4de,lightyellow:ffffe0,lime:0f0,limegreen:32cd32,linen:faf0e6," +
+    "magenta:f0f,maroon:800000,mediumaquamarine:66cdaa,mediumblue:0000cd,mediumorchid:ba55d3,mediumpurple:9370db," +
+    "mediumseagreen:3cb371,mediumslateblue:7b68ee,mediumspringgreen:00fa9a,mediumturquoise:48d1cc," +
+    "mediumvioletred:c71585,midnightblue:191970,mintcream:f5fffa,mistyrose:ffe4e1,moccasin:ffe4b5," +
+    "navajowhite:ffdead,navy:000080,oldlace:fdf5e6,olive:808000,olivedrab:6b8e23,orange:ffa500,orangered:ff4500," +
+    "orchid:da70d6,palegoldenrod:eee8aa,palegreen:98fb98,paleturquoise:afeeee,palevioletred:db7093," +
+    "papayawhip:ffefd5,peachpuff:ffdab9,peru:cd853f,pink:ffc0cb,plum:dda0dd,powderblue:b0e0e6,purple:800080," +
+    "rebeccapurple:639,red:f00,rosybrown:bc8f8f,royalblue:4169e1,saddlebrown:8b4513,salmon:fa8072," +
+    "sandybrown:f4a460,seagreen:2e8b57,seashell:fff5ee,sienna:a0522d,silver:c0c0c0,skyblue:87ceeb,slateblue:6a5acd," +
+    "slategray:708090,slategrey:708090,snow:fffafa,springgreen:00ff7f,steelblue:4682b4,tan:d2b48c,teal:008080," +
+    "thistle:d8bfd8,tomato:ff6347,turquoise:40e0d0,violet:ee82ee,wheat:f5deb3,white:fff,whitesmoke:f5f5f5," +
+    "yellow:ff0,yellowgreen:9acd32,";
+export const NAMED_COLORS = Object.fromEntries(TABLE.split(",").filter(Boolean).map((pair) => pair.split(":")));