fake-node 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 speedydelete
+
+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/globals.ts

@@ -0,0 +1,38 @@
+
+import {Buffer} from './modules/buffer';
+import * as process from './modules/process';
+
+// todo: properly implement eval
+const ES_GLOBALS = {Infinity, NaN, undefined, eval, isFinite, isNaN, parseFloat, parseInt, decodeURI, decodeURIComponent, encodeURI, encodeURIComponent, escape, unescape, Object, Function, Boolean, Symbol, Error, AggregateError, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError, Number, BigInt, Math, Date, String, RegExp, Array, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array, BigUint64Array, Float32Array, Float64Array, Map, Set, WeakMap, WeakSet, ArrayBuffer, SharedArrayBuffer, DataView, Atomics, JSON, WeakRef, FinalizationRegistry, Promise, Reflect, Proxy, Intl};
+
+const WEB_ONLY_GLOBALS: string[] = ['webkitSpeechRecognitionEvent', 'webkitSpeechRecognitionError', 'webkitSpeechRecognition', 'webkitSpeechGrammarList', 'webkitSpeechGrammar', 'WebSocketStream', 'WebSocketError', 'ViewTransitionTypeSet', 'SpeechSynthesisVoice', 'SpeechSynthesisUtterance', 'SpeechSynthesisEvent', 'SpeechSynthesisErrorEvent', 'SpeechSynthesis', 'SnapEvent', 'SharedWorker', 'SharedStorageWorklet', 'SharedStorage', 'ViewTimeline', 'ScrollTimeline', 'RemotePlayback', 'RTCDataChannel', 'PushSubscriptionOptions', 'PushSubscription', 'PushManager', 'Permissions', 'PermissionStatus', 'PeriodicSyncManager', 'PerformanceScriptTiming', 'PerformanceLongAnimationFrameTiming', 'PageSwapEvent', 'PageRevealEvent', 'Notification', 'NavigationActivation', 'MediaSession', 'MediaMetadata', 'HTMLFencedFrameElement', 'FencedFrameConfig', 'Fence', 'DocumentPictureInPictureEvent', 'CropTarget', 'ChapterInformation', 'CaretPosition', 'CSSViewTransitionRule', 'CSSNestedDeclarations', 'CSSMarginRule', 'BluetoothUUID', 'BackgroundFetchRegistration', 'BackgroundFetchRecord', 'BackgroundFetchManager', 'Option', 'Image', 'Audio', 'webkitURL', 'webkitRTCPeerConnection', 'webkitMediaStream', 'WebKitMutationObserver', 'WebKitCSSMatrix', 'XSLTProcessor', 'XPathResult', 'XPathExpression', 'XPathEvaluator', 'XMLSerializer', 'XMLHttpRequestUpload', 'XMLHttpRequestEventTarget', 'XMLHttpRequest', 'XMLDocument', 'Worker', 'WindowControlsOverlayGeometryChangeEvent', 'WindowControlsOverlay', 'Window', 'WheelEvent', 'WebGLVertexArrayObject', 'WebGLUniformLocation', 'WebGLTransformFeedback', 'WebGLTexture', 'WebGLSync', 'WebGLShaderPrecisionFormat', 'WebGLShader', 'WebGLSampler', 'WebGLRenderingContext', 'WebGLRenderbuffer', 'WebGLQuery', 'WebGLProgram', 'WebGLObject', 'WebGLFramebuffer', 'WebGLContextEvent', 'WebGLBuffer', 'WebGLActiveInfo', 'WebGL2RenderingContext', 'WaveShaperNode', 'VisualViewport', 'VisibilityStateEntry', 'VirtualKeyboardGeometryChangeEvent', 'ViewTransition', 'VideoPlaybackQuality', 'VideoFrame', 'VideoColorSpace', 'ValidityState', 'VTTCue', 'UserActivation', 'URLPattern', 'UIEvent', 'TrustedTypePolicyFactory', 'TrustedTypePolicy', 'TrustedScriptURL', 'TrustedScript', 'TrustedHTML', 'TreeWalker', 'TransitionEvent', 'TransformStream', 'TrackEvent', 'TouchList', 'TouchEvent', 'Touch', 'ToggleEvent', 'TimeRanges', 'TextUpdateEvent', 'TextTrackList', 'TextTrackCueList', 'TextTrackCue', 'TextTrack', 'TextMetrics', 'TextFormatUpdateEvent', 'TextFormat', 'TextEvent', 'Text', 'TaskSignal', 'TaskPriorityChangeEvent', 'TaskController', 'TaskAttributionTiming', 'SyncManager', 'SubmitEvent', 'StyleSheetList', 'StyleSheet', 'StylePropertyMapReadOnly', 'StylePropertyMap', 'StorageEvent', 'StereoPannerNode', 'StaticRange', 'SourceBufferList', 'SourceBuffer', 'ShadowRoot', 'Selection', 'SecurityPolicyViolationEvent', 'ScriptProcessorNode', 'ScreenOrientation', 'Screen', 'Scheduling', 'Scheduler', 'SVGViewElement', 'SVGUseElement', 'SVGUnitTypes', 'SVGTransformList', 'SVGTransform', 'SVGTitleElement', 'SVGTextPositioningElement', 'SVGTextPathElement', 'SVGTextElement', 'SVGTextContentElement', 'SVGTSpanElement', 'SVGSymbolElement', 'SVGSwitchElement', 'SVGStyleElement', 'SVGStringList', 'SVGStopElement', 'SVGSetElement', 'SVGScriptElement', 'SVGSVGElement', 'SVGRectElement', 'SVGRect', 'SVGRadialGradientElement', 'SVGPreserveAspectRatio', 'SVGPolylineElement', 'SVGPolygonElement', 'SVGPointList', 'SVGPoint', 'SVGPatternElement', 'SVGPathElement', 'SVGNumberList', 'SVGNumber', 'SVGMetadataElement', 'SVGMatrix', 'SVGMaskElement', 'SVGMarkerElement', 'SVGMPathElement', 'SVGLinearGradientElement', 'SVGLineElement', 'SVGLengthList', 'SVGLength', 'SVGImageElement', 'SVGGraphicsElement', 'SVGGradientElement', 'SVGGeometryElement', 'SVGGElement', 'SVGForeignObjectElement', 'SVGFilterElement', 'SVGFETurbulenceElement', 'SVGFETileElement', 'SVGFESpotLightElement', 'SVGFESpecularLightingElement', 'SVGFEPointLightElement', 'SVGFEOffsetElement', 'SVGFEMorphologyElement', 'SVGFEMergeNodeElement', 'SVGFEMergeElement', 'SVGFEImageElement', 'SVGFEGaussianBlurElement', 'SVGFEFuncRElement', 'SVGFEFuncGElement', 'SVGFEFuncBElement', 'SVGFEFuncAElement', 'SVGFEFloodElement', 'SVGFEDropShadowElement', 'SVGFEDistantLightElement', 'SVGFEDisplacementMapElement', 'SVGFEDiffuseLightingElement', 'SVGFEConvolveMatrixElement', 'SVGFECompositeElement', 'SVGFEComponentTransferElement', 'SVGFEColorMatrixElement', 'SVGFEBlendElement', 'SVGEllipseElement', 'SVGElement', 'SVGDescElement', 'SVGDefsElement', 'SVGComponentTransferFunctionElement', 'SVGClipPathElement', 'SVGCircleElement', 'SVGAnimationElement', 'SVGAnimatedTransformList', 'SVGAnimatedString', 'SVGAnimatedRect', 'SVGAnimatedPreserveAspectRatio', 'SVGAnimatedNumberList', 'SVGAnimatedNumber', 'SVGAnimatedLengthList', 'SVGAnimatedLength', 'SVGAnimatedInteger', 'SVGAnimatedEnumeration', 'SVGAnimatedBoolean', 'SVGAnimatedAngle', 'SVGAnimateTransformElement', 'SVGAnimateMotionElement', 'SVGAnimateElement', 'SVGAngle', 'SVGAElement', 'ResizeObserverSize', 'ResizeObserverEntry', 'ResizeObserver', 'ReportingObserver', 'ReadableStreamDefaultReader', 'ReadableStreamDefaultController', 'ReadableStreamBYOBRequest', 'ReadableStreamBYOBReader', 'ReadableStream', 'Range', 'RadioNodeList', 'RTCTrackEvent', 'RTCStatsReport', 'RTCSessionDescription', 'RTCSctpTransport', 'RTCRtpTransceiver', 'RTCRtpSender', 'RTCRtpReceiver', 'RTCPeerConnectionIceEvent', 'RTCPeerConnectionIceErrorEvent', 'RTCPeerConnection', 'RTCIceTransport', 'RTCIceCandidate', 'RTCErrorEvent', 'RTCError', 'RTCEncodedVideoFrame', 'RTCEncodedAudioFrame', 'RTCDtlsTransport', 'RTCDataChannelEvent', 'RTCDTMFToneChangeEvent', 'RTCDTMFSender', 'RTCCertificate', 'PromiseRejectionEvent', 'ProgressEvent', 'Profiler', 'ProcessingInstruction', 'PopStateEvent', 'PointerEvent', 'PluginArray', 'Plugin', 'PictureInPictureWindow', 'PictureInPictureEvent', 'PeriodicWave', 'PerformanceTiming', 'PerformanceServerTiming', 'PerformancePaintTiming', 'PerformanceObserverEntryList', 'PerformanceNavigationTiming', 'PerformanceNavigation', 'PerformanceLongTaskTiming', 'PerformanceEventTiming', 'PerformanceElementTiming', 'Performance', 'Path2D', 'PannerNode', 'PageTransitionEvent', 'OverconstrainedError', 'OscillatorNode', 'OffscreenCanvasRenderingContext2D', 'OffscreenCanvas', 'OfflineAudioContext', 'OfflineAudioCompletionEvent', 'NodeList', 'NodeIterator', 'NodeFilter', 'Node', 'NetworkInformation', 'NavigatorUAData', 'NavigationTransition', 'NavigationHistoryEntry', 'NavigationDestination', 'NavigationCurrentEntryChangeEvent', 'Navigation', 'NavigateEvent', 'NamedNodeMap', 'MutationRecord', 'MutationObserver', 'MouseEvent', 'MimeTypeArray', 'MimeType', 'MediaStreamTrackVideoStats', 'MediaStreamTrackProcessor', 'MediaStreamTrackGenerator', 'MediaStreamTrackEvent', 'MediaStreamTrackAudioStats', 'MediaStreamTrack', 'MediaStreamEvent', 'MediaStreamAudioSourceNode', 'MediaStreamAudioDestinationNode', 'MediaStream', 'MediaSourceHandle', 'MediaSource', 'MediaRecorder', 'MediaQueryListEvent', 'MediaQueryList', 'MediaList', 'MediaError', 'MediaEncryptedEvent', 'MediaElementAudioSourceNode', 'MediaCapabilities', 'MathMLElement', 'Location', 'LayoutShiftAttribution', 'LayoutShift', 'LargestContentfulPaint', 'KeyframeEffect', 'KeyboardEvent', 'IntersectionObserverEntry', 'IntersectionObserver', 'InputEvent', 'InputDeviceInfo', 'InputDeviceCapabilities', 'Ink', 'ImageData', 'ImageCapture', 'ImageBitmapRenderingContext', 'ImageBitmap', 'IdleDeadline', 'IIRFilterNode', 'IDBVersionChangeEvent', 'IDBTransaction', 'IDBRequest', 'IDBOpenDBRequest', 'IDBObjectStore', 'IDBKeyRange', 'IDBIndex', 'IDBFactory', 'IDBDatabase', 'IDBCursorWithValue', 'IDBCursor', 'History', 'HighlightRegistry', 'Highlight', 'HashChangeEvent', 'HTMLVideoElement', 'HTMLUnknownElement', 'HTMLUListElement', 'HTMLTrackElement', 'HTMLTitleElement', 'HTMLTimeElement', 'HTMLTextAreaElement', 'HTMLTemplateElement', 'HTMLTableSectionElement', 'HTMLTableRowElement', 'HTMLTableElement', 'HTMLTableColElement', 'HTMLTableCellElement', 'HTMLTableCaptionElement', 'HTMLStyleElement', 'HTMLSpanElement', 'HTMLSourceElement', 'HTMLSlotElement', 'HTMLSelectElement', 'HTMLScriptElement', 'HTMLQuoteElement', 'HTMLProgressElement', 'HTMLPreElement', 'HTMLPictureElement', 'HTMLParamElement', 'HTMLParagraphElement', 'HTMLOutputElement', 'HTMLOptionsCollection', 'HTMLOptionElement', 'HTMLOptGroupElement', 'HTMLObjectElement', 'HTMLOListElement', 'HTMLModElement', 'HTMLMeterElement', 'HTMLMetaElement', 'HTMLMenuElement', 'HTMLMediaElement', 'HTMLMarqueeElement', 'HTMLMapElement', 'HTMLLinkElement', 'HTMLLegendElement', 'HTMLLabelElement', 'HTMLLIElement', 'HTMLInputElement', 'HTMLImageElement', 'HTMLIFrameElement', 'HTMLHtmlElement', 'HTMLHeadingElement', 'HTMLHeadElement', 'HTMLHRElement', 'HTMLFrameSetElement', 'HTMLFrameElement', 'HTMLFormElement', 'HTMLFormControlsCollection', 'HTMLFontElement', 'HTMLFieldSetElement', 'HTMLEmbedElement', 'HTMLElement', 'HTMLDocument', 'HTMLDivElement', 'HTMLDirectoryElement', 'HTMLDialogElement', 'HTMLDetailsElement', 'HTMLDataListElement', 'HTMLDataElement', 'HTMLDListElement', 'HTMLCollection', 'HTMLCanvasElement', 'HTMLButtonElement', 'HTMLBodyElement', 'HTMLBaseElement', 'HTMLBRElement', 'HTMLAudioElement', 'HTMLAreaElement', 'HTMLAnchorElement', 'HTMLAllCollection', 'GeolocationPositionError', 'GeolocationPosition', 'GeolocationCoordinates', 'Geolocation', 'GamepadHapticActuator', 'GamepadEvent', 'GamepadButton', 'Gamepad', 'GainNode', 'FormDataEvent', 'FontFaceSetLoadEvent', 'FontFace', 'FocusEvent', 'FileReader', 'FileList', 'File', 'FeaturePolicy', 'External', 'EventCounts', 'ErrorEvent', 'EncodedVideoChunk', 'EncodedAudioChunk', 'ElementInternals', 'Element', 'EditContext', 'DynamicsCompressorNode', 'DragEvent', 'DocumentType', 'DocumentTimeline', 'DocumentFragment', 'Document', 'DelegatedInkTrailPresenter', 'DelayNode', 'DataTransferItemList', 'DataTransferItem', 'DataTransfer', 'DOMTokenList', 'DOMStringMap', 'DOMStringList', 'DOMRectReadOnly', 'DOMRectList', 'DOMRect', 'DOMQuad', 'DOMPointReadOnly', 'DOMPoint', 'DOMParser', 'DOMMatrixReadOnly', 'DOMMatrix', 'DOMImplementation', 'DOMError', 'CustomStateSet', 'CustomElementRegistry', 'ConvolverNode', 'ContentVisibilityAutoStateChangeEvent', 'ConstantSourceNode', 'CompositionEvent', 'Comment', 'CloseWatcher', 'ClipboardEvent', 'CharacterData', 'CharacterBoundsUpdateEvent', 'ChannelSplitterNode', 'ChannelMergerNode', 'CanvasRenderingContext2D', 'CanvasPattern', 'CanvasGradient', 'CanvasCaptureMediaStreamTrack', 'CSSVariableReferenceValue', 'CSSUnparsedValue', 'CSSUnitValue', 'CSSTranslate', 'CSSTransition', 'CSSTransformValue', 'CSSTransformComponent', 'CSSSupportsRule', 'CSSStyleValue', 'CSSStyleSheet', 'CSSStyleRule', 'CSSStyleDeclaration', 'CSSStartingStyleRule', 'CSSSkewY', 'CSSSkewX', 'CSSSkew', 'CSSScopeRule', 'CSSScale', 'CSSRuleList', 'CSSRule', 'CSSRotate', 'CSSPropertyRule', 'CSSPositionValue', 'CSSPositionTryRule', 'CSSPositionTryDescriptors', 'CSSPerspective', 'CSSPageRule', 'CSSNumericValue', 'CSSNumericArray', 'CSSNamespaceRule', 'CSSMediaRule', 'CSSMatrixComponent', 'CSSMathValue', 'CSSMathSum', 'CSSMathProduct', 'CSSMathNegate', 'CSSMathMin', 'CSSMathMax', 'CSSMathInvert', 'CSSMathClamp', 'CSSLayerStatementRule', 'CSSLayerBlockRule', 'CSSKeywordValue', 'CSSKeyframesRule', 'CSSKeyframeRule', 'CSSImportRule', 'CSSImageValue', 'CSSGroupingRule', 'CSSFontPaletteValuesRule', 'CSSFontFaceRule', 'CSSCounterStyleRule', 'CSSContainerRule', 'CSSConditionRule', 'CSSAnimation', 'CSS', 'CDATASection', 'BrowserCaptureMediaStreamTrack', 'BroadcastChannel', 'BlobEvent', 'BiquadFilterNode', 'BeforeUnloadEvent', 'BeforeInstallPromptEvent', 'BaseAudioContext', 'BarProp', 'AudioWorkletNode', 'AudioSinkInfo', 'AudioScheduledSourceNode', 'AudioProcessingEvent', 'AudioParamMap', 'AudioParam', 'AudioNode', 'AudioListener', 'AudioDestinationNode', 'AudioData', 'AudioContext', 'AudioBufferSourceNode', 'AudioBuffer', 'Attr', 'AnimationTimeline', 'AnimationPlaybackEvent', 'AnimationEvent', 'AnimationEffect', 'Animation', 'AnalyserNode', 'AbstractRange', 'AbortSignal', 'window', 'self', 'document', 'name', 'location', 'customElements', 'history', 'navigation', 'locationbar', 'menubar', 'personalbar', 'scrollbars', 'statusbar', 'toolbar', 'status', 'closed', 'frames', 'length', 'top', 'opener', 'parent', 'frameElement', 'origin', 'external', 'screen', 'innerWidth', 'innerHeight', 'scrollX', 'pageXOffset', 'scrollY', 'pageYOffset', 'visualViewport', 'screenX', 'screenY', 'outerWidth', 'outerHeight', 'devicePixelRatio', 'event', 'clientInformation', 'offscreenBuffering', 'screenLeft', 'screenTop', 'styleMedia', 'onsearch', 'isSecureContext', 'trustedTypes', 'performance', 'onappinstalled', 'onbeforeinstallprompt', 'indexedDB', 'onbeforexrselect', 'onabort', 'onbeforeinput', 'onbeforematch', 'onbeforetoggle', 'onblur', 'oncancel', 'oncanplay', 'oncanplaythrough', 'onchange', 'onclick', 'onclose', 'oncontentvisibilityautostatechange', 'oncontextlost', 'oncontextmenu', 'oncontextrestored', 'oncuechange', 'ondblclick', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'ondurationchange', 'onemptied', 'onended', 'onerror', 'onfocus', 'onformdata', 'oninput', 'oninvalid', 'onkeydown', 'onkeypress', 'onkeyup', 'onload', 'onloadeddata', 'onloadedmetadata', 'onloadstart', 'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onpause', 'onplay', 'onplaying', 'onprogress', 'onratechange', 'onreset', 'onresize', 'onscroll', 'onsecuritypolicyviolation', 'onseeked', 'onseeking', 'onselect', 'onslotchange', 'onstalled', 'onsubmit', 'onsuspend', 'ontimeupdate', 'ontoggle', 'onvolumechange', 'onwaiting', 'onwebkitanimationend', 'onwebkitanimationiteration', 'onwebkitanimationstart', 'onwebkittransitionend', 'onwheel', 'onauxclick', 'ongotpointercapture', 'onlostpointercapture', 'onpointerdown', 'onpointermove', 'onpointerrawupdate', 'onpointerup', 'onpointercancel', 'onpointerover', 'onpointerout', 'onpointerenter', 'onpointerleave', 'onselectstart', 'onselectionchange', 'onanimationend', 'onanimationiteration', 'onanimationstart', 'ontransitionrun', 'ontransitionstart', 'ontransitionend', 'ontransitioncancel', 'onafterprint', 'onbeforeprint', 'onbeforeunload', 'onhashchange', 'onlanguagechange', 'onmessage', 'onmessageerror', 'onoffline', 'ononline', 'onpagehide', 'onpageshow', 'onpopstate', 'onrejectionhandled', 'onstorage', 'onunhandledrejection', 'onunload', 'crossOriginIsolated', 'scheduler', 'alert', 'blur', 'cancelAnimationFrame', 'cancelIdleCallback', 'captureEvents', 'close', 'confirm', 'createImageBitmap', 'find', 'focus', 'getComputedStyle', 'getSelection', 'matchMedia', 'moveBy', 'moveTo', 'open', 'postMessage', 'print', 'prompt', 'releaseEvents', 'reportError', 'requestAnimationFrame', 'requestIdleCallback', 'resizeBy', 'resizeTo', 'scroll', 'scrollBy', 'scrollTo', 'stop', 'webkitCancelAnimationFrame', 'webkitRequestAnimationFrame', 'originAgentCluster', 'onpageswap', 'onpagereveal', 'credentialless', 'fence', 'speechSynthesis', 'onscrollend', 'onscrollsnapchange', 'onscrollsnapchanging', 'webkitRequestFileSystem', 'webkitResolveLocalFileSystemURL', 'Iterator', 'chrome', 'caches', 'cookieStore', 'ondevicemotion', 'ondeviceorientation', 'ondeviceorientationabsolute', 'launchQueue', 'sharedStorage', 'documentPictureInPicture', 'AbsoluteOrientationSensor', 'Accelerometer', 'AudioDecoder', 'AudioEncoder', 'AudioWorklet', 'BatteryManager', 'Cache', 'CacheStorage', 'Clipboard', 'ClipboardItem', 'CookieChangeEvent', 'CookieStore', 'CookieStoreManager', 'Credential', 'CredentialsContainer', 'DeviceMotionEvent', 'DeviceMotionEventAcceleration', 'DeviceMotionEventRotationRate', 'DeviceOrientationEvent', 'FederatedCredential', 'GPU', 'GPUAdapter', 'GPUAdapterInfo', 'GPUBindGroup', 'GPUBindGroupLayout', 'GPUBuffer', 'GPUBufferUsage', 'GPUCanvasContext', 'GPUColorWrite', 'GPUCommandBuffer', 'GPUCommandEncoder', 'GPUCompilationInfo', 'GPUCompilationMessage', 'GPUComputePassEncoder', 'GPUComputePipeline', 'GPUDevice', 'GPUDeviceLostInfo', 'GPUError', 'GPUExternalTexture', 'GPUInternalError', 'GPUMapMode', 'GPUOutOfMemoryError', 'GPUPipelineError', 'GPUPipelineLayout', 'GPUQuerySet', 'GPUQueue', 'GPURenderBundle', 'GPURenderBundleEncoder', 'GPURenderPassEncoder', 'GPURenderPipeline', 'GPUSampler', 'GPUShaderModule', 'GPUShaderStage', 'GPUSupportedFeatures', 'GPUSupportedLimits', 'GPUTexture', 'GPUTextureUsage', 'GPUTextureView', 'GPUUncapturedErrorEvent', 'GPUValidationError', 'GravitySensor', 'Gyroscope', 'IdleDetector', 'ImageDecoder', 'ImageTrack', 'ImageTrackList', 'Keyboard', 'KeyboardLayoutMap', 'LinearAccelerationSensor', 'Lock', 'LockManager', 'MIDIAccess', 'MIDIConnectionEvent', 'MIDIInput', 'MIDIInputMap', 'MIDIMessageEvent', 'MIDIOutput', 'MIDIOutputMap', 'MIDIPort', 'MediaDeviceInfo', 'MediaDevices', 'MediaKeyMessageEvent', 'MediaKeySession', 'MediaKeyStatusMap', 'MediaKeySystemAccess', 'MediaKeys', 'NavigationPreloadManager', 'NavigatorManagedData', 'OrientationSensor', 'PasswordCredential', 'RelativeOrientationSensor', 'ScreenDetailed', 'ScreenDetails', 'Sensor', 'SensorErrorEvent', 'ServiceWorker', 'ServiceWorkerContainer', 'ServiceWorkerRegistration', 'StorageManager', 'VideoDecoder', 'VideoEncoder', 'VirtualKeyboard', 'WGSLLanguageFeatures', 'WebTransport', 'WebTransportBidirectionalStream', 'WebTransportDatagramDuplexStream', 'WebTransportError', 'Worklet', 'XRDOMOverlayState', 'XRLayer', 'XRWebGLBinding', 'AuthenticatorAssertionResponse', 'AuthenticatorAttestationResponse', 'AuthenticatorResponse', 'PublicKeyCredential', 'BarcodeDetector', 'Bluetooth', 'BluetoothCharacteristicProperties', 'BluetoothDevice', 'BluetoothRemoteGATTCharacteristic', 'BluetoothRemoteGATTDescriptor', 'BluetoothRemoteGATTServer', 'BluetoothRemoteGATTService', 'CaptureController', 'DocumentPictureInPicture', 'EyeDropper', 'FileSystemDirectoryHandle', 'FileSystemFileHandle', 'FileSystemHandle', 'FileSystemWritableFileStream', 'FontData', 'FragmentDirective', 'HID', 'HIDConnectionEvent', 'HIDDevice', 'HIDInputReportEvent', 'HandwritingStroke', 'IdentityCredential', 'IdentityProvider', 'IdentityCredentialError', 'LaunchParams', 'LaunchQueue', 'NavigatorLogin', 'NotRestoredReasonDetails', 'NotRestoredReasons', 'OTPCredential', 'PaymentAddress', 'PaymentRequest', 'PaymentRequestUpdateEvent', 'PaymentResponse', 'PaymentManager', 'PaymentMethodChangeEvent', 'Presentation', 'PresentationAvailability', 'PresentationConnection', 'PresentationConnectionAvailableEvent', 'PresentationConnectionCloseEvent', 'PresentationConnectionList', 'PresentationReceiver', 'PresentationRequest', 'PressureObserver', 'PressureRecord', 'ProtectedAudience', 'Serial', 'SerialPort', 'StorageBucket', 'StorageBucketManager', 'USB', 'USBAlternateInterface', 'USBConfiguration', 'USBConnectionEvent', 'USBDevice', 'USBEndpoint', 'USBInTransferResult', 'USBInterface', 'USBIsochronousInTransferPacket', 'USBIsochronousInTransferResult', 'USBIsochronousOutTransferPacket', 'USBIsochronousOutTransferResult', 'USBOutTransferResult', 'WakeLock', 'WakeLockSentinel', 'XRAnchor', 'XRAnchorSet', 'XRBoundedReferenceSpace', 'XRCPUDepthInformation', 'XRCamera', 'XRDepthInformation', 'XRFrame', 'XRHitTestResult', 'XRHitTestSource', 'XRInputSource', 'XRInputSourceArray', 'XRInputSourceEvent', 'XRInputSourcesChangeEvent', 'XRLightEstimate', 'XRLightProbe', 'XRPose', 'XRRay', 'XRReferenceSpace', 'XRReferenceSpaceEvent', 'XRRenderState', 'XRRigidTransform', 'XRSession', 'XRSessionEvent', 'XRSpace', 'XRSystem', 'XRTransientInputHitTestResult', 'XRTransientInputHitTestSource', 'XRView', 'XRViewerPose', 'XRViewport', 'XRWebGLDepthInformation', 'XRWebGLLayer', 'XRHand', 'XRJointPose', 'XRJointSpace', 'getDigitalGoodsService', 'getScreenDetails', 'queryLocalFonts', 'showDirectoryPicker', 'showOpenFilePicker', 'showSaveFilePicker', 'copy'];
+
+const NODE_AND_WEB_GLOBALS = {AbortController, Blob, ByteLengthQueuingStrategy, atob, BroadcastChannel, btoa, clearInterval, clearTimeout, CloseEvent, CompressionStream, console, CountQueuingStrategy, Crypto, crypto, CryptoKey, CustomEvent, DecompressionStream, Event, EventSource, EventTarget, fetch, FormData, Headers, localStorage, MessageChannel, MessageEvent, MessagePort, Navigator, navigator, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, performance, queueMicrotask, ReadableByteStreamController, Response, Request, sessionStorage, setInterval, setTimeout, Storage, structuredClone, SubtleCrypto, DOMException, TextDecoder, TextDecoderStream, TextEncoder, TextEncoderStream, TransformStreamDefaultController, URL, URLSearchParams, WebAssembly, WebSocket, WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter};
+
+let modules: Map<string, any> = new Map();
+let builtinModules: Map<string, any> = new Map();
+
+globalThis.__fakeNode_modules = modules;
+globalThis.__fakeNode_builtinModules = builtinModules;
+
+function require(name: string): any {
+    if (modules.has(name)) {
+        return modules.get(name);
+    } else if (builtinModules.has(name)) {
+        return builtinModules.get(name);
+    } else {
+        throw new Error(`cannot find module '${name}'`);
+    }
+}
+
+const NODE_ONLY_GLOBALS = {Buffer, require, process};
+
+let globals = {};
+Object.assign(globals, ES_GLOBALS);
+for (const name of WEB_ONLY_GLOBALS) {
+    Object.defineProperty(globals, name, {get: () => {throw new ReferenceError(`${name} is not defined`)}});
+}
+Object.assign(globals, NODE_AND_WEB_GLOBALS);
+Object.assign(globals, NODE_ONLY_GLOBALS);
+
+export default globals;

