Confronta il testo

Trova la differenza tra due file di testo

Editor live

Comprimi invariate

Senza a capo

Layout

Livello di dettaglio

Evidenziazione sintassi

Diffchecker Desktop Il modo più sicuro per usare Diffchecker. Ottieni l'app Diffchecker Desktop: i tuoi diff non lasciano mai il tuo computer!Ottieni Desktop

hashify diff

Creato 4 anni faIl diff non scade mai

37 rimozioni

Linee
Totale
Rimosso

Caratteri
Totale
Rimosso

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

296 linee

18 aggiunte

Linee
Totale
Aggiunto

Caratteri
Totale
Aggiunto

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

277 linee

// we define a 'polyfill' BigInt so we can support Firefox 62 and above instead of 68+

try {

BigInt(1);

Remainder = (a, b) => { return a % b };

Add = (a, b) => { return a + b };

} catch (e) {

BigInt = JSBI.BigInt;

Remainder = JSBI.remainder;

Add = JSBI.ADD;

}

const COLORS = {

white: '#ffffff',

black: '#000000',

green: '#49F2CC',

lightGrey: '#ddd',

grey: '#29363B',

cyan: 'cyan',

yellow: '#FFE202',

hotpink: 'deeppink',

};

function getChar(opts, char, x, y, randomOpts = {}) {

var char_shape = new mojs.Shape({

...opts,

...getStdOpts(char, opts.baseCharSize),

x: x,

y: y,

...randomOpts,

});

return char_shape;

}

function getText(text, x, y, baseOptions) {

let charSize = baseOptions.baseCharSize;

let opts = { ...baseOptions };

xStep = opts.xTxtSpacing;

shapes = [];

cX = x;

chars = text.split('');

for (c of chars) {

if (c === ' ') {

cX += xStep;

continue;

}

opts.radius = charSize;

var rdnOpts = {}

if (opts.animate) {

rdnOpts.radius = {};

rdnOpts.radius[charSize] = charSize * 1.1; // {charSize: charSize*1.1}

}

if (c <= 9 && c >= 0)

rdnOpts.fill = COLORS.white;

var cShape = getChar(opts, c, cX, y, rdnOpts)

shapes = shapes.concat(cShape);

cX += xStep;

}

return shapes;

}

function addText(text, timeline, x, y, options) {

var shapes = getText(text, x, y, options);

for (s of shapes)

timeline.add(s);

}

AVAILABLE_CHARS = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'J',

'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U', 'V', 'W',

'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9'];

let defaultBaseCharSize = 25;

let defaultBaseCharSize = 20;

let defaultBaseIconSize = 50;

let defaultBaseIconSize = 40;

