@limetech/lime-elements 40.5.2 → 40.6.0

package/dist/collection/components/action-bar/action-bar-item/action-bar-item.css

@@ -128,7 +128,7 @@ button:not([disabled]) {
   transition: color var(--limel-clickable-transition-speed, 0.4s) ease, background-color var(--limel-clickable-transition-speed, 0.4s) ease, box-shadow var(--limel-clickable-transform-speed, 0.4s) ease, transform var(--limel-clickable-transform-speed, 0.4s) var(--limel-clickable-transform-timing-function, ease);
   cursor: pointer;
   color: var(--limel-action-bar-item-text-color);
-  background-color: var(--limel-action-bar-background-color);
+  background-color: transparent;
 }
 button:not([disabled]):hover, button:not([disabled]):focus, button:not([disabled]):focus-visible {
   will-change: color, background-color, box-shadow, transform;

package/dist/collection/components/form/fields/schema-field.js

@@ -6,6 +6,7 @@ import { resetDependentFields, schemaAllowsNull } from "./field-helpers";
 import { FieldTemplate } from "../templates";
 import { getHelpComponent } from "../help";
 import { TimePicker } from "../widgets/time-picker";
+import { isIntegerType, isNumberType } from "../schema";
 import { RowLayoutContext } from "../row/row-context";
 const { fields: defaultFields } = getDefaultRegistry();
 const BaseSchemaField = defaultFields.SchemaField;
@@ -172,6 +173,7 @@ export class SchemaField extends React.Component {
     }
     render() {
         var _a;
+        const schema = this.props.schema;
         if ((_a = this.props.schema.lime) === null || _a === void 0 ? void 0 : _a.hidden) {
             return null;
         }
@@ -182,6 +184,12 @@ export class SchemaField extends React.Component {
         if (this.props.schema.format === 'time') {
             fieldProps.uiSchema = Object.assign({ 'ui:widget': TimePicker }, fieldProps.uiSchema);
         }
+        // Our text widget renders a native `<input type="number">` for numeric
+        // schemas. `@rjsf/core` otherwise rewrites the value to the locale's
+        // decimal separator, which such an input cannot display.
+        if (isNumberType(schema) || isIntegerType(schema)) {
+            fieldProps.uiSchema = Object.assign({ 'ui:inputType': 'number' }, fieldProps.uiSchema);
+        }
         return React.createElement(BaseSchemaField, fieldProps);
     }
 }

package/dist/collection/components/form/form.js

@@ -112,6 +112,7 @@ export class Form {
             // `default` values, matching the pre-v6 behavior.
             experimental_defaultFormStateBehavior: {
                 constAsDefaults: 'skipOneOf',
+                requiredBooleanDefault: 'skip',
             },
             showErrorList: false,
             extraErrors: this.getExtraErrors(this.errors),

package/dist/collection/components/form/form.test-schemas.js

@@ -601,3 +601,50 @@ export const nestedLayoutSchemaPathSchema = {
         },
     },
 };
+export const getConditionalCustomComponentSchema = (value) => ({
+    type: 'object',
+    properties: Object.assign({ trigger: { type: 'string', title: 'Trigger' } }, ((value === null || value === void 0 ? void 0 : value.trigger) === 'show'
+        ? {
+            color: {
+                type: 'string',
+                title: 'Color',
+                default: 'rgb(0, 0, 0)',
+                lime: { component: { name: 'limel-color-picker' } },
+            },
+        }
+        : {})),
+});
+export const arrayItemWithEnumAndDefaultSchema = {
+    type: 'object',
+    properties: {
+        entries: {
+            type: 'array',
+            title: 'Entries',
+            items: {
+                type: 'object',
+                properties: {
+                    mode: {
+                        type: 'string',
+                        title: 'Mode',
+                        oneOf: [
+                            { const: 'a', title: 'A', type: 'string' },
+                            { const: 'b', title: 'B', type: 'string' },
+                        ],
+                    },
+                    plain: {
+                        type: 'string',
+                        title: 'Plain',
+                        default: 'preset',
+                    },
+                },
+            },
+        },
+    },
+};
+export const requiredCheckboxSchema = {
+    type: 'object',
+    properties: {
+        accept: { type: 'boolean', title: 'I accept the terms' },
+    },
+    required: ['accept'],
+};

package/dist/collection/components/form/templates/array-field-collapsible-item.js

