Upload 6 files

Dockerfile

@@ -0,0 +1,21 @@
+# Menggunakan image Node.js yang lebih stabil
+FROM node:16-slim
+
+
+# Tentukan direktori kerja di dalam container
+WORKDIR /app
+
+# Salin file package.json dan package-lock.json terlebih dahulu
+COPY package*.json ./
+
+# Install dependensi Node.js
+RUN npm install
+
+# Salin seluruh kode aplikasi ke dalam container
+COPY . .
+
+# Ekspose port 3000 yang akan digunakan aplikasi Express
+EXPOSE 3000
+
+# Tentukan perintah untuk menjalankan aplikasi Express.js
+CMD ["npm", "start"]

extract-colors.js

@@ -0,0 +1,329 @@
+class Color {
+  constructor(red, green, blue, hex = red << 16 | green << 8 | blue) {
+    this._count = 1
+    this.__saturation = -1
+    this.__hue = -1
+    this.__lightness = -1
+    this.__intensity = -1
+    this._red = red
+    this._green = green
+    this._blue = blue
+    this._hex = hex
+  }
+  static distance(colorA, colorB) {
+    return (Math.abs(colorB._red - colorA._red) + Math.abs(colorB._green - colorA._green) + Math.abs(colorB._blue - colorA._blue)) / (3 * 255)
+  }
+  updateHSL() {
+    const red = this._red / 255
+    const green = this._green / 255
+    const blue = this._blue / 255
+    const max = Math.max(red, green, blue)
+    const min = Math.min(red, green, blue)
+    this.__lightness = (max + min) / 2
+    if (max === min) {
+      this.__hue = 0
+      this.__saturation = 0
+      this.__intensity = 0
+    } else {
+      const distance2 = max - min
+      this.__saturation = this.__lightness > 0.5 ? distance2 / (2 - max - min) : distance2 / (max + min)
+      this.__intensity = this.__saturation * ((0.5 - Math.abs(0.5 - this.__lightness)) * 2)
+      switch (max) {
+        case red:
+          this.__hue = ((green - blue) / distance2 + (green < blue ? 6 : 0)) / 6
+          break
+        case green:
+          this.__hue = ((blue - red) / distance2 + 2) / 6
+          break
+        case blue:
+          this.__hue = ((red - green) / distance2 + 4) / 6
+          break
+      }
+    }
+  }
+  get _hue() {
+    if (this.__hue === -1) {
+      this.updateHSL()
+    }
+    return this.__hue
+  }
+  get _saturation() {
+    if (this.__saturation === -1) {
+      this.updateHSL()
+    }
+    return this.__saturation
+  }
+  get _lightness() {
+    if (this.__lightness === -1) {
+      this.updateHSL()
+    }
+    return this.__lightness
+  }
+  get _intensity() {
+    if (this.__intensity === -1) {
+      this.updateHSL()
+    }
+    return this.__intensity
+  }
+}
+const distance = (a, b) => Math.abs(a - b)
+const hueDistance = (a, b) => Math.min(distance(a, b), distance((a + 0.5) % 1, (b + 0.5) % 1))
+class AverageGroup {
+  constructor() {
+    this.colors = []
+    this._average = null
+  }
+  addColor(color) {
+    this.colors.push(color)
+    this._average = null
+  }
+  isSamePalette(color, hue, saturation, lightness) {
+    for (let i = 0; i < this.colors.length; i++) {
+      const currentColor = this.colors[i]
+      const isSame = hueDistance(currentColor._hue, color._hue) < hue && distance(currentColor._saturation, color._saturation) < saturation && distance(currentColor._lightness, color._lightness) < lightness
+      if (!isSame) {
+        return false
+      }
+    }
+    return true
+  }
+  get average() {
+    if (!this._average) {
+      const { r, g, b } = this.colors.reduce((total2, color) => {
+        total2.r += color._red
+        total2.g += color._green
+        total2.b += color._blue
+        return total2
+      }, { r: 0, g: 0, b: 0 })
+      const total = this.colors.reduce((_count, color) => _count + color._count, 0)
+      this._average = new Color(
+        Math.round(r / this.colors.length),
+        Math.round(g / this.colors.length),
+        Math.round(b / this.colors.length)
+      )
+      this._average._count = total
+    }
+    return this._average
+  }
+}
+class AverageManager {
+  constructor(hue, saturation, lightness) {
+    this._groups = []
+    this._hue = hue
+    this._saturation = saturation
+    this._lightness = lightness
+  }
+  addColor(color) {
+    const samePalette = this._groups.find((averageGroup) => averageGroup.isSamePalette(color, this._hue, this._saturation, this._lightness))
+    if (samePalette) {
+      samePalette.addColor(color)
+    } else {
+      const averageGroup = new AverageGroup()
+      averageGroup.addColor(color)
+      this._groups.push(averageGroup)
+    }
+  }
+  getGroups() {
+    return this._groups.map((averageGroup) => averageGroup.average)
+  }
+}
+var sortColors = (list, _pixels, _hueDistance, _saturationDistance, _lightnessDistance) => {
+  const averageManager = new AverageManager(_hueDistance, _saturationDistance, _lightnessDistance)
+  list.forEach((color) => averageManager.addColor(color))
+  const sorted = averageManager.getGroups()
+  sorted.sort((a, b) => {
+    const bPower = (b._intensity + 0.1) * (0.9 - b._count / _pixels)
+    const aPower = (a._intensity + 0.1) * (0.9 - a._count / _pixels)
+    return bPower - aPower
+  })
+  return sorted
+}
+const createFinalColor = (color, pixels) => {
+  return {
+    hex: `#${'0'.repeat(6 - color._hex.toString(16).length)}${color._hex.toString(16)}`,
+    red: color._red,
+    green: color._green,
+    blue: color._blue,
+    area: color._count / pixels,
+    hue: color._hue,
+    saturation: color._saturation,
+    lightness: color._lightness,
+    intensity: color._intensity
+  }
+}
+const testUint = (label, val, min = 0, max = Number.MAX_SAFE_INTEGER) => {
+  if (!Number.isInteger(val) || val < min || val > max) {
+    throw new Error(`${label} is invalid (${val})`)
+  }
+  return val
+}
+const testNumber = (label, val, min = 0, max = Number.MAX_VALUE) => {
+  if (Number(val) !== val || val < min || val > max) {
+    throw new Error(`${label} is invalid (${val})`)
+  }
+  return val
+}
+const testFunction = (label, val) => {
+  if (!val || {}.toString.call(val) !== '[object Function]') {
+    throw new Error(`${label} is invalid (${val})`)
+  }
+  return val
+}
+var cleanInputs = (options) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h
+  return [
+    testUint('pixels', (_a = options.pixels) != null ? _a : 1e4, 1),
+    testNumber('distance', (_b = options.distance) != null ? _b : 0.12, 0, 1),
+    testUint('splitPower', (_c = options.splitPower) != null ? _c : 10, 2, 15),
+    testFunction('colorValidator', (_d = options.colorValidator) != null ? _d : (_red, _green, _blue, _alpha) => (_alpha != null ? _alpha : 255) > 250),
+    testNumber('hueDistance', (_e = options.hueDistance) != null ? _e : 0.08333333333333333, 0, 1),
+    testNumber('saturationDistance', (_f = options.saturationDistance) != null ? _f : 0.2, 0, 1),
+    testNumber('lightnessDistance', (_g = options.lightnessDistance) != null ? _g : 0.2, 0, 1),
+    (_h = options.crossOrigin) != null ? _h : null
+  ]
+}
+class BudGroup {
+  constructor() {
+    this._count = 1
+    this._children = {}
+  }
+  addColor(_hex, _red, _green, _blue) {
+    if (this._children[_hex]) {
+      this._children[_hex]._count++
+    } else {
+      this._children[_hex] = new Color(_red, _green, _blue, _hex)
+    }
+    return this._children[_hex]
+  }
+  getList() {
+    return Object.keys(this._children).map((key) => this._children[key])
+  }
+  getMaxWeight(_count) {
+    if (this._maxWeight === void 0) {
+      const list = this.getList().map((child) => child._count / _count)
+      list.sort((a, b) => b - a)
+      this._maxWeight = list[0] || 0
+    }
+    return this._maxWeight
+  }
+  getMaxWeightColor(_count) {
+    const list = this.getList()
+    list.sort((a, b) => {
+      return b._count / _count - a._count / _count
+    })
+    return list[0]
+  }
+  getMaxCountColor() {
+    const list = this.getList()
+    const biggest = list.reduce((a, b) => a._count >= b._count ? a : b)
+    return biggest
+  }
+}
+class RootGroup {
+  constructor() {
+    this._count = 1
+    this._children = {}
+  }
+  addRootGroup(key) {
+    if (this._children[key]) {
+      this._children[key]._count++
+    } else {
+      this._children[key] = new RootGroup()
+    }
+    return this._children[key]
+  }
+  getList() {
+    return Object.keys(this._children).map((key) => this._children[key])
+  }
+  addBudGroup(key) {
+    if (this._children[key]) {
+      this._children[key]._count++
+    } else {
+      this._children[key] = new BudGroup()
+    }
+    return this._children[key]
+  }
+  getMaxWeight(_count) {
+    if (this._maxWeight === void 0) {
+      const list = this.getList().map((child) => child._count / _count)
+      list.sort((a, b) => b - a)
+      this._maxWeight = list[0] || 0
+    }
+    return this._maxWeight
+  }
+  getMaxWeightColor(_count) {
+    const list = this.getList()
+    list.sort((a, b) => {
+      return b._count / _count - a._count / _count
+    })
+    return list[0].getMaxWeightColor(_count)
+  }
+  getMaxCountColor() {
+    const list = this.getList()
+    const biggest = list.reduce((a, b) => a.getMaxCountColor()._count >= b.getMaxCountColor()._count ? a : b)
+    return biggest.getMaxCountColor()
+  }
+  getColors(_distance, _count) {
+    const list = this.getList().map((child) => {
+      const { _count: _count2 } = child
+      const color = child.getMaxCountColor()
+      color._count = _count2
+      return color
+    })
+    list.sort((a, b) => b._count / _count - a._count / _count)
+    const newList = []
+    list.forEach((color) => {
+      const near = newList.find((col) => Color.distance(col, color) < _distance)
+      if (!near) {
+        newList.push(color)
+      } else {
+        near._count += color._count
+      }
+    })
+    return newList
+  }
+}
+var extractor = ({ data, width, height }, _pixels, _distance, _splitPower, _colorValidator) => {
+  const rootGroup = new RootGroup()
+  const reducer = width && height ? Math.floor(width * height / _pixels) || 1 : 1
+  for (let i = 0; i < data.length; i += 4 * reducer) {
+    const r = data[i]
+    const g = data[i + 1]
+    const b = data[i + 2]
+    const a = data[i + 3]
+    if (_colorValidator(r, g, b, a)) {
+      const real = r << 16 | g << 8 | b
+      const medium = (r >> 4 & 15) << 2 | (g >> 4 & 15) << 1 | b >> 4 & 15
+      const small = Math.round(r * (_splitPower - 1) / 255) * (_splitPower * _splitPower) + Math.round(g * (_splitPower - 1) / 255) * _splitPower + Math.round(b * (_splitPower - 1) / 255)
+      const smallGroup = rootGroup.addRootGroup(small)
+      const mediumGroup = smallGroup.addBudGroup(medium)
+      mediumGroup.addColor(real, r, g, b)
+    }
+  }
+  return rootGroup.getColors(_distance, _pixels)
+}
+const sortFinalColors = (_colors, _pixels, _hueDistance, _saturationDistance, _lightnessDistance) => {
+  const list = sortColors(_colors, _pixels, _hueDistance, _saturationDistance, _lightnessDistance)
+  return list.map((color) => createFinalColor(color, _pixels))
+}
+const extractColorsFromImageData = (imageData, options = {}) => {
+  const [_pixels, _distance, _splitPower, _colorValidator, _hueDistance, _saturationDistance, _lightnessDistance] = cleanInputs(options)
+  const colors = extractor(imageData, _pixels, _distance, _splitPower, _colorValidator)
+  const px = imageData.width && imageData.height ? Math.min(imageData.width * imageData.height, _pixels) : _pixels
+  return sortFinalColors(colors, px, _hueDistance, _saturationDistance, _lightnessDistance)
+}
+const extractColors = (imageData, options) => {
+  if (imageData.data) {
+    return new Promise((resolve) => {
+      resolve(extractColorsFromImageData(imageData, options))
+    })
+  }
+  throw new Error('Send imageData to extractColors')
+}
+const extractColorsFromImage = () => {
+  throw new Error('Can not use extractColorsFromImage for Node.js')
+}
+const extractColorsFromSrc = () => {
+  throw new Error('Can not use extractColorsFromSrc for Node.js')
+}
+export { extractColors as default, extractColors, extractColorsFromImage, extractColorsFromImageData, extractColorsFromSrc }