DEFAULT_OPTS = {

x: 0,

y: 0,

yTxtSpacing: 2.3 * defaultBaseCharSize,

xTxtSpacing: 2.3 * defaultBaseCharSize,

baseCharSize: defaultBaseCharSize,

baseIconSize: defaultBaseIconSize,

iconCharSpacing: 1 + Math.max(defaultBaseIconSize, defaultBaseCharSize) - Math.min(defaultBaseIconSize, defaultBaseCharSize),

yIconSpacing: 2.3 * defaultBaseIconSize,

xIconSpacing: 2.3 * defaultBaseIconSize,

icon_generators: ICON_GENERATORS,

extraNumbersGenerated: 16,

masks: {

animate: true,

thinLine: false,

movingLine: true

}

class hashify {

constructor(generator) {

this.generator = generator();

}

/**

* Defines an object with a hashing generator. Example: hashify.seed("1212")

* @param {string} hash Hex string of the starting hash

* @param {string} salt Text of the salt

* @param {string} hashalg SHA variant. Valid options: "SHA-1", "SHA-256", "SHA-512"

static seed(hash, salt = "", hashalg = "SHA-256") {

static seed(hash, salt = "", hashAlgorithm = "SHA-256", hashFormat = "HEX", saltFormat = "TEXT") {

var sha_gen = function* () {

const shaGenerator = function* () {

var saltHasher = new jsSHA(

const saltHasher = new jsSHA(hashAlgorithm, saltFormat);

hashalg,

"TEXT"

);

saltHasher.update(salt);

let saltHex = saltHasher.getHash("HEX");

const saltHex = saltHasher.getHash("HEX");

let hashObject;

var hashObj = new jsSHA(

let currentState = hash;

hashalg,

"HEX"

);

// we set the initial state

//hashObj.update(hash);

let current_state = hash;

while (true) {

var hashObj = new jsSHA(

hashObject = new jsSHA(hashAlgorithm, hashFormat);

hashalg,

hashObject.update(currentState + saltHex);

"HEX"

currentState = hashObject.getHash("HEX");

);

yield BigInt("0x" + currentState);

hashObj.update(current_state + saltHex);

current_state = hashObj.getHash("HEX");

yield BigInt("0x" + current_state);

}

return new hashify(shaGenerator);

return new hashify(sha_gen);

}

/**

* Generates an object with a custom generator. Example: hashify.custom([1,2,3])

* @param {Array} custom_values Array of integers or BigIntegers

* @param {boolean} cycle If true, repeat the values upon reaching the end

static custom(custom_values, cycle = true) {

var custom_gen = function* () {

var internal_vals = custom_values;

let i = 0;

while (i < internal_vals.length) {

yield internal_vals[i];

i++;

if (i >= internal_vals.length) {

if (cycle)

i = 0;

else

return;

}

return new hashify(custom_gen);

}

/**

* Generates an animations in the parent element

* @param {Array} letters_grid Define the size grid of letters

* @param {Array} images_grid Define the size of the grid of images

* @param {string} parent Id of parent element

* @param {Object} options Customizable options, like position

prepAnimation(parent, letters_grid = [1, 4], images_grid = [2, 2], options = DEFAULT_OPTS) {

// Verifying that everything whe need is ok

try {

BigInt(1);

} catch (e) {

throw "BigInt support is needed";

}

// We clean the element

$(parent).empty();

// We create a new timeline

var timeline = this.getNewTimeline(options);

let availableIcons = Object.keys(options.icon_generators);

let optsWithParent = { ...options, parent: parent };

// We move the first icons back a bit, to better center the whole hash seal

let deltaY = -1 * ((

(letters_grid[0] - 1) * options.yTxtSpacing + options.baseCharSize +

(images_grid[0] - 1) * options.yIconSpacing + options.baseIconSize +

options.iconCharSpacing

) / 2);

// Generating the letters

const availableCharsLength = BigInt(AVAILABLE_CHARS.length);

for (var i = 0; i < letters_grid[0]; i++) {

let deltaX = -1 * (letters_grid[1] - 1) * options.xTxtSpacing / 2; // center this char line

for (var j = 0; j < letters_grid[1]; j++) {

let n = Remainder(this.generator.next().value, availableCharsLength);

addText(AVAILABLE_CHARS[n], timeline, options.x + deltaX, options.y + deltaY,

{

...optsWithParent,

...this.getRandomLetterOptions(options.extraNumbersGenerated, options.masks)

});

deltaX += options.xTxtSpacing;

}

deltaY += options.yTxtSpacing;

}

// There needs to be a bit of separation between the letters and icons

deltaY += options.iconCharSpacing;

// Generating the icons

let availableIconsLength = BigInt(availableIcons.length);

for (var i = 0; i < images_grid[0]; i++) {

let deltaX = -1 * (images_grid[1] - 1) * options.xIconSpacing / 2; // center this icon line

for (var j = 0; j < images_grid[1]; j++) {

// Select a value from the generator and take the modulo of the available icons

let n = Remainder(this.generator.next().value, availableIconsLength);

// Generate all "random" options

let rdn_opts = this.getRandomIconOptions(options.extraNumbersGenerated, options.masks);

// Select the generator function

let icon_generator = options.icon_generators[availableIcons[n]];

// Calling the function that creates the icon in the new position

icon_generator(timeline, options.x + deltaX, options.y + deltaY,

{ ...optsWithParent, ...rdn_opts });

deltaX += options.xIconSpacing;

}

deltaY += options.yIconSpacing;

}

this.timeline = timeline;

}

animate() {

this.timeline.play();

}

getRandomLetterOptions(generatorSpacing, masks) {

var rdnBaseNumbers = Array

.from(Array(generatorSpacing))

.map(() => this.generator.next().value);

return {};

}

getRandomIconOptions(generatorSpacing, masks) {

var rdnBaseNumbers = Array

.from(Array(generatorSpacing))

.map(() => this.generator.next().value);

let animateBool = masks.animate && Remainder(rdnBaseNumbers[0], BigInt(2)) == 0;

let thinLineBool = masks.thinLine && Remainder(rdnBaseNumbers[1], BigInt(2)) == 0;

let movingLineBool = masks.movingLine && Remainder(rdnBaseNumbers[2], BigInt(2)) == 0;

let dashArrayOffset = masks.movingLine && Add(Remainder(rdnBaseNumbers[2], BigInt(100)), BigInt(100));

let rdn_opts = {

animate: animateBool, thinLine: thinLineBool,

movingLine: movingLineBool, customDashArrayOffset: dashArrayOffset

};

return rdn_opts;

}

getNewTimeline(options) {

if (options.loop == 0) {

var timeline = new mojs.Timeline({

onComplete() {

this.replay(0); // create an infinite loop

}

});

}

else {

var timeline = new mojs.Timeline();

}

return timeline;

}

//a = hashify.seed("121213").animate("#svgDiv", letters_grid = [2, 5], images_grid = [5, 5]);

//a = hashify.seed("121213").animate("#svgDiv");

Diff salvati

Testo originale

Apri file

// we define a 'polyfill' BigInt so we can support Firefox 62 and above instead of 68+
try {
  BigInt(1);
  Remainder = (a, b) => { return a % b };
  Add = (a, b) => { return a + b };
} catch (e) {
  BigInt = JSBI.BigInt;
  Remainder = JSBI.remainder;
  Add = JSBI.ADD;
}

const COLORS = {
  white: '#ffffff',
  black: '#000000',
  green: '#49F2CC',
  lightGrey: '#ddd',
  grey: '#29363B',
  cyan: 'cyan',
  yellow: '#FFE202',
  hotpink: 'deeppink',
};

function getChar(opts, char, x, y, randomOpts = {}) {
  var char_shape = new mojs.Shape({
    ...opts,
    ...getStdOpts(char, opts.baseCharSize),

x: x,
    y: y,
    ...randomOpts,
  });

return char_shape;
}

function getText(text, x, y, baseOptions) {
  let charSize = baseOptions.baseCharSize;

let opts = { ...baseOptions };
  xStep = opts.xTxtSpacing;
  shapes = [];
  cX = x;
  chars = text.split('');
  for (c of chars) {
    if (c === ' ') {
      cX += xStep;
      continue;
    }

opts.radius = charSize;

var cShape = getChar(opts, c, cX, y, rdnOpts)
    shapes = shapes.concat(cShape);
    cX += xStep;
  }

return shapes;
}

function addText(text, timeline, x, y, options) {
  var shapes = getText(text, x, y, options);

for (s of shapes)
    timeline.add(s);
}

AVAILABLE_CHARS = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'J',
  'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U', 'V', 'W',
  'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9'];

let defaultBaseCharSize = 25;
let defaultBaseIconSize = 50;
DEFAULT_OPTS = {
  x: 0,
  y: 0,
  yTxtSpacing: 2.3 * defaultBaseCharSize,
  xTxtSpacing: 2.3 * defaultBaseCharSize,
  baseCharSize: defaultBaseCharSize,
  baseIconSize: defaultBaseIconSize,
  iconCharSpacing: 1 + Math.max(defaultBaseIconSize, defaultBaseCharSize) - Math.min(defaultBaseIconSize, defaultBaseCharSize),
  yIconSpacing: 2.3 * defaultBaseIconSize,
  xIconSpacing: 2.3 * defaultBaseIconSize,
  icon_generators: ICON_GENERATORS,
  extraNumbersGenerated: 16,
  masks: {
    animate: true,
    thinLine: false,
    movingLine: true
  }
}

class hashify {
  constructor(generator) {
    this.generator = generator();
  }

var hashObj = new jsSHA(
        hashalg,
        "HEX"
      );

// we set the initial state
      //hashObj.update(hash);
      let current_state = hash;
      while (true) {
        var hashObj = new jsSHA(
          hashalg,
          "HEX"
        );
        hashObj.update(current_state + saltHex);
        current_state = hashObj.getHash("HEX");

yield BigInt("0x" + current_state);
      }
    }

return new hashify(sha_gen);
  }

/**
   * Generates an object with a custom generator. Example: hashify.custom([1,2,3])
   * @param {Array} custom_values Array of integers or BigIntegers
   * @param {boolean} cycle If true, repeat the values upon reaching the end
   */
  static custom(custom_values, cycle = true) {
    var custom_gen = function* () {
      var internal_vals = custom_values;
      let i = 0;
      while (i < internal_vals.length) {
        yield internal_vals[i];
        i++;

if (i >= internal_vals.length) {
          if (cycle)
            i = 0;
          else
            return;
        }
      }
    }

return new hashify(custom_gen);
  }

/**
   * Generates an animations in the parent element
   * @param {Array} letters_grid Define the size grid of letters
   * @param {Array} images_grid Define the size of the grid of images
   * @param {string} parent Id of parent element
   * @param {Object} options Customizable options, like position
   */
  prepAnimation(parent, letters_grid = [1, 4], images_grid = [2, 2], options = DEFAULT_OPTS) {
    // Verifying that everything whe need is ok
    try {
      BigInt(1);
    } catch (e) {
      throw "BigInt support is needed";
    }

// We clean the element
    $(parent).empty();

// We create a new timeline
    var timeline = this.getNewTimeline(options);

let availableIcons = Object.keys(options.icon_generators);
    let optsWithParent = { ...options, parent: parent };

// We move the first icons back a bit, to better center the whole hash seal
    let deltaY = -1 * ((
      (letters_grid[0] - 1) * options.yTxtSpacing + options.baseCharSize +
      (images_grid[0] - 1) * options.yIconSpacing + options.baseIconSize +
      options.iconCharSpacing
    ) / 2);

// Generating the letters
    const availableCharsLength = BigInt(AVAILABLE_CHARS.length);
    for (var i = 0; i < letters_grid[0]; i++) {
      let deltaX = -1 * (letters_grid[1] - 1) * options.xTxtSpacing / 2; // center this char line

for (var j = 0; j < letters_grid[1]; j++) {
        let n = Remainder(this.generator.next().value, availableCharsLength);
        addText(AVAILABLE_CHARS[n], timeline, options.x + deltaX, options.y + deltaY,
          {
            ...optsWithParent,
            ...this.getRandomLetterOptions(options.extraNumbersGenerated, options.masks)
          });

deltaX += options.xTxtSpacing;
      }

deltaY += options.yTxtSpacing;
    }

// There needs to be a bit of separation between the letters and icons
    deltaY += options.iconCharSpacing;

// Generating the icons
    let availableIconsLength = BigInt(availableIcons.length);
    for (var i = 0; i < images_grid[0]; i++) {
      let deltaX = -1 * (images_grid[1] - 1) * options.xIconSpacing / 2; // center this icon line

for (var j = 0; j < images_grid[1]; j++) {
        // Select a value from the generator and take the modulo of the available icons
        let n = Remainder(this.generator.next().value, availableIconsLength);

// Generate all "random" options
        let rdn_opts = this.getRandomIconOptions(options.extraNumbersGenerated, options.masks);

// Select the generator function
        let icon_generator = options.icon_generators[availableIcons[n]];

// Calling the function that creates the icon in the new position
        icon_generator(timeline, options.x + deltaX, options.y + deltaY,
          { ...optsWithParent, ...rdn_opts });

deltaX += options.xIconSpacing;
      }

deltaY += options.yIconSpacing;
    }

this.timeline = timeline;
  }

animate() {
    this.timeline.play();
  }

getRandomLetterOptions(generatorSpacing, masks) {
    var rdnBaseNumbers = Array
      .from(Array(generatorSpacing))
      .map(() => this.generator.next().value);

return {};
  }

getRandomIconOptions(generatorSpacing, masks) {
    var rdnBaseNumbers = Array
      .from(Array(generatorSpacing))
      .map(() => this.generator.next().value);
    let animateBool = masks.animate && Remainder(rdnBaseNumbers[0], BigInt(2)) == 0;
    let thinLineBool = masks.thinLine && Remainder(rdnBaseNumbers[1], BigInt(2)) == 0;
    let movingLineBool = masks.movingLine && Remainder(rdnBaseNumbers[2], BigInt(2)) == 0;
    let dashArrayOffset = masks.movingLine && Add(Remainder(rdnBaseNumbers[2], BigInt(100)), BigInt(100));

let rdn_opts = {
      animate: animateBool, thinLine: thinLineBool,
      movingLine: movingLineBool, customDashArrayOffset: dashArrayOffset
    };
    return rdn_opts;
  }

getNewTimeline(options) {
    if (options.loop == 0) {
      var timeline = new mojs.Timeline({
        onComplete() {
          this.replay(0); // create an infinite loop
        }
      });
    }
    else {
      var timeline = new mojs.Timeline();
    }
    return timeline;
  }
}

//a = hashify.seed("121213").animate("#svgDiv", letters_grid = [2, 5], images_grid = [5, 5]);
//a = hashify.seed("121213").animate("#svgDiv");

Testo modificato

Apri file

const COLORS = {
  white: '#ffffff',
  black: '#000000',
  green: '#49F2CC',
  lightGrey: '#ddd',
  grey: '#29363B',
  cyan: 'cyan',
  yellow: '#FFE202',
  hotpink: 'deeppink',
};

function getChar(opts, char, x, y, randomOpts = {}) {
  var char_shape = new mojs.Shape({
    ...opts,
    ...getStdOpts(char, opts.baseCharSize),

x: x,
    y: y,
    ...randomOpts,
  });

return char_shape;
}

function getText(text, x, y, baseOptions) {
  let charSize = baseOptions.baseCharSize;
  let opts = { ...baseOptions };
  xStep = opts.xTxtSpacing;
  shapes = [];
  cX = x;
  chars = text.split('');
  for (c of chars) {
    if (c === ' ') {
      cX += xStep;
      continue;
    }

opts.radius = charSize;

var cShape = getChar(opts, c, cX, y, rdnOpts)
    shapes = shapes.concat(cShape);
    cX += xStep;
  }

return shapes;
}

function addText(text, timeline, x, y, options) {
  var shapes = getText(text, x, y, options);

for (s of shapes)
    timeline.add(s);
}

AVAILABLE_CHARS = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'J',
  'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U', 'V', 'W',
  'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9'];

