@aiwayds/dsh-opentui 0.1.0 → 0.3.0

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/sequence.ts

@@ -0,0 +1,59 @@
+import { ITERATOR_CONSTRUCTOR } from './constructors';
+import { SYM_ITERATOR } from './symbols';
+
+export interface Sequence {
+  __SEROVAL_SEQUENCE__: true;
+
+  v: unknown[];
+  t: number;
+  d: number;
+}
+
+export function isSequence(value: object): value is Sequence {
+  return '__SEROVAL_SEQUENCE__' in value;
+}
+
+export function createSequence(
+  values: unknown[],
+  throwAt: number,
+  doneAt: number,
+): Sequence {
+  return {
+    __SEROVAL_SEQUENCE__: true,
+
+    v: values,
+    t: throwAt,
+    d: doneAt,
+  };
+}
+
+export function createSequenceFromIterable<T>(source: Iterable<T>): Sequence {
+  const values: unknown[] = [];
+  let throwsAt = -1;
+  let doneAt = -1;
+  const iterator = source[SYM_ITERATOR]();
+
+  while (true) {
+    try {
+      const value = iterator.next();
+      values.push(value.value);
+      if (value.done) {
+        doneAt = values.length - 1;
+        break;
+      }
+    } catch (error) {
+      throwsAt = values.length;
+      values.push(error);
+    }
+  }
+
+  return createSequence(values, throwsAt, doneAt);
+}
+
+const createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
+
+export function sequenceToIterator<T>(
+  sequence: Sequence,
+): () => IterableIterator<T> {
+  return createIterator(sequence) as unknown as () => IterableIterator<T>;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/special-reference.ts

@@ -0,0 +1,42 @@
+import {
+  SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
+  SERIALIZED_PROMISE_CONSTRUCTOR,
+  SERIALIZED_PROMISE_FAILURE,
+  SERIALIZED_PROMISE_SUCCESS,
+  SERIALIZED_STREAM_CONSTRUCTOR,
+} from './constructors';
+
+export const ITERATOR = {};
+
+export const ASYNC_ITERATOR = {};
+
+export const enum SpecialReference {
+  MapSentinel = 0,
+  PromiseConstructor = 1,
+  PromiseSuccess = 2,
+  PromiseFailure = 3,
+  StreamConstructor = 4,
+  ArrayBufferConstructor = 5,
+}
+
+/**
+ * Placeholder references
+ */
+export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
+  [SpecialReference.MapSentinel]: {},
+  [SpecialReference.PromiseConstructor]: {},
+  [SpecialReference.PromiseSuccess]: {},
+  [SpecialReference.PromiseFailure]: {},
+  [SpecialReference.StreamConstructor]: {},
+  [SpecialReference.ArrayBufferConstructor]: {},
+};
+
+export const SPECIAL_REF_STRING: Record<SpecialReference, string> = {
+  [SpecialReference.MapSentinel]: '[]',
+  [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,
+  [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,
+  [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,
+  [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,
+  [SpecialReference.ArrayBufferConstructor]:
+    SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
+};

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/stream.ts

@@ -0,0 +1,71 @@
+import {
+  ASYNC_ITERATOR_CONSTRUCTOR,
+  PROMISE_CONSTRUCTOR,
+  STREAM_CONSTRUCTOR,
+} from './constructors';
+import { SYM_ASYNC_ITERATOR } from './symbols';
+
+export interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export interface Stream<T> {
+  __SEROVAL_STREAM__: true;
+
+  on(listener: StreamListener<T>): () => void;
+
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export function isStream<T>(value: object): value is Stream<T> {
+  return '__SEROVAL_STREAM__' in value;
+}
+
+export function createStream<T>(): Stream<T> {
+  return STREAM_CONSTRUCTOR() as unknown as Stream<T>;
+}
+
+export function createStreamFromAsyncIterable<T>(
+  iterable: AsyncIterable<T>,
+): Stream<T> {
+  const stream = createStream<T>();
+
+  const iterator = iterable[SYM_ASYNC_ITERATOR]();
+
+  async function push(): Promise<void> {
+    try {
+      const value = await iterator.next();
+      if (value.done) {
+        stream.return(value.value as T);
+      } else {
+        stream.next(value.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+
+  push().catch(() => {
+    // no-op
+  });
+
+  return stream;
+}
+
+const createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(
+  SYM_ASYNC_ITERATOR,
+  PROMISE_CONSTRUCTOR,
+);
+
+export function streamToAsyncIterable<T>(
+  stream: Stream<T>,
+): () => AsyncIterableIterator<T> {
+  return createAsyncIterable(
+    stream,
+  ) as unknown as () => AsyncIterableIterator<T>;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/string.ts

@@ -0,0 +1,86 @@
+import { NIL } from './constants';
+
+export function serializeChar(str: string): string | undefined {
+  switch (str) {
+    case '"':
+      return '\\"';
+    case '\\':
+      return '\\\\';
+    case '\n':
+      return '\\n';
+    case '\r':
+      return '\\r';
+    case '\b':
+      return '\\b';
+    case '\t':
+      return '\\t';
+    case '\f':
+      return '\\f';
+    case '<':
+      return '\\x3C';
+    case '\u2028':
+      return '\\u2028';
+    case '\u2029':
+      return '\\u2029';
+    default:
+      return NIL;
+  }
+}
+
+// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
+// Creates a JavaScript double quoted string and escapes all characters
+// not listed as DoubleStringCharacters on
+// Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
+// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+export function serializeString(str: string): string {
+  let result = '';
+  let lastPos = 0;
+  let replacement: string | undefined;
+  for (let i = 0, len = str.length; i < len; i++) {
+    replacement = serializeChar(str[i]);
+    if (replacement) {
+      result += str.slice(lastPos, i) + replacement;
+      lastPos = i + 1;
+    }
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return result;
+}
+
+function deserializeReplacer(str: string): string {
+  switch (str) {
+    case '\\\\':
+      return '\\';
+    case '\\"':
+      return '"';
+    case '\\n':
+      return '\n';
+    case '\\r':
+      return '\r';
+    case '\\b':
+      return '\b';
+    case '\\t':
+      return '\t';
+    case '\\f':
+      return '\f';
+    case '\\x3C':
+      return '\x3C';
+    case '\\u2028':
+      return '\u2028';
+    case '\\u2029':
+      return '\u2029';
+    default:
+      return str;
+  }
+}
+
+export function deserializeString(str: string): string {
+  return str.replace(
+    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
+    deserializeReplacer,
+  );
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/symbols.ts

@@ -0,0 +1,20 @@
+export const SYM_ASYNC_ITERATOR: typeof Symbol.asyncIterator =
+  Symbol.asyncIterator;
+export const SYM_HAS_INSTANCE: typeof Symbol.hasInstance = Symbol.hasInstance;
+export const SYM_IS_CONCAT_SPREADABLE: typeof Symbol.isConcatSpreadable =
+  Symbol.isConcatSpreadable;
+export const SYM_ITERATOR: typeof Symbol.iterator = Symbol.iterator;
+export const SYM_MATCH: typeof Symbol.match = Symbol.match;
+export const SYM_MATCH_ALL: typeof Symbol.matchAll = Symbol.matchAll;
+export const SYM_REPLACE: typeof Symbol.replace = Symbol.replace;
+export const SYM_SEARCH: typeof Symbol.search = Symbol.search;
+export const SYM_SPECIES: typeof Symbol.species = Symbol.species;
+export const SYM_SPLIT: typeof Symbol.split = Symbol.split;
+export const SYM_TO_PRIMITIVE: typeof Symbol.toPrimitive = Symbol.toPrimitive;
+export const SYM_TO_STRING_TAG: typeof Symbol.toStringTag = Symbol.toStringTag;
+export const SYM_UNSCOPABLES: typeof Symbol.unscopables = Symbol.unscopables;
+
+// For the future
+
+// export const SYM_DISPOSE = Symbol.dispose;
+// export const SYM_ASYNC_DISPOSE = Symbol.asyncDispose;

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/tree/index.ts

@@ -0,0 +1,134 @@
+import {
+  createAsyncParserContext,
+  parseTopAsync,
+} from '../context/async-parser';
+import {
+  createVanillaDeserializerContext,
+  deserializeTop,
+} from '../context/deserializer';
+import type { BaseParserContextOptions } from '../context/parser';
+import {
+  createVanillaSerializerContext,
+  serializeTopVanilla,
+} from '../context/serializer';
+import { createSyncParserContext, parseTop } from '../context/sync-parser';
+import {
+  type PluginAccessOptions,
+  resolvePlugins,
+  SerovalMode,
+} from '../plugin';
+import type { SerovalNode } from '../types';
+import { ALL_ENABLED } from '../compat';
+export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
+export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
+
+export function serialize<T>(
+  source: T,
+  options: SyncParserContextOptions = {},
+): string {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = parseTop(ctx, source);
+  const serial = createVanillaSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopVanilla(serial, tree);
+}
+
+export async function serializeAsync<T>(
+  source: T,
+  options: AsyncParserContextOptions = {},
+): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = await parseTopAsync(ctx, source);
+  const serial = createVanillaSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopVanilla(serial, tree);
+}
+
+export function deserialize<T>(source: string): T {
+  return (0, eval)(source) as T;
+}
+
+export interface SerovalJSON {
+  t: SerovalNode;
+  f: number;
+  m: number[];
+}
+
+export interface FromJSONOptions extends PluginAccessOptions {
+  disabledFeatures?: number;
+}
+
+export function toJSON<T>(
+  source: T,
+  options: SyncParserContextOptions = {},
+): SerovalJSON {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  return {
+    t: parseTop(ctx, source),
+    f: ctx.base.features,
+    m: Array.from(ctx.base.marked),
+  };
+}
+
+export async function toJSONAsync<T>(
+  source: T,
+  options: AsyncParserContextOptions = {},
+): Promise<SerovalJSON> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  return {
+    t: await parseTopAsync(ctx, source),
+    f: ctx.base.features,
+    m: Array.from(ctx.base.marked),
+  };
+}
+
+export function compileJSON(
+  source: SerovalJSON,
+  options: PluginAccessOptions = {},
+): string {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createVanillaSerializerContext({
+    plugins,
+    features: source.f,
+    markedRefs: source.m,
+  });
+  return serializeTopVanilla(ctx, source.t);
+}
+
+export function fromJSON<T>(
+  source: SerovalJSON,
+  options: FromJSONOptions = {},
+): T {
+  const plugins = resolvePlugins(options.plugins);
+  const disabledFeatures = options.disabledFeatures || 0;
+  const sourceFeatures = source.f ?? ALL_ENABLED;
+  const ctx = createVanillaDeserializerContext({
+    plugins,
+    markedRefs: source.m,
+    features: sourceFeatures & ~disabledFeatures,
+    disabledFeatures,
+  });
+  return deserializeTop(ctx, source.t) as T;
+}