@elastic/eui-theme-common 0.0.1

package/lib/cjs/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _global_styling = require("./global_styling");
+Object.keys(_global_styling).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _global_styling[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _global_styling[key];
+    }
+  });
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _utils[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/lib/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_global_styling","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_types","_utils"],"sources":["../../src/index.ts"],"sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0 and the Server Side Public License, v 1; you may not use this file except\n * in compliance with, at your election, the Elastic License 2.0 or the Server\n * Side Public License, v 1.\n */\n\nexport * from './global_styling';\n\nexport * from './types';\nexport * from './utils';\n"],"mappings":";;;;;;;;;;AAQA,IAAAA,eAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,eAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,eAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,IAAA;MAAA,OAAAT,eAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAK,MAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,MAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,MAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,IAAA;MAAA,OAAAC,MAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,MAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,MAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,MAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,IAAA;MAAA,OAAAE,MAAA,CAAAN,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/lib/cjs/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Like `keyof typeof`, but for getting values instead of keys
+ * ValueOf<typeof {key1: 'value1', key2: 'value2'}>
+ * Results in `'value1' | 'value2'`
+ */
+export declare type ValueOf<T> = T[keyof T];
+/**
+ * Replaces all properties on any type as optional, includes nested types
+ *
+ * @example
+ * ```ts
+ * interface Person {
+ *  name: string;
+ *  age?: number;
+ *  spouse: Person;
+ *  children: Person[];
+ * }
+ * type PartialPerson = RecursivePartial<Person>;
+ * // results in
+ * interface PartialPerson {
+ *  name?: string;
+ *  age?: number;
+ *  spouse?: RecursivePartial<Person>;
+ *  children?: RecursivePartial<Person>[]
+ * }
+ * ```
+ */
+export declare type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends NonAny[] ? T[P] : T[P] extends readonly NonAny[] ? T[P] : T[P] extends Array<infer U> ? Array<RecursivePartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<RecursivePartial<U>> : T[P] extends Set<infer V> ? Set<RecursivePartial<V>> : T[P] extends Map<infer K, infer V> ? Map<K, RecursivePartial<V>> : T[P] extends NonAny ? T[P] : RecursivePartial<T[P]>;
+};
+declare type NonAny = number | boolean | string | symbol | null;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,oBAAY,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oBAAY,gBAAgB,CAAC,CAAC,IAAI;KAC/B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,EAAE,GAClC,CAAC,CAAC,CAAC,CAAC,GACJ,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,GAC9B,CAAC,CAAC,CAAC,CAAC,GACJ,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAC3B,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC1B,CAAC,CAAC,CAAC,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GACnC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAClC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GACzB,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GACxB,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAClC,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC3B,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GACnB,CAAC,CAAC,CAAC,CAAC,GACJ,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC3B,CAAC;AACF,aAAK,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC"}

