@openuiai/next 16.2.0 → 16.2.1

package/dist/fonts/font-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateSizeAdjustValues", {
+    enumerable: true,
+    get: function() {
+        return calculateSizeAdjustValues;
+    }
+});
+const _constants = require("../shared/lib/constants");
+const capsizeFontsMetrics = require('next/dist/server/capsize-font-metrics.json');
+function formatName(str) {
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+    }).replace(/\s+/g, '');
+}
+function formatOverrideValue(val) {
+    return Math.abs(val * 100).toFixed(2);
+}
+function calculateSizeAdjustValues(fontName) {
+    const fontKey = formatName(fontName);
+    const fontMetrics = capsizeFontsMetrics[fontKey];
+    let { category, ascent, descent, lineGap, unitsPerEm, xWidthAvg } = fontMetrics;
+    const mainFontAvgWidth = xWidthAvg / unitsPerEm;
+    const fallbackFont = category === 'serif' ? _constants.DEFAULT_SERIF_FONT : _constants.DEFAULT_SANS_SERIF_FONT;
+    const fallbackFontName = formatName(fallbackFont.name);
+    const fallbackFontMetrics = capsizeFontsMetrics[fallbackFontName];
+    const fallbackFontAvgWidth = fallbackFontMetrics.xWidthAvg / fallbackFontMetrics.unitsPerEm;
+    let sizeAdjust = xWidthAvg ? mainFontAvgWidth / fallbackFontAvgWidth : 1;
+    ascent = formatOverrideValue(ascent / (unitsPerEm * sizeAdjust));
+    descent = formatOverrideValue(descent / (unitsPerEm * sizeAdjust));
+    lineGap = formatOverrideValue(lineGap / (unitsPerEm * sizeAdjust));
+    return {
+        ascent,
+        descent,
+        lineGap,
+        fallbackFont: fallbackFont.name,
+        sizeAdjust: formatOverrideValue(sizeAdjust)
+    };
+}
+
+//# sourceMappingURL=font-utils.js.map

package/dist/fonts/font-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../fonts/font-utils.ts"],"sourcesContent":["import {\n  DEFAULT_SERIF_FONT,\n  DEFAULT_SANS_SERIF_FONT,\n} from '../shared/lib/constants'\nconst capsizeFontsMetrics = require('next/dist/server/capsize-font-metrics.json')\n\nfunction formatName(str: string): string {\n  return str\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, function (word, index) {\n      return index === 0 ? word.toLowerCase() : word.toUpperCase()\n    })\n    .replace(/\\s+/g, '')\n}\n\nfunction formatOverrideValue(val: number) {\n  return Math.abs(val * 100).toFixed(2)\n}\n\nexport function calculateSizeAdjustValues(fontName: string) {\n  const fontKey = formatName(fontName)\n  const fontMetrics = capsizeFontsMetrics[fontKey]\n  let { category, ascent, descent, lineGap, unitsPerEm, xWidthAvg } =\n    fontMetrics\n  const mainFontAvgWidth = xWidthAvg / unitsPerEm\n  const fallbackFont =\n    category === 'serif' ? DEFAULT_SERIF_FONT : DEFAULT_SANS_SERIF_FONT\n  const fallbackFontName = formatName(fallbackFont.name)\n  const fallbackFontMetrics = capsizeFontsMetrics[fallbackFontName]\n  const fallbackFontAvgWidth =\n    fallbackFontMetrics.xWidthAvg / fallbackFontMetrics.unitsPerEm\n  let sizeAdjust = xWidthAvg ? mainFontAvgWidth / fallbackFontAvgWidth : 1\n\n  ascent = formatOverrideValue(ascent / (unitsPerEm * sizeAdjust))\n  descent = formatOverrideValue(descent / (unitsPerEm * sizeAdjust))\n  lineGap = formatOverrideValue(lineGap / (unitsPerEm * sizeAdjust))\n\n  return {\n    ascent,\n    descent,\n    lineGap,\n    fallbackFont: fallbackFont.name,\n    sizeAdjust: formatOverrideValue(sizeAdjust),\n  }\n}\n"],"names":["calculateSizeAdjustValues","capsizeFontsMetrics","require","formatName","str","replace","word","index","toLowerCase","toUpperCase","formatOverrideValue","val","Math","abs","toFixed","fontName","fontKey","fontMetrics","category","ascent","descent","lineGap","unitsPerEm","xWidthAvg","mainFontAvgWidth","fallbackFont","DEFAULT_SERIF_FONT","DEFAULT_SANS_SERIF_FONT","fallbackFontName","name","fallbackFontMetrics","fallbackFontAvgWidth","sizeAdjust"],"mappings":";;;;+BAkBgBA;;;eAAAA;;;2BAfT;AACP,MAAMC,sBAAsBC,QAAQ;AAEpC,SAASC,WAAWC,GAAW;IAC7B,OAAOA,IACJC,OAAO,CAAC,uBAAuB,SAAUC,IAAI,EAAEC,KAAK;QACnD,OAAOA,UAAU,IAAID,KAAKE,WAAW,KAAKF,KAAKG,WAAW;IAC5D,GACCJ,OAAO,CAAC,QAAQ;AACrB;AAEA,SAASK,oBAAoBC,GAAW;IACtC,OAAOC,KAAKC,GAAG,CAACF,MAAM,KAAKG,OAAO,CAAC;AACrC;AAEO,SAASd,0BAA0Be,QAAgB;IACxD,MAAMC,UAAUb,WAAWY;IAC3B,MAAME,cAAchB,mBAAmB,CAACe,QAAQ;IAChD,IAAI,EAAEE,QAAQ,EAAEC,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,UAAU,EAAEC,SAAS,EAAE,GAC/DN;IACF,MAAMO,mBAAmBD,YAAYD;IACrC,MAAMG,eACJP,aAAa,UAAUQ,6BAAkB,GAAGC,kCAAuB;IACrE,MAAMC,mBAAmBzB,WAAWsB,aAAaI,IAAI;IACrD,MAAMC,sBAAsB7B,mBAAmB,CAAC2B,iBAAiB;IACjE,MAAMG,uBACJD,oBAAoBP,SAAS,GAAGO,oBAAoBR,UAAU;IAChE,IAAIU,aAAaT,YAAYC,mBAAmBO,uBAAuB;IAEvEZ,SAAST,oBAAoBS,SAAUG,CAAAA,aAAaU,UAAS;IAC7DZ,UAAUV,oBAAoBU,UAAWE,CAAAA,aAAaU,UAAS;IAC/DX,UAAUX,oBAAoBW,UAAWC,CAAAA,aAAaU,UAAS;IAE/D,OAAO;QACLb;QACAC;QACAC;QACAI,cAAcA,aAAaI,IAAI;QAC/BG,YAAYtB,oBAAoBsB;IAClC;AACF","ignoreList":[0]}

