@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/image-blur-svg.js

@@ -0,0 +1,22 @@
+/**
+ * A shared function, used on both client and server, to generate a SVG blur placeholder.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImageBlurSvg", {
+    enumerable: true,
+    get: function() {
+        return getImageBlurSvg;
+    }
+});
+function getImageBlurSvg({ widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit }) {
+    const std = 20;
+    const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
+    const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
+    const viewBox = svgWidth && svgHeight ? `viewBox='0 0 ${svgWidth} ${svgHeight}'` : '';
+    const preserveAspectRatio = viewBox ? 'none' : objectFit === 'contain' ? 'xMidYMid' : objectFit === 'cover' ? 'xMidYMid slice' : 'none';
+    return `%3Csvg xmlns='http://www.w3.org/2000/svg' ${viewBox}%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='${preserveAspectRatio}' style='filter: url(%23b);' href='${blurDataURL}'/%3E%3C/svg%3E`;
+}
+
+//# sourceMappingURL=image-blur-svg.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageConfigContext", {
+    enumerable: true,
+    get: function() {
+        return ImageConfigContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _imageconfig = require("./image-config");
+const ImageConfigContext = _react.default.createContext(_imageconfig.imageConfigDefault);
+if (process.env.NODE_ENV !== 'production') {
+    ImageConfigContext.displayName = 'ImageConfigContext';
+}
+
+//# sourceMappingURL=image-config-context.shared-runtime.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/image-config.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    VALID_LOADERS: null,
+    imageConfigDefault: null,
+    prepareImageConfig: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VALID_LOADERS: function() {
+        return VALID_LOADERS;
+    },
+    imageConfigDefault: function() {
+        return imageConfigDefault;
+    },
+    prepareImageConfig: function() {
+        return prepareImageConfig;
+    }
+});
+const VALID_LOADERS = [
+    'default',
+    'imgix',
+    'cloudinary',
+    'akamai',
+    'custom'
+];
+const missingImageConfig = {};
+const preparedImageConfigs = new WeakMap();
+function prepareImageConfig(envConfig, contextConfig) {
+    const envKey = envConfig ?? missingImageConfig;
+    const contextKey = contextConfig ?? missingImageConfig;
+    let preparedByContext = preparedImageConfigs.get(envKey);
+    if (preparedByContext) {
+        const cached = preparedByContext.get(contextKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    const source = envConfig || contextConfig || imageConfigDefault;
+    const deviceSizes = [
+        ...source.deviceSizes
+    ].sort((a, b)=>a - b);
+    const imageSizes = [
+        ...source.imageSizes
+    ];
+    const prepared = {
+        deviceSizes,
+        imageSizes,
+        allSizes: [
+            ...deviceSizes,
+            ...imageSizes
+        ].sort((a, b)=>a - b),
+        qualities: source.qualities === undefined ? undefined : [
+            ...source.qualities
+        ].sort((a, b)=>a - b),
+        path: source.path,
+        loader: source.loader,
+        dangerouslyAllowSVG: source.dangerouslyAllowSVG,
+        unoptimized: source.unoptimized,
+        domains: source.domains,
+        remotePatterns: source.remotePatterns,
+        // The inlined browser options supply their own patterns. During SSR the
+        // context supplies security-sensitive patterns omitted from the inline data.
+        localPatterns: typeof window === 'undefined' && contextConfig !== undefined ? contextConfig.localPatterns : source.localPatterns,
+        output: source.output
+    };
+    if (!preparedByContext) {
+        preparedByContext = new WeakMap();
+        preparedImageConfigs.set(envKey, preparedByContext);
+    }
+    preparedByContext.set(contextKey, prepared);
+    return prepared;
+}
+const imageConfigDefault = {
+    deviceSizes: [
+        640,
+        750,
+        828,
+        1080,
+        1200,
+        1920,
+        2048,
+        3840
+    ],
+    imageSizes: [
+        32,
+        48,
+        64,
+        96,
+        128,
+        256,
+        384
+    ],
+    path: '/_next/image',
+    loader: 'default',
+    loaderFile: '',
+    /**
+   * @deprecated Use `remotePatterns` instead to protect your application from malicious users.
+   */ domains: [],
+    disableStaticImages: false,
+    minimumCacheTTL: 14400,
+    formats: [
+        'image/webp'
+    ],
+    maximumDiskCacheSize: undefined,
+    maximumRedirects: 3,
+    maximumResponseBody: 50000000,
+    dangerouslyAllowLocalIP: false,
+    dangerouslyAllowSVG: false,
+    contentSecurityPolicy: `script-src 'none'; frame-src 'none'; sandbox;`,
+    contentDispositionType: 'attachment',
+    localPatterns: undefined,
+    remotePatterns: [],
+    qualities: [
+        75
+    ],
+    unoptimized: false,
+    customCacheHandler: false
+};
+
+//# sourceMappingURL=image-config.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/instant-messages.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createLinkPrefetchPartialError: null,
+    createUnrenderedSegmentError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLinkPrefetchPartialError: function() {
+        return createLinkPrefetchPartialError;
+    },
+    createUnrenderedSegmentError: function() {
+        return createUnrenderedSegmentError;
+    }
+});
+function createUnrenderedSegmentError(route, missingFiles) {
+    let message = `Route "${route}": Could not validate that a segment in your UI has instant navigation.`;
+    if (missingFiles.length > 0) {
+        const label = missingFiles.length === 1 ? 'Dropped segment' : 'Dropped segments';
+        message += `\n\nThis segment was dropped from rendering. Issues that would prevent instant navigation will go undetected.` + `\n\n${label}:\n${missingFiles.map((p)=>`  ${p}`).join('\n')}` + `\n\nWays to fix this:` + `\n  - [render] Render the dropped segment` + `\n  - [ignore] Set \`export const instant = false\` to opt the dropped segment out of instant-navigation validation` + `\n\nLearn more: https://nextjs.org/docs/messages/instant-unrendered-segment`;
+    }
+    return new Error(message);
+}
+function createLinkPrefetchPartialError(pathname) {
+    return new Error(`Next.js encountered dynamic data during prefetching for "${pathname}".\n\n` + `This will lead to slower, more expensive prefetches.\n\n` + `Ways to fix this:\n` + `  - [upgrade] Opt into Partial Prefetching by exporting \`const prefetch = 'partial'\` from the page or layout, or by setting \`partialPrefetching: true\` in next.config to opt the whole app in\n` + `  - [disable] Remove \`prefetch={true}\` from the <Link> to use the default prefetch\n` + `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n\n` + `Learn more: https://nextjs.org/docs/messages/instant-link-prefetch-partial`);
+}
+
+//# sourceMappingURL=instant-messages.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/invariant-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "InvariantError", {
+    enumerable: true,
+    get: function() {
+        return InvariantError;
+    }
+});
+class InvariantError extends Error {
+    constructor(message, options){
+        super(`Invariant: ${message.endsWith('.') ? message : message + '.'} This is a bug in Next.js.`, options);
+        this.name = 'InvariantError';
+    }
+}
+
+//# sourceMappingURL=invariant-error.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/is-plain-object.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getObjectClassLabel: null,
+    isPlainObject: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getObjectClassLabel: function() {
+        return getObjectClassLabel;
+    },
+    isPlainObject: function() {
+        return isPlainObject;
+    }
+});
+function getObjectClassLabel(value) {
+    return Object.prototype.toString.call(value);
+}
+function isPlainObject(value) {
+    if (getObjectClassLabel(value) !== '[object Object]') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    /**
+   * this used to be previously:
+   *
+   * `return prototype === null || prototype === Object.prototype`
+   *
+   * but Edge Runtime expose Object from vm, being that kind of type-checking wrongly fail.
+   *
+   * It was changed to the current implementation since it's resilient to serialization.
+   */ return prototype === null || prototype.hasOwnProperty('isPrototypeOf');
+}
+
+//# sourceMappingURL=is-plain-object.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/is-thenable.js

