@tokens-studio/tokenscript-schemas 0.1.2 → 0.2.0

package/bundled/types/okhsv-color.json

@@ -1,57 +0,0 @@
-{
-  "name": "OKHSV",
-  "type": "color",
-  "description": "OKHSV color space by Björn Ottosson - a perceptually uniform HSV based on OKLab. H is hue (0-360), S is saturation (0-1), V is value (0-1). Reference: https://bottosson.github.io/posts/colorpicker/",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "h": {
-        "type": "number",
-        "description": "Hue angle (0-360 degrees), same as OKLCH hue"
-      },
-      "s": {
-        "type": "number",
-        "description": "Saturation (0-1), ratio of chroma to maximum at this value"
-      },
-      "v": {
-        "type": "number",
-        "description": "Value/brightness (0-1), with V=1 being the brightest for that saturation"
-      }
-    },
-    "required": [
-      "h",
-      "s",
-      "v"
-    ],
-    "order": [
-      "h",
-      "s",
-      "v"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "OKHSV Color Initializer",
-      "keyword": "okhsv",
-      "description": "Creates an OKHSV color from H, S, V values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKHSV Color Initializer\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n//\n// Creates an OKHSV color from hue, saturation, and value.\n// OKHSV is a perceptually uniform version of HSV built on OKLab.\n//\n// Parameters:\n// - h: Hue angle (0-360 degrees), same as OKLCH hue\n// - s: Saturation (0-1), ratio of chroma to maximum at this value\n// - v: Value/brightness (0-1), with V=1 being brightest for that saturation\n// - alpha: Optional alpha channel (0-1)\n//\n// Input: Object with h, s, v, and optional alpha properties\n// Output: Color.OKHSV\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable v: Number = input.v;\n\nvariable output: Color.OKHSV;\noutput.h = h;\noutput.s = s;\noutput.v = v;\n\n// Set alpha if provided\nif (input.alpha != null) [\n  output.alpha = input.alpha;\n];\n\noutput"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-      "target": "$self",
-      "description": "Converts OKLab to OKHSV using Ottosson's algorithm with Halley's method refinement for gamut boundary",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKLab to OKHSV Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsv.js\n// Reference: https://bottosson.github.io/posts/oklab/ (original OKLab paper)\n//\n// OKHSV maps colors to a perceptually uniform HSV cylinder.\n// The algorithm finds the exact gamut boundary using compute_max_saturation\n// and positions colors relative to the cusp (maximum chroma point).\n//\n// Key difference from OKHSL:\n// - V=1 means maximum brightness (white at S=0, cusp color at S=1)\n// - More intuitive for picking saturated colors\n//\n// Input: Color.OKLab with l (0-1), a, b coordinates\n// Output: Color.OKHSV with h (0-360), s (0-1), v (0-1)\n\nvariable lab_l: Number = input.l;\nvariable lab_a: Number = input.a;\nvariable lab_b: Number = input.b;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// Toe function constants (same as OKHSL)\nvariable toe_k1: Number = 0.206;\nvariable toe_k2: Number = 0.03;\nvariable toe_k3: Number = 1.17009708737864;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Convert to polar coordinates (L, C, H)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = sqrt(lab_a * lab_a + lab_b * lab_b);\nvariable h: Number = 0;\n\nif (c > 0.00001) [\n  // Note: ColorJS uses atan2(-b, -a) and adds 0.5, we use atan2(b, a)\n  h = atan2(lab_b, lab_a) * 180 / pi_val;\n  if (h < 0) [\n    h = h + 360;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Initialize defaults and apply toe function to L for V\n// toe(x) = 0.5 * (k3*x - k1 + sqrt((k3*x - k1)^2 + 4*k2*k3*x))\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s: Number = 0;\nvariable v: Number = lab_l;\n\n// Apply toe function to get initial V\nif (lab_l > 0.0001 && lab_l < 0.9999) [\n  variable term: Number = toe_k3 * lab_l - toe_k1;\n  v = 0.5 * (term + sqrt(term * term + 4 * toe_k2 * toe_k3 * lab_l));\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Compute normalized hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable a_: Number = 0;\nvariable b_: Number = 0;\nif (c > 0.00001) [\n  a_ = lab_a / c;\n  b_ = lab_b / c;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in multiple steps)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find maximum saturation and cusp\n// Only process if we have chroma (non-achromatic) and L is valid\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\n// Variables for LMS intermediate calculations\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (c > 0.00001 && lab_l > 0.00001 && lab_l < 0.99999) [\n  // Determine which RGB component clips first\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  // Polynomial approximation\n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Find cusp (L_cusp, C_cusp)\n  // ═══════════════════════════════════════════════════════════════════════\n  if (s_max > 0) [\n    variable l_cusp_temp: Number = 1 + s_max * kl;\n    variable m_cusp_temp: Number = 1 + s_max * km;\n    variable s_cusp_temp: Number = 1 + s_max * ks;\n    \n    l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n    m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n    s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n    \n    variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n    variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n    variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n    \n    variable max_rgb: Number = r_lin;\n    if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n    if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n    \n    if (max_rgb > 0) [\n      l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n      c_cusp = l_cusp * s_max;\n    ];\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Compute OKHSV S and V using ColorJS algorithm\n//\n// The algorithm uses the ST coordinate system where:\n// - S_t = C/L (slope from origin)\n// - T_t = C/(1-L) (slope from white)\n//\n// Key formulas from ColorJS:\n// - t = tMax / (c + l * tMax)\n// - lv = t * l, cv = t * c\n// - Apply RGB scaling and toe compensation\n// - v = l / lv, s = ((s0 + tMax) * cv) / (tMax * s0 + tMax * k * cv)\n// ═══════════════════════════════════════════════════════════════════════════\nif (c > 0.00001 && lab_l > 0.00001 && lab_l < 0.99999 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  // Compute ST values at cusp\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  variable t_t_cusp: Number = c_cusp / (1 - l_cusp + 0.0001);\n  \n  // Fixed s0 parameter\n  variable s_0: Number = 0.5;\n  variable k_param: Number = 1 - s_0 / s_t_cusp;\n  \n  // Compute t and derived values (following ColorJS exactly)\n  variable t: Number = t_t_cusp / (c + lab_l * t_t_cusp + 0.0001);\n  variable lv: Number = t * lab_l;\n  variable cv: Number = t * c;\n  \n  // Apply inverse toe to lv for compensation\n  variable lvt: Number = lv;\n  if (lv > 0.0001 && lv < 0.9999) [\n    lvt = (lv * lv + toe_k1 * lv) / (toe_k3 * (lv + toe_k2));\n  ];\n  \n  variable cvt: Number = cv;\n  if (lv > 0.0001) [\n    cvt = cv * lvt / lv;\n  ];\n  \n  // RGB scale computation\n  variable scale_l_: Number = 1 + s_max * kl;\n  variable scale_m_: Number = 1 + s_max * km;\n  variable scale_s_: Number = 1 + s_max * ks;\n  \n  variable lms_l: Number = lvt + a_ * cvt * kl;\n  variable lms_m: Number = lvt + a_ * cvt * km;\n  variable lms_s: Number = lvt + a_ * cvt * ks;\n  \n  // Convert to linear RGB using LMS\n  variable lms_l_cubed: Number = lms_l * lms_l * lms_l;\n  variable lms_m_cubed: Number = lms_m * lms_m * lms_m;\n  variable lms_s_cubed: Number = lms_s * lms_s * lms_s;\n  \n  variable rs: Number = 4.0767416621 * lms_l_cubed - 3.3077115913 * lms_m_cubed + 0.2309699292 * lms_s_cubed;\n  variable gs: Number = -1.2684380046 * lms_l_cubed + 2.6097574011 * lms_m_cubed - 0.3413193965 * lms_s_cubed;\n  variable bs: Number = -0.0041960863 * lms_l_cubed - 0.7034186147 * lms_m_cubed + 1.7076147010 * lms_s_cubed;\n  \n  variable max_s: Number = rs;\n  if (gs > max_s) [ max_s = gs; ];\n  if (bs > max_s) [ max_s = bs; ];\n  if (max_s < 0.0001) [ max_s = 0.0001; ];\n  \n  variable scale_l: Number = pow(1 / max_s, 0.3333333333333333);\n  \n  // Scale L and C\n  variable l_scaled: Number = lab_l / scale_l;\n  variable c_scaled: Number = c / scale_l;\n  \n  // Apply toe to scaled L for compensation\n  variable l_toed: Number = l_scaled;\n  if (l_scaled > 0.0001 && l_scaled < 0.9999) [\n    variable term2: Number = toe_k3 * l_scaled - toe_k1;\n    l_toed = 0.5 * (term2 + sqrt(term2 * term2 + 4 * toe_k2 * toe_k3 * l_scaled));\n  ];\n  \n  c_scaled = c_scaled * l_toed / (l_scaled + 0.0001);\n  \n  // Compute final v and s\n  if (lv > 0.0001) [\n    v = l_toed / lv;\n    if (v > 1) [ v = 1; ];\n    if (v < 0) [ v = 0; ];\n  ];\n  \n  variable denom_s: Number = t_t_cusp * s_0 + t_t_cusp * k_param * cv;\n  if (abs(denom_s) > 0.0001) [\n    s = ((s_0 + t_t_cusp) * cv) / denom_s;\n    if (s > 1) [ s = 1; ];\n    if (s < 0) [ s = 0; ];\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKHSV;\noutput.h = h;\noutput.s = s;\noutput.v = v;\noutput"
-      }
-    }
-  ],
-  "slug": "okhsv-color"
-}

