quickwin 1.0.0

package/lib/react-qw/reconciler.ts

@@ -0,0 +1,373 @@
+import ReactReconciler from 'react-reconciler'
+import { createContext } from 'react'
+import { DefaultEventPriority, NoEventPriority } from 'react-reconciler/constants'
+import * as gui from 'gui'
+import * as os from 'os'
+import { applyProps } from './props.js'
+import { calculateFlexLayout, type FlexStyle } from './layout.js'
+import { getButtonIdealSize, measureTextForHwnd } from '../text-measure.js'
+import type { WIntrinsicProps } from './jsx.js'
+
+// DEBUG 由 esbuild --define 在 bundle 时替换（见 build.ts），生产环境为 false
+declare const DEBUG: boolean
+
+const dpiFont = gui.CreateSystemDpiFont()
+export const scaleFactor = gui.GetScaleFactor()
+
+type Container = gui.HWND
+export type Props = WIntrinsicProps
+
+export interface Instance {
+  hwnd: gui.HWND | null
+  type: string
+  props: Props
+  children: Instance[]
+  lastRect?: { x: number; y: number; w: number; h: number }
+}
+
+const DELAYED_CONTROLS = new Set(['SysListView32', 'SysTreeView32', 'LISTBOX', 'COMBOBOX', 'msctls_trackbar32', 'SysDateTimePick32', 'SysLink'])
+
+function isDelayedControl(winClass: string): boolean {
+  return DELAYED_CONTROLS.has(winClass)
+}
+
+function setupWindowProc(instance: Instance, hwnd: gui.HWND) {
+  instance.hwnd = hwnd
+  const oldProc = gui.GetWindowLongPtr(hwnd, gui.Gwlp.WNDPROC)
+  instancesByHwnd.set(hwnd, instance)
+  gui.SetWindowProc(hwnd, (hwnd: gui.HWND, msg: number, wParam: number, lParam: number) => {
+    const ev = instance.props.onEvent
+    if (!ev) return gui.CallWindowProc(oldProc, hwnd, msg, wParam, lParam)
+    if (typeof ev === 'object') {
+      return ev.fn({ hwnd, msg, wParam, lParam, callOldWndProc: () => gui.CallWindowProc(oldProc, hwnd, msg, wParam, lParam) })
+    }
+    const result = gui.CallWindowProc(oldProc, hwnd, msg, wParam, lParam)
+    const override = ev({ hwnd, msg, wParam, lParam })
+    return typeof override === 'number' && Number.isInteger(override) ? override : result
+  })
+}
+
+function ensureChildWindow(child: Instance, parentHwnd: gui.HWND): gui.HWND {
+  if (child.hwnd !== null) return child.hwnd
+  const sty = child.props.style || {}
+  const ws = ((child.props.ws ?? 0) | gui.WindowStyle.CHILD) & ~gui.WindowStyle.VISIBLE
+  const hwnd = gui.CreateWindow(
+    child.type, child.props.text || '', ws,
+    0, 0,
+    (typeof sty.width === 'number' ? sty.width : 100) * scaleFactor, (typeof sty.height === 'number' ? sty.height : 30) * scaleFactor,
+    parentHwnd, null
+  )!
+  if (dpiFont) gui.SendMessage(hwnd, gui.WmMsg.SETFONT, dpiFont, 1)
+  setupWindowProc(child, hwnd)
+  return hwnd
+}
+
+type HostContext = Record<string, never>
+
+export const instancesByHwnd = new Map<gui.HWND, Instance>()
+
+function runFlexLayout(inst: Instance) {
+  const children = inst.children
+  if (children.length === 0) return
+  const s = inst.props.style
+  const flex: FlexStyle = s || {}
+  const visible = children.filter(c => !c.props.hidden)
+  if (visible.length === 0) return
+  const rect = gui.GetClientRect(inst.hwnd!)
+  if (!rect) { console.log('flex: no rect for', inst.hwnd, inst.type); return }
+  const pw = (rect.right - rect.left) / scaleFactor
+  const ph = (rect.bottom - rect.top) / scaleFactor
+  if (pw <= 0 || ph <= 0) { console.log('flex: zero size for', inst.hwnd, inst.type, pw, ph); return }
+  const autoSizes = new Map<Instance, { w: number; h: number }>()
+  for (const child of visible) {
+    const sty = child.props.style || {}
+    if (!child.hwnd) continue
+    if (child.type === 'BUTTON' && (sty.width === 'auto' || sty.height === 'auto')) {
+      const ideal = getButtonIdealSize(child.hwnd)
+      autoSizes.set(child, { w: ideal.width / scaleFactor, h: ideal.height / scaleFactor })
+    } else if (child.type === 'STATIC' && (sty.width === 'auto' || sty.height === 'auto') && child.props.text) {
+      const measured = measureTextForHwnd(child.hwnd, child.props.text!)
+      autoSizes.set(child, { w: measured.width / scaleFactor, h: measured.height / scaleFactor })
+    }
+  }
+  const results = calculateFlexLayout(flex, pw, ph, visible.map(c => {
+    const sty = c.props.style || {}
+    const auto = autoSizes.get(c)
+    return {
+      style: {
+        ...sty,
+        width: auto ? (sty.width === 'auto' ? auto.w : sty.width) : sty.width,
+        height: auto ? (sty.height === 'auto' ? auto.h : sty.height) : sty.height,
+      }
+    }
+  }))
+  const pl = flex.paddingLeft ?? flex.padding ?? 0
+  const pt = flex.paddingTop ?? flex.padding ?? 0
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i]!
+    const child = visible[i]!
+    const lr = child.lastRect
+    if (lr && lr.x === r.x && lr.y === r.y && lr.w === r.width && lr.h === r.height) continue
+    console.log('flex: set', child.type, child.hwnd, 'to', r.x, r.y, r.width, r.height)
+    gui.SetWindowPos(child.hwnd!, gui.SetWindowPosHwnd.TOP, (r.x + pl) * scaleFactor, (r.y + pt) * scaleFactor, r.width * scaleFactor, r.height * scaleFactor, gui.SetWindowPosFlag.SWP_SHOWWINDOW)
+    gui.InvalidateRect(child.hwnd!, null, true)
+    child.lastRect = { x: r.x, y: r.y, w: r.width, h: r.height }
+  }
+  for (const c of children) runFlexLayout(c)
+}
+
+export function forceFlexLayout(hwnd: gui.HWND): void {
+  const inst = instancesByHwnd.get(hwnd)
+  if (inst) runFlexLayout(inst)
+}
+
+/**
+ * 扩展 HostConfig 类型定义
+ * 
+ * @types/react-reconciler 的 HostConfig 存在以下问题：
+ * 1. 缺少 rendererPackageName/rendererVersion 属性
+ * 
+ * 解决方案：扩展补充缺失定义
+ */
+type QuickWinHostConfig = ReactReconciler.HostConfig<
+  string, Props, Container, Instance, Instance,
+  never, never, never, gui.HWND,
+  HostContext, never, number, -1, null
+> & {
+  // rendererPackageName/rendererVersion（原类型定义中缺失）
+  rendererPackageName: string
+  rendererVersion: string
+}
+
+let currentUpdatePriority = NoEventPriority
+
+const hostConfig: QuickWinHostConfig = {
+  // Core methods
+  createInstance(type: string, props: Props, rootContainer: Container) {
+    if (DEBUG) console.log('[reconciler] createInstance called:', type, 'class=' + props.type)
+    const winClass = props.type
+    if (isDelayedControl(winClass)) {
+      if (DEBUG) console.log('[reconciler] delayed control, skipping CreateWindow:', winClass)
+      return { hwnd: null, type: winClass, props, children: [] }
+    }
+    if (winClass === 'STATIC' && props.text !== undefined && props.children !== undefined && props.children !== null) {
+      throw new Error('[STATIC] text and children are mutually exclusive')
+    }
+    const sty = props.style || {}
+    // reconciler 创建的都是子窗口，确保 WS_CHILD 避免定位异常；创建时不带 WS_VISIBLE 防止 (0,0) 闪烁
+    const ws = ((props.ws ?? 0) | gui.WindowStyle.CHILD) & ~gui.WindowStyle.VISIBLE
+    if (DEBUG) console.log('[reconciler] CreateWindow args:', winClass, props.text ?? '', ws, 0, 0, sty.width ?? 100, sty.height ?? 30, rootContainer)
+    const hwnd = gui.CreateWindow(
+      winClass, props.text ?? '', ws,
+      0, 0,
+      (typeof sty.width === 'number' ? sty.width : 100) * scaleFactor, (typeof sty.height === 'number' ? sty.height : 30) * scaleFactor,
+      rootContainer, null
+    )!
+    if (dpiFont) gui.SendMessage(hwnd, gui.WmMsg.SETFONT, dpiFont, 1)
+    if (DEBUG) console.log('[reconciler] createInstance hwnd result:', hwnd, 'null?', hwnd === null)
+    const instance: Instance = { hwnd, type: winClass, props, children: [] }
+    setupWindowProc(instance, hwnd)
+    return instance
+  },
+
+  createTextInstance(_text: string, _rootContainer: Container) {
+    throw new Error('should never be called (shouldSetTextContent=true)')
+  },
+
+  appendInitialChild(parent: Instance, child: Instance) {
+    if (child.hwnd === null) {
+      ensureChildWindow(child, parent.hwnd!)
+    } else {
+      gui.SetParent(child.hwnd, parent.hwnd)
+    }
+    if (DEBUG) console.log('[reconciler] appendInitialChild parent:', parent.hwnd, 'child:', child.hwnd)
+    parent.children.push(child)
+  },
+
+  appendChild(parent: Instance, child: Instance) {
+    if (child.hwnd === null) {
+      ensureChildWindow(child, parent.hwnd!)
+    } else {
+      gui.SetParent(child.hwnd, parent.hwnd)
+    }
+    if (DEBUG) console.log('[reconciler] appendChild parent:', parent.hwnd, 'child:', child.hwnd)
+    parent.children.push(child)
+  },
+
+  appendChildToContainer(container: Container, child: Instance) {
+    if (child.hwnd === null) {
+      ensureChildWindow(child, container)
+    } else {
+      gui.SetParent(child.hwnd, container)
+    }
+    const rootInst = instancesByHwnd.get(container)
+    if (rootInst) rootInst.children.push(child)
+    if (DEBUG) console.log('[reconciler] appendChildToContainer container:', container, 'child hwnd:', child.hwnd)
+  },
+
+  insertBefore(parent: Instance, child: Instance, beforeChild: Instance) {
+    if (child.hwnd === null) {
+      ensureChildWindow(child, parent.hwnd!)
+    } else {
+      gui.SetParent(child.hwnd, parent.hwnd)
+    }
+    if (DEBUG) console.log('[reconciler] insertBefore parent:', parent.hwnd, 'child:', child.hwnd, 'before:', beforeChild.hwnd)
+    const idx = parent.children.indexOf(beforeChild)
+    if (idx >= 0) parent.children.splice(idx, 0, child)
+  },
+
+  insertInContainerBefore(container: Container, child: Instance, _before: Instance) {
+    if (child.hwnd === null) {
+      ensureChildWindow(child, container)
+    } else {
+      gui.SetParent(child.hwnd, container)
+    }
+    const rootInst = instancesByHwnd.get(container)
+    if (!rootInst) throw new Error('insertInContainerBefore: no root instance for container')
+    const idx = rootInst.children.indexOf(_before)
+    if (idx >= 0) rootInst.children.splice(idx, 0, child)
+    else rootInst.children.push(child)
+    if (DEBUG) console.log('[reconciler] insertInContainerBefore container:', container, 'child hwnd:', child.hwnd)
+  },
+
+  removeChild(parent: Instance, child: Instance) {
+    if (DEBUG) console.log('[reconciler] removeChild parent:', parent.hwnd, 'child:', child.hwnd, 'type:', child.type)
+    if (child.hwnd !== null) gui.DestroyWindow(child.hwnd)
+    const idx = parent.children.indexOf(child)
+    if (idx >= 0) parent.children.splice(idx, 1)
+  },
+
+  removeChildFromContainer(container: Container, child: Instance) {
+    if (child.hwnd === null) return
+    if (DEBUG) console.log('[reconciler] removeChildFromContainer container:', container, 'child hwnd:', child.hwnd)
+    gui.DestroyWindow(child.hwnd)
+    const rootInst = instancesByHwnd.get(container)
+    if (rootInst) {
+      const idx = rootInst.children.indexOf(child)
+      if (idx >= 0) rootInst.children.splice(idx, 1)
+    }
+  },
+
+  commitUpdate(instance: Instance, _type: string, oldProps: Props, newProps: Props, _internalHandle: unknown) {
+    applyProps(instance, newProps, oldProps)
+  },
+
+  commitMount(_instance: Instance, _type: string, _props: Props, _internal: unknown) { },
+
+  finalizeInitialChildren(instance: Instance, type: string, props: Props) {
+    if (DEBUG) console.log('[reconciler] finalizeInitialChildren instance:', instance.hwnd, 'props:', JSON.stringify(props))
+    applyProps(instance, props, { type })
+    return false
+  },
+
+  resetAfterCommit(containerInfo: Container) {
+    if (DEBUG) console.log('[reconciler] resetAfterCommit')
+    const rootInst = instancesByHwnd.get(containerInfo)
+    if (!rootInst) throw new Error('resetAfterCommit: no root instance for container')
+    runFlexLayout(rootInst)
+  },
+
+  resetTextContent(_instance: Instance) { },
+
+  commitTextUpdate(instance: Instance, _oldText: string, newText: string) {
+    gui.SetWindowText(instance.hwnd!, newText)
+  },
+
+  hideInstance(instance: Instance) {
+    if (instance.hwnd !== null) gui.ShowWindow(instance.hwnd, gui.ShowWindowCmd.HIDE)
+  },
+
+  hideTextInstance(instance: Instance) {
+    if (instance.hwnd !== null) gui.ShowWindow(instance.hwnd, gui.ShowWindowCmd.HIDE)
+  },
+
+  unhideInstance(instance: Instance, _props: Props) {
+    if (instance.hwnd !== null) gui.ShowWindow(instance.hwnd, gui.ShowWindowCmd.SHOW)
+  },
+
+  unhideTextInstance(instance: Instance, _text: string) {
+    if (instance.hwnd !== null) gui.ShowWindow(instance.hwnd, gui.ShowWindowCmd.SHOW)
+  },
+
+  shouldSetTextContent(_type: string, props: Props) {
+    return typeof props.children === 'string' || typeof props.children === 'number'
+  },
+
+  getPublicInstance(instance: Instance) {
+    return instance.hwnd!
+  },
+
+  getRootHostContext(_rootContainer: Container) {
+    return {}
+  },
+
+  getChildHostContext(_parentContext: HostContext, _type: string) {
+    return {}
+  },
+
+  prepareForCommit(_containerInfo: Container) {
+    return null
+  },
+
+  preparePortalMount(_containerInfo: Container) { },
+
+  clearContainer(_container: Container) {
+    // 不需要清理，React reconciler 会通过 removeChildFromContainer 来移除子节点
+  },
+
+  scheduleTimeout(fn: () => void, delay: number) {
+    return os.setTimeout(fn, delay)
+  },
+
+  cancelTimeout(id: os.TimerId) {
+    os.clearTimeout?.(id)
+  },
+
+  noTimeout: -1,
+
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  isPrimaryRenderer: true,
+  supportsMicrotasks: false,
+
+  setCurrentUpdatePriority(p: number) { currentUpdatePriority = p },
+  getCurrentUpdatePriority() { return currentUpdatePriority },
+  resolveUpdatePriority() { return DefaultEventPriority },
+
+  resolveEventType() { return null },
+  resolveEventTimeStamp() { return Date.now() },
+  trackSchedulerEvent() { },
+
+  shouldAttemptEagerTransition() { return false },
+  detachDeletedInstance(instance: Instance) {
+    if (DEBUG) console.log('[reconciler] detachDeletedInstance hwnd:', instance.hwnd, 'type:', instance.type)
+    if (instance.hwnd !== null) instancesByHwnd.delete(instance.hwnd)
+  },
+  
+  // 添加必需方法
+  getInstanceFromNode(_node: unknown) { return null },
+  beforeActiveInstanceBlur() { },
+  afterActiveInstanceBlur() { },
+  prepareScopeUpdate(_scopeInstance: unknown, _instance: unknown) { },
+  getInstanceFromScope(_scopeInstance: unknown) { return null },
+  
+  // Suspense/Concurrent Mode 支持
+  maySuspendCommit() { return false },
+  requestPostPaintCallback() { },
+  preloadInstance() { return true },
+  startSuspendingCommit() { },
+  suspendInstance() { },
+  waitForCommitToBeReady() { return null },
+
+  rendererVersion: '0.1.0',
+  rendererPackageName: 'react-qw',
+  NotPendingTransition: null,
+  // @types/react.Context<T> 与 @types/react-reconciler.ReactContext<T> 是同一运行时对象
+  // 的两个不兼容类型定义（ReactContext 多 _currentValue 等字段），此 cast 不可避免
+  HostTransitionContext: createContext(null) as unknown as ReactReconciler.ReactContext<null>,
+  resetFormInstance(_form: never) { },
+}
+
+const reconciler = ReactReconciler(hostConfig)
+export default reconciler

