@aiwayds/dsh-opentui 0.1.0 → 0.2.0

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

@@ -0,0 +1,202 @@
+import {
+  SYM_ASYNC_ITERATOR,
+  SYM_HAS_INSTANCE,
+  SYM_IS_CONCAT_SPREADABLE,
+  SYM_ITERATOR,
+  SYM_MATCH,
+  SYM_MATCH_ALL,
+  SYM_REPLACE,
+  SYM_SEARCH,
+  SYM_SPECIES,
+  SYM_SPLIT,
+  SYM_TO_PRIMITIVE,
+  SYM_TO_STRING_TAG,
+  SYM_UNSCOPABLES,
+} from './symbols';
+
+export const enum SerovalConstant {
+  Null = 0,
+  Undefined = 1,
+  True = 2,
+  False = 3,
+  NegZero = 4,
+  Inf = 5,
+  NegInf = 6,
+  Nan = 7,
+}
+
+export const enum SerovalNodeType {
+  Number = 0,
+  String = 1,
+  Constant = 2,
+  BigInt = 3,
+  IndexedValue = 4,
+  Date = 5,
+  RegExp = 6,
+  Set = 7,
+  Map = 8,
+  Array = 9,
+  Object = 10,
+  NullConstructor = 11,
+  Promise = 12,
+  Error = 13,
+  AggregateError = 14,
+  TypedArray = 15,
+  BigIntTypedArray = 16,
+  WKSymbol = 17,
+  Reference = 18,
+  ArrayBuffer = 19,
+  DataView = 20,
+  Boxed = 21,
+  PromiseConstructor = 22,
+  PromiseSuccess = 23,
+  PromiseFailure = 24,
+  Plugin = 25,
+  SpecialReference = 26,
+  IteratorFactory = 27,
+  IteratorFactoryInstance = 28,
+  AsyncIteratorFactory = 29,
+  AsyncIteratorFactoryInstance = 30,
+  StreamConstructor = 31,
+  StreamNext = 32,
+  StreamThrow = 33,
+  StreamReturn = 34,
+  Sequence = 35,
+}
+
+export const enum SerovalObjectFlags {
+  None = 0,
+  NonExtensible = 1,
+  Sealed = 2,
+  Frozen = 3,
+}
+
+export const enum Symbols {
+  AsyncIterator = 0,
+  HasInstance = 1,
+  IsConcatSpreadable = 2,
+  Iterator = 3,
+  Match = 4,
+  MatchAll = 5,
+  Replace = 6,
+  Search = 7,
+  Species = 8,
+  Split = 9,
+  ToPrimitive = 10,
+  ToStringTag = 11,
+  Unscopables = 12,
+}
+
+export const SYMBOL_STRING: Record<Symbols, string> = {
+  [Symbols.AsyncIterator]: 'Symbol.asyncIterator',
+  [Symbols.HasInstance]: 'Symbol.hasInstance',
+  [Symbols.IsConcatSpreadable]: 'Symbol.isConcatSpreadable',
+  [Symbols.Iterator]: 'Symbol.iterator',
+  [Symbols.Match]: 'Symbol.match',
+  [Symbols.MatchAll]: 'Symbol.matchAll',
+  [Symbols.Replace]: 'Symbol.replace',
+  [Symbols.Search]: 'Symbol.search',
+  [Symbols.Species]: 'Symbol.species',
+  [Symbols.Split]: 'Symbol.split',
+  [Symbols.ToPrimitive]: 'Symbol.toPrimitive',
+  [Symbols.ToStringTag]: 'Symbol.toStringTag',
+  [Symbols.Unscopables]: 'Symbol.unscopables',
+};
+
+export const INV_SYMBOL_REF = /* @__PURE__ */ {
+  [SYM_ASYNC_ITERATOR]: Symbols.AsyncIterator,
+  [SYM_HAS_INSTANCE]: Symbols.HasInstance,
+  [SYM_IS_CONCAT_SPREADABLE]: Symbols.IsConcatSpreadable,
+  [SYM_ITERATOR]: Symbols.Iterator,
+  [SYM_MATCH]: Symbols.Match,
+  [SYM_MATCH_ALL]: Symbols.MatchAll,
+  [SYM_REPLACE]: Symbols.Replace,
+  [SYM_SEARCH]: Symbols.Search,
+  [SYM_SPECIES]: Symbols.Species,
+  [SYM_SPLIT]: Symbols.Split,
+  [SYM_TO_PRIMITIVE]: Symbols.ToPrimitive,
+  [SYM_TO_STRING_TAG]: Symbols.ToStringTag,
+  [SYM_UNSCOPABLES]: Symbols.Unscopables,
+};
+
+export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
+
+export const SYMBOL_REF: Record<Symbols, WellKnownSymbols> = {
+  [Symbols.AsyncIterator]: SYM_ASYNC_ITERATOR,
+  [Symbols.HasInstance]: SYM_HAS_INSTANCE,
+  [Symbols.IsConcatSpreadable]: SYM_IS_CONCAT_SPREADABLE,
+  [Symbols.Iterator]: SYM_ITERATOR,
+  [Symbols.Match]: SYM_MATCH,
+  [Symbols.MatchAll]: SYM_MATCH_ALL,
+  [Symbols.Replace]: SYM_REPLACE,
+  [Symbols.Search]: SYM_SEARCH,
+  [Symbols.Species]: SYM_SPECIES,
+  [Symbols.Split]: SYM_SPLIT,
+  [Symbols.ToPrimitive]: SYM_TO_PRIMITIVE,
+  [Symbols.ToStringTag]: SYM_TO_STRING_TAG,
+  [Symbols.Unscopables]: SYM_UNSCOPABLES,
+};
+
+export const CONSTANT_STRING: Record<SerovalConstant, string> = {
+  [SerovalConstant.True]: '!0',
+  [SerovalConstant.False]: '!1',
+  [SerovalConstant.Undefined]: 'void 0',
+  [SerovalConstant.Null]: 'null',
+  [SerovalConstant.NegZero]: '-0',
+  [SerovalConstant.Inf]: '1/0',
+  [SerovalConstant.NegInf]: '-1/0',
+  [SerovalConstant.Nan]: '0/0',
+};
+
+export const NIL = void 0;
+
+export const CONSTANT_VAL: Record<SerovalConstant, unknown> = {
+  [SerovalConstant.True]: true,
+  [SerovalConstant.False]: false,
+  [SerovalConstant.Undefined]: NIL,
+  [SerovalConstant.Null]: null,
+  [SerovalConstant.NegZero]: -0,
+  [SerovalConstant.Inf]: Number.POSITIVE_INFINITY,
+  [SerovalConstant.NegInf]: Number.NEGATIVE_INFINITY,
+  [SerovalConstant.Nan]: Number.NaN,
+};
+
+export const enum ErrorConstructorTag {
+  Error = 0,
+  EvalError = 1,
+  RangeError = 2,
+  ReferenceError = 3,
+  SyntaxError = 4,
+  TypeError = 5,
+  URIError = 6,
+}
+
+export const ERROR_CONSTRUCTOR_STRING: Record<ErrorConstructorTag, string> = {
+  [ErrorConstructorTag.Error]: 'Error',
+  [ErrorConstructorTag.EvalError]: 'EvalError',
+  [ErrorConstructorTag.RangeError]: 'RangeError',
+  [ErrorConstructorTag.ReferenceError]: 'ReferenceError',
+  [ErrorConstructorTag.SyntaxError]: 'SyntaxError',
+  [ErrorConstructorTag.TypeError]: 'TypeError',
+  [ErrorConstructorTag.URIError]: 'URIError',
+};
+
+type ErrorConstructors =
+  | ErrorConstructor
+  | EvalErrorConstructor
+  | RangeErrorConstructor
+  | ReferenceErrorConstructor
+  | SyntaxErrorConstructor
+  | TypeErrorConstructor
+  | URIErrorConstructor;
+
+export const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors> =
+  {
+    [ErrorConstructorTag.Error]: Error,
+    [ErrorConstructorTag.EvalError]: EvalError,
+    [ErrorConstructorTag.RangeError]: RangeError,
+    [ErrorConstructorTag.ReferenceError]: ReferenceError,
+    [ErrorConstructorTag.SyntaxError]: SyntaxError,
+    [ErrorConstructorTag.TypeError]: TypeError,
+    [ErrorConstructorTag.URIError]: URIError,
+  };

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