package/index.js

@@ -0,0 +1 @@
+throw new ReferenceError('module is not defined');

package/index.ts

@@ -0,0 +1,80 @@
+
+import globals from './globals';
+
+import * as module_assert from './modules/assert';
+import * as module_buffer from './modules/buffer';
+import * as module_fs from './modules/fs';
+import * as module_os from './modules/os';
+import * as module_path from './modules/path';
+import * as module_process from './modules/process';
+import * as module_querystring from './modules/querystring';
+import * as module_util from './modules/util';
+
+function setup(path?: string, argv: string[] = []): object {
+    module_process._argv.argv = argv;
+    let scope: {[key: string]: any} = {};
+    Object.assign(scope, globals);
+    let readonly: {[key: string]: any} = {};
+    scope.global = scope;
+    scope.globalThis = scope;
+    globalThis.__fakeNode_oldWd = globalThis.__fakeNode_wd;
+    if (path !== undefined) {
+        const splitPath = path.split('/');
+        readonly.__dirname = splitPath.slice(0, -1).join('/');
+        readonly.__filename = splitPath[splitPath.length - 1];
+        scope.__fakeNode_wd = readonly.__dirname;
+    }
+    Object.defineProperties(scope, Object.fromEntries(Object.entries(readonly).map(([name, value]) => [name, {value: value, writable: false}])));
+    return scope;
+}
+
+globalThis.__fakeNode_setup = setup;
+
+function cleanup(): void {
+    globalThis.__fakeNode_wd = globalThis.__fakeNode_oldWd;
+}
+
+globalThis.__fakeNode_cleanup = cleanup;
+
+function run(code: string, argv: string[] = []): void {
+    code = `with(window.__fakeNode_setup(undefined,${JSON.stringify(argv)})){(function(){${code}})();window.__fakeNode_cleanup();}`;
+    let elt = document.createElement('script');
+    elt.textContent = code;
+    document.body.appendChild(elt);
+}
+
+function addModule(name: string, code: string): void {
+    code = `with(window.__fakeNode_setup()){window.__fakeNode_modules.set('${name}',(function(){${code};return module.exports;})();window.__fakeNode_cleanup();}`;
+    let elt = document.createElement('script');
+    elt.textContent = code;
+    document.body.appendChild(elt);
+}
+
+function addBuiltinModule(name: string, data: any): void {
+    globalThis.__fakeNode_builtinModules.set(name, data);
+}
+
+function deleteModule(name: string): void {
+    globalThis.__fakeNode_modules.delete(name);
+}
+
+function deleteBuiltinModule(name: string): void {
+    globalThis.__fakeNode_builtinModules.delete(name);
+}
+
+addBuiltinModule('assert', module_assert);
+addBuiltinModule('buffer', module_buffer);
+addBuiltinModule('fs', module_fs);
+addBuiltinModule('os', module_os);
+addBuiltinModule('path', module_path);
+addBuiltinModule('process', module_process);
+addBuiltinModule('querystring', module_querystring);
+addBuiltinModule('util', module_util);
+
+export {
+    run,
+    addModule,
+    addBuiltinModule,
+    deleteModule,
+    deleteBuiltinModule,
+}

