@btst/stack 1.9.0 → 1.10.0

package/dist/node_modules/.pnpm/next-themes@0.4.6_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next-themes/dist/index.cjs

@@ -0,0 +1,23 @@
+"use client";
+'use strict';
+
+const React = require('react');
+
+function _interopNamespaceCompat(e) {
+	if (e && typeof e === 'object' && 'default' in e) return e;
+	const n = Object.create(null);
+	if (e) {
+		for (const k in e) {
+			n[k] = e[k];
+		}
+	}
+	n.default = e;
+	return n;
+}
+
+const React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+var M=(e,i,s,u,m,a,l,h)=>{let d=document.documentElement,w=["light","dark"];function p(n){(Array.isArray(e)?e:[e]).forEach(y=>{let k=y==="class",S=k&&a?m.map(f=>a[f]||f):m;k?(d.classList.remove(...S),d.classList.add(a&&a[n]?a[n]:n)):d.setAttribute(y,n);}),R(n);}function R(n){h&&w.includes(n)&&(d.style.colorScheme=n);}function c(){return window.matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"}if(u)p(u);else try{let n=localStorage.getItem(i)||s,y=l&&n==="system"?c():n;p(y);}catch(n){}};var b=["light","dark"],I="(prefers-color-scheme: dark)",O=typeof window=="undefined",x=React__namespace.createContext(void 0),U={setTheme:e=>{},themes:[]},z=()=>{var e;return (e=React__namespace.useContext(x))!=null?e:U},J=e=>React__namespace.useContext(x)?React__namespace.createElement(React__namespace.Fragment,null,e.children):React__namespace.createElement(V,{...e}),N=["light","dark"],V=({forcedTheme:e,disableTransitionOnChange:i=false,enableSystem:s=true,enableColorScheme:u=true,storageKey:m="theme",themes:a=N,defaultTheme:l=s?"system":"light",attribute:h="data-theme",value:d,children:w,nonce:p,scriptProps:R})=>{let[c,n]=React__namespace.useState(()=>H(m,l)),[T,y]=React__namespace.useState(()=>c==="system"?E():c),k=d?Object.values(d):a,S=React__namespace.useCallback(o=>{let r=o;if(!r)return;o==="system"&&s&&(r=E());let v=d?d[r]:r,C=i?W(p):null,P=document.documentElement,L=g=>{g==="class"?(P.classList.remove(...k),v&&P.classList.add(v)):g.startsWith("data-")&&(v?P.setAttribute(g,v):P.removeAttribute(g));};if(Array.isArray(h)?h.forEach(L):L(h),u){let g=b.includes(l)?l:null,D=b.includes(r)?r:g;P.style.colorScheme=D;}C==null||C();},[p]),f=React__namespace.useCallback(o=>{let r=typeof o=="function"?o(c):o;n(r);try{localStorage.setItem(m,r);}catch(v){}},[c]),A=React__namespace.useCallback(o=>{let r=E(o);y(r),c==="system"&&s&&!e&&S("system");},[c,e]);React__namespace.useEffect(()=>{let o=window.matchMedia(I);return o.addListener(A),A(o),()=>o.removeListener(A)},[A]),React__namespace.useEffect(()=>{let o=r=>{r.key===m&&(r.newValue?n(r.newValue):f(l));};return window.addEventListener("storage",o),()=>window.removeEventListener("storage",o)},[f]),React__namespace.useEffect(()=>{S(e!=null?e:c);},[e,c]);let Q=React__namespace.useMemo(()=>({theme:c,setTheme:f,forcedTheme:e,resolvedTheme:c==="system"?T:c,themes:s?[...a,"system"]:a,systemTheme:s?T:void 0}),[c,f,e,T,s,a]);return React__namespace.createElement(x.Provider,{value:Q},React__namespace.createElement(_,{forcedTheme:e,storageKey:m,attribute:h,enableSystem:s,enableColorScheme:u,defaultTheme:l,value:d,themes:a,nonce:p,scriptProps:R}),w)},_=React__namespace.memo(({forcedTheme:e,storageKey:i,attribute:s,enableSystem:u,enableColorScheme:m,defaultTheme:a,value:l,themes:h,nonce:d,scriptProps:w})=>{let p=JSON.stringify([s,i,a,e,h,l,u,m]).slice(1,-1);return React__namespace.createElement("script",{...w,suppressHydrationWarning:true,nonce:typeof window=="undefined"?d:"",dangerouslySetInnerHTML:{__html:`(${M.toString()})(${p})`}})}),H=(e,i)=>{if(O)return;let s;try{s=localStorage.getItem(e)||void 0;}catch(u){}return s||i},W=e=>{let i=document.createElement("style");return e&&i.setAttribute("nonce",e),i.appendChild(document.createTextNode("*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}")),document.head.appendChild(i),()=>{window.getComputedStyle(document.body),setTimeout(()=>{document.head.removeChild(i);},1);}},E=e=>(e||(e=window.matchMedia(I)),e.matches?"dark":"light");
+
+exports.ThemeProvider = J;
+exports.useTheme = z;

package/dist/node_modules/.pnpm/next-themes@0.4.6_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next-themes/dist/index.mjs

@@ -0,0 +1,6 @@
+"use client";
+import * as React from 'react';
+
+var M=(e,i,s,u,m,a,l,h)=>{let d=document.documentElement,w=["light","dark"];function p(n){(Array.isArray(e)?e:[e]).forEach(y=>{let k=y==="class",S=k&&a?m.map(f=>a[f]||f):m;k?(d.classList.remove(...S),d.classList.add(a&&a[n]?a[n]:n)):d.setAttribute(y,n);}),R(n);}function R(n){h&&w.includes(n)&&(d.style.colorScheme=n);}function c(){return window.matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"}if(u)p(u);else try{let n=localStorage.getItem(i)||s,y=l&&n==="system"?c():n;p(y);}catch(n){}};var b=["light","dark"],I="(prefers-color-scheme: dark)",O=typeof window=="undefined",x=React.createContext(void 0),U={setTheme:e=>{},themes:[]},z=()=>{var e;return (e=React.useContext(x))!=null?e:U},J=e=>React.useContext(x)?React.createElement(React.Fragment,null,e.children):React.createElement(V,{...e}),N=["light","dark"],V=({forcedTheme:e,disableTransitionOnChange:i=false,enableSystem:s=true,enableColorScheme:u=true,storageKey:m="theme",themes:a=N,defaultTheme:l=s?"system":"light",attribute:h="data-theme",value:d,children:w,nonce:p,scriptProps:R})=>{let[c,n]=React.useState(()=>H(m,l)),[T,y]=React.useState(()=>c==="system"?E():c),k=d?Object.values(d):a,S=React.useCallback(o=>{let r=o;if(!r)return;o==="system"&&s&&(r=E());let v=d?d[r]:r,C=i?W(p):null,P=document.documentElement,L=g=>{g==="class"?(P.classList.remove(...k),v&&P.classList.add(v)):g.startsWith("data-")&&(v?P.setAttribute(g,v):P.removeAttribute(g));};if(Array.isArray(h)?h.forEach(L):L(h),u){let g=b.includes(l)?l:null,D=b.includes(r)?r:g;P.style.colorScheme=D;}C==null||C();},[p]),f=React.useCallback(o=>{let r=typeof o=="function"?o(c):o;n(r);try{localStorage.setItem(m,r);}catch(v){}},[c]),A=React.useCallback(o=>{let r=E(o);y(r),c==="system"&&s&&!e&&S("system");},[c,e]);React.useEffect(()=>{let o=window.matchMedia(I);return o.addListener(A),A(o),()=>o.removeListener(A)},[A]),React.useEffect(()=>{let o=r=>{r.key===m&&(r.newValue?n(r.newValue):f(l));};return window.addEventListener("storage",o),()=>window.removeEventListener("storage",o)},[f]),React.useEffect(()=>{S(e!=null?e:c);},[e,c]);let Q=React.useMemo(()=>({theme:c,setTheme:f,forcedTheme:e,resolvedTheme:c==="system"?T:c,themes:s?[...a,"system"]:a,systemTheme:s?T:void 0}),[c,f,e,T,s,a]);return React.createElement(x.Provider,{value:Q},React.createElement(_,{forcedTheme:e,storageKey:m,attribute:h,enableSystem:s,enableColorScheme:u,defaultTheme:l,value:d,themes:a,nonce:p,scriptProps:R}),w)},_=React.memo(({forcedTheme:e,storageKey:i,attribute:s,enableSystem:u,enableColorScheme:m,defaultTheme:a,value:l,themes:h,nonce:d,scriptProps:w})=>{let p=JSON.stringify([s,i,a,e,h,l,u,m]).slice(1,-1);return React.createElement("script",{...w,suppressHydrationWarning:true,nonce:typeof window=="undefined"?d:"",dangerouslySetInnerHTML:{__html:`(${M.toString()})(${p})`}})}),H=(e,i)=>{if(O)return;let s;try{s=localStorage.getItem(e)||void 0;}catch(u){}return s||i},W=e=>{let i=document.createElement("style");return e&&i.setAttribute("nonce",e),i.appendChild(document.createTextNode("*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}")),document.head.appendChild(i),()=>{window.getComputedStyle(document.body),setTimeout(()=>{document.head.removeChild(i);},1);}},E=e=>(e||(e=window.matchMedia(I)),e.matches?"dark":"light");
+
+export { J as ThemeProvider, z as useTheme };

package/dist/node_modules/.pnpm/object-hash@3.0.0/node_modules/object-hash/index.cjs

@@ -0,0 +1,472 @@
+'use strict';
+
+const index = require('../../../../../_virtual/index7.cjs');
+const require$$0 = require('crypto');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
+
+var hasRequiredObjectHash;
+
+function requireObjectHash () {
+	if (hasRequiredObjectHash) return index.__module.exports;
+	hasRequiredObjectHash = 1;
+	(function (module, exports$1) {
+
+		var crypto = require$$0__default;
+
+		/**
+		 * Exported function
+		 *
+		 * Options:
+		 *
+		 *  - `algorithm` hash algo to be used by this instance: *'sha1', 'md5'
+		 *  - `excludeValues` {true|*false} hash object keys, values ignored
+		 *  - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64'
+		 *  - `ignoreUnknown` {true|*false} ignore unknown object types
+		 *  - `replacer` optional function that replaces values before hashing
+		 *  - `respectFunctionProperties` {*true|false} consider function properties when hashing
+		 *  - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing
+		 *  - `respectType` {*true|false} Respect special properties (prototype, constructor)
+		 *    when hashing to distinguish between types
+		 *  - `unorderedArrays` {true|*false} Sort all arrays before hashing
+		 *  - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing
+		 *  * = default
+		 *
+		 * @param {object} object value to hash
+		 * @param {object} options hashing options
+		 * @return {string} hash value
+		 * @api public
+		 */
+		exports$1 = module.exports = objectHash;
+
+		function objectHash(object, options){
+		  options = applyDefaults(object, options);
+
+		  return hash(object, options);
+		}
+
+		/**
+		 * Exported sugar methods
+		 *
+		 * @param {object} object value to hash
+		 * @return {string} hash value
+		 * @api public
+		 */
+		exports$1.sha1 = function(object){
+		  return objectHash(object);
+		};
+		exports$1.keys = function(object){
+		  return objectHash(object, {excludeValues: true, algorithm: 'sha1', encoding: 'hex'});
+		};
+		exports$1.MD5 = function(object){
+		  return objectHash(object, {algorithm: 'md5', encoding: 'hex'});
+		};
+		exports$1.keysMD5 = function(object){
+		  return objectHash(object, {algorithm: 'md5', encoding: 'hex', excludeValues: true});
+		};
+
+		// Internals
+		var hashes = crypto.getHashes ? crypto.getHashes().slice() : ['sha1', 'md5'];
+		hashes.push('passthrough');
+		var encodings = ['buffer', 'hex', 'binary', 'base64'];
+
+		function applyDefaults(object, sourceOptions){
+		  sourceOptions = sourceOptions || {};
+
+		  // create a copy rather than mutating
+		  var options = {};
+		  options.algorithm = sourceOptions.algorithm || 'sha1';
+		  options.encoding = sourceOptions.encoding || 'hex';
+		  options.excludeValues = sourceOptions.excludeValues ? true : false;
+		  options.algorithm = options.algorithm.toLowerCase();
+		  options.encoding = options.encoding.toLowerCase();
+		  options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false
+		  options.respectType = sourceOptions.respectType === false ? false : true; // default to true
+		  options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+		  options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+		  options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false
+		  options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false
+		  options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true
+		  options.replacer = sourceOptions.replacer || undefined;
+		  options.excludeKeys = sourceOptions.excludeKeys || undefined;
+
+		  if(typeof object === 'undefined') {
+		    throw new Error('Object argument required.');
+		  }
+
+		  // if there is a case-insensitive match in the hashes list, accept it
+		  // (i.e. SHA256 for sha256)
+		  for (var i = 0; i < hashes.length; ++i) {
+		    if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
+		      options.algorithm = hashes[i];
+		    }
+		  }
+
+		  if(hashes.indexOf(options.algorithm) === -1){
+		    throw new Error('Algorithm "' + options.algorithm + '"  not supported. ' +
+		      'supported values: ' + hashes.join(', '));
+		  }
+
+		  if(encodings.indexOf(options.encoding) === -1 &&
+		     options.algorithm !== 'passthrough'){
+		    throw new Error('Encoding "' + options.encoding + '"  not supported. ' +
+		      'supported values: ' + encodings.join(', '));
+		  }
+
+		  return options;
+		}
+
+		/** Check if the given function is a native function */
+		function isNativeFunction(f) {
+		  if ((typeof f) !== 'function') {
+		    return false;
+		  }
+		  var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+		  return exp.exec(Function.prototype.toString.call(f)) != null;
+		}
+
+		function hash(object, options) {
+		  var hashingStream;
+
+		  if (options.algorithm !== 'passthrough') {
+		    hashingStream = crypto.createHash(options.algorithm);
+		  } else {
+		    hashingStream = new PassThrough();
+		  }
+
+		  if (typeof hashingStream.write === 'undefined') {
+		    hashingStream.write = hashingStream.update;
+		    hashingStream.end   = hashingStream.update;
+		  }
+
+		  var hasher = typeHasher(options, hashingStream);
+		  hasher.dispatch(object);
+		  if (!hashingStream.update) {
+		    hashingStream.end('');
+		  }
+
+		  if (hashingStream.digest) {
+		    return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding);
+		  }
+
+		  var buf = hashingStream.read();
+		  if (options.encoding === 'buffer') {
+		    return buf;
+		  }
+
+		  return buf.toString(options.encoding);
+		}
+
+		/**
+		 * Expose streaming API
+		 *
+		 * @param {object} object  Value to serialize
+		 * @param {object} options  Options, as for hash()
+		 * @param {object} stream  A stream to write the serializiation to
+		 * @api public
+		 */
+		exports$1.writeToStream = function(object, options, stream) {
+		  if (typeof stream === 'undefined') {
+		    stream = options;
+		    options = {};
+		  }
+
+		  options = applyDefaults(object, options);
+
+		  return typeHasher(options, stream).dispatch(object);
+		};
+
+		function typeHasher(options, writeTo, context){
+		  context = context || [];
+		  var write = function(str) {
+		    if (writeTo.update) {
+		      return writeTo.update(str, 'utf8');
+		    } else {
+		      return writeTo.write(str, 'utf8');
+		    }
+		  };
+
+		  return {
+		    dispatch: function(value){
+		      if (options.replacer) {
+		        value = options.replacer(value);
+		      }
+
+		      var type = typeof value;
+		      if (value === null) {
+		        type = 'null';
+		      }
+
+		      //console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type);
+
+		      return this['_' + type](value);
+		    },
+		    _object: function(object) {
+		      var pattern = (/\[object (.*)\]/i);
+		      var objString = Object.prototype.toString.call(object);
+		      var objType = pattern.exec(objString);
+		      if (!objType) { // object type did not match [object ...]
+		        objType = 'unknown:[' + objString + ']';
+		      } else {
+		        objType = objType[1]; // take only the class name
+		      }
+
+		      objType = objType.toLowerCase();
+
+		      var objectNumber = null;
+
+		      if ((objectNumber = context.indexOf(object)) >= 0) {
+		        return this.dispatch('[CIRCULAR:' + objectNumber + ']');
+		      } else {
+		        context.push(object);
+		      }
+
+		      if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) {
+		        write('buffer:');
+		        return write(object);
+		      }
+
+		      if(objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') {
+		        if(this['_' + objType]) {
+		          this['_' + objType](object);
+		        } else if (options.ignoreUnknown) {
+		          return write('[' + objType + ']');
+		        } else {
+		          throw new Error('Unknown object type "' + objType + '"');
+		        }
+		      }else {
+		        var keys = Object.keys(object);
+		        if (options.unorderedObjects) {
+		          keys = keys.sort();
+		        }
+		        // Make sure to incorporate special properties, so
+		        // Types with different prototypes will produce
+		        // a different hash and objects derived from
+		        // different functions (`new Foo`, `new Bar`) will
+		        // produce different hashes.
+		        // We never do this for native functions since some
+		        // seem to break because of that.
+		        if (options.respectType !== false && !isNativeFunction(object)) {
+		          keys.splice(0, 0, 'prototype', '__proto__', 'constructor');
+		        }
+
+		        if (options.excludeKeys) {
+		          keys = keys.filter(function(key) { return !options.excludeKeys(key); });
+		        }
+
+		        write('object:' + keys.length + ':');
+		        var self = this;
+		        return keys.forEach(function(key){
+		          self.dispatch(key);
+		          write(':');
+		          if(!options.excludeValues) {
+		            self.dispatch(object[key]);
+		          }
+		          write(',');
+		        });
+		      }
+		    },
+		    _array: function(arr, unordered){
+		      unordered = typeof unordered !== 'undefined' ? unordered :
+		        options.unorderedArrays !== false; // default to options.unorderedArrays
+
+		      var self = this;
+		      write('array:' + arr.length + ':');
+		      if (!unordered || arr.length <= 1) {
+		        return arr.forEach(function(entry) {
+		          return self.dispatch(entry);
+		        });
+		      }
+
+		      // the unordered case is a little more complicated:
+		      // since there is no canonical ordering on objects,
+		      // i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false,
+		      // we first serialize each entry using a PassThrough stream
+		      // before sorting.
+		      // also: we can’t use the same context array for all entries
+		      // since the order of hashing should *not* matter. instead,
+		      // we keep track of the additions to a copy of the context array
+		      // and add all of them to the global context array when we’re done
+		      var contextAdditions = [];
+		      var entries = arr.map(function(entry) {
+		        var strm = new PassThrough();
+		        var localContext = context.slice(); // make copy
+		        var hasher = typeHasher(options, strm, localContext);
+		        hasher.dispatch(entry);
+		        // take only what was added to localContext and append it to contextAdditions
+		        contextAdditions = contextAdditions.concat(localContext.slice(context.length));
+		        return strm.read().toString();
+		      });
+		      context = context.concat(contextAdditions);
+		      entries.sort();
+		      return this._array(entries, false);
+		    },
+		    _date: function(date){
+		      return write('date:' + date.toJSON());
+		    },
+		    _symbol: function(sym){
+		      return write('symbol:' + sym.toString());
+		    },
+		    _error: function(err){
+		      return write('error:' + err.toString());
+		    },
+		    _boolean: function(bool){
+		      return write('bool:' + bool.toString());
+		    },
+		    _string: function(string){
+		      write('string:' + string.length + ':');
+		      write(string.toString());
+		    },
+		    _function: function(fn){
+		      write('fn:');
+		      if (isNativeFunction(fn)) {
+		        this.dispatch('[native]');
+		      } else {
+		        this.dispatch(fn.toString());
+		      }
+
+		      if (options.respectFunctionNames !== false) {
+		        // Make sure we can still distinguish native functions
+		        // by their name, otherwise String and Function will
+		        // have the same hash
+		        this.dispatch("function-name:" + String(fn.name));
+		      }
+
+		      if (options.respectFunctionProperties) {
+		        this._object(fn);
+		      }
+		    },
+		    _number: function(number){
+		      return write('number:' + number.toString());
+		    },
+		    _xml: function(xml){
+		      return write('xml:' + xml.toString());
+		    },
+		    _null: function() {
+		      return write('Null');
+		    },
+		    _undefined: function() {
+		      return write('Undefined');
+		    },
+		    _regexp: function(regex){
+		      return write('regex:' + regex.toString());
+		    },
+		    _uint8array: function(arr){
+		      write('uint8array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _uint8clampedarray: function(arr){
+		      write('uint8clampedarray:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _int8array: function(arr){
+		      write('int8array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _uint16array: function(arr){
+		      write('uint16array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _int16array: function(arr){
+		      write('int16array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _uint32array: function(arr){
+		      write('uint32array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _int32array: function(arr){
+		      write('int32array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _float32array: function(arr){
+		      write('float32array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _float64array: function(arr){
+		      write('float64array:');
+		      return this.dispatch(Array.prototype.slice.call(arr));
+		    },
+		    _arraybuffer: function(arr){
+		      write('arraybuffer:');
+		      return this.dispatch(new Uint8Array(arr));
+		    },
+		    _url: function(url) {
+		      return write('url:' + url.toString());
+		    },
+		    _map: function(map) {
+		      write('map:');
+		      var arr = Array.from(map);
+		      return this._array(arr, options.unorderedSets !== false);
+		    },
+		    _set: function(set) {
+		      write('set:');
+		      var arr = Array.from(set);
+		      return this._array(arr, options.unorderedSets !== false);
+		    },
+		    _file: function(file) {
+		      write('file:');
+		      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+		    },
+		    _blob: function() {
+		      if (options.ignoreUnknown) {
+		        return write('[blob]');
+		      }
+
+		      throw Error('Hashing Blob objects is currently not supported\n' +
+		        '(see https://github.com/puleos/object-hash/issues/26)\n' +
+		        'Use "options.replacer" or "options.ignoreUnknown"\n');
+		    },
+		    _domwindow: function() { return write('domwindow'); },
+		    _bigint: function(number){
+		      return write('bigint:' + number.toString());
+		    },
+		    /* Node.js standard native objects */
+		    _process: function() { return write('process'); },
+		    _timer: function() { return write('timer'); },
+		    _pipe: function() { return write('pipe'); },
+		    _tcp: function() { return write('tcp'); },
+		    _udp: function() { return write('udp'); },
+		    _tty: function() { return write('tty'); },
+		    _statwatcher: function() { return write('statwatcher'); },
+		    _securecontext: function() { return write('securecontext'); },
+		    _connection: function() { return write('connection'); },
+		    _zlib: function() { return write('zlib'); },
+		    _context: function() { return write('context'); },
+		    _nodescript: function() { return write('nodescript'); },
+		    _httpparser: function() { return write('httpparser'); },
+		    _dataview: function() { return write('dataview'); },
+		    _signal: function() { return write('signal'); },
+		    _fsevent: function() { return write('fsevent'); },
+		    _tlswrap: function() { return write('tlswrap'); },
+		  };
+		}
+
+		// Mini-implementation of stream.PassThrough
+		// We are far from having need for the full implementation, and we can
+		// make assumptions like "many writes, then only one final read"
+		// and we can ignore encoding specifics
+		function PassThrough() {
+		  return {
+		    buf: '',
+
+		    write: function(b) {
+		      this.buf += b;
+		    },
+
+		    end: function(b) {
+		      this.buf += b;
+		    },
+
+		    read: function() {
+		      return this.buf;
+		    }
+		  };
+		} 
+	} (index.__module, index.__module.exports));
+	return index.__module.exports;
+}
+
+exports.__require = requireObjectHash;