@@ -1,6 +1,8 @@
 import React from "react";
 import { findTitle, hasNestedErrors } from "./common";
-import { isEmpty } from "lodash-es";
+import { getDefaultFormState, } from "@rjsf/utils";
+import { isEmpty, isEqual } from "lodash-es";
+import { rjsfValidator } from "../validator";
 export class CollapsibleItemTemplate extends React.Component {
     constructor(props) {
         super(props);
@@ -14,9 +16,8 @@ export class CollapsibleItemTemplate extends React.Component {
             });
         };
         this.handleAction = this.handleAction.bind(this);
-        this.isDeepEmpty = this.isDeepEmpty.bind(this);
         this.state = {
-            isOpen: this.isDeepEmpty(props.data),
+            isOpen: isNewItem(props),
         };
     }
     componentDidMount() {
@@ -77,13 +78,39 @@ export class CollapsibleItemTemplate extends React.Component {
         event.stopPropagation();
         event.detail.run(event);
     }
-    isDeepEmpty(data) {
-        if (typeof data !== 'object') {
-            return false;
-        }
-        if (isEmpty(data)) {
-            return true;
-        }
-        return Object.values(data).every(this.isDeepEmpty);
+}
+/**
+ * An item counts as new while it holds nothing the user entered. Since
+ * `@rjsf/core` 6.10 fills a required property with its default as soon as the
+ * item exists, "nothing entered" means empty data *or* data equal to what the
+ * schema produces on its own.
+ *
+ * @param props - the props of the item being rendered
+ */
+function isNewItem(props) {
+    if (isDeepEmpty(props.data)) {
+        return true;
+    }
+    return isEqual(props.data, getItemDefaults(props));
+}
+function getItemDefaults(props) {
+    var _a, _b;
+    const items = (_a = props.schema) === null || _a === void 0 ? void 0 : _a.items;
+    const itemSchema = (Array.isArray(items) ? items[props.index] : items);
+    if (!itemSchema) {
+        return;
+    }
+    // Must match the `experimental_defaultFormStateBehavior` that `limel-form`
+    // passes to `@rjsf/core`. Computing defaults under different options gives
+    // data the form never writes, and the comparison above then fails.
+    return getDefaultFormState(rjsfValidator, itemSchema, undefined, ((_b = props.formSchema) !== null && _b !== void 0 ? _b : itemSchema), false, { constAsDefaults: 'skipOneOf', requiredBooleanDefault: 'skip' });
+}
+function isDeepEmpty(data) {
+    if (typeof data !== 'object') {
+        return false;
+    }
+    if (isEmpty(data)) {
+        return true;
     }
+    return Object.values(data).every(isDeepEmpty);
 }

package/dist/collection/components/markdown/markdown-exporter.js

@@ -0,0 +1,186 @@
+import { fromDom } from "hast-util-from-dom";
+import { defaultHandlers } from "hast-util-to-mdast";
+import { defaultHandlers as defaultMarkdownHandlers, } from "mdast-util-to-markdown";
+import rehypeRemark from "rehype-remark";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+/**
+ * Convert rendered markdown content back to markdown, replacing each
+ * whitelisted custom element with the markdown it describes itself as.
+ *
+ * Elements that do not implement {@link MarkdownDescribable} are
+ * converted like any unknown element: their light DOM children are kept,
+ * and an element without children disappears.
+ *
+ * @param container - The element holding the rendered content.
+ * @param whitelist - The custom elements allowed in the content.
+ * @returns The content as GitHub Flavored Markdown.
+ */
+export async function exportMarkdown(container, whitelist) {
+    const tagNames = new Set(whitelist
+        .map((definition) => definition.tagName)
+        .filter(isDescribableTag));
+    // The tree is captured before any description is awaited, so that
+    // content rendered in the meantime cannot end up in the export without
+    // its description.
+    const describableElements = new Map();
+    const tree = fromDom(container, {
+        afterTransform: (domNode, hastNode) => {
+            if (hastNode.type !== 'element') {
+                return;
+            }
+            restoreDeferredImage(hastNode);
+            hideFootnoteBackReference(hastNode);
+            if (domNode instanceof Element && tagNames.has(domNode.localName)) {
+                describableElements.set(hastNode, domNode);
+            }
+        },
+    });
+    await describeElements(describableElements);
+    const handlers = {
+        sup: handleSup,
+        section: handleSection,
+    };
+    for (const tagName of tagNames) {
+        handlers[tagName] = handleCustomElement;
+    }
+    const processor = unified()
+        .use(rehypeRemark, { handlers })
+        .use(remarkGfm)
+        .use(remarkStringify, {
+        bullet: '-',
+        handlers: { break: handleBreak },
+    });
+    const mdast = await processor.run({
+        type: 'root',
+        children: tree.children,
+    });
+    return processor.stringify(mdast).trimEnd();
+}
+/**
+ * The description is kept on the node itself, since `rehype-remark`
+ * works on a clone of the tree. It also becomes the node's only child, so
+ * that whitespace minification treats the element as content and keeps
+ * the spaces around it. An element whose description fails is converted
+ * as if it did not describe itself.
+ * @param elements
+ */
+async function describeElements(elements) {
+    await Promise.all([...elements].map(async ([node, element]) => {
+        try {
+            const description = await element.toMarkdown();
+            node.properties.dataMarkdownDescription = description;
+            node.children = [{ type: 'text', value: description }];
+        }
+        catch (error) {
+            console.error('Failed to describe element as markdown', error);
+        }
+    }));
+}
+const handleCustomElement = (state, node) => {
+    const description = node.properties.dataMarkdownDescription;
+    if (typeof description === 'string') {
+        return parseMarkdown(description);
+    }
+    return state.all(node);
+};
+/**
+ * Write hard line breaks as two trailing spaces rather than a backslash,
+ * since the export is also read as plain text, where the spaces are
+ * invisible.
+ * @param args
+ */
+const handleBreak = (...args) => {
+    const markdown = defaultMarkdownHandlers.break(...args);
+    return markdown === '\\\n' ? '  \n' : markdown;
+};
+/**
+ * Parse a description into mdast nodes. A description that is a single
+ * paragraph gives phrasing content, so that an element inside a
+ * paragraph or list item stays inline.
+ * @param markdown
+ */
+function parseMarkdown(markdown) {
+    const { children } = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .parse(markdown);
+    if (children.length === 1 && children[0].type === 'paragraph') {
+        return children[0].children;
+    }
+    return children;
+}
+/**
+ * An image that has not been scrolled into view yet keeps its URL in
+ * `data-src`, until the lazy loading moves it to `src`.
+ * @param node
+ */
+function restoreDeferredImage(node) {
+    const deferredSrc = node.properties.dataSrc;
+    if (node.tagName === 'img' && !node.properties.src && deferredSrc) {
+        node.properties.src = deferredSrc;
+    }
+}
+/**
+ * The links from a footnote back to its references are recreated when the
+ * markdown is rendered again.
+ * @param node
+ */
+function hideFootnoteBackReference(node) {
+    if (node.tagName === 'a' &&
+        node.properties.dataFootnoteBackref !== undefined) {
+        node.properties.dataMdast = 'ignore';
+    }
+}
+/**
+ * Footnotes are labelled with their rendered numbers. The ids only keep an
+ * encoded, lowercased form of the original labels, which cannot be turned
+ * back into them reliably. A reference shows its footnote's number, and
+ * the definitions are listed in the same order.
+ * @param state
+ * @param node
+ */
+const handleSup = (state, node) => {
+    const link = node.children.find((child) => isElement(child, 'a') &&
+        child.properties.dataFootnoteRef !== undefined);
+    if (!link) {
+        return defaultHandlers.sup(state, node);
+    }
+    const identifier = link.children
+        .map((child) => (child.type === 'text' ? child.value : ''))
+        .join('');
+    return { type: 'footnoteReference', identifier, label: identifier };
+};
+const handleSection = (state, node) => {
+    if (node.properties.dataFootnotes === undefined) {
+        return defaultHandlers.section(state, node);
+    }
+    const list = node.children.find((child) => isElement(child, 'ol'));
+    const items = list === null || list === void 0 ? void 0 : list.children.filter((child) => isElement(child, 'li'));
+    return (items !== null && items !== void 0 ? items : []).map((item, index) => {
+        const identifier = String(index + 1);
+        return {
+            type: 'footnoteDefinition',
+            identifier,
+            label: identifier,
+            children: state.toFlow(state.all(item)),
+        };
+    });
+};
+function isElement(node, tagName) {
+    return node.type === 'element' && node.tagName === tagName;
+}
+/**
+ * Whether the custom element registered for the tag implements
+ * {@link MarkdownDescribable}. Stencil defines a component's methods on
+ * the element's prototype when the tag is registered, before the
+ * component itself has loaded.
+ * @param tagName
+ */
+function isDescribableTag(tagName) {
+    var _a;
+    const prototype = (_a = customElements.get(tagName)) === null || _a === void 0 ? void 0 : _a.prototype;
+    return typeof (prototype === null || prototype === void 0 ? void 0 : prototype.toMarkdown) === 'function';
+}

package/dist/collection/components/markdown/markdown-parser.js

@@ -2,6 +2,7 @@ import { unified } from "unified";
 import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import remarkGfm from "remark-gfm";
+import remarkBreaks from "remark-breaks";
 import rehypeParse from "rehype-parse";
 import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
 import rehypeStringify from "rehype-stringify";
@@ -27,12 +28,10 @@ import { createRemoveEmptyParagraphsPlugin } from "./remove-empty-paragraphs-plu
  */
 export async function markdownToHTML(text, options) {
     var _a;
-    if (options === null || options === void 0 ? void 0 : options.forceHardLineBreaks) {
-        text = text.replaceAll(/(?<!\\)([\n\r])/g, '  $1');
-    }
     const file = await unified()
         .use(remarkParse)
         .use(remarkGfm)
+        .use((options === null || options === void 0 ? void 0 : options.forceHardLineBreaks) ? [remarkBreaks] : [])
         .use(remarkRehype, { allowDangerousHtml: true })
         .use(rehypeRaw)
         .use(createLinksPlugin())

package/dist/collection/components/markdown/markdown.js

@@ -39,6 +39,7 @@ import { adaptColorContrast } from "../../util/adapt-color-contrast";
  * @exampleComponent limel-example-markdown-custom-component-with-json-props
  * @exampleComponent limel-example-markdown-remove-empty-paragraphs
  * @exampleComponent limel-example-markdown-adapt-color-contrast
+ * @exampleComponent limel-example-markdown-to-markdown
  * @exampleComponent limel-example-markdown-composite
  */
 export class Markdown {
@@ -97,7 +98,31 @@ export class Markdown {
         this.adaptColorContrast = false;
         this.imageIntersectionObserver = null;
     }
-    async textChanged() {
+    /**
+     * Returns the content as markdown, with every whitelisted custom
+     * element replaced by the markdown it describes itself as.
+     *
+     * Use this to hand the content to a target that cannot render custom
+     * elements, such as the clipboard. An element describes itself by
+     * implementing `MarkdownDescribable`; elements that do not keep
+     * their child content, or are removed if they have none.
+     *
+     * The markdown is generated from the rendered content, so it may be
+     * formatted differently from `value`.
+     *
+     * @alpha
+     * @returns The content as markdown.
+     */
+    async toMarkdown() {
+        await this.rendering;
+        const { exportMarkdown } = await import('./markdown-exporter');
+        return exportMarkdown(this.rootElement, this.cachedCombinedWhitelist);
+    }
+    textChanged() {
+        this.rendering = this.renderMarkdown();
+        return this.rendering;
+    }
+    async renderMarkdown() {
         try {
             this.cleanupImageIntersectionObserver();
             // The whitelist merge and default import live here (not in
@@ -145,7 +170,7 @@ export class Markdown {
         this.cleanupImageIntersectionObserver();
     }
     render() {
-        return (h(Host, { key: 'd10bcceddc2844e43817d406965155f282e21549' }, h("div", { key: '4253c517b72dbd21081e5fe26aaa0e75a91cb7db', id: "markdown", ref: (el) => (this.rootElement = el) })));
+        return (h(Host, { key: '86a21b8636af14891a657e136a9dceae4acb3b23' }, h("div", { key: '5f53c998000e2f197953232a63b2deb8ee1878bf', id: "markdown", ref: (el) => (this.rootElement = el) })));
     }
     setupImageIntersectionObserver() {
         if (this.lazyLoadImages) {
@@ -282,6 +307,33 @@ export class Markdown {
             }
         };
     }
+    static get methods() {
+        return {
+            "toMarkdown": {
+                "complexType": {
+                    "signature": "() => Promise<string>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "Returns the content as markdown, with every whitelisted custom\nelement replaced by the markdown it describes itself as.\n\nUse this to hand the content to a target that cannot render custom\nelements, such as the clipboard. An element describes itself by\nimplementing `MarkdownDescribable`; elements that do not keep\ntheir child content, or are removed if they have none.\n\nThe markdown is generated from the rendered content, so it may be\nformatted differently from `value`.",
+                    "tags": [{
+                            "name": "alpha",
+                            "text": undefined
+                        }, {
+                            "name": "returns",
+                            "text": "The content as markdown."
+                        }]
+                }
+            }
+        };
+    }
     static get watchers() {
         return [{
                 "propName": "value",

package/dist/collection/components/table/table.css

@@ -355,7 +355,6 @@
   display: none;
 }
 .tabulator .tabulator-header .tabulator-frozen-rows-holder {
-  padding-top: 1em;
   display: inline-block;
 }
 .tabulator .tabulator-header .tabulator-frozen-rows-holder:empty {
@@ -412,7 +411,7 @@
 .tabulator .tabulator-tableholder .tabulator-range-overlay {
   position: absolute;
   inset: 0;
-  z-index: 10;
+  z-index: 11;
   pointer-events: none;
 }
 .tabulator .tabulator-tableholder .tabulator-range-overlay .tabulator-range {

package/dist/esm/{_baseEach-lvj-g1Zj.js → _baseForOwn-D5j7fHlv.js}

@@ -1,5 +1,4 @@
-import { k as keys } from './_baseIsEqual-B6bIeexY.js';
-import { i as isArrayLike } from './isArrayLike-CyVGB489.js';
+import { k as keys } from './_baseIsEqual-CyF4P8uM.js';
 
 /**
  * Creates a base function for methods like `_.forIn` and `_.forOwn`.
@@ -50,43 +49,4 @@ function baseForOwn(object, iteratee) {
   return object && baseFor(object, iteratee, keys);
 }
 
-/**
- * Creates a `baseEach` or `baseEachRight` function.
- *
- * @private
- * @param {Function} eachFunc The function to iterate over a collection.
- * @param {boolean} [fromRight] Specify iterating from right to left.
- * @returns {Function} Returns the new base function.
- */
-function createBaseEach(eachFunc, fromRight) {
-  return function(collection, iteratee) {
-    if (collection == null) {
-      return collection;
-    }
-    if (!isArrayLike(collection)) {
-      return eachFunc(collection, iteratee);
-    }
-    var length = collection.length,
-        index = -1,
-        iterable = Object(collection);
-
-    while ((++index < length)) {
-      if (iteratee(iterable[index], index, iterable) === false) {
-        break;
-      }
-    }
-    return collection;
-  };
-}
-
-/**
- * The base implementation of `_.forEach` without support for iteratee shorthands.
- *
- * @private
- * @param {Array|Object} collection The collection to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Array|Object} Returns `collection`.
- */
-var baseEach = createBaseEach(baseForOwn);
-
-export { baseEach as a, baseFor as b, baseForOwn as c };
+export { baseForOwn as b };

package/dist/esm/{_baseIsEqual-B6bIeexY.js → _baseIsEqual-CyF4P8uM.js}

@@ -1,5 +1,5 @@
 import { e as eq } from './eq-CZ30nDJE.js';
-import { b as isArguments, i as isBuffer, a as isTypedArray, c as baseKeys, M as Map, g as getTag } from './_getTag-CMJL-6hk.js';
+import { i as isArguments, a as isBuffer, b as isTypedArray, c as baseKeys, M as Map, g as getTag } from './_getTag-BiAaLWvH.js';
 import { g as getNative } from './_getNative-COawFdVX.js';
 import { r as root, S as Symbol } from './isObject-BJQylLSL.js';
 import { i as isArray } from './isArray-B8VKuhvH.js';
@@ -1203,4 +1203,4 @@ function baseIsEqual(value, other, bitmask, customizer, stack) {
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
 }
 
-export { MapCache as M, Stack as S, Uint8Array as U, SetCache as a, baseTimes as b, cacheHas as c, baseIsEqual as d, getAllKeys as e, arrayPush as f, getSymbols as g, arrayLikeKeys as h, stubArray as i, baseGetAllKeys as j, keys as k, setToArray as s };
+export { MapCache as M, SetCache as S, Uint8Array as U, Stack as a, baseIsEqual as b, cacheHas as c, arrayPush as d, arrayLikeKeys as e, stubArray as f, getAllKeys as g, getSymbols as h, baseGetAllKeys as i, keys as k, setToArray as s };

package/dist/esm/{_baseIteratee-CEZRuq23.js → _baseIteratee-CpbczHY1.js}

@@ -1,8 +1,8 @@
-import { M as MapCache, S as Stack, d as baseIsEqual, k as keys } from './_baseIsEqual-B6bIeexY.js';
+import { M as MapCache, a as Stack, b as baseIsEqual, k as keys } from './_baseIsEqual-CyF4P8uM.js';
 import { S as Symbol, i as isObject } from './isObject-BJQylLSL.js';
 import { i as isArray } from './isArray-B8VKuhvH.js';
 import { i as isSymbol } from './isSymbol-ClAke5ga.js';
-import { b as isArguments } from './_getTag-CMJL-6hk.js';
+import { i as isArguments } from './_getTag-BiAaLWvH.js';
 import { i as isIndex } from './_isIndex-B--C3qwe.js';
 import { a as isLength } from './isArrayLike-CyVGB489.js';
 import { i as identity } from './identity-CK4jS9_E.js';
@@ -598,4 +598,4 @@ function baseIteratee(value) {
   return property(value);
 }
 
-export { arrayMap as a, baseGet as b, baseIteratee as c, castPath as d, toKey as e, hasPath as f, get as g, hasIn as h, stringToPath as s, toString as t };
+export { toKey as a, baseIteratee as b, castPath as c, baseGet as d, arrayMap as e, get as g, hasPath as h, toString as t };

package/dist/esm/_baseSet-Cw2IE6ZF.js

@@ -0,0 +1,89 @@
+import { a as assignValue } from './_assignValue-CEFvyZxO.js';
+import { c as castPath, a as toKey } from './_baseIteratee-CpbczHY1.js';
+import { i as isIndex } from './_isIndex-B--C3qwe.js';
+import { i as isObject } from './isObject-BJQylLSL.js';
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that negates the result of the predicate `func`. The
+ * `func` predicate is invoked with the `this` binding and arguments of the
+ * created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} predicate The predicate to negate.
+ * @returns {Function} Returns the new negated function.
+ * @example
+ *
+ * function isEven(n) {
+ *   return n % 2 == 0;
+ * }
+ *
+ * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
+ * // => [1, 3, 5]
+ */
+function negate(predicate) {
+  if (typeof predicate != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  return function() {
+    var args = arguments;
+    switch (args.length) {
+      case 0: return !predicate.call(this);
+      case 1: return !predicate.call(this, args[0]);
+      case 2: return !predicate.call(this, args[0], args[1]);
+      case 3: return !predicate.call(this, args[0], args[1], args[2]);
+    }
+    return !predicate.apply(this, args);
+  };
+}
+
+/**
+ * The base implementation of `_.set`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+function baseSet(object, path, value, customizer) {
+  if (!isObject(object)) {
+    return object;
+  }
+  path = castPath(path, object);
+
+  var index = -1,
+      length = path.length,
+      lastIndex = length - 1,
+      nested = object;
+
+  while (nested != null && ++index < length) {
+    var key = toKey(path[index]),
+        newValue = value;
+
+    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+      return object;
+    }
+
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = undefined;
+      if (newValue === undefined) {
+        newValue = isObject(objValue)
+          ? objValue
+          : (isIndex(path[index + 1]) ? [] : {});
+      }
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+
+export { baseSet as b, negate as n };

package/dist/esm/_getPrototype-B0kMNv1F.js

@@ -0,0 +1,6 @@
+import { o as overArg } from './_getTag-BiAaLWvH.js';
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+export { getPrototype as g };

package/dist/esm/{_getTag-CMJL-6hk.js → _getTag-BiAaLWvH.js}

@@ -341,4 +341,4 @@ if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
   };
 }
 
-export { Map as M, Set as S, isTypedArray as a, isArguments as b, baseKeys as c, isPrototype as d, baseUnary as e, getTag as g, isBuffer as i, nodeUtil as n, overArg as o };
+export { Map as M, Set as S, isBuffer as a, isTypedArray as b, baseKeys as c, isPrototype as d, baseUnary as e, getTag as g, isArguments as i, nodeUtil as n, overArg as o };