package/dist/fonts/get-preloadable-fonts.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPreloadableFonts", {
+    enumerable: true,
+    get: function() {
+        return getPreloadableFonts;
+    }
+});
+function getPreloadableFonts(nextFontManifest, filePath, injectedFontPreloadTags) {
+    if (!nextFontManifest || !filePath) {
+        return null;
+    }
+    const filepathWithoutExtension = filePath.replace(/\.[^.]+$/, '');
+    const fontFiles = new Set();
+    let foundFontUsage = false;
+    const preloadedFontFiles = nextFontManifest.app[filepathWithoutExtension];
+    if (preloadedFontFiles) {
+        foundFontUsage = true;
+        for (const fontFile of preloadedFontFiles){
+            if (!injectedFontPreloadTags.has(fontFile)) {
+                fontFiles.add(fontFile);
+                injectedFontPreloadTags.add(fontFile);
+            }
+        }
+    }
+    if (fontFiles.size) {
+        return [
+            ...fontFiles
+        ].sort();
+    } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {
+        return [];
+    } else {
+        return null;
+    }
+}
+
+//# sourceMappingURL=get-preloadable-fonts.js.map

package/dist/fonts/get-preloadable-fonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../fonts/get-preloadable-fonts.ts"],"sourcesContent":["import type { NextFontManifest } from '../build/webpack/plugins/next-font-manifest-plugin'\nimport type { DeepReadonly } from '../shared/lib/deep-readonly'\n\n/**\n * Get hrefs for fonts to preload\n * Returns null if there are no fonts at all.\n * Returns string[] if there are fonts to preload (font paths)\n * Returns empty string[] if there are fonts but none to preload and no other fonts have been preloaded\n * Returns null if there are fonts but none to preload and at least some were previously preloaded\n */\nexport function getPreloadableFonts(\n  nextFontManifest: DeepReadonly<NextFontManifest> | undefined,\n  filePath: string | undefined,\n  injectedFontPreloadTags: Set<string>\n): string[] | null {\n  if (!nextFontManifest || !filePath) {\n    return null\n  }\n  const filepathWithoutExtension = filePath.replace(/\\.[^.]+$/, '')\n  const fontFiles = new Set<string>()\n  let foundFontUsage = false\n\n  const preloadedFontFiles = nextFontManifest.app[filepathWithoutExtension]\n  if (preloadedFontFiles) {\n    foundFontUsage = true\n    for (const fontFile of preloadedFontFiles) {\n      if (!injectedFontPreloadTags.has(fontFile)) {\n        fontFiles.add(fontFile)\n        injectedFontPreloadTags.add(fontFile)\n      }\n    }\n  }\n\n  if (fontFiles.size) {\n    return [...fontFiles].sort()\n  } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {\n    return []\n  } else {\n    return null\n  }\n}\n"],"names":["getPreloadableFonts","nextFontManifest","filePath","injectedFontPreloadTags","filepathWithoutExtension","replace","fontFiles","Set","foundFontUsage","preloadedFontFiles","app","fontFile","has","add","size","sort"],"mappings":";;;;+BAUgBA;;;eAAAA;;;AAAT,SAASA,oBACdC,gBAA4D,EAC5DC,QAA4B,EAC5BC,uBAAoC;IAEpC,IAAI,CAACF,oBAAoB,CAACC,UAAU;QAClC,OAAO;IACT;IACA,MAAME,2BAA2BF,SAASG,OAAO,CAAC,YAAY;IAC9D,MAAMC,YAAY,IAAIC;IACtB,IAAIC,iBAAiB;IAErB,MAAMC,qBAAqBR,iBAAiBS,GAAG,CAACN,yBAAyB;IACzE,IAAIK,oBAAoB;QACtBD,iBAAiB;QACjB,KAAK,MAAMG,YAAYF,mBAAoB;YACzC,IAAI,CAACN,wBAAwBS,GAAG,CAACD,WAAW;gBAC1CL,UAAUO,GAAG,CAACF;gBACdR,wBAAwBU,GAAG,CAACF;YAC9B;QACF;IACF;IAEA,IAAIL,UAAUQ,IAAI,EAAE;QAClB,OAAO;eAAIR;SAAU,CAACS,IAAI;IAC5B,OAAO,IAAIP,kBAAkBL,wBAAwBW,IAAI,KAAK,GAAG;QAC/D,OAAO,EAAE;IACX,OAAO;QACL,OAAO;IACT;AACF","ignoreList":[0]}

package/dist/hash/bloom-filter.js

