k2hash 1.1.34 → 2.0.1

package/index.mjs

@@ -0,0 +1,154 @@
+/*
+ * K2HASH
+ *
+ * Copyright 2015 Yahoo Japan Corporation.
+ *
+ * K2HASH is key-valuew store base libraries.
+ * K2HASH is made for the purpose of the construction of
+ * original KVS system and the offer of the library.
+ * The characteristic is this KVS library which Key can
+ * layer. And can support multi-processing and multi-thread,
+ * and is provided safely as available KVS.
+ *
+ * For the full copyright and license information, please view
+ * the license file that was distributed with this source code.
+ *
+ * AUTHOR:   Takeshi Nakatani
+ * CREATE:   Wed 19 Nov 2025
+ * REVISION:
+ */
+
+//
+// lazy-load the built CJS bundle and provide compatible exports
+//
+// [NOTE]
+// 
+// This file intentionally does NOT require('./build/cjs/index.js') at top-level.
+//
+
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+//
+// Load CJS
+//
+let	_loaded_cjs = null;
+function loadCjs()
+{
+	if(null !== _loaded_cjs){
+		return _loaded_cjs;
+	}
+	_loaded_cjs = require('./build/cjs/index.js');
+	return _loaded_cjs;
+}
+
+//
+// Factory that delegates to CJS impl on first use
+//
+function k2hashFactory(...args)
+{
+	const cjs	= loadCjs();
+	const impl	= (typeof cjs === 'function') ? cjs : (cjs && cjs.default) ? cjs.default : cjs;
+	if(typeof impl === 'function'){
+		return impl(...args);
+	}
+	return impl;
+}
+
+//
+// Provide callable/constructible proxies for named exports
+//
+// This mirrors createLazyProxy from src/index.ts but scoped to ESM file.
+//
+function createLazyExport(name)
+{
+	let _cached = undefined;
+
+	function loadActual()
+	{
+		if(_cached !== undefined){
+			return _cached;
+		}
+		const _cjs		= loadCjs();
+		const _actual	= (_cjs && _cjs[name]) ? _cjs[name] : (_cjs && _cjs.default && _cjs.default[name]) ? _cjs.default[name] : undefined;
+		if (!_actual){
+			throw new Error("Native export " + JSON.stringify(name) + " is not available from ./build/cjs/index.js");
+		}
+		_cached = _actual;
+		return _cached;
+	}
+
+	const target = function(...args)
+	{
+		const _actual = loadActual();
+		return _actual.apply(this, args);
+	};
+
+	const handler = {
+		apply(_t, thisArg, args) {
+			const _actual = loadActual();
+			return _actual.apply(thisArg, args);
+		},
+		construct(_t, args, newTarget) {
+			const _actual = loadActual();
+			return Reflect.construct(_actual, args, newTarget);
+		},
+		get(_t, prop, receiver) {
+			const _actual = loadActual();
+			return Reflect.get(_actual, prop, receiver);
+		},
+		set(_t, prop, value, receiver) {
+			const _actual = loadActual();
+			return Reflect.set(_actual, prop, value, receiver);
+		},
+		has(_t, prop) {
+			const _actual = loadActual();
+			return prop in _actual;
+		},
+		ownKeys(_t) {
+			const _actual = loadActual();
+			return Reflect.ownKeys(_actual);
+		},
+		getOwnPropertyDescriptor(_t, prop) {
+			const _actual = loadActual();
+			return Object.getOwnPropertyDescriptor(_actual, prop) || undefined;
+		},
+		getPrototypeOf(_t) {
+			const _actual = loadActual();
+			return Object.getPrototypeOf(_actual);
+		},
+		setPrototypeOf(_t, proto) {
+			const _actual = loadActual();
+			return Object.setPrototypeOf(_actual, proto);
+		},
+		defineProperty(_t, prop, descriptor) {
+			const _actual = loadActual();
+			return Reflect.defineProperty(_actual, prop, descriptor);
+		},
+		deleteProperty(_t, prop) {
+			const _actual = loadActual();
+			return Reflect.deleteProperty(_actual, prop);
+		}
+	};
+
+	return new Proxy(target, handler);
+}
+
+//
+// Export named lazy-callable proxies
+//
+export const K2hNode		= createLazyExport('K2hNode');
+export const K2hQueue		= createLazyExport('K2hQueue');
+export const K2hKeyQueue	= createLazyExport('K2hKeyQueue');
+
+export default k2hashFactory;
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noexpandtab sw=4 ts=4 fdm=marker
+ * vim<600: noexpandtab sw=4 ts=4
+ */

