@worldcoin/nucleus 0.1.4 → 0.1.5

package/examples/android/app/src/main/kotlin/com/worldcoin/nucleusapp/TokenData.kt

@@ -1,369 +0,0 @@
-package com.worldcoin.nucleusapp
-
-import android.content.Context
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
-
-private const val GENERATED_TOKEN_DIR = "com/worldcoin/nucleus"
-private const val PRIMITIVE_FILE = "$GENERATED_TOKEN_DIR/NucleusPrimitiveColors.kt"
-private const val SEMANTIC_LIGHT_FILE = "$GENERATED_TOKEN_DIR/NucleusSemanticColorsLight.kt"
-private const val SEMANTIC_DARK_FILE = "$GENERATED_TOKEN_DIR/NucleusSemanticColorsDark.kt"
-
-private val tokenLineRegex = Regex("""^\s*val\s+([A-Za-z0-9_]+)\s*=\s*(.+)$""")
-private val tokenReferenceRegex = Regex("""^Nucleus(PrimitiveColors|SemanticColors(?:Light|Dark))\.([A-Za-z0-9_]+)$""")
-private val tokenColorRegex = Regex("""^Color\(0x([0-9A-Fa-f]{8})\)$""")
-
-private data class ResolvedToken(
-    val name: String,
-    val value: String,
-    val family: String,
-    val tone: Int?,
-)
-
-private fun loadTokenPairs(context: Context, fileName: String): List<Pair<String, String>> =
-    context.assets.open(fileName).bufferedReader().useLines { lines ->
-        lines.mapNotNull { line ->
-            tokenLineRegex.matchEntire(line)?.destructured?.let { (name, value) ->
-                name to value.trim()
-            }
-        }.toList()
-    }
-
-private fun tokenFamilyKey(name: String): String {
-    if (name == "white" || name == "black") {
-        return "base"
-    }
-
-    val prefix = name.takeWhile { it.isLowerCase() }
-    return prefix.ifEmpty { name }
-}
-
-private fun familyTitle(name: String): String =
-    name.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
-
-private fun tokenTone(name: String): Int? {
-    val digits = name.takeLastWhile { it.isDigit() }
-    return digits.toIntOrNull()
-}
-
-private fun referenceTokenKey(value: String): Pair<String, String>? {
-    val match = tokenReferenceRegex.matchEntire(value) ?: return null
-    val root = if (match.groupValues[1] == "PrimitiveColors") "primitive" else "semantic"
-    return root to match.groupValues[2]
-}
-
-private fun colorLiteralValue(value: String): String? {
-    val match = tokenColorRegex.matchEntire(value) ?: return null
-    val argb = match.groupValues[1].uppercase()
-    val alpha = argb.substring(0, 2)
-    val rgb = argb.substring(2)
-    return if (alpha == "FF") rgb else rgb + alpha
-}
-
-private fun resolveTokenEntries(
-    tokens: List<Pair<String, String>>,
-    primitiveTokens: Map<String, String>,
-    semanticTokens: Map<String, String>? = null,
-): List<ResolvedToken> =
-    tokens.map { (name, rawValue) ->
-        ResolvedToken(
-            name = name,
-            value = resolveColorValue(rawValue, primitiveTokens, semanticTokens),
-            family = tokenFamilyKey(name),
-            tone = tokenTone(name),
-        )
-    }
-
-private fun resolveColorValue(
-    value: String,
-    primitiveTokens: Map<String, String>,
-    semanticTokens: Map<String, String>? = null,
-): String {
-    colorLiteralValue(value)?.let { return it }
-
-    val reference = referenceTokenKey(value) ?: return value.removePrefix("#").uppercase()
-    val sourceTokens = if (reference.first == "primitive") primitiveTokens else semanticTokens
-    val resolved = sourceTokens?.get(reference.second) ?: return value.removePrefix("#").uppercase()
-
-    if (resolved == value) {
-        return value.removePrefix("#").uppercase()
-    }
-
-    return resolveColorValue(resolved, primitiveTokens, semanticTokens)
-}
-
-private fun String.toComposeColor(): Color {
-    val normalized = removePrefix("#").uppercase()
-    val argbHex = when (normalized.length) {
-        6 -> "FF$normalized"
-        8 -> normalized.takeLast(2) + normalized.dropLast(2)
-        else -> error("Unsupported color format: $this")
-    }
-
-    return Color(argbHex.toLong(radix = 16).toInt())
-}
-
-private fun groupEntriesByFamily(entries: List<ResolvedToken>): LinkedHashMap<String, MutableList<ResolvedToken>> {
-    val groups = linkedMapOf<String, MutableList<ResolvedToken>>()
-
-    entries.forEach { entry ->
-        groups.getOrPut(entry.family) { mutableListOf() }.add(entry)
-    }
-
-    return groups
-}
-
-private fun isOpaque(hex: String): Boolean {
-    val normalized = hex.removePrefix("#").uppercase()
-    return normalized.length != 8 || normalized.endsWith("FF")
-}
-
-private fun pickOpaqueFamilyToken(entries: List<ResolvedToken>?, index: Int = 0): String? {
-    val opaqueEntries = entries?.filter { isOpaque(it.value) }.orEmpty()
-    if (opaqueEntries.isEmpty()) {
-        return null
-    }
-
-    return opaqueEntries.getOrNull(index)?.value ?: opaqueEntries.first().value
-}
-
-private fun pickLastDistinctOpaqueToken(entries: List<ResolvedToken>?, excluded: List<String>): String? =
-    entries
-        ?.asReversed()
-        ?.firstOrNull { entry -> isOpaque(entry.value) && entry.value !in excluded }
-        ?.value
-
-private fun pickTone(entries: List<ResolvedToken>?, targets: List<Int>): String? {
-    val tonedEntries = entries?.filter { it.tone != null }.orEmpty()
-    if (tonedEntries.isEmpty()) {
-        return entries?.firstOrNull()?.value
-    }
-
-    targets.forEach { target ->
-        tonedEntries.firstOrNull { it.tone == target }?.let { return it.value }
-    }
-
-    val firstTarget = targets.firstOrNull() ?: return tonedEntries.first().value
-    return tonedEntries.minByOrNull { kotlin.math.abs((it.tone ?: firstTarget) - firstTarget) }?.value
-}
-
-private fun pickNeutralEntries(groups: Map<String, List<ResolvedToken>>): List<ResolvedToken> {
-    val candidates = listOf("grey", "gray", "neutral", "stone", "slate")
-
-    candidates.forEach { family ->
-        val entries = groups[family]
-        if (entries?.any { it.tone != null } == true) {
-            return entries
-        }
-    }
-
-    return groups.values
-        .filter { entries -> entries.any { it.tone != null } }
-        .maxByOrNull { it.size }
-        .orEmpty()
-}
-
-private fun pickAccentEntries(
-    groups: Map<String, List<ResolvedToken>>,
-    neutralFamily: String,
-): List<ResolvedToken> {
-    val priorities = listOf("info", "accent", "brand", "blue")
-
-    priorities.forEach { family ->
-        groups[family]?.let { return it }
-    }
-
-    return groups.entries.firstOrNull { (family, _) ->
-        family != "base" && family != neutralFamily
-    }?.value.orEmpty()
-}
-
-private fun contrastColor(color: String, light: String = "FFFFFF", dark: String = "17181A"): String {
-    val normalized = color.removePrefix("#").uppercase()
-    val rgb = normalized.take(6)
-    if (rgb.length != 6) {
-        return light
-    }
-
-    val red = rgb.substring(0, 2).toInt(16)
-    val green = rgb.substring(2, 4).toInt(16)
-    val blue = rgb.substring(4, 6).toInt(16)
-    val luminance = (0.2126 * red + 0.7152 * green + 0.0722 * blue) / 255
-
-    return if (luminance > 0.6) dark else light
-}
-
-private fun buildTokenGroups(
-    tokens: List<ResolvedToken>,
-): List<TokenGroup> {
-    val groupedTokens = linkedMapOf<String, MutableList<TokenSwatch>>()
-
-    tokens.forEach { token ->
-        val family = token.family
-        groupedTokens.getOrPut(family) { mutableListOf() }
-            .add(
-                TokenSwatch(
-                    id = token.name,
-                    name = token.name,
-                    hex = token.value,
-                    color = token.value.toComposeColor(),
-                ),
-            )
-    }
-
-    return groupedTokens.map { (family, swatches) ->
-        TokenGroup(
-            id = family,
-            name = familyTitle(family),
-            tokens = swatches.toList(),
-        )
-    }
-}
-
-private fun buildNeutralTheme(entries: List<ResolvedToken>): TokenTheme {
-    val groups = groupEntriesByFamily(entries)
-    val neutralEntries = pickNeutralEntries(groups)
-    val neutralFamily = neutralEntries.firstOrNull()?.family ?: "grey"
-    val baseEntries = groups["base"].orEmpty()
-    val white = baseEntries.firstOrNull { it.name == "white" }?.value ?: "FFFFFF"
-    val black = baseEntries.firstOrNull { it.name == "black" }?.value ?: "17181A"
-    val accent = pickTone(pickAccentEntries(groups, neutralFamily), listOf(600, 500, 400)) ?: "0064EE"
-
-    return TokenTheme(
-        background = (pickTone(neutralEntries, listOf(100, 200)) ?: white).toComposeColor(),
-        surface = white.toComposeColor(),
-        surfaceAlt = white.toComposeColor(),
-        border = (pickTone(neutralEntries, listOf(300, 400)) ?: "D7D9DC").toComposeColor(),
-        text = (pickTone(neutralEntries, listOf(950, 900, 800)) ?: black).toComposeColor(),
-        muted = (pickTone(neutralEntries, listOf(700, 600, 500)) ?: black).toComposeColor(),
-        accent = accent.toComposeColor(),
-        accentContent = contrastColor(accent, white, black).toComposeColor(),
-    )
-}
-
-private fun buildSemanticTheme(
-    entries: List<ResolvedToken>,
-    neutralTheme: TokenTheme,
-): TokenTheme {
-    val groups = groupEntriesByFamily(entries)
-    val surfaceEntries = groups["surface"]
-    val textEntries = groups["text"]
-    val iconEntries = groups["icon"]
-    val borderEntries = groups["border"]
-    val accentEntries = groups["accent"]
-    val actionEntries = groups["action"]
-    val statusEntries = groups["status"]
-    val surface = pickOpaqueFamilyToken(surfaceEntries, 0)?.toComposeColor() ?: neutralTheme.surface
-    val background = pickOpaqueFamilyToken(surfaceEntries, 1)?.toComposeColor() ?: surface
-    val surfaceAltHex =
-        pickLastDistinctOpaqueToken(surfaceEntries, listOf(surface.toHexString(), background.toHexString()))
-            ?: pickOpaqueFamilyToken(surfaceEntries, 0)
-            ?: neutralTheme.surfaceAlt.toHexString()
-    val accentHex =
-        pickOpaqueFamilyToken(accentEntries, 0)
-            ?: pickOpaqueFamilyToken(actionEntries, 0)
-            ?: pickOpaqueFamilyToken(statusEntries, 0)
-            ?: neutralTheme.accent.toHexString()
-    val accentContentHex =
-        pickOpaqueFamilyToken(accentEntries, 1)
-            ?: pickOpaqueFamilyToken(actionEntries, 1)
-            ?: contrastColor(accentHex)
-
-    return TokenTheme(
-        background = background,
-        surface = surface,
-        surfaceAlt = surfaceAltHex.toComposeColor(),
-        border = (
-            pickOpaqueFamilyToken(borderEntries, 1)
-                ?: pickOpaqueFamilyToken(borderEntries, 0)
-                ?: neutralTheme.border.toHexString()
-            ).toComposeColor(),
-        text = (
-            pickOpaqueFamilyToken(textEntries, 0)
-                ?: pickOpaqueFamilyToken(iconEntries, 0)
-                ?: neutralTheme.text.toHexString()
-            ).toComposeColor(),
-        muted = (
-            pickOpaqueFamilyToken(textEntries, 1)
-                ?: pickOpaqueFamilyToken(iconEntries, 1)
-                ?: neutralTheme.muted.toHexString()
-            ).toComposeColor(),
-        accent = accentHex.toComposeColor(),
-        accentContent = accentContentHex.toComposeColor(),
-    )
-}
-
-private fun buildSemanticMode(
-    id: String,
-    name: String,
-    tokens: List<Pair<String, String>>,
-    primitiveTokens: Map<String, String>,
-    neutralTheme: TokenTheme,
-): SemanticModeData {
-    val semanticTokenMap = tokens.toMap()
-    val entries = resolveTokenEntries(tokens, primitiveTokens, semanticTokenMap)
-    val groups = buildTokenGroups(entries)
-
-    return SemanticModeData(
-        id = id,
-        name = name,
-        theme = buildSemanticTheme(entries, neutralTheme),
-        groups = groups,
-    )
-}
-
-fun Color.toHexString(): String {
-    val argb = toArgb()
-    val alpha = (argb ushr 24) and 0xFF
-    val red = (argb ushr 16) and 0xFF
-    val green = (argb ushr 8) and 0xFF
-    val blue = argb and 0xFF
-    return if (alpha == 0xFF) {
-        String.format("%02X%02X%02X", red, green, blue)
-    } else {
-        String.format("%02X%02X%02X%02X", red, green, blue, alpha)
-    }
-}
-
-fun loadTokenCatalog(context: Context): TokenCatalog {
-    val primitivePairs = loadTokenPairs(context, PRIMITIVE_FILE)
-    val semanticLightPairs = loadTokenPairs(context, SEMANTIC_LIGHT_FILE)
-    val semanticDarkPairs = loadTokenPairs(context, SEMANTIC_DARK_FILE)
-    val primitiveMap = primitivePairs.toMap()
-    val primitiveEntries = resolveTokenEntries(primitivePairs, primitiveMap)
-    val neutralTheme = buildNeutralTheme(primitiveEntries)
-
-    val semanticModes = listOf(
-        buildSemanticMode("light", "Light", semanticLightPairs, primitiveMap, neutralTheme),
-        buildSemanticMode("dark", "Dark", semanticDarkPairs, primitiveMap, neutralTheme),
-    )
-
-    val appearanceThemes = semanticModes.map { mode ->
-        AppearanceTheme(
-            id = mode.id,
-            name = mode.name,
-            theme = mode.theme,
-        )
-    }
-
-    val primitiveGroups = buildTokenGroups(primitiveEntries)
-
-    val tokenSections = listOf(
-        TokenSectionData(
-            id = "primitive",
-            label = "Primitive",
-            groups = primitiveGroups,
-        ),
-    ) + semanticModes.map { mode ->
-        TokenSectionData(
-            id = "semantic-${mode.id}",
-            label = mode.name,
-            groups = mode.groups,
-        )
-    }
-
-    return TokenCatalog(
-        appearanceThemes = appearanceThemes,
-        tokenSections = tokenSections,
-    )
-}

package/examples/android/app/src/main/res/values/strings.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name">Nucleus</string>
-</resources>

package/examples/android/app/src/main/res/values/themes.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <style name="Theme.NucleusApp" parent="Theme.Material3.DayNight.NoActionBar" />
-</resources>

package/examples/android/build.gradle.kts

@@ -1,6 +0,0 @@
-plugins {
-    id("com.android.application") version "8.7.3" apply false
-    id("com.android.library") version "8.7.3" apply false
-    kotlin("android") version "2.0.21" apply false
-    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21" apply false
-}

package/examples/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

package/examples/android/gradle.properties

@@ -1,4 +0,0 @@
-android.useAndroidX=true
-kotlin.code.style=official
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-nucleusPackageVersion=0.0.0

package/examples/android/gradlew

@@ -1,251 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# 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
-#
-#      https://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.
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"