package/bundled/types/oklab-color.json

@@ -1,87 +0,0 @@
-{
-  "name": "OKLab",
-  "type": "color",
-  "description": "OKLab perceptually uniform color space by Björn Ottosson. L is lightness (0-1), a is green-red axis, b is blue-yellow axis.",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "l": {
-        "type": "number",
-        "description": "Lightness (0-1)"
-      },
-      "a": {
-        "type": "number",
-        "description": "Green-red axis (typically -0.4 to 0.4)"
-      },
-      "b": {
-        "type": "number",
-        "description": "Blue-yellow axis (typically -0.4 to 0.4)"
-      }
-    },
-    "required": [
-      "l",
-      "a",
-      "b"
-    ],
-    "order": [
-      "l",
-      "a",
-      "b"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "OKLab Color Initializer",
-      "keyword": "oklab",
-      "description": "Creates an OKLab color from L, a, b values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKLab Color Initializer\n// Creates an OKLab color from L, a, b values\n// Input: List of [l, a, b] or [l, a, b, alpha] values\n\nvariable lab_values: List = {input};\nvariable output: Color.OKLab;\n\noutput.l = lab_values.get(0);\noutput.a = lab_values.get(1);\noutput.b = lab_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lab_values.length() > 3) [\n  output.alpha = lab_values.get(3);\n];\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-      "target": "$self",
-      "description": "Converts XYZ-D65 to OKLab using Björn Ottosson's algorithm",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// XYZ-D65 to OKLab Conversion\n// Uses ColorJS-compatible matrices (recalculated for consistent D65 white)\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/oklab.js\n//\n// Algorithm:\n// 1. XYZ-D65 → LMS (M1 matrix)\n// 2. LMS → LMS' (cube root transformation)\n// 3. LMS' → OKLab (M2 matrix)\n//\n// Input: Color.XYZD65 with x, y, z tristimulus\n// Output: Color.OKLab with l, a, b coordinates\n\n// Get input XYZ-D65 values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// Step 1: XYZ-D65 → LMS cone response\n// ColorJS XYZtoLMS_M matrix (recalculated for consistent reference white)\nvariable lms_l: Number = x * 0.8190224379967030 + y * 0.3619062600528904 + z * -0.1288737815209879;\nvariable lms_m: Number = x * 0.0329836539323885 + y * 0.9292868615863434 + z * 0.0361446663506424;\nvariable lms_s: Number = x * 0.0481771893596242 + y * 0.2642395317527308 + z * 0.6335478284694309;\n\n// Step 2: Apply cube root (γ = 1/3)\n// Note: Using pow with 1/3 exponent (cbrt equivalent for positive values)\nvariable cube_root_exp: Number = 0.3333333333333333;\nvariable lms_l_prime: Number = pow(lms_l, cube_root_exp);\nvariable lms_m_prime: Number = pow(lms_m, cube_root_exp);\nvariable lms_s_prime: Number = pow(lms_s, cube_root_exp);\n\n// Step 3: LMS' → OKLab\n// ColorJS LMStoLab_M matrix\nvariable oklab_l: Number = lms_l_prime * 0.2104542683093140 + lms_m_prime * 0.7936177747023054 + lms_s_prime * -0.0040720430116193;\nvariable oklab_a: Number = lms_l_prime * 1.9779985324311684 + lms_m_prime * -2.4285922420485799 + lms_s_prime * 0.4505937096174110;\nvariable oklab_b: Number = lms_l_prime * 0.0259040424655478 + lms_m_prime * 0.7827717124575296 + lms_s_prime * -0.8086757549230774;\n\n// Create output\nvariable output: Color.OKLab;\noutput.l = oklab_l;\noutput.a = oklab_a;\noutput.b = oklab_b;\n\nreturn output;"
-      }
-    },
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-      "target": "$self",
-      "description": "Converts OKLCH to OKLab (polar to cartesian)",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKLCH to OKLab Conversion\n// Converts polar (C, H) back to cartesian (a, b) coordinates\n// Reference: Björn Ottosson's OKLab specification\n//\n// Algorithm:\n// L stays the same (lightness)\n// a = C * cos(H * π/180)\n// b = C * sin(H * π/180)\n//\n// Input: Color.OKLCH with l, c, h coordinates\n// Output: Color.OKLab with l, a, b coordinates\n\n// Get input OKLCH values\nvariable l: Number = {input}.l;\nvariable c: Number = {input}.c;\nvariable h: Number = {input}.h;\n\n// Constants\nvariable pi: Number = pi();\nvariable deg_to_rad: Number = pi / 180;\n\n// Convert hue to radians\nvariable h_rad: Number = h * deg_to_rad;\n\n// Convert polar to cartesian\nvariable a: Number = c * cos(h_rad);\nvariable b: Number = c * sin(h_rad);\n\n// Create output\nvariable output: Color.OKLab;\noutput.l = l;\noutput.a = a;\noutput.b = b;\n\nreturn output;"
-      }
-    },
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/okhsl-color/0/",
-      "target": "$self",
-      "description": "Converts OKHSL to OKLab",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKHSL to OKLab Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsl.js\n//\n// Converts OKHSL back to OKLab using:\n// 1. Inverse toe function to recover OKLab lightness\n// 2. Cusp finding to determine max chroma at this hue\n// 3. Saturation denormalization to get actual chroma\n//\n// Input: Color.OKHSL with h (0-360), s (0-1), l (0-1)\n// Output: Color.OKLab with l (0-1), a, b coordinates\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable l: Number = input.l;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// Toe function constants\nvariable toe_k1: Number = 0.206;\nvariable toe_k2: Number = 0.03;\nvariable toe_k3: Number = 1.17009708737864;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Apply inverse toe function to get OKLab lightness\n// toe_inv(x) = (x^2 + k1*x) / (k3 * (x + k2))\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_l: Number = l;\nif (l > 0.0001 && l < 0.9999) [\n  lab_l = (l * l + toe_k1 * l) / (toe_k3 * (l + toe_k2));\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Handle achromatic case\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_a: Number = 0;\nvariable lab_b: Number = 0;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Compute hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable h_rad: Number = h * pi_val / 180;\nvariable a_: Number = cos(h_rad);\nvariable b_: Number = sin(h_rad);\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in steps 4 and 5)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find maximum saturation at this hue (same as forward conversion)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\n\n// Variables for LMS intermediate calculations (reused in step 5)\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (s >= 0.0001) [\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Find cusp\n// ═══════════════════════════════════════════════════════════════════════════\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\nif (s >= 0.0001 && s_max > 0) [\n  // Recompute LMS values with refined s_max (kl, km, ks already computed)\n  variable l_cusp_temp: Number = 1 + s_max * kl;\n  variable m_cusp_temp: Number = 1 + s_max * km;\n  variable s_cusp_temp: Number = 1 + s_max * ks;\n  \n  l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n  m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n  s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n  \n  variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n  variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n  variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n  \n  variable max_rgb: Number = r_lin;\n  if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n  if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n  \n  if (max_rgb > 0) [\n    l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n    c_cusp = l_cusp * s_max;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 6: Compute chroma from saturation\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = 0;\n\nif (s >= 0.0001 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  \n  // Denormalize saturation to get chroma\n  c = s * lab_l * s_t_cusp;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 7: Convert polar to cartesian\n// ═══════════════════════════════════════════════════════════════════════════\nif (s >= 0.0001) [\n  lab_a = c * a_;\n  lab_b = c * b_;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKLab;\noutput.l = lab_l;\noutput.a = lab_a;\noutput.b = lab_b;\noutput"
-      }
-    },
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/okhsv-color/0/",
-      "target": "$self",
-      "description": "Converts OKHSV to OKLab",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKHSV to OKLab Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsv.js\n//\n// Converts OKHSV back to OKLab using:\n// 1. Cusp finding to determine gamut boundary at this hue\n// 2. V and S denormalization to get L and C\n//\n// Input: Color.OKHSV with h (0-360), s (0-1), v (0-1)\n// Output: Color.OKLab with l (0-1), a, b coordinates\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable v: Number = input.v;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Handle edge cases\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_l: Number = v;\nvariable lab_a: Number = 0;\nvariable lab_b: Number = 0;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Compute hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable h_rad: Number = h * pi_val / 180;\nvariable a_: Number = cos(h_rad);\nvariable b_: Number = sin(h_rad);\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in steps 3 and 4)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Find maximum saturation at this hue\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\n\n// Variables for LMS intermediate calculations (reused in step 4)\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001) [\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find cusp\n// ═══════════════════════════════════════════════════════════════════════════\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001 && s_max > 0) [\n  // Recompute LMS values with refined s_max (kl, km, ks already computed)\n  variable l_cusp_temp: Number = 1 + s_max * kl;\n  variable m_cusp_temp: Number = 1 + s_max * km;\n  variable s_cusp_temp: Number = 1 + s_max * ks;\n  \n  l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n  m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n  s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n  \n  variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n  variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n  variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n  \n  variable max_rgb: Number = r_lin;\n  if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n  if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n  \n  if (max_rgb > 0) [\n    l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n    c_cusp = l_cusp * s_max;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Compute L and C from V and S\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  variable t_t_cusp: Number = c_cusp / (1 - l_cusp + 0.0001);\n  \n  // Compute max chroma at this V\n  variable c_max_at_v: Number = 0;\n  \n  if (v <= l_cusp) [\n    c_max_at_v = v * s_t_cusp;\n  ] else [\n    c_max_at_v = (1 - v) * t_t_cusp;\n  ];\n  \n  // Compute actual chroma\n  c = s * c_max_at_v;\n  \n  // Compute L from V and C\n  // Reverse of: V = L + C / s_t_cusp\n  lab_l = v - c / (s_t_cusp + 0.0001);\n  if (lab_l < 0) [ lab_l = 0; ];\n  if (lab_l > 1) [ lab_l = 1; ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 6: Convert polar to cartesian\n// ═══════════════════════════════════════════════════════════════════════════\nif (s >= 0.0001 && v >= 0.0001) [\n  lab_a = c * a_;\n  lab_b = c * b_;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKLab;\noutput.l = lab_l;\noutput.a = lab_a;\noutput.b = lab_b;\noutput"
-      }
-    }
-  ],
-  "slug": "oklab-color"
-}