@@ -0,0 +1,85 @@
+// minimal implementation MurmurHash2 hash function
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BloomFilter", {
+    enumerable: true,
+    get: function() {
+        return BloomFilter;
+    }
+});
+function murmurhash2(str) {
+    let h = 0;
+    for(let i = 0; i < str.length; i++){
+        const c = str.charCodeAt(i);
+        h = Math.imul(h ^ c, 0x5bd1e995);
+        h ^= h >>> 13;
+        h = Math.imul(h, 0x5bd1e995);
+    }
+    return h >>> 0;
+}
+// default to 0.01% error rate as the filter compresses very well
+const DEFAULT_ERROR_RATE = 0.0001;
+class BloomFilter {
+    constructor(numItems, errorRate = DEFAULT_ERROR_RATE){
+        this.numItems = numItems;
+        this.errorRate = errorRate;
+        this.numBits = Math.ceil(-(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2)));
+        this.numHashes = Math.ceil(this.numBits / numItems * Math.log(2));
+        this.bitArray = new Array(this.numBits).fill(0);
+    }
+    static from(items, errorRate = DEFAULT_ERROR_RATE) {
+        const filter = new BloomFilter(items.length, errorRate);
+        for (const item of items){
+            filter.add(item);
+        }
+        return filter;
+    }
+    export() {
+        const data = {
+            numItems: this.numItems,
+            errorRate: this.errorRate,
+            numBits: this.numBits,
+            numHashes: this.numHashes,
+            bitArray: this.bitArray
+        };
+        if (process.env.NEXT_RUNTIME === 'nodejs') {
+            if (this.errorRate < DEFAULT_ERROR_RATE) {
+                const filterData = JSON.stringify(data);
+                const gzipSize = require('next/dist/compiled/gzip-size').sync(filterData);
+                if (gzipSize > 1024) {
+                    console.warn(`Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate ${this.errorRate} resulted in size ${filterData.length} bytes, ${gzipSize} bytes (gzip)`);
+                }
+            }
+        }
+        return data;
+    }
+    import(data) {
+        this.numItems = data.numItems;
+        this.errorRate = data.errorRate;
+        this.numBits = data.numBits;
+        this.numHashes = data.numHashes;
+        this.bitArray = data.bitArray;
+    }
+    add(item) {
+        const hashValues = this.getHashValues(item);
+        hashValues.forEach((hash)=>{
+            this.bitArray[hash] = 1;
+        });
+    }
+    contains(item) {
+        const hashValues = this.getHashValues(item);
+        return hashValues.every((hash)=>this.bitArray[hash]);
+    }
+    getHashValues(item) {
+        const hashValues = [];
+        for(let i = 1; i <= this.numHashes; i++){
+            const hash = murmurhash2(`${item}${i}`) % this.numBits;
+            hashValues.push(hash);
+        }
+        return hashValues;
+    }
+}
+
+//# sourceMappingURL=bloom-filter.js.map

package/dist/hash/bloom-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hash/bloom-filter.ts"],"sourcesContent":["// minimal implementation MurmurHash2 hash function\nfunction murmurhash2(str: string) {\n  let h = 0\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i)\n    h = Math.imul(h ^ c, 0x5bd1e995)\n    h ^= h >>> 13\n    h = Math.imul(h, 0x5bd1e995)\n  }\n  return h >>> 0\n}\n\n// default to 0.01% error rate as the filter compresses very well\nconst DEFAULT_ERROR_RATE = 0.0001\n\nexport class BloomFilter {\n  numItems: number\n  errorRate: number\n  numBits: number\n  numHashes: number\n  bitArray: number[]\n\n  constructor(numItems: number, errorRate: number = DEFAULT_ERROR_RATE) {\n    this.numItems = numItems\n    this.errorRate = errorRate\n    this.numBits = Math.ceil(\n      -(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2))\n    )\n    this.numHashes = Math.ceil((this.numBits / numItems) * Math.log(2))\n    this.bitArray = new Array(this.numBits).fill(0)\n  }\n\n  static from(items: string[], errorRate = DEFAULT_ERROR_RATE) {\n    const filter = new BloomFilter(items.length, errorRate)\n\n    for (const item of items) {\n      filter.add(item)\n    }\n    return filter\n  }\n\n  export() {\n    const data = {\n      numItems: this.numItems,\n      errorRate: this.errorRate,\n      numBits: this.numBits,\n      numHashes: this.numHashes,\n      bitArray: this.bitArray,\n    }\n\n    if (process.env.NEXT_RUNTIME === 'nodejs') {\n      if (this.errorRate < DEFAULT_ERROR_RATE) {\n        const filterData = JSON.stringify(data)\n        const gzipSize = (\n          require('next/dist/compiled/gzip-size') as typeof import('next/dist/compiled/gzip-size')\n        ).sync(filterData)\n\n        if (gzipSize > 1024) {\n          console.warn(\n            `Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate ${this.errorRate} resulted in size ${filterData.length} bytes, ${gzipSize} bytes (gzip)`\n          )\n        }\n      }\n    }\n\n    return data\n  }\n\n  import(data: ReturnType<(typeof this)['export']>) {\n    this.numItems = data.numItems\n    this.errorRate = data.errorRate\n    this.numBits = data.numBits\n    this.numHashes = data.numHashes\n    this.bitArray = data.bitArray\n  }\n\n  add(item: string) {\n    const hashValues = this.getHashValues(item)\n    hashValues.forEach((hash) => {\n      this.bitArray[hash] = 1\n    })\n  }\n\n  contains(item: string) {\n    const hashValues = this.getHashValues(item)\n    return hashValues.every((hash) => this.bitArray[hash])\n  }\n\n  getHashValues(item: string) {\n    const hashValues = []\n    for (let i = 1; i <= this.numHashes; i++) {\n      const hash = murmurhash2(`${item}${i}`) % this.numBits\n      hashValues.push(hash)\n    }\n    return hashValues\n  }\n}\n"],"names":["BloomFilter","murmurhash2","str","h","i","length","c","charCodeAt","Math","imul","DEFAULT_ERROR_RATE","constructor","numItems","errorRate","numBits","ceil","log","numHashes","bitArray","Array","fill","from","items","filter","item","add","export","data","process","env","NEXT_RUNTIME","filterData","JSON","stringify","gzipSize","require","sync","console","warn","import","hashValues","getHashValues","forEach","hash","contains","every","push"],"mappings":"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","ignoreList":[0]}

package/dist/hash/etag.js

