@aiwayds/dsh-opentui 0.1.0 → 0.2.0

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/dom-exception.ts

@@ -0,0 +1,57 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+type DOMExceptionNode = {
+  name: SerovalNode;
+  message: SerovalNode;
+};
+
+const DOMExceptionPlugin = /* @__PURE__ */ createPlugin<
+  DOMException,
+  DOMExceptionNode
+>({
+  tag: 'seroval-plugins/web/DOMException',
+  test(value) {
+    if (typeof DOMException === 'undefined') {
+      return false;
+    }
+    return value instanceof DOMException;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        name: ctx.parse(value.name),
+        message: ctx.parse(value.message),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        name: await ctx.parse(value.name),
+        message: await ctx.parse(value.message),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        name: ctx.parse(value.name),
+        message: ctx.parse(value.message),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new DOMException(' +
+      ctx.serialize(node.message) +
+      ',' +
+      ctx.serialize(node.name) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new DOMException(
+      ctx.deserialize(node.message) as string,
+      ctx.deserialize(node.name) as string,
+    );
+  },
+});
+
+export default DOMExceptionPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/event.ts

@@ -0,0 +1,62 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+function createEventOptions(current: Event): EventInit {
+  return {
+    bubbles: current.bubbles,
+    cancelable: current.cancelable,
+    composed: current.composed,
+  };
+}
+
+type EventNode = {
+  type: SerovalNode;
+  options: SerovalNode;
+};
+
+const EventPlugin = /* @__PURE__ */ createPlugin<Event, EventNode>({
+  tag: 'seroval-plugins/web/Event',
+  test(value) {
+    if (typeof Event === 'undefined') {
+      return false;
+    }
+    return value instanceof Event;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        type: ctx.parse(value.type),
+        options: ctx.parse(createEventOptions(value)),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        type: await ctx.parse(value.type),
+        options: await ctx.parse(createEventOptions(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        type: ctx.parse(value.type),
+        options: ctx.parse(createEventOptions(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new Event(' +
+      ctx.serialize(node.type) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new Event(
+      ctx.deserialize(node.type) as string,
+      ctx.deserialize(node.options) as EventInit,
+    );
+  },
+});
+
+export default EventPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/file.ts

@@ -0,0 +1,50 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+type FileNode = {
+  name: SerovalNode;
+  options: SerovalNode;
+  buffer: SerovalNode;
+};
+
+const FilePlugin = /* @__PURE__ */ createPlugin<File, FileNode>({
+  tag: 'seroval-plugins/web/File',
+  test(value) {
+    if (typeof File === 'undefined') {
+      return false;
+    }
+    return value instanceof File;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        name: await ctx.parse(value.name),
+        options: await ctx.parse({
+          type: value.type,
+          lastModified: value.lastModified,
+        }),
+        buffer: await ctx.parse(await value.arrayBuffer()),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new File([' +
+      ctx.serialize(node.buffer) +
+      '],' +
+      ctx.serialize(node.name) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new File(
+      [ctx.deserialize(node.buffer) as ArrayBuffer],
+      ctx.deserialize(node.name) as string,
+      ctx.deserialize(node.options) as FilePropertyBag,
+    );
+  },
+});
+
+export default FilePlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/form-data.ts

@@ -0,0 +1,105 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import FilePlugin from './file';
+
+type FormDataInit = [key: string, value: FormDataEntryValue][];
+
+function convertFormData(instance: FormData): FormDataInit {
+  const items: FormDataInit = [];
+  instance.forEach((value, key) => {
+    items.push([key, value]);
+  });
+  return items;
+}
+
+const FORM_DATA_FACTORY = {};
+
+const FORM_DATA_FACTORY_CONSTRUCTOR = (
+  e: [key: string, value: FormDataEntryValue][],
+  f = new FormData(),
+  i = 0,
+  s = e.length,
+  t?: [key: string, value: FormDataEntryValue],
+) => {
+  for (; i < s; i++) {
+    t = e[i];
+    f.append(t[0], t[1]);
+  }
+  return f;
+};
+
+const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
+  tag: 'seroval-plugins/web/FormDataFactory',
+  test(value) {
+    return value === FORM_DATA_FACTORY;
+  },
+  parse: {
+    sync() {
+      return FORM_DATA_FACTORY;
+    },
+    async async() {
+      return await Promise.resolve(FORM_DATA_FACTORY);
+    },
+    stream() {
+      return FORM_DATA_FACTORY;
+    },
+  },
+  serialize() {
+    return FORM_DATA_FACTORY_CONSTRUCTOR.toString();
+  },
+  deserialize() {
+    return FORM_DATA_FACTORY;
+  },
+});
+
+type FormDataNode = {
+  factory: SerovalNode;
+  entries: SerovalNode;
+};
+
+const FormDataPlugin = /* @__PURE__ */ createPlugin<FormData, FormDataNode>({
+  tag: 'seroval-plugins/web/FormData',
+  extends: [FilePlugin, FormDataFactoryPlugin],
+  test(value) {
+    if (typeof FormData === 'undefined') {
+      return false;
+    }
+    return value instanceof FormData;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        factory: ctx.parse(FORM_DATA_FACTORY),
+        entries: ctx.parse(convertFormData(value)),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        factory: await ctx.parse(FORM_DATA_FACTORY),
+        entries: await ctx.parse(convertFormData(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        factory: ctx.parse(FORM_DATA_FACTORY),
+        entries: ctx.parse(convertFormData(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      '(' +
+      ctx.serialize(node.factory) +
+      ')(' +
+      ctx.serialize(node.entries) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return FORM_DATA_FACTORY_CONSTRUCTOR(
+      ctx.deserialize(node.entries) as FormDataInit,
+    );
+  },
+});
+
+export default FormDataPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/headers.ts

@@ -0,0 +1,49 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+function convertHeaders(instance: Headers): HeadersInit {
+  const items: HeadersInit = [];
+  // biome-ignore lint/complexity/noForEach: <explanation>
+  instance.forEach((value, key) => {
+    items.push([key, value]);
+  });
+  return items;
+}
+
+const HeadersPlugin = /* @__PURE__ */ createPlugin<
+  Headers,
+  { value: SerovalNode }
+>({
+  tag: 'seroval-plugins/web/Headers',
+  test(value) {
+    if (typeof Headers === 'undefined') {
+      return false;
+    }
+    return value instanceof Headers;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        value: ctx.parse(convertHeaders(value)),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        value: await ctx.parse(convertHeaders(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        value: ctx.parse(convertHeaders(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return 'new Headers(' + ctx.serialize(node.value) + ')';
+  },
+  deserialize(node, ctx) {
+    return new Headers(ctx.deserialize(node.value) as HeadersInit);
+  },
+});
+
+export default HeadersPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/image-data.ts

@@ -0,0 +1,74 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+type ImageDataNode = {
+  data: SerovalNode;
+  width: SerovalNode;
+  height: SerovalNode;
+  options: SerovalNode;
+};
+
+const ImageDataPlugin = /* @__PURE__ */ createPlugin<ImageData, ImageDataNode>({
+  tag: 'seroval-plugins/web/ImageData',
+  test(value) {
+    if (typeof ImageData === 'undefined') {
+      return false;
+    }
+    return value instanceof ImageData;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        data: ctx.parse(value.data),
+        width: ctx.parse(value.width),
+        height: ctx.parse(value.height),
+        options: ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        data: await ctx.parse(value.data),
+        width: await ctx.parse(value.width),
+        height: await ctx.parse(value.height),
+        options: await ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        data: ctx.parse(value.data),
+        width: ctx.parse(value.width),
+        height: ctx.parse(value.height),
+        options: ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new ImageData(' +
+      ctx.serialize(node.data) +
+      ',' +
+      ctx.serialize(node.width) +
+      ',' +
+      ctx.serialize(node.height) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new ImageData(
+      ctx.deserialize(node.data) as Uint8ClampedArray<ArrayBuffer>,
+      ctx.deserialize(node.width) as number,
+      ctx.deserialize(node.height) as number,
+      ctx.deserialize(node.options) as ImageDataSettings,
+    );
+  },
+});
+
+export default ImageDataPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/index.ts

@@ -0,0 +1,14 @@
+export { default as AbortSignalPlugin } from './abort-signal';
+export { default as BlobPlugin } from './blob';
+export { default as CustomEventPlugin } from './custom-event';
+export { default as DOMExceptionPlugin } from './dom-exception';
+export { default as EventPlugin } from './event';
+export { default as FilePlugin } from './file';
+export { default as FormDataPlugin } from './form-data';
+export { default as HeadersPlugin } from './headers';
+export { default as ImageDataPlugin } from './image-data';
+export { default as ReadableStreamPlugin } from './readable-stream';
+export { default as RequestPlugin } from './request';
+export { default as ResponsePlugin } from './response';
+export { default as URLPlugin } from './url';
+export { default as URLSearchParamsPlugin } from './url-search-params';

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/readable-stream.ts

@@ -0,0 +1,148 @@
+import type { SerovalNode, Stream } from 'seroval';
+import { createPlugin, createStream } from 'seroval';
+
+const READABLE_STREAM_FACTORY = {};
+
+const READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream: Stream<unknown>) =>
+  new ReadableStream({
+    start: controller => {
+      stream.on({
+        next: value => {
+          try {
+            controller.enqueue(value);
+          } catch (_error) {
+            // no-op
+          }
+        },
+        throw: value => {
+          controller.error(value);
+        },
+        return: () => {
+          try {
+            controller.close();
+          } catch (_error) {
+            // no-op
+          }
+        },
+      });
+    },
+  });
+
+const ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
+  tag: 'seroval-plugins/web/ReadableStreamFactory',
+  test(value) {
+    return value === READABLE_STREAM_FACTORY;
+  },
+  parse: {
+    sync() {
+      return READABLE_STREAM_FACTORY;
+    },
+    async async() {
+      return await Promise.resolve(READABLE_STREAM_FACTORY);
+    },
+    stream() {
+      return READABLE_STREAM_FACTORY;
+    },
+  },
+  serialize() {
+    return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();
+  },
+  deserialize() {
+    return READABLE_STREAM_FACTORY;
+  },
+});
+
+async function drainStream<T>(
+  stream: Stream<T | undefined>,
+  reader: ReadableStreamDefaultReader<T>,
+): Promise<void> {
+  try {
+    const result = await reader.read();
+    if (result.done) {
+      stream.return(result.value);
+      reader.releaseLock();
+    } else {
+      stream.next(result.value);
+      await drainStream(stream, reader);
+    }
+  } catch (error) {
+    stream.throw(error);
+  }
+}
+
+function cleanupStream<T>(reader: ReadableStreamDefaultReader<T>): void {
+  reader.cancel().catch(() => {
+    // no-op
+  });
+  reader.releaseLock();
+}
+
+function toStream<T>(
+  value: ReadableStream<T>,
+): [Stream<T | undefined>, () => void] {
+  const stream = createStream<T | undefined>();
+
+  const reader = value.getReader();
+
+  const cleanup = cleanupStream.bind(null, reader);
+
+  drainStream(stream, reader).catch(cleanup);
+
+  return [stream, cleanup];
+}
+
+type ReadableStreamNode = {
+  factory: SerovalNode;
+  stream: SerovalNode;
+};
+
+const ReadableStreamPlugin = /* @__PURE__ */ createPlugin<
+  ReadableStream,
+  ReadableStreamNode
+>({
+  tag: 'seroval/plugins/web/ReadableStream',
+  extends: [ReadableStreamFactoryPlugin],
+  test(value) {
+    if (typeof ReadableStream === 'undefined') {
+      return false;
+    }
+    return value instanceof ReadableStream;
+  },
+  parse: {
+    sync(_value, ctx) {
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(createStream()),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        factory: await ctx.parse(READABLE_STREAM_FACTORY),
+        stream: await ctx.parse(toStream(value)[0]),
+      };
+    },
+    stream(value, ctx) {
+      const [stream, cleanup] = toStream(value);
+      ctx.addCleanup(cleanup);
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(stream),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      '(' +
+      ctx.serialize(node.factory) +
+      ')(' +
+      ctx.serialize(node.stream) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    const stream = ctx.deserialize(node.stream) as Stream<any>;
+    return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);
+  },
+});
+
+export default ReadableStreamPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/request.ts

@@ -0,0 +1,82 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import HeadersPlugin from './headers';
+import ReadableStreamPlugin from './readable-stream';
+
+function createRequestOptions(
+  current: Request,
+  body: ArrayBuffer | ReadableStream | null,
+): RequestInit {
+  return {
+    body,
+    cache: current.cache,
+    credentials: current.credentials,
+    headers: current.headers,
+    integrity: current.integrity,
+    keepalive: current.keepalive,
+    method: current.method,
+    mode: current.mode,
+    redirect: current.redirect,
+    referrer: current.referrer,
+    referrerPolicy: current.referrerPolicy,
+  };
+}
+
+type RequestNode = {
+  url: SerovalNode;
+  options: SerovalNode;
+};
+
+const RequestPlugin = /* @__PURE__ */ createPlugin<Request, RequestNode>({
+  tag: 'seroval-plugins/web/Request',
+  extends: [ReadableStreamPlugin, HeadersPlugin],
+  test(value) {
+    if (typeof Request === 'undefined') {
+      return false;
+    }
+    return value instanceof Request;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        url: await ctx.parse(value.url),
+        options: await ctx.parse(
+          createRequestOptions(
+            value,
+            value.body && !value.bodyUsed
+              ? await value.clone().arrayBuffer()
+              : null,
+          ),
+        ),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        url: ctx.parse(value.url),
+        options: ctx.parse(
+          createRequestOptions(
+            value,
+            value.body && !value.bodyUsed ? value.clone().body : null,
+          ),
+        ),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new Request(' +
+      ctx.serialize(node.url) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new Request(
+      ctx.deserialize(node.url) as string,
+      ctx.deserialize(node.options) as RequestInit,
+    );
+  },
+});
+
+export default RequestPlugin;

package/dist-host/node_modules/.pnpm/seroval-plugins@1.5.6_seroval@1.5.6/node_modules/seroval-plugins/web/response.ts

@@ -0,0 +1,65 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import HeadersPlugin from './headers';
+import ReadableStreamPlugin from './readable-stream';
+
+function createResponseOptions(current: Response): ResponseInit {
+  return {
+    headers: current.headers,
+    status: current.status,
+    statusText: current.statusText,
+  };
+}
+
+type ResponseNode = {
+  body: SerovalNode;
+  options: SerovalNode;
+};
+
+const ResponsePlugin = /* @__PURE__ */ createPlugin<Response, ResponseNode>({
+  tag: 'seroval-plugins/web/Response',
+  extends: [ReadableStreamPlugin, HeadersPlugin],
+  test(value) {
+    if (typeof Response === 'undefined') {
+      return false;
+    }
+    return value instanceof Response;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        body: await ctx.parse(
+          value.body && !value.bodyUsed
+            ? await value.clone().arrayBuffer()
+            : null,
+        ),
+        options: await ctx.parse(createResponseOptions(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        body: ctx.parse(
+          value.body && !value.bodyUsed ? value.clone().body : null,
+        ),
+        options: ctx.parse(createResponseOptions(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new Response(' +
+      ctx.serialize(node.body) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new Response(
+      ctx.deserialize(node.body) as BodyInit,
+      ctx.deserialize(node.options) as ResponseInit,
+    );
+  },
+});
+
+export default ResponsePlugin;