package/bundled/types/oklch-color.json

@@ -1,57 +0,0 @@
-{
-  "name": "OKLCH",
-  "type": "color",
-  "description": "OKLCH color space - the polar form of OKLab. L is lightness (0-1), C is chroma, H is hue angle (0-360).",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "l": {
-        "type": "number",
-        "description": "Lightness (0-1)"
-      },
-      "c": {
-        "type": "number",
-        "description": "Chroma (0 to ~0.4 for sRGB gamut)"
-      },
-      "h": {
-        "type": "number",
-        "description": "Hue angle (0-360 degrees)"
-      }
-    },
-    "required": [
-      "l",
-      "c",
-      "h"
-    ],
-    "order": [
-      "l",
-      "c",
-      "h"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "OKLCH Color Initializer",
-      "keyword": "oklch",
-      "description": "Creates an OKLCH color from L, C, H values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKLCH Color Initializer\n// Creates an OKLCH color from L, C, H values\n// Input: List of [l, c, h] or [l, c, h, alpha] values\n\nvariable lch_values: List = {input};\nvariable output: Color.OKLCH;\n\noutput.l = lch_values.get(0);\noutput.c = lch_values.get(1);\noutput.h = lch_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lch_values.length() > 3) [\n  output.alpha = lch_values.get(3);\n];\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-      "target": "$self",
-      "description": "Converts OKLab to OKLCH using Cartesian to polar transformation",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// OKLab to OKLCH Conversion\n// Converts Cartesian (a, b) to polar (C, H) coordinates\n// Reference: Björn Ottosson's OKLab specification\n//\n// Algorithm:\n// L stays the same (lightness)\n// C = sqrt(a² + b²) (chroma - distance from neutral axis)\n// H = atan2(b, a) * 180/π (hue angle in degrees)\n//\n// Input: Color.OKLab with l, a, b coordinates\n// Output: Color.OKLCH with l, c, h coordinates\n\n// Get input OKLab values\nvariable l: Number = {input}.l;\nvariable a: Number = {input}.a;\nvariable b: Number = {input}.b;\n\n// Constants\nvariable pi: Number = pi();\nvariable rad_to_deg: Number = 180 / pi;\n\n// Calculate chroma (distance from neutral axis)\nvariable c: Number = sqrt(a * a + b * b);\n\n// Calculate hue angle using atan2\n// atan2(y, x) returns angle in radians from -π to π\nvariable h_rad: Number = atan2(b, a);\nvariable h: Number = h_rad * rad_to_deg;\n\n// Normalize hue to 0-360 range\nif (h < 0) [\n    h = h + 360;\n];\n\n// Create output\nvariable output: Color.OKLCH;\noutput.l = l;\noutput.c = c;\noutput.h = h;\n\nreturn output;"
-      }
-    }
-  ],
-  "slug": "oklch-color"
-}

