@forestadmin/agent-bff 1.18.0 → 1.19.1

package/dist/docs/docs-samples.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_key_middleware_1 = require("../api-key/api-key-middleware");
+const timezone_middleware_1 = require("../timezone/timezone-middleware");
+/** Neutral and always valid, where a local zone would only be right for whoever generated it. */
+const SAMPLE_TIMEZONE = 'UTC';
+const KEY_VARIABLE = 'BFF_KEY';
+/**
+ * Browser source, injected into the page: it decorates the fetched document with `x-codeSamples`,
+ * which Redoc renders as one tab per language, then hands it to `Redoc.init`.
+ *
+ * In the page rather than in the document, deliberately. Three samples per operation weigh ~73 KB on
+ * a 16-collection schema and several hundred KB on a large one, which every consumer of
+ * `/agent/openapi.json` would pay for an extension only a viewer reads — where this costs one
+ * function whatever the operation count. It also lets a sample carry the REAL origin: the document
+ * declares `servers: [{ url: '/' }]`, so a sample built into it could only hold a placeholder host,
+ * while the page knows where it is served from and emits a command that runs as pasted.
+ *
+ * The key is never inlined: each language reads it from the environment, so a copied sample cannot
+ * carry a credential into a shell history or a paste.
+ *
+ * Everything else is read from the document rather than assumed: the auth header comes from the
+ * security scheme the operation names, and the body carries exactly the properties its request
+ * schema makes required — `parentId` for a relation, `recordIds` for an action, nothing at all for a
+ * list, whose body is optional. The one header that cannot be read off an operation is the timezone,
+ * a component-level parameter reference; resolving it would buy nothing, since omitting it is a 400
+ * (`resolveTimezone` throws `missing_timezone` when header, body field and deployment default are
+ * all absent) and that is precisely what a hand-written sample forgets.
+ */
+const SAMPLES_SCRIPT = `
+        var KEY_HEADER = ${JSON.stringify(api_key_middleware_1.BFF_KEY_HEADER)};
+        var TIMEZONE_HEADER = ${JSON.stringify(timezone_middleware_1.TIMEZONE_HEADER)};
+        var SAMPLE_TIMEZONE = ${JSON.stringify(SAMPLE_TIMEZONE)};
+        var KEY_VARIABLE = ${JSON.stringify(KEY_VARIABLE)};
+
+        /**
+         * Every walk below is depth-bounded, because a document can reference itself: a filter is a
+         * condition TREE, and nothing stops a \`$ref\` or an \`allOf\` from naming its own schema. An
+         * overflow here is not local — it throws out of the decoration, so every operation after the
+         * offending one loses its samples too.
+         */
+        var MAX_DEPTH = 6;
+
+        function schemaOf(spec, node, depth) {
+          if (!node || depth > MAX_DEPTH) return {};
+
+          if (node.$ref) {
+            var schemas = (spec.components || {}).schemas || {};
+
+            return schemaOf(spec, schemas[node.$ref.split('/').pop()], depth + 1);
+          }
+
+          return node;
+        }
+
+        // A relation request is its foreign collection request plus a parent id, expressed as allOf.
+        function flatten(spec, node, depth) {
+          var schema = schemaOf(spec, node, depth);
+
+          if (!schema.allOf || depth > MAX_DEPTH) return schema;
+
+          var merged = { properties: {}, required: [] };
+
+          schema.allOf.forEach(function (part) {
+            var flat = flatten(spec, part, depth + 1);
+
+            Object.keys(flat.properties || {}).forEach(function (name) {
+              merged.properties[name] = flat.properties[name];
+            });
+            merged.required = merged.required.concat(flat.required || []);
+          });
+
+          return merged;
+        }
+
+        function placeholder(spec, name, node, depth) {
+          if (depth > MAX_DEPTH) return '<' + name + '>';
+
+          var schema = schemaOf(spec, node, depth);
+          var alternatives = schema.anyOf || schema.oneOf;
+
+          if (alternatives && alternatives.length) {
+            return placeholder(spec, name, alternatives[0], depth + 1);
+          }
+
+          if (schema.enum && schema.enum.length) return schema.enum[0];
+          if (schema.type === 'array') return [placeholder(spec, name, schema.items, depth + 1)];
+          if (schema.type === 'number' || schema.type === 'integer') return 0;
+          if (schema.type === 'boolean') return true;
+          if (schema.type === 'object') return {};
+
+          return '<' + name + '>';
+        }
+
+        function exampleBody(spec, operation) {
+          var content = ((operation.requestBody || {}).content || {})['application/json'];
+
+          if (!content) return undefined;
+
+          var schema = flatten(spec, content.schema, 0);
+          var body = {};
+
+          (schema.required || []).forEach(function (name) {
+            body[name] = placeholder(spec, name, (schema.properties || {})[name], 0);
+          });
+
+          return body;
+        }
+
+        // The scheme the operation names, so a document that renames or re-types it stays right.
+        function authHeader(spec, operation) {
+          var schemes = (spec.components || {}).securitySchemes || {};
+          var requirements = operation.security || spec.security || [];
+          var header = null;
+
+          requirements.forEach(function (requirement) {
+            Object.keys(requirement).forEach(function (name) {
+              if (header) return;
+
+              var scheme = schemes[name] || {};
+
+              if (scheme.type === 'apiKey' && scheme.in === 'header') {
+                header = { name: scheme.name, prefix: '', secret: true };
+              } else if (scheme.type === 'http' && scheme.scheme === 'bearer') {
+                header = { name: 'Authorization', prefix: 'Bearer ', secret: true };
+              }
+            });
+          });
+
+          return header || { name: KEY_HEADER, prefix: '', secret: true };
+        }
+
+        /**
+         * The unfolded document has no path parameter left — its segments are the real names, already
+         * URL-encoded — but the generic one is all templates, and a sample cannot be made to invoke
+         * those: the generic document is served precisely BECAUSE the deployment cannot enumerate its
+         * collections, so there is no real name to substitute. Inventing one would read as runnable
+         * and answer 404. Each template becomes the same \`<name>\` placeholder the bodies use, so one
+         * notation across a snippet means "replace this" and none of it looks like API syntax.
+         */
+        function samplePath(spec, item, operation, path) {
+          var parameters = (item.parameters || []).concat(operation.parameters || []);
+          var components = (spec.components || {}).parameters || {};
+          var sampled = path;
+
+          parameters.forEach(function (parameter) {
+            var declared = parameter && parameter.$ref
+              ? components[parameter.$ref.split('/').pop()] || {}
+              : parameter || {};
+
+            if (declared.in !== 'path' || !declared.name) return;
+
+            sampled = sampled.split('{' + declared.name + '}').join('<' + declared.name + '>');
+          });
+
+          return sampled;
+        }
+
+        function headersOf(spec, operation, body) {
+          var headers = [authHeader(spec, operation)];
+
+          headers.push({ name: TIMEZONE_HEADER, value: SAMPLE_TIMEZONE });
+
+          if (body !== undefined) headers.push({ name: 'Content-Type', value: 'application/json' });
+
+          return headers;
+        }
+
+        /**
+         * A collection or action name reaches these samples with its apostrophes intact:
+         * \`encodeURIComponent\` leaves \`'\` alone, so a collection called \`John's orders\` is a path
+         * segment carrying one, and a field name or enum value can carry one into a body. Every
+         * interpolation therefore goes through the quoting of its target language.
+         */
+        function shellQuoted(value) {
+          return "'" + String(value).split("'").join("'\\\\''") + "'";
+        }
+
+        // For a value that must EXPAND: single quotes would send the literal '$BFF_KEY' and earn a
+        // 401. Only fixed text is ever placed here, but it is escaped for the context regardless.
+        function shellExpanding(text) {
+          return String(text).replace(/([\\\\"\`$])/g, '\\\\$1');
+        }
+
+        function rubyQuoted(value) {
+          return "'" + String(value).replace(/\\\\/g, '\\\\\\\\').split("'").join("\\\\'") + "'";
+        }
+
+        // Ruby interpolates #{...} inside double quotes, and a JSON literal is double-quoted.
+        function rubySafeJson(text) {
+          return String(text).split('#{').join('\\\\#{');
+        }
+
+        function curlSample(url, method, headers, body) {
+          var lines = ['curl -X ' + method + ' ' + shellQuoted(url)];
+
+          headers.forEach(function (header) {
+            if (header.secret) {
+              var expanded =
+                shellExpanding(header.name) +
+                ': ' +
+                shellExpanding(header.prefix) +
+                '$' +
+                KEY_VARIABLE;
+
+              lines.push('  -H "' + expanded + '"');
+
+              return;
+            }
+
+            lines.push('  -H ' + shellQuoted(header.name + ': ' + header.value));
+          });
+
+          if (body !== undefined) lines.push('  -d ' + shellQuoted(JSON.stringify(body)));
+
+          return lines.join(' \\\\\\n');
+        }
+
+        function nodeSample(url, method, headers, body) {
+          var lines = [
+            'const response = await fetch(' + JSON.stringify(url) + ', {',
+            '  method: ' + JSON.stringify(method) + ',',
+            '  headers: {',
+          ];
+
+          headers.forEach(function (header) {
+            var value = header.secret
+              ? (header.prefix ? JSON.stringify(header.prefix) + ' + ' : '') +
+                'process.env.' +
+                KEY_VARIABLE
+              : JSON.stringify(header.value);
+
+            lines.push('    ' + JSON.stringify(header.name) + ': ' + value + ',');
+          });
+
+          lines.push('  },');
+
+          if (body !== undefined) {
+            lines.push('  body: JSON.stringify(' + JSON.stringify(body) + '),');
+          }
+
+          lines.push('});');
+          lines.push('');
+          lines.push(
+            "if (!response.ok) throw new Error(response.status + ' ' + (await response.text()));",
+          );
+          lines.push('');
+          lines.push('console.log(await response.json());');
+
+          return lines.join('\\n');
+        }
+
+        function rubySample(url, method, headers, body) {
+          var verb = method.charAt(0) + method.slice(1).toLowerCase();
+          var lines = [
+            "require 'json'",
+            "require 'net/http'",
+            '',
+            'uri = URI(' + rubyQuoted(url) + ')',
+            'request = Net::HTTP::' + verb + '.new(uri)',
+          ];
+
+          headers.forEach(function (header) {
+            var read = "ENV.fetch('" + KEY_VARIABLE + "')";
+            var value = header.secret
+              ? (header.prefix ? '"' + header.prefix + '#{' + read + '}"' : read)
+              : rubyQuoted(header.value);
+
+            lines.push('request[' + rubyQuoted(header.name) + '] = ' + value);
+          });
+
+          if (body !== undefined) {
+            lines.push('request.body = JSON.generate(' + rubySafeJson(JSON.stringify(body)) + ')');
+          }
+
+          lines.push('');
+          lines.push(
+            "response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|",
+          );
+          lines.push('  http.request(request)');
+          lines.push('end');
+          lines.push('');
+          lines.push('puts response.body');
+
+          return lines.join('\\n');
+        }
+
+        function decorateWithSamples(spec, origin) {
+          var paths = spec.paths || {};
+
+          Object.keys(paths).forEach(function (path) {
+            var item = paths[path] || {};
+
+            Object.keys(item).forEach(function (method) {
+              var operation = item[method];
+
+              if (!operation || typeof operation !== 'object' || !operation.responses) return;
+
+              var body = exampleBody(spec, operation);
+              var headers = headersOf(spec, operation, body);
+              var url = origin + samplePath(spec, item, operation, path);
+              var verb = method.toUpperCase();
+
+              operation['x-codeSamples'] = [
+                { lang: 'cURL', source: curlSample(url, verb, headers, body) },
+                { lang: 'JavaScript', source: nodeSample(url, verb, headers, body) },
+                { lang: 'Ruby', source: rubySample(url, verb, headers, body) },
+              ];
+            });
+          });
+
+          return spec;
+        }
+
+        /**
+         * Samples are a convenience; the document is the point. A shape the generator cannot walk
+         * costs the reader its snippets, never the page — and reporting it as a Redoc render failure
+         * would send them looking in the wrong place.
+         */
+        function withSamples(spec) {
+          try {
+            return decorateWithSamples(spec, window.location.origin);
+          } catch (samplesError) {
+            return spec;
+          }
+        }
+`;
+exports.default = SAMPLES_SCRIPT;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jcy1zYW1wbGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RvY3MvZG9jcy1zYW1wbGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsc0VBQStEO0FBQy9ELHlFQUFrRTtBQUVsRSxpR0FBaUc7QUFDakcsTUFBTSxlQUFlLEdBQUcsS0FBSyxDQUFDO0FBQzlCLE1BQU0sWUFBWSxHQUFHLFNBQVMsQ0FBQztBQUUvQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsTUFBTSxjQUFjLEdBQUc7MkJBQ0ksSUFBSSxDQUFDLFNBQVMsQ0FBQyxtQ0FBYyxDQUFDO2dDQUN6QixJQUFJLENBQUMsU0FBUyxDQUFDLHFDQUFlLENBQUM7Z0NBQy9CLElBQUksQ0FBQyxTQUFTLENBQUMsZUFBZSxDQUFDOzZCQUNsQyxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FxU3hELENBQUM7QUFFRixrQkFBZSxjQUFjLENBQUMifQ==