@@ -0,0 +1,265 @@
+import type { Sequence } from './sequence';
+import type { Stream } from './stream';
+
+type SpecialPromise = Promise<unknown> & { s?: 1 | 2; v?: unknown };
+
+export interface PromiseConstructorResolver {
+  p: SpecialPromise;
+  s: (value: unknown) => void;
+  f: (value: unknown) => void;
+}
+
+export const PROMISE_CONSTRUCTOR = (): PromiseConstructorResolver => {
+  const resolver = {
+    p: 0,
+    s: 0,
+    f: 0,
+  } as unknown as PromiseConstructorResolver;
+  resolver.p = new Promise((resolve, reject) => {
+    resolver.s = resolve;
+    resolver.f = reject;
+  });
+  return resolver;
+};
+
+export const PROMISE_SUCCESS = (
+  resolver: PromiseConstructorResolver,
+  data: unknown,
+): void => {
+  resolver.s(data);
+  resolver.p.s = 1;
+  resolver.p.v = data;
+};
+
+export const PROMISE_FAILURE = (
+  resolver: PromiseConstructorResolver,
+  data: unknown,
+): void => {
+  resolver.f(data);
+  resolver.p.s = 2;
+  resolver.p.v = data;
+};
+
+export const SERIALIZED_PROMISE_CONSTRUCTOR =
+  /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();
+export const SERIALIZED_PROMISE_SUCCESS =
+  /* @__PURE__ */ PROMISE_SUCCESS.toString();
+export const SERIALIZED_PROMISE_FAILURE =
+  /* @__PURE__ */ PROMISE_FAILURE.toString();
+
+interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export const STREAM_CONSTRUCTOR = () => {
+  const buffer: unknown[] = [];
+  const listeners: StreamListener<unknown>[] = [];
+  let alive = true;
+  let success = false;
+  let count = 0;
+  const flush = (
+    value: unknown,
+    mode: keyof StreamListener<unknown>,
+    x?: number,
+  ) => {
+    for (x = 0; x < count; x++) {
+      if (listeners[x]) {
+        listeners[x][mode](value);
+      }
+    }
+  };
+  const up = (
+    listener: StreamListener<unknown>,
+    x?: number,
+    z?: number,
+    current?: unknown,
+  ) => {
+    for (x = 0, z = buffer.length; x < z; x++) {
+      current = buffer[x];
+      if (!alive && x === z - 1) {
+        listener[success ? 'return' : 'throw'](current);
+      } else {
+        listener.next(current);
+      }
+    }
+  };
+  const on = (listener: StreamListener<unknown>, temp?: number) => {
+    if (alive) {
+      temp = count++;
+      listeners[temp] = listener;
+    }
+    up(listener);
+    return () => {
+      if (alive) {
+        listeners[temp!] = listeners[count];
+        listeners[count--] = undefined as any;
+      }
+    };
+  };
+  return {
+    __SEROVAL_STREAM__: true,
+    on: (listener: StreamListener<unknown>) => on(listener),
+    next: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'next');
+      }
+    },
+    throw: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'throw');
+        alive = false;
+        success = false;
+        listeners.length = 0;
+      }
+    },
+    return: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'return');
+        alive = false;
+        success = true;
+        listeners.length = 0;
+      }
+    },
+  };
+};
+
+export const SERIALIZED_STREAM_CONSTRUCTOR =
+  /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();
+
+export const ITERATOR_CONSTRUCTOR =
+  (symbol: symbol) => (sequence: Sequence) => () => {
+    let index = 0;
+    const instance = {
+      [symbol]: () => instance,
+      next: () => {
+        if (index > sequence.d) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+        const currentIndex = index++;
+        const data = sequence.v[currentIndex];
+        if (currentIndex === sequence.t) {
+          throw data;
+        }
+        return {
+          done: currentIndex === sequence.d,
+          value: data,
+        };
+      },
+    };
+    return instance;
+  };
+
+export const SERIALIZED_ITERATOR_CONSTRUCTOR =
+  /* @__PURE__ */ ITERATOR_CONSTRUCTOR.toString();
+
+export const ASYNC_ITERATOR_CONSTRUCTOR =
+  (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) =>
+  (stream: Stream<unknown>) =>
+  () => {
+    let count = 0;
+    let doneAt = -1;
+    let isThrow = false;
+    const buffer: unknown[] = [];
+    const pending: PromiseConstructorResolver[] = [];
+    const finalize = (i = 0, len = pending.length) => {
+      for (; i < len; i++) {
+        pending[i].s({
+          done: true,
+          value: undefined,
+        });
+      }
+    };
+    stream.on({
+      next: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.s({ done: false, value });
+        }
+        buffer.push(value);
+      },
+      throw: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.f(value);
+        }
+        finalize();
+        doneAt = buffer.length;
+        isThrow = true;
+        buffer.push(value);
+      },
+      return: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.s({ done: true, value });
+        }
+        finalize();
+        doneAt = buffer.length;
+        buffer.push(value);
+      },
+    });
+
+    const instance = {
+      [symbol]: () => instance,
+      next: () => {
+        if (doneAt === -1) {
+          const index = count++;
+          if (index >= buffer.length) {
+            const temp = createPromise();
+            pending.push(temp);
+            return temp.p;
+          }
+          return {
+            done: false,
+            value: buffer[index],
+          };
+        }
+        if (count > doneAt) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+        const index = count++;
+        const value = buffer[index];
+        if (index !== doneAt) {
+          return {
+            done: false,
+            value,
+          };
+        }
+        if (isThrow) {
+          throw value;
+        }
+        return {
+          done: true,
+          value,
+        };
+      },
+    };
+
+    return instance;
+  };
+
+export const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR =
+  /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();
+
+export const ARRAY_BUFFER_CONSTRUCTOR = (b64: string) => {
+  const decoded = atob(b64);
+  const length = decoded.length;
+  const arr = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = decoded.charCodeAt(i);
+  }
+  return arr.buffer;
+};
+
+export const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR =
+  /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();