@@ -0,0 +1,20 @@
+/**
+ * Check to see if a value is Thenable.
+ *
+ * @param promise the maybe-thenable value
+ * @returns true if the value is thenable
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isThenable", {
+    enumerable: true,
+    get: function() {
+        return isThenable;
+    }
+});
+function isThenable(promise) {
+    return promise !== null && typeof promise === 'object' && 'then' in promise && typeof promise.then === 'function';
+}
+
+//# sourceMappingURL=is-thenable.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/isomorphic/path.js

@@ -0,0 +1,14 @@
+/**
+ * This module is for next.js server internal usage of path module.
+ * It will use native path module for nodejs runtime.
+ * It will use path-browserify polyfill for edge runtime.
+ */ "use strict";
+let path;
+if (process.env.NEXT_RUNTIME === 'edge') {
+    path = require('next/dist/compiled/path-browserify');
+} else {
+    path = require('path');
+}
+module.exports = path;
+
+//# sourceMappingURL=path.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.js

@@ -0,0 +1,37 @@
+// This has to be a shared module which is shared between client component error boundary and dynamic component
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    BailoutToCSRError: null,
+    isBailoutToCSRError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BailoutToCSRError: function() {
+        return BailoutToCSRError;
+    },
+    isBailoutToCSRError: function() {
+        return isBailoutToCSRError;
+    }
+});
+const BAILOUT_TO_CSR = 'BAILOUT_TO_CLIENT_SIDE_RENDERING';
+class BailoutToCSRError extends Error {
+    constructor(reason){
+        super(`Bail out to client-side rendering: ${reason}`), this.reason = reason, this.digest = BAILOUT_TO_CSR;
+    }
+}
+function isBailoutToCSRError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err)) {
+        return false;
+    }
+    return err.digest === BAILOUT_TO_CSR;
+}
+
+//# sourceMappingURL=bailout-to-csr.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/lazy-dynamic/react-browser-bailout.js