package/dist/docs/docs-theme.d.ts

@@ -0,0 +1,84 @@
+/** Passed to `Redoc.init`. Unknown keys are merged into Redoc's own defaults, so this is additive. */
+export declare const REDOC_THEME: {
+    readonly colors: {
+        readonly primary: {
+            readonly main: "#62801a";
+        };
+        readonly success: {
+            readonly main: "#10b981";
+        };
+        readonly warning: {
+            readonly main: "#f59e0b";
+        };
+        readonly error: {
+            readonly main: "#bf3636";
+        };
+        readonly text: {
+            readonly primary: "#14171c";
+            readonly secondary: "#505d6f";
+        };
+        readonly border: {
+            readonly light: "#e0e3e8";
+            readonly dark: "#c1c7d1";
+        };
+        readonly http: {
+            readonly get: "#7ba01f";
+            readonly post: "#10b981";
+            readonly put: "#3b82f6";
+            readonly patch: "#f59e0b";
+            readonly delete: "#bf3636";
+            readonly options: "#505d6f";
+            readonly head: "#505d6f";
+            readonly basic: "#505d6f";
+            readonly link: "#3b82f6";
+        };
+    };
+    readonly typography: {
+        readonly fontSize: "15px";
+        readonly lineHeight: "1.6";
+        readonly fontFamily: "Inter, system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+        readonly headings: {
+            readonly fontFamily: "Inter, system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+            readonly fontWeight: "600";
+        };
+        readonly code: {
+            readonly fontFamily: "'Source Code Pro', ui-monospace, SFMono-Regular, Menlo, monospace";
+            readonly fontSize: "13px";
+        };
+        readonly links: {
+            readonly color: "#62801a";
+            readonly visited: "#62801a";
+            readonly hover: "#496015";
+        };
+    };
+    readonly sidebar: {
+        readonly backgroundColor: "#14171c";
+        readonly textColor: "#c1c7d1";
+        readonly activeTextColor: "#afdf3c";
+        readonly arrow: {
+            readonly color: "#8390a2";
+        };
+    };
+    readonly rightPanel: {
+        readonly backgroundColor: "#282e38";
+        readonly textColor: "#f0f1f3";
+    };
+    readonly schema: {
+        readonly typeNameColor: "#505d6f";
+        readonly typeTitleColor: "#62801a";
+        readonly requireLabelColor: "#bf3636";
+    };
+};
+/**
+ * The product logo, verbatim from the frontend's `public/img/logo.svg` minus its XML prolog — the
+ * mark itself, not a redrawing of it, so it cannot drift in geometry. The tree is negative space:
+ * the lime path covers everything the dark ground does not show through. Both colours are the logo's
+ * own, brighter and darker than any shade the interface palette carries.
+ *
+ * Inline rather than a file: this page must request nothing off-origin, and a favicon is a request
+ * like any other. It also needs no route of its own, and no bundle to exist.
+ */
+export declare const FAVICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 1080 1080\" fill=\"none\">\n  <rect width=\"1080\" height=\"1080\" fill=\"#3F5B1E\"/>\n  <path d=\"M0 0V1080H487.658V649.169L277.256 859.597L203.317 785.648L540 448.922L876.683 785.648L802.744 859.597L592.342 649.169V1080H1080V0H0ZM802.675 568.892L539.931 306.115L277.188 568.892L203.248 494.943L539.931 158.217L876.614 494.943L802.675 568.892Z\" fill=\"#DDF327\"/>\n</svg>";
+/** The shell around Redoc: the key prompt, and the error box it writes into. */
+export declare const PAGE_STYLES: string;
+//# sourceMappingURL=docs-theme.d.ts.map