let defaultBaseCharSize = 20;
let defaultBaseIconSize = 40;
DEFAULT_OPTS = {
  x: 0,
  y: 0,
  yTxtSpacing: 2.3 * defaultBaseCharSize,
  xTxtSpacing: 2.3 * defaultBaseCharSize,
  baseCharSize: defaultBaseCharSize,
  baseIconSize: defaultBaseIconSize,
  iconCharSpacing: 1 + Math.max(defaultBaseIconSize, defaultBaseCharSize) - Math.min(defaultBaseIconSize, defaultBaseCharSize),
  yIconSpacing: 2.3 * defaultBaseIconSize,
  xIconSpacing: 2.3 * defaultBaseIconSize,
  icon_generators: ICON_GENERATORS,
  extraNumbersGenerated: 16,
  masks: {
    animate: true,
    thinLine: false,
    movingLine: true
  }
}

class hashify {
  constructor(generator) {
    this.generator = generator();
  }

/**
   * Defines an object with a hashing generator. Example: hashify.seed("1212")
   * @param {string} hash Hex string of the starting hash
   * @param {string} salt Text of the salt
   * @param {string} hashalg SHA variant. Valid options: "SHA-1", "SHA-256", "SHA-512"
   */
  static seed(hash, salt = "",  hashAlgorithm = "SHA-256", hashFormat = "HEX", saltFormat = "TEXT") {
    const shaGenerator = function* () {
      const saltHasher = new jsSHA(hashAlgorithm, saltFormat);
      saltHasher.update(salt);
      const saltHex = saltHasher.getHash("HEX");
      let hashObject;
      let currentState = hash;
      while (true) {
        hashObject = new jsSHA(hashAlgorithm, hashFormat);
        hashObject.update(currentState + saltHex);
        currentState = hashObject.getHash("HEX");
        yield BigInt("0x" + currentState);
      }
    }
    return new hashify(shaGenerator);
  }

if (i >= internal_vals.length) {
          if (cycle)
            i = 0;
          else
            return;
        }
      }
    }