package/modules/assert.ts

@@ -0,0 +1,205 @@
+
+export class AssertionError extends Error {
+
+    message: string;
+    actual: any;
+    expected: any;
+    operator: string;
+    generatedMessage: boolean;
+    name: 'AssertionError' = 'AssertionError';
+
+    constructor({message, actual, expected, operator}: {message?: string | Error, actual?: any, expected?: any, operator: string}) {
+        super();
+        this.actual = actual;
+        this.expected = expected.
+        this.operator = operator;
+        if (message !== undefined) {
+            this.message = message instanceof Error ? message.message : message;
+            this.generatedMessage = false;
+        } else {
+            // todo: finish this
+            this.message = `expected ${expected} but got ${actual} using ${operator}`;
+            this.generatedMessage = true;
+        }
+    }
+
+    get [Symbol.toStringTag]() {
+        return 'AssertionError';
+    }
+
+}
+
+export function deepEqual(actual: any, expected: any, message?: string | Error): void {
+    if (typeof actual === 'object' && actual !== null) {
+        if (typeof expected === 'object' && expected !== null) {
+            // todo: finish this
+            let expectedKeys = Object.keys(expected);
+            for (const key of Object.keys(actual)) {
+                if (!expectedKeys.includes(key)) {
+                    throw new AssertionError({message, actual, expected, operator: 'deepEqual'});
+                }
+                expectedKeys = expectedKeys.filter(x => x !== key);
+            }
+            if (expectedKeys.length > 0) {
+                throw new AssertionError({message, actual, expected, operator: 'deepEqual'});
+            }
+        } else {
+            throw new AssertionError({message, actual, expected, operator: 'deepEqual'});
+        }
+    } else {
+        if (actual != expected && !(Number.isNaN(actual) && Number.isNaN(expected))) {
+            throw new AssertionError({message, actual, expected, operator: 'deepEqual'});
+        }
+    }
+}
+
+export function deepStrictEqual(actual: any, expected: any, message?: string | Error): void {
+    if (typeof actual === 'object' && actual !== null) {
+        if (typeof expected === 'object' && expected !== null) {
+            // todo: finish this 
+            let expectedKeys = Object.keys(expected);
+            for (const key of Object.keys(actual)) {
+                if (!expectedKeys.includes(key)) {
+                    throw new AssertionError({message, actual, expected, operator: 'deepStrictEqual'});
+                }
+                expectedKeys = expectedKeys.filter(x => x !== key);
+            }
+            if (expectedKeys.length > 0) {
+                throw new AssertionError({message, actual, expected, operator: 'deepStrictEqual'});
+            }
+        } else {
+            throw new AssertionError({message, actual, expected, operator: 'deepStrictEqual'});
+        }
+    } else {
+        if (actual !== expected && !(Number.isNaN(actual) && Number.isNaN(expected))) {
+            throw new AssertionError({message, actual, expected, operator: 'deepStrictEqual'});
+        }
+    }
+}
+
+export function doesNotMatch(string: string, regexp: RegExp, message?: string | Error): void {
+    if (string.match(regexp)) {
+        throw new AssertionError({message, operator: 'doesNotMatch'});
+    }
+}
+
+export function equal(expected: any, actual: any, message?: string | Error): void {
+    if (actual != expected && !(Number.isNaN(actual) && Number.isNaN(expected))) {
+        throw new AssertionError({message, actual, expected, operator: 'equal'});
+    }
+}
+
+export function fail(message: string | Error = 'Failed'): void {
+    throw new AssertionError({message, operator: 'fail'});
+}
+
+export function ifError(value: any): void {
+    if (value !== undefined && value !== null) {
+        throw new AssertionError({operator: 'ifError'});
+    }
+}
+
+export function match(string: string, regexp: RegExp, message?: string | Error): void {
+    if (!string.match(regexp)) {
+        throw new AssertionError({message, operator: 'match'});
+    }
+}
+
+export function notDeepEqual(actual: any, expected: any, message?: string | Error): void {
+    try {
+        deepEqual(actual, expected);
+    } catch (error) {
+        if (error instanceof AssertionError) {
+            return;
+        } else {
+            throw error;
+        }
+    }
+    throw new AssertionError({message, actual, expected, operator: 'notDeepEqual'});
+}
+
+export function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void {
+    try {
+        deepStrictEqual(actual, expected);
+    } catch (error) {
+        if (error instanceof AssertionError) {
+            return;
+        } else {
+            throw error;
+        }
+    }
+    throw new AssertionError({message, actual, expected, operator: 'notDeepStrictEqual'});
+}
+
+export function notEqual(actual: any, expected: any, message?: string | Error): void {
+    try {
+        equal(actual, expected);
+    } catch (error) {
+        if (error instanceof AssertionError) {
+            return;
+        } else {
+            throw error;
+        }
+    }
+    throw new AssertionError({message, actual, expected, operator: 'notEqual'});
+}
+
+export function notStrictEqual(actual: any, expected: any, message?: string | Error): void {
+    try {
+        strictEqual(actual, expected);
+    } catch (error) {
+        if (error instanceof AssertionError) {
+            return;
+        } else {
+            throw error;
+        }
+    }
+    throw new AssertionError({message, actual, expected, operator: 'notStrictEqual'});
+}
+
+export function ok(value: any, message?: string | Error): void {
+    if (!value) {
+        throw new AssertionError({message, operator: 'ok'})
+    }
+}
+
+export function strictEqual(expected: any, actual: any, message?: string | Error): void {
+    if (actual !== expected && !(Number.isNaN(actual) && Number.isNaN(expected))) {
+        throw new AssertionError({message, actual, expected, operator: 'strictEqual'});
+    }
+}
+
+export function assert(value: any, message?: string | Error): void {
+    ok(value, message);
+}
+
+Object.assign(assert, {
+    deepEqual,
+    deepStrictEqual,
+    doesNotMatch,
+    equal,
+    fail,
+    ifError,
+    match,
+    notDeepEqual,
+    notDeepStrictEqual,
+    notEqual,
+    notStrictEqual,
+    ok,
+    strictEqual,
+    strict: {
+        deepEqual: deepStrictEqual,
+        deepStrictEqual,
+        doesNotMatch,
+        equal: strictEqual,
+        fail,
+        ifError,
+        match,
+        notDeepEqual: notDeepStrictEqual,
+        notDeepStrictEqual,
+        notEqual: notStrictEqual,
+        notStrictEqual,
+        ok,
+        strictEqual,
+    },
+});

