@aiwayds/dsh-opentui 0.1.0 → 0.3.0

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

@@ -0,0 +1,377 @@
+import type {
+  ErrorConstructorTag,
+  SerovalConstant,
+  SerovalNodeType,
+  SerovalObjectFlags,
+  Symbols,
+} from './constants';
+import type { SpecialReference } from './special-reference';
+
+export interface SerovalBaseNode {
+  // Type of the node
+  t: SerovalNodeType;
+  // Reference ID
+  i: number | undefined;
+  // Serialized value
+  s: unknown;
+  // Constructor name / RegExp source
+  c: string | undefined;
+  // message/flags
+  m: string | undefined;
+  // properties (objects)
+  p: SerovalObjectRecordNode | undefined;
+  // entries (for Map, etc.)
+  e: SerovalMapRecordNode | undefined;
+  // array of nodes
+  a: (SerovalNode | 0)[] | undefined;
+  // fulfilled node
+  f: SerovalNode | undefined;
+  // byte offset/object flags
+  b: number | undefined;
+  // object flag
+  o: SerovalObjectFlags | undefined;
+  // length
+  l: number | undefined;
+}
+
+export type SerovalObjectRecordKey = string | SerovalNode;
+
+export interface SerovalObjectRecordNode {
+  k: SerovalObjectRecordKey[];
+  v: SerovalNode[];
+}
+
+export interface SerovalMapRecordNode {
+  k: SerovalNode[];
+  v: SerovalNode[];
+}
+
+export interface SerovalNumberNode extends SerovalBaseNode {
+  t: SerovalNodeType.Number;
+  s: number;
+}
+
+export interface SerovalStringNode extends SerovalBaseNode {
+  t: SerovalNodeType.String;
+  s: string;
+}
+
+export interface SerovalConstantNode extends SerovalBaseNode {
+  t: SerovalNodeType.Constant;
+  s: SerovalConstant;
+}
+
+export type SerovalPrimitiveNode =
+  | SerovalNumberNode
+  | SerovalStringNode
+  | SerovalConstantNode;
+
+export interface SerovalIndexedValueNode extends SerovalBaseNode {
+  t: SerovalNodeType.IndexedValue;
+  // id
+  i: number;
+}
+
+export interface SerovalBigIntNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigInt;
+  // value in string
+  s: string;
+}
+
+export interface SerovalDateNode extends SerovalBaseNode {
+  t: SerovalNodeType.Date;
+  // id (Dates are stateful)
+  i: number;
+  // value in ISO string
+  s: string;
+}
+
+export interface SerovalRegExpNode extends SerovalBaseNode {
+  t: SerovalNodeType.RegExp;
+  // id (RegExp are stateful)
+  i: number;
+  // source
+  c: string;
+  // flags
+  m: string;
+}
+
+export interface SerovalArrayBufferNode extends SerovalBaseNode {
+  t: SerovalNodeType.ArrayBuffer;
+  // id
+  i: number;
+  // byte string
+  s: string;
+  // array buffer constructor
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.TypedArray;
+  // id
+  i: number;
+  // TypedArray Constructor
+  c: string;
+  // ArrayBuffer reference
+  f: SerovalNode;
+  // Byte Offset
+  b: number;
+  // length
+  l: number;
+}
+
+export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigIntTypedArray;
+  i: number;
+  // TypedArray Constructor
+  c: string;
+  // ArrayBuffer reference
+  f: SerovalNode;
+  // Byte Offset
+  b: number;
+  // length
+  l: number;
+}
+
+export type SerovalSemiPrimitiveNode =
+  | SerovalBigIntNode
+  | SerovalDateNode
+  | SerovalRegExpNode
+  | SerovalTypedArrayNode
+  | SerovalBigIntTypedArrayNode;
+
+export interface SerovalSetNode extends SerovalBaseNode {
+  t: SerovalNodeType.Set;
+  // id
+  i: number;
+  // Items in Set (as array)
+  a: SerovalNode[];
+}
+
+export interface SerovalMapNode extends SerovalBaseNode {
+  t: SerovalNodeType.Map;
+  i: number;
+  // key/value pairs
+  e: SerovalMapRecordNode;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.Array;
+  // items
+  a: (SerovalNode | 0)[];
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalObjectNode extends SerovalBaseNode {
+  t: SerovalNodeType.Object;
+  // key/value pairs
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalNullConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.NullConstructor;
+  // key/value pairs
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalPromiseNode extends SerovalBaseNode {
+  t: SerovalNodeType.Promise;
+  s: 0 | 1;
+  // resolved value
+  f: SerovalNode;
+  i: number;
+}
+
+export interface SerovalErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.Error;
+  // constructor name
+  s: ErrorConstructorTag;
+  // message
+  m: string;
+  // other properties
+  p: SerovalObjectRecordNode | undefined;
+  i: number;
+}
+
+export interface SerovalAggregateErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AggregateError;
+  i: number;
+  // message
+  m: string;
+  // other properties
+  p: SerovalObjectRecordNode | undefined;
+}
+
+export interface SerovalWKSymbolNode extends SerovalBaseNode {
+  t: SerovalNodeType.WKSymbol;
+  i: number;
+  s: Symbols;
+}
+
+export interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
+  i: number;
+  // id of the reference in the map
+  s: string;
+}
+
+export interface SerovalDataViewNode extends SerovalBaseNode {
+  t: SerovalNodeType.DataView;
+  i: number;
+  // reference to array buffer
+  f: SerovalNode;
+  // byte offset
+  b: number;
+  // byte length
+  l: number;
+}
+
+export interface SerovalBoxedNode extends SerovalBaseNode {
+  t: SerovalNodeType.Boxed;
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseConstructor;
+  i: number;
+  s: number;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalPromiseResolveNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseSuccess;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+
+export interface SerovalPromiseRejectNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseFailure;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+
+export interface SerovalPluginNode extends SerovalBaseNode {
+  t: SerovalNodeType.Plugin;
+  i: number;
+  // value
+  s: Record<string, SerovalNode>;
+  // tag name
+  c: string;
+}
+
+/**
+ * Represents special values as placeholders
+ */
+export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.SpecialReference;
+  i: number;
+  s: SpecialReference;
+}
+
+export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactory;
+  i: number;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
+}
+
+export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactory;
+  i: number;
+  a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
+}
+
+export interface SerovalAsyncIteratorFactoryInstanceNode
+  extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
+}
+
+export interface SerovalStreamConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamConstructor;
+  i: number;
+  a: SerovalNode[];
+  // special reference to the constructor
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalStreamNextNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamNext;
+  i: number;
+  // Next value
+  f: SerovalNode;
+}
+
+export interface SerovalStreamThrowNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamThrow;
+  i: number;
+  // Throw value
+  f: SerovalNode;
+}
+
+export interface SerovalStreamReturnNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamReturn;
+  i: number;
+  // Return value
+  f: SerovalNode;
+}
+
+export interface SerovalSequenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Sequence;
+  i: number;
+  // Throw at
+  s: number;
+  a: SerovalNode[];
+  // Done at
+  l: number;
+}
+
+export type SerovalSyncNode =
+  | SerovalPrimitiveNode
+  | SerovalIndexedValueNode
+  | SerovalSemiPrimitiveNode
+  | SerovalSetNode
+  | SerovalMapNode
+  | SerovalArrayNode
+  | SerovalObjectNode
+  | SerovalNullConstructorNode
+  | SerovalPromiseNode
+  | SerovalErrorNode
+  | SerovalAggregateErrorNode
+  | SerovalWKSymbolNode
+  | SerovalReferenceNode
+  | SerovalArrayBufferNode
+  | SerovalDataViewNode
+  | SerovalBoxedNode
+  | SerovalPluginNode
+  | SerovalSpecialReferenceNode
+  | SerovalIteratorFactoryNode
+  | SerovalIteratorFactoryInstanceNode
+  | SerovalAsyncIteratorFactoryNode
+  | SerovalAsyncIteratorFactoryInstanceNode
+  | SerovalSequenceNode;
+
+export type SerovalAsyncNode =
+  | SerovalPromiseNode
+  | SerovalPromiseConstructorNode
+  | SerovalPromiseResolveNode
+  | SerovalPromiseRejectNode
+  | SerovalStreamConstructorNode
+  | SerovalStreamNextNode
+  | SerovalStreamThrowNode
+  | SerovalStreamReturnNode;
+
+export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
+
+export type SerovalNodeWithID = Extract<SerovalNode, { i: number }>;

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