package/bundled/types/p3-color.json

@@ -1,57 +0,0 @@
-{
-  "name": "P3",
-  "type": "color",
-  "description": "Display-P3 color space with sRGB transfer function. Wider gamut than sRGB, common on modern Apple displays.",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "r": {
-        "type": "number",
-        "description": "Red channel (0-1, can exceed for out-of-gamut)"
-      },
-      "g": {
-        "type": "number",
-        "description": "Green channel (0-1, can exceed for out-of-gamut)"
-      },
-      "b": {
-        "type": "number",
-        "description": "Blue channel (0-1, can exceed for out-of-gamut)"
-      }
-    },
-    "required": [
-      "r",
-      "g",
-      "b"
-    ],
-    "order": [
-      "r",
-      "g",
-      "b"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "Display-P3 Color Initializer",
-      "keyword": "p3",
-      "description": "Creates a Display-P3 color from 0-1 values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Display-P3 Color Initializer\n// Creates a Display-P3 color from 0-1 values\n// Input: List of [r, g, b] or [r, g, b, alpha] values\n\nvariable color_values: List = {input};\nvariable output: Color.P3;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_values.length() > 3) [\n  output.alpha = color_values.get(3);\n];\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/p3-linear-color/0/",
-      "target": "$self",
-      "description": "Converts Linear P3 to P3 by applying sRGB transfer function",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Linear P3 to P3 Conversion\n// Applies sRGB transfer function (gamma encoding)\n// P3 uses the same transfer function as sRGB\n// Reference: CSS Color Level 4\n//\n// Algorithm (same as sRGB):\n//   if linear ≤ 0.0031308: encoded = 12.92 × linear\n//   else: encoded = 1.055 × linear^(1/2.4) - 0.055\n//\n// Input: Color.LinearP3 with linear r, g, b values\n// Output: Color.P3 with gamma-encoded r, g, b values\n\n// Transfer function constants (same as sRGB)\nvariable threshold: Number = 0.0031308;\nvariable linear_scale: Number = 12.92;\nvariable gamma_scale: Number = 1.055;\nvariable gamma_offset: Number = 0.055;\nvariable gamma_exponent: Number = 0.4166666666666667;\n\n// Get linear values\nvariable linear_r: Number = {input}.r;\nvariable linear_g: Number = {input}.g;\nvariable linear_b: Number = {input}.b;\n\n// Convert red channel\nvariable encoded_r: Number = 0;\nif (linear_r <= threshold) [\n    encoded_r = linear_scale * linear_r;\n] else [\n    encoded_r = gamma_scale * pow(linear_r, gamma_exponent) - gamma_offset;\n];\n\n// Convert green channel\nvariable encoded_g: Number = 0;\nif (linear_g <= threshold) [\n    encoded_g = linear_scale * linear_g;\n] else [\n    encoded_g = gamma_scale * pow(linear_g, gamma_exponent) - gamma_offset;\n];\n\n// Convert blue channel\nvariable encoded_b: Number = 0;\nif (linear_b <= threshold) [\n    encoded_b = linear_scale * linear_b;\n] else [\n    encoded_b = gamma_scale * pow(linear_b, gamma_exponent) - gamma_offset;\n];\n\n// Create output\nvariable output: Color.P3;\noutput.r = encoded_r;\noutput.g = encoded_g;\noutput.b = encoded_b;\n\nreturn output;"
-      }
-    }
-  ],
-  "slug": "p3-color"
-}