return new hashify(custom_gen);
  }

// We clean the element
    $(parent).empty();

// We create a new timeline
    var timeline = this.getNewTimeline(options);

let availableIcons = Object.keys(options.icon_generators);
    let optsWithParent = { ...options, parent: parent };

deltaX += options.xTxtSpacing;
      }

deltaY += options.yTxtSpacing;
    }

// There needs to be a bit of separation between the letters and icons
    deltaY += options.iconCharSpacing;

// Generate all "random" options
        let rdn_opts = this.getRandomIconOptions(options.extraNumbersGenerated, options.masks);

// Select the generator function
        let icon_generator = options.icon_generators[availableIcons[n]];

// Calling the function that creates the icon in the new position
        icon_generator(timeline, options.x + deltaX, options.y + deltaY,
          { ...optsWithParent, ...rdn_opts });

deltaX += options.xIconSpacing;
      }

deltaY += options.yIconSpacing;
    }

this.timeline = timeline;
  }

animate() {
    this.timeline.play();
  }

getRandomLetterOptions(generatorSpacing, masks) {
    var rdnBaseNumbers = Array
      .from(Array(generatorSpacing))
      .map(() => this.generator.next().value);

return {};
  }

let rdn_opts = {
      animate: animateBool, thinLine: thinLineBool,
      movingLine: movingLineBool, customDashArrayOffset: dashArrayOffset
    };
    return rdn_opts;
  }

//a = hashify.seed("121213").animate("#svgDiv", letters_grid = [2, 5], images_grid = [5, 5]);
//a = hashify.seed("121213").animate("#svgDiv");