renovate-log-parser 0.1.0 → 0.1.2

package/web/.output/server/node_modules/@floating-ui/dom/package.json

@@ -1,72 +0,0 @@
-{
-  "name": "@floating-ui/dom",
-  "version": "1.8.0",
-  "description": "Floating UI for the web",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./dist/floating-ui.dom.umd.js",
-  "module": "./dist/floating-ui.dom.esm.js",
-  "unpkg": "./dist/floating-ui.dom.umd.min.js",
-  "types": "./dist/floating-ui.dom.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "types": "./dist/floating-ui.dom.d.mts",
-        "default": "./dist/floating-ui.dom.mjs"
-      },
-      "types": "./dist/floating-ui.dom.d.ts",
-      "module": "./dist/floating-ui.dom.esm.js",
-      "default": "./dist/floating-ui.dom.umd.js"
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "dist"
-  ],
-  "author": "atomiks",
-  "license": "MIT",
-  "bugs": "https://github.com/floating-ui/floating-ui",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/floating-ui/floating-ui.git",
-    "directory": "packages/dom"
-  },
-  "homepage": "https://floating-ui.com",
-  "keywords": [
-    "tooltip",
-    "popover",
-    "dropdown",
-    "menu",
-    "popup",
-    "positioning"
-  ],
-  "dependencies": {
-    "@floating-ui/core": "^1.8.0",
-    "@floating-ui/utils": "^0.2.12"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.19",
-    "@types/react-dom": "^18.3.1",
-    "@vitejs/plugin-react": "^4.3.4",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-router-dom": "^6.21.1",
-    "config": "0.0.0"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --ignore-path ../../.gitignore --write .",
-    "clean": "rimraf dist out-tsc test-results",
-    "dev": "vite",
-    "build": "rollup -c",
-    "build:api": "build-api --tsc tsconfig.lib.json",
-    "test": "vitest run",
-    "test:watch": "vitest watch",
-    "test:browser": "TEST_ENV=browser vitest --browser",
-    "publint": "publint",
-    "playwright": "playwright test ./test/functional",
-    "typecheck": "tsc -b"
-  }
-}

package/web/.output/server/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs

