Website Structure

Frontend-Learner/node_modules/@poppinss/dumper/build/src/helpers.d.ts

@@ -0,0 +1,47 @@
+import type { Parser } from './parser.js';
+/**
+ * Helper to tokenize an object and its prototype
+ */
+export declare function tokenizeObject(value: Record<string | symbol, any>, parser: Parser, config: {
+    depth: number;
+    showHidden: boolean;
+    collapse: string[];
+    inspectObjectPrototype: boolean | 'unless-plain-object';
+    constructorName?: string;
+    membersToIgnore?: (string | symbol)[];
+    eagerGetters?: (string | symbol)[];
+}): void;
+/**
+ * Tokenizes the prototype of a value by calling Object.getPrototypeOf
+ * method on the value.
+ */
+export declare function tokenizePrototype(value: any, parser: Parser, config: {
+    prototypeToIgnore?: any;
+    membersToIgnore?: (string | symbol)[];
+    eagerGetters?: (string | symbol)[];
+}): void;
+/**
+ * Helper to tokenize array like values.
+ */
+export declare function tokenizeArray(values: Array<any> | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array, parser: Parser, config: {
+    name?: string;
+    depth: number;
+    collapse: string[];
+    inspectArrayPrototype: boolean;
+    maxArrayLength: number;
+}): void;
+/**
+ * HTML escape string values so that they can be nested
+ * inside the pre-tags.
+ */
+export declare function htmlEscape(value: string): string;
+/**
+ * Wraps a string value to be on multiple lines after
+ * a certain characters limit has been hit.
+ */
+export declare function wordWrap(value: string, options: {
+    width: number;
+    indent: string;
+    newLine: string;
+    escape?: (value: string) => string;
+}): string;

Frontend-Learner/node_modules/@poppinss/dumper/build/src/parser.d.ts

@@ -0,0 +1,53 @@
+import type { ParserConfig, Token } from './types.js';
+/**
+ * Parser is used to parse a JavaScript value into a set
+ * of tokens that can be used to pretty-print the same
+ * value.
+ *
+ * @example
+ * ```ts
+ * import { Parser } from '@poppinss/dumper'
+ *
+ * const parser = new Parser()
+ * const value = {
+ *   id: 1,
+ *   username: 'foo',
+ * }
+ *
+ * parser.parse(value)
+ * parser.flush() // Token[]
+ * ```
+ */
+export declare class Parser {
+    #private;
+    /**
+     * Config shared with tokenizers
+     */
+    config: Readonly<Required<ParserConfig>>;
+    /**
+     * Context maintained through out the parsing phase.
+     * Each instance of Parser has its own context
+     * that gets mutated internally.
+     */
+    context: Record<string, any>;
+    constructor(config?: ParserConfig, context?: Record<string, any>);
+    /**
+     * Collect a token inside the list of tokens. The order
+     * of tokens matter during printing therefore you must
+     * collect tokens in the right order.
+     */
+    collect(token: Token): void;
+    /**
+     * Parses a value using the tokenizers. Under the hood the
+     * tokenizers will call "parser.collect" to collect
+     * tokens inside an array.
+     *
+     * You can use "parser.flush" method to get the list of
+     * tokens.
+     */
+    parse(value: unknown): void;
+    /**
+     * Returns collected tokens and resets the internal state.
+     */
+    flush(): Token[];
+}

Frontend-Learner/node_modules/@poppinss/dumper/build/src/tokenizers/main.d.ts

@@ -0,0 +1,7 @@
+import { type TypeName } from '@sindresorhus/is';
+import type { Tokenizer } from '../types.js';
+/**
+ * Tokenizers are responsible for converting JS data types
+ * to known dumper tokens.
+ */
+export declare const tokenizers: Partial<Record<TypeName, Tokenizer>>;

Frontend-Learner/node_modules/@poppinss/dumper/build/src/types.d.ts