@@ -0,0 +1,56 @@
+/**
+ * FNV-1a Hash implementation
+ * @author Travis Webb (tjwebb) <me@traviswebb.com>
+ *
+ * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
+ *
+ * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
+ * and still making use of Javascript's 53-bit integer space.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fnv1a52: null,
+    generateETag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fnv1a52: function() {
+        return fnv1a52;
+    },
+    generateETag: function() {
+        return generateETag;
+    }
+});
+const fnv1a52 = (str)=>{
+    const len = str.length;
+    let i = 0, t0 = 0, v0 = 0x2325, t1 = 0, v1 = 0x8422, t2 = 0, v2 = 0x9ce4, t3 = 0, v3 = 0xcbf2;
+    while(i < len){
+        v0 ^= str.charCodeAt(i++);
+        t0 = v0 * 435;
+        t1 = v1 * 435;
+        t2 = v2 * 435;
+        t3 = v3 * 435;
+        t2 += v0 << 8;
+        t3 += v1 << 8;
+        t1 += t0 >>> 16;
+        v0 = t0 & 65535;
+        t2 += t1 >>> 16;
+        v1 = t1 & 65535;
+        v3 = t3 + (t2 >>> 16) & 65535;
+        v2 = t2 & 65535;
+    }
+    return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const generateETag = (payload, weak = false)=>{
+    const prefix = weak ? 'W/"' : '"';
+    return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+
+//# sourceMappingURL=etag.js.map

package/dist/hash/etag.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hash/etag.ts"],"sourcesContent":["/**\n * FNV-1a Hash implementation\n * @author Travis Webb (tjwebb) <me@traviswebb.com>\n *\n * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js\n *\n * Simplified, optimized and add modified for 52 bit, which provides a larger hash space\n * and still making use of Javascript's 53-bit integer space.\n */\nexport const fnv1a52 = (str: string) => {\n  const len = str.length\n  let i = 0,\n    t0 = 0,\n    v0 = 0x2325,\n    t1 = 0,\n    v1 = 0x8422,\n    t2 = 0,\n    v2 = 0x9ce4,\n    t3 = 0,\n    v3 = 0xcbf2\n\n  while (i < len) {\n    v0 ^= str.charCodeAt(i++)\n    t0 = v0 * 435\n    t1 = v1 * 435\n    t2 = v2 * 435\n    t3 = v3 * 435\n    t2 += v0 << 8\n    t3 += v1 << 8\n    t1 += t0 >>> 16\n    v0 = t0 & 65535\n    t2 += t1 >>> 16\n    v1 = t1 & 65535\n    v3 = (t3 + (t2 >>> 16)) & 65535\n    v2 = t2 & 65535\n  }\n\n  return (\n    (v3 & 15) * 281474976710656 +\n    v2 * 4294967296 +\n    v1 * 65536 +\n    (v0 ^ (v3 >> 4))\n  )\n}\n\nexport const generateETag = (payload: string, weak = false) => {\n  const prefix = weak ? 'W/\"' : '\"'\n  return (\n    prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '\"'\n  )\n}\n"],"names":["fnv1a52","generateETag","str","len","length","i","t0","v0","t1","v1","t2","v2","t3","v3","charCodeAt","payload","weak","prefix","toString"],"mappings":"AAAA;;;;;;;;CAQC;;;;;;;;;;;;;;;IACYA,OAAO;eAAPA;;IAoCAC,YAAY;eAAZA;;;AApCN,MAAMD,UAAU,CAACE;IACtB,MAAMC,MAAMD,IAAIE,MAAM;IACtB,IAAIC,IAAI,GACNC,KAAK,GACLC,KAAK,QACLC,KAAK,GACLC,KAAK,QACLC,KAAK,GACLC,KAAK,QACLC,KAAK,GACLC,KAAK;IAEP,MAAOR,IAAIF,IAAK;QACdI,MAAML,IAAIY,UAAU,CAACT;QACrBC,KAAKC,KAAK;QACVC,KAAKC,KAAK;QACVC,KAAKC,KAAK;QACVC,KAAKC,KAAK;QACVH,MAAMH,MAAM;QACZK,MAAMH,MAAM;QACZD,MAAMF,OAAO;QACbC,KAAKD,KAAK;QACVI,MAAMF,OAAO;QACbC,KAAKD,KAAK;QACVK,KAAK,AAACD,KAAMF,CAAAA,OAAO,EAAC,IAAM;QAC1BC,KAAKD,KAAK;IACZ;IAEA,OACE,AAACG,CAAAA,KAAK,EAAC,IAAK,kBACZF,KAAK,aACLF,KAAK,QACJF,CAAAA,KAAMM,MAAM,CAAC;AAElB;AAEO,MAAMZ,eAAe,CAACc,SAAiBC,OAAO,KAAK;IACxD,MAAMC,SAASD,OAAO,QAAQ;IAC9B,OACEC,SAASjB,QAAQe,SAASG,QAAQ,CAAC,MAAMH,QAAQX,MAAM,CAACc,QAAQ,CAAC,MAAM;AAE3E","ignoreList":[0]}

package/dist/hash/fnv1a.js