package/lib/cjs/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/lib/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0 and the Server Side Public License, v 1; you may not use this file except\n * in compliance with, at your election, the Elastic License 2.0 or the Server\n * Side Public License, v 1.\n */\n\n/* TODO: duplicated types from /eui/src/components/common - extract to shared location */\n\n/**\n * Like `keyof typeof`, but for getting values instead of keys\n * ValueOf<typeof {key1: 'value1', key2: 'value2'}>\n * Results in `'value1' | 'value2'`\n */\nexport type ValueOf<T> = T[keyof T];\n\n/**\n * Replaces all properties on any type as optional, includes nested types\n *\n * @example\n * ```ts\n * interface Person {\n *  name: string;\n *  age?: number;\n *  spouse: Person;\n *  children: Person[];\n * }\n * type PartialPerson = RecursivePartial<Person>;\n * // results in\n * interface PartialPerson {\n *  name?: string;\n *  age?: number;\n *  spouse?: RecursivePartial<Person>;\n *  children?: RecursivePartial<Person>[]\n * }\n * ```\n */\nexport type RecursivePartial<T> = {\n  [P in keyof T]?: T[P] extends NonAny[] // checks for nested any[]\n    ? T[P]\n    : T[P] extends readonly NonAny[] // checks for nested ReadonlyArray<any>\n    ? T[P]\n    : T[P] extends Array<infer U>\n    ? Array<RecursivePartial<U>>\n    : T[P] extends ReadonlyArray<infer U>\n    ? ReadonlyArray<RecursivePartial<U>>\n    : T[P] extends Set<infer V> // checks for Sets\n    ? Set<RecursivePartial<V>>\n    : T[P] extends Map<infer K, infer V> // checks for Maps\n    ? Map<K, RecursivePartial<V>>\n    : T[P] extends NonAny // checks for primitive values\n    ? T[P]\n    : RecursivePartial<T[P]>; // recurse for all non-array and non-primitive values\n};\ntype NonAny = number | boolean | string | symbol | null;\n"],"mappings":"","ignoreList":[]}

package/lib/cjs/utils.d.ts

@@ -0,0 +1,104 @@
+import { EuiThemeColorMode, EuiThemeColorModeStandard, EuiThemeSystem, EuiThemeShape, EuiThemeComputed } from './global_styling';
+export declare const DEFAULT_COLOR_MODE: "LIGHT";
+/**
+ * Returns whether the provided color mode is `inverse`
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ */
+export declare const isInverseColorMode: (colorMode?: string | undefined) => colorMode is "INVERSE";
+/**
+ * Returns the color mode configured in the current EuiThemeProvider.
+ * Returns the parent color mode if none is explicity set.
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ * @param {string} parentColorMode - `LIGHT` or `DARK`; used as the fallback
+ */
+export declare const getColorMode: (colorMode?: EuiThemeColorMode | undefined, parentColorMode?: EuiThemeColorModeStandard | undefined) => EuiThemeColorModeStandard;
+/**
+ * Returns a value at a given path on an object.
+ * If `colorMode` is provided, will scope the value to the appropriate color mode key (LIGHT\DARK)
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {string} colorMode - `light` or `dark`
+ */
+export declare const getOn: (model: {
+    [key: string]: any;
+}, _path: string, colorMode?: EuiThemeColorModeStandard | undefined) => {
+    [key: string]: any;
+} | undefined;
+/**
+ * Sets a value at a given path on an object.
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {any} string -  The value to set
+ */
+export declare const setOn: (model: {
+    [key: string]: any;
+}, _path: string, value: any) => boolean;
+/**
+ * Creates a class to store the `computer` method and its eventual parameters.
+ * Allows for on-demand computation with up-to-date parameters via `getValue` method.
+ * @constructor
+ * @param {function} computer - Function to be computed
+ * @param {string | array} dependencies - Dependencies passed to the `computer` as parameters
+ */
+export declare class Computed<T> {
+    computer: (...values: any[]) => T;
+    dependencies: string | string[];
+    constructor(computer: (...values: any[]) => T, dependencies?: string | string[]);
+    /**
+     * Executes the `computer` method with the current state of the theme
+     * by taking into account previously computed values and modifications.
+     * @param {Proxy | object} base - Computed or uncomputed theme
+     * @param {Proxy | object} modifications - Theme value overrides
+     * @param {object} working - Partially computed theme
+     * @param {string} colorMode - `light` or `dark`
+     */
+    getValue(base: EuiThemeSystem | EuiThemeShape | null, modifications: import("./types").RecursivePartial<EuiThemeShape> | undefined, working: Partial<EuiThemeComputed>, colorMode?: EuiThemeColorModeStandard): T;
+}
+/**
+ * Returns a Class (`Computed`) that stores the arbitrary computer method
+ * and references to its optional dependecies.
+ * @param {function} computer - Arbitrary method to be called at compute time.
+ * @param {string | array} dependencies - Values that will be provided to `computer` at compute time.
+ */
+export declare function computed<T>(computer: (value: EuiThemeComputed) => T): T;
+export declare function computed<T>(computer: (value: any[]) => T, dependencies: string[]): T;
+export declare function computed<T>(computer: (value: any) => T, dependencies: string): T;
+/**
+ * Takes an uncomputed theme, and computes and returns all values taking
+ * into consideration value overrides and configured color mode.
+ * Overrides take precedence, and only values in the current color mode
+ * are computed and returned.
+ * @param {Proxy} base - Object to transform into Proxy
+ * @param {Proxy | object} over - Unique identifier or name
+ * @param {string} colorMode - `light` or `dark`
+ */
+export declare const getComputed: <T = EuiThemeShape>(base: EuiThemeSystem<T>, over: Partial<EuiThemeSystem<T>>, colorMode: EuiThemeColorModeStandard) => EuiThemeComputed<T>;
+/**
+ * Builds a Proxy with a custom `handler` designed to self-reference values
+ * and prevent arbitrary value overrides.
+ * @param {object} model - Object to transform into Proxy
+ * @param {string} key - Unique identifier or name
+ */
+export declare const buildTheme: <T extends {}>(model: T, key: string) => {
+    model: T;
+    root: T;
+    key: string;
+};
+/**
+ * Deeply merges two objects, using `source` values whenever possible.
+ * @param {object} _target - Object with fallback values
+ * @param {object} source - Object with desired values
+ */
+export declare const mergeDeep: (_target: {
+    [key: string]: any;
+}, source?: {
+    [key: string]: any;
+}) => {
+    [key: string]: any;
+};
+/**
+ * Returns token name string based on passed dynamic variants
+ * and additional prefix/suffix
+ */
+export declare const getTokenName: (prefix: string, variant: string, suffix?: string | undefined) => string;
+//# sourceMappingURL=utils.d.ts.map

package/lib/cjs/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,iBAAiB,EAEjB,yBAAyB,EAEzB,cAAc,EACd,aAAa,EACb,gBAAgB,EAGjB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,kBAAkB,SAA6B,CAAC;AAQ7D;;;GAGG;AACH,eAAO,MAAM,kBAAkB,4DAI9B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,0GAGtB,yBAeF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK;;UAET,MAAM;;aAgCd,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;UAET,MAAM,SACN,GAAG,YAgBX,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,QAAQ,CAAC,CAAC;IAEZ,QAAQ,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC;IACjC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;gBAD/B,QAAQ,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,EACjC,YAAY,GAAE,MAAM,GAAG,MAAM,EAAO;IAG7C;;;;;;;OAOG;IACH,QAAQ,CACN,IAAI,EAAE,cAAc,GAAG,aAAa,GAAG,IAAI,EAC3C,aAAa,+DAA4B,EACzC,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAClC,SAAS,CAAC,EAAE,yBAAyB;CAsBxC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,CAAC,GAAG,CAAC,CAAC;AACzE,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EAC7B,YAAY,EAAE,MAAM,EAAE,GACrB,CAAC,CAAC;AACL,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,EAC3B,YAAY,EAAE,MAAM,GACnB,CAAC,CAAC;AAkBL;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,4FAGX,yBAAyB,wBAgDrC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,gCAAiC,MAAM;;;;CA+E7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;CAsBrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,WACf,MAAM,WACL,MAAM,wCAShB,CAAC"}

package/lib/cjs/utils.js

@@ -0,0 +1,382 @@
+"use strict";
+
+require("core-js/modules/es.symbol.to-primitive.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.date.to-primitive.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.object.define-properties.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.regexp.test.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildTheme = exports.DEFAULT_COLOR_MODE = exports.Computed = void 0;
+exports.computed = computed;
+exports.setOn = exports.mergeDeep = exports.isInverseColorMode = exports.getTokenName = exports.getOn = exports.getComputed = exports.getColorMode = void 0;
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.is-array.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.object.values.js");
+require("core-js/modules/es.reflect.define-property.js");
+require("core-js/modules/es.reflect.get-own-property-descriptor.js");
+require("core-js/modules/es.reflect.get-prototype-of.js");
+require("core-js/modules/es.reflect.has.js");
+require("core-js/modules/es.reflect.is-extensible.js");
+require("core-js/modules/es.reflect.own-keys.js");
+require("core-js/modules/es.reflect.prevent-extensions.js");
+require("core-js/modules/es.reflect.set-prototype-of.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.sticky.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _global_styling = require("./global_styling");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } /*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+var DEFAULT_COLOR_MODE = exports.DEFAULT_COLOR_MODE = _global_styling.COLOR_MODES_STANDARD.light;
+
+/**
+ * Returns whether the parameter is an object
+ * @param {any} obj - Anything
+ */
+var isObject = function isObject(obj) {
+  return obj && _typeof(obj) === 'object';
+};
+
+/**
+ * Returns whether the provided color mode is `inverse`
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ */
+var isInverseColorMode = exports.isInverseColorMode = function isInverseColorMode(colorMode) {
+  return colorMode === _global_styling.COLOR_MODES_INVERSE;
+};
+
+/**
+ * Returns the color mode configured in the current EuiThemeProvider.
+ * Returns the parent color mode if none is explicity set.
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ * @param {string} parentColorMode - `LIGHT` or `DARK`; used as the fallback
+ */
+var getColorMode = exports.getColorMode = function getColorMode(colorMode, parentColorMode) {
+  if (colorMode == null) {
+    return parentColorMode || DEFAULT_COLOR_MODE;
+  }
+  var mode = colorMode.toUpperCase();
+  if (isInverseColorMode(mode)) {
+    return parentColorMode === _global_styling.COLOR_MODES_STANDARD.dark || parentColorMode === undefined ? _global_styling.COLOR_MODES_STANDARD.light : _global_styling.COLOR_MODES_STANDARD.dark;
+  } else {
+    return mode;
+  }
+};
+
+/**
+ * Returns a value at a given path on an object.
+ * If `colorMode` is provided, will scope the value to the appropriate color mode key (LIGHT\DARK)
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {string} colorMode - `light` or `dark`
+ */
+var getOn = exports.getOn = function getOn(model, _path, colorMode) {
+  var path = _path.split('.');
+  var node = model;
+  while (path.length) {
+    var segment = path.shift();
+    if (node.hasOwnProperty(segment) === false) {
+      if (colorMode && node.hasOwnProperty(colorMode) === true && node[colorMode].hasOwnProperty(segment) === true) {
+        if (node[colorMode][segment] instanceof Computed) {
+          node = node[colorMode][segment].getValue(null, {}, node, colorMode);
+        } else {
+          node = node[colorMode][segment];
+        }
+      } else {
+        return undefined;
+      }
+    } else {
+      if (node[segment] instanceof Computed) {
+        node = node[segment].getValue(null, {}, node, colorMode);
+      } else {
+        node = node[segment];
+      }
+    }
+  }
+  return node;
+};
+
+/**
+ * Sets a value at a given path on an object.
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {any} string -  The value to set
+ */
+var setOn = exports.setOn = function setOn(model, _path, value) {
+  var path = _path.split('.');
+  var propertyName = path.pop();
+  var node = model;
+  while (path.length) {
+    var segment = path.shift();
+    if (node.hasOwnProperty(segment) === false) {
+      node[segment] = {};
+    }
+    node = node[segment];
+  }
+  node[propertyName] = value;
+  return true;
+};
+
+/**
+ * Creates a class to store the `computer` method and its eventual parameters.
+ * Allows for on-demand computation with up-to-date parameters via `getValue` method.
+ * @constructor
+ * @param {function} computer - Function to be computed
+ * @param {string | array} dependencies - Dependencies passed to the `computer` as parameters
+ */
+var Computed = exports.Computed = /*#__PURE__*/function () {
+  function Computed(computer) {
+    var dependencies = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, Computed);
+    this.computer = computer;
+    this.dependencies = dependencies;
+  }
+
+  /**
+   * Executes the `computer` method with the current state of the theme
+   * by taking into account previously computed values and modifications.
+   * @param {Proxy | object} base - Computed or uncomputed theme
+   * @param {Proxy | object} modifications - Theme value overrides
+   * @param {object} working - Partially computed theme
+   * @param {string} colorMode - `light` or `dark`
+   */
+  return _createClass(Computed, [{
+    key: "getValue",
+    value: function getValue(base) {
+      var modifications = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var working = arguments.length > 2 ? arguments[2] : undefined;
+      var colorMode = arguments.length > 3 ? arguments[3] : undefined;
+      if (!this.dependencies.length) {
+        return this.computer(working);
+      }
+      if (!Array.isArray(this.dependencies)) {
+        var _ref, _getOn;
+        return this.computer((_ref = (_getOn = getOn(working, this.dependencies)) !== null && _getOn !== void 0 ? _getOn : getOn(modifications, this.dependencies, colorMode)) !== null && _ref !== void 0 ? _ref : base ? getOn(base, this.dependencies, colorMode) : working);
+      }
+      return this.computer(this.dependencies.map(function (dependency) {
+        var _ref2, _getOn2;
+        return (_ref2 = (_getOn2 = getOn(working, dependency)) !== null && _getOn2 !== void 0 ? _getOn2 : getOn(modifications, dependency, colorMode)) !== null && _ref2 !== void 0 ? _ref2 : base ? getOn(base, dependency, colorMode) : working;
+      }));
+    }
+  }]);
+}();
+/**
+ * Returns a Class (`Computed`) that stores the arbitrary computer method
+ * and references to its optional dependecies.
+ * @param {function} computer - Arbitrary method to be called at compute time.
+ * @param {string | array} dependencies - Values that will be provided to `computer` at compute time.
+ */
+function computed(comp, dep) {
+  return new Computed(comp, dep);
+}
+
+/**
+ * Type guard to check for a Computed object based on object shape
+ * without relying on the Computed class directly
+ */
+var isComputedLike = function isComputedLike(key) {
+  if (_typeof(key) !== 'object' || Array.isArray(key)) return false;
+  return key.hasOwnProperty('dependencies') && key.hasOwnProperty('computer');
+};
+
+/**
+ * Takes an uncomputed theme, and computes and returns all values taking
+ * into consideration value overrides and configured color mode.
+ * Overrides take precedence, and only values in the current color mode
+ * are computed and returned.
+ * @param {Proxy} base - Object to transform into Proxy
+ * @param {Proxy | object} over - Unique identifier or name
+ * @param {string} colorMode - `light` or `dark`
+ */
+var getComputed = exports.getComputed = function getComputed(base, over, colorMode) {
+  var output = {
+    themeName: base.key
+  };
+  function loop(base, over) {
+    var checkExisting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var path = arguments.length > 3 ? arguments[3] : undefined;
+    Object.keys(base).forEach(function (key) {
+      var newPath = path ? "".concat(path, ".").concat(key) : "".concat(key);
+      // @ts-expect-error `key` is not necessarily a colorMode key
+      if ([].concat(_toConsumableArray(Object.values(_global_styling.COLOR_MODES_STANDARD)), [colorMode]).includes(key)) {
+        if (key !== colorMode) {
+          return;
+        } else {
+          var colorModeSegment = new RegExp("(\\.".concat(colorMode, "\\b)|(\\b").concat(colorMode, "\\.)"));
+          newPath = newPath.replace(colorModeSegment, '');
+        }
+      }
+      var existing = checkExisting && getOn(output, newPath);
+      if (!existing || isObject(existing)) {
+        // NOTE: the class type check for Computed is not true for themes created externally;
+        // we additionally check on the object shape to confirm a Computed value
+        var baseValue = base[key] instanceof Computed || isComputedLike(base[key]) ? base[key].getValue(base.root, over.root, output, colorMode) : base[key];
+        var overValue = over[key] instanceof Computed || isComputedLike(over[key]) ? over[key].getValue(base.root, over.root, output, colorMode) : over[key];
+        if (isObject(baseValue) && !Array.isArray(baseValue)) {
+          loop(baseValue, overValue !== null && overValue !== void 0 ? overValue : {}, checkExisting, newPath);
+        } else {
+          setOn(output, newPath, overValue !== null && overValue !== void 0 ? overValue : baseValue);
+        }
+      }
+    });
+  }
+  // Compute standard theme values and apply overrides
+  loop(base, over);
+  // Compute and apply extension values only
+  loop(over, {}, true);
+  return output;
+};
+
+/**
+ * Builds a Proxy with a custom `handler` designed to self-reference values
+ * and prevent arbitrary value overrides.
+ * @param {object} model - Object to transform into Proxy
+ * @param {string} key - Unique identifier or name
+ */
+var buildTheme = exports.buildTheme = function buildTheme(model, key) {
+  var handler = {
+    getPrototypeOf: function getPrototypeOf(target) {
+      return Reflect.getPrototypeOf(target.model);
+    },
+    setPrototypeOf: function setPrototypeOf(target, prototype) {
+      return Reflect.setPrototypeOf(target.model, prototype);
+    },
+    isExtensible: function isExtensible(target) {
+      return Reflect.isExtensible(target);
+    },
+    preventExtensions: function preventExtensions(target) {
+      return Reflect.preventExtensions(target.model);
+    },
+    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, key) {
+      return Reflect.getOwnPropertyDescriptor(target.model, key);
+    },
+    defineProperty: function defineProperty(target, property, attributes) {
+      return Reflect.defineProperty(target.model, property, attributes);
+    },
+    has: function has(target, property) {
+      return Reflect.has(target.model, property);
+    },
+    get: function get(_target, property) {
+      if (property === 'key') {
+        return _target[property];
+      }
+
+      // prevent Safari from locking up when the proxy is used in dev tools
+      // as it doesn't support getPrototypeOf
+      if (property === '__proto__') return {};
+      var target = property === 'root' ? _target : _target.model || _target;
+      // @ts-ignore `string` index signature
+      var value = target[property];
+      if (isObject(value) && !Array.isArray(value)) {
+        return new Proxy({
+          model: value,
+          root: _target.root,
+          key: "_".concat(_target.key)
+        }, handler);
+      } else {
+        return value;
+      }
+    },
+    set: function set(target) {
+      return target;
+    },
+    deleteProperty: function deleteProperty(target) {
+      return target;
+    },
+    ownKeys: function ownKeys(target) {
+      return Reflect.ownKeys(target.model);
+    },
+    apply: function apply(target) {
+      return target;
+    },
+    construct: function construct(target) {
+      return target;
+    }
+  };
+  var themeProxy = new Proxy({
+    model: model,
+    root: model,
+    key: key
+  }, handler);
+  return themeProxy;
+};
+
+/**
+ * Deeply merges two objects, using `source` values whenever possible.
+ * @param {object} _target - Object with fallback values
+ * @param {object} source - Object with desired values
+ */
+var mergeDeep = exports.mergeDeep = function mergeDeep(_target) {
+  var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var target = _objectSpread({}, _target);
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+  Object.keys(source).forEach(function (key) {
+    var targetValue = target[key];
+    var sourceValue = source[key];
+    if (isObject(targetValue) && isObject(sourceValue)) {
+      target[key] = mergeDeep(_objectSpread({}, targetValue), _objectSpread({}, sourceValue));
+    } else {
+      target[key] = sourceValue;
+    }
+  });
+  return target;
+};
+
+/**
+ * Returns token name string based on passed dynamic variants
+ * and additional prefix/suffix
+ */
+var getTokenName = exports.getTokenName = function getTokenName(prefix, variant, suffix) {
+  var getCapitalized = function getCapitalized(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+  var colorName = variant.charAt(0).toUpperCase() + variant.slice(1);
+  var _suffix = suffix ? getCapitalized(suffix) : '';
+  return "".concat(prefix).concat(getCapitalized(colorName)).concat(_suffix);
+};
+//# sourceMappingURL=utils.js.map