@@ -1,165 +0,0 @@
-function hasWindow() {
-  return typeof window !== 'undefined';
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || '').toLowerCase();
-  }
-  // Mocked nodes in testing environments may not be instances of Node. By
-  // returning `#document` an infinite loop won't occur.
-  // https://github.com/floating-ui/floating-ui/issues/2317
-  return '#document';
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== 'inline' && display !== 'contents';
-}
-function isTableElement(element) {
-  return /^(table|td|th)$/.test(getNodeName(element));
-}
-function isTopLayer(element) {
-  try {
-    if (element.matches(':popover-open')) {
-      return true;
-    }
-  } catch (_e) {
-    // no-op
-  }
-  try {
-    return element.matches(':modal');
-  } catch (_e) {
-    return false;
-  }
-}
-const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
-const containRe = /paint|layout|strict|content/;
-const isNotNone = value => !!value && value !== 'none';
-let isWebKitValue;
-function isContainingBlock(elementOrCss) {
-  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (isWebKitValue == null) {
-    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
-  }
-  return isWebKitValue;
-}
-function isLastTraversableNode(node) {
-  return /^(html|body|#document)$/.test(getNodeName(node));
-}
-function getComputedStyle(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return (node.ownerDocument || node).body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    const frameElement = getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-  } else {
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-  }
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-
-export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

package/web/.output/server/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs

@@ -1,136 +0,0 @@
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-
-const sides = ['top', 'right', 'bottom', 'left'];
-const alignments = ['start', 'end'];
-const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = v => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split('-')[0];
-}
-function getAlignment(placement) {
-  return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-  return axis === 'y' ? 'height' : 'width';
-}
-function getSideAxis(placement) {
-  const firstChar = placement[0];
-  return firstChar === 't' || firstChar === 'b' ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
-}
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  const side = getSide(placement);
-  return oppositeSideMap[side] + placement.slice(side.length);
-}
-function expandPaddingObject(padding) {
-  var _padding$top, _padding$right, _padding$bottom, _padding$left;
-  return {
-    top: (_padding$top = padding.top) != null ? _padding$top : 0,
-    right: (_padding$right = padding.right) != null ? _padding$right : 0,
-    bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
-    left: (_padding$left = padding.left) != null ? _padding$left : 0
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-
-export { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };

package/web/.output/server/node_modules/@floating-ui/utils/package.json

@@ -1,70 +0,0 @@
-{
-  "name": "@floating-ui/utils",
-  "version": "0.2.12",
-  "description": "Utilities for Floating UI",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./dist/floating-ui.utils.umd.js",
-  "module": "./dist/floating-ui.utils.esm.js",
-  "types": "./dist/floating-ui.utils.d.ts",
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "dom"
-  ],
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "types": "./dist/floating-ui.utils.d.mts",
-        "default": "./dist/floating-ui.utils.mjs"
-      },
-      "types": "./dist/floating-ui.utils.d.ts",
-      "module": "./dist/floating-ui.utils.esm.js",
-      "default": "./dist/floating-ui.utils.umd.js"
-    },
-    "./dom": {
-      "import": {
-        "types": "./dist/floating-ui.utils.dom.d.mts",
-        "default": "./dist/floating-ui.utils.dom.mjs"
-      },
-      "types": "./dist/floating-ui.utils.dom.d.ts",
-      "module": "./dist/floating-ui.utils.dom.esm.js",
-      "default": "./dist/floating-ui.utils.dom.umd.js"
-    }
-  },
-  "author": "atomiks",
-  "license": "MIT",
-  "bugs": "https://github.com/floating-ui/floating-ui",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/floating-ui/floating-ui.git",
-    "directory": "packages/utils"
-  },
-  "homepage": "https://floating-ui.com",
-  "keywords": [
-    "tooltip",
-    "popover",
-    "dropdown",
-    "menu",
-    "popup",
-    "positioning"
-  ],
-  "devDependencies": {
-    "@testing-library/jest-dom": "^6.1.6",
-    "config": "0.0.0"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --ignore-path ../../.gitignore --write .",
-    "clean": "rimraf dist out-tsc dom react",
-    "test": "vitest run --globals",
-    "test:watch": "vitest watch --globals",
-    "dev": "rollup -c -w",
-    "build": "rollup -c",
-    "build:api": "build-api --tsc tsconfig.lib.json --aec api-extractor.json --aec api-extractor.dom.json --aec api-extractor.react.json",
-    "publint": "publint",
-    "typecheck": "tsc -b"
-  }
-}

package/web/.output/server/node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs

@@ -1,190 +0,0 @@
-import { arrow as arrow$1, computePosition } from '@floating-ui/dom';
-export { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';
-import { isNode, getNodeName } from '@floating-ui/utils/dom';
-import { unref, computed, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly } from 'vue-demi';
-
-function isComponentPublicInstance(target) {
-  return target != null && typeof target === 'object' && '$el' in target;
-}
-function unwrapElement(target) {
-  if (isComponentPublicInstance(target)) {
-    const element = target.$el;
-    return isNode(element) && getNodeName(element) === '#comment' ? null : element;
-  }
-  return target;
-}
-
-function toValue(source) {
-  return typeof source === 'function' ? source() : unref(source);
-}
-
-/**
- * Positions an inner element of the floating element such that it is centered to the reference element.
- * @param options The arrow options.
- * @see https://floating-ui.com/docs/arrow
- */
-function arrow(options) {
-  return {
-    name: 'arrow',
-    options,
-    fn(args) {
-      const element = unwrapElement(toValue(options.element));
-      if (element == null) {
-        return {};
-      }
-      return arrow$1({
-        element,
-        padding: options.padding
-      }).fn(args);
-    }
-  };
-}
-
-function getDPR(element) {
-  if (typeof window === 'undefined') {
-    return 1;
-  }
-  const win = element.ownerDocument.defaultView || window;
-  return win.devicePixelRatio || 1;
-}
-
-function roundByDPR(element, value) {
-  const dpr = getDPR(element);
-  return Math.round(value * dpr) / dpr;
-}
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
- * @param reference The reference template ref.
- * @param floating The floating template ref.
- * @param options The floating options.
- * @see https://floating-ui.com/docs/vue
- */
-function useFloating(reference, floating, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const whileElementsMountedOption = options.whileElementsMounted;
-  const openOption = computed(() => {
-    var _toValue;
-    return (_toValue = toValue(options.open)) != null ? _toValue : true;
-  });
-  const middlewareOption = computed(() => toValue(options.middleware));
-  const placementOption = computed(() => {
-    var _toValue2;
-    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : 'bottom';
-  });
-  const strategyOption = computed(() => {
-    var _toValue3;
-    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : 'absolute';
-  });
-  const transformOption = computed(() => {
-    var _toValue4;
-    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
-  });
-  const referenceElement = computed(() => unwrapElement(reference.value));
-  const floatingElement = computed(() => unwrapElement(floating.value));
-  const x = ref(0);
-  const y = ref(0);
-  const strategy = ref(strategyOption.value);
-  const placement = ref(placementOption.value);
-  const middlewareData = shallowRef({});
-  const isPositioned = ref(false);
-  const floatingStyles = computed(() => {
-    const initialStyles = {
-      position: strategy.value,
-      left: '0',
-      top: '0'
-    };
-    if (!floatingElement.value) {
-      return initialStyles;
-    }
-    const xVal = roundByDPR(floatingElement.value, x.value);
-    const yVal = roundByDPR(floatingElement.value, y.value);
-    if (transformOption.value) {
-      return {
-        ...initialStyles,
-        transform: "translate(" + xVal + "px, " + yVal + "px)",
-        ...(getDPR(floatingElement.value) >= 1.5 && {
-          willChange: 'transform'
-        })
-      };
-    }
-    return {
-      position: strategy.value,
-      left: xVal + "px",
-      top: yVal + "px"
-    };
-  });
-  let whileElementsMountedCleanup;
-  function update() {
-    if (referenceElement.value == null || floatingElement.value == null) {
-      return;
-    }
-    const open = openOption.value;
-    computePosition(referenceElement.value, floatingElement.value, {
-      middleware: middlewareOption.value,
-      placement: placementOption.value,
-      strategy: strategyOption.value
-    }).then(position => {
-      x.value = position.x;
-      y.value = position.y;
-      strategy.value = position.strategy;
-      placement.value = position.placement;
-      middlewareData.value = position.middlewareData;
-      /**
-       * The floating element's position may be recomputed while it's closed
-       * but still mounted (such as when transitioning out). To ensure
-       * `isPositioned` will be `false` initially on the next open, avoid
-       * setting it to `true` when `open === false` (must be specified).
-       */
-      isPositioned.value = open !== false;
-    });
-  }
-  function cleanup() {
-    if (typeof whileElementsMountedCleanup === 'function') {
-      whileElementsMountedCleanup();
-      whileElementsMountedCleanup = undefined;
-    }
-  }
-  function attach() {
-    cleanup();
-    if (whileElementsMountedOption === undefined) {
-      update();
-      return;
-    }
-    if (referenceElement.value != null && floatingElement.value != null) {
-      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
-      return;
-    }
-  }
-  function reset() {
-    if (!openOption.value) {
-      isPositioned.value = false;
-    }
-  }
-  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
-    flush: 'sync'
-  });
-  watch([referenceElement, floatingElement], attach, {
-    flush: 'sync'
-  });
-  watch(openOption, reset, {
-    flush: 'sync'
-  });
-  if (getCurrentScope()) {
-    onScopeDispose(cleanup);
-  }
-  return {
-    x: shallowReadonly(x),
-    y: shallowReadonly(y),
-    strategy: shallowReadonly(strategy),
-    placement: shallowReadonly(placement),
-    middlewareData: shallowReadonly(middlewareData),
-    isPositioned: shallowReadonly(isPositioned),
-    floatingStyles,
-    update
-  };
-}
-
-export { arrow, useFloating };