package/package.json

@@ -1,33 +1,77 @@
 {
   "name": "k2hash",
-  "version": "1.1.34",
+  "version": "2.0.1",
   "description": "K2HASH addon library for Node.js",
   "os": "linux",
   "main": "index.js",
+  "module": "index.mjs",
+  "types": "types/index.d.ts",
   "directories": {
-    "test": "test"
+    "test": "tests"
   },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "binding.gyp",
+    "types",
+    "src",
+    "build/cjs/index.js",
+    "build/esm/index.js",
+    "buildutils/make_node_prebuild_variables.sh",
+    "buildutils/node_prebuild_install.sh",
+    "buildutils/node_prebuild.sh",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
     "bindings": "^1.5.0",
-    "nan": "^2.22.0"
+    "node-addon-api": "^8.5.0",
+    "prebuild-install": "^7.1.3"
   },
   "devDependencies": {
-    "chai": "^4.5.0",
-    "mocha": "^11.1.0"
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.0.3",
+    "chai": "^6.2.2",
+    "mocha": "^11.7.5",
+    "node-gyp": "^12.1.0",
+    "prebuild": "^13.0.1",
+    "rollup": "^4.54.0",
+    "typescript": "^5.9.3",
+    "ts-node": "^10.9.2"
   },
   "scripts": {
-    "build": "npm run build:before && npm run build:configure && npm run build:rebuild && npm run build:linkdir && npm run build:after",
-    "build:before": "echo \"Build - Start\"",
-    "build:configure": "if [ -f src/binding.gyp ]; then cd src; fi && node-gyp configure --verbose --release --target_arch=x64 --coverage=true",
-    "build:rebuild": "if [ -f src/binding.gyp ]; then cd src; fi && node-gyp rebuild --verbose --release --target_arch=x64 --coverage=true",
-    "build:linkdir": "if [ ! -f build -a ! -s build ]; then ln -s src/build .; fi",
-    "build:after": "echo \"Build - Succeed\"",
-    "install": "npm run build",
-    "test": "npm run test:all",
-    "test:all": "echo \"Test - All\" && tests/test.sh && echo \"Finished\"",
-    "test:k2hash": "echo \"Test - k2hash\" && tests/test.sh k2hash && echo \"Finished\"",
-    "test:k2hqueue": "echo \"Test - k2hqueue\" && tests/test.sh k2hqueue && echo \"Finished\"",
-    "test:k2hkeyqueue": "echo \"Test - k2hkeyqueue\" && tests/test.sh k2hkeyqueue && echo \"Finished\""
+    "help": "echo 'command list:\n    npm run install\n    npm run install:onlypackages\n    npm run build\n    npm run build:ts\n    npm run build:ts:cjs\n    npm run build:ts:esm\n    npm run build:ts:tests:cjs\n    npm run build:types\n    npm run build:checktypes\n    npm run build:configure\n    npm run build:rebuild\n    npm run build:prebuild\n    npm run build:prebuild:pure\n    npm run build:bundle:esm\n    npm run prepublishOnly\n    npm run lint\n    npm run test\n    npm run test:ci\n    npm run test:all\n    npm run test:smoke\n    npm run test:smoke:cjs\n    npm run test:smoke:esm\n    npm run test:smoke:ts\n    npm run test:k2hash\n    npm run test:k2hqueue\n    npm run test:k2hkeyqueue\n'",
+    "install": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Install' && ./buildutils/node_prebuild_install.sh || (echo '[INFO] No binaries found, so building from source\n' && if [ -d build/cjs ] && [ -d build/esm ]; then npm run build:rebuild; else npm run build; fi) && echo '-> [DONE] Install\n'",
+    "install:onlypackages": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Install:onlypackages' && npm install --ignore-scripts && echo '-> [DONE] Install:onlypackages\n'",
+    "build": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build' && npm run build:checktypes && npm run build:configure && npm run build:rebuild && npm run build:ts && echo '-> [DONE] Build\n'",
+    "build:ts": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:ts' && npm run build:ts:cjs && npm run build:ts:esm && echo '-> [DONE] Build:ts\n'",
+    "build:ts:cjs": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:ts:cjs' && tsc -p tsconfig.cjs.json && echo '-> [DONE] Build:ts:cjs\n'",
+    "build:ts:esm": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:ts:esm' && tsc -p tsconfig.esm.json && echo '-> [DONE] Build:ts:esm\n'",
+    "build:ts:tests:cjs": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:ts:tests:cjs' && tsc -p tsconfig.tests.json && echo '-> [DONE] Build:ts:tests:cjs\n'",
+    "build:types": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:types' && echo '[NOTICE] We already provide index.d.ts manually, so NOT need to build types.(if run, index.d.ts is generated in \"types-generated\", but NOT use it.)' && tsc -p tsconfig.types.json && echo '-> [DONE] Build:types\n'",
+    "build:checktypes": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:checktypes' && tsc --noEmit -p tsconfig.types.json && echo '-> [DONE] Build:checktypes\n'",
+    "build:configure": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:configure' && if [ -f binding.gyp ]; then (node-gyp configure --verbose --release --target_arch=$(uname -m | sed 's/x86_64/x64/')); else echo '[WARNING] No binding.gyp, skipping configure'; fi && echo '-> [DONE] Build:configure\n'",
+    "build:rebuild": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:rebuild' && if [ -f binding.gyp ]; then (node-gyp rebuild --verbose --release --target_arch=$(uname -m | sed 's/x86_64/x64/')); else echo '[WARNING] No binding.gyp, skipping rebuild'; fi && echo '-> [DONE] Build:rebuild\n'",
+    "build:prebuild": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:prebuild' && ./buildutils/node_prebuild.sh && echo '-> [DONE] Build:prebuild\n'",
+    "build:prebuild:pure": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:prebuild:pure (for only prebuild confirmation)' && GYP_DEFINES=openssl_fips= prebuild --strip --napi --path prebuilds && echo '-> [DONE] Build:prebuild:pure\n'",
+    "build:bundle:esm": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Build:bundle:esm' && echo '[NOTICE] Currently, rollup is NOT necessary, Does NOT use those outputed files, so do NOT run before packaging.' && rollup -c rollup.config.mjs && echo '-> [DONE] Build:bundle:esm\n'",
+    "prepublishOnly": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] PrepublishOnly' && echo '[INFO] Currently, no implementation. If there are signatures and final inspections, etc., the processing will be implemented here.' && echo '-> [DONE] PrepublishOnly\n'",
+    "lint": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Lint' && echo '[INFO] No linter configured' && echo '-> [DONE] Lint\n'",
+    "test": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test' && if [ ! -f build/cjs/index.js ]; then npm run build || exit 1; fi && npm run test:all && echo '-> [DONE] Test\n'",
+    "test:ci": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:ci' && if [ ! -f build/cjs/index.js ]; then echo '[ERROR] Not found build/cjs/index.js (build missing)'; exit 1; fi && npm run test:all && echo '-> [DONE] Test:ci\n'",
+    "test:all": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:all' && npm run test:smoke && tests/test.sh && echo '-> [DONE] Test:all\n'",
+    "test:smoke": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:smoke' && npm run test:smoke:cjs && npm run test:smoke:esm && npm run test:smoke:ts && echo '-> [DONE] Test:smoke\n'",
+    "test:smoke:cjs": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:smoke:cjs' && node tests/smoke_test_cjs.js && echo '-> [DONE] Test:smoke:cjs\n'",
+    "test:smoke:esm": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:smoke:esm' && node tests/smoke_test_esm.mjs && echo '-> [DONE] Test:smoke:esm\n'",
+    "test:smoke:ts": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:smoke:ts' && tsc --noEmit tests/smoke_test_ts.ts && echo '-> [DONE] Test:smoke:ts\n'",
+    "test:k2hash": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:k2hash' && tests/test.sh k2hash && echo '-> [DONE] Test:k2hash\n'",
+    "test:k2hqueue": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:k2hqueue' && tests/test.sh k2hqueue && echo '-> [DONE] Test:k2hqueue\n'",
+    "test:k2hkeyqueue": "export NPM_CONFIG_LOGLEVEL=silent && echo '[START] Test:k2hkeyqueue]' && tests/test.sh k2hkeyqueue && echo '-> [DONE] Test:k2hkeyqueue\n'"
   },
   "repository": {
     "type": "git",
@@ -44,15 +88,27 @@
     "transaction",
     "database",
     "queue",
-    "in-memory"
+    "in-memory",
+    "n-api",
+    "native",
+    "addon"
   ],
   "bugs": {
     "url": "http://github.com/yahoojapan/k2hash_nodejs/issues",
-    "email": "antpickax-support@mail.yahoo.co.jp"
+    "email": "ml-antpickax-support@lycorp.co.jp"
   },
   "author": "Takeshi Nakatani <ggtakec@gmail.com> (https://github.com/ggtakec)",
   "contributors": [
     "Hirotaka Wakabayashi <hiwakaba@lycorp.co.jp> (https://github.com/hiwakaba)"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
+  },
+  "engines": {
+    "node": ">=14"
+  }
 }