fast-average-color.js

@@ -0,0 +1,510 @@
+/*! Fast Average Color | © 2022 Denis Seleznev | MIT License | https://github.com/fast-average-color/fast-average-color */
+function toHex(num) {
+	let str = num.toString(16)
+	return str.length === 1 ? '0' + str : str
+}
+function arrayToHex(arr) {
+	return '#' + arr.map(toHex).join('')
+}
+function isDark(color) {
+	// http://www.w3.org/TR/AERT#color-contrast
+	let result = (color[0] * 299 + color[1] * 587 + color[2] * 114) / 1000
+	return result < 128
+}
+function prepareIgnoredColor(color) {
+	if (!color) {
+		return []
+	}
+	return isRGBArray(color) ? color : [color]
+}
+function isRGBArray(value) {
+	return Array.isArray(value[0])
+}
+function isIgnoredColor(data, index, ignoredColor) {
+	for (let i = 0; i < ignoredColor.length; i++) {
+		if (isIgnoredColorAsNumbers(data, index, ignoredColor[i])) {
+			return true
+		}
+	}
+	return false
+}
+function isIgnoredColorAsNumbers(data, index, ignoredColor) {
+	switch (ignoredColor.length) {
+		case 3:
+			// [red, green, blue]
+			if (isIgnoredRGBColor(data, index, ignoredColor)) {
+				return true
+			}
+			break
+		case 4:
+			// [red, green, blue, alpha]
+			if (isIgnoredRGBAColor(data, index, ignoredColor)) {
+				return true
+			}
+			break
+		case 5:
+			// [red, green, blue, alpha, threshold]
+			if (isIgnoredRGBAColorWithThreshold(data, index, ignoredColor)) {
+				return true
+			}
+			break
+		default:
+			return false
+	}
+}
+function isIgnoredRGBColor(data, index, ignoredColor) {
+	// Ignore if the pixel are transparent.
+	if (data[index + 3] !== 255) {
+		return true
+	}
+	if (data[index] === ignoredColor[0] &&
+		data[index + 1] === ignoredColor[1] &&
+		data[index + 2] === ignoredColor[2]) {
+		return true
+	}
+	return false
+}
+function isIgnoredRGBAColor(data, index, ignoredColor) {
+	if (data[index + 3] && ignoredColor[3]) {
+		return data[index] === ignoredColor[0] &&
+			data[index + 1] === ignoredColor[1] &&
+			data[index + 2] === ignoredColor[2] &&
+			data[index + 3] === ignoredColor[3]
+	}
+	// Ignore rgb components if the pixel are fully transparent.
+	return data[index + 3] === ignoredColor[3]
+}
+function inRange(colorComponent, ignoredColorComponent, value) {
+	return colorComponent >= (ignoredColorComponent - value) &&
+		colorComponent <= (ignoredColorComponent + value)
+}
+function isIgnoredRGBAColorWithThreshold(data, index, ignoredColor) {
+	let redIgnored = ignoredColor[0]
+	let greenIgnored = ignoredColor[1]
+	let blueIgnored = ignoredColor[2]
+	let alphaIgnored = ignoredColor[3]
+	let threshold = ignoredColor[4]
+	let alphaData = data[index + 3]
+	let alphaInRange = inRange(alphaData, alphaIgnored, threshold)
+	if (!alphaIgnored) {
+		return alphaInRange
+	}
+	if (!alphaData && alphaInRange) {
+		return true
+	}
+	if (inRange(data[index], redIgnored, threshold) &&
+		inRange(data[index + 1], greenIgnored, threshold) &&
+		inRange(data[index + 2], blueIgnored, threshold) &&
+		alphaInRange) {
+		return true
+	}
+	return false
+}
+
+function dominantAlgorithm(arr, len, options) {
+	let colorHash = {}
+	let divider = 24
+	let ignoredColor = options.ignoredColor
+	let step = options.step
+	let max = [0, 0, 0, 0, 0]
+	for (let i = 0; i < len; i += step) {
+		let red = arr[i]
+		let green = arr[i + 1]
+		let blue = arr[i + 2]
+		let alpha = arr[i + 3]
+		if (ignoredColor && isIgnoredColor(arr, i, ignoredColor)) {
+			continue
+		}
+		let key = Math.round(red / divider) + ',' +
+			Math.round(green / divider) + ',' +
+			Math.round(blue / divider)
+		if (colorHash[key]) {
+			colorHash[key] = [
+				colorHash[key][0] + red * alpha,
+				colorHash[key][1] + green * alpha,
+				colorHash[key][2] + blue * alpha,
+				colorHash[key][3] + alpha,
+				colorHash[key][4] + 1
+			]
+		}
+		else {
+			colorHash[key] = [red * alpha, green * alpha, blue * alpha, alpha, 1]
+		}
+		if (max[4] < colorHash[key][4]) {
+			max = colorHash[key]
+		}
+	}
+	let redTotal = max[0]
+	let greenTotal = max[1]
+	let blueTotal = max[2]
+	let alphaTotal = max[3]
+	let count = max[4]
+	return alphaTotal ? [
+		Math.round(redTotal / alphaTotal),
+		Math.round(greenTotal / alphaTotal),
+		Math.round(blueTotal / alphaTotal),
+		Math.round(alphaTotal / count)
+	] : options.defaultColor
+}
+
+function simpleAlgorithm(arr, len, options) {
+	let redTotal = 0
+	let greenTotal = 0
+	let blueTotal = 0
+	let alphaTotal = 0
+	let count = 0
+	let ignoredColor = options.ignoredColor
+	let step = options.step
+	for (let i = 0; i < len; i += step) {
+		let alpha = arr[i + 3]
+		let red = arr[i] * alpha
+		let green = arr[i + 1] * alpha
+		let blue = arr[i + 2] * alpha
+		if (ignoredColor && isIgnoredColor(arr, i, ignoredColor)) {
+			continue
+		}
+		redTotal += red
+		greenTotal += green
+		blueTotal += blue
+		alphaTotal += alpha
+		count++
+	}
+	return alphaTotal ? [
+		Math.round(redTotal / alphaTotal),
+		Math.round(greenTotal / alphaTotal),
+		Math.round(blueTotal / alphaTotal),
+		Math.round(alphaTotal / count)
+	] : options.defaultColor
+}
+
+function sqrtAlgorithm(arr, len, options) {
+	let redTotal = 0
+	let greenTotal = 0
+	let blueTotal = 0
+	let alphaTotal = 0
+	let count = 0
+	let ignoredColor = options.ignoredColor
+	let step = options.step
+	for (let i = 0; i < len; i += step) {
+		let red = arr[i]
+		let green = arr[i + 1]
+		let blue = arr[i + 2]
+		let alpha = arr[i + 3]
+		if (ignoredColor && isIgnoredColor(arr, i, ignoredColor)) {
+			continue
+		}
+		redTotal += red * red * alpha
+		greenTotal += green * green * alpha
+		blueTotal += blue * blue * alpha
+		alphaTotal += alpha
+		count++
+	}
+	return alphaTotal ? [
+		Math.round(Math.sqrt(redTotal / alphaTotal)),
+		Math.round(Math.sqrt(greenTotal / alphaTotal)),
+		Math.round(Math.sqrt(blueTotal / alphaTotal)),
+		Math.round(alphaTotal / count)
+	] : options.defaultColor
+}
+
+function getDefaultColor(options) {
+	return getOption(options, 'defaultColor', [0, 0, 0, 0])
+}
+function getOption(options, name, defaultValue) {
+	return (options[name] === undefined ? defaultValue : options[name])
+}
+
+let MIN_SIZE = 10
+let MAX_SIZE = 100
+function isSvg(filename) {
+	return filename.search(/\.svg(\?|$)/i) !== -1
+}
+function getOriginalSize(resource) {
+	if (isInstanceOfHTMLImageElement(resource)) {
+		let width = resource.naturalWidth
+		let height = resource.naturalHeight
+		// For SVG images with only viewBox attribute
+		if (!resource.naturalWidth && isSvg(resource.src)) {
+			width = height = MAX_SIZE
+		}
+		return {
+			width: width,
+			height: height,
+		}
+	}
+	if (isInstanceOfHTMLVideoElement(resource)) {
+		return {
+			width: resource.videoWidth,
+			height: resource.videoHeight
+		}
+	}
+	return {
+		width: resource.width,
+		height: resource.height
+	}
+}
+function getSrc(resource) {
+	if (isInstanceOfHTMLCanvasElement(resource)) {
+		return 'canvas'
+	}
+	if (isInstanceOfOffscreenCanvas(resource)) {
+		return 'offscreencanvas'
+	}
+	if (isInstanceOfImageBitmap(resource)) {
+		return 'imagebitmap'
+	}
+	return resource.src
+}
+function isInstanceOfHTMLImageElement(resource) {
+	return typeof HTMLImageElement !== 'undefined' && resource instanceof HTMLImageElement
+}
+let hasOffscreenCanvas = typeof OffscreenCanvas !== 'undefined'
+function isInstanceOfOffscreenCanvas(resource) {
+	return hasOffscreenCanvas && resource instanceof OffscreenCanvas
+}
+function isInstanceOfHTMLVideoElement(resource) {
+	return typeof HTMLVideoElement !== 'undefined' && resource instanceof HTMLVideoElement
+}
+function isInstanceOfHTMLCanvasElement(resource) {
+	return typeof HTMLCanvasElement !== 'undefined' && resource instanceof HTMLCanvasElement
+}
+function isInstanceOfImageBitmap(resource) {
+	return typeof ImageBitmap !== 'undefined' && resource instanceof ImageBitmap
+}
+function prepareSizeAndPosition(originalSize, options) {
+	let srcLeft = getOption(options, 'left', 0)
+	let srcTop = getOption(options, 'top', 0)
+	let srcWidth = getOption(options, 'width', originalSize.width)
+	let srcHeight = getOption(options, 'height', originalSize.height)
+	let destWidth = srcWidth
+	let destHeight = srcHeight
+	if (options.mode === 'precision') {
+		return {
+			srcLeft: srcLeft,
+			srcTop: srcTop,
+			srcWidth: srcWidth,
+			srcHeight: srcHeight,
+			destWidth: destWidth,
+			destHeight: destHeight
+		}
+	}
+	let factor
+	if (srcWidth > srcHeight) {
+		factor = srcWidth / srcHeight
+		destWidth = MAX_SIZE
+		destHeight = Math.round(destWidth / factor)
+	}
+	else {
+		factor = srcHeight / srcWidth
+		destHeight = MAX_SIZE
+		destWidth = Math.round(destHeight / factor)
+	}
+	if (destWidth > srcWidth || destHeight > srcHeight ||
+		destWidth < MIN_SIZE || destHeight < MIN_SIZE) {
+		destWidth = srcWidth
+		destHeight = srcHeight
+	}
+	return {
+		srcLeft: srcLeft,
+		srcTop: srcTop,
+		srcWidth: srcWidth,
+		srcHeight: srcHeight,
+		destWidth: destWidth,
+		destHeight: destHeight
+	}
+}
+let isWebWorkers = typeof window === 'undefined'
+function makeCanvas() {
+	if (isWebWorkers) {
+		return hasOffscreenCanvas ? new OffscreenCanvas(1, 1) : null
+	}
+	return document.createElement('canvas')
+}
+
+let ERROR_PREFIX = 'FastAverageColor: '
+function getError(message) {
+	return Error(ERROR_PREFIX + message)
+}
+function outputError(error, silent) {
+	if (!silent) {
+		console.error(error)
+	}
+}
+
+let FastAverageColor = /** @class */ (function () {
+	function FastAverageColor() {
+		this.canvas = null
+		this.ctx = null
+	}
+	/**
+	 * Get asynchronously the average color from not loaded image.
+	 */
+	FastAverageColor.prototype.getColorAsync = function (resource, options) {
+		if (!resource) {
+			return Promise.reject(getError('call .getColorAsync() without resource.'))
+		}
+		if (typeof resource === 'string') {
+			// Web workers
+			if (typeof Image === 'undefined') {
+				return Promise.reject(getError('resource as string is not supported in this environment'))
+			}
+			let img = new Image()
+			img.crossOrigin = options && options.crossOrigin || ''
+			img.src = resource
+			return this.bindImageEvents(img, options)
+		}
+		else if (isInstanceOfHTMLImageElement(resource) && !resource.complete) {
+			return this.bindImageEvents(resource, options)
+		}
+		else {
+			let result = this.getColor(resource, options)
+			return result.error ? Promise.reject(result.error) : Promise.resolve(result)
+		}
+	}
+	/**
+	 * Get the average color from images, videos and canvas.
+	 */
+	FastAverageColor.prototype.getColor = function (resource, options) {
+		options = options || {}
+		let defaultColor = getDefaultColor(options)
+		if (!resource) {
+			let error = getError('call .getColor(null) without resource')
+			outputError(error, options.silent)
+			return this.prepareResult(defaultColor, error)
+		}
+		let originalSize = getOriginalSize(resource)
+		let size = prepareSizeAndPosition(originalSize, options)
+		if (!size.srcWidth || !size.srcHeight || !size.destWidth || !size.destHeight) {
+			let error = getError("incorrect sizes for resource \"".concat(getSrc(resource), "\""))
+			outputError(error, options.silent)
+			return this.prepareResult(defaultColor, error)
+		}
+		if (!this.canvas) {
+			this.canvas = makeCanvas()
+			if (!this.canvas) {
+				let error = getError('OffscreenCanvas is not supported in this browser')
+				outputError(error, options.silent)
+				return this.prepareResult(defaultColor, error)
+			}
+		}
+		if (!this.ctx) {
+			this.ctx = this.canvas.getContext('2d', { willReadFrequently: true })
+			if (!this.ctx) {
+				let error = getError('Canvas Context 2D is not supported in this browser')
+				outputError(error, options.silent)
+				return this.prepareResult(defaultColor)
+			}
+			this.ctx.imageSmoothingEnabled = false
+		}
+		this.canvas.width = size.destWidth
+		this.canvas.height = size.destHeight
+		try {
+			this.ctx.clearRect(0, 0, size.destWidth, size.destHeight)
+			this.ctx.drawImage(resource, size.srcLeft, size.srcTop, size.srcWidth, size.srcHeight, 0, 0, size.destWidth, size.destHeight)
+			let bitmapData = this.ctx.getImageData(0, 0, size.destWidth, size.destHeight).data
+			return this.prepareResult(this.getColorFromArray4(bitmapData, options))
+		}
+		catch (originalError) {
+			let error = getError("security error (CORS) for resource ".concat(getSrc(resource), ".\nDetails: https://developer.mozilla.org/en/docs/Web/HTML/CORS_enabled_image"))
+			outputError(error, options.silent)
+			!options.silent && console.error(originalError)
+			return this.prepareResult(defaultColor, error)
+		}
+	}
+	/**
+	 * Get the average color from a array when 1 pixel is 4 bytes.
+	 */
+	FastAverageColor.prototype.getColorFromArray4 = function (arr, options) {
+		options = options || {}
+		let bytesPerPixel = 4
+		let arrLength = arr.length
+		let defaultColor = getDefaultColor(options)
+		if (arrLength < bytesPerPixel) {
+			return defaultColor
+		}
+		let len = arrLength - arrLength % bytesPerPixel
+		let step = (options.step || 1) * bytesPerPixel
+		let algorithm
+		switch (options.algorithm || 'sqrt') {
+			case 'simple':
+				algorithm = simpleAlgorithm
+				break
+			case 'sqrt':
+				algorithm = sqrtAlgorithm
+				break
+			case 'dominant':
+				algorithm = dominantAlgorithm
+				break
+			default:
+				throw getError("".concat(options.algorithm, " is unknown algorithm"))
+		}
+		return algorithm(arr, len, {
+			defaultColor: defaultColor,
+			ignoredColor: prepareIgnoredColor(options.ignoredColor),
+			step: step
+		})
+	}
+	/**
+	 * Get color data from value ([r, g, b, a]).
+	 */
+	FastAverageColor.prototype.prepareResult = function (value, error) {
+		let rgb = value.slice(0, 3)
+		let rgba = [value[0], value[1], value[2], value[3] / 255]
+		let isDarkColor = isDark(value)
+		return {
+			value: [value[0], value[1], value[2], value[3]],
+			rgb: 'rgb(' + rgb.join(',') + ')',
+			rgba: 'rgba(' + rgba.join(',') + ')',
+			hex: arrayToHex(rgb),
+			hexa: arrayToHex(value),
+			isDark: isDarkColor,
+			isLight: !isDarkColor,
+			error: error,
+		}
+	}
+	/**
+	 * Destroy the instance.
+	 */
+	FastAverageColor.prototype.destroy = function () {
+		if (this.canvas) {
+			this.canvas.width = 1
+			this.canvas.height = 1
+			this.canvas = null
+		}
+		this.ctx = null
+	}
+	FastAverageColor.prototype.bindImageEvents = function (resource, options) {
+		let _this = this
+		return new Promise(function (resolve, reject) {
+			let onload = function () {
+				unbindEvents()
+				let result = _this.getColor(resource, options)
+				if (result.error) {
+					reject(result.error)
+				}
+				else {
+					resolve(result)
+				}
+			}
+			let onerror = function () {
+				unbindEvents()
+				reject(getError("Error loading image \"".concat(resource.src, "\".")))
+			}
+			let onabort = function () {
+				unbindEvents()
+				reject(getError("Image \"".concat(resource.src, "\" loading aborted")))
+			}
+			let unbindEvents = function () {
+				resource.removeEventListener('load', onload)
+				resource.removeEventListener('error', onerror)
+				resource.removeEventListener('abort', onabort)
+			}
+			resource.addEventListener('load', onload)
+			resource.addEventListener('error', onerror)
+			resource.addEventListener('abort', onabort)
+		})
+	}
+	return FastAverageColor
+}())
+
+export default FastAverageColor