@@ -0,0 +1,56 @@
+// source: https://github.com/sindresorhus/fnv1a
+// FNV_PRIMES and FNV_OFFSETS from
+// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return fnv1a;
+    }
+});
+const FNV_PRIMES = {
+    32: BigInt(16777619),
+    64: BigInt(1099511628211),
+    128: BigInt(309485009821345068724781371),
+    256: BigInt(374144419156711147060143317175368453031918731002211),
+    512: BigInt(35835915874844867368919076489095108449946327955754392558399825615420669938882575126094039892345713852759),
+    1024: BigInt(5016456510113118655434598811035278955030765345404790744303017523831112055108147451509157692220295382716162651878526895249385292291816524375083746691371804094271873160484737966720260389217684476157468082573)
+};
+const FNV_OFFSETS = {
+    32: BigInt(2166136261),
+    64: BigInt(14695981039346656037),
+    128: BigInt(144066263297769815596495629667062367629),
+    256: BigInt(100029257958052580907070968620625704837092796014241193945225284501741471925557),
+    512: BigInt(9659303129496669498009435400716310466090418745672637896108374329434462657994582932197716438449813051892206539805784495328239340083876191928701583869517785),
+    1024: BigInt(14197795064947621068722070641403218320880622795441933960878474914617582723252296732303717722150864096521202355549365628174669108571814760471015076148029755969804077320157692458563003215304957150157403644460363550505412711285966361610267868082893823963790439336411086884584107735010676915)
+};
+function fnv1a(inputString, { size = 32, seed = 0 } = {}) {
+    if (!FNV_PRIMES[size]) {
+        throw Object.defineProperty(new Error('The `size` option must be one of 32, 64, 128, 256, 512, or 1024'), "__NEXT_ERROR_CODE", {
+            value: "E462",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    let hash = FNV_OFFSETS[size] ^ BigInt(seed);
+    const fnvPrime = FNV_PRIMES[size];
+    // Handle Unicode code points > 0x7f
+    let isUnicoded = false;
+    for(let index = 0; index < inputString.length; index++){
+        let characterCode = inputString.charCodeAt(index);
+        // Non-ASCII characters trigger the Unicode escape logic
+        if (characterCode > 0x7f && !isUnicoded) {
+            inputString = unescape(encodeURIComponent(inputString));
+            characterCode = inputString.charCodeAt(index);
+            isUnicoded = true;
+        }
+        hash ^= BigInt(characterCode);
+        hash = BigInt.asUintN(size, hash * fnvPrime);
+    }
+    return hash;
+}
+
+//# sourceMappingURL=fnv1a.js.map

package/dist/hash/fnv1a.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hash/fnv1a.ts"],"sourcesContent":["// source: https://github.com/sindresorhus/fnv1a\n// FNV_PRIMES and FNV_OFFSETS from\n// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param\n\nconst FNV_PRIMES = {\n  32: BigInt(16_777_619),\n  64: BigInt(1_099_511_628_211),\n  128: BigInt(309_485_009_821_345_068_724_781_371),\n  256: BigInt(\n    374_144_419_156_711_147_060_143_317_175_368_453_031_918_731_002_211\n  ),\n  512: BigInt(\n    35_835_915_874_844_867_368_919_076_489_095_108_449_946_327_955_754_392_558_399_825_615_420_669_938_882_575_126_094_039_892_345_713_852_759\n  ),\n  1024: BigInt(\n    5_016_456_510_113_118_655_434_598_811_035_278_955_030_765_345_404_790_744_303_017_523_831_112_055_108_147_451_509_157_692_220_295_382_716_162_651_878_526_895_249_385_292_291_816_524_375_083_746_691_371_804_094_271_873_160_484_737_966_720_260_389_217_684_476_157_468_082_573\n  ),\n} as const\n\nconst FNV_OFFSETS = {\n  32: BigInt(2_166_136_261),\n  64: BigInt(14_695_981_039_346_656_037),\n  128: BigInt(144_066_263_297_769_815_596_495_629_667_062_367_629),\n  256: BigInt(\n    100_029_257_958_052_580_907_070_968_620_625_704_837_092_796_014_241_193_945_225_284_501_741_471_925_557\n  ),\n  512: BigInt(\n    9_659_303_129_496_669_498_009_435_400_716_310_466_090_418_745_672_637_896_108_374_329_434_462_657_994_582_932_197_716_438_449_813_051_892_206_539_805_784_495_328_239_340_083_876_191_928_701_583_869_517_785\n  ),\n  1024: BigInt(\n    14_197_795_064_947_621_068_722_070_641_403_218_320_880_622_795_441_933_960_878_474_914_617_582_723_252_296_732_303_717_722_150_864_096_521_202_355_549_365_628_174_669_108_571_814_760_471_015_076_148_029_755_969_804_077_320_157_692_458_563_003_215_304_957_150_157_403_644_460_363_550_505_412_711_285_966_361_610_267_868_082_893_823_963_790_439_336_411_086_884_584_107_735_010_676_915\n  ),\n} as const\n\nexport default function fnv1a(\n  inputString: string,\n  {\n    size = 32,\n    seed = 0,\n  }: {\n    size?: keyof typeof FNV_PRIMES\n    seed?: number\n  } = {}\n) {\n  if (!FNV_PRIMES[size]) {\n    throw new Error(\n      'The `size` option must be one of 32, 64, 128, 256, 512, or 1024'\n    )\n  }\n\n  let hash: bigint = FNV_OFFSETS[size] ^ BigInt(seed)\n  const fnvPrime = FNV_PRIMES[size]\n\n  // Handle Unicode code points > 0x7f\n  let isUnicoded = false\n\n  for (let index = 0; index < inputString.length; index++) {\n    let characterCode = inputString.charCodeAt(index)\n\n    // Non-ASCII characters trigger the Unicode escape logic\n    if (characterCode > 0x7f && !isUnicoded) {\n      inputString = unescape(encodeURIComponent(inputString))\n      characterCode = inputString.charCodeAt(index)\n      isUnicoded = true\n    }\n\n    hash ^= BigInt(characterCode)\n    hash = BigInt.asUintN(size, hash * fnvPrime)\n  }\n\n  return hash\n}\n"],"names":["fnv1a","FNV_PRIMES","BigInt","FNV_OFFSETS","inputString","size","seed","Error","hash","fnvPrime","isUnicoded","index","length","characterCode","charCodeAt","unescape","encodeURIComponent","asUintN"],"mappings":"AAAA,gDAAgD;AAChD,kCAAkC;AAClC,iEAAiE;;;;;+BAgCjE;;;eAAwBA;;;AA9BxB,MAAMC,aAAa;IACjB,IAAIC,OAAO;IACX,IAAIA,OAAO;IACX,KAAKA,OAAO;IACZ,KAAKA,OACH;IAEF,KAAKA,OACH;IAEF,MAAMA,OACJ;AAEJ;AAEA,MAAMC,cAAc;IAClB,IAAID,OAAO;IACX,IAAIA,OAAO;IACX,KAAKA,OAAO;IACZ,KAAKA,OACH;IAEF,KAAKA,OACH;IAEF,MAAMA,OACJ;AAEJ;AAEe,SAASF,MACtBI,WAAmB,EACnB,EACEC,OAAO,EAAE,EACTC,OAAO,CAAC,EAIT,GAAG,CAAC,CAAC;IAEN,IAAI,CAACL,UAAU,CAACI,KAAK,EAAE;QACrB,MAAM,qBAEL,CAFK,IAAIE,MACR,oEADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,IAAIC,OAAeL,WAAW,CAACE,KAAK,GAAGH,OAAOI;IAC9C,MAAMG,WAAWR,UAAU,CAACI,KAAK;IAEjC,oCAAoC;IACpC,IAAIK,aAAa;IAEjB,IAAK,IAAIC,QAAQ,GAAGA,QAAQP,YAAYQ,MAAM,EAAED,QAAS;QACvD,IAAIE,gBAAgBT,YAAYU,UAAU,CAACH;QAE3C,wDAAwD;QACxD,IAAIE,gBAAgB,QAAQ,CAACH,YAAY;YACvCN,cAAcW,SAASC,mBAAmBZ;YAC1CS,gBAAgBT,YAAYU,UAAU,CAACH;YACvCD,aAAa;QACf;QAEAF,QAAQN,OAAOW;QACfL,OAAON,OAAOe,OAAO,CAACZ,MAAMG,OAAOC;IACrC;IAEA,OAAOD;AACT","ignoreList":[0]}

package/dist/hash/hash.js

@@ -0,0 +1,39 @@
+// http://www.cse.yorku.ca/~oz/hash.html
+// More specifically, 32-bit hash via djbxor
+// (ref: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765#gistcomment-3367765)
+// 32-bit hash for consistent output across different runtime implementations.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    djb2Hash: null,
+    hexHash: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    djb2Hash: function() {
+        return djb2Hash;
+    },
+    hexHash: function() {
+        return hexHash;
+    }
+});
+function djb2Hash(str) {
+    let hash = 5381;
+    for(let i = 0; i < str.length; i++){
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) + hash + char & 0xffffffff;
+    }
+    return hash >>> 0;
+}
+function hexHash(str) {
+    return djb2Hash(str).toString(36).slice(0, 5);
+}
+
+//# sourceMappingURL=hash.js.map

