yurique

import {Plugin} from "vite";

interface PluginConfig {
  excludeExtensions?: string[]
}

interface ResolvedPluginConfig extends PluginConfig {
  excludeExtensions: string[]
}

yurique

val isScala3Setting = Def.setting {
  isScala3(CrossVersion.partialVersion(scalaVersion.value))
}

def isScala3(v: Option[(Long, Long)]): Boolean = v.exists(_._1 != 2)

yurique

package app.tulz.tuplez

trait ApplyConverterInstancesPriLow[O] {
  implicit def singleParam[T1]: ApplyConverter[T1, O] { type In = (T1) => O } = new ApplyConverter[T1, O] {
    type In = T1 => O
    def apply(fn: T1 => O): T1 => O = fn
  }
}

trait ApplyConverterInstances[O] extends ApplyConverterInstancesPriLow[O] {

yurique

package app.tulz.tuplez

abstract class ApplyConverter[L, O] {
  type In
  def apply(f: In): L => O
}

trait ApplyConverters[O] extends ApplyConverterInstances[O]

yurique

import java.io.File
import scala.reflect.macros.blackbox

object FileToLiteral {

  def apply(fileName: String): String = macro FileToLiteralImpl.referEmbeddedFile

}

class FileToLiteralImpl(val c: blackbox.Context) {

yurique

import sbt._
import sbt.Keys._
import sbt.KeyRanks._
import java.nio.file.Files
import java.nio.file.Path
import sbt.nio._
import sbt.nio.Keys._

object EmbeddedFilesGenerator extends AutoPlugin {

yurique

package app.tulz.tuplez

object TupleComposition {

  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)

}

abstract class Composition[-A, -B] {
  type Composed

yurique

package app.tulz.tuplez

object TupleComposition {

  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)

}

abstract class Composition[-A, -B] {
  type Composed

yurique

package app.tulz.tuplez

object TupleComposition {

  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)

}

abstract class Composition[-A, -B] {
  type Composed

yurique

package app.tulz.tuplez

object TupleComposition {

  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)

}

abstract class Composition[-A, -B] {
  type Composed