index.js

@@ -0,0 +1,94 @@
+import Koa from 'koa'
+import http from 'axios'
+import sharp from 'sharp'
+import tf from '@tensorflow/tfjs-node'
+import nsfw from 'nsfwjs'
+
+import { extractColors } from './extract-colors.js'
+import FastAverageColor from './fast-average-color.js'
+import { phash } from './phash.js'
+
+const app = new Koa()
+
+app.use(async (ctx) => {
+  const { data: image_buffer } = await http({
+    method: 'GET',
+    url: String(ctx.request.query.url).replace(
+      'i.pximg.net',
+      'i.pixiv.re',
+    ),
+    responseType: 'arraybuffer',
+  })
+  const { data: image_raw, info } = await sharp(image_buffer, {
+    animated: true,
+  })
+    .ensureAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true })
+    const image_phash = await phash(image_buffer)
+  const colors = await extractColors(
+    { data: image_raw, width: info.width, height: info.height },
+    {
+      pixels: info.width * info.height,
+      distance: 0.05,
+      splitPower: 6,
+      colorValidator: (red, green, blue, alpha = 255) => alpha >= 255,
+      hueDistance: 0,
+      saturationDistance: 1,
+      lightnessDistance: 1,
+    },
+  )
+  const fac = new FastAverageColor()
+  const {
+    value: [r, g, b, a],
+    hex,
+    isLight: blight,
+  } = fac.prepareResult(fac.getColorFromArray4(image_raw))
+  const image_resize = await sharp(image_buffer, { animated: true })
+    .resize({
+      width: 128,
+      height: 128,
+      fit: 'inside',
+    })
+    .gif({ dither: 0 })
+    .toBuffer()
+    // const model = await nsfw.load(`https://raw.githubusercontent.com/infinitered/nsfwjs/refs/heads/master/models/mobilenet_v2_mid/model.json`, { type: 'graph' })
+  //   // const model = await nsfw.load(`https://raw.githubusercontent.com/infinitered/nsfwjs/refs/heads/master/models/mobilenet_v2/model.json`)
+  //   // const model = await nsfw.load(`https://s3.amazonaws.com/ir_public/nsfwjscdn/TFJS_nsfw_mobilenet/tfjs_quant_nsfw_mobilenet/model.json`)
+  //   const model = await nsfw.load(`https://raw.githubusercontent.com/infinitered/nsfwjs/refs/heads/master/models/inception_v3/model.json`, { size: 299 })
+  const predictions = await model.classifyGif(image_resize, { fps: 1 })
+  const detail = new Map()
+  predictions
+    .flat(Infinity)
+    .sort((a, b) => a.probability - b.probability)
+    .forEach((i) => {
+      detail.set(
+        i.className.toLocaleLowerCase(),
+        Math.floor(i.probability * 100),
+      )
+    })
+    const fail = ['hentai', 'porn', 'sexy']
+  const result = [...detail]
+    .filter((i) => i.pop() > 7)
+    .some((i) => fail.includes(i.pop()))
+    tf.dispose()
+  model.model.dispose()
+  ctx.body = {
+    nsfw: Object.assign({ result }, Object.fromEntries(detail)),
+    colors: colors
+      .sort((a, b) => b.area - a.area)
+      .slice(0, 3)
+      .map((i) => {
+        // hex: `#${Number(十进制).toString(16).padStart(6, 0)}`
+        return {
+          color: parseInt(String(i.hex).replace('#', ''), 16),
+          ratio: Number(i.area.toFixed(2)),
+        }
+      }),
+    color: hex,
+    // blight,
+    phash: image_phash,
+  }
+})
+
+app.listen(process.env.PORT || 7860)

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nsfw",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@tensorflow/tfjs-node": "^4.4.0",
+    "axios": "^1.3.5",
+    "form-data": "^4.0.0",
+    "koa": "3.0.1",
+    "nsfwjs": "^2.4.2"
+  }
+}