package/src/index.ts

@@ -0,0 +1,378 @@
+/*
+ * K2HASH
+ *
+ * Copyright 2015 Yahoo Japan Corporation.
+ *
+ * K2HASH is key-valuew store base libraries.
+ * K2HASH is made for the purpose of the construction of
+ * original KVS system and the offer of the library.
+ * The characteristic is this KVS library which Key can
+ * layer. And can support multi-processing and multi-thread,
+ * and is provided safely as available KVS.
+ *
+ * For the full copyright and license information, please view
+ * the license file that was distributed with this source code.
+ *
+ * AUTHOR:   Takeshi Nakatani
+ * CREATE:   Wed 19 Nov 2025
+ * REVISION:
+ */
+
+//---------------------------------------------------------
+// High-level TypeScript wrapper for the native k2hash addon
+//
+// [NOTE]
+// Implementation intentionally uses `any` for the native
+// binding because detailed types are provided in the
+// hand-written types/index.d.ts which will be included in
+// the package.
+//
+// Lazy-loading, compatibility-preserving implementation for
+// the k2hash package.
+//	- ensureNative() loads the native binding on first use.
+//	- copyPropsToFactory preserves callable default + named
+//	  properties.
+//	- createLazyProxy provides callable/constructible named
+//	  exports.
+//
+//---------------------------------------------------------
+// How to call this module supported(index.js/index.mjs)
+//---------------------------------------------------------
+//	- CommonJS
+//		const k2hash = require('k2hash');
+//		const k2h = k2hash();
+//
+//	- CommonJS(reference constuctor directly)
+//		const k2hash = require('k2hash');
+//		const K2hNode = k2hash.K2hNode;
+//		const k2h = k2hash();
+//
+//	- TypeScript(1)
+//		import k2hash from 'k2hash';
+//		const k2h = k2hash();
+//
+//	- TypeScript(2)
+//		import k2hash from 'k2hash';
+//		const k2h = new k2hash();
+//
+//	- TypeScript(3: compatible calling)
+//		import k2hash = require('k2hash');
+//		const k2h = k2hash();
+//
+//	- TypeScript(reference constuctor directly)
+//		import k2hash from 'k2hash';
+//		const K2hNode = k2hash.K2hNode;
+//		const k2h = k2hash();
+//
+//	- ESM(pure ES module files: guaranteed version)
+//		import { createRequire } from 'module';
+//		const require = createRequire(import.meta.url);
+//		const k2hash = require('k2hash');
+//		const k2h = k2hash();
+//---------------------------------------------------------
+
+type AnyFn = (...args: any[]) => any;
+
+let _native: any = undefined;
+let _nativeLoaded = false;
+
+// [NOTE]
+// Copy properties from native onto the factory(mirrors original runtime
+// normalization)
+// We try to preserve descriptors when possible.
+//
+function copyPropsToFactory(k2hashFactory: AnyFn, factory_native: any)
+{
+	if(!factory_native || (typeof factory_native !== 'object' && typeof factory_native !== 'function')){
+		return;
+	}
+
+	try{
+		Object.getOwnPropertyNames(factory_native).forEach((name) => {
+			if(name === 'prototype'){
+				return;
+			}
+			try{
+				const	desc = Object.getOwnPropertyDescriptor(factory_native, name);
+				if(desc){
+					Object.defineProperty(k2hashFactory, name, desc);
+				}
+			}catch{
+				try{
+					(k2hashFactory as any)[name] = factory_native[name];
+				}catch{
+					// ignore
+				}
+			}
+		});
+
+		Object.getOwnPropertySymbols(factory_native).forEach((sym) => {
+			try{
+				const	desc = Object.getOwnPropertyDescriptor(factory_native, sym as any);
+				if(desc){
+					Object.defineProperty(k2hashFactory, sym as any, desc);
+				}
+			}catch{
+				try{
+					(k2hashFactory as any)[sym as any] = factory_native[sym as any];
+				}catch{
+					// ignore
+				}
+			}
+		});
+	}catch{
+		// ignore odd cases(native undefined or primitive)
+	}
+
+	try{
+		if(factory_native && factory_native.K2hNode){
+			(k2hashFactory as any).K2hNode = factory_native.K2hNode;
+		}
+		if(factory_native && factory_native.K2hQueue){
+			(k2hashFactory as any).K2hQueue = factory_native.K2hQueue;
+		}
+		if(factory_native && factory_native.K2hKeyQueue){
+			(k2hashFactory as any).K2hKeyQueue = factory_native.K2hKeyQueue;
+		}
+	}catch{
+		// ignore
+	}
+}
+
+// [NOTE]
+// Load native on first need. Also call copyPropsToFactory once after
+// loading.
+// require('bindings') may throw if native not present at build/test time
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+//
+function ensureNative(): any
+{
+	if(_nativeLoaded){
+		return _native;
+	}
+	_nativeLoaded = true;
+
+	try{
+		const bindings = require('bindings');
+		_native = bindings('k2hash');
+	}catch{
+		_native = undefined;
+	}
+
+	// [NOTE]
+	// If we successfully loaded native, copy properties onto the factory so
+	//  default export retains the same shape as before (callable + named
+	//  properties).
+	//
+	if(_native){
+		try{
+			// [NOTE]
+			// k2hashFactory is hoisted(function declaration), safe to
+			// reference here
+			copyPropsToFactory(k2hashFactory as AnyFn, _native);
+		}catch{
+			// swallow copy errors to preserve robustness
+		}
+	}
+	return _native;
+}
+
+// [NOTE]
+// Default factory that mirrors previous behavior
+//
+function k2hashFactory(...args: any[]): any
+{
+	const _factory_native = ensureNative();
+	if(typeof _factory_native === 'function'){
+		try{
+			const retobj = (_factory_native as AnyFn).apply(null, args);
+			if(retobj !== undefined){
+				return retobj;
+			}
+		}catch{
+			// fallthrough to constructor fallback
+		}
+	}
+
+	if(_factory_native && typeof _factory_native.K2hNode === 'function'){
+		try{
+			return new _factory_native.K2hNode(...args);
+		}catch{
+			// fallthrough
+		}
+	}
+
+	// fallback: return native itself (could be an object with properties)
+	return _factory_native;
+}
+
+// [NOTE]
+// Returns a callable & constructible Proxy that forwards to native export
+//
+function createLazyProxy(name: string): AnyFn
+{
+	let _cached: any = undefined;
+
+	function loadActual()
+	{
+		if(_cached !== undefined){
+			return _cached;
+		}
+		const _lazy_native	= ensureNative();
+		const _actual		= _lazy_native && _lazy_native[name] ? _lazy_native[name] : undefined;
+		if(!_actual){
+			throw new Error("Native export " + JSON.stringify(name) + " is not available");
+		}
+		_cached = _actual;
+		return _cached;
+	}
+
+	const target = function (this: any, ...args: any[])
+	{
+		const _actual = loadActual();
+		return _actual.apply(this, args);
+	};
+
+	const handler: ProxyHandler<any> = {
+		apply(_t, thisArg, args) {
+			const _actual = loadActual();
+			return _actual.apply(thisArg, args);
+		},
+		construct(_t, args, newTarget) {
+			const _actual = loadActual();
+			return Reflect.construct(_actual, args, newTarget);
+		},
+		get(_t, prop, receiver) {
+			const _actual = loadActual();
+			return Reflect.get(_actual, prop, receiver);
+		},
+		set(_t, prop, value, receiver) {
+			const _actual = loadActual();
+			return Reflect.set(_actual, prop, value, receiver);
+		},
+		has(_t, prop) {
+			const _actual = loadActual();
+			return prop in _actual;
+		},
+		ownKeys(_t) {
+			const _actual = loadActual();
+			return Reflect.ownKeys(_actual);
+		},
+		getOwnPropertyDescriptor(_t, prop) {
+			const _actual = loadActual();
+			return Object.getOwnPropertyDescriptor(_actual, prop) || undefined;
+		},
+		getPrototypeOf(_t) {
+			const _actual = loadActual();
+			return Object.getPrototypeOf(_actual);
+		},
+		setPrototypeOf(_t, proto) {
+			const _actual = loadActual();
+			return Object.setPrototypeOf(_actual, proto);
+		},
+		defineProperty(_t, prop, descriptor) {
+			const _actual = loadActual();
+			return Reflect.defineProperty(_actual, prop, descriptor);
+		},
+		deleteProperty(_t, prop) {
+			const _actual = loadActual();
+			return Reflect.deleteProperty(_actual, prop);
+		}
+	};
+
+	return new Proxy(target as AnyFn, handler) as AnyFn;
+}
+
+//
+// Export named proxies to keep compatibility with existing consumers
+//
+// Named convenience exports (runtime values).
+// Types are provided by types/index.d.ts.
+//
+export const K2hNode		= createLazyProxy('K2hNode');
+export const K2hQueue		= createLazyProxy('K2hQueue');
+export const K2hKeyQueue	= createLazyProxy('K2hKeyQueue');
+
+export default k2hashFactory;
+
+//
+// Compatibility normalization for CommonJS output
+//
+// [NOTE]
+// When TypeScript/packager emits CommonJS, it can produce "module.exports = { default: ..., ... }"
+// which causes ESM consumers to get an object whose "default" is the callable factory.
+// Normalize module.exports so that "require(...)" yields a callable function while
+// preserving named properties.
+// This runs only in CommonJS environments and is intentionally defensive.
+//
+declare const module: any;
+
+try{
+	if(typeof module !== 'undefined' && module && module.exports){
+		const	own_module_export = module.exports as any;
+
+		//
+		// If module.exports is exactly { default: fn }, replace module.exports with fn.
+		//
+		if(	own_module_export													&&
+			typeof own_module_export === 'object'								&&
+			Object.prototype.hasOwnProperty.call(own_module_export, 'default')	&&
+			typeof own_module_export.default === 'function'						&&
+			Object.keys(own_module_export).length === 1							)
+		{
+			module.exports = own_module_export.default;
+
+		}else if(own_module_export && typeof own_module_export === 'object' && typeof own_module_export.default === 'function'){
+			//
+			// If default is a function but other named exports exist,
+			// prefer a top-level callable while preserving named props.
+			//
+			try{
+				const	defaultFn = own_module_export.default as Function;
+
+				// If top-level is not already callable, make it so.
+				if(typeof own_module_export !== 'function'){
+					// create a callable wrapper that forwards to defaultFn
+					const	callable = function(this: any, ...args: any[]){
+						return defaultFn.apply(this, args);
+					};
+
+					// copy named properties from original exports except 'default'
+					Object.keys(own_module_export).forEach((key) => {
+						if(key === 'default'){
+							return;
+						}
+						try{
+							(callable as any)[key] = own_module_export[key];
+						}catch{
+							// ignore
+						}
+					});
+
+					// preserve reference to original module
+					try{
+						(callable as any).__orig_module = own_module_export;
+					}catch{
+						// ignore
+					}
+
+					// replace module.exports with callable that also carries named props
+					module.exports = callable;
+				}
+			}catch{
+				// swallow normalization errors - not critical
+			}
+		}
+	}
+}catch{
+	// ignore
+}
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noexpandtab sw=4 ts=4 fdm=marker
+ * vim<600: noexpandtab sw=4 ts=4
+ */