package/modules/buffer.ts

@@ -0,0 +1,4 @@
+
+export class Buffer extends Uint8Array {
+
+}

package/modules/fs.ts

@@ -0,0 +1,8 @@
+
+import {Buffer} from "./buffer";
+
+let files = new Map();
+
+export function accessSync(path: string | Buffer | URL) {
+
+}

package/modules/os.ts

@@ -0,0 +1,81 @@
+
+export const EOL = '\r\n';
+
+export function availableParallelism(): number {
+    return navigator.hardwareConcurrency;
+}
+
+export function arch(): string {
+    return 'web';
+}
+
+export const constants = {
+
+};
+
+export function cpus(): {model: string, speed: number, times: {user: number, nice: number, sys: number, idle: number, irq: number}}[] {
+    return [];
+}
+
+export const devNull = '/dev/null';
+
+export function endianness(): string {
+    return 'LE';
+}
+
+export function freemem(): number {
+    // @ts-ignore
+    return navigator.deviceMemory * 2**30;
+}
+
+export function homedir(): string {
+    return '/home/root';
+}
+
+export function hostname(): string {
+    return 'fake-node';
+}
+
+export function loadavg(): [number, number, number] {
+    return [0, 0, 0];
+}
+
+export function machine(): string {
+    return 'fake';
+}
+
+export function platform(): string {
+    const data = navigator.userAgent.slice('Mozilla/5.0 ('.length, navigator.userAgent.indexOf(')'));
+    if (data.includes('Windows')) {
+        return 'win32';
+    } else if (data.includes('Linux')) {
+        return 'linux';
+    } else if (data.includes('Mac')) {
+        return 'darwin';
+    } else {
+        return 'unknown';
+    }
+}
+
+export function tmpdir(): string {
+    return '/tmp';
+}
+
+export function totalmem(): number {
+    // @ts-ignore
+    return navigator.deviceMemory * 2**30;
+}
+
+export function type(): string {
+    const data = navigator.userAgent.slice('Mozilla/5.0 ('.length, navigator.userAgent.indexOf(')'));
+    if (data.includes('Windows NT')) {
+        return 'Windows_NT';
+    } else if (data.includes('Linux')) {
+        return 'Linux';
+    } else if (data.includes('Mac')) {
+        return 'Darwin';
+    } else {
+        return 'unknown';
+    }
+}
+

