@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/util/column-type.d.ts

@@ -0,0 +1,175 @@
+import type { DrainOuterGeneric } from './type-utils.js';
+/**
+ * This type can be used to specify a different type for
+ * select, insert and update operations.
+ *
+ * Also see the {@link Generated} type.
+ *
+ * ### Examples
+ *
+ * The next example defines a number column that is optional
+ * in inserts and updates. All columns are always optional
+ * in updates so therefore we don't need to specify `undefined`
+ * for the update type. The type below is useful for all kinds of
+ * database generated columns like identifiers. The `Generated`
+ * type is actually just a shortcut for the type in this example:
+ *
+ * ```ts
+ * type GeneratedNumber = ColumnType<number, number | undefined, number>
+ * ```
+ *
+ * The above example makes the column optional in inserts
+ * and updates, but you can still choose to provide the
+ * column. If you want to prevent insertion/update you
+ * can se the type as `never`:
+ *
+ * ```ts
+ * type ReadonlyNumber = ColumnType<number, never, never>
+ * ```
+ *
+ * Here's one more example where the type is different
+ * for each different operation:
+ *
+ * ```ts
+ * type UnupdateableDate = ColumnType<Date, string, never>
+ * ```
+ */
+export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
+    readonly __select__: SelectType;
+    readonly __insert__: InsertType;
+    readonly __update__: UpdateType;
+};
+/**
+ * A shortcut for defining database-generated columns. The type
+ * is the same for all selects, inserts and updates but the
+ * column is optional for inserts and updates.
+ *
+ * The update type is `S` instead of `S | undefined` because updates are always
+ * optional --> no need to specify optionality.
+ * ```
+ */
+export type Generated<S> = ColumnType<S, S | undefined, S>;
+/**
+ * A shortcut for defining columns that are only database-generated
+ * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
+ * is allowed.
+ */
+export type GeneratedAlways<S> = ColumnType<S, never, never>;
+/**
+ * A shortcut for defining JSON columns, which are by default inserted/updated
+ * as stringified JSON strings.
+ */
+export type JSONColumnType<SelectType extends object | null, InsertType = string, UpdateType = string> = ColumnType<SelectType, InsertType, UpdateType>;
+/**
+ * Evaluates to `K` if `T` can be `null` or `undefined`.
+ */
+type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+/**
+ * Evaluates to `K` if `T` can't be `null` or `undefined`.
+ */
+type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
+/**
+ * Evaluates to `K` if `T` isn't `never`.
+ */
+type IfNotNever<T, K> = T extends never ? never : K;
+export type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
+export type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
+export type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
+/**
+ * Keys of `R` whose `InsertType` values can be `null` or `undefined`.
+ */
+export type NullableInsertKeys<R> = {
+    [K in keyof R]: IfNullable<InsertType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `InsertType` values can't be `null` or `undefined`.
+ */
+export type NonNullableInsertKeys<R> = {
+    [K in keyof R]: IfNotNullable<InsertType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `SelectType` values are not `never`
+ */
+type NonNeverSelectKeys<R> = {
+    [K in keyof R]: IfNotNever<SelectType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `UpdateType` values are not `never`
+ */
+export type UpdateKeys<R> = {
+    [K in keyof R]: IfNotNever<UpdateType<R[K]>, K>;
+}[keyof R];
+/**
+ * Given a table interface, extracts the select type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type Person = Selectable<PersonTable>
+ * // {
+ * //   id: number,
+ * //   first_name: string
+ * //   modified_at: Date
+ * // }
+ * ```
+ */
+export type Selectable<R> = DrainOuterGeneric<{
+    [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
+}>;
+/**
+ * Given a table interface, extracts the insert type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type InsertablePerson = Insertable<PersonTable>
+ * // {
+ * //   id?: number,
+ * //   first_name: string
+ * //   modified_at: string
+ * // }
+ * ```
+ */
+export type Insertable<R> = DrainOuterGeneric<{
+    [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
+} & {
+    [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
+}>;
+/**
+ * Given a table interface, extracts the update type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type UpdateablePerson = Updateable<PersonTable>
+ * // {
+ * //   id?: number,
+ * //   first_name?: string
+ * // }
+ * ```
+ */
+export type Updateable<R> = DrainOuterGeneric<{
+    [K in UpdateKeys<R>]?: UpdateType<R[K]>;
+}>;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/util/column-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/node_modules/kysely/dist/cjs/util/compilable.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+export interface Compilable<O = unknown> {
+    compile(): CompiledQuery<O>;
+}
+export declare function isCompilable(value: unknown): value is Compilable;

package/dist/server/node_modules/kysely/dist/cjs/util/compilable.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompilable = isCompilable;
+const object_utils_js_1 = require("./object-utils.js");
+function isCompilable(value) {
+    return (0, object_utils_js_1.isObject)(value) && (0, object_utils_js_1.isFunction)(value.compile);
+}

package/dist/server/node_modules/kysely/dist/cjs/util/deferred.d.ts

@@ -0,0 +1,7 @@
+export declare class Deferred<T> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/dist/server/node_modules/kysely/dist/cjs/util/deferred.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = void 0;
+class Deferred {
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#promise = new Promise((resolve, reject) => {
+            this.#reject = reject;
+            this.#resolve = resolve;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve = (value) => {
+        if (this.#resolve) {
+            this.#resolve(value);
+        }
+    };
+    reject = (reason) => {
+        if (this.#reject) {
+            this.#reject(reason);
+        }
+    };
+}
+exports.Deferred = Deferred;

package/dist/server/node_modules/kysely/dist/cjs/util/explainable.d.ts

@@ -0,0 +1,40 @@
+import type { Expression } from '../expression/expression.js';
+export type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export interface Explainable {
+    /**
+     * Executes query with `explain` statement before the main query.
+     *
+     * ```ts
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json select * from `person` where `gender` = ?
+     * ```
+     *
+     * You can also execute `explain analyze` statements.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json', sql`analyze`)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * explain (analyze, format json) select * from "person" where "gender" = $1
+     * ```
+     */
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<O[]>;
+}

package/dist/server/node_modules/kysely/dist/cjs/util/explainable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/node_modules/kysely/dist/cjs/util/infer-result.d.ts

@@ -0,0 +1,48 @@
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { Compilable } from './compilable.js';
+import type { Simplify } from './type-utils.js';
+/**
+ * A helper type that allows inferring a select/insert/update/delete query's result
+ * type from a query builder or compiled query.
+ *
+ * ### Examples
+ *
+ * Infer a query builder's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const query = db
+ *   .selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select(['person.first_name', 'pet.name'])
+ *
+ * type QueryResult = InferResult<typeof query> // { first_name: string; name: string; }[]
+ * ```
+ *
+ * Infer a compiled query's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const compiledQuery = db
+ *   .insertInto('person')
+ *   .values({
+ *     first_name: 'Foo',
+ *     last_name: 'Barson',
+ *     gender: 'other',
+ *     age: 15,
+ *   })
+ *   .returningAll()
+ *   .compile()
+ *
+ * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
+ * ```
+ */
+export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O[] : Simplify<O>[];
+export {};

package/dist/server/node_modules/kysely/dist/cjs/util/infer-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/node_modules/kysely/dist/cjs/util/json-object-args.d.ts

@@ -0,0 +1,3 @@
+import type { Expression } from '../expression/expression.js';
+import type { SelectQueryNode } from '../operation-node/select-query-node.js';
+export declare function getJsonObjectArgs(node: SelectQueryNode, table: string): Expression<unknown>[];

package/dist/server/node_modules/kysely/dist/cjs/util/json-object-args.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonObjectArgs = getJsonObjectArgs;
+const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const reference_node_js_1 = require("../operation-node/reference-node.js");
+const table_node_js_1 = require("../operation-node/table-node.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (column_node_js_1.ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
+            args.push(colName(s.alias.name), colRef(table, s.alias.name));
+        }
+        else {
+            throw new Error(`can't extract column names from the select query node`);
+        }
+    }
+    return args;
+}
+function colName(col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(col), table_node_js_1.TableNode.create(table)));
+}

package/dist/server/node_modules/kysely/dist/cjs/util/log-once.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+export declare function logOnce(message: string): void;

package/dist/server/node_modules/kysely/dist/cjs/util/log-once.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logOnce = logOnce;
+const LOGGED_MESSAGES = new Set();
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+function logOnce(message) {
+    if (LOGGED_MESSAGES.has(message)) {
+        return;
+    }
+    LOGGED_MESSAGES.add(message);
+    console.log(message);
+}

package/dist/server/node_modules/kysely/dist/cjs/util/log.d.ts

@@ -0,0 +1,28 @@
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { ArrayItemType } from './type-utils.js';
+declare const logLevels: readonly ["query", "error"];
+export declare const LOG_LEVELS: Readonly<typeof logLevels>;
+export type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
+export interface QueryLogEvent {
+    readonly level: 'query';
+    readonly isStream?: boolean;
+    readonly query: CompiledQuery;
+    readonly queryDurationMillis: number;
+}
+export interface ErrorLogEvent {
+    readonly level: 'error';
+    readonly error: unknown;
+    readonly query: CompiledQuery;
+    readonly queryDurationMillis: number;
+}
+export type LogEvent = QueryLogEvent | ErrorLogEvent;
+export type Logger = (event: LogEvent) => void | Promise<void>;
+export type LogConfig = ReadonlyArray<LogLevel> | Logger;
+export declare class Log {
+    #private;
+    constructor(config: LogConfig);
+    isLevelEnabled(level: LogLevel): boolean;
+    query(getEvent: () => QueryLogEvent): Promise<void>;
+    error(getEvent: () => ErrorLogEvent): Promise<void>;
+}
+export {};

package/dist/server/node_modules/kysely/dist/cjs/util/log.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.LOG_LEVELS = void 0;
+const object_utils_js_1 = require("./object-utils.js");
+const logLevels = ['query', 'error'];
+exports.LOG_LEVELS = (0, object_utils_js_1.freeze)(logLevels);
+class Log {
+    #levels;
+    #logger;
+    constructor(config) {
+        if ((0, object_utils_js_1.isFunction)(config)) {
+            this.#logger = config;
+            this.#levels = (0, object_utils_js_1.freeze)({
+                query: true,
+                error: true,
+            });
+        }
+        else {
+            this.#logger = defaultLogger;
+            this.#levels = (0, object_utils_js_1.freeze)({
+                query: config.includes('query'),
+                error: config.includes('error'),
+            });
+        }
+    }
+    isLevelEnabled(level) {
+        return this.#levels[level];
+    }
+    async query(getEvent) {
+        if (this.#levels.query) {
+            await this.#logger(getEvent());
+        }
+    }
+    async error(getEvent) {
+        if (this.#levels.error) {
+            await this.#logger(getEvent());
+        }
+    }
+}
+exports.Log = Log;
+function defaultLogger(event) {
+    if (event.level === 'query') {
+        const prefix = `kysely:query:${event.isStream ? 'stream:' : ''}`;
+        console.log(`${prefix} ${event.query.sql}`);
+        console.log(`${prefix} duration: ${event.queryDurationMillis.toFixed(1)}ms`);
+    }
+    else if (event.level === 'error') {
+        if (event.error instanceof Error) {
+            console.error(`kysely:error: ${event.error.stack ?? event.error.message}`);
+        }
+        else {
+            console.error(`kysely:error: ${JSON.stringify({
+                error: event.error,
+                query: event.query.sql,
+                queryDurationMillis: event.queryDurationMillis,
+            })}`);
+        }
+    }
+}