phash.js

@@ -0,0 +1,99 @@
+import sharp from 'sharp'
+
+const SAMPLE_SIZE = 32
+
+const initSQRT = (N) => {
+  const c = new Array(N)
+  for (let i = 1; i < N; i++) {
+    c[i] = 1
+  }
+  c[0] = 1 / Math.sqrt(2.0)
+  return c
+}
+
+const SQRT = initSQRT(SAMPLE_SIZE)
+
+const initCOS = (N) => {
+  const cosines = new Array(N)
+  for (let k = 0; k < N; k++) {
+    cosines[k] = new Array(N)
+    for (let n = 0; n < N; n++) {
+      cosines[k][n] = Math.cos(((2 * k + 1) / (2.0 * N)) * n * Math.PI)
+    }
+  }
+  return cosines
+}
+
+const COS = initCOS(SAMPLE_SIZE)
+
+const applyDCT = (f, size) => {
+  var N = size
+
+  var F = new Array(N)
+  for (var u = 0; u < N; u++) {
+    F[u] = new Array(N)
+    for (var v = 0; v < N; v++) {
+      var sum = 0
+      for (var i = 0; i < N; i++) {
+        for (var j = 0; j < N; j++) {
+          sum += COS[i][u] * COS[j][v] * f[i][j]
+        }
+      }
+      sum *= (SQRT[u] * SQRT[v]) / 4
+      F[u][v] = sum
+    }
+  }
+  return F
+}
+
+const LOW_SIZE = 8
+
+export const phash = async (image, options) => {
+  const data = await sharp(image, options)
+    .greyscale()
+    .resize(SAMPLE_SIZE, SAMPLE_SIZE, { fit: 'fill' })
+    .rotate()
+    .raw()
+    .toBuffer()
+  // copy signal
+  const s = new Array(SAMPLE_SIZE)
+  for (let x = 0; x < SAMPLE_SIZE; x++) {
+    s[x] = new Array(SAMPLE_SIZE)
+    for (let y = 0; y < SAMPLE_SIZE; y++) {
+      s[x][y] = data[SAMPLE_SIZE * y + x]
+    }
+  }
+
+  // apply 2D DCT II
+  const dct = applyDCT(s, SAMPLE_SIZE)
+
+  // get AVG on high frequencies
+  let totalSum = 0
+  for (let x = 0; x < LOW_SIZE; x++) {
+    for (let y = 0; y < LOW_SIZE; y++) {
+      totalSum += dct[x + 1][y + 1]
+    }
+  }
+
+  const avg = totalSum / (LOW_SIZE * LOW_SIZE)
+
+  // compute hash
+  let fingerprint = []
+
+  for (let x = 0; x < LOW_SIZE; x++) {
+    for (let y = 0; y < LOW_SIZE; y++) {
+      fingerprint.push(dct[x + 1][y + 1] > avg ? 1 : 0)
+    }
+  }
+  return parseInt(fingerprint.join(''), 2).toString(16)
+}
+
+export const distance = (a, b) => {
+  let count = 0
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      count++
+    }
+  }
+  return count
+}