@@ -0,0 +1,73 @@
+import { Feature } from '../compat';
+import { ERROR_CONSTRUCTOR_STRING, ErrorConstructorTag } from '../constants';
+
+type ErrorValue =
+  | Error
+  | AggregateError
+  | EvalError
+  | RangeError
+  | ReferenceError
+  | TypeError
+  | SyntaxError
+  | URIError;
+
+export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
+  if (error instanceof EvalError) {
+    return ErrorConstructorTag.EvalError;
+  }
+  if (error instanceof RangeError) {
+    return ErrorConstructorTag.RangeError;
+  }
+  if (error instanceof ReferenceError) {
+    return ErrorConstructorTag.ReferenceError;
+  }
+  if (error instanceof SyntaxError) {
+    return ErrorConstructorTag.SyntaxError;
+  }
+  if (error instanceof TypeError) {
+    return ErrorConstructorTag.TypeError;
+  }
+  if (error instanceof URIError) {
+    return ErrorConstructorTag.URIError;
+  }
+  return ErrorConstructorTag.Error;
+}
+
+function getInitialErrorOptions(
+  error: Error,
+): Record<string, unknown> | undefined {
+  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
+  // Name has been modified
+  if (error.name !== construct) {
+    return { name: error.name };
+  }
+  if (error.constructor.name !== construct) {
+    // Otherwise, name is overriden because
+    // the Error class is extended
+    return { name: error.constructor.name };
+  }
+  return {};
+}
+
+export function getErrorOptions(
+  error: Error,
+  features: number,
+): Record<string, unknown> | undefined {
+  let options = getInitialErrorOptions(error);
+  const names = Object.getOwnPropertyNames(error);
+  for (let i = 0, len = names.length, name: string; i < len; i++) {
+    name = names[i];
+    if (name !== 'name' && name !== 'message') {
+      if (name === 'stack') {
+        if (features & Feature.ErrorPrototypeStack) {
+          options = options || {};
+          options[name] = error[name as keyof Error];
+        }
+      } else {
+        options = options || {};
+        options[name] = error[name as keyof Error];
+      }
+    }
+  }
+  return options;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/get-identifier.ts

@@ -0,0 +1,18 @@
+// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
+const REF_START_CHARS = /* @__PURE__ */ 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.
+const REF_START_CHARS_LEN = /* @__PURE__ */ REF_START_CHARS.length;
+const REF_CHARS =
+  /* @__PURE__ */ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';
+const REF_CHARS_LEN = /* @__PURE__ */ REF_CHARS.length;
+
+export default function getIdentifier(index: number): string {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (index > 0) {
+    mod = index % REF_CHARS_LEN;
+    ref += REF_CHARS[mod];
+    index = (index - mod) / REF_CHARS_LEN;
+  }
+  return ref;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/get-object-flag.ts

@@ -0,0 +1,14 @@
+import { SerovalObjectFlags } from '../constants';
+
+export function getObjectFlag(obj: unknown): SerovalObjectFlags {
+  if (Object.isFrozen(obj)) {
+    return SerovalObjectFlags.Frozen;
+  }
+  if (Object.isSealed(obj)) {
+    return SerovalObjectFlags.Sealed;
+  }
+  if (Object.isExtensible(obj)) {
+    return SerovalObjectFlags.None;
+  }
+  return SerovalObjectFlags.NonExtensible;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/is-valid-identifier.ts

@@ -0,0 +1,12 @@
+const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
+
+export function isValidIdentifier(name: string): boolean {
+  const char = name[0];
+  return (
+    (char === '$' ||
+      char === '_' ||
+      (char >= 'A' && char <= 'Z') ||
+      (char >= 'a' && char <= 'z')) &&
+    IDENTIFIER_CHECK.test(name)
+  );
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/promise-to-result.ts

@@ -0,0 +1,9 @@
+export default async function promiseToResult(
+  current: Promise<unknown>,
+): Promise<[0 | 1, unknown]> {
+  try {
+    return [1, await current];
+  } catch (e) {
+    return [0, e];
+  }
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/typed-array.ts

@@ -0,0 +1,56 @@
+import { SerovalUnknownTypedArrayError } from '../errors';
+
+type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Int16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint8ArrayConstructor
+  | Uint16ArrayConstructor
+  | Uint32ArrayConstructor
+  | Uint8ClampedArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor
+  | BigInt64ArrayConstructor
+  | BigUint64ArrayConstructor;
+
+export type TypedArrayValue =
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint8Array
+  | Uint16Array
+  | Uint32Array
+  | Uint8ClampedArray
+  | Float32Array
+  | Float64Array;
+
+export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
+
+export function getTypedArrayConstructor(name: string): TypedArrayConstructor {
+  switch (name) {
+    case 'Int8Array':
+      return Int8Array;
+    case 'Int16Array':
+      return Int16Array;
+    case 'Int32Array':
+      return Int32Array;
+    case 'Uint8Array':
+      return Uint8Array;
+    case 'Uint16Array':
+      return Uint16Array;
+    case 'Uint32Array':
+      return Uint32Array;
+    case 'Uint8ClampedArray':
+      return Uint8ClampedArray;
+    case 'Float32Array':
+      return Float32Array;
+    case 'Float64Array':
+      return Float64Array;
+    case 'BigInt64Array':
+      return BigInt64Array;
+    case 'BigUint64Array':
+      return BigUint64Array;
+    default:
+      throw new SerovalUnknownTypedArrayError(name);
+  }
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/utils/valid-properties.ts

@@ -0,0 +1,34 @@
+import {
+  SYM_ASYNC_ITERATOR,
+  SYM_IS_CONCAT_SPREADABLE,
+  SYM_ITERATOR,
+  SYM_TO_STRING_TAG,
+} from '../symbols';
+
+export function isValidKey(key: string): boolean {
+  switch (key) {
+    case 'constructor':
+    case '__proto__':
+    case 'prototype':
+    case '__defineGetter__':
+    case '__defineSetter__':
+    case '__lookupGetter__':
+    case '__lookupSetter__':
+      // case 'then':
+      return false;
+    default:
+      return true;
+  }
+}
+
+export function isValidSymbol(symbol: symbol): boolean {
+  switch (symbol) {
+    case SYM_ASYNC_ITERATOR:
+    case SYM_IS_CONCAT_SPREADABLE:
+    case SYM_TO_STRING_TAG:
+    case SYM_ITERATOR:
+      return true;
+    default:
+      return false;
+  }
+}

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

@@ -0,0 +1,36 @@
+export { Feature } from './core/compat';
+export type {
+  AsyncParsePluginContext,
+  AsyncParserContextOptions,
+} from './core/context/async-parser';
+export type {
+  BaseDeserializerContextOptions,
+  CrossDeserializerContextOptions,
+  DeserializePluginContext,
+  VanillaDeserializerContextOptions,
+} from './core/context/deserializer';
+export type { BaseParserContextOptions } from './core/context/parser';
+export type {
+  BaseSerializerContextOptions,
+  CrossContextOptions,
+  CrossSerializerContextOptions,
+  SerializePluginContext,
+  VanillaSerializerContextOptions,
+} from './core/context/serializer';
+export type {
+  StreamParsePluginContext,
+  StreamParserContextOptions,
+  SyncParsePluginContext,
+  SyncParserContextOptions,
+} from './core/context/sync-parser';
+export * from './core/cross';
+export * from './core/errors';
+export { getCrossReferenceHeader } from './core/keys';
+export { OpaqueReference } from './core/opaque-reference';
+export * from './core/plugin';
+export { createReference } from './core/reference';
+export { default as Serializer } from './core/Serializer';
+export { createStream } from './core/stream';
+export type { Stream, StreamListener } from './core/stream';
+export * from './core/tree';
+export type { SerovalNode } from './core/types';

package/dist-host/node_modules/.pnpm/{solid-js@1.9.17 → solid-js@1.9.12}/node_modules/solid-js/README.md

@@ -186,7 +186,7 @@ Come chat with us on [Discord](https://discord.com/invite/solidjs)! Solid's crea
 
 ### Contributors
 
-<a href="https://github.com/solidjs/solid/graphs/contributors"><img src="https://contrib.rocks/image?repo=solidjs/solid" style="max-width:100%;"></a>
+<a href="https://github.com/solidjs/solid/graphs/contributors"><img src="https://opencollective.com/solid/contributors.svg?width=890&amp;button=false" style="max-width:100%;"></a>
 
 ### Open Collective