storybook 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/_browser-chunks/chunk-G33S6YM3.js

@@ -0,0 +1,521 @@
+import {
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs
+function isSymbol(value) {
+  return typeof value === "symbol" || value instanceof Symbol;
+}
+__name(isSymbol, "isSymbol");
+
+// ../node_modules/es-toolkit/dist/compat/util/toNumber.mjs
+function toNumber(value) {
+  if (isSymbol(value)) {
+    return NaN;
+  }
+  return Number(value);
+}
+__name(toNumber, "toNumber");
+
+// ../node_modules/es-toolkit/dist/compat/util/toFinite.mjs
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === Infinity || value === -Infinity) {
+    const sign = value < 0 ? -1 : 1;
+    return sign * Number.MAX_VALUE;
+  }
+  return value === value ? value : 0;
+}
+__name(toFinite, "toFinite");
+
+// ../node_modules/es-toolkit/dist/compat/util/toInteger.mjs
+function toInteger(value) {
+  const finite = toFinite(value);
+  const remainder = finite % 1;
+  return remainder ? finite - remainder : finite;
+}
+__name(toInteger, "toInteger");
+
+// ../node_modules/es-toolkit/dist/array/chunk.mjs
+function chunk(arr, size) {
+  if (!Number.isInteger(size) || size <= 0) {
+    throw new Error("Size must be an integer greater than zero.");
+  }
+  const chunkLength = Math.ceil(arr.length / size);
+  const result = Array(chunkLength);
+  for (let index = 0; index < chunkLength; index++) {
+    const start = index * size;
+    const end = start + size;
+    result[index] = arr.slice(start, end);
+  }
+  return result;
+}
+__name(chunk, "chunk");
+
+// ../node_modules/es-toolkit/dist/array/compact.mjs
+function compact(arr) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(compact, "compact");
+
+// ../node_modules/es-toolkit/dist/array/flatten.mjs
+function flatten(arr, depth = 1) {
+  const result = [];
+  const flooredDepth = Math.floor(depth);
+  const recursive = /* @__PURE__ */ __name((arr2, currentDepth) => {
+    for (let i = 0; i < arr2.length; i++) {
+      const item = arr2[i];
+      if (Array.isArray(item) && currentDepth < flooredDepth) {
+        recursive(item, currentDepth + 1);
+      } else {
+        result.push(item);
+      }
+    }
+  }, "recursive");
+  recursive(arr, 0);
+  return result;
+}
+__name(flatten, "flatten");
+
+// ../node_modules/es-toolkit/dist/array/difference.mjs
+function difference(firstArr, secondArr) {
+  const secondSet = new Set(secondArr);
+  return firstArr.filter((item) => !secondSet.has(item));
+}
+__name(difference, "difference");
+
+// ../node_modules/es-toolkit/dist/array/last.mjs
+function last(arr) {
+  return arr[arr.length - 1];
+}
+__name(last, "last");
+
+// ../node_modules/es-toolkit/dist/array/differenceBy.mjs
+function differenceBy(firstArr, secondArr, mapper) {
+  const mappedSecondSet = new Set(secondArr.map((item) => mapper(item)));
+  return firstArr.filter((item) => {
+    return !mappedSecondSet.has(mapper(item));
+  });
+}
+__name(differenceBy, "differenceBy");
+
+// ../node_modules/es-toolkit/dist/array/differenceWith.mjs
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter((firstItem) => {
+    return secondArr.every((secondItem) => {
+      return !areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
+__name(differenceWith, "differenceWith");
+
+// ../node_modules/es-toolkit/dist/array/drop.mjs
+function drop(arr, itemsCount) {
+  itemsCount = Math.max(itemsCount, 0);
+  return arr.slice(itemsCount);
+}
+__name(drop, "drop");
+
+// ../node_modules/es-toolkit/dist/array/dropRight.mjs
+function dropRight(arr, itemsCount) {
+  itemsCount = Math.min(-itemsCount, 0);
+  if (itemsCount === 0) {
+    return arr.slice();
+  }
+  return arr.slice(0, itemsCount);
+}
+__name(dropRight, "dropRight");
+
+// ../node_modules/es-toolkit/dist/array/dropRightWhile.mjs
+function dropRightWhile(arr, canContinueDropping) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!canContinueDropping(arr[i], i, arr)) {
+      return arr.slice(0, i + 1);
+    }
+  }
+  return [];
+}
+__name(dropRightWhile, "dropRightWhile");
+
+// ../node_modules/es-toolkit/dist/array/dropWhile.mjs
+function dropWhile(arr, canContinueDropping) {
+  const dropEndIndex = arr.findIndex((item, index, arr2) => !canContinueDropping(item, index, arr2));
+  if (dropEndIndex === -1) {
+    return [];
+  }
+  return arr.slice(dropEndIndex);
+}
+__name(dropWhile, "dropWhile");
+
+// ../node_modules/es-toolkit/dist/array/fill.mjs
+function fill(array, value, start = 0, end = array.length) {
+  const length = array.length;
+  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+  for (let i = finalStart; i < finalEnd; i++) {
+    array[i] = value;
+  }
+  return array;
+}
+__name(fill, "fill");
+
+// ../node_modules/es-toolkit/dist/array/head.mjs
+function head(arr) {
+  return arr[0];
+}
+__name(head, "head");
+
+// ../node_modules/es-toolkit/dist/array/groupBy.mjs
+function groupBy(arr, getKeyFromItem) {
+  const result = {};
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    const key = getKeyFromItem(item);
+    if (!Object.hasOwn(result, key)) {
+      result[key] = [];
+    }
+    result[key].push(item);
+  }
+  return result;
+}
+__name(groupBy, "groupBy");
+
+// ../node_modules/es-toolkit/dist/array/initial.mjs
+function initial(arr) {
+  return arr.slice(0, -1);
+}
+__name(initial, "initial");
+
+// ../node_modules/es-toolkit/dist/array/intersection.mjs
+function intersection(firstArr, secondArr) {
+  const secondSet = new Set(secondArr);
+  return firstArr.filter((item) => {
+    return secondSet.has(item);
+  });
+}
+__name(intersection, "intersection");
+
+// ../node_modules/es-toolkit/dist/array/uniq.mjs
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+__name(uniq, "uniq");
+
+// ../node_modules/es-toolkit/dist/array/intersectionBy.mjs
+function intersectionBy(firstArr, secondArr, mapper) {
+  const mappedSecondSet = new Set(secondArr.map(mapper));
+  return firstArr.filter((item) => mappedSecondSet.has(mapper(item)));
+}
+__name(intersectionBy, "intersectionBy");
+
+// ../node_modules/es-toolkit/dist/array/intersectionWith.mjs
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter((firstItem) => {
+    return secondArr.some((secondItem) => {
+      return areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
+__name(intersectionWith, "intersectionWith");
+
+// ../node_modules/es-toolkit/dist/array/pull.mjs
+function pull(arr, valuesToRemove) {
+  const valuesSet = new Set(valuesToRemove);
+  let resultIndex = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (valuesSet.has(arr[i])) {
+      continue;
+    }
+    if (!Object.hasOwn(arr, i)) {
+      delete arr[resultIndex++];
+      continue;
+    }
+    arr[resultIndex++] = arr[i];
+  }
+  arr.length = resultIndex;
+  return arr;
+}
+__name(pull, "pull");
+
+// ../node_modules/es-toolkit/dist/array/remove.mjs
+function remove(arr, shouldRemoveElement) {
+  const originalArr = arr.slice();
+  const removed = [];
+  let resultIndex = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (shouldRemoveElement(arr[i], i, originalArr)) {
+      removed.push(arr[i]);
+      continue;
+    }
+    if (!Object.hasOwn(arr, i)) {
+      delete arr[resultIndex++];
+      continue;
+    }
+    arr[resultIndex++] = arr[i];
+  }
+  arr.length = resultIndex;
+  return removed;
+}
+__name(remove, "remove");
+
+// ../node_modules/es-toolkit/dist/array/sample.mjs
+function sample(arr) {
+  const randomIndex = Math.floor(Math.random() * arr.length);
+  return arr[randomIndex];
+}
+__name(sample, "sample");
+
+// ../node_modules/es-toolkit/dist/math/random.mjs
+function random(minimum, maximum) {
+  if (maximum == null) {
+    maximum = minimum;
+    minimum = 0;
+  }
+  if (minimum >= maximum) {
+    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
+  }
+  return Math.random() * (maximum - minimum) + minimum;
+}
+__name(random, "random");
+
+// ../node_modules/es-toolkit/dist/math/randomInt.mjs
+function randomInt(minimum, maximum) {
+  return Math.floor(random(minimum, maximum));
+}
+__name(randomInt, "randomInt");
+
+// ../node_modules/es-toolkit/dist/array/sampleSize.mjs
+function sampleSize(array, size) {
+  if (size > array.length) {
+    throw new Error("Size must be less than or equal to the length of array.");
+  }
+  const result = new Array(size);
+  const selected = /* @__PURE__ */ new Set();
+  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
+    let index = randomInt(0, step + 1);
+    if (selected.has(index)) {
+      index = step;
+    }
+    selected.add(index);
+    result[resultIndex] = array[index];
+  }
+  return result;
+}
+__name(sampleSize, "sampleSize");
+
+// ../node_modules/es-toolkit/dist/array/shuffle.mjs
+function shuffle(arr) {
+  const result = arr.slice();
+  for (let i = result.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+__name(shuffle, "shuffle");
+
+// ../node_modules/es-toolkit/dist/array/tail.mjs
+function tail(arr) {
+  return arr.slice(1);
+}
+__name(tail, "tail");
+
+// ../node_modules/es-toolkit/dist/array/take.mjs
+function take(arr, count, guard) {
+  count = guard || count === void 0 ? 1 : toInteger(count);
+  return arr.slice(0, count);
+}
+__name(take, "take");
+
+// ../node_modules/es-toolkit/dist/array/takeRight.mjs
+function takeRight(arr, count = 1, guard) {
+  count = guard || count === void 0 ? 1 : toInteger(count);
+  if (count <= 0 || arr == null || arr.length === 0) {
+    return [];
+  }
+  return arr.slice(-count);
+}
+__name(takeRight, "takeRight");
+
+// ../node_modules/es-toolkit/dist/array/uniqBy.mjs
+function uniqBy(arr, mapper) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    const key = mapper(item);
+    if (!map.has(key)) {
+      map.set(key, item);
+    }
+  }
+  return Array.from(map.values());
+}
+__name(uniqBy, "uniqBy");
+
+// ../node_modules/es-toolkit/dist/array/uniqWith.mjs
+function uniqWith(arr, areItemsEqual) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    const isUniq = result.every((v) => !areItemsEqual(v, item));
+    if (isUniq) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(uniqWith, "uniqWith");
+
+// ../node_modules/es-toolkit/dist/array/unzip.mjs
+function unzip(zipped) {
+  let maxLen = 0;
+  for (let i = 0; i < zipped.length; i++) {
+    if (zipped[i].length > maxLen) {
+      maxLen = zipped[i].length;
+    }
+  }
+  const result = new Array(maxLen);
+  for (let i = 0; i < maxLen; i++) {
+    result[i] = new Array(zipped.length);
+    for (let j = 0; j < zipped.length; j++) {
+      result[i][j] = zipped[j][i];
+    }
+  }
+  return result;
+}
+__name(unzip, "unzip");
+
+// ../node_modules/es-toolkit/dist/array/without.mjs
+function without(array, ...values) {
+  return difference(array, values);
+}
+__name(without, "without");
+
+// ../node_modules/es-toolkit/dist/array/windowed.mjs
+function windowed(arr, size, step = 1, { partialWindows = false } = {}) {
+  if (size <= 0 || !Number.isInteger(size)) {
+    throw new Error("Size must be a positive integer.");
+  }
+  if (step <= 0 || !Number.isInteger(step)) {
+    throw new Error("Step must be a positive integer.");
+  }
+  const result = [];
+  const end = partialWindows ? arr.length : arr.length - size + 1;
+  for (let i = 0; i < end; i += step) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+__name(windowed, "windowed");
+
+// ../node_modules/es-toolkit/dist/array/zip.mjs
+function zip(...arrs) {
+  let rowCount = 0;
+  for (let i = 0; i < arrs.length; i++) {
+    if (arrs[i].length > rowCount) {
+      rowCount = arrs[i].length;
+    }
+  }
+  const columnCount = arrs.length;
+  const result = Array(rowCount);
+  for (let i = 0; i < rowCount; ++i) {
+    const row = Array(columnCount);
+    for (let j = 0; j < columnCount; ++j) {
+      row[j] = arrs[j][i];
+    }
+    result[i] = row;
+  }
+  return result;
+}
+__name(zip, "zip");
+
+// ../node_modules/es-toolkit/dist/array/maxBy.mjs
+function maxBy(items, getValue) {
+  if (items.length === 0) {
+    return void 0;
+  }
+  let maxElement = items[0];
+  let max = getValue(maxElement);
+  for (let i = 1; i < items.length; i++) {
+    const element = items[i];
+    const value = getValue(element);
+    if (value > max) {
+      max = value;
+      maxElement = element;
+    }
+  }
+  return maxElement;
+}
+__name(maxBy, "maxBy");
+
+// ../node_modules/es-toolkit/dist/array/minBy.mjs
+function minBy(items, getValue) {
+  if (items.length === 0) {
+    return void 0;
+  }
+  let minElement = items[0];
+  let min = getValue(minElement);
+  for (let i = 1; i < items.length; i++) {
+    const element = items[i];
+    const value = getValue(element);
+    if (value < min) {
+      min = value;
+      minElement = element;
+    }
+  }
+  return minElement;
+}
+__name(minBy, "minBy");
+
+export {
+  chunk,
+  compact,
+  flatten,
+  difference,
+  last,
+  differenceBy,
+  differenceWith,
+  drop,
+  isSymbol,
+  toNumber,
+  toFinite,
+  toInteger,
+  dropRight,
+  dropRightWhile,
+  dropWhile,
+  fill,
+  head,
+  groupBy,
+  initial,
+  intersection,
+  uniq,
+  intersectionBy,
+  intersectionWith,
+  pull,
+  remove,
+  sample,
+  random,
+  randomInt,
+  sampleSize,
+  shuffle,
+  tail,
+  take,
+  takeRight,
+  uniqBy,
+  uniqWith,
+  unzip,
+  without,
+  windowed,
+  zip,
+  maxBy,
+  minBy
+};

package/dist/_browser-chunks/chunk-GJ67EE65.js

@@ -0,0 +1,67 @@
+import {
+  _objectWithoutPropertiesLoose
+} from "./chunk-VAMFPZY3.js";
+import {
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../node_modules/@babel/runtime/helpers/esm/typeof.js
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+__name(_typeof, "_typeof");
+
+// ../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+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);
+}
+__name(toPrimitive, "toPrimitive");
+
+// ../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+__name(toPropertyKey, "toPropertyKey");
+
+// ../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+__name(_defineProperty, "_defineProperty");
+
+// ../node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o, r, i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+__name(_objectWithoutProperties, "_objectWithoutProperties");
+
+export {
+  _objectWithoutProperties,
+  _typeof,
+  toPropertyKey,
+  _defineProperty
+};