conductor-oss 0.61.21 → 0.61.23

package/web/.next/standalone/node_modules/sharp/dist/sharp.cjs

@@ -0,0 +1,164 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+// Inspects the runtime environment and exports the relevant sharp.node binary
+
+
+const { familySync, versionSync } = require("detect-libc");
+
+const libvips = require("./libvips.cjs");
+const pkg = require('../package.json');
+
+
+const { version } = pkg;
+
+const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = libvips;
+const runtimePlatform = runtimePlatformArch();
+
+/* node:coverage disable */
+
+let sharp;
+const errors = [];
+try {
+  sharp = require(`../src/build/Release/sharp-${runtimePlatform}-${version}.node`);
+} catch (err) {
+  errors.push(err);
+}
+if (!sharp) {
+  try {
+    sharp = require(`../src/build/Release/sharp-wasm32-${version}.node`);
+  } catch (err) {
+    errors.push(err);
+  }
+}
+if (!sharp) {
+  try {
+    switch (runtimePlatform) {
+      case "darwin-arm64":
+        sharp = require("@img/sharp-darwin-arm64/sharp.node");
+        break;
+      case "darwin-x64":
+        sharp = require("@img/sharp-darwin-x64/sharp.node");
+        break;
+      case "linux-arm":
+        sharp = require("@img/sharp-linux-arm/sharp.node");
+        break;
+      case "linux-arm64":
+        sharp = require("@img/sharp-linux-arm64/sharp.node");
+        break;
+      case "linux-ppc64":
+        sharp = require("@img/sharp-linux-ppc64/sharp.node");
+        break;
+      case "linux-riscv64":
+        sharp = require("@img/sharp-linux-riscv64/sharp.node");
+        break;
+      case "linux-s390x":
+        sharp = require("@img/sharp-linux-s390x/sharp.node");
+        break;
+      case "linux-x64":
+        sharp = require("@img/sharp-linux-x64/sharp.node");
+        break;
+      case "linuxmusl-arm64":
+        sharp = require("@img/sharp-linuxmusl-arm64/sharp.node");
+        break;
+      case "linuxmusl-x64":
+        sharp = require("@img/sharp-linuxmusl-x64/sharp.node");
+        break;
+      case "win32-arm64":
+        sharp = require("@img/sharp-win32-arm64/sharp.node");
+        break;
+      case "win32-ia32":
+        sharp = require("@img/sharp-win32-ia32/sharp.node");
+        break;
+      case "win32-x64":
+        sharp = require("@img/sharp-win32-x64/sharp.node");
+        break;
+      case "freebsd-arm64":
+      case "freebsd-x64":
+        sharp = require("@img/sharp-freebsd-wasm32/sharp.node");
+        break;
+      case "linux-wasm32":
+        sharp = require("@img/sharp-webcontainers-wasm32/sharp.node");
+        break;
+      default:
+        sharp = require("@img/sharp-wasm32/sharp.node");
+        break;
+    }
+    if (["linux-x64", "linuxmusl-x64"].includes(runtimePlatform) && !sharp._isUsingX64V2()) {
+      const err = new Error("Prebuilt binaries for Linux x64 require v2 microarchitecture");
+      err.code = "Unsupported CPU";
+      errors.push(err);
+      sharp = null;
+    }
+  } catch (err) {
+    errors.push(err);
+  }
+}
+
+if (!sharp) {
+  const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os) => runtimePlatform.startsWith(os));
+
+  const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
+  errors.forEach((err) => {
+    if (!err.code.endsWith("MODULE_NOT_FOUND")) {
+      help.push(`${err.code}: ${err.message}`);
+    }
+  });
+  const messages = errors.map((err) => err.message).join(" ");
+  help.push("Possible solutions:");
+  // Common error messages
+  if (isUnsupportedNodeRuntime()) {
+    const { found, expected } = isUnsupportedNodeRuntime();
+    help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
+  } else if (prebuiltPlatforms.includes(runtimePlatform)) {
+    const [os, cpu] = runtimePlatform.split("-");
+    const libc = os.endsWith("musl") ? " --libc=musl" : "";
+    help.push(
+      "- Ensure optional dependencies can be installed:",
+      "    npm install --include=optional sharp",
+      "- Ensure your package manager supports multi-platform installation:",
+      "    See https://sharp.pixelplumbing.com/install#cross-platform",
+      "- Add platform-specific dependencies:",
+      `    npm install --os=${os.replace("musl", "")}${libc} --cpu=${cpu} sharp`,
+    );
+  } else {
+    help.push(
+      `- Manually install libvips >= ${minimumLibvipsVersion}`,
+      "    See https://sharp.pixelplumbing.com/install#building-from-source",
+      "- Add WebAssembly-based dependencies:",
+      "    npm install sharp @img/sharp-wasm32",
+    );
+  }
+  if (isLinux && /(symbol not found|CXXABI_)/i.test(messages)) {
+    try {
+      const { config } = require(`@img/sharp-libvips-${runtimePlatform}/package`);
+      const libcFound = `${familySync()} ${versionSync()}`;
+      const libcRequires = `${config.musl ? "musl" : "glibc"} ${config.musl || config.glibc}`;
+      help.push("- Update your OS:", `    Found ${libcFound}`, `    Requires ${libcRequires}`);
+    } catch (_errEngines) {}
+  }
+  if (isLinux && /\/snap\/core[0-9]{2}/.test(messages)) {
+    help.push("- Remove the Node.js Snap, which does not support native modules", "    snap remove node");
+  }
+  if (isMacOs && /Incompatible library version/.test(messages)) {
+    help.push("- Update Homebrew:", "    brew update && brew upgrade vips");
+  }
+  if (errors.some((err) => err.code === "ERR_DLOPEN_DISABLED")) {
+    help.push("- Run Node.js without using the --no-addons flag");
+  }
+  // Link to installation docs
+  if (isWindows && /The specified procedure could not be found/.test(messages)) {
+    help.push(
+      "- Using the canvas package on Windows?",
+      "    See https://sharp.pixelplumbing.com/install#canvas-and-windows",
+      "- Check for outdated versions of sharp in the dependency tree:",
+      "    npm ls sharp",
+    );
+  }
+  help.push("- Consult the installation documentation:", "    See https://sharp.pixelplumbing.com/install");
+  throw new Error(help.join("\n"));
+}
+
+module.exports = sharp;

