@rspack/core 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/lib/HookWebpackError.js

@@ -1,23 +1,24 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Sean Larkin @thelarkinn
-*/
 "use strict";
-const WebpackError = require("./WebpackError.js");
-// /** @typedef {import("./Module")} Module */
-/** @typedef {any} Module */
 /**
- * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/HookWebpackError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-class HookWebpackError extends WebpackError {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryRunOrWebpackError = exports.makeWebpackErrorCallback = exports.makeWebpackError = exports.HookWebpackError = void 0;
+const WebpackError_1 = __importDefault(require("./WebpackError"));
+class HookWebpackError extends WebpackError_1.default {
     /**
      * Creates an instance of HookWebpackError.
-     * @param {Error} error inner error
-     * @param {string} hook name of hook
+     * @param error inner error
+     * @param hook name of hook
      */
     constructor(error, hook) {
         super(error.message);
@@ -29,28 +30,28 @@ class HookWebpackError extends WebpackError {
         this.stack += `\n-- inner error --\n${error.stack}`;
     }
 }
-module.exports = HookWebpackError;
+exports.HookWebpackError = HookWebpackError;
+exports.default = HookWebpackError;
 /**
- * @param {Error} error an error
- * @param {string} hook name of the hook
- * @returns {WebpackError} a webpack error
+ * @param error an error
+ * @param hook name of the hook
+ * @returns a webpack error
  */
 const makeWebpackError = (error, hook) => {
-    if (error instanceof WebpackError)
+    if (error instanceof WebpackError_1.default)
         return error;
     return new HookWebpackError(error, hook);
 };