package/lib/stream.js

@@ -0,0 +1,2 @@
+import { ReadableStream as ReadableStreamImpl, } from './vendor/web-streams/ponyfill.mjs';
+globalThis.ReadableStream = ReadableStreamImpl;

package/lib/stream.ts

@@ -0,0 +1,22 @@
+export {}
+
+import {
+    ReadableStream as ReadableStreamImpl,
+    ReadableStreamDefaultController as ReadableStreamDefaultControllerImpl,
+    ReadableStreamDefaultReader as ReadableStreamDefaultReaderImpl,
+} from './vendor/web-streams/ponyfill.mjs'
+
+declare global {
+    type ReadableStreamReadResult<R = any> =
+        | { done: false; value: R }
+        | { done: true; value?: undefined }
+
+    interface ReadableStreamReader<R = any> extends ReadableStreamDefaultReaderImpl<R> {}
+    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamDefaultReaderImpl<R> {}
+    interface ReadableStream<R = any> extends ReadableStreamImpl<R> {}
+    interface ReadableStreamDefaultController<R = any> extends ReadableStreamDefaultControllerImpl<R> {}
+
+    var ReadableStream: typeof ReadableStreamImpl
+}
+
+globalThis.ReadableStream = ReadableStreamImpl

package/lib/text-codec.js

