403WebShell

403Webshell
Server IP : 45.32.152.128 / Your IP : 216.73.216.91
Web Server : nginx/1.24.0
System : Linux stage-vultr 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User : forge ( 1000)
PHP Version : 8.2.14
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON
Directory : /home/forge/evolutionequity.pdgm.dev/node_modules/stylefire/dist/
Upload File :
[ Back ]
Current File : /home/forge/evolutionequity.pdgm.dev/node_modules/stylefire/dist//stylefire.js
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('tslib'), require('framesync'), require('style-value-types'), require('hey-listen')) :
  typeof define === 'function' && define.amd ? define(['exports', 'tslib', 'framesync', 'style-value-types', 'hey-listen'], factory) :
  (global = global || self, factory(global.stylefire = {}, global.tslib, global.framesync, global.valueTypes, global.heyListen));
}(this, (function (exports, tslib, sync, styleValueTypes, heyListen) { 'use strict';

  sync = sync && sync.hasOwnProperty('default') ? sync['default'] : sync;

  var createStyler = function (_a) {
      var onRead = _a.onRead, onRender = _a.onRender, _b = _a.uncachedValues, uncachedValues = _b === void 0 ? new Set() : _b, _c = _a.useCache, useCache = _c === void 0 ? true : _c;
      return function (_a) {
          if (_a === void 0) { _a = {}; }
          var props = tslib.__rest(_a, []);
          var state = {};
          var changedValues = [];
          var hasChanged = false;
          function setValue(key, value) {
              if (key.startsWith('--')) {
                  props.hasCSSVariable = true;
              }
              var currentValue = state[key];
              state[key] = value;
              if (state[key] === currentValue)
                  return;
              if (changedValues.indexOf(key) === -1) {
                  changedValues.push(key);
              }
              if (!hasChanged) {
                  hasChanged = true;
                  sync.render(styler.render);
              }
          }
          var styler = {
              get: function (key, forceRead) {
                  if (forceRead === void 0) { forceRead = false; }
                  var useCached = !forceRead &&
                      useCache &&
                      !uncachedValues.has(key) &&
                      state[key] !== undefined;
                  return useCached ? state[key] : onRead(key, props);
              },
              set: function (values, value) {
                  if (typeof values === 'string') {
                      setValue(values, value);
                  }
                  else {
                      for (var key in values) {
                          setValue(key, values[key]);
                      }
                  }
                  return this;
              },
              render: function (forceRender) {
                  if (forceRender === void 0) { forceRender = false; }
                  if (hasChanged || forceRender === true) {
                      onRender(state, props, changedValues);
                      hasChanged = false;
                      changedValues.length = 0;
                  }
                  return this;
              }
          };
          return styler;
      };
  };

  var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;
  var REPLACE_TEMPLATE = '$1-$2';
  var camelToDash = function (str) {
      return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();
  };

  var camelCache = new Map();
  var dashCache = new Map();
  var prefixes = ['Webkit', 'Moz', 'O', 'ms', ''];
  var numPrefixes = prefixes.length;
  var isBrowser = typeof document !== 'undefined';
  var testElement;
  var setDashPrefix = function (key, prefixed) {
      return dashCache.set(key, camelToDash(prefixed));
  };
  var testPrefix = function (key) {
      testElement = testElement || document.createElement('div');
      for (var i = 0; i < numPrefixes; i++) {
          var prefix = prefixes[i];
          var noPrefix = prefix === '';
          var prefixedPropertyName = noPrefix
              ? key
              : prefix + key.charAt(0).toUpperCase() + key.slice(1);
          if (prefixedPropertyName in testElement.style || noPrefix) {
              if (noPrefix && key === 'clipPath' && dashCache.has(key)) {
                  return;
              }
              camelCache.set(key, prefixedPropertyName);
              setDashPrefix(key, "" + (noPrefix ? '' : '-') + camelToDash(prefixedPropertyName));
          }
      }
  };
  var setServerProperty = function (key) { return setDashPrefix(key, key); };
  var prefixer = function (key, asDashCase) {
      if (asDashCase === void 0) { asDashCase = false; }
      var cache = asDashCase ? dashCache : camelCache;
      if (!cache.has(key)) {
          isBrowser ? testPrefix(key) : setServerProperty(key);
      }
      return cache.get(key) || key;
  };

  var axes = ['', 'X', 'Y', 'Z'];
  var order = ['translate', 'scale', 'rotate', 'skew', 'transformPerspective'];
  var transformProps = order.reduce(function (acc, key) {
      return axes.reduce(function (axesAcc, axesKey) {
          axesAcc.push(key + axesKey);
          return axesAcc;
      }, acc);
  }, ['x', 'y', 'z']);
  var transformPropDictionary = transformProps.reduce(function (dict, key) {
      dict[key] = true;
      return dict;
  }, {});
  function isTransformProp(key) {
      return transformPropDictionary[key] === true;
  }
  function sortTransformProps(a, b) {
      return transformProps.indexOf(a) - transformProps.indexOf(b);
  }
  var transformOriginProps = new Set(['originX', 'originY', 'originZ']);
  function isTransformOriginProp(key) {
      return transformOriginProps.has(key);
  }

  var int = tslib.__assign(tslib.__assign({}, styleValueTypes.number), { transform: Math.round });
  var valueTypes = {
      color: styleValueTypes.color,
      backgroundColor: styleValueTypes.color,
      outlineColor: styleValueTypes.color,
      fill: styleValueTypes.color,
      stroke: styleValueTypes.color,
      borderColor: styleValueTypes.color,
      borderTopColor: styleValueTypes.color,
      borderRightColor: styleValueTypes.color,
      borderBottomColor: styleValueTypes.color,
      borderLeftColor: styleValueTypes.color,
      borderWidth: styleValueTypes.px,
      borderTopWidth: styleValueTypes.px,
      borderRightWidth: styleValueTypes.px,
      borderBottomWidth: styleValueTypes.px,
      borderLeftWidth: styleValueTypes.px,
      borderRadius: styleValueTypes.px,
      radius: styleValueTypes.px,
      borderTopLeftRadius: styleValueTypes.px,
      borderTopRightRadius: styleValueTypes.px,
      borderBottomRightRadius: styleValueTypes.px,
      borderBottomLeftRadius: styleValueTypes.px,
      width: styleValueTypes.px,
      maxWidth: styleValueTypes.px,
      height: styleValueTypes.px,
      maxHeight: styleValueTypes.px,
      size: styleValueTypes.px,
      top: styleValueTypes.px,
      right: styleValueTypes.px,
      bottom: styleValueTypes.px,
      left: styleValueTypes.px,
      padding: styleValueTypes.px,
      paddingTop: styleValueTypes.px,
      paddingRight: styleValueTypes.px,
      paddingBottom: styleValueTypes.px,
      paddingLeft: styleValueTypes.px,
      margin: styleValueTypes.px,
      marginTop: styleValueTypes.px,
      marginRight: styleValueTypes.px,
      marginBottom: styleValueTypes.px,
      marginLeft: styleValueTypes.px,
      rotate: styleValueTypes.degrees,
      rotateX: styleValueTypes.degrees,
      rotateY: styleValueTypes.degrees,
      rotateZ: styleValueTypes.degrees,
      scale: styleValueTypes.scale,
      scaleX: styleValueTypes.scale,
      scaleY: styleValueTypes.scale,
      scaleZ: styleValueTypes.scale,
      skew: styleValueTypes.degrees,
      skewX: styleValueTypes.degrees,
      skewY: styleValueTypes.degrees,
      distance: styleValueTypes.px,
      translateX: styleValueTypes.px,
      translateY: styleValueTypes.px,
      translateZ: styleValueTypes.px,
      x: styleValueTypes.px,
      y: styleValueTypes.px,
      z: styleValueTypes.px,
      perspective: styleValueTypes.px,
      opacity: styleValueTypes.alpha,
      originX: styleValueTypes.progressPercentage,
      originY: styleValueTypes.progressPercentage,
      originZ: styleValueTypes.px,
      zIndex: int,
      fillOpacity: styleValueTypes.alpha,
      strokeOpacity: styleValueTypes.alpha,
      numOctaves: int
  };
  var getValueType = function (key) { return valueTypes[key]; };
  var getValueAsType = function (value, type) {
      return type && typeof value === 'number' ? type.transform(value) : value;
  };

  var SCROLL_LEFT = 'scrollLeft';
  var SCROLL_TOP = 'scrollTop';
  var scrollKeys = new Set([SCROLL_LEFT, SCROLL_TOP]);

  var blacklist = new Set([SCROLL_LEFT, SCROLL_TOP, 'transform']);
  var translateAlias = {
      x: 'translateX',
      y: 'translateY',
      z: 'translateZ'
  };
  function isCustomTemplate(v) {
      return typeof v === 'function';
  }
  function buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration, allowTransformNone) {
      if (allowTransformNone === void 0) { allowTransformNone = true; }
      var transformString = '';
      var transformHasZ = false;
      transformKeys.sort(sortTransformProps);
      var numTransformKeys = transformKeys.length;
      for (var i = 0; i < numTransformKeys; i++) {
          var key = transformKeys[i];
          transformString += (translateAlias[key] || key) + "(" + transform[key] + ") ";
          transformHasZ = key === 'z' ? true : transformHasZ;
      }
      if (!transformHasZ && enableHardwareAcceleration) {
          transformString += 'translateZ(0)';
      }
      else {
          transformString = transformString.trim();
      }
      if (isCustomTemplate(state.transform)) {
          transformString = state.transform(transform, transformIsDefault ? '' : transformString);
      }
      else if (allowTransformNone && transformIsDefault) {
          transformString = 'none';
      }
      return transformString;
  }
  function buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase, allowTransformNone) {
      if (enableHardwareAcceleration === void 0) { enableHardwareAcceleration = true; }
      if (styles === void 0) { styles = {}; }
      if (transform === void 0) { transform = {}; }
      if (transformOrigin === void 0) { transformOrigin = {}; }
      if (transformKeys === void 0) { transformKeys = []; }
      if (isDashCase === void 0) { isDashCase = false; }
      if (allowTransformNone === void 0) { allowTransformNone = true; }
      var transformIsDefault = true;
      var hasTransform = false;
      var hasTransformOrigin = false;
      for (var key in state) {
          var value = state[key];
          var valueType = getValueType(key);
          var valueAsType = getValueAsType(value, valueType);
          if (isTransformProp(key)) {
              hasTransform = true;
              transform[key] = valueAsType;
              transformKeys.push(key);
              if (transformIsDefault) {
                  if ((valueType.default && value !== valueType.default) ||
                      (!valueType.default && value !== 0)) {
                      transformIsDefault = false;
                  }
              }
          }
          else if (isTransformOriginProp(key)) {
              transformOrigin[key] = valueAsType;
              hasTransformOrigin = true;
          }
          else if (!blacklist.has(key) || !isCustomTemplate(valueAsType)) {
              styles[prefixer(key, isDashCase)] = valueAsType;
          }
      }
      if (hasTransform || typeof state.transform === 'function') {
          styles.transform = buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration, allowTransformNone);
      }
      if (hasTransformOrigin) {
          styles.transformOrigin = (transformOrigin.originX ||
              '50%') + " " + (transformOrigin.originY || '50%') + " " + (transformOrigin.originZ ||
              0);
      }
      return styles;
  }
  function createStyleBuilder(_a) {
      var _b = _a === void 0 ? {} : _a, _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.isDashCase, isDashCase = _d === void 0 ? true : _d, _e = _b.allowTransformNone, allowTransformNone = _e === void 0 ? true : _e;
      var styles = {};
      var transform = {};
      var transformOrigin = {};
      var transformKeys = [];
      return function (state) {
          transformKeys.length = 0;
          buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase, allowTransformNone);
          return styles;
      };
  }

  function onRead(key, options) {
      var element = options.element, preparseOutput = options.preparseOutput;
      var defaultValueType = getValueType(key);
      if (isTransformProp(key)) {
          return defaultValueType ? defaultValueType.default || 0 : 0;
      }
      else if (scrollKeys.has(key)) {
          return element[key];
      }
      else {
          var domValue = window
              .getComputedStyle(element, null)
              .getPropertyValue(prefixer(key, true)) || 0;
          return preparseOutput &&
              defaultValueType &&
              defaultValueType.test(domValue) &&
              defaultValueType.parse
              ? defaultValueType.parse(domValue)
              : domValue;
      }
  }
  function onRender(state, _a, changedValues) {
      var element = _a.element, buildStyles = _a.buildStyles, hasCSSVariable = _a.hasCSSVariable;
      Object.assign(element.style, buildStyles(state));
      if (hasCSSVariable) {
          var numChangedValues = changedValues.length;
          for (var i = 0; i < numChangedValues; i++) {
              var key = changedValues[i];
              if (key.startsWith('--')) {
                  element.style.setProperty(key, state[key]);
              }
          }
      }
      if (changedValues.indexOf(SCROLL_LEFT) !== -1) {
          element[SCROLL_LEFT] = state[SCROLL_LEFT];
      }
      if (changedValues.indexOf(SCROLL_TOP) !== -1) {
          element[SCROLL_TOP] = state[SCROLL_TOP];
      }
  }
  var cssStyler = createStyler({
      onRead: onRead,
      onRender: onRender,
      uncachedValues: scrollKeys
  });
  function createCssStyler(element, _a) {
      if (_a === void 0) { _a = {}; }
      var enableHardwareAcceleration = _a.enableHardwareAcceleration, allowTransformNone = _a.allowTransformNone, props = tslib.__rest(_a, ["enableHardwareAcceleration", "allowTransformNone"]);
      return cssStyler(tslib.__assign({ element: element, buildStyles: createStyleBuilder({
              enableHardwareAcceleration: enableHardwareAcceleration,
              allowTransformNone: allowTransformNone
          }), preparseOutput: true }, props));
  }

  var camelCaseAttributes = new Set([
      'baseFrequency',
      'diffuseConstant',
      'kernelMatrix',
      'kernelUnitLength',
      'keySplines',
      'keyTimes',
      'limitingConeAngle',
      'markerHeight',
      'markerWidth',
      'numOctaves',
      'targetX',
      'targetY',
      'surfaceScale',
      'specularConstant',
      'specularExponent',
      'stdDeviation',
      'tableValues'
  ]);

  var defaultOrigin = 0.5;
  var svgAttrsTemplate = function () { return ({
      style: {}
  }); };
  var progressToPixels = function (progress, length) {
      return styleValueTypes.px.transform(progress * length);
  };
  var unmeasured = { x: 0, y: 0, width: 0, height: 0 };
  function calcOrigin(origin, offset, size) {
      return typeof origin === 'string'
          ? origin
          : styleValueTypes.px.transform(offset + size * origin);
  }
  function calculateSVGTransformOrigin(dimensions, originX, originY) {
      return calcOrigin(originX, dimensions.x, dimensions.width) + " " + calcOrigin(originY, dimensions.y, dimensions.height);
  }
  var svgStyleConfig = {
      enableHardwareAcceleration: false,
      isDashCase: false
  };
  function buildSVGAttrs(_a, dimensions, totalPathLength, cssBuilder, attrs, isDashCase) {
      if (dimensions === void 0) { dimensions = unmeasured; }
      if (cssBuilder === void 0) { cssBuilder = createStyleBuilder(svgStyleConfig); }
      if (attrs === void 0) { attrs = svgAttrsTemplate(); }
      if (isDashCase === void 0) { isDashCase = true; }
      var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, state = tslib.__rest(_a, ["attrX", "attrY", "originX", "originY", "pathLength", "pathSpacing", "pathOffset"]);
      var style = cssBuilder(state);
      for (var key in style) {
          if (key === 'transform') {
              attrs.style.transform = style[key];
          }
          else {
              var attrKey = isDashCase && !camelCaseAttributes.has(key) ? camelToDash(key) : key;
              attrs[attrKey] = style[key];
          }
      }
      if (originX !== undefined || originY !== undefined || style.transform) {
          attrs.style.transformOrigin = calculateSVGTransformOrigin(dimensions, originX !== undefined ? originX : defaultOrigin, originY !== undefined ? originY : defaultOrigin);
      }
      if (attrX !== undefined)
          attrs.x = attrX;
      if (attrY !== undefined)
          attrs.y = attrY;
      if (totalPathLength !== undefined && pathLength !== undefined) {
          attrs[isDashCase ? 'stroke-dashoffset' : 'strokeDashoffset'] = progressToPixels(-pathOffset, totalPathLength);
          attrs[isDashCase ? 'stroke-dasharray' : 'strokeDasharray'] = progressToPixels(pathLength, totalPathLength) + " " + progressToPixels(pathSpacing, totalPathLength);
      }
      return attrs;
  }
  function createAttrBuilder(dimensions, totalPathLength, isDashCase) {
      if (isDashCase === void 0) { isDashCase = true; }
      var attrs = svgAttrsTemplate();
      var cssBuilder = createStyleBuilder(svgStyleConfig);
      return function (state) {
          return buildSVGAttrs(state, dimensions, totalPathLength, cssBuilder, attrs, isDashCase);
      };
  }

  var getDimensions = function (element) {
      return typeof element.getBBox === 'function'
          ? element.getBBox()
          : element.getBoundingClientRect();
  };
  var getSVGElementDimensions = function (element) {
      try {
          return getDimensions(element);
      }
      catch (e) {
          return { x: 0, y: 0, width: 0, height: 0 };
      }
  };

  var isPath = function (element) {
      return element.tagName === 'path';
  };
  var svgStyler = createStyler({
      onRead: function (key, _a) {
          var element = _a.element;
          key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
          if (!isTransformProp(key)) {
              return element.getAttribute(key);
          }
          else {
              var valueType = getValueType(key);
              return valueType ? valueType.default || 0 : 0;
          }
      },
      onRender: function (state, _a) {
          var element = _a.element, buildAttrs = _a.buildAttrs;
          var attrs = buildAttrs(state);
          for (var key in attrs) {
              if (key === 'style') {
                  Object.assign(element.style, attrs.style);
              }
              else {
                  element.setAttribute(key, attrs[key]);
              }
          }
      }
  });
  var svg = (function (element) {
      var dimensions = getSVGElementDimensions(element);
      var pathLength = isPath(element) && element.getTotalLength
          ? element.getTotalLength()
          : undefined;
      return svgStyler({
          element: element,
          buildAttrs: createAttrBuilder(dimensions, pathLength)
      });
  });

  var viewport = createStyler({
      useCache: false,
      onRead: function (key) {
          return key === 'scrollTop' ? window.pageYOffset : window.pageXOffset;
      },
      onRender: function (_a) {
          var _b = _a.scrollTop, scrollTop = _b === void 0 ? 0 : _b, _c = _a.scrollLeft, scrollLeft = _c === void 0 ? 0 : _c;
          return window.scrollTo(scrollLeft, scrollTop);
      }
  });

  var cache = new WeakMap();
  var isHTMLElement = function (node) {
      return (node instanceof HTMLElement ||
          typeof node.click === 'function');
  };
  var isSVGElement = function (node) {
      return node instanceof SVGElement || 'ownerSVGElement' in node;
  };
  var createDOMStyler = function (node, props) {
      var styler;
      if (node === window) {
          styler = viewport(node);
      }
      else if (isHTMLElement(node)) {
          styler = createCssStyler(node, props);
      }
      else if (isSVGElement(node)) {
          styler = svg(node);
      }
      heyListen.invariant(styler !== undefined, 'No valid node provided. Node must be HTMLElement, SVGElement or window.');
      cache.set(node, styler);
      return styler;
  };
  var getStyler = function (node, props) {
      return cache.has(node) ? cache.get(node) : createDOMStyler(node, props);
  };
  function index (nodeOrSelector, props) {
      var node = typeof nodeOrSelector === 'string'
          ? document.querySelector(nodeOrSelector)
          : nodeOrSelector;
      return getStyler(node, props);
  }

  exports.buildSVGAttrs = buildSVGAttrs;
  exports.buildStyleProperty = buildStyleProperty;
  exports.createStylerFactory = createStyler;
  exports.default = index;
  exports.isTransformProp = isTransformProp;
  exports.transformProps = transformProps;

  Object.defineProperty(exports, '__esModule', { value: true });

})));
Youez - 2016 - github.com/yon3zu
LinuXploit