-module.exports.makeWebpackError = makeWebpackError;
+exports.makeWebpackError = makeWebpackError;
 /**
- * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
- * @param {string} hook name of hook
- * @returns {Callback<T>} generic callback
+ * @param callback webpack error callback
+ * @param hook name of hook
+ * @returns generic callback
  */
 const makeWebpackErrorCallback = (callback, hook) => {
     return (err, result) => {
         if (err) {
-            if (err instanceof WebpackError) {
+            if (err instanceof WebpackError_1.default) {
                 callback(err);
                 return;
             }
@@ -60,12 +61,11 @@ const makeWebpackErrorCallback = (callback, hook) => {
         callback(null, result);
     };
 };
-module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
 /**
- * @template T
- * @param {function(): T} fn function which will be wrapping in try catch
- * @param {string} hook name of hook
- * @returns {T} the result
+ * @param fn function which will be wrapping in try catch
+ * @param hook name of hook
+ * @returns the result
  */
 const tryRunOrWebpackError = (fn, hook) => {
     let r;
@@ -73,12 +73,11 @@ const tryRunOrWebpackError = (fn, hook) => {
         r = fn();
     }
     catch (err) {
-        if (err instanceof WebpackError) {
+        if (err instanceof WebpackError_1.default) {
             throw err;
         }
-        // @ts-expect-error
         throw new HookWebpackError(err, hook);
     }
     return r;
 };
-module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
+exports.tryRunOrWebpackError = tryRunOrWebpackError;

package/dist/lib/IgnoreWarningsPlugin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/IgnoreWarningsPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler, IgnoreWarningsNormalized, RspackPluginInstance } from "..";
+declare class IgnoreWarningsPlugin implements RspackPluginInstance {
+    _ignorePattern: IgnoreWarningsNormalized;
+    name: string;
+    /**
+     * @param ignoreWarnings conditions to ignore warnings
+     */
+    constructor(ignorePattern: IgnoreWarningsNormalized);
+    /**
+     * Apply the plugin
+     * @param compiler the compiler instance
+     * @returns
+     */
+    apply(compiler: Compiler): void;
+}
+export default IgnoreWarningsPlugin;

package/dist/lib/{ignoreWarningsPlugin.js → IgnoreWarningsPlugin.js}

@@ -1,10 +1,27 @@
 "use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/IgnoreWarningsPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 class IgnoreWarningsPlugin {
+    /**
+     * @param ignoreWarnings conditions to ignore warnings
+     */
     constructor(ignorePattern) {
         this.name = "IgnoreWarningsPlugin";
         this._ignorePattern = ignorePattern;
     }
+    /**
+     * Apply the plugin
+     * @param compiler the compiler instance
+     * @returns
+     */
     apply(compiler) {
         compiler.hooks.compilation.tap(this.name, compilation => {
             compilation.hooks.processWarnings.tap(this.name, warnings => {

package/dist/lib/LoaderOptionsPlugin.d.ts

@@ -1,17 +1,26 @@
-export type Compiler = import("../Compiler").Compiler;
-export type LoaderOptionsPluginOptions = any;
-/** @typedef {import("../Compiler").Compiler} Compiler */
-/** @typedef {any} LoaderOptionsPluginOptions */
-export class LoaderOptionsPlugin {
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/LoaderOptionsPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+import type { MatchObject } from "./ModuleFilenameHelpers";
+type LoaderOptionsPluginOptions = any;
+export declare class LoaderOptionsPlugin {
+    options: MatchObject;
     /**
-     * @param {LoaderOptionsPluginOptions} options options object
+     * @param options options object
      */
     constructor(options?: LoaderOptionsPluginOptions);
-    options: any;
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler: Compiler): void;
 }
+export {};

package/dist/lib/LoaderOptionsPlugin.js

@@ -1,18 +1,43 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/LoaderOptionsPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoaderOptionsPlugin = void 0;
-const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
-const { NormalModule } = require("../NormalModule");
-// /** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
-/** @typedef {import("../Compiler").Compiler} Compiler */
-/** @typedef {any} LoaderOptionsPluginOptions */
+const NormalModule_1 = require("../NormalModule");
+const ModuleFilenameHelpers = __importStar(require("./ModuleFilenameHelpers"));
 class LoaderOptionsPlugin {
     /**
-     * @param {LoaderOptionsPluginOptions} options options object
+     * @param options options object
      */
     constructor(options = {}) {
         if (typeof options !== "object")
@@ -26,13 +51,13 @@ class LoaderOptionsPlugin {
     }
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler) {
         const options = this.options;
         compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
-            NormalModule.getCompilationHooks(compilation).loader.tap("LoaderOptionsPlugin", context => {
+            NormalModule_1.NormalModule.getCompilationHooks(compilation).loader.tap("LoaderOptionsPlugin", context => {
                 const resource = context.resourcePath;
                 if (!resource)
                     return;
@@ -41,7 +66,6 @@ class LoaderOptionsPlugin {
                         if (key === "include" || key === "exclude" || key === "test") {
                             continue;
                         }
-                        // @ts-expect-error
                         context[key] = options[key];
                     }
                 }

package/dist/lib/LoaderTargetPlugin.d.ts

@@ -1,15 +1,24 @@
-export type Compiler = any;
-/** @typedef {any} Compiler */
-export class LoaderTargetPlugin {
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/LoaderTargetPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+import type { Target } from "../config";
+export declare class LoaderTargetPlugin {
+    readonly target: Target;
     /**
-     * @param {string} target the target
+     * @param target the target
      */
-    constructor(target: string);
-    target: string;
+    constructor(target: Target);
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler: Compiler): void;
 }

package/dist/lib/LoaderTargetPlugin.js

@@ -1,32 +1,34 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/LoaderTargetPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoaderTargetPlugin = void 0;
-const NormalModule = require("../NormalModule");
-// /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {any} Compiler */
+const NormalModule_1 = __importDefault(require("../NormalModule"));
 class LoaderTargetPlugin {
     /**
-     * @param {string} target the target
+     * @param target the target
      */
     constructor(target) {
         this.target = target;
     }
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler) {
-        // @ts-expect-error
         compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
-            // @ts-expect-error
-            NormalModule.getCompilationHooks(compilation).loader.tap("LoaderTargetPlugin", 
-            // @ts-expect-error
-            loaderContext => {
+            NormalModule_1.default.getCompilationHooks(compilation).loader.tap("LoaderTargetPlugin", loaderContext => {
                 loaderContext.target = this.target;
             });
         });

package/dist/lib/ModuleFilenameHelpers.d.ts

@@ -1,3 +1,12 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/ModuleFilenameHelpers.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
 type Matcher = string | RegExp | (string | RegExp)[];
 /**
  * Returns a function that returns the string with the token replaced with the replacement
@@ -12,7 +21,7 @@ type Matcher = string | RegExp | (string | RegExp)[];
  */
 export declare const asRegExp: (test: string | RegExp) => RegExp;
 export declare const matchPart: (str: string, test: Matcher) => boolean;
-interface MatchObject {
+export interface MatchObject {
     test?: Matcher;
     include?: Matcher;
     exclude?: Matcher;

package/dist/lib/ModuleFilenameHelpers.js

@@ -1,4 +1,13 @@
 "use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/ModuleFilenameHelpers.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchObject = exports.matchPart = exports.asRegExp = void 0;
 /**

package/dist/lib/NormalModuleReplacementPlugin.d.ts

@@ -1,7 +1,11 @@
 /**
- * Based on [webpack/lib/NormalModuleReplacementPlugin.js]{@link https://github.com/webpack/webpack/blob/29cc4ead7eb6aafc3a5f6d0b10ce41d33d1ad874/lib/NormalModuleReplacementPlugin.js}
- * Licensed with [MIT License]{@link http://www.opensource.org/licenses/mit-license.php}
- * Original Author Tobias Koppers @sokra
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/NormalModuleReplacementPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type { Compiler } from "../Compiler";
 import type { ResolveData } from "../Module";
@@ -10,10 +14,16 @@ export declare class NormalModuleReplacementPlugin {
     readonly resourceRegExp: RegExp;
     readonly newResource: string | ModuleReplacer;
     /**
-     * @param {RegExp} resourceRegExp the resource matcher
-     * @param {string|ModuleReplacer} newResource the resource replacement
+     * Create an instance of the plugin
+     * @param resourceRegExp the resource matcher
+     * @param newResource the resource replacement
      */
     constructor(resourceRegExp: RegExp, newResource: string | ModuleReplacer);
+    /**
+     * Apply the plugin
+     * @param compiler the compiler instance
+     * @returns
+     */
     apply(compiler: Compiler): void;
 }
 export {};

package/dist/lib/NormalModuleReplacementPlugin.js

@@ -1,8 +1,12 @@
 "use strict";
 /**
- * Based on [webpack/lib/NormalModuleReplacementPlugin.js]{@link https://github.com/webpack/webpack/blob/29cc4ead7eb6aafc3a5f6d0b10ce41d33d1ad874/lib/NormalModuleReplacementPlugin.js}
- * Licensed with [MIT License]{@link http://www.opensource.org/licenses/mit-license.php}
- * Original Author Tobias Koppers @sokra
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/NormalModuleReplacementPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -32,13 +36,19 @@ exports.NormalModuleReplacementPlugin = void 0;
 const NodePath = __importStar(require("node:path"));
 class NormalModuleReplacementPlugin {
     /**
-     * @param {RegExp} resourceRegExp the resource matcher
-     * @param {string|ModuleReplacer} newResource the resource replacement
+     * Create an instance of the plugin
+     * @param resourceRegExp the resource matcher
+     * @param newResource the resource replacement
      */
     constructor(resourceRegExp, newResource) {
         this.resourceRegExp = resourceRegExp;
         this.newResource = newResource;
     }
+    /**
+     * Apply the plugin
+     * @param compiler the compiler instance
+     * @returns
+     */
     apply(compiler) {
         const { resourceRegExp, newResource } = this;
         compiler.hooks.normalModuleFactory.tap("NormalModuleReplacementPlugin", nmf => {

package/dist/lib/WebpackError.d.ts

@@ -1,23 +1,30 @@
-export = WebpackError;
-/** @typedef {any} Chunk */
-/** @typedef {any} DependencyLocation */
-/** @typedef {any} Module */
-declare class WebpackError extends Error {
-    details: any;
-    /** @type {Module} */
-    module: Module;
-    /** @type {DependencyLocation} */
-    loc: DependencyLocation;
-    /** @type {boolean} */
-    hideStack: boolean;
-    /** @type {Chunk} */
-    chunk: Chunk;
-    /** @type {string} */
-    file: string;
-}
-declare namespace WebpackError {
-    export { Chunk, DependencyLocation, Module };
-}
-type Module = any;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/WebpackError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/// <reference types="node" />
+import { inspect } from "node:util";
+import type { Chunk } from "../Chunk";
+import type { Module } from "../Module";
 type DependencyLocation = any;
-type Chunk = any;
+export declare class WebpackError extends Error {
+    loc?: DependencyLocation;
+    file?: string;
+    chunk?: Chunk;
+    module?: Module;
+    details?: string;
+    hideStack?: boolean;
+    /**
+     * Creates an instance of WebpackError.
+     * @param message error message
+     * @returns
+     */
+    constructor(message?: string);
+    [inspect.custom](): string;
+}
+export default WebpackError;

package/dist/lib/WebpackError.js

@@ -1,40 +1,28 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Jarid Margolin @jaridmargolin
-*/
 "use strict";
-const inspect = require("node:util").inspect.custom;
-// /** @typedef {import("./Chunk")} Chunk */
-// /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-// /** @typedef {import("./Module")} Module */
-/** @typedef {any} Chunk */
-/** @typedef {any} DependencyLocation */
-/** @typedef {any} Module */
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/WebpackError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpackError = void 0;
+const node_util_1 = require("node:util");
 class WebpackError extends Error {
     /**
      * Creates an instance of WebpackError.
-     * @param {string=} message error message
+     * @param message error message
+     * @returns
      */
     constructor(message) {
         super(message);
-        // @ts-expect-error
-        this.details = undefined;
-        /** @type {Module} */
-        this.module = undefined;
-        /** @type {DependencyLocation} */
-        this.loc = undefined;
-        /** @type {boolean} */
-        // @ts-expect-error
-        this.hideStack = undefined;
-        /** @type {Chunk} */
-        this.chunk = undefined;
-        /** @type {string} */
-        // @ts-expect-error
-        this.file = undefined;
     }
-    [inspect]() {
+    [node_util_1.inspect.custom]() {
         return this.stack + (this.details ? `\n${this.details}` : "");
     }
 }
-// makeSerializable(WebpackError, "webpack/lib/WebpackError");
-module.exports = WebpackError;
+exports.WebpackError = WebpackError;
+exports.default = WebpackError;

package/dist/lib/cache/getLazyHashedEtag.d.ts

@@ -1,35 +1,35 @@
-export = getter;
 /**
- * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
- * @returns {LazyHashedEtag} etag
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/getLazyHashedEtag.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare function getter(obj: HashableObject, hashFunction?: string | HashConstructor): LazyHashedEtag;
-declare namespace getter {
-    export { Hash, HashConstructor, HashableObject };
+import type Hash from "../../util/hash";
+export type HashConstructor = typeof Hash;
+export interface HashableObject {
+    updateHash(hash: Hash): void;
 }
-type HashableObject = {
-    updateHash: (arg0: Hash) => void;
-};
-type HashConstructor = any;
-/** @typedef {any} Hash */
-/** @typedef {any} HashConstructor */
-/**
- * @typedef {Object} HashableObject
- * @property {function(Hash): void} updateHash
- */
 declare class LazyHashedEtag {
+    _obj: HashableObject;
+    _hash?: string;
+    _hashFunction: string | HashConstructor;
     /**
-     * @param {HashableObject} obj object with updateHash method
-     * @param {string | HashConstructor} hashFunction the hash function to use
+     * @param obj object with updateHash method
+     * @param hashFunction the hash function to use
      */
     constructor(obj: HashableObject, hashFunction?: string | HashConstructor);
-    _obj: HashableObject;
-    _hash: string | undefined;
-    _hashFunction: any;
     /**
-     * @returns {string} hash of object
+     * @returns hash of object
      */
     toString(): string;
 }
-type Hash = any;
+/**
+ * @param obj object with updateHash method
+ * @param ashFunction the hash function to use
+ * @returns etag
+ */
+export declare const getter: (obj: HashableObject, hashFunction?: string | HashConstructor) => LazyHashedEtag;
+export default getter;