package/bundled/types/p3-linear-color.json

@@ -1,57 +0,0 @@
-{
-  "name": "LinearP3",
-  "type": "color",
-  "description": "Linear Display-P3 color space (gamma-decoded). Used for matrix transformations to XYZ.",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "r": {
-        "type": "number",
-        "description": "Linear red channel (0-1, can exceed for HDR)"
-      },
-      "g": {
-        "type": "number",
-        "description": "Linear green channel (0-1, can exceed for HDR)"
-      },
-      "b": {
-        "type": "number",
-        "description": "Linear blue channel (0-1, can exceed for HDR)"
-      }
-    },
-    "required": [
-      "r",
-      "g",
-      "b"
-    ],
-    "order": [
-      "r",
-      "g",
-      "b"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "Linear P3 Color Initializer",
-      "keyword": "linearp3",
-      "description": "Creates a linear Display-P3 color from linear 0-1 values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Linear P3 Color Initializer\n// Creates a linear Display-P3 color from linear 0-1 values\n// Input: List of [r, g, b] linear values\n\nvariable color_values: List = {input};\nvariable output: Color.LinearP3;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-      "target": "$self",
-      "description": "Converts XYZ-D65 to Linear P3 using the P3 transformation matrix",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// XYZ-D65 to Linear P3 Conversion\n// Converts CIE XYZ (D65) to linear Display-P3 RGB\n// Reference: CSS Color Level 4 specification\n//\n// Uses the inverse of the P3 to XYZ-D65 matrix\n// Matrix values from ColorJS / CSS Color Level 4\n//\n// Input: Color.XYZD65 with x, y, z tristimulus values\n// Output: Color.LinearP3 with linear r, g, b values (may be outside 0-1 for out-of-gamut)\n\n// Get XYZ values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// XYZ to Linear P3 matrix (inverse of P3 to XYZ)\n// Row 1\nvariable m00: Number = 2.4934969119414254;\nvariable m01: Number = -0.9313836179191239;\nvariable m02: Number = -0.40271078445071684;\n\n// Row 2\nvariable m10: Number = -0.8294889695615747;\nvariable m11: Number = 1.7626640603183463;\nvariable m12: Number = 0.023624685841943577;\n\n// Row 3\nvariable m20: Number = 0.03584583024378447;\nvariable m21: Number = -0.07617238926804182;\nvariable m22: Number = 0.9568845240076872;\n\n// Matrix multiplication: [r, g, b] = M × [x, y, z]\nvariable linear_r: Number = m00 * x + m01 * y + m02 * z;\nvariable linear_g: Number = m10 * x + m11 * y + m12 * z;\nvariable linear_b: Number = m20 * x + m21 * y + m22 * z;\n\n// Create output (note: values may be outside 0-1 for out-of-gamut colors)\nvariable output: Color.LinearP3;\noutput.r = linear_r;\noutput.g = linear_g;\noutput.b = linear_b;\n\nreturn output;"
-      }
-    }
-  ],
-  "slug": "p3-linear-color"
-}