package/modules/path.ts

@@ -0,0 +1,56 @@
+
+export function basename(path: string, suffix?: string): string {
+    const parts = path.split('/');
+    let out = parts[parts.length - 1];
+    if (suffix !== undefined && out.endsWith(suffix)) {
+        out = out.slice(0, out.length - suffix.length);
+    }
+    return out;
+}
+
+export const delimiter = ':';
+
+export function dirname(path: string): string {
+    const parts = path.split('/');
+    return parts.slice(0, parts.length - 1).join('/');
+}
+
+export function extname(path: string): string {
+    const parts = path.split('.');
+    return parts[parts.length - 1];
+}
+
+export function isAbsolute(path: string): boolean {
+    return path.startsWith('/');
+}
+
+export function join(...paths: string[]): string {
+    return normalize(paths.join('/'));
+}
+
+export function normalize(path: string): string {
+    let out: string[] = [];
+    const segments = path.split('/');
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if ((segment === '.' && i !== 0) || segment === '') {
+            continue;
+        } else if (segment === '..') {
+            out.pop();
+        } else {
+            out.push(segment);
+        }
+    }
+    return out.join('');
+}
+
+export function resolve(...paths: string[]): string {
+    const path = join(...paths);
+    if (path.startsWith('/')) {
+        return path;
+    } else {
+        return globalThis.__fakeNode_wd + path;
+    }
+}
+
+export const sep = '/';