package/dist/hash/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hash/hash.ts"],"sourcesContent":["// http://www.cse.yorku.ca/~oz/hash.html\n// More specifically, 32-bit hash via djbxor\n// (ref: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765#gistcomment-3367765)\n// 32-bit hash for consistent output across different runtime implementations.\nexport function djb2Hash(str: string) {\n  let hash = 5381\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i)\n    hash = ((hash << 5) + hash + char) & 0xffffffff\n  }\n  return hash >>> 0\n}\n\nexport function hexHash(str: string) {\n  return djb2Hash(str).toString(36).slice(0, 5)\n}\n"],"names":["djb2Hash","hexHash","str","hash","i","length","char","charCodeAt","toString","slice"],"mappings":"AAAA,wCAAwC;AACxC,4CAA4C;AAC5C,iHAAiH;AACjH,8EAA8E;;;;;;;;;;;;;;;;IAC9DA,QAAQ;eAARA;;IASAC,OAAO;eAAPA;;;AATT,SAASD,SAASE,GAAW;IAClC,IAAIC,OAAO;IACX,IAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnC,MAAME,OAAOJ,IAAIK,UAAU,CAACH;QAC5BD,OAAO,AAAEA,CAAAA,QAAQ,CAAA,IAAKA,OAAOG,OAAQ;IACvC;IACA,OAAOH,SAAS;AAClB;AAEO,SAASF,QAAQC,GAAW;IACjC,OAAOF,SAASE,KAAKM,QAAQ,CAAC,IAAIC,KAAK,CAAC,GAAG;AAC7C","ignoreList":[0]}

package/dist/hostname/format-hostname.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatHostname", {
+    enumerable: true,
+    get: function() {
+        return formatHostname;
+    }
+});
+const _isipv6 = require("./is-ipv6");
+function formatHostname(hostname) {
+    return (0, _isipv6.isIPv6)(hostname) ? `[${hostname}]` : hostname;
+}
+
+//# sourceMappingURL=format-hostname.js.map

package/dist/hostname/format-hostname.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hostname/format-hostname.ts"],"sourcesContent":["import { isIPv6 } from './is-ipv6'\n\n/**\n * Formats a hostname so that it is a valid host that can be fetched by wrapping\n * IPv6 hosts with brackets.\n * @param hostname\n * @returns\n */\nexport function formatHostname(hostname: string): string {\n  return isIPv6(hostname) ? `[${hostname}]` : hostname\n}\n"],"names":["formatHostname","hostname","isIPv6"],"mappings":";;;;+BAQgBA;;;eAAAA;;;wBARO;AAQhB,SAASA,eAAeC,QAAgB;IAC7C,OAAOC,IAAAA,cAAM,EAACD,YAAY,CAAC,CAAC,EAAEA,SAAS,CAAC,CAAC,GAAGA;AAC9C","ignoreList":[0]}

package/dist/hostname/get-hostname.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getHostname", {
+    enumerable: true,
+    get: function() {
+        return getHostname;
+    }
+});
+function getHostname(parsed, headers) {
+    // Get the hostname from the headers if it exists, otherwise use the parsed
+    // hostname.
+    let hostname;
+    if ((headers == null ? void 0 : headers.host) && !Array.isArray(headers.host)) {
+        hostname = headers.host.toString().split(':', 1)[0];
+    } else if (parsed.hostname) {
+        hostname = parsed.hostname;
+    } else return;
+    return hostname.toLowerCase();
+}
+
+//# sourceMappingURL=get-hostname.js.map