package/bundled/types/rgb-color.json

@@ -1,73 +0,0 @@
-{
-  "name": "Rgb",
-  "type": "color",
-  "description": "RGB color",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "r": {
-        "type": "number"
-      },
-      "g": {
-        "type": "number"
-      },
-      "b": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "r",
-      "g",
-      "b"
-    ],
-    "order": [
-      "r",
-      "g",
-      "b"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "function",
-      "keyword": "rgb",
-      "description": "Creates an RGB color",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// RGB Color Initializer\n// Creates an RGB color from r, g, b values (0-255 range)\n//\n// Usage: rgb(255, 128, 64) → Color.Rgb { r: 255, g: 128, b: 64 }\n//        rgb(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }\n//\n// Input: List of 3 or 4 numbers [r, g, b] or [r, g, b, alpha]\n// Output: Color.Rgb\n\nvariable color_parts: List = {input}; \n\nvariable output: Color.Rgb;\noutput.r = color_parts.get(0);\noutput.g = color_parts.get(1);\noutput.b = color_parts.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_parts.length() > 3) [\n  output.alpha = color_parts.get(3);\n];\n\nreturn output;"
-      }
-    },
-    {
-      "title": "function",
-      "keyword": "rgba",
-      "description": "Creates an RGB color with alpha",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// RGBA Color Initializer\n// Creates an RGB color with alpha from r, g, b, a values\n//\n// Usage: rgba(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }\n//\n// Input: List of 4 numbers [r, g, b, alpha]\n// Output: Color.Rgb with alpha\n\nvariable color_parts: List = {input}; \n\nvariable output: Color.Rgb;\noutput.r = color_parts.get(0);\noutput.g = color_parts.get(1);\noutput.b = color_parts.get(2);\noutput.alpha = color_parts.get(3);\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hex-color/0/",
-      "target": "$self",
-      "description": "Converts HEX to RGB",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Hex to RGB Conversion\n// Converts hexadecimal color string to RGB (0-255 range)\n//\n// Supports both shorthand (#RGB) and standard (#RRGGBB) formats:\n//   #f00     → RGB(255, 0, 0)\n//   #ff0000  → RGB(255, 0, 0)\n//\n// Algorithm:\n// 1. Remove '#' prefix and split into characters\n// 2. For shorthand: duplicate each digit (f → ff)\n// 3. Parse hex pairs to decimal values\n//\n// Input: Color.Hex (e.g., #ff5733)\n// Output: Color.Rgb with r, g, b in 0-255 range\n\n// Split hex string on '#' and get the color value\nvariable color_parts: List = {input}.to_string().split('#'); \nvariable color: List = color_parts.get(1).split(); \nvariable length: Number = color.length(); \n\n// Initialize RGB values\nvariable rgb: List = 0, 0, 0; \n\n// Handle shorthand (#RGB) vs standard (#RRGGBB) format\nif(length == 3) [ \n  // Shorthand: duplicate each digit\n  rgb.update(0, parse_int(color.get(0).concat(color.get(0)), 16)); \n  rgb.update(1, parse_int(color.get(1).concat(color.get(1)), 16)); \n  rgb.update(2, parse_int(color.get(2).concat(color.get(2)), 16)); \n] else [ \n  // Standard: pair adjacent digits\n  rgb.update(0, parse_int(color.get(0).concat(color.get(1)), 16)); \n  rgb.update(1, parse_int(color.get(2).concat(color.get(3)), 16)); \n  rgb.update(2, parse_int(color.get(4).concat(color.get(5)), 16)); \n]; \n\n// Create output color\nvariable output: Color.Rgb; \noutput.r = rgb.get(0); \noutput.g = rgb.get(1); \noutput.b = rgb.get(2); \n\nreturn output;"
-      }
-    },
-    {
-      "source": "$self",
-      "target": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hex-color/0/",
-      "description": "Converts RGB to HEX",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// RGB to Hex Conversion\n// Converts RGB (0-255) color to hexadecimal string format\n//\n// Examples:\n//   RGB(255, 0, 0)   → #ff0000\n//   RGB(0, 255, 128) → #00ff80\n//\n// Algorithm:\n// 1. Round each channel to nearest integer\n// 2. Convert to base-16 string\n// 3. Pad single digits with leading zero\n// 4. Concatenate with '#' prefix\n//\n// Input: Color.Rgb with r, g, b in 0-255 range\n// Output: String (hex format #rrggbb)\n\nvariable rgba: List = {input}.r, {input}.g, {input}.b;\nvariable hex: String = \"#\";\nvariable i: Number = 0;\nvariable value: Number = 0;\n\n// Convert each RGB channel to hex\nwhile( i < min(rgba.length(), 3)) [\n  value = round(rgba.get(i));\n  if(value < 16) [\n    hex = hex.concat(\"0\").concat(value.to_string(16));\n  ] else [\n    hex = hex.concat(value.to_string(16));\n  ];\n  i = i + 1;\n];\n\nif (rgba.length() == 4) [\n  value = rgba.get(3) * 255; // Convert alpha to 0-255 range\n  if(value < 16) [\n    hex = hex.concat(\"0\").concat(value.to_string(16));\n  ] else [\n    hex = hex.concat(value.to_string(16));\n  ];\n];\n\nreturn hex;"
-      }
-    }
-  ],
-  "slug": "rgb-color"
-}