package/modules/process.ts

@@ -0,0 +1,78 @@
+
+import {join} from './path';
+import {platform as _platform} from './os';
+
+export function abort(): void {
+    window.close();
+}
+    
+export const allowedNodeEnvironmentFlags = new Set<never>();
+    
+export let _argv: {argv: string[]} = {argv: []};
+export const argv = _argv.argv;
+
+export const argv0 = '/usr/bin/local/node';
+
+export const channel = undefined;
+
+export function chdir(directory: string): void {
+    globalThis.__fakeNode_wd = join(globalThis.__fakeNode_wd, directory);
+}
+
+export const config = {};
+
+export const connected = undefined;
+
+export function constrainedMemory(): number {
+    return 0;
+}
+
+export function availableMemory(): number {
+    // @ts-ignore
+    return navigator.deviceMemory * 2**30;
+}
+
+export function cwd(): string {
+    return globalThis.__fakeNode_wd;
+}
+
+export const env = {
+    SHELL: '/usr/local/bin/bash',
+    USER: 'root',
+    PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+    PWD: '/home/root',
+    EDITOR: 'vim',
+    SHLVL: '1',
+    HOME: '/home/root',
+    LOGNAME: 'root',
+    _: '/usr/local/bin/node'
+}; 
+
+export const execPath = '/usr/bin/local/node';
+
+export function exit(code: number = 0): void {
+    console.log('Exit code', code);
+    window.close();
+}
+
+export const exitCode = undefined;
+
+export const features = {
+    cached_builtins: true,
+    debug: false,
+    inspector: false,
+    ipv6: true,
+    require_module: true,
+    tls: false,
+    tls_alpn: false,
+    tls_ocsp: false,
+    tls_sni: false,
+    typescript: false,
+    uv: false,
+};
+
+export function getBuiltinModule(id: string): any {
+    return globalThis.__fakeNode_builtinModules[id];
+}
+
+export const platform = _platform();