package/dist/docs/docs-theme.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGE_STYLES = exports.FAVICON_SVG = exports.REDOC_THEME = void 0;
+/**
+ * The Forest palette, as the frontend defines it in `app/styles/common/palette.css`: `accent` is the
+ * lime ramp, the neutrals are `slate`. Copied rather than shared — this package depends on nothing in
+ * the frontend, and a viewer that trails a shade behind a redesign is not a defect.
+ *
+ * Only the shades this page uses are here. The pairings below are the accessible ones: lime 500 is
+ * the brand colour but it carries 1.96:1 against white, so it is a FILL with dark text on it, never
+ * text itself. Lime 700 (4.54:1) is the lightest shade usable as text on white, and the dark chrome
+ * takes lime 400 (11.5:1 on slate 1000).
+ */
+const LIME = {
+    400: '#afdf3c',
+    500: '#99c924',
+    600: '#7ba01f',
+    700: '#62801a',
+    800: '#496015',
+};
+const SLATE = {
+    100: '#f0f1f3',
+    200: '#e0e3e8',
+    300: '#c1c7d1',
+    500: '#8390a2',
+    700: '#505d6f',
+    900: '#282e38',
+    1000: '#14171c',
+};
+const RED = { 100: '#fdecec', 700: '#bf3636' };
+const EMERALD = { 600: '#10b981' };
+const YELLOW = { 600: '#f59e0b' };
+const BLUE = { 600: '#3b82f6' };
+/**
+ * Inter and Source Code Pro are the frontend's faces, first in the stack so a machine that has them
+ * uses them. They are NOT fetched: a page holding an API key in memory must not talk to a font CDN,
+ * for the same reason the Redoc bundle is served from here rather than from one. Everyone else gets
+ * the system UI font, which is the price of that.
+ */
+const SANS = "Inter, system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+const MONO = "'Source Code Pro', ui-monospace, SFMono-Regular, Menlo, monospace";
+/** Passed to `Redoc.init`. Unknown keys are merged into Redoc's own defaults, so this is additive. */
+exports.REDOC_THEME = {
+    colors: {
+        primary: { main: LIME[700] },
+        success: { main: EMERALD[600] },
+        warning: { main: YELLOW[600] },
+        error: { main: RED[700] },
+        text: { primary: SLATE[1000], secondary: SLATE[700] },
+        border: { light: SLATE[200], dark: SLATE[300] },
+        http: {
+            get: LIME[600],
+            post: EMERALD[600],
+            put: BLUE[600],
+            patch: YELLOW[600],
+            delete: RED[700],
+            options: SLATE[700],
+            head: SLATE[700],
+            basic: SLATE[700],
+            link: BLUE[600],
+        },
+    },
+    typography: {
+        fontSize: '15px',
+        lineHeight: '1.6',
+        fontFamily: SANS,
+        headings: { fontFamily: SANS, fontWeight: '600' },
+        code: { fontFamily: MONO, fontSize: '13px' },
+        links: { color: LIME[700], visited: LIME[700], hover: LIME[800] },
+    },
+    // Forest's own chrome is dark with lime accents; Redoc's two panels are where that reads.
+    sidebar: {
+        backgroundColor: SLATE[1000],
+        textColor: SLATE[300],
+        activeTextColor: LIME[400],
+        arrow: { color: SLATE[500] },
+    },
+    rightPanel: { backgroundColor: SLATE[900], textColor: SLATE[100] },
+    schema: { typeNameColor: SLATE[700], typeTitleColor: LIME[700], requireLabelColor: RED[700] },
+};
+/**
+ * The product logo, verbatim from the frontend's `public/img/logo.svg` minus its XML prolog — the
+ * mark itself, not a redrawing of it, so it cannot drift in geometry. The tree is negative space:
+ * the lime path covers everything the dark ground does not show through. Both colours are the logo's
+ * own, brighter and darker than any shade the interface palette carries.
+ *
+ * Inline rather than a file: this page must request nothing off-origin, and a favicon is a request
+ * like any other. It also needs no route of its own, and no bundle to exist.
+ */
+exports.FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 1080" fill="none">
+  <rect width="1080" height="1080" fill="#3F5B1E"/>
+  <path d="M0 0V1080H487.658V649.169L277.256 859.597L203.317 785.648L540 448.922L876.683 785.648L802.744 859.597L592.342 649.169V1080H1080V0H0ZM802.675 568.892L539.931 306.115L277.188 568.892L203.248 494.943L539.931 158.217L876.614 494.943L802.675 568.892Z" fill="#DDF327"/>
+</svg>`;
+/** The shell around Redoc: the key prompt, and the error box it writes into. */
+exports.PAGE_STYLES = `
+      body { margin: 0; font-family: ${SANS}; color: ${SLATE[1000]}; }
+      #unlock { display: flex; gap: 12px; flex-wrap: wrap; align-items: center; padding: 14px 20px; background: ${SLATE[1000]}; color: #fff; }
+      #unlock strong { font-size: 15px; font-weight: 600; margin-right: 4px; }
+      #unlock strong span { color: ${LIME[400]}; }
+      #unlock label { font-size: 13px; color: ${SLATE[300]}; }
+      #unlock input { flex: 1 1 280px; max-width: 420px; padding: 7px 10px; font: inherit; font-size: 14px; color: #fff; background: ${SLATE[900]}; border: 1px solid ${SLATE[700]}; border-radius: 4px; }
+      #unlock input:focus { outline: 2px solid ${LIME[500]}; outline-offset: 1px; }
+      #unlock button { padding: 7px 16px; font: inherit; font-size: 14px; font-weight: 600; color: ${SLATE[1000]}; background: ${LIME[500]}; border: 0; border-radius: 4px; cursor: pointer; }
+      #unlock button:hover { background: ${LIME[400]}; }
+      #error { display: none; margin: 20px; padding: 12px 14px; border-left: 3px solid ${RED[700]}; background: ${RED[100]}; color: ${RED[700]}; font-size: 14px; white-space: pre-wrap; }
+      #error[data-shown] { display: block; }
+`;
+//# sourceMappingURL=data:application/json;base64,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