package/web/.next/standalone/node_modules/sharp/{lib/utility.js → dist/utility.cjs}

@@ -4,13 +4,17 @@
 */
 
 const events = require('node:events');
+
+const { availableParallelism } = require("node:os");
 const detectLibc = require('detect-libc');
 
-const is = require('./is');
-const { runtimePlatformArch } = require('./libvips');
-const sharp = require('./sharp');
+const is = require('./is.cjs');
+const libvips = require('./libvips.cjs');
+const sharp = require('./sharp.cjs');
+const pkg = require("../package.json");
+
 
-const runtimePlatform = runtimePlatformArch();
+const runtimePlatform = libvips.runtimePlatformArch();
 const libvipsVersion = sharp.libvipsVersion();
 
 /**
@@ -24,7 +28,7 @@ const format = sharp.format();
 format.heif.output.alias = ['avif', 'heic'];
 format.jpeg.output.alias = ['jpe', 'jpg'];
 format.tiff.output.alias = ['tif'];
-format.jp2k.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
+format.jp2.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
 
 /**
  * An Object containing the available interpolators and their proper values
@@ -73,7 +77,7 @@ if (!libvipsVersion.isGlobal) {
     } catch (_) {}
   }
 }
-versions.sharp = require('../package.json').version;
+versions.sharp = pkg.version;
 
 /* node:coverage ignore next 5 */
 if (versions.heif && format.heif) {
@@ -156,7 +160,7 @@ if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   sharp.concurrency(1);
 } else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {
   // Reduce default concurrency when musl thread over-subscription detected
-  sharp.concurrency(require('node:os').availableParallelism());
+  sharp.concurrency(availableParallelism());
 }
 
 /**

package/web/.next/standalone/node_modules/{semver → sharp/node_modules/semver}/classes/range.js

@@ -98,6 +98,9 @@ class Range {
   }
 
   parseRange (range) {
+    // strip build metadata so it can't bleed into the version
+    range = range.replace(BUILDSTRIPRE, '')
+
     // memoize range parsing for performance.
     // this is a very hot path, and fully deterministic.
     const memoOpts =
@@ -223,6 +226,7 @@ const debug = require('../internal/debug')
 const SemVer = require('./semver')
 const {
   safeRe: re,
+  src,
   t,
   comparatorTrimReplace,
   tildeTrimReplace,
@@ -230,6 +234,9 @@ const {
 } = require('../internal/re')
 const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')
 
+// unbounded global build-metadata stripper used by parseRange
+const BUILDSTRIPRE = new RegExp(src[t.BUILD], 'g')
+
 const isNullSet = c => c.value === '<0.0.0-0'
 const isAny = c => c.value === ''
 
@@ -270,6 +277,11 @@ const parseComparator = (comp, options) => {
 
 const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
 
+const invalidXRangeOrder = (M, m, p) => (
+  (isX(M) && !isX(m)) ||
+  (isX(m) && p && !isX(p))
+)
+
 // ~, ~> --> * (any, kinda silly)
 // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
 // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
@@ -287,6 +299,10 @@ const replaceTildes = (comp, options) => {
 
 const replaceTilde = (comp, options) => {
   const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  // if we're including prereleases in the match, then the lower bound is
+  // -0, the lowest possible prerelease value, just like x-ranges and carets.
+  // this keeps `~1.2` equivalent to the `1.2.x` x-range it's documented as.
+  const z = options.includePrerelease ? '-0' : ''
   return comp.replace(r, (_, M, m, p, pr) => {
     debug('tilde', comp, _, M, m, p, pr)
     let ret
@@ -294,10 +310,10 @@ const replaceTilde = (comp, options) => {
     if (isX(M)) {
       ret = ''
     } else if (isX(m)) {
-      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
     } else if (isX(p)) {
       // ~1.2 == >=1.2.0 <1.3.0-0
-      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+      ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
     } else if (pr) {
       debug('replaceTilde pr', pr)
       ret = `>=${M}.${m}.${p}-${pr
@@ -366,10 +382,10 @@ const replaceCaret = (comp, options) => {
       if (M === '0') {
         if (m === '0') {
           ret = `>=${M}.${m}.${p
-          }${z} <${M}.${m}.${+p + 1}-0`
+          } <${M}.${m}.${+p + 1}-0`
         } else {
           ret = `>=${M}.${m}.${p
-          }${z} <${M}.${+m + 1}.0-0`
+          } <${M}.${+m + 1}.0-0`
         }
       } else {
         ret = `>=${M}.${m}.${p
@@ -395,6 +411,10 @@ const replaceXRange = (comp, options) => {
   const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
   return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
     debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    if (invalidXRangeOrder(M, m, p)) {
+      return comp
+    }
+
     const xM = isX(M)
     const xm = xM || isX(m)
     const xp = xm || isX(p)

package/web/.next/standalone/node_modules/{semver → sharp/node_modules/semver}/classes/semver.js

@@ -6,6 +6,22 @@ const { safeRe: re, t } = require('../internal/re')
 
 const parseOptions = require('../internal/parse-options')
 const { compareIdentifiers } = require('../internal/identifiers')
+
+const isPrereleaseIdentifier = (prerelease, identifier) => {
+  const identifiers = identifier.split('.')
+  if (identifiers.length > prerelease.length) {
+    return false
+  }
+
+  for (let i = 0; i < identifiers.length; i++) {
+    if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+      return false
+    }
+  }
+
+  return true
+}
+
 class SemVer {
   constructor (version, options) {
     options = parseOptions(options)
@@ -309,8 +325,9 @@ class SemVer {
           if (identifierBase === false) {
             prerelease = [identifier]
           }
-          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-            if (isNaN(this.prerelease[1])) {
+          if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+            const prereleaseBase = this.prerelease[identifier.split('.').length]
+            if (isNaN(prereleaseBase)) {
               this.prerelease = prerelease
             }
           } else {

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/clean.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const clean = (version, options) => {
+  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+module.exports = clean

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/compare-build.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const compareBuild = (a, b, loose) => {
+  const versionA = new SemVer(a, loose)
+  const versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+module.exports = compareBuild

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/compare-loose.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const compareLoose = (a, b) => compare(a, b, true)
+module.exports = compareLoose

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/diff.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const parse = require('./parse.js')
+
+const diff = (version1, version2) => {
+  const v1 = parse(version1, null, true)
+  const v2 = parse(version2, null, true)
+  const comparison = v1.compare(v2)
+
+  if (comparison === 0) {
+    return null
+  }
+
+  const v1Higher = comparison > 0
+  const highVersion = v1Higher ? v1 : v2
+  const lowVersion = v1Higher ? v2 : v1
+  const highHasPre = !!highVersion.prerelease.length
+  const lowHasPre = !!lowVersion.prerelease.length
+
+  if (lowHasPre && !highHasPre) {
+    // Going from prerelease -> no prerelease requires some special casing
+
+    // If the low version has only a major, then it will always be a major
+    // Some examples:
+    // 1.0.0-1 -> 1.0.0
+    // 1.0.0-1 -> 1.1.1
+    // 1.0.0-1 -> 2.0.0
+    if (!lowVersion.patch && !lowVersion.minor) {
+      return 'major'
+    }
+
+    // If the main part has no difference
+    if (lowVersion.compareMain(highVersion) === 0) {
+      if (lowVersion.minor && !lowVersion.patch) {
+        return 'minor'
+      }
+      return 'patch'
+    }
+  }
+
+  // add the `pre` prefix if we are going to a prerelease version
+  const prefix = highHasPre ? 'pre' : ''
+
+  if (v1.major !== v2.major) {
+    return prefix + 'major'
+  }
+
+  if (v1.minor !== v2.minor) {
+    return prefix + 'minor'
+  }
+
+  if (v1.patch !== v2.patch) {
+    return prefix + 'patch'
+  }
+
+  // high and low are prereleases
+  return 'prerelease'
+}
+
+module.exports = diff

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/inc.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+
+const inc = (version, release, options, identifier, identifierBase) => {
+  if (typeof (options) === 'string') {
+    identifierBase = identifier
+    identifier = options
+    options = undefined
+  }
+
+  try {
+    return new SemVer(
+      version instanceof SemVer ? version.version : version,
+      options
+    ).inc(release, identifier, identifierBase).version
+  } catch (er) {
+    return null
+  }
+}
+module.exports = inc

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/major.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const major = (a, loose) => new SemVer(a, loose).major
+module.exports = major

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/minor.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const minor = (a, loose) => new SemVer(a, loose).minor
+module.exports = minor

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/patch.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const patch = (a, loose) => new SemVer(a, loose).patch
+module.exports = patch

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/prerelease.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const prerelease = (version, options) => {
+  const parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+module.exports = prerelease

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/rcompare.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const rcompare = (a, b, loose) => compare(b, a, loose)
+module.exports = rcompare

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/rsort.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compareBuild = require('./compare-build')
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
+module.exports = rsort

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/sort.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compareBuild = require('./compare-build')
+const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
+module.exports = sort

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/truncate.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const parse = require('./parse')
+const constants = require('../internal/constants')
+const SemVer = require('../classes/semver')
+
+const truncate = (version, truncation, options) => {
+  if (!constants.RELEASE_TYPES.includes(truncation)) {
+    return null
+  }
+
+  const clonedVersion = cloneInputVersion(version, options)
+  return clonedVersion && doTruncation(clonedVersion, truncation)
+}
+
+const cloneInputVersion = (version, options) => {
+  const versionStringToParse = (
+    version instanceof SemVer ? version.version : version
+  )
+
+  return parse(versionStringToParse, options)
+}
+
+const doTruncation = (version, truncation) => {
+  if (isPrerelease(truncation)) {
+    return version.version
+  }
+
+  version.prerelease = []
+
+  switch (truncation) {
+    case 'major':
+      version.minor = 0
+      version.patch = 0
+      break
+    case 'minor':
+      version.patch = 0
+      break
+  }
+
+  return version.format()
+}
+
+const isPrerelease = (type) => {
+  return type.startsWith('pre')
+}
+
+module.exports = truncate

package/web/.next/standalone/node_modules/sharp/node_modules/semver/functions/valid.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const valid = (version, options) => {
+  const v = parse(version, options)
+  return v ? v.version : null
+}
+module.exports = valid

package/web/.next/standalone/node_modules/sharp/node_modules/semver/index.js

@@ -0,0 +1,93 @@
+'use strict'
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = require('./internal/re')
+const constants = require('./internal/constants')
+const SemVer = require('./classes/semver')
+const identifiers = require('./internal/identifiers')
+const parse = require('./functions/parse')
+const valid = require('./functions/valid')
+const clean = require('./functions/clean')
+const inc = require('./functions/inc')
+const diff = require('./functions/diff')
+const major = require('./functions/major')
+const minor = require('./functions/minor')
+const patch = require('./functions/patch')
+const prerelease = require('./functions/prerelease')
+const compare = require('./functions/compare')
+const rcompare = require('./functions/rcompare')
+const compareLoose = require('./functions/compare-loose')
+const compareBuild = require('./functions/compare-build')
+const sort = require('./functions/sort')
+const rsort = require('./functions/rsort')
+const gt = require('./functions/gt')
+const lt = require('./functions/lt')
+const eq = require('./functions/eq')
+const neq = require('./functions/neq')
+const gte = require('./functions/gte')
+const lte = require('./functions/lte')
+const cmp = require('./functions/cmp')
+const coerce = require('./functions/coerce')
+const truncate = require('./functions/truncate')
+const Comparator = require('./classes/comparator')
+const Range = require('./classes/range')
+const satisfies = require('./functions/satisfies')
+const toComparators = require('./ranges/to-comparators')
+const maxSatisfying = require('./ranges/max-satisfying')
+const minSatisfying = require('./ranges/min-satisfying')
+const minVersion = require('./ranges/min-version')
+const validRange = require('./ranges/valid')
+const outside = require('./ranges/outside')
+const gtr = require('./ranges/gtr')
+const ltr = require('./ranges/ltr')
+const intersects = require('./ranges/intersects')
+const simplifyRange = require('./ranges/simplify')
+const subset = require('./ranges/subset')
+module.exports = {
+  parse,
+  valid,
+  clean,
+  inc,
+  diff,
+  major,
+  minor,
+  patch,
+  prerelease,
+  compare,
+  rcompare,
+  compareLoose,
+  compareBuild,
+  sort,
+  rsort,
+  gt,
+  lt,
+  eq,
+  neq,
+  gte,
+  lte,
+  cmp,
+  coerce,
+  truncate,
+  Comparator,
+  Range,
+  satisfies,
+  toComparators,
+  maxSatisfying,
+  minSatisfying,
+  minVersion,
+  validRange,
+  outside,
+  gtr,
+  ltr,
+  intersects,
+  simplifyRange,
+  subset,
+  SemVer,
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+}

package/web/.next/standalone/node_modules/{semver → sharp/node_modules/semver}/internal/re.js

@@ -136,7 +136,7 @@ createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
 createToken('GTLT', '((?:<|>)?=?)')
 
 // Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Note that "x.x" is a valid xRange identifier, meaning "any version"
 // Only the first item is strictly required.
 createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
 createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)