package/modules/querystring.ts

@@ -0,0 +1,33 @@
+
+type Parsed = object;
+
+export function decode(str: string) {
+    return parse(str);
+}
+
+export function encode(obj: Parsed): string {
+    return stringify(obj);
+}
+
+export function parse(str: string): Parsed {
+    let obj = Object.create(null);
+    const params = new URLSearchParams(str);
+    for (const key of params.keys()) {
+        obj[key] = params.getAll(key);
+    }
+    return obj;
+}
+
+export function stringify(obj: Parsed): string {
+    let params = new URLSearchParams();
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'string') {
+            params.append(key, value);
+        } else {
+            for (const item of Object.keys(value)) {
+                params.append(key, item);
+            }
+        }
+    }
+    return params.toString();
+}

package/modules/util.ts

@@ -0,0 +1,116 @@
+
+export function callbackify(original: (...args: any[]) => Promise<any>): (...args: [...any[], (err: Error | null, value: any) => void]) => void {
+    return function(...args: [...any[], (err: Error | null, value: any) => void]): void {
+        const callback = args[args.length - 1];
+        original(...args.slice(0, -1)).then((value: any) => callback(null, value)).catch((reason) => callback(reason instanceof Error ? 
+        reason : new Error(reason), null));
+    };
+}
+
+const PERCENT_REGEX = /(?<!%)(%[sdifjoOc%])/;
+
+export function format(format: string, ...args: any[]): string {
+    const parts = format.split(PERCENT_REGEX);
+    let out = '';
+    let j = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i % 2 === 0) {
+            out += part;
+        } else if (part === '%%') {
+            out += '%';
+        } else {
+            const arg = args[j];
+            if (part === '%s') {
+                if (typeof arg === 'object') {
+                    if (arg === null) {
+                        out += String(part);
+                    } else {
+                        if (arg.toString === Object.prototype.toString) {
+                            out += inspect(arg, {depth: 0, colors: false, compact: 3});
+                        } else {
+                            out += arg.toString();
+                        }
+                    }
+                } else if (typeof part === 'bigint') {
+                    out += String(part) + 'n';
+                } else {
+                    out += String(part);
+                }
+            } else if (part === '%d') {
+                if (typeof arg === 'bigint') {
+                    out += String(arg) + 'n';
+                } else if (typeof arg === 'symbol') {
+                    out += String(arg);
+                } else {
+                    out += String(Number(arg));
+                }
+            } else if (part === '%i') {
+                if (typeof arg === 'symbol') {
+                    out += String(arg);
+                } else {
+                    out += String(parseInt(arg, 10));
+                }
+            } else if (part === '%f') {
+                if (typeof arg === 'symbol') {
+                    out += String(arg);
+                } else {
+                    out += String(parseFloat(arg));
+                }
+            } else if (part === '%j') {
+                out += JSON.stringify(part);
+            } else if (part === '%o') {
+                out += inspect(part, {showHidden: true, showProxy: true});
+            } else if (part === '%O') {
+                out += inspect(part);
+            }
+            j++;
+        }
+    }
+    return out;
+}
+
+interface InspectOptions {
+    showHidden?: boolean;
+    depth?: number;
+    colors?: boolean;
+    customInspect?: boolean;
+    showProxy?: boolean;
+    maxArrayLength?: number;
+    maxStringLength?: number;
+    breakLength?: number;
+    compact?: false | number;
+    sorted?: true | ((a: any, b: any) => number);
+    getters?: boolean | 'get';
+    numericSeperator?: boolean;
+}
+
+export function inspect(object: any, {showHidden = false, depth = 2, colors = false, customInspect = true, showProxy = false,  maxArrayLength = 100, maxStringLength = 10000, breakLength = 80, compact = 3, sorted = true, getters = false, numericSeperator = false}: InspectOptions = {}): string {
+    if (typeof object !== 'object' || object === 'null') {
+        return String(object);
+    } else {
+        return '<util.inspect is not implemented yet>';
+    }
+
+}
+
+export function promisify(original: (...args: [...any[], (err: Error | null, value: any) => void]) => void): (...args: any[]) => Promise<any> {
+    return async (...args: any[]) => {
+        return new Promise((resolve: (value: any) => void, reject: (reason?: any) => void) => {
+            original(...args, (err: Error | null, value: any) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(value);
+                }
+            });
+
+        });
+    };
+}
+
+const ANSI_CONTROL_REGEX = /\x1b\[[0-?]*[ -\/]*[@-~]/g;
+
+export function stripVTControlCharacters(str: string) {
+    return str.replace(ANSI_CONTROL_REGEX, '');
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "fake-node",
+  "version": "0.1.0",
+  "description": "A fake version of Node that works in the browser",
+  "license": "MIT",
+  "author": "speedydelete",
+  "type": "module",
+  "main": "index.js",
+  "homepage": "https://github.com/speedydelete/fake-node",
+  "repository": "github:speedydelete/fake-node",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}