package/dist/hostname/get-hostname.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hostname/get-hostname.ts"],"sourcesContent":["import type { OutgoingHttpHeaders } from 'http'\n\n/**\n * Takes an object with a hostname property (like a parsed URL) and some\n * headers that may contain Host and returns the preferred hostname.\n * @param parsed An object containing a hostname property.\n * @param headers A dictionary with headers containing a `host`.\n */\nexport function getHostname(\n  parsed: { hostname?: string | null },\n  headers?: OutgoingHttpHeaders\n): string | undefined {\n  // Get the hostname from the headers if it exists, otherwise use the parsed\n  // hostname.\n  let hostname: string\n  if (headers?.host && !Array.isArray(headers.host)) {\n    hostname = headers.host.toString().split(':', 1)[0]\n  } else if (parsed.hostname) {\n    hostname = parsed.hostname\n  } else return\n\n  return hostname.toLowerCase()\n}\n"],"names":["getHostname","parsed","headers","hostname","host","Array","isArray","toString","split","toLowerCase"],"mappings":";;;;+BAQgBA;;;eAAAA;;;AAAT,SAASA,YACdC,MAAoC,EACpCC,OAA6B;IAE7B,2EAA2E;IAC3E,YAAY;IACZ,IAAIC;IACJ,IAAID,CAAAA,2BAAAA,QAASE,IAAI,KAAI,CAACC,MAAMC,OAAO,CAACJ,QAAQE,IAAI,GAAG;QACjDD,WAAWD,QAAQE,IAAI,CAACG,QAAQ,GAAGC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE;IACrD,OAAO,IAAIP,OAAOE,QAAQ,EAAE;QAC1BA,WAAWF,OAAOE,QAAQ;IAC5B,OAAO;IAEP,OAAOA,SAASM,WAAW;AAC7B","ignoreList":[0]}

package/dist/hostname/get-network-host.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNetworkHost", {
+    enumerable: true,
+    get: function() {
+        return getNetworkHost;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getNetworkHosts(family) {
+    const interfaces = _os.default.networkInterfaces();
+    const hosts = [];
+    Object.keys(interfaces).forEach((key)=>{
+        var _interfaces_key;
+        (_interfaces_key = interfaces[key]) == null ? void 0 : _interfaces_key.filter((networkInterface)=>{
+            switch(networkInterface.family){
+                case 'IPv6':
+                    return family === 'IPv6' && networkInterface.scopeid === 0 && networkInterface.address !== '::1';
+                case 'IPv4':
+                    return family === 'IPv4' && networkInterface.address !== '127.0.0.1';
+                default:
+                    return false;
+            }
+        }).forEach((networkInterface)=>{
+            if (networkInterface.address) {
+                hosts.push(networkInterface.address);
+            }
+        });
+    });
+    return hosts;
+}
+function getNetworkHost(family) {
+    const hosts = getNetworkHosts(family);
+    return hosts[0] ?? null;
+}
+
+//# sourceMappingURL=get-network-host.js.map

package/dist/hostname/get-network-host.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hostname/get-network-host.ts"],"sourcesContent":["import os from 'os'\n\nfunction getNetworkHosts(family: 'IPv4' | 'IPv6'): string[] {\n  const interfaces = os.networkInterfaces()\n  const hosts: string[] = []\n\n  Object.keys(interfaces).forEach((key) => {\n    interfaces[key]\n      ?.filter((networkInterface) => {\n        switch (networkInterface.family) {\n          case 'IPv6':\n            return (\n              family === 'IPv6' &&\n              networkInterface.scopeid === 0 &&\n              networkInterface.address !== '::1'\n            )\n          case 'IPv4':\n            return family === 'IPv4' && networkInterface.address !== '127.0.0.1'\n          default:\n            return false\n        }\n      })\n      .forEach((networkInterface) => {\n        if (networkInterface.address) {\n          hosts.push(networkInterface.address)\n        }\n      })\n  })\n\n  return hosts\n}\n\nexport function getNetworkHost(family: 'IPv4' | 'IPv6'): string | null {\n  const hosts = getNetworkHosts(family)\n  return hosts[0] ?? null\n}\n"],"names":["getNetworkHost","getNetworkHosts","family","interfaces","os","networkInterfaces","hosts","Object","keys","forEach","key","filter","networkInterface","scopeid","address","push"],"mappings":";;;;+BAgCgBA;;;eAAAA;;;2DAhCD;;;;;;AAEf,SAASC,gBAAgBC,MAAuB;IAC9C,MAAMC,aAAaC,WAAE,CAACC,iBAAiB;IACvC,MAAMC,QAAkB,EAAE;IAE1BC,OAAOC,IAAI,CAACL,YAAYM,OAAO,CAAC,CAACC;YAC/BP;SAAAA,kBAAAA,UAAU,CAACO,IAAI,qBAAfP,gBACIQ,MAAM,CAAC,CAACC;YACR,OAAQA,iBAAiBV,MAAM;gBAC7B,KAAK;oBACH,OACEA,WAAW,UACXU,iBAAiBC,OAAO,KAAK,KAC7BD,iBAAiBE,OAAO,KAAK;gBAEjC,KAAK;oBACH,OAAOZ,WAAW,UAAUU,iBAAiBE,OAAO,KAAK;gBAC3D;oBACE,OAAO;YACX;QACF,GACCL,OAAO,CAAC,CAACG;YACR,IAAIA,iBAAiBE,OAAO,EAAE;gBAC5BR,MAAMS,IAAI,CAACH,iBAAiBE,OAAO;YACrC;QACF;IACJ;IAEA,OAAOR;AACT;AAEO,SAASN,eAAeE,MAAuB;IACpD,MAAMI,QAAQL,gBAAgBC;IAC9B,OAAOI,KAAK,CAAC,EAAE,IAAI;AACrB","ignoreList":[0]}

package/dist/hostname/is-ipv6.js

@@ -0,0 +1,41 @@
+// Regex from `node/lib/internal/net.js`: https://github.com/nodejs/node/blob/9fc57006c27564ed7f75eee090eca86786508f51/lib/internal/net.js#L19-L29
+// License included below:
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isIPv6", {
+    enumerable: true,
+    get: function() {
+        return isIPv6;
+    }
+});
+const v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+const v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+const v6Seg = '(?:[0-9a-fA-F]{1,4})';
+const IPv6Reg = new RegExp('^(' + `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` + `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` + `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` + `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` + `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` + `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + ')(%[0-9a-zA-Z-.:]{1,})?$');
+function isIPv6(s) {
+    return IPv6Reg.test(s);
+}
+
+//# sourceMappingURL=is-ipv6.js.map

package/dist/hostname/is-ipv6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hostname/is-ipv6.ts"],"sourcesContent":["// Regex from `node/lib/internal/net.js`: https://github.com/nodejs/node/blob/9fc57006c27564ed7f75eee090eca86786508f51/lib/internal/net.js#L19-L29\n// License included below:\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nconst v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`\nconst v6Seg = '(?:[0-9a-fA-F]{1,4})'\nconst IPv6Reg = new RegExp(\n  '^(' +\n    `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n    `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n    `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n    `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n    `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n    `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n    ')(%[0-9a-zA-Z-.:]{1,})?$'\n)\n\nexport function isIPv6(s: string) {\n  return IPv6Reg.test(s)\n}\n"],"names":["isIPv6","v4Seg","v4Str","v6Seg","IPv6Reg","RegExp","s","test"],"mappings":"AAAA,kJAAkJ;AAClJ,0BAA0B;AAC1B,sDAAsD;AACtD,EAAE;AACF,0EAA0E;AAC1E,gEAAgE;AAChE,sEAAsE;AACtE,sEAAsE;AACtE,4EAA4E;AAC5E,qEAAqE;AACrE,wBAAwB;AACxB,EAAE;AACF,0EAA0E;AAC1E,yDAAyD;AACzD,EAAE;AACF,0EAA0E;AAC1E,6DAA6D;AAC7D,4EAA4E;AAC5E,2EAA2E;AAC3E,wEAAwE;AACxE,4EAA4E;AAC5E,yCAAyC;;;;;+BAkBzBA;;;eAAAA;;;AAhBhB,MAAMC,QAAQ;AACd,MAAMC,QAAQ,CAAC,CAAC,EAAED,MAAM,OAAO,EAAEA,OAAO;AACxC,MAAME,QAAQ;AACd,MAAMC,UAAU,IAAIC,OAClB,OACE,CAAC,GAAG,EAAEF,MAAM,QAAQ,EAAEA,MAAM,IAAI,CAAC,GACjC,CAAC,GAAG,EAAEA,MAAM,QAAQ,EAAED,MAAM,EAAE,EAAEC,MAAM,IAAI,CAAC,GAC3C,CAAC,GAAG,EAAEA,MAAM,SAAS,EAAED,MAAM,GAAG,EAAEC,MAAM,UAAU,CAAC,GACnD,CAAC,GAAG,EAAEA,MAAM,UAAU,EAAEA,MAAM,OAAO,EAAED,MAAM,GAAG,EAAEC,MAAM,UAAU,CAAC,GACnE,CAAC,GAAG,EAAEA,MAAM,UAAU,EAAEA,MAAM,OAAO,EAAED,MAAM,GAAG,EAAEC,MAAM,UAAU,CAAC,GACnE,CAAC,GAAG,EAAEA,MAAM,UAAU,EAAEA,MAAM,OAAO,EAAED,MAAM,GAAG,EAAEC,MAAM,UAAU,CAAC,GACnE,CAAC,GAAG,EAAEA,MAAM,UAAU,EAAEA,MAAM,OAAO,EAAED,MAAM,GAAG,EAAEC,MAAM,UAAU,CAAC,GACnE,CAAC,SAAS,EAAEA,MAAM,OAAO,EAAED,MAAM,KAAK,EAAEC,MAAM,UAAU,CAAC,GACzD;AAGG,SAASH,OAAOM,CAAS;IAC9B,OAAOF,QAAQG,IAAI,CAACD;AACtB","ignoreList":[0]}

package/dist/image/find-closest-quality.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findClosestQuality", {
+    enumerable: true,
+    get: function() {
+        return findClosestQuality;
+    }
+});
+function findClosestQuality(quality, config) {
+    const q = quality || 75;
+    if (!config?.qualities?.length) {
+        return q;
+    }
+    return config.qualities.reduce((prev, cur)=>Math.abs(cur - q) < Math.abs(prev - q) ? cur : prev, 0);
+}
+
+//# sourceMappingURL=find-closest-quality.js.map