@@ -0,0 +1,270 @@
+import type { TypeName } from '@sindresorhus/is';
+import type { Parser } from './parser.js';
+/**
+ * Simplifies the complex merged types
+ */
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+ * Representation of a tokenizer function. Tokenizers are
+ * responsible for converting values to a list of tokens
+ * and collect them using the "parser.collect" method.
+ */
+export type Tokenizer = (value: any, parser: Parser) => void;
+/**
+ * Tokens Map represents the list of supported tokens. Tokens
+ * without any properties acts as a boundary for enclosed
+ * values.
+ */
+export type TokensMap = {
+    /**
+     * Object tokens
+     */
+    'object-start': {
+        constructorName: null | string;
+    };
+    'object-end': {};
+    'object-key': {
+        isWritable: boolean;
+        isSymbol: boolean;
+        value: string;
+    };
+    'object-value-start': {};
+    'object-value-end': {};
+    'object-value-getter': {};
+    'object-circular-ref': {};
+    'object-max-depth-ref': {};
+    /**
+     * Array tokens
+     */
+    'array-start': {
+        name: string;
+        size: number;
+    };
+    'array-end': {
+        size: number;
+    };
+    'array-value-start': {
+        index: number;
+    };
+    'array-value-hole': {
+        index: number;
+    };
+    'array-value-end': {
+        index: number;
+    };
+    'array-circular-ref': {};
+    'array-max-depth-ref': {};
+    'array-max-length-ref': {
+        limit: number;
+        size: number;
+    };
+    /**
+     * Boundary for the prototype properties
+     */
+    'prototype-start': {};
+    'prototype-end': {};
+    /**
+     * Set tokens
+     */
+    'set-start': {
+        size: number;
+    };
+    'set-end': {
+        size: number;
+    };
+    'set-value-start': {
+        index: number;
+    };
+    'set-value-end': {
+        index: number;
+    };
+    'set-circular-ref': {};
+    'set-max-depth-ref': {};
+    'set-max-length-ref': {
+        limit: number;
+        size: number;
+    };
+    /**
+     * Map tokens
+     */
+    'map-start': {
+        size: number;
+    };
+    'map-end': {
+        size: number;
+    };
+    'map-row-start': {
+        index: number;
+    };
+    'map-row-end': {
+        index: number;
+    };
+    'map-key-start': {
+        index: number;
+    };
+    'map-key-end': {
+        index: number;
+    };
+    'map-value-start': {
+        index: number;
+    };
+    'map-value-end': {
+        index: number;
+    };
+    'map-max-depth-ref': {};
+    'map-circular-ref': {};
+    'map-max-length-ref': {
+        limit: number;
+        size: number;
+    };
+    /**
+     * Primitives
+     */
+    'string': {
+        value: string;
+    };
+    'number': {
+        value: number;
+    };
+    'bigInt': {
+        value: string;
+    };
+    'boolean': {
+        value: boolean;
+    };
+    'undefined': {};
+    'null': {};
+    'symbol': {
+        value: string;
+    };
+    /**
+     * Others
+     */
+    'function': {
+        name: string;
+        isGenerator: boolean;
+        isAsync: boolean;
+        isClass: boolean;
+    };
+    /**
+     * Boundary for the static members
+     */
+    'static-members-start': {};
+    'static-members-end': {};
+    'date': {
+        value: string;
+    };
+    'buffer': {
+        value: string;
+    };
+    'regexp': {
+        value: string;
+    };
+    'unknown': {
+        jsType: TypeName;
+        value: any;
+    };
+    'weak-set': {};
+    'weak-ref': {};
+    'weak-map': {};
+    'observable': {};
+    'blob': {
+        size: number;
+        contentType: string;
+    };
+    'promise': {
+        isFulfilled: boolean;
+    };
+    'generator': {
+        isAsync: boolean;
+    };
+    /**
+     * Collapse token represents a value that has been
+     * collpased and its children are not further
+     * processed.
+     *
+     * Only objects and arrays can be collapsed
+     */
+    'collapse': {
+        name: string;
+        token: ({
+            type: 'object-start';
+        } & TokensMap['object-start']) | ({
+            type: 'array-start';
+        } & TokensMap['array-start']);
+    };
+};
+/**
+ * A union of known tokens. The tokenizer will always
+ * output only these tokens
+ */
+export type Token = {
+    [K in keyof TokensMap]: Simplify<{
+        type: K;
+    } & TokensMap[K]>;
+}[keyof TokensMap];
+/**
+ * Configuration accepted by the parser
+ */
+export type ParserConfig = {
+    /**
+     * When set to true, the non-enumerable properties of an
+     * object will be processed.
+     *
+     * Defaults to false
+     */
+    showHidden?: boolean;
+    /**
+     * The depth at which to stop parsing nested values. The depth
+     * is shared among all tree like data structures.
+     *
+     * Defaults to 5
+     */
+    depth?: number;
+    /**
+     * Inspect prototype properties of an object. The non-enumerable properties
+     * of prototype are included by default.
+     *
+     * Defaults to "unless-plain-object"
+     *
+     * - The "unless-plain-object" will inspect the prototype of objects
+     *   created with a prototype other than the "Object"
+     * - True will inspect the prototype for all objects that has a prototype
+     * - False will not inpsect the prototype
+     */
+    inspectObjectPrototype?: boolean | 'unless-plain-object';
+    /**
+     * Inspect prototype properties of an array. The non-enumerable properties
+     * of prototype are included by default.
+     *
+     * Defaults to false
+     */
+    inspectArrayPrototype?: boolean;
+    /**
+     * Inspect static members of a class. Even though functions and classes are
+     * technically same, this config only applies to functions defined using
+     * the [class] keyword.
+     *
+     * Defaults to false
+     */
+    inspectStaticMembers?: boolean;
+    /**
+     * Maximum number of members to process for Arrays, Maps and Sets.
+     *
+     * Defaults to 100
+     */
+    maxArrayLength?: number;
+    /**
+     * Maximum number of characters to display for a string.
+     *
+     * Defaults to 1000
+     */
+    maxStringLength?: number;
+    /**
+     * An array of values that must be collapsed. The objects and
+     * arrays constructor names are checked against these values.
+     */
+    collapse?: string[];
+};