@@ -0,0 +1,197 @@
+const _labelMap = {
+    'utf-8': 'utf-8',
+    'utf8': 'utf-8',
+    'unicode-1-1-utf-8': 'utf-8',
+    'utf-16': 'utf-16le',
+    'utf-16le': 'utf-16le',
+    'utf-16be': 'utf-16be',
+};
+function _normalizeLabel(label) {
+    if (!label)
+        return 'utf-8';
+    const result = _labelMap[label.trim().toLowerCase()];
+    if (result)
+        return result;
+    throw new RangeError(`The encoding label "${label}" is not supported`);
+}
+function _decodeUTF8(buf, fatal) {
+    let out = '';
+    for (let i = 0; i < buf.length;) {
+        const b = buf[i++];
+        if (b < 0x80) {
+            out += String.fromCharCode(b);
+            continue;
+        }
+        if (b < 0xC0) {
+            out += fatal ? (() => { throw new TypeError('unexpected continuation byte'); })() : '\uFFFD';
+            continue;
+        }
+        let c, min;
+        if (b < 0xE0) {
+            if (i >= buf.length) {
+                out += fatal ? (() => { throw new TypeError('incomplete utf-8'); })() : '\uFFFD';
+                break;
+            }
+            const b2 = buf[i++];
+            if ((b2 & 0xC0) !== 0x80) {
+                out += '\uFFFD';
+                continue;
+            }
+            c = ((b & 0x1F) << 6) | (b2 & 0x3F);
+            min = 0x80;
+        }
+        else if (b < 0xF0) {
+            if (i + 1 >= buf.length) {
+                out += fatal ? (() => { throw new TypeError('incomplete utf-8'); })() : '\uFFFD';
+                break;
+            }
+            const b2 = buf[i++];
+            const b3 = buf[i++];
+            if (((b2 & 0xC0) !== 0x80) || ((b3 & 0xC0) !== 0x80)) {
+                out += '\uFFFD';
+                continue;
+            }
+            c = ((b & 0x0F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F);
+            min = 0x800;
+        }
+        else if (b < 0xF8) {
+            if (i + 2 >= buf.length) {
+                out += fatal ? (() => { throw new TypeError('incomplete utf-8'); })() : '\uFFFD';
+                break;
+            }
+            const b2 = buf[i++];
+            const b3 = buf[i++];
+            const b4 = buf[i++];
+            if (((b2 & 0xC0) !== 0x80) || ((b3 & 0xC0) !== 0x80) || ((b4 & 0xC0) !== 0x80)) {
+                out += '\uFFFD';
+                continue;
+            }
+            c = ((b & 0x07) << 18) | ((b2 & 0x3F) << 12) | ((b3 & 0x3F) << 6) | (b4 & 0x3F);
+            min = 0x10000;
+        }
+        else {
+            out += fatal ? (() => { throw new TypeError('invalid utf-8 start'); })() : '\uFFFD';
+            continue;
+        }
+        if (c < min || (c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF) {
+            out += fatal ? (() => { throw new TypeError('invalid utf-8 codepoint'); })() : '\uFFFD';
+            continue;
+        }
+        if (c <= 0xFFFF)
+            out += String.fromCharCode(c);
+        else {
+            c -= 0x10000;
+            out += String.fromCharCode(0xD800 | (c >> 10), 0xDC00 | (c & 0x3FF));
+        }
+    }
+    return out;
+}
+function _decodeUTF16(buf, le, fatal) {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    let out = '';
+    for (let i = 0; i + 1 < buf.length; i += 2) {
+        let c = dv.getUint16(i, le);
+        if (c >= 0xD800 && c <= 0xDBFF) {
+            i += 2;
+            if (i + 1 >= buf.length) {
+                out += fatal ? (() => { throw new TypeError('truncated surrogate pair'); })() : '\uFFFD';
+                break;
+            }
+            const c2 = dv.getUint16(i, le);
+            if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
+                out += String.fromCharCode(c, c2);
+            }
+            else {
+                out += fatal ? (() => { throw new TypeError('invalid surrogate pair'); })() : '\uFFFD';
+                i -= 2;
+            }
+        }
+        else if (c >= 0xDC00 && c <= 0xDFFF) {
+            out += fatal ? (() => { throw new TypeError('unexpected trailing surrogate'); })() : '\uFFFD';
+        }
+        else {
+            out += String.fromCharCode(c);
+        }
+    }
+    return out;
+}
+class TextDecoderImpl {
+    _encoding;
+    _fatal;
+    _ignoreBOM;
+    constructor(label, options) {
+        this._encoding = _normalizeLabel(label);
+        this._fatal = options?.fatal ?? false;
+        this._ignoreBOM = options?.ignoreBOM ?? false;
+    }
+    get encoding() { return this._encoding; }
+    get fatal() { return this._fatal; }
+    get ignoreBOM() { return this._ignoreBOM; }
+    decode(buffer) {
+        if (!buffer)
+            return '';
+        const arr = buffer instanceof Uint8Array ? buffer
+            : buffer instanceof ArrayBuffer ? new Uint8Array(buffer)
+                : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        if (this._encoding === 'utf-8') {
+            return _decodeUTF8(arr, this._fatal);
+        }
+        const le = this._encoding === 'utf-16le';
+        let offset = 0;
+        if (arr.length >= 2 && !this._ignoreBOM) {
+            const bomLo = le ? arr[0] : arr[1];
+            const bomHi = le ? arr[1] : arr[0];
+            const bom = (bomHi << 8) | bomLo;
+            if (bom === 0xFEFF || bom === 0xFFFE) {
+                offset = 2;
+            }
+        }
+        return _decodeUTF16(arr.slice(offset), le, this._fatal);
+    }
+}
+class TextEncoderImpl {
+    _encoding;
+    constructor(label) {
+        this._encoding = _normalizeLabel(label);
+    }
+    get encoding() { return this._encoding; }
+    encode(input) {
+        if (!input)
+            return new Uint8Array(0);
+        if (this._encoding === 'utf-8') {
+            const bytes = [];
+            for (let i = 0; i < input.length; i++) {
+                let c = input.charCodeAt(i);
+                if (c < 0x80) {
+                    bytes.push(c);
+                }
+                else if (c < 0x800) {
+                    bytes.push(0xC0 | (c >> 6), 0x80 | (c & 0x3F));
+                }
+                else if (c < 0xD800 || c >= 0xE000) {
+                    bytes.push(0xE0 | (c >> 12), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+                }
+                else {
+                    i++;
+                    const c2 = input.charCodeAt(i);
+                    c = 0x10000 + ((c & 0x3FF) << 10) | (c2 & 0x3FF);
+                    bytes.push(0xF0 | (c >> 18), 0x80 | ((c >> 12) & 0x3F), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+                }
+            }
+            return new Uint8Array(bytes);
+        }
+        const le = this._encoding === 'utf-16le';
+        const buf = new ArrayBuffer(input.length * 2);
+        const dv = new DataView(buf);
+        for (let i = 0; i < input.length; i++)
+            dv.setUint16(i * 2, input.charCodeAt(i), le);
+        return new Uint8Array(buf);
+    }
+}
+if (typeof globalThis.TextDecoder === 'undefined') {
+    globalThis.TextDecoder = TextDecoderImpl;
+}
+if (typeof globalThis.TextEncoder === 'undefined') {
+    globalThis.TextEncoder = TextEncoderImpl;
+}
+export {};