package/dist/server/node_modules/kysely/dist/cjs/util/object-utils.d.ts

@@ -0,0 +1,23 @@
+import type { ShallowRecord } from './type-utils.js';
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
+export declare function isUndefined(obj: unknown): obj is undefined;
+export declare function isString(obj: unknown): obj is string;
+export declare function isNumber(obj: unknown): obj is number;
+export declare function isBoolean(obj: unknown): obj is boolean;
+export declare function isNull(obj: unknown): obj is null;
+export declare function isDate(obj: unknown): obj is Date;
+export declare function isBigInt(obj: unknown): obj is bigint;
+export declare function isBuffer(obj: unknown): obj is {
+    length: number;
+};
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
+export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
+export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
+export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
+export declare function freeze<T>(obj: T): Readonly<T>;
+export declare function asArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
+export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
+export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
+export declare function noop<T>(obj: T): T;
+export declare function compare(obj1: unknown, obj2: unknown): boolean;

package/dist/server/node_modules/kysely/dist/cjs/util/object-utils.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = isEmpty;
+exports.isUndefined = isUndefined;
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isBoolean = isBoolean;
+exports.isNull = isNull;
+exports.isDate = isDate;
+exports.isBigInt = isBigInt;
+exports.isBuffer = isBuffer;
+exports.isFunction = isFunction;
+exports.isObject = isObject;
+exports.isArrayBufferOrView = isArrayBufferOrView;
+exports.isPlainObject = isPlainObject;
+exports.getLast = getLast;
+exports.freeze = freeze;
+exports.asArray = asArray;
+exports.asReadonlyArray = asReadonlyArray;
+exports.isReadonlyArray = isReadonlyArray;
+exports.noop = noop;
+exports.compare = compare;
+function isEmpty(obj) {
+    if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
+        return obj.length === 0;
+    }
+    else if (obj) {
+        return Object.keys(obj).length === 0;
+    }
+    return false;
+}
+function isUndefined(obj) {
+    return typeof obj === 'undefined' || obj === undefined;
+}
+function isString(obj) {
+    return typeof obj === 'string';
+}
+function isNumber(obj) {
+    return typeof obj === 'number';
+}
+function isBoolean(obj) {
+    return typeof obj === 'boolean';
+}
+function isNull(obj) {
+    return obj === null;
+}
+function isDate(obj) {
+    return obj instanceof Date;
+}
+function isBigInt(obj) {
+    return typeof obj === 'bigint';
+}
+// Don't change the returnd type to `obj is Buffer` to not create a
+// hard dependency to node.
+function isBuffer(obj) {
+    return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
+}
+function isFunction(obj) {
+    return typeof obj === 'function';
+}
+function isObject(obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+function isArrayBufferOrView(obj) {
+    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
+}
+function isPlainObject(obj) {
+    if (!isObject(obj) || getTag(obj) !== '[object Object]') {
+        return false;
+    }
+    if (Object.getPrototypeOf(obj) === null) {
+        return true;
+    }
+    let proto = obj;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(obj) === proto;
+}
+function getLast(arr) {
+    return arr[arr.length - 1];
+}
+function freeze(obj) {
+    return Object.freeze(obj);
+}
+function asArray(arg) {
+    if (isReadonlyArray(arg)) {
+        return arg;
+    }
+    else {
+        return [arg];
+    }
+}
+function asReadonlyArray(arg) {
+    if (isReadonlyArray(arg)) {
+        return arg;
+    }
+    else {
+        return freeze([arg]);
+    }
+}
+function isReadonlyArray(arg) {
+    return Array.isArray(arg);
+}
+function noop(obj) {
+    return obj;
+}
+function compare(obj1, obj2) {
+    if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
+        return compareArrays(obj1, obj2);
+    }
+    else if (isObject(obj1) && isObject(obj2)) {
+        return compareObjects(obj1, obj2);
+    }
+    return obj1 === obj2;
+}
+function compareArrays(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; ++i) {
+        if (!compare(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareObjects(obj1, obj2) {
+    if (isBuffer(obj1) && isBuffer(obj2)) {
+        return compareBuffers(obj1, obj2);
+    }
+    else if (isDate(obj1) && isDate(obj2)) {
+        return compareDates(obj1, obj2);
+    }
+    return compareGenericObjects(obj1, obj2);
+}
+function compareBuffers(buf1, buf2) {
+    return Buffer.compare(buf1, buf2) === 0;
+}
+function compareDates(date1, date2) {
+    return date1.getTime() === date2.getTime();
+}
+function compareGenericObjects(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!compare(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+const toString = Object.prototype.toString;
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return toString.call(value);
+}

package/dist/server/node_modules/kysely/dist/cjs/util/performance-now.d.ts

@@ -0,0 +1 @@
+export declare function performanceNow(): number;

package/dist/server/node_modules/kysely/dist/cjs/util/performance-now.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performanceNow = performanceNow;
+const object_utils_js_1 = require("./object-utils.js");
+function performanceNow() {
+    if (typeof performance !== 'undefined' && (0, object_utils_js_1.isFunction)(performance.now)) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}