@@ -0,0 +1,45 @@
+// This module is bundled separately into user code and the precompiled App
+// Router runtime. Use the global symbol registry so both copies recognize the
+// same browser bailout reason.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createReactBrowserBailoutReason: null,
+    getReactBrowserBailoutReason: null,
+    isNextBrowserBailoutError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createReactBrowserBailoutReason: function() {
+        return createReactBrowserBailoutReason;
+    },
+    getReactBrowserBailoutReason: function() {
+        return getReactBrowserBailoutReason;
+    },
+    isNextBrowserBailoutError: function() {
+        return isNextBrowserBailoutError;
+    }
+});
+const REACT_BROWSER_BAILOUT_REASON = Symbol.for('next.browser-bailout-reason');
+function createReactBrowserBailoutReason(reason) {
+    return {
+        $$typeof: REACT_BROWSER_BAILOUT_REASON,
+        reason
+    };
+}
+function getReactBrowserBailoutReason(error) {
+    const cause = error?.cause;
+    return cause?.$$typeof === REACT_BROWSER_BAILOUT_REASON ? cause.reason : undefined;
+}
+function isNextBrowserBailoutError(error) {
+    return getReactBrowserBailoutReason(error) !== undefined;
+}
+
+//# sourceMappingURL=react-browser-bailout.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/loadable-context.shared-runtime.js