package/bundled/types/srgb-color.json

@@ -1,77 +0,0 @@
-{
-  "name": "SRGB",
-  "type": "color",
-  "description": "sRGB color space with normalized 0-1 range. The standard color space for web and displays.",
-  "schema": {
-    "type": "object",
-    "properties": {
-      "r": {
-        "type": "number",
-        "description": "Red channel (0-1)"
-      },
-      "g": {
-        "type": "number",
-        "description": "Green channel (0-1)"
-      },
-      "b": {
-        "type": "number",
-        "description": "Blue channel (0-1)"
-      }
-    },
-    "required": [
-      "r",
-      "g",
-      "b"
-    ],
-    "order": [
-      "r",
-      "g",
-      "b"
-    ],
-    "additionalProperties": false
-  },
-  "initializers": [
-    {
-      "title": "sRGB Color Initializer",
-      "keyword": "srgb",
-      "description": "Creates an sRGB color from normalized 0-1 values",
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// sRGB Color Initializer\n// Creates an sRGB color from normalized 0-1 values\n// Input: List of [r, g, b] or [r, g, b, alpha] values in 0-1 range\n\nvariable color_values: List = {input};\nvariable output: Color.SRGB;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_values.length() > 3) [\n  output.alpha = color_values.get(3);\n];\n\nreturn output;"
-      }
-    }
-  ],
-  "conversions": [
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/rgb-color/0/",
-      "target": "$self",
-      "description": "Converts RGB (0-255) to sRGB (0-1) by normalizing",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// RGB to sRGB Conversion\n// Converts RGB (0-255) to sRGB (0-1) by normalizing\n// Input: Color.Rgb with r, g, b in 0-255 range\n// Output: Color.SRGB with r, g, b in 0-1 range\n// Lossless: Yes (simple division)\n\nvariable r_normalized: Number = {input}.r / 255;\nvariable g_normalized: Number = {input}.g / 255;\nvariable b_normalized: Number = {input}.b / 255;\n\nvariable output: Color.SRGB;\noutput.r = r_normalized;\noutput.g = g_normalized;\noutput.b = b_normalized;\n\nreturn output;"
-      }
-    },
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hsl-color/0/",
-      "target": "$self",
-      "description": "Converts HSL to sRGB",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// HSL to sRGB Conversion\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js\n//\n// Algorithm:\n// 1. If saturation is 0, it's achromatic: R=G=B=L\n// 2. Otherwise use the HSL to RGB formula:\n//    - Calculate intermediate values based on L\n//    - Use hue to determine RGB components\n//\n// Input: Color.HSL with h (0-360), s (0-1), l (0-1)\n// Output: Color.SRGB with r, g, b in 0-1 range\n\n// Get input HSL values\nvariable h: Number = {input}.h;\nvariable s: Number = {input}.s;\nvariable l: Number = {input}.l;\n\n// Normalize hue to 0-1 range\nvariable hue: Number = h / 360;\n\n// Output values\nvariable r: Number = l;\nvariable g: Number = l;\nvariable b: Number = l;\n\n// Only calculate if there's saturation (not achromatic)\nif (s > 0) [\n    // Calculate intermediate value\n    variable q: Number = 0;\n    if (l < 0.5) [\n        q = l * (1 + s);\n    ] else [\n        q = l + s - l * s;\n    ];\n    \n    variable p: Number = 2 * l - q;\n    \n    // Helper function logic inlined for R (hue + 1/3)\n    variable tr: Number = hue + 0.333333333333333;\n    if (tr < 0) [ tr = tr + 1; ];\n    if (tr > 1) [ tr = tr - 1; ];\n    \n    if (tr < 0.166666666666667) [\n        r = p + (q - p) * 6 * tr;\n    ] else [\n        if (tr < 0.5) [\n            r = q;\n        ] else [\n            if (tr < 0.666666666666667) [\n                r = p + (q - p) * (0.666666666666667 - tr) * 6;\n            ] else [\n                r = p;\n            ];\n        ];\n    ];\n    \n    // Helper function logic inlined for G (hue)\n    variable tg: Number = hue;\n    if (tg < 0) [ tg = tg + 1; ];\n    if (tg > 1) [ tg = tg - 1; ];\n    \n    if (tg < 0.166666666666667) [\n        g = p + (q - p) * 6 * tg;\n    ] else [\n        if (tg < 0.5) [\n            g = q;\n        ] else [\n            if (tg < 0.666666666666667) [\n                g = p + (q - p) * (0.666666666666667 - tg) * 6;\n            ] else [\n                g = p;\n            ];\n        ];\n    ];\n    \n    // Helper function logic inlined for B (hue - 1/3)\n    variable tb: Number = hue - 0.333333333333333;\n    if (tb < 0) [ tb = tb + 1; ];\n    if (tb > 1) [ tb = tb - 1; ];\n    \n    if (tb < 0.166666666666667) [\n        b = p + (q - p) * 6 * tb;\n    ] else [\n        if (tb < 0.5) [\n            b = q;\n        ] else [\n            if (tb < 0.666666666666667) [\n                b = p + (q - p) * (0.666666666666667 - tb) * 6;\n            ] else [\n                b = p;\n            ];\n        ];\n    ];\n];\n\n// Create output\nvariable output: Color.SRGB;\noutput.r = r;\noutput.g = g;\noutput.b = b;\n\nreturn output;"
-      }
-    },
-    {
-      "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/",
-      "target": "$self",
-      "description": "Converts Linear sRGB to sRGB by applying gamma correction",
-      "lossless": true,
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Linear sRGB to sRGB Conversion\n// Applies gamma correction (transfer function)\n// Reference: IEC 61966-2-1:1999 (sRGB specification)\n//\n// Algorithm:\n//   if linear ≤ 0.0031308: srgb = linear * 12.92\n//   else: srgb = 1.055 * linear^(1/2.4) - 0.055\n//\n// Input: Color.LinearSRGB with r, g, b in linear 0-1 range\n// Output: Color.SRGB with r, g, b in gamma-corrected 0-1 range\n\n// Gamma correction constants (IEC 61966-2-1)\nvariable threshold: Number = 0.0031308;\nvariable linear_scale: Number = 12.92;\nvariable gamma_offset: Number = 0.055;\nvariable gamma_scale: Number = 1.055;\nvariable gamma_exponent: Number = 0.416666666666667;\n\n// Get input linear values\nvariable linear_r: Number = {input}.r;\nvariable linear_g: Number = {input}.g;\nvariable linear_b: Number = {input}.b;\n\n// Convert red channel\nvariable srgb_r: Number = 0;\nif (linear_r <= threshold) [\n    srgb_r = linear_r * linear_scale;\n] else [\n    srgb_r = gamma_scale * pow(linear_r, gamma_exponent) - gamma_offset;\n];\n\n// Convert green channel\nvariable srgb_g: Number = 0;\nif (linear_g <= threshold) [\n    srgb_g = linear_g * linear_scale;\n] else [\n    srgb_g = gamma_scale * pow(linear_g, gamma_exponent) - gamma_offset;\n];\n\n// Convert blue channel\nvariable srgb_b: Number = 0;\nif (linear_b <= threshold) [\n    srgb_b = linear_b * linear_scale;\n] else [\n    srgb_b = gamma_scale * pow(linear_b, gamma_exponent) - gamma_offset;\n];\n\n// Create output\nvariable output: Color.SRGB;\noutput.r = srgb_r;\noutput.g = srgb_g;\noutput.b = srgb_b;\n\nreturn output;"
-      }
-    }
-  ],
-  "slug": "srgb-color"
-}