package/dist/image/find-closest-quality.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../image/find-closest-quality.ts"],"sourcesContent":["import type { NextConfig } from '../server/config-shared'\n\n/**\n * Find the closest matching `quality` in the list of `config.qualities`\n * @param quality the quality prop passed to the image component\n * @param config the \"images\" configuration from next.config.js\n * @returns the closest matching quality value\n */\nexport function findClosestQuality(\n  quality: number | undefined,\n  config: NextConfig['images'] | undefined\n): number {\n  const q = quality || 75\n  if (!config?.qualities?.length) {\n    return q\n  }\n  return config.qualities.reduce(\n    (prev, cur) => (Math.abs(cur - q) < Math.abs(prev - q) ? cur : prev),\n    0\n  )\n}\n"],"names":["findClosestQuality","quality","config","q","qualities","length","reduce","prev","cur","Math","abs"],"mappings":";;;;+BAQgBA;;;eAAAA;;;AAAT,SAASA,mBACdC,OAA2B,EAC3BC,MAAwC;IAExC,MAAMC,IAAIF,WAAW;IACrB,IAAI,CAACC,QAAQE,WAAWC,QAAQ;QAC9B,OAAOF;IACT;IACA,OAAOD,OAAOE,SAAS,CAACE,MAAM,CAC5B,CAACC,MAAMC,MAASC,KAAKC,GAAG,CAACF,MAAML,KAAKM,KAAKC,GAAG,CAACH,OAAOJ,KAAKK,MAAMD,MAC/D;AAEJ","ignoreList":[0]}