@@ -0,0 +1,19 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LoadableContext", {
+    enumerable: true,
+    get: function() {
+        return LoadableContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const LoadableContext = _react.default.createContext(null);
+if (process.env.NODE_ENV !== 'production') {
+    LoadableContext.displayName = 'LoadableContext';
+}
+
+//# sourceMappingURL=loadable-context.shared-runtime.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/loadable.shared-runtime.js

@@ -0,0 +1,246 @@
+// TODO: Remove use of `any` type.
+/**
+@copyright (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+*/ // https://github.com/jamiebuilds/react-loadable/blob/v5.5.0/src/index.js
+// Modified to be compatible with webpack 4 / Next.js
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _loadablecontextsharedruntime = require("./loadable-context.shared-runtime");
+function resolve(obj) {
+    return obj && obj.default ? obj.default : obj;
+}
+const ALL_INITIALIZERS = [];
+const READY_INITIALIZERS = [];
+let initialized = false;
+function load(loader) {
+    let promise = loader();
+    let state = {
+        loading: true,
+        loaded: null,
+        error: null
+    };
+    state.promise = promise.then((loaded)=>{
+        state.loading = false;
+        state.loaded = loaded;
+        return loaded;
+    }).catch((err)=>{
+        state.loading = false;
+        state.error = err;
+        throw err;
+    });
+    return state;
+}
+function createLoadableComponent(loadFn, options) {
+    let opts = Object.assign({
+        loader: null,
+        loading: null,
+        delay: 200,
+        timeout: null,
+        webpack: null,
+        modules: null
+    }, options);
+    /** @type LoadableSubscription */ let subscription = null;
+    function init() {
+        if (!subscription) {
+            const sub = new LoadableSubscription(loadFn, opts);
+            subscription = {
+                getCurrentValue: sub.getCurrentValue.bind(sub),
+                subscribe: sub.subscribe.bind(sub),
+                retry: sub.retry.bind(sub),
+                promise: sub.promise.bind(sub)
+            };
+        }
+        return subscription.promise();
+    }
+    // Server only
+    if (typeof window === 'undefined') {
+        ALL_INITIALIZERS.push(init);
+    }
+    // Client only
+    if (!initialized && typeof window !== 'undefined') {
+        // require.resolveWeak check is needed for environments that don't have it available like Jest
+        const moduleIds = opts.webpack && typeof require.resolveWeak === 'function' ? opts.webpack() : opts.modules;
+        if (moduleIds) {
+            READY_INITIALIZERS.push((ids)=>{
+                for (const moduleId of moduleIds){
+                    if (ids.includes(moduleId)) {
+                        return init();
+                    }
+                }
+            });
+        }
+    }
+    function useLoadableModule() {
+        init();
+        const context = _react.default.useContext(_loadablecontextsharedruntime.LoadableContext);
+        if (context && Array.isArray(opts.modules)) {
+            opts.modules.forEach((moduleName)=>{
+                context(moduleName);
+            });
+        }
+    }
+    function LoadableComponent(props, ref) {
+        useLoadableModule();
+        const state = _react.default.useSyncExternalStore(subscription.subscribe, subscription.getCurrentValue, subscription.getCurrentValue);
+        _react.default.useImperativeHandle(ref, ()=>({
+                retry: subscription.retry
+            }), []);
+        return _react.default.useMemo(()=>{
+            if (state.loading || state.error) {
+                return /*#__PURE__*/ _react.default.createElement(opts.loading, {
+                    isLoading: state.loading,
+                    pastDelay: state.pastDelay,
+                    timedOut: state.timedOut,
+                    error: state.error,
+                    retry: subscription.retry
+                });
+            } else if (state.loaded) {
+                return /*#__PURE__*/ _react.default.createElement(resolve(state.loaded), props);
+            } else {
+                return null;
+            }
+        }, [
+            props,
+            state
+        ]);
+    }
+    LoadableComponent.preload = ()=>init();
+    LoadableComponent.displayName = 'LoadableComponent';
+    return /*#__PURE__*/ _react.default.forwardRef(LoadableComponent);
+}
+class LoadableSubscription {
+    constructor(loadFn, opts){
+        this._loadFn = loadFn;
+        this._opts = opts;
+        this._callbacks = new Set();
+        this._delay = null;
+        this._timeout = null;
+        this.retry();
+    }
+    promise() {
+        return this._res.promise;
+    }
+    retry() {
+        this._clearTimeouts();
+        this._res = this._loadFn(this._opts.loader);
+        this._state = {
+            pastDelay: false,
+            timedOut: false
+        };
+        const { _res: res, _opts: opts } = this;
+        if (res.loading) {
+            if (typeof opts.delay === 'number') {
+                if (opts.delay === 0) {
+                    this._state.pastDelay = true;
+                } else {
+                    this._delay = setTimeout(()=>{
+                        this._update({
+                            pastDelay: true
+                        });
+                    }, opts.delay);
+                }
+            }
+            if (typeof opts.timeout === 'number') {
+                this._timeout = setTimeout(()=>{
+                    this._update({
+                        timedOut: true
+                    });
+                }, opts.timeout);
+            }
+        }
+        this._res.promise.then(()=>{
+            this._update({});
+            this._clearTimeouts();
+        }).catch((_err)=>{
+            this._update({});
+            this._clearTimeouts();
+        });
+        this._update({});
+    }
+    _update(partial) {
+        this._state = {
+            ...this._state,
+            error: this._res.error,
+            loaded: this._res.loaded,
+            loading: this._res.loading,
+            ...partial
+        };
+        this._callbacks.forEach((callback)=>callback());
+    }
+    _clearTimeouts() {
+        clearTimeout(this._delay);
+        clearTimeout(this._timeout);
+    }
+    getCurrentValue() {
+        return this._state;
+    }
+    subscribe(callback) {
+        this._callbacks.add(callback);
+        return ()=>{
+            this._callbacks.delete(callback);
+        };
+    }
+}
+function Loadable(opts) {
+    return createLoadableComponent(load, opts);
+}
+function flushInitializers(initializers, ids) {
+    let promises = [];
+    while(initializers.length){
+        let init = initializers.pop();
+        promises.push(init(ids));
+    }
+    return Promise.all(promises).then(()=>{
+        if (initializers.length) {
+            return flushInitializers(initializers, ids);
+        }
+    });
+}
+Loadable.preloadAll = ()=>{
+    return new Promise((resolveInitializers, reject)=>{
+        flushInitializers(ALL_INITIALIZERS).then(resolveInitializers, reject);
+    });
+};
+Loadable.preloadReady = (ids = [])=>{
+    return new Promise((resolvePreload)=>{
+        const res = ()=>{
+            initialized = true;
+            return resolvePreload();
+        };
+        // We always will resolve, errors should be handled within loading UIs.
+        flushInitializers(READY_INITIALIZERS, ids).then(res, res);
+    });
+};
+if (typeof window !== 'undefined') {
+    window.__NEXT_PRELOADREADY = Loadable.preloadReady;
+}
+const _default = Loadable;
+
+//# sourceMappingURL=loadable.shared-runtime.js.map