Datasets:

nuprl

/

stenotype-ts-evl-with-usages

like 0

Follow

Northeastern University Programming Research Lab 21

a602d09d6492b568180b56a8fff0ba51ab32f708

ts

TypeScript

libs/amyr-ts-lib/src/lib/libs/tsmt/utils/string-utils.ts

theAlgorithmist/AMYR

db4141d7e545b94a5c98fc5430a065e2ba229e75

2022-01-17T21:31:47.000Z

2022-03-04T20:16:21.000Z

libs/amyr-ts-lib/src/lib/libs/tsmt/utils/string-utils.ts

theAlgorithmist/AMYR

db4141d7e545b94a5c98fc5430a065e2ba229e75

libs/amyr-ts-lib/src/lib/libs/tsmt/utils/string-utils.ts

theAlgorithmist/AMYR

db4141d7e545b94a5c98fc5430a065e2ba229e75

/** * Copyright 2016 Jim Armstrong (www.algorithmist.net) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * AMYR Library: Low-level, utils string utility functions (probably similar to many you have seen * elsewhere as there really isn't anything new under the sun). These methods are optimized for reasonable * performance and there is little error checking. You break it ... you buy it. Some methods are direct * replacement for lodash equivalents. * * @author Jim Armstrong (https://www.linkedin.com/in/jimarmstrong/) * * @version 1.0 */ export const WHITESPACE: Array<string> = [ ' ', '\n', '\r', '\t', '\f', '\v', '\u00A0', '\u1680', '\u180E', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004', '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200A', '\u2028', '\u2029', '\u202F', '\u205F', '\u3000' ]; /** * Determine if an input string starts exactly with the specified char string (case matters) * * @param {string} input Input string * * @param {string} target string to check against * @default 0 */ export function startsWith(input: string, target: string, position: number = 0): boolean { const length: number = input.length || 0; if (!input || !target ) return false; // relatively quick string-convert target = `${target}`; const n: number = target.length; if (length == 0 && n == 0) { return true; } position = position < 0 ? 0 : (position >= length ? length-1 : position); return input.slice(position, position + n) === target } /** * Capitalize the first letter of a string and convert all remaining characters to lowercase * * @param {string} input String to be capitalized */ export function capitalize(input: string): string { const n: number = input.length; if (n === 0) return input; if (n === 1) return input.toUpperCase(); return input.charAt(0).toUpperCase() + (input.substr(1, n)).toLowerCase(); } /** * Quick trim of spaces from a string * * @param {string} inputInput string */ export function trim(input: string): string { return input.replace(/ /g, ''); } /** * Remove selected whitepsace characters from the beginning of a string * * @param {string} input Input string * * @param {Array<string>} white List of whitespace characters to be removed * @default {WHITESPACE} */ export function leftTrim(input: string, chars: Array<string> = WHITESPACE): string { let start = 0; const len: number = input.length; const whiteLen: number = chars.length; let found = true; let i: number; let char: string; while (found && start < len) { found = false; i = -1; char = input.charAt(start); while (++i < whiteLen) { if (char === chars[i]) { found = true; start++; break; } } } return (start >= len) ? '' : input.substr(start, len); } /** * Remove selected whitespace characters from the end of a string * * @param {string} input Input string * * @param {Array<string>} white List of whitespace characters to be removed * @default {WHITESPACE} */ export function rightTrim(input: string, chars: Array<string> = WHITESPACE): string { const len: number = input.length; let end: number = len-1; const whiteLen: number = chars.length; let found = true; let i: number; let char: string; while (found && end >= 0) { found = false; i = -1; char = input.charAt(end); while (++i < whiteLen) { if (char === chars[i]) { found = true; end--; break; } } } return (end >= 0) ? input.substr(0, end+1) : ''; } /** * Trim whitespace from beginning and end of a string based on a list of whitespace characters * (that may include line feeds and such) * * @param {string} input Input string * * @param {Array<string>} chars List of 'whitespace' characters to remove * @default {WHITESPACE} */ export function trimEnds(input: string, chars: Array<string> = WHITESPACE): string { return leftTrim(rightTrim(input, chars), chars); } /** * Trim a string at the nearest (previous) space based on a character count with optional insertion of ellipses. * Original string is trimmed at nearest previous space, i.e. 'This is a test' is trimmed to 'This is a' * with a character count greater than nine or 'This is a...' if the ellipses parameter is true. * * @param input : input string * * @param count : number - Character count for trimming (must be greater than zero) * * @param ellipses: boolean If true, insert ellipses (...) after trip * @default {false} */ export function trimToCharCount(input: string, count: number, ellipses: boolean = false): string { count = Math.max(1, Math.round(count)); const len: number = input.length; if (len < count) return input; if (input === ' ') return ''; let char: string = input.charAt(count-1); let end: number = count-1; while (end >= 0) { char = input.charAt(end--); if (char === ' ') break; } end = end < 0 ? count-1 : end; // add ellipses? return ellipses ? input.substring(0,end+1) + '...' : input.substring(0, end+1); } /** * Left-pad a string with a specified character if its length is smaller than the specified value * * @param {string} input Input string * * @param {number} len minimum length (must be greater than zero) * * @param {string} replaceWith: string Replacement string * @default ' ' (single space) */ export function leftPad(input: string, len: number, replaceWith: string = ' '): string { len = Math.max(1, Math.round(len)); return ((input.length < len) ? repeat(replaceWith, len - input.length) + input : input); } /** * Right-pad a string with a specified character if its length is smaller than the specified value * * @param {string} input Input string * * @param {number} len minimum length (must be greater than zero) * * @param {string} replaceWith Replacement string * @default ' ' (single space) */ export function rightPad(input: string, len: number, replaceWith: string = ' '): string { len = Math.max(1, Math.round(len)); return (input.length < len) ? input + repeat(replaceWith, len - input.length) : input; } /** * Repeat a string specified number of times * * @param {string} input Input string * * @param {number} n Repeat count (must be greater than zero) */ export function repeat(input: string, n: number): string { n = Math.max(1, Math.round(n)); return (new Array(n + 1)).join(input); } /** * Escape a string to prepare for DOM insertion * * @param {string} input Input string with characters that require escaping before dynamic placement into DOM elements */ export function toHtml(input: string): string { return input .replace(/</g, '&lt;') .replace(/>/g, '&gt;') .replace(/&/g, '&amp;') .replace(/"/g, '&quot;') .replace(/'/g, '&#39;'); } /** * Unescape HTML special characters (reverse of toHtml) * * @param {string} input Input string containing html-escaped characters */ export function fromHtml(input: string): string { return input .replace(/&lt;/g, '<') .replace(/&gt;/g, '>') .replace(/&amp;/g, '&') .replace(/&quot;/g, '"') .replace(/&#39;/g, "'"); } /** * Return the first non-repeating character in a string or a null string if all characters are unique * * @param {string} input Input string */ export function firstNonrepeatingChar(input: string): string { if (input == '') return ''; // this algorithm tends to run reasonably fast in practice, although complexity is still O(n^2). const len: number = input.length; let i: number let char = ''; for (i = 0; i < len; ++i) { char = input.charAt(i); if (input.indexOf(char) == i && input.indexOf(char,i+1) == -1) { return char; } } return ''; } /** * Reverse characters in a string * * @param {string} input Input string */ export function reverseChars(input: string): string { return input.split('').reverse().join(''); } /** * Convert an input string (presumed to be a name) into uppercase initials with an optional delimiter, i.e. * james tiberius kirk -> JTK or J.T.K. * * @param {string} input Input string */ export function initials(input: string, delim: string=''): string { return input.split(' ').map( (n:string): string => {return n.charAt(0).toUpperCase()} ).join(delim); } /** * Count the number of words in a string. * * @param {string} input Input string */ export function wordCount(input: string): number { if (input === undefined || input == null) return 0; if (input == '' || input == ' ') return 0; const matcher: RegExpMatchArray | null = input.match(/\b\w+\b/g); return matcher != null ? matcher.length : 0; } /** * Remove all instances of the input substring from the supplied string. * * @param {string} input Input string * * @param {string} remove Substring to be removed * * @param {boolean} caseSensitive Indicate if replacement is case sensitive. * @edefault {true} */ export function remove(input: string, remove: string, caseSensitive: boolean=true): string { if (input === undefined || input == null) return ''; if (input == '' || input == ' ') return input; const rem: string = __pattern(remove); const flags: string = (!caseSensitive) ? 'ig' : 'g'; return input.replace(new RegExp(rem, flags), ''); } /** * Is the input string numeric? * * @param {string} input Input string */ export function isNumeric(input: string): boolean { if (input === undefined && input == null) return false; if (input == '' || input == ' ') return false; // ha ha - another one I looked up on stackoverflow! const regex = /^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/; return regex.test(input); } export function __pattern(pattern: string): string { // of course I ripped this from stackoverflow ... what did you expect? return pattern.replace(/(\]|\[|\{|\}|\(|\)|\*|\+|\?|\.|\\)/g, '\\$1'); }

/** * Copyright 2016 Jim Armstrong (www.algorithmist.net) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * AMYR Library: Low-level, utils string utility functions (probably similar to many you have seen * elsewhere as there really isn't anything new under the sun). These methods are optimized for reasonable * performance and there is little error checking. You break it ... you buy it. Some methods are direct * replacement for lodash equivalents. * * @author Jim Armstrong (https://www.linkedin.com/in/jimarmstrong/) * * @version 1.0 */ export const WHITESPACE = [ ' ', '\n', '\r', '\t', '\f', '\v', '\u00A0', '\u1680', '\u180E', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004', '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200A', '\u2028', '\u2029', '\u202F', '\u205F', '\u3000' ]; /** * Determine if an input string starts exactly with the specified char string (case matters) * * @param {string} input Input string * * @param {string} target string to check against * @default 0 */ export function startsWith(input, target, position = 0) { const length = input.length || 0; if (!input || !target ) return false; // relatively quick string-convert target = `${target}`; const n = target.length; if (length == 0 && n == 0) { return true; } position = position < 0 ? 0 : (position >= length ? length-1 : position); return input.slice(position, position + n) === target } /** * Capitalize the first letter of a string and convert all remaining characters to lowercase * * @param {string} input String to be capitalized */ export function capitalize(input) { const n = input.length; if (n === 0) return input; if (n === 1) return input.toUpperCase(); return input.charAt(0).toUpperCase() + (input.substr(1, n)).toLowerCase(); } /** * Quick trim of spaces from a string * * @param {string} inputInput string */ export function trim(input) { return input.replace(/ /g, ''); } /** * Remove selected whitepsace characters from the beginning of a string * * @param {string} input Input string * * @param {Array<string>} white List of whitespace characters to be removed * @default {WHITESPACE} */ export /* Example usages of 'leftTrim' are shown below: leftTrim(rightTrim(input, chars), chars); */ function leftTrim(input, chars = WHITESPACE) { let start = 0; const len = input.length; const whiteLen = chars.length; let found = true; let i; let char; while (found && start < len) { found = false; i = -1; char = input.charAt(start); while (++i < whiteLen) { if (char === chars[i]) { found = true; start++; break; } } } return (start >= len) ? '' : input.substr(start, len); } /** * Remove selected whitespace characters from the end of a string * * @param {string} input Input string * * @param {Array<string>} white List of whitespace characters to be removed * @default {WHITESPACE} */ export /* Example usages of 'rightTrim' are shown below: leftTrim(rightTrim(input, chars), chars); */ function rightTrim(input, chars = WHITESPACE) { const len = input.length; let end = len-1; const whiteLen = chars.length; let found = true; let i; let char; while (found && end >= 0) { found = false; i = -1; char = input.charAt(end); while (++i < whiteLen) { if (char === chars[i]) { found = true; end--; break; } } } return (end >= 0) ? input.substr(0, end+1) : ''; } /** * Trim whitespace from beginning and end of a string based on a list of whitespace characters * (that may include line feeds and such) * * @param {string} input Input string * * @param {Array<string>} chars List of 'whitespace' characters to remove * @default {WHITESPACE} */ export function trimEnds(input, chars = WHITESPACE) { return leftTrim(rightTrim(input, chars), chars); } /** * Trim a string at the nearest (previous) space based on a character count with optional insertion of ellipses. * Original string is trimmed at nearest previous space, i.e. 'This is a test' is trimmed to 'This is a' * with a character count greater than nine or 'This is a...' if the ellipses parameter is true. * * @param input : input string * * @param count : number - Character count for trimming (must be greater than zero) * * @param ellipses: boolean If true, insert ellipses (...) after trip * @default {false} */ export function trimToCharCount(input, count, ellipses = false) { count = Math.max(1, Math.round(count)); const len = input.length; if (len < count) return input; if (input === ' ') return ''; let char = input.charAt(count-1); let end = count-1; while (end >= 0) { char = input.charAt(end--); if (char === ' ') break; } end = end < 0 ? count-1 : end; // add ellipses? return ellipses ? input.substring(0,end+1) + '...' : input.substring(0, end+1); } /** * Left-pad a string with a specified character if its length is smaller than the specified value * * @param {string} input Input string * * @param {number} len minimum length (must be greater than zero) * * @param {string} replaceWith: string Replacement string * @default ' ' (single space) */ export function leftPad(input, len, replaceWith = ' ') { len = Math.max(1, Math.round(len)); return ((input.length < len) ? repeat(replaceWith, len - input.length) + input : input); } /** * Right-pad a string with a specified character if its length is smaller than the specified value * * @param {string} input Input string * * @param {number} len minimum length (must be greater than zero) * * @param {string} replaceWith Replacement string * @default ' ' (single space) */ export function rightPad(input, len, replaceWith = ' ') { len = Math.max(1, Math.round(len)); return (input.length < len) ? input + repeat(replaceWith, len - input.length) : input; } /** * Repeat a string specified number of times * * @param {string} input Input string * * @param {number} n Repeat count (must be greater than zero) */ export /* Example usages of 'repeat' are shown below: (input.length < len) ? repeat(replaceWith, len - input.length) + input : input; (input.length < len) ? input + repeat(replaceWith, len - input.length) : input; */ function repeat(input, n) { n = Math.max(1, Math.round(n)); return (new Array(n + 1)).join(input); } /** * Escape a string to prepare for DOM insertion * * @param {string} input Input string with characters that require escaping before dynamic placement into DOM elements */ export function toHtml(input) { return input .replace(/</g, '&lt;') .replace(/>/g, '&gt;') .replace(/&/g, '&amp;') .replace(/"/g, '&quot;') .replace(/'/g, '&#39;'); } /** * Unescape HTML special characters (reverse of toHtml) * * @param {string} input Input string containing html-escaped characters */ export function fromHtml(input) { return input .replace(/&lt;/g, '<') .replace(/&gt;/g, '>') .replace(/&amp;/g, '&') .replace(/&quot;/g, '"') .replace(/&#39;/g, "'"); } /** * Return the first non-repeating character in a string or a null string if all characters are unique * * @param {string} input Input string */ export function firstNonrepeatingChar(input) { if (input == '') return ''; // this algorithm tends to run reasonably fast in practice, although complexity is still O(n^2). const len = input.length; let i let char = ''; for (i = 0; i < len; ++i) { char = input.charAt(i); if (input.indexOf(char) == i && input.indexOf(char,i+1) == -1) { return char; } } return ''; } /** * Reverse characters in a string * * @param {string} input Input string */ export function reverseChars(input) { return input.split('').reverse().join(''); } /** * Convert an input string (presumed to be a name) into uppercase initials with an optional delimiter, i.e. * james tiberius kirk -> JTK or J.T.K. * * @param {string} input Input string */ export function initials(input, delim='') { return input.split(' ').map( (n) => {return n.charAt(0).toUpperCase()} ).join(delim); } /** * Count the number of words in a string. * * @param {string} input Input string */ export function wordCount(input) { if (input === undefined || input == null) return 0; if (input == '' || input == ' ') return 0; const matcher = input.match(/\b\w+\b/g); return matcher != null ? matcher.length : 0; } /** * Remove all instances of the input substring from the supplied string. * * @param {string} input Input string * * @param {string} remove Substring to be removed * * @param {boolean} caseSensitive Indicate if replacement is case sensitive. * @edefault {true} */ export /* Example usages of 'remove' are shown below: ; __pattern(remove); */ function remove(input, remove, caseSensitive=true) { if (input === undefined || input == null) return ''; if (input == '' || input == ' ') return input; const rem = __pattern(remove); const flags = (!caseSensitive) ? 'ig' : 'g'; return input.replace(new RegExp(rem, flags), ''); } /** * Is the input string numeric? * * @param {string} input Input string */ export function isNumeric(input) { if (input === undefined && input == null) return false; if (input == '' || input == ' ') return false; // ha ha - another one I looked up on stackoverflow! const regex = /^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/; return regex.test(input); } export /* Example usages of '__pattern' are shown below: __pattern(remove); */ function __pattern(pattern) { // of course I ripped this from stackoverflow ... what did you expect? return pattern.replace(/(\]|\[|\{|\}|\(|\)|\*|\+|\?|\.|\\)/g, '\\$1'); }

a665fed0ae259c933eeb81c6c1c601dcc968e5ba

ts

TypeScript

src/structures/util/Color.ts

SevenTV/Website

285153a36974e2c5d0253c6a4279d2ab2491faf2

2022-03-02T10:34:23.000Z

2022-03-17T16:36:06.000Z

src/structures/util/Color.ts

SevenTV/Website

285153a36974e2c5d0253c6a4279d2ab2491faf2

2022-02-24T00:35:41.000Z

2022-03-31T00:28:44.000Z

src/structures/util/Color.ts

SevenTV/Website

285153a36974e2c5d0253c6a4279d2ab2491faf2

2022-03-06T18:30:59.000Z

2022-03-27T15:50:23.000Z

export const ConvertIntColorToHex = (color: number, alpha?: number) => { return `#${color.toString(16)}` + (alpha ? SetHexAlpha(alpha) : ""); }; export const SetHexAlpha = (alpha: number): string => { if (alpha > 1 || alpha < 0 || isNaN(alpha)) { throw Error("alpha must be between 0 and 1"); } return Math.ceil(255 * alpha) .toString(16) .toUpperCase(); }; export const ConvertRGBAToDecimal = (r: number, g: number, b: number, a: number): number => (r << 24) | (g << 16) | (b << 8) | a; export const ConvertDecimalRGBAToString = (num: number): string => { const r = (num >>> 24) & 0xff; const g = (num >>> 16) & 0xff; const b = (num >>> 8) & 0xff; const a = num & 0xff; return `rgba(${r}, ${g}, ${b}, ${(a / 255).toFixed(3)})`; }; export const ConvertHexToRGB = (hex: string): [number, number, number] => { const t = parseInt(hex?.slice(1) ?? "0", 16); const r = (t >> 16) & 255; const g = (t >> 8) & 255; const b = t & 255; return [r, g, b]; }; export const ConvertDecimalToHex = (num: number, alpha?: boolean): string => { const r = (num >>> 24) & 0xff; const g = (num >>> 16) & 0xff; const b = (num >>> 8) & 0xff; const a = num & 0xff; return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1) + (alpha ? SetHexAlpha(a / 255) : ""); }; export const ConvertIntToHSVColor = (color: number) => { const r = color >> 16; const g = (color >> 8) & ((1 << 8) - 1); const b = color & ((1 << 8) - 1); return ConvertRGBToHSVColor(r, g, b); }; export const ConvertRGBToHSVColor = (r: number, g: number, b: number) => { const rabs = r / 255; const gabs = g / 255; const babs = b / 255; const v = Math.max(rabs, gabs, babs); const diff = v - Math.min(rabs, gabs, babs); const diffc = (c: number) => (v - c) / 6 / diff + 1 / 2; const percentRoundFn = (num: number) => Math.round(num * 100) / 100; let h = 0; let s = 0; if (diff === 0) { h = s = 0; } else { s = diff / v; const rr = diffc(rabs); const gg = diffc(gabs); const bb = diffc(babs); if (rabs === v) { h = bb - gg; } else if (gabs === v) { h = 1 / 3 + rr - bb; } else if (babs === v) { h = 2 / 3 + gg - rr; } if (h < 0) { h += 1; } else if (h > 1) { h -= 1; } } return { h: Math.round(h * 360), s: percentRoundFn(s * 100), v: percentRoundFn(v * 100), }; }; export const hsv2hsl = (h: number, s: number, v: number, l = v - (v * s) / 2, m = Math.min(l, 1 - l)) => [ h, m ? (v - l) / m : 0, l, ]; export const hsl2hsv = (h: number, s: number, l: number, v = s * Math.min(l, 1 - l) + l) => [ h, v ? 2 - (2 * l) / v : 0, v, ]; export const NormalizeColor = (color: number, loweLight: number, upperLight: number) => { const r = color >> 16; const g = (color >> 8) & ((1 << 8) - 1); const b = color & ((1 << 8) - 1); const hsv = ConvertRGBToHSVColor(r, g, b); const hsl = hsv2hsl(hsv.h / 360, hsv.s / 100, hsv.v / 100).map((v) => v * 100); return `hsl(${hsl[0] * 3.6}deg, ${hsl[1]}%, ${ hsl[2] < loweLight ? loweLight : hsl[2] > upperLight ? upperLight : hsl[2] }%)`; };

export const ConvertIntColorToHex = (color, alpha?) => { return `#${color.toString(16)}` + (alpha ? SetHexAlpha(alpha) : ""); }; export /* Example usages of 'SetHexAlpha' are shown below: alpha ? SetHexAlpha(alpha) : ""; alpha ? SetHexAlpha(a / 255) : ""; */ const SetHexAlpha = (alpha) => { if (alpha > 1 || alpha < 0 || isNaN(alpha)) { throw Error("alpha must be between 0 and 1"); } return Math.ceil(255 * alpha) .toString(16) .toUpperCase(); }; export const ConvertRGBAToDecimal = (r, g, b, a) => (r << 24) | (g << 16) | (b << 8) | a; export const ConvertDecimalRGBAToString = (num) => { const r = (num >>> 24) & 0xff; const g = (num >>> 16) & 0xff; const b = (num >>> 8) & 0xff; const a = num & 0xff; return `rgba(${r}, ${g}, ${b}, ${(a / 255).toFixed(3)})`; }; export const ConvertHexToRGB = (hex) => { const t = parseInt(hex?.slice(1) ?? "0", 16); const r = (t >> 16) & 255; const g = (t >> 8) & 255; const b = t & 255; return [r, g, b]; }; export const ConvertDecimalToHex = (num, alpha?) => { const r = (num >>> 24) & 0xff; const g = (num >>> 16) & 0xff; const b = (num >>> 8) & 0xff; const a = num & 0xff; return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1) + (alpha ? SetHexAlpha(a / 255) : ""); }; export const ConvertIntToHSVColor = (color) => { const r = color >> 16; const g = (color >> 8) & ((1 << 8) - 1); const b = color & ((1 << 8) - 1); return ConvertRGBToHSVColor(r, g, b); }; export /* Example usages of 'ConvertRGBToHSVColor' are shown below: ConvertRGBToHSVColor(r, g, b); */ const ConvertRGBToHSVColor = (r, g, b) => { const rabs = r / 255; const gabs = g / 255; const babs = b / 255; const v = Math.max(rabs, gabs, babs); const diff = v - Math.min(rabs, gabs, babs); /* Example usages of 'diffc' are shown below: diffc(rabs); diffc(gabs); diffc(babs); */ const diffc = (c) => (v - c) / 6 / diff + 1 / 2; /* Example usages of 'percentRoundFn' are shown below: percentRoundFn(s * 100); percentRoundFn(v * 100); */ const percentRoundFn = (num) => Math.round(num * 100) / 100; let h = 0; let s = 0; if (diff === 0) { h = s = 0; } else { s = diff / v; const rr = diffc(rabs); const gg = diffc(gabs); const bb = diffc(babs); if (rabs === v) { h = bb - gg; } else if (gabs === v) { h = 1 / 3 + rr - bb; } else if (babs === v) { h = 2 / 3 + gg - rr; } if (h < 0) { h += 1; } else if (h > 1) { h -= 1; } } return { h: Math.round(h * 360), s: percentRoundFn(s * 100), v: percentRoundFn(v * 100), }; }; export /* Example usages of 'hsv2hsl' are shown below: hsv2hsl(hsv.h / 360, hsv.s / 100, hsv.v / 100).map((v) => v * 100); */ const hsv2hsl = (h, s, v, l = v - (v * s) / 2, m = Math.min(l, 1 - l)) => [ h, m ? (v - l) / m : 0, l, ]; export const hsl2hsv = (h, s, l, v = s * Math.min(l, 1 - l) + l) => [ h, v ? 2 - (2 * l) / v : 0, v, ]; export const NormalizeColor = (color, loweLight, upperLight) => { const r = color >> 16; const g = (color >> 8) & ((1 << 8) - 1); const b = color & ((1 << 8) - 1); const hsv = ConvertRGBToHSVColor(r, g, b); const hsl = hsv2hsl(hsv.h / 360, hsv.s / 100, hsv.v / 100).map((v) => v * 100); return `hsl(${hsl[0] * 3.6}deg, ${hsl[1]}%, ${ hsl[2] < loweLight ? loweLight : hsl[2] > upperLight ? upperLight : hsl[2] }%)`; };

a674ca2d53758362beae531b93f4d5c527eb5ec1

ts

TypeScript

src/app/script/klecks/image-operations/flood-fill.ts

satopian/klecks

aa1026c59ab925a275c330b3bbe552063c8c810f

2022-01-29T22:46:39.000Z

2022-03-28T15:42:22.000Z

src/app/script/klecks/image-operations/flood-fill.ts

satopian/klecks

aa1026c59ab925a275c330b3bbe552063c8c810f

2022-02-13T21:52:23.000Z

2022-03-31T16:07:47.000Z

src/app/script/klecks/image-operations/flood-fill.ts

satopian/klecks

aa1026c59ab925a275c330b3bbe552063c8c810f

2022-02-04T23:51:42.000Z

2022-03-21T12:31:44.000Z

/** * Flood fill. Tried https://github.com/binarymax/floodfill.js/ but it implemented tolerance wrong, and had bugs. * So, my own implementation. can handle tolerance, grow, opacity. * Needs to be optimized. */ /** * Set values in data within rect to 254, unless they're 255 * * @param data Uint8Array * @param width int * @param x0 int * @param y0 int * @param x1 int >x0 * @param y1 int >y0 */ function fillRect(data, width, x0, y0, x1, y1) { for (let x = x0; x <= x1; x++) { for (let y = y0; y <= y1; y++) { if (data[y * width + x] === 255) { continue; } data[y * width + x] = 254; } } } let mx, my; /** * Get index i moved by dX, dY. in array with dimensions width height. * Returns null if outside bounds. * * @param width int * @param height int * @param i int * @param dX int * @param dY int * @returns {null|*} */ function moveIndex(width, height, i, dX, dY) { mx = i % width + dX; my = Math.floor(i / width) + dY; if (mx < 0 || my < 0 || mx >= width || my >= height) { return null; } return my * width + mx; } /** * If pixel can be filled (within tolerance) will be set 255 and returns true. * returns false if already filled, or i is null * * @param srcArr Uint8Array rgba * @param targetArr Uint8Array * @param width int * @param height int * @param initRgba rgba * @param tolerance int 0 - 255 * @param i int - srcArr index * @returns {boolean} */ function testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, i) { if (i === null || targetArr[i] === 255) { return false; } if ( srcArr[i * 4] === initRgba[0] && srcArr[i * 4 + 1] === initRgba[1] && srcArr[i * 4 + 2] === initRgba[2] && srcArr[i * 4 + 3] === initRgba[3] ) { targetArr[i] = 255; return true; } if ( tolerance > 0 && Math.abs(srcArr[i * 4] - initRgba[0]) <= tolerance && Math.abs(srcArr[i * 4 + 1] - initRgba[1]) <= tolerance && Math.abs(srcArr[i * 4 + 2] - initRgba[2]) <= tolerance && Math.abs(srcArr[i * 4 + 3] - initRgba[3]) <= tolerance ) { targetArr[i] = 255; return true; } return false; } /** * * @param srcArr Uint8Array rgba * @param targetArr Uint8Array * @param width int * @param height int * @param px int * @param py int * @param tolerance int 0 - 255 * @param grow int >= 0 * @param isContiguous boolean */ function floodFill(srcArr, targetArr, width, height, px, py, tolerance, grow, isContiguous) { let initRgba = [ srcArr[(py * width + px) * 4], srcArr[(py * width + px) * 4 + 1], srcArr[(py * width + px) * 4 + 2], srcArr[(py * width + px) * 4 + 3] ]; if (isContiguous) { let q = []; q.push(py * width + px); targetArr[py * width + px] = 255; let i, e; while (q.length) { i = q.pop(); // queue up unfilled neighbors e = moveIndex(width, height, i, -1, 0); // left testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 1, 0); // right testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 0, -1); // up testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 0, 1); // bottom testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); } } else { for (let i = 0; i < width * height; i++) { testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, i); } } // grow if (grow === 0) { return; } // how does it grow? it finds all pixel at the edge. // then depending on what kind of edge it is, it draws a rectangle into target // the rectangle has the value 254, or else it mess it all up. // after it's all done, replaces it with 255 let x0, x1, y0, y1; let l, tl, t, tr, r, br, b, bl; // left, top left, top, top right, etc. for (let x = 0; x < width; x++) { for (let y = 0; y < height; y++) { if (targetArr[y * width + x] !== 255) { continue; } // bounds of rectangle x0 = x; x1 = x; y0 = y; y1 = y; l = targetArr[(y) * width + x - 1] !== 255; tl = targetArr[(y - 1) * width + x - 1] !== 255; t = targetArr[(y - 1) * width + x] !== 255; tr = targetArr[(y - 1) * width + x + 1] !== 255; r = targetArr[(y) * width + x + 1] !== 255; br = targetArr[(y + 1) * width + x + 1] !== 255; b = targetArr[(y + 1) * width + x] !== 255; bl = targetArr[(y + 1) * width + x - 1] !== 255; if (l) { // left x0 = x - grow; } if (l && tl && t) { // top left x0 = x - grow; y0 = y - grow; } if (t) { // top y0 = Math.min(y0, y - grow); } if (t && tr && r) { // top right y0 = Math.min(y0, y - grow); x1 = x + grow; } if (r) { // right x1 = Math.max(x1, x + 1 * grow); } if (r && br && b) { // bottom right x1 = Math.max(x1, x + 1 * grow); y1 = Math.max(y1, y + 1 * grow); } if (b) { // bottom y1 = Math.max(y1, y + 1 * grow); } if (b && bl && l) { // bottom left x0 = Math.min(x0, x - 1 * grow); y1 = Math.max(y1, y + 1 * grow); } if (!l && !tl && !t && !tr && !r && !br && !b && !bl) { continue; } fillRect( targetArr, width, Math.max(0, x0), Math.max(0, y0), Math.min(width - 1, x1), Math.min(height - 1, y1) ); } } for (let i = 0; i < width * height; i++) { if (targetArr[i] === 254) { targetArr[i] = 255; } } } /** * Does flood fill, and returns that. an array - 0 not filled. 255 filled * * returns { * data: Uint8Array * } * * @param rgbaArr Uint8Array rgba * @param width int * @param height int * @param x int * @param y int * @param tolerance int 0 - 255 * @param grow int >= 0 * @param isContiguous boolean * @returns {{data: Uint8Array}} */ export function floodFillBits(rgbaArr, width, height, x, y, tolerance, grow, isContiguous) { x = Math.round(x); y = Math.round(y); let resultArr = new Uint8Array(new ArrayBuffer(width * height)); floodFill(rgbaArr, resultArr, width, height, x, y, tolerance, grow, isContiguous); return { data: resultArr } }

/** * Flood fill. Tried https://github.com/binarymax/floodfill.js/ but it implemented tolerance wrong, and had bugs. * So, my own implementation. can handle tolerance, grow, opacity. * Needs to be optimized. */ /** * Set values in data within rect to 254, unless they're 255 * * @param data Uint8Array * @param width int * @param x0 int * @param y0 int * @param x1 int >x0 * @param y1 int >y0 */ /* Example usages of 'fillRect' are shown below: fillRect(targetArr, width, Math.max(0, x0), Math.max(0, y0), Math.min(width - 1, x1), Math.min(height - 1, y1)); */ function fillRect(data, width, x0, y0, x1, y1) { for (let x = x0; x <= x1; x++) { for (let y = y0; y <= y1; y++) { if (data[y * width + x] === 255) { continue; } data[y * width + x] = 254; } } } let mx, my; /** * Get index i moved by dX, dY. in array with dimensions width height. * Returns null if outside bounds. * * @param width int * @param height int * @param i int * @param dX int * @param dY int * @returns {null|*} */ /* Example usages of 'moveIndex' are shown below: // queue up unfilled neighbors e = moveIndex(width, height, i, -1, 0); e = moveIndex(width, height, i, 1, 0); e = moveIndex(width, height, i, 0, -1); e = moveIndex(width, height, i, 0, 1); */ function moveIndex(width, height, i, dX, dY) { mx = i % width + dX; my = Math.floor(i / width) + dY; if (mx < 0 || my < 0 || mx >= width || my >= height) { return null; } return my * width + mx; } /** * If pixel can be filled (within tolerance) will be set 255 and returns true. * returns false if already filled, or i is null * * @param srcArr Uint8Array rgba * @param targetArr Uint8Array * @param width int * @param height int * @param initRgba rgba * @param tolerance int 0 - 255 * @param i int - srcArr index * @returns {boolean} */ /* Example usages of 'testAndFill' are shown below: testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, i); */ function testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, i) { if (i === null || targetArr[i] === 255) { return false; } if ( srcArr[i * 4] === initRgba[0] && srcArr[i * 4 + 1] === initRgba[1] && srcArr[i * 4 + 2] === initRgba[2] && srcArr[i * 4 + 3] === initRgba[3] ) { targetArr[i] = 255; return true; } if ( tolerance > 0 && Math.abs(srcArr[i * 4] - initRgba[0]) <= tolerance && Math.abs(srcArr[i * 4 + 1] - initRgba[1]) <= tolerance && Math.abs(srcArr[i * 4 + 2] - initRgba[2]) <= tolerance && Math.abs(srcArr[i * 4 + 3] - initRgba[3]) <= tolerance ) { targetArr[i] = 255; return true; } return false; } /** * * @param srcArr Uint8Array rgba * @param targetArr Uint8Array * @param width int * @param height int * @param px int * @param py int * @param tolerance int 0 - 255 * @param grow int >= 0 * @param isContiguous boolean */ /* Example usages of 'floodFill' are shown below: floodFill(rgbaArr, resultArr, width, height, x, y, tolerance, grow, isContiguous); */ function floodFill(srcArr, targetArr, width, height, px, py, tolerance, grow, isContiguous) { let initRgba = [ srcArr[(py * width + px) * 4], srcArr[(py * width + px) * 4 + 1], srcArr[(py * width + px) * 4 + 2], srcArr[(py * width + px) * 4 + 3] ]; if (isContiguous) { let q = []; q.push(py * width + px); targetArr[py * width + px] = 255; let i, e; while (q.length) { i = q.pop(); // queue up unfilled neighbors e = moveIndex(width, height, i, -1, 0); // left testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 1, 0); // right testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 0, -1); // up testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); e = moveIndex(width, height, i, 0, 1); // bottom testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, e) && q.push(e); } } else { for (let i = 0; i < width * height; i++) { testAndFill(srcArr, targetArr, width, height, initRgba, tolerance, i); } } // grow if (grow === 0) { return; } // how does it grow? it finds all pixel at the edge. // then depending on what kind of edge it is, it draws a rectangle into target // the rectangle has the value 254, or else it mess it all up. // after it's all done, replaces it with 255 let x0, x1, y0, y1; let l, tl, t, tr, r, br, b, bl; // left, top left, top, top right, etc. for (let x = 0; x < width; x++) { for (let y = 0; y < height; y++) { if (targetArr[y * width + x] !== 255) { continue; } // bounds of rectangle x0 = x; x1 = x; y0 = y; y1 = y; l = targetArr[(y) * width + x - 1] !== 255; tl = targetArr[(y - 1) * width + x - 1] !== 255; t = targetArr[(y - 1) * width + x] !== 255; tr = targetArr[(y - 1) * width + x + 1] !== 255; r = targetArr[(y) * width + x + 1] !== 255; br = targetArr[(y + 1) * width + x + 1] !== 255; b = targetArr[(y + 1) * width + x] !== 255; bl = targetArr[(y + 1) * width + x - 1] !== 255; if (l) { // left x0 = x - grow; } if (l && tl && t) { // top left x0 = x - grow; y0 = y - grow; } if (t) { // top y0 = Math.min(y0, y - grow); } if (t && tr && r) { // top right y0 = Math.min(y0, y - grow); x1 = x + grow; } if (r) { // right x1 = Math.max(x1, x + 1 * grow); } if (r && br && b) { // bottom right x1 = Math.max(x1, x + 1 * grow); y1 = Math.max(y1, y + 1 * grow); } if (b) { // bottom y1 = Math.max(y1, y + 1 * grow); } if (b && bl && l) { // bottom left x0 = Math.min(x0, x - 1 * grow); y1 = Math.max(y1, y + 1 * grow); } if (!l && !tl && !t && !tr && !r && !br && !b && !bl) { continue; } fillRect( targetArr, width, Math.max(0, x0), Math.max(0, y0), Math.min(width - 1, x1), Math.min(height - 1, y1) ); } } for (let i = 0; i < width * height; i++) { if (targetArr[i] === 254) { targetArr[i] = 255; } } } /** * Does flood fill, and returns that. an array - 0 not filled. 255 filled * * returns { * data: Uint8Array * } * * @param rgbaArr Uint8Array rgba * @param width int * @param height int * @param x int * @param y int * @param tolerance int 0 - 255 * @param grow int >= 0 * @param isContiguous boolean * @returns {{data: Uint8Array}} */ export function floodFillBits(rgbaArr, width, height, x, y, tolerance, grow, isContiguous) { x = Math.round(x); y = Math.round(y); let resultArr = new Uint8Array(new ArrayBuffer(width * height)); floodFill(rgbaArr, resultArr, width, height, x, y, tolerance, grow, isContiguous); return { data: resultArr } }

a69d585dc2b6c26d17b76427c1eb6e676c7905ec

ts

TypeScript

src/utils.ts

mame/xterm-pty

4424b40ad7b5985e217b9aabc74ed3aa3678275b

2022-02-18T10:48:32.000Z

2022-03-24T18:32:26.000Z

src/utils.ts

mame/xterm-pty

4424b40ad7b5985e217b9aabc74ed3aa3678275b

src/utils.ts

mame/xterm-pty

4424b40ad7b5985e217b9aabc74ed3aa3678275b

export const BS = 8; export const TAB = 9; export const NL = 10; export const CR = 13; export const SP = 32; export const isalnum = (c: number) => (0x30 <= c && c <= 0x39) || (0x41 <= c && c <= 0x5a) || c == 0x5f || (0x61 <= c && c <= 0x7a); export const iscntrl = (c: number) => (0x00 <= c && c <= 0x1f && c != 0x09) || c == 0x7f; export const isUtf8ContinuationByte = (c: number) => (c & 0xc0) == 0x80; export const tolower = (c: number) => (0x41 <= c && c <= 0x5a ? c + 0x20 : c); export const toupper = (c: number) => (0x61 <= c && c <= 0x7a ? c - 0x20 : c); export const utf8BytesToString = (buf: number[]): [string, number[]] => { let str = ""; let i = 0; while (i < buf.length) { const b = buf[i]; let cp; if (b < 0x80) { cp = b; } else if ((b & 0xe0) == 0xc0) { if (buf.length <= i + 1) break; cp = (b & 0x1f) << 6; cp |= buf[++i] & 0x3f; } else if ((b & 0xf0) == 0xe0) { if (buf.length <= i + 2) break; cp = (b & 0x0f) << 12; cp |= (buf[++i] & 0x3f) << 6; cp |= buf[++i] & 0x3f; } else if ((b & 0xf8) == 0xf0) { if (buf.length <= i + 3) break; cp = (b & 0x03) << 18; cp |= (buf[++i] & 0x3f) << 12; cp |= (buf[++i] & 0x3f) << 6; cp |= buf[++i] & 0x3f; } else { cp = 0xfffe; } i++; str += String.fromCodePoint(cp); } return [str, buf.slice(i)]; }; export const stringToUtf8Bytes = (str: string) => { const bytes: number[] = []; for (let i = 0; i < str.length; ) { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion const cp = str.codePointAt(i)!; if (cp < 0x80) bytes.push(cp); else if (cp < 0x800) { bytes.push(0xc0 | (cp >> 6)); bytes.push(0x80 | (cp & 0x3f)); } else if (cp < 0x10000) { bytes.push(0xe0 | (cp >> 12)); bytes.push(0x80 | ((cp >> 6) & 0x3f)); bytes.push(0x80 | (cp & 0x3f)); } else { bytes.push(0xf0 | (cp >> 18)); bytes.push(0x80 | ((cp >> 12) & 0x3f)); bytes.push(0x80 | ((cp >> 6) & 0x3f)); bytes.push(0x80 | (cp & 0x3f)); } i += cp >= 0x10000 ? 2 : 1; } return bytes; };

export const BS = 8; export const TAB = 9; export const NL = 10; export const CR = 13; export const SP = 32; export const isalnum = (c) => (0x30 <= c && c <= 0x39) || (0x41 <= c && c <= 0x5a) || c == 0x5f || (0x61 <= c && c <= 0x7a); export const iscntrl = (c) => (0x00 <= c && c <= 0x1f && c != 0x09) || c == 0x7f; export const isUtf8ContinuationByte = (c) => (c & 0xc0) == 0x80; export const tolower = (c) => (0x41 <= c && c <= 0x5a ? c + 0x20 : c); export const toupper = (c) => (0x61 <= c && c <= 0x7a ? c - 0x20 : c); export const utf8BytesToString = (buf) => { let str = ""; let i = 0; while (i < buf.length) { const b = buf[i]; let cp; if (b < 0x80) { cp = b; } else if ((b & 0xe0) == 0xc0) { if (buf.length <= i + 1) break; cp = (b & 0x1f) << 6; cp |= buf[++i] & 0x3f; } else if ((b & 0xf0) == 0xe0) { if (buf.length <= i + 2) break; cp = (b & 0x0f) << 12; cp |= (buf[++i] & 0x3f) << 6; cp |= buf[++i] & 0x3f; } else if ((b & 0xf8) == 0xf0) { if (buf.length <= i + 3) break; cp = (b & 0x03) << 18; cp |= (buf[++i] & 0x3f) << 12; cp |= (buf[++i] & 0x3f) << 6; cp |= buf[++i] & 0x3f; } else { cp = 0xfffe; } i++; str += String.fromCodePoint(cp); } return [str, buf.slice(i)]; }; export const stringToUtf8Bytes = (str) => { const bytes = []; for (let i = 0; i < str.length; ) { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion const cp = str.codePointAt(i)!; if (cp < 0x80) bytes.push(cp); else if (cp < 0x800) { bytes.push(0xc0 | (cp >> 6)); bytes.push(0x80 | (cp & 0x3f)); } else if (cp < 0x10000) { bytes.push(0xe0 | (cp >> 12)); bytes.push(0x80 | ((cp >> 6) & 0x3f)); bytes.push(0x80 | (cp & 0x3f)); } else { bytes.push(0xf0 | (cp >> 18)); bytes.push(0x80 | ((cp >> 12) & 0x3f)); bytes.push(0x80 | ((cp >> 6) & 0x3f)); bytes.push(0x80 | (cp & 0x3f)); } i += cp >= 0x10000 ? 2 : 1; } return bytes; };

a6f9aec61c153682dc872f7fdabd8d491ac1618e

ts

TypeScript

day-24.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

2022-03-14T00:03:38.000Z

2022-03-14T11:51:27.000Z

day-24.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

day-24.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

export type Task = { taskId: number; estimatedTime: number; dependsOnTasks: number[]; }; export type ScheduledTask = { taskId: number; start: number; finish: number; }; /** * Christmas is coming! Santa Claus and his elves have to produce all the presents before the D-day. * In order to be as efficient as possible they want to schedule and parallelize as many tasks as possible. * * So they come up with a precise list of all the tasks including their dependencies and the time they will take. * Now we have to suggest the ideal timetable to achieve this goal. * * @param tasks - Define the tasks to achieve. * Tasks should not define circular dependencies, one task cannot be dependant on itself (even indirectly). * * The following implementation is based on the one suggested at https://algs4.cs.princeton.edu/44sp/CPM.java.html. * It solves the "parallel precedence-constrained job scheduling problem". */ export function christmasFactorySchedule(tasks: Task[]): ScheduledTask[] { const g = buildDirectedGraphFromTasks(tasks); const distTo = computeAcyclicLongestPath(g); return tasks.map( (task): ScheduledTask => ({ taskId: task.taskId, start: distTo[g.startVertexFor(task.taskId)], finish: distTo[g.finishVertexFor(task.taskId)], }) ); } type InternalTask = { estimatedTime: number; dependsOnTasks: number[]; }; type DirectedEdge = { from: number; to: number; weight: number; }; type DirectedGraph = { source: number; startVertexFor: (taskId: number) => number; finishVertexFor: (taskId: number) => number; numVertex: number; edges: DirectedEdge[]; }; function buildDirectedGraphFromTasks(tasks: Task[]): DirectedGraph { const n = tasks.length; const source = 2 * n; const sink = 2 * n + 1; const edges = tasks .map( (task): InternalTask => ({ estimatedTime: task.estimatedTime, dependsOnTasks: task.dependsOnTasks.map((taskId) => tasks.findIndex((t) => t.taskId === taskId) ), }) ) .flatMap((task, index): DirectedEdge[] => { return [ { from: source, to: index, weight: 0 }, { from: index + n, to: sink, weight: 0 }, { from: index, to: index + n, weight: task.estimatedTime }, //...task.dependsOnTasks.map((dependsOnTaskId) => ({ from: index + n, to: dependsOnTaskId, weight: 0 })), ...task.dependsOnTasks.map((dependsOnTaskId) => ({ from: dependsOnTaskId + n, to: index, weight: 0, })), ]; }); return { numVertex: 2 * n + 2, edges, source, startVertexFor: (taskId) => tasks.findIndex((t) => t.taskId === taskId), finishVertexFor: (taskId) => tasks.findIndex((t) => t.taskId === taskId) + n, }; } function computeAcyclicLongestPath(g: DirectedGraph): number[] { const distTo: number[] = Array(g.numVertex).fill(Number.NEGATIVE_INFINITY); distTo[g.source] = 0; for (const v of topologicalOrder(g)) { for (const e of g.edges.filter((e) => e.from === v)) { const w = e.to; if (distTo[w] < distTo[v] + e.weight) { distTo[w] = distTo[v] + e.weight; } } } return distTo; } function topologicalOrder(g: DirectedGraph): number[] { const marked = new Set<number>(); const postOrder: number[] = []; for (let v = 0; v !== g.numVertex; ++v) { if (!marked.has(v)) { postDfsInternal(g, v, marked, postOrder); } } return postOrder.reverse(); } function postDfsInternal( g: DirectedGraph, v: number, marked: Set<number>, acc: number[] ): void { marked.add(v); for (const adj of g.edges.filter((e) => e.from === v)) { if (!marked.has(adj.to)) { postDfsInternal(g, adj.to, marked, acc); } } acc.push(v); }

export type Task = { taskId; estimatedTime; dependsOnTasks; }; export type ScheduledTask = { taskId; start; finish; }; /** * Christmas is coming! Santa Claus and his elves have to produce all the presents before the D-day. * In order to be as efficient as possible they want to schedule and parallelize as many tasks as possible. * * So they come up with a precise list of all the tasks including their dependencies and the time they will take. * Now we have to suggest the ideal timetable to achieve this goal. * * @param tasks - Define the tasks to achieve. * Tasks should not define circular dependencies, one task cannot be dependant on itself (even indirectly). * * The following implementation is based on the one suggested at https://algs4.cs.princeton.edu/44sp/CPM.java.html. * It solves the "parallel precedence-constrained job scheduling problem". */ export function christmasFactorySchedule(tasks) { const g = buildDirectedGraphFromTasks(tasks); const distTo = computeAcyclicLongestPath(g); return tasks.map( (task) => ({ taskId: task.taskId, start: distTo[g.startVertexFor(task.taskId)], finish: distTo[g.finishVertexFor(task.taskId)], }) ); } type InternalTask = { estimatedTime; dependsOnTasks; }; type DirectedEdge = { from; to; weight; }; type DirectedGraph = { source; startVertexFor; finishVertexFor; numVertex; edges; }; /* Example usages of 'buildDirectedGraphFromTasks' are shown below: buildDirectedGraphFromTasks(tasks); */ function buildDirectedGraphFromTasks(tasks) { const n = tasks.length; const source = 2 * n; const sink = 2 * n + 1; const edges = tasks .map( (task) => ({ estimatedTime: task.estimatedTime, dependsOnTasks: task.dependsOnTasks.map((taskId) => tasks.findIndex((t) => t.taskId === taskId) ), }) ) .flatMap((task, index) => { return [ { from: source, to: index, weight: 0 }, { from: index + n, to: sink, weight: 0 }, { from: index, to: index + n, weight: task.estimatedTime }, //...task.dependsOnTasks.map((dependsOnTaskId) => ({ from: index + n, to: dependsOnTaskId, weight: 0 })), ...task.dependsOnTasks.map((dependsOnTaskId) => ({ from: dependsOnTaskId + n, to: index, weight: 0, })), ]; }); return { numVertex: 2 * n + 2, edges, source, startVertexFor: (taskId) => tasks.findIndex((t) => t.taskId === taskId), finishVertexFor: (taskId) => tasks.findIndex((t) => t.taskId === taskId) + n, }; } /* Example usages of 'computeAcyclicLongestPath' are shown below: computeAcyclicLongestPath(g); */ function computeAcyclicLongestPath(g) { const distTo = Array(g.numVertex).fill(Number.NEGATIVE_INFINITY); distTo[g.source] = 0; for (const v of topologicalOrder(g)) { for (const e of g.edges.filter((e) => e.from === v)) { const w = e.to; if (distTo[w] < distTo[v] + e.weight) { distTo[w] = distTo[v] + e.weight; } } } return distTo; } /* Example usages of 'topologicalOrder' are shown below: topologicalOrder(g); */ function topologicalOrder(g) { const marked = new Set<number>(); const postOrder = []; for (let v = 0; v !== g.numVertex; ++v) { if (!marked.has(v)) { postDfsInternal(g, v, marked, postOrder); } } return postOrder.reverse(); } /* Example usages of 'postDfsInternal' are shown below: postDfsInternal(g, v, marked, postOrder); postDfsInternal(g, adj.to, marked, acc); */ function postDfsInternal( g, v, marked, acc ) { marked.add(v); for (const adj of g.edges.filter((e) => e.from === v)) { if (!marked.has(adj.to)) { postDfsInternal(g, adj.to, marked, acc); } } acc.push(v); }

98000e7ea7d9f88c6c0f12d701d19d81441d0dd5

ts

TypeScript

src/app/ChymallServices/helpers/datetranslate.ts

Natdiv/chymall-app

bc52466ffe7f49187bfe1d13c5beb49fd69d3232

2022-03-06T22:11:43.000Z

2022-03-06T22:11:43.000Z

src/app/ChymallServices/helpers/datetranslate.ts

Natdiv/chymall-app

bc52466ffe7f49187bfe1d13c5beb49fd69d3232

2022-02-13T23:15:16.000Z

2022-03-02T10:09:20.000Z

src/app/ChymallServices/helpers/datetranslate.ts

Natdiv/chymall-app

bc52466ffe7f49187bfe1d13c5beb49fd69d3232

export class Datetranslate { public static getFrenchDay(date: Date) { const day = date.getDay(); switch (day) { case 1: return 'Lundi'; case 2: return 'Mardi'; case 3: return 'Mercredi'; case 4: return 'Jeudi'; case 5: return 'Vendredi'; case 6: return 'Samedi'; case 7: return 'Dimanche'; default: return ''; } } public static getFrenchMonth(date: Date) { const month = date.getMonth(); switch (month) { case 0: return 'Janvier'; case 1: return 'Février'; case 2: return 'Mars'; case 3: return 'Avril'; case 4: return 'Mai'; case 5: return 'Juin'; case 6: return 'Juillet'; case 7: return 'Août'; case 8: return 'Septembre'; case 9: return 'Octobre'; case 10: return 'Novembre'; case 11: return 'Décembre'; default: return ''; } } public static formatInFrench(date: Date) { const month = Datetranslate.getFrenchMonth(date); const dayweek = Datetranslate.getFrenchDay(date); const chaine = dayweek + ' ' + date.getDate() + ' ' + month + ' ' + date.getFullYear(); return chaine; } }

export class Datetranslate { public static getFrenchDay(date) { const day = date.getDay(); switch (day) { case 1: return 'Lundi'; case 2: return 'Mardi'; case 3: return 'Mercredi'; case 4: return 'Jeudi'; case 5: return 'Vendredi'; case 6: return 'Samedi'; case 7: return 'Dimanche'; default: return ''; } } public static getFrenchMonth(date) { const month = date.getMonth(); switch (month) { case 0: return 'Janvier'; case 1: return 'Février'; case 2: return 'Mars'; case 3: return 'Avril'; case 4: return 'Mai'; case 5: return 'Juin'; case 6: return 'Juillet'; case 7: return 'Août'; case 8: return 'Septembre'; case 9: return 'Octobre'; case 10: return 'Novembre'; case 11: return 'Décembre'; default: return ''; } } public static formatInFrench(date) { const month = Datetranslate.getFrenchMonth(date); const dayweek = Datetranslate.getFrenchDay(date); const chaine = dayweek + ' ' + date.getDate() + ' ' + month + ' ' + date.getFullYear(); return chaine; } }

98134d8b39c30fa1b56afbccd90b832c3f8eb635

ts

TypeScript

src/react/TransformStyles.ts

dipeshrai123/re-motion

5b768bb54c8806666f3ffb9ff6782df4381fca95

2022-03-24T13:46:32.000Z

2022-03-24T13:46:32.000Z

src/react/TransformStyles.ts

dipeshrai123/re-motion

5b768bb54c8806666f3ffb9ff6782df4381fca95

2022-02-28T12:04:00.000Z

2022-02-28T12:04:00.000Z

src/react/TransformStyles.ts

dipeshrai123/re-motion

5b768bb54c8806666f3ffb9ff6782df4381fca95

/** * style keys which can be accepted by animated component */ export const styleTrasformKeys = [ 'perspective', 'translate', 'translateX', 'translateY', 'translateZ', 'scale', 'scaleX', 'scaleY', 'scaleZ', 'rotate', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY', ] as const; function splitCSSValueAndUnit(value: string) { const valueMatch = value.match(/(-)?(\d+.)?\d+/g); const unitMatch = value.match( /px|rem|em|ex|%|cm|mm|in|pt|pc|ch|vh|vw|vmin|vmax/ ); return { value: Number(valueMatch), unit: unitMatch && unitMatch[0], }; } // get unit of transform style property function getValueUnit(property: string, value: string) { let unit; const splitValue = splitCSSValueAndUnit(String(value)).value; const splitUnit = splitCSSValueAndUnit(String(value)).unit; // if string value is passed with unit then split it if (splitUnit) { return { value: splitValue, unit: splitUnit }; } if ( property.indexOf('translate') !== -1 || property.indexOf('perspective') !== -1 ) { unit = 'px'; } else if (property.indexOf('scale') !== -1) { unit = ''; } else if ( property.indexOf('rotate') !== -1 || property.indexOf('skew') !== -1 ) { unit = 'deg'; } return { value, unit }; } function getTransformValueWithUnits(property: string, value: string) { const valueUnit = getValueUnit(property, value); if ( property.indexOf('X') !== -1 || property.indexOf('Y') !== -1 || property.indexOf('Z') !== -1 || property.indexOf('perspective') !== -1 || property.indexOf('rotate') !== -1 || property.indexOf('skew') !== -1 ) { // axis value return `${property}(${valueUnit.value}${valueUnit.unit})`; } else if ( property.indexOf('translate') !== -1 || property.indexOf('scale') !== -1 ) { // two parameter value return `${property}(${valueUnit.value}${valueUnit.unit}, ${valueUnit.value}${valueUnit.unit})`; } else { throw new Error(`Error! Property '${property}' cannot be transformed`); } } /** * getTransform function returns transform string from style object */ export function getTransform(style: any) { const styleKeys: any = Object.keys(style); return styleKeys .map(function (styleProp: string) { const value = style[styleProp]; return getTransformValueWithUnits(styleProp, value); }) .reduce(function (transform: string, value: number) { return (transform += ` ${value}`); }, '') .trim(); }

/** * style keys which can be accepted by animated component */ export const styleTrasformKeys = [ 'perspective', 'translate', 'translateX', 'translateY', 'translateZ', 'scale', 'scaleX', 'scaleY', 'scaleZ', 'rotate', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY', ] as const; /* Example usages of 'splitCSSValueAndUnit' are shown below: splitCSSValueAndUnit(String(value)).value; splitCSSValueAndUnit(String(value)).unit; */ function splitCSSValueAndUnit(value) { const valueMatch = value.match(/(-)?(\d+.)?\d+/g); const unitMatch = value.match( /px|rem|em|ex|%|cm|mm|in|pt|pc|ch|vh|vw|vmin|vmax/ ); return { value: Number(valueMatch), unit: unitMatch && unitMatch[0], }; } // get unit of transform style property /* Example usages of 'getValueUnit' are shown below: getValueUnit(property, value); */ function getValueUnit(property, value) { let unit; const splitValue = splitCSSValueAndUnit(String(value)).value; const splitUnit = splitCSSValueAndUnit(String(value)).unit; // if string value is passed with unit then split it if (splitUnit) { return { value: splitValue, unit: splitUnit }; } if ( property.indexOf('translate') !== -1 || property.indexOf('perspective') !== -1 ) { unit = 'px'; } else if (property.indexOf('scale') !== -1) { unit = ''; } else if ( property.indexOf('rotate') !== -1 || property.indexOf('skew') !== -1 ) { unit = 'deg'; } return { value, unit }; } /* Example usages of 'getTransformValueWithUnits' are shown below: getTransformValueWithUnits(styleProp, value); */ function getTransformValueWithUnits(property, value) { const valueUnit = getValueUnit(property, value); if ( property.indexOf('X') !== -1 || property.indexOf('Y') !== -1 || property.indexOf('Z') !== -1 || property.indexOf('perspective') !== -1 || property.indexOf('rotate') !== -1 || property.indexOf('skew') !== -1 ) { // axis value return `${property}(${valueUnit.value}${valueUnit.unit})`; } else if ( property.indexOf('translate') !== -1 || property.indexOf('scale') !== -1 ) { // two parameter value return `${property}(${valueUnit.value}${valueUnit.unit}, ${valueUnit.value}${valueUnit.unit})`; } else { throw new Error(`Error! Property '${property}' cannot be transformed`); } } /** * getTransform function returns transform string from style object */ export function getTransform(style) { const styleKeys = Object.keys(style); return styleKeys .map(function (styleProp) { const value = style[styleProp]; return getTransformValueWithUnits(styleProp, value); }) .reduce(function (transform, value) { return (transform += ` ${value}`); }, '') .trim(); }

9824df1e1ab70908c6c3c952d7f8ed237842e242

ts

TypeScript

src/command/tokenize.ts

bridge-core/common-utils

a3be7ee0c169667c73ec93735812f7cc044a32a3

src/command/tokenize.ts

bridge-core/common-utils

a3be7ee0c169667c73ec93735812f7cc044a32a3

src/command/tokenize.ts

bridge-core/common-utils

a3be7ee0c169667c73ec93735812f7cc044a32a3

2022-01-20T18:35:59.000Z

2022-01-20T18:35:59.000Z

/** * Tokenize a Minecraft command * @param command * @returns */ export function tokenizeCommand(command: string) { let curlyBrackets = 0 let squareBrackets = 0 let inQuotes = false let i = 0 let wordStart = 0 let word = '' let tokens = [] while (i < command.length) { if ( (command[i] === '^' && word[0] === '^') || (command[i] === '~' && word[0] === '~') ) { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = command[i] } else if (command[i] === '"') { word += command[i] if (inQuotes) { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = '' } inQuotes = !inQuotes } else if (command[i] === ' ' || command[i] === '\t') { if (inQuotes) { word += command[i] i++ continue } if (curlyBrackets === 0 && squareBrackets === 0 && word !== '') { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = '' } } else { if (command[i] === '{') { curlyBrackets++ } else if (command[i] === '}') { curlyBrackets-- } else if (command[i] === '[') { squareBrackets++ } else if (command[i] === ']') { squareBrackets-- } if (command[i].trim() !== '') word += command[i] } i++ } tokens.push({ startColumn: wordStart, endColumn: i, word, }) return { tokens } } /** * Tokenize target selectors that may appear inside of Minecraft's commands * @param targetSelector * * @example "@a[tag=test]" > [{ startColumn: ..., endColumn: ..., word: "tag" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test" }] * @example "@a[tag=test,tag2=test2]" > [{ startColumn: ..., endColumn: ..., word: "tag" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test" }, { startColumn: ..., endColumn: ..., word: "," }, { startColumn: ..., endColumn: ..., word: "tag2" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test2" }] */ export function tokenizeTargetSelector(targetSelector: string, wordOffset = 0) { let i = 0 let wordStart = 0 let word = '' let tokens = [] while (i < targetSelector.length) { // TODO: Properly support advanced score selector: "scores={something=..1,something_else=0..2}" if (targetSelector[i] === '=') { tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) wordStart = i + 1 word = '' if (targetSelector[i + 1] === '!') { tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset + 1, word: '=!', }) i++ wordStart++ } else { tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset, word: '=', }) } } else if (targetSelector[i] === ',') { tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) wordStart = i + 1 word = '' tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset, word: ',', }) } else { if (targetSelector[i].trim() === '' && wordStart === i) wordStart++ word += targetSelector[i].trim() } i++ } tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) return { tokens } }

/** * Tokenize a Minecraft command * @param command * @returns */ export function tokenizeCommand(command) { let curlyBrackets = 0 let squareBrackets = 0 let inQuotes = false let i = 0 let wordStart = 0 let word = '' let tokens = [] while (i < command.length) { if ( (command[i] === '^' && word[0] === '^') || (command[i] === '~' && word[0] === '~') ) { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = command[i] } else if (command[i] === '"') { word += command[i] if (inQuotes) { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = '' } inQuotes = !inQuotes } else if (command[i] === ' ' || command[i] === '\t') { if (inQuotes) { word += command[i] i++ continue } if (curlyBrackets === 0 && squareBrackets === 0 && word !== '') { tokens.push({ startColumn: wordStart, endColumn: i, word, }) wordStart = i + 1 word = '' } } else { if (command[i] === '{') { curlyBrackets++ } else if (command[i] === '}') { curlyBrackets-- } else if (command[i] === '[') { squareBrackets++ } else if (command[i] === ']') { squareBrackets-- } if (command[i].trim() !== '') word += command[i] } i++ } tokens.push({ startColumn: wordStart, endColumn: i, word, }) return { tokens } } /** * Tokenize target selectors that may appear inside of Minecraft's commands * @param targetSelector * * @example "@a[tag=test]" > [{ startColumn: ..., endColumn: ..., word: "tag" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test" }] * @example "@a[tag=test,tag2=test2]" > [{ startColumn: ..., endColumn: ..., word: "tag" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test" }, { startColumn: ..., endColumn: ..., word: "," }, { startColumn: ..., endColumn: ..., word: "tag2" }, { startColumn: ..., endColumn: ..., word: "=" }, { startColumn: ..., endColumn: ..., word: "test2" }] */ export function tokenizeTargetSelector(targetSelector, wordOffset = 0) { let i = 0 let wordStart = 0 let word = '' let tokens = [] while (i < targetSelector.length) { // TODO: Properly support advanced score selector: "scores={something=..1,something_else=0..2}" if (targetSelector[i] === '=') { tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) wordStart = i + 1 word = '' if (targetSelector[i + 1] === '!') { tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset + 1, word: '=!', }) i++ wordStart++ } else { tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset, word: '=', }) } } else if (targetSelector[i] === ',') { tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) wordStart = i + 1 word = '' tokens.push({ startColumn: i + wordOffset, endColumn: wordStart + wordOffset, word: ',', }) } else { if (targetSelector[i].trim() === '' && wordStart === i) wordStart++ word += targetSelector[i].trim() } i++ } tokens.push({ startColumn: wordStart + wordOffset, endColumn: i + wordOffset, word, }) return { tokens } }

982df982b3c52b9f90008fa7aeefb3502e4c2543

ts

TypeScript

src/arithmetic/fractions.ts

donatto-minaya/ax-calculator

1b015e2e58796b76bd40fa3055b8709e51137a08

2022-01-04T20:01:33.000Z

2022-02-24T03:27:24.000Z

src/arithmetic/fractions.ts

donatto22/ax-calculator

1b015e2e58796b76bd40fa3055b8709e51137a08

src/arithmetic/fractions.ts

donatto22/ax-calculator

1b015e2e58796b76bd40fa3055b8709e51137a08

2022-02-15T23:35:52.000Z

2022-02-15T23:35:52.000Z

export const Fractions = { sum: function(numerator1: number, denominator1: number, numerator2: number, denominator2: number) { let result, bober = false; if(denominator1 == denominator2) { // When dominators are equals let top = numerator1 + numerator2 let bottom = denominator1 //Check if negative if(top < 0) { bober = true; top = top * -1; } if((top / bottom) % 1 == 0) { result = String(top / bottom) } else { result = String(top) + "/" + String(bottom); } } else { // When dominators are different let top = (denominator2 * numerator1) + (denominator1 * numerator2) let bottom = denominator1 * denominator2 result = simplify(top, bottom); } return result; }, substract: function(numerator1: number, denominator1: number, numerator2: number, denominator2: number) { var result; if(denominator1 == denominator2) { // When dominators are equals var top = numerator1 - numerator2 var bottom = denominator1 if((top / bottom) % 1 == 0) { result = String(top / bottom) } else { result = String(top) + "/" + String(bottom); } } else { // When dominators are different var top = (denominator2 * numerator1) - (denominator1 * numerator2) var bottom = denominator1 * denominator2 result = simplify(top, bottom); } return result; }, product: function(numerator1: number, denominator1: number, numerator2: number, denominator2: number) { var top = numerator1 * numerator2; var bottom = denominator1 * denominator2; return simplify(top, bottom); }, division: function(numerator1: number, denominator1: number, numerator2: number, denominator2: number) { var top = numerator1 * denominator2; var bottom = denominator1 * numerator2; return simplify(top, bottom); }, /** @param top - Numerator @param bottom - Denominator **/ simplify: function(top: number, bottom: number) { return simplify(top, bottom); }, /** @param fraction **/ destructure: function(fraction: string) { return destructure(fraction); } } function simplify(top: number, bottom: number): string { let result = ''; var bober = false; if(top < 0) { bober = true; top = top * -1; } if(bottom < 0) { bober = true; bottom = bottom * -1; } for(let i = 2; i < 20; i++) { while((top / i > 0) && ((bottom / i) > 0)) { if((top % i == 0) && ((bottom % i) == 0)) { top = top / i; bottom = bottom / i; } else{ if(bober) { result = "-" + String(top) + "/" + String(bottom) } else { result = String(top) + "/" + String(bottom) } break; } } } return result; } function destructure(string: string) { let array = string.split('/'); var top = array[0], bottom = array[1]; return { top, bottom } }

export const Fractions = { sum: function(numerator1, denominator1, numerator2, denominator2) { let result, bober = false; if(denominator1 == denominator2) { // When dominators are equals let top = numerator1 + numerator2 let bottom = denominator1 //Check if negative if(top < 0) { bober = true; top = top * -1; } if((top / bottom) % 1 == 0) { result = String(top / bottom) } else { result = String(top) + "/" + String(bottom); } } else { // When dominators are different let top = (denominator2 * numerator1) + (denominator1 * numerator2) let bottom = denominator1 * denominator2 result = simplify(top, bottom); } return result; }, substract: function(numerator1, denominator1, numerator2, denominator2) { var result; if(denominator1 == denominator2) { // When dominators are equals var top = numerator1 - numerator2 var bottom = denominator1 if((top / bottom) % 1 == 0) { result = String(top / bottom) } else { result = String(top) + "/" + String(bottom); } } else { // When dominators are different var top = (denominator2 * numerator1) - (denominator1 * numerator2) var bottom = denominator1 * denominator2 result = simplify(top, bottom); } return result; }, product: function(numerator1, denominator1, numerator2, denominator2) { var top = numerator1 * numerator2; var bottom = denominator1 * denominator2; return simplify(top, bottom); }, division: function(numerator1, denominator1, numerator2, denominator2) { var top = numerator1 * denominator2; var bottom = denominator1 * numerator2; return simplify(top, bottom); }, /** @param top - Numerator @param bottom - Denominator **/ simplify: function(top, bottom) { return simplify(top, bottom); }, /** @param fraction **/ destructure: function(fraction) { return destructure(fraction); } } /* Example usages of 'simplify' are shown below: result = simplify(top, bottom); simplify(top, bottom); * @param top - Numerator @param bottom - Denominator * ; */ function simplify(top, bottom) { let result = ''; var bober = false; if(top < 0) { bober = true; top = top * -1; } if(bottom < 0) { bober = true; bottom = bottom * -1; } for(let i = 2; i < 20; i++) { while((top / i > 0) && ((bottom / i) > 0)) { if((top % i == 0) && ((bottom % i) == 0)) { top = top / i; bottom = bottom / i; } else{ if(bober) { result = "-" + String(top) + "/" + String(bottom) } else { result = String(top) + "/" + String(bottom) } break; } } } return result; } /* Example usages of 'destructure' are shown below: * @param fraction * ; destructure(fraction); */ function destructure(string) { let array = string.split('/'); var top = array[0], bottom = array[1]; return { top, bottom } }

98f45a45b0cd927be1978060c2e2bccd7e68e1be

ts

TypeScript

src/parse.ts

KeithAlt/FTP-Deploy-Action

d6ad227aa5444819c601ca2590fd1b921aafdef8

2022-01-29T19:13:26.000Z

2022-01-29T19:13:26.000Z

src/parse.ts

KeithAlt/FTP-Deploy-Action

d6ad227aa5444819c601ca2590fd1b921aafdef8

src/parse.ts

KeithAlt/FTP-Deploy-Action

d6ad227aa5444819c601ca2590fd1b921aafdef8

export function optionalString(rawValue: string): string | undefined { if (rawValue.length === 0) { return undefined; } return rawValue; } export function optionalBoolean(argumentName: string, rawValue: string): boolean | undefined { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "true") { return true; } if (cleanValue === "false") { return false; } throw new Error(`${argumentName}: invalid parameter - please use a boolean, you provided "${rawValue}". Try true or false instead.`); } export function optionalProtocol(argumentName: string, rawValue: string): "ftp" | "ftps" | "ftps-legacy" | undefined { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "ftp") { return "ftp"; } if (cleanValue === "ftps") { return "ftps"; } if (cleanValue === "ftps-legacy") { return "ftps-legacy"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "ftp", "ftps", or "ftps-legacy" instead.`); } export function optionalLogLevel(argumentName: string, rawValue: string): "minimal" | "standard" | "verbose" | undefined { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "minimal") { return "minimal"; } if (cleanValue === "standard") { return "standard"; } if (cleanValue === "verbose") { return "verbose"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "minimal", "standard", or "verbose" instead.`); } export function optionalSecurity(argumentName: string, rawValue: string): "loose" | "strict" | undefined { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "loose") { return "loose"; } if (cleanValue === "strict") { return "strict"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "loose" or "strict" instead.`); } export function optionalInt(argumentName: string, rawValue: string): number | undefined { if (rawValue.length === 0) { return undefined; } const valueAsNumber = parseFloat(rawValue); if (Number.isInteger(valueAsNumber)) { return valueAsNumber; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try a whole number (no decimals) instead like 1234`); } export function optionalStringArray(argumentName: string, rawValue: string[]): string[] | undefined { if (typeof rawValue === "string") { throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". This option expects an list in the EXACT format described in the readme`); } return rawValue; }

export function optionalString(rawValue) { if (rawValue.length === 0) { return undefined; } return rawValue; } export function optionalBoolean(argumentName, rawValue) { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "true") { return true; } if (cleanValue === "false") { return false; } throw new Error(`${argumentName}: invalid parameter - please use a boolean, you provided "${rawValue}". Try true or false instead.`); } export function optionalProtocol(argumentName, rawValue) { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "ftp") { return "ftp"; } if (cleanValue === "ftps") { return "ftps"; } if (cleanValue === "ftps-legacy") { return "ftps-legacy"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "ftp", "ftps", or "ftps-legacy" instead.`); } export function optionalLogLevel(argumentName, rawValue) { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "minimal") { return "minimal"; } if (cleanValue === "standard") { return "standard"; } if (cleanValue === "verbose") { return "verbose"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "minimal", "standard", or "verbose" instead.`); } export function optionalSecurity(argumentName, rawValue) { if (rawValue.length === 0) { return undefined; } const cleanValue = rawValue.toLowerCase(); if (cleanValue === "loose") { return "loose"; } if (cleanValue === "strict") { return "strict"; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "loose" or "strict" instead.`); } export function optionalInt(argumentName, rawValue) { if (rawValue.length === 0) { return undefined; } const valueAsNumber = parseFloat(rawValue); if (Number.isInteger(valueAsNumber)) { return valueAsNumber; } throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try a whole number (no decimals) instead like 1234`); } export function optionalStringArray(argumentName, rawValue) { if (typeof rawValue === "string") { throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". This option expects an list in the EXACT format described in the readme`); } return rawValue; }

cf0796b6a6d7cd2657a854a73c3e908fae288953

ts

TypeScript

wwwroot/libs/vidyano/common/string.ts

Vidyano/vidyano

1c7639568974515e821dd033beff6df360a3ca58

wwwroot/libs/vidyano/common/string.ts

Vidyano/vidyano

1c7639568974515e821dd033beff6df360a3ca58

2022-03-16T12:52:46.000Z

2022-03-25T12:05:18.000Z

wwwroot/libs/vidyano/common/string.ts

Vidyano/vidyano

1c7639568974515e821dd033beff6df360a3ca58

declare global { export interface String { asDataUri(): string; contains(str: string): boolean; endsWith(suffix: string): boolean; insert(str: string, index: number): string; padLeft(width: number, str?: string): string; padRight(width: number, str?: string): string; splitWithTail(separator: string | RegExp, limit?: number): string[]; toKebabCase(): string; trimEnd(char: string): string; trimStart(char: string): string; } export interface StringConstructor { isNullOrEmpty(str: string): boolean; isNullOrWhiteSpace(str: string): boolean; format(format: string, ...args: any[]): string; fromChar(ch: string, count: number): string; } } String.prototype.contains = function(it: string) { return this.indexOf(it) != -1; }; String.prototype.padLeft = function(totalWidth: number, ch: string) { if (this.length < totalWidth) { return String.fromChar(ch || ' ', totalWidth - this.length) + this; } return this.substring(0, this.length); }; String.prototype.padRight = function(totalWidth: number, ch?: string) { if (this.length < totalWidth) { return this + String.fromChar(ch || ' ', totalWidth - this.length); } return this.substring(0, this.length); }; const trimStart = String.prototype.trimStart; String.prototype.trimStart = <any>function(ch?: string) { if (!ch || !this.length) return trimStart.apply(this); ch = ch || ' '; var i = 0; for (; this.charAt(i) == ch && i < this.length; i++); return this.substring(i); }; const trimEnd = String.prototype.trimEnd; String.prototype.trimEnd = <any>function(ch?: string) { if (!ch || !this.length) return trimEnd.apply(this); ch = ch ? ch : ' '; var i = this.length - 1; for (; i >= 0 && this.charAt(i) == ch; i--); return this.substring(0, i + 1); }; String.prototype.insert = function(str: string, index: number) { var length = this.length; if (index == length) { return this.substring(0, index) + str; } return this.substring(0, index) + str + this.substring(index, length); }; String.prototype.asDataUri = function() { if (/^iVBOR/.test(this)) return "data:image/png;base64," + this; if (/^\/9j\//.test(this)) return "data:image/jpeg;base64," + this; if (/^R0lGOD/.test(this)) return "data:image/gif;base64," + this; if (/^Qk/.test(this)) return "data:image/bmp;base64," + this; if (/^PD94/.test(this)) return "data:image/svg+xml;base64," + this; return ""; }; String.prototype.toKebabCase = function() { if (!this || this === this.toLowerCase()) return this; var _this = this; return Array.from(this as string).map(function(c, i) { var cLower = c.toLowerCase(); if (c === cLower) return c; if (i === 0) return cLower; var cPrev = _this[i - 1]; if (!/^[a-zA-Z]+$/.test(cPrev)) return cLower; var cPrevLower = cPrev.toLowerCase(); if (cPrev === cPrevLower) return "-" + cLower; if (i + 1 === _this.length) return cLower; var cNext = _this[i + 1]; var cNextUpper = cNext.toUpperCase(); if (cNext === cNextUpper) return cLower; return "-" + cLower; }).join(""); } String.prototype.splitWithTail = function(separator: string | RegExp, limit?: number): string[] { let pattern: RegExp, startIndex: number, m: RegExpExecArray; const parts: string[] = []; if (!limit) return this.split(separator); if (separator instanceof RegExp) pattern = new RegExp(separator.source, "g" + (separator.ignoreCase ? "i" : "") + (separator.multiline ? "m" : "")); else pattern = new RegExp(separator.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1"), "g"); do { startIndex = pattern.lastIndex; if (m = pattern.exec(this)) { parts.push(this.substr(startIndex, m.index - startIndex)); } } while (m && parts.length < limit - 1); parts.push(this.substr(pattern.lastIndex)); return parts; } String.isNullOrEmpty = function(str: string) { return str == null || str.length == 0; }; String.isNullOrWhiteSpace = function(str: string) { return str == null || !(/\S/.test(str)); }; const _formatRE = /(\{[^\}^\{]+\})/g; const _format = function(format: string, values: any[], useLocale: boolean) { return format.replace(_formatRE, function (m) { var index = parseInt(m.substr(1), 10); var value = values[index]; if (value == null) return ''; if (value.format) { var formatSpec = null; var formatIndex = m.indexOf(':'); if (formatIndex > 0) { formatSpec = m.substring(formatIndex + 1, m.length - 1); } return useLocale ? value.localeFormat(formatSpec) : value.format(formatSpec); } else return useLocale ? (value.localeFormat ? value.localeFormat() : value.toLocaleString()) : value.toString(); }); }; String.format = function(format: string, ...args: any[]) { return _format(format, args, /* useLocale */true); }; String.fromChar = function(ch: string, count: number) { var s = ch; for (var i = 1; i < count; i++) { s += ch; } return s; }; export default String;

declare global { export interface String { asDataUri(); contains(str); endsWith(suffix); insert(str, index); padLeft(width, str?); padRight(width, str?); splitWithTail(separator, limit?); toKebabCase(); trimEnd(char); trimStart(char); } export interface StringConstructor { isNullOrEmpty(str); isNullOrWhiteSpace(str); format(format, ...args); fromChar(ch, count); } } String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; String.prototype.padLeft = function(totalWidth, ch) { if (this.length < totalWidth) { return String.fromChar(ch || ' ', totalWidth - this.length) + this; } return this.substring(0, this.length); }; String.prototype.padRight = function(totalWidth, ch?) { if (this.length < totalWidth) { return this + String.fromChar(ch || ' ', totalWidth - this.length); } return this.substring(0, this.length); }; const trimStart = String.prototype.trimStart; String.prototype.trimStart = <any>function(ch?) { if (!ch || !this.length) return trimStart.apply(this); ch = ch || ' '; var i = 0; for (; this.charAt(i) == ch && i < this.length; i++); return this.substring(i); }; const trimEnd = String.prototype.trimEnd; String.prototype.trimEnd = <any>function(ch?) { if (!ch || !this.length) return trimEnd.apply(this); ch = ch ? ch : ' '; var i = this.length - 1; for (; i >= 0 && this.charAt(i) == ch; i--); return this.substring(0, i + 1); }; String.prototype.insert = function(str, index) { var length = this.length; if (index == length) { return this.substring(0, index) + str; } return this.substring(0, index) + str + this.substring(index, length); }; String.prototype.asDataUri = function() { if (/^iVBOR/.test(this)) return "data:image/png;base64," + this; if (/^\/9j\//.test(this)) return "data:image/jpeg;base64," + this; if (/^R0lGOD/.test(this)) return "data:image/gif;base64," + this; if (/^Qk/.test(this)) return "data:image/bmp;base64," + this; if (/^PD94/.test(this)) return "data:image/svg+xml;base64," + this; return ""; }; String.prototype.toKebabCase = function() { if (!this || this === this.toLowerCase()) return this; var _this = this; return Array.from(this as string).map(function(c, i) { var cLower = c.toLowerCase(); if (c === cLower) return c; if (i === 0) return cLower; var cPrev = _this[i - 1]; if (!/^[a-zA-Z]+$/.test(cPrev)) return cLower; var cPrevLower = cPrev.toLowerCase(); if (cPrev === cPrevLower) return "-" + cLower; if (i + 1 === _this.length) return cLower; var cNext = _this[i + 1]; var cNextUpper = cNext.toUpperCase(); if (cNext === cNextUpper) return cLower; return "-" + cLower; }).join(""); } String.prototype.splitWithTail = function(separator, limit?) { let pattern, startIndex, m; const parts = []; if (!limit) return this.split(separator); if (separator instanceof RegExp) pattern = new RegExp(separator.source, "g" + (separator.ignoreCase ? "i" : "") + (separator.multiline ? "m" : "")); else pattern = new RegExp(separator.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1"), "g"); do { startIndex = pattern.lastIndex; if (m = pattern.exec(this)) { parts.push(this.substr(startIndex, m.index - startIndex)); } } while (m && parts.length < limit - 1); parts.push(this.substr(pattern.lastIndex)); return parts; } String.isNullOrEmpty = function(str) { return str == null || str.length == 0; }; String.isNullOrWhiteSpace = function(str) { return str == null || !(/\S/.test(str)); }; const _formatRE = /(\{[^\}^\{]+\})/g; /* Example usages of '_format' are shown below: _format(format, args, useLocale true); */ const _format = function(format, values, useLocale) { return format.replace(_formatRE, function (m) { var index = parseInt(m.substr(1), 10); var value = values[index]; if (value == null) return ''; if (value.format) { var formatSpec = null; var formatIndex = m.indexOf(':'); if (formatIndex > 0) { formatSpec = m.substring(formatIndex + 1, m.length - 1); } return useLocale ? value.localeFormat(formatSpec) : value.format(formatSpec); } else return useLocale ? (value.localeFormat ? value.localeFormat() : value.toLocaleString()) : value.toString(); }); }; String.format = function(format, ...args) { return _format(format, args, /* useLocale */true); }; String.fromChar = function(ch, count) { var s = ch; for (var i = 1; i < count; i++) { s += ch; } return s; }; export default String;

a312d18e48976a6825298b151b938de7054db0c1

ts

TypeScript

src/lib/hmac-md5.ts

raine/homebridge-w215

67b05050dcfc6fb262a2728fb8fcd8d0dcc7668d

src/lib/hmac-md5.ts

raine/homebridge-w215

67b05050dcfc6fb262a2728fb8fcd8d0dcc7668d

src/lib/hmac-md5.ts

raine/homebridge-w215

67b05050dcfc6fb262a2728fb8fcd8d0dcc7668d

2022-03-26T17:08:51.000Z

2022-03-26T17:08:51.000Z

export class HMACMD5 { public static hex_hmac_md5(k, d) { return HMACMD5.rstr2hex(HMACMD5.rstr_hmac_md5(HMACMD5.str2rstr_utf8(k), HMACMD5.str2rstr_utf8(d))); } /* * Calculate the HMAC-MD5, of a key and some data (raw strings) */ private static rstr_hmac_md5(key, data) { let bkey = HMACMD5.rstr2binl(key); if (bkey.length > 16) { bkey = HMACMD5.binl_md5(bkey, key.length * 8); } const ipad = Array(16), opad = Array(16); for (let i = 0; i < 16; i++) { ipad[i] = bkey[i] ^ 0x36363636; opad[i] = bkey[i] ^ 0x5C5C5C5C; } const hash = HMACMD5.binl_md5(ipad.concat(HMACMD5.rstr2binl(data)), 512 + data.length * 8); return HMACMD5.binl2rstr(HMACMD5.binl_md5(opad.concat(hash), 512 + 128)); } /* * Convert a raw string to a hex string */ private static rstr2hex(input) { let hexcase = 0; try { hexcase } catch (e) { hexcase = 0; } const hex_tab = hexcase ? '0123456789ABCDEF' : '0123456789abcdef'; let output = ''; let x; for (let i = 0; i < input.length; i++) { x = input.charCodeAt(i); output += hex_tab.charAt((x >>> 4) & 0x0F) + hex_tab.charAt(x & 0x0F); } return output; } /* * Encode a string as utf-8. * For efficiency, this assumes the input is valid utf-16. */ private static str2rstr_utf8(input) { let output = ''; let i = -1; let x, y; while (++i < input.length) { /* Decode utf-16 surrogate pairs */ x = input.charCodeAt(i); y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0; if (0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) { x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF); i++; } /* Encode output as utf-8 */ if (x <= 0x7F) { output += String.fromCharCode(x); } else if (x <= 0x7FF) { output += String.fromCharCode(0xC0 | ((x >>> 6) & 0x1F), 0x80 | (x & 0x3F)); } else if (x <= 0xFFFF) { output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F)); } else if (x <= 0x1FFFFF) { output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07), 0x80 | ((x >>> 12) & 0x3F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F)); } } return output; } /* * Convert a raw string to an array of little-endian words * Characters >255 have their high-byte silently ignored. */ private static rstr2binl(input) { let i; const output = Array(input.length >> 2); for (i = 0; i < output.length; i++) { output[i] = 0; } for (i = 0; i < input.length * 8; i += 8) { output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32); } return output; } /* * Convert an array of little-endian words to a string */ private static binl2rstr(input) { let output = ''; for (let i = 0; i < input.length * 32; i += 8) { output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF); } return output; } /* * Calculate the MD5 of an array of little-endian words, and a bit length. */ private static binl_md5(x, len) { /* append padding */ x[len >> 5] |= 0x80 << ((len) % 32); x[(((len + 64) >>> 9) << 4) + 14] = len; let a = 1732584193; let b = -271733879; let c = -1732584194; let d = 271733878; for (let i = 0; i < x.length; i += 16) { const olda = a; const oldb = b; const oldc = c; const oldd = d; a = HMACMD5.md5_ff(a, b, c, d, x[i], 7, -680876936); d = HMACMD5.md5_ff(d, a, b, c, x[i + 1], 12, -389564586); c = HMACMD5.md5_ff(c, d, a, b, x[i + 2], 17, 606105819); b = HMACMD5.md5_ff(b, c, d, a, x[i + 3], 22, -1044525330); a = HMACMD5.md5_ff(a, b, c, d, x[i + 4], 7, -176418897); d = HMACMD5.md5_ff(d, a, b, c, x[i + 5], 12, 1200080426); c = HMACMD5.md5_ff(c, d, a, b, x[i + 6], 17, -1473231341); b = HMACMD5.md5_ff(b, c, d, a, x[i + 7], 22, -45705983); a = HMACMD5.md5_ff(a, b, c, d, x[i + 8], 7, 1770035416); d = HMACMD5.md5_ff(d, a, b, c, x[i + 9], 12, -1958414417); c = HMACMD5.md5_ff(c, d, a, b, x[i + 10], 17, -42063); b = HMACMD5.md5_ff(b, c, d, a, x[i + 11], 22, -1990404162); a = HMACMD5.md5_ff(a, b, c, d, x[i + 12], 7, 1804603682); d = HMACMD5.md5_ff(d, a, b, c, x[i + 13], 12, -40341101); c = HMACMD5.md5_ff(c, d, a, b, x[i + 14], 17, -1502002290); b = HMACMD5.md5_ff(b, c, d, a, x[i + 15], 22, 1236535329); a = HMACMD5.md5_gg(a, b, c, d, x[i + 1], 5, -165796510); d = HMACMD5.md5_gg(d, a, b, c, x[i + 6], 9, -1069501632); c = HMACMD5.md5_gg(c, d, a, b, x[i + 11], 14, 643717713); b = HMACMD5.md5_gg(b, c, d, a, x[i], 20, -373897302); a = HMACMD5.md5_gg(a, b, c, d, x[i + 5], 5, -701558691); d = HMACMD5.md5_gg(d, a, b, c, x[i + 10], 9, 38016083); c = HMACMD5.md5_gg(c, d, a, b, x[i + 15], 14, -660478335); b = HMACMD5.md5_gg(b, c, d, a, x[i + 4], 20, -405537848); a = HMACMD5.md5_gg(a, b, c, d, x[i + 9], 5, 568446438); d = HMACMD5.md5_gg(d, a, b, c, x[i + 14], 9, -1019803690); c = HMACMD5.md5_gg(c, d, a, b, x[i + 3], 14, -187363961); b = HMACMD5.md5_gg(b, c, d, a, x[i + 8], 20, 1163531501); a = HMACMD5.md5_gg(a, b, c, d, x[i + 13], 5, -1444681467); d = HMACMD5.md5_gg(d, a, b, c, x[i + 2], 9, -51403784); c = HMACMD5.md5_gg(c, d, a, b, x[i + 7], 14, 1735328473); b = HMACMD5.md5_gg(b, c, d, a, x[i + 12], 20, -1926607734); a = HMACMD5.md5_hh(a, b, c, d, x[i + 5], 4, -378558); d = HMACMD5.md5_hh(d, a, b, c, x[i + 8], 11, -2022574463); c = HMACMD5.md5_hh(c, d, a, b, x[i + 11], 16, 1839030562); b = HMACMD5.md5_hh(b, c, d, a, x[i + 14], 23, -35309556); a = HMACMD5.md5_hh(a, b, c, d, x[i + 1], 4, -1530992060); d = HMACMD5.md5_hh(d, a, b, c, x[i + 4], 11, 1272893353); c = HMACMD5.md5_hh(c, d, a, b, x[i + 7], 16, -155497632); b = HMACMD5.md5_hh(b, c, d, a, x[i + 10], 23, -1094730640); a = HMACMD5.md5_hh(a, b, c, d, x[i + 13], 4, 681279174); d = HMACMD5.md5_hh(d, a, b, c, x[i], 11, -358537222); c = HMACMD5.md5_hh(c, d, a, b, x[i + 3], 16, -722521979); b = HMACMD5.md5_hh(b, c, d, a, x[i + 6], 23, 76029189); a = HMACMD5.md5_hh(a, b, c, d, x[i + 9], 4, -640364487); d = HMACMD5.md5_hh(d, a, b, c, x[i + 12], 11, -421815835); c = HMACMD5.md5_hh(c, d, a, b, x[i + 15], 16, 530742520); b = HMACMD5.md5_hh(b, c, d, a, x[i + 2], 23, -995338651); a = HMACMD5.md5_ii(a, b, c, d, x[i], 6, -198630844); d = HMACMD5.md5_ii(d, a, b, c, x[i + 7], 10, 1126891415); c = HMACMD5.md5_ii(c, d, a, b, x[i + 14], 15, -1416354905); b = HMACMD5.md5_ii(b, c, d, a, x[i + 5], 21, -57434055); a = HMACMD5.md5_ii(a, b, c, d, x[i + 12], 6, 1700485571); d = HMACMD5.md5_ii(d, a, b, c, x[i + 3], 10, -1894986606); c = HMACMD5.md5_ii(c, d, a, b, x[i + 10], 15, -1051523); b = HMACMD5.md5_ii(b, c, d, a, x[i + 1], 21, -2054922799); a = HMACMD5.md5_ii(a, b, c, d, x[i + 8], 6, 1873313359); d = HMACMD5.md5_ii(d, a, b, c, x[i + 15], 10, -30611744); c = HMACMD5.md5_ii(c, d, a, b, x[i + 6], 15, -1560198380); b = HMACMD5.md5_ii(b, c, d, a, x[i + 13], 21, 1309151649); a = HMACMD5.md5_ii(a, b, c, d, x[i + 4], 6, -145523070); d = HMACMD5.md5_ii(d, a, b, c, x[i + 11], 10, -1120210379); c = HMACMD5.md5_ii(c, d, a, b, x[i + 2], 15, 718787259); b = HMACMD5.md5_ii(b, c, d, a, x[i + 9], 21, -343485551); a = HMACMD5.safe_add(a, olda); b = HMACMD5.safe_add(b, oldb); c = HMACMD5.safe_add(c, oldc); d = HMACMD5.safe_add(d, oldd); } return Array(a, b, c, d); } /* * These functions implement the four basic operations the algorithm uses. */ private static md5_cmn(q, a, b, x, s, t) { return HMACMD5.safe_add(HMACMD5.bit_rol(HMACMD5.safe_add(HMACMD5.safe_add(a, q), HMACMD5.safe_add(x, t)), s), b); } private static md5_ff(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn((b & c) | ((~b) & d), a, b, x, s, t); } private static md5_gg(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn((b & d) | (c & (~d)), a, b, x, s, t); } private static md5_hh(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn(b ^ c ^ d, a, b, x, s, t); } private static md5_ii(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn(c ^ (b | (~d)), a, b, x, s, t); } /* * Add integers, wrapping at 2^32. This uses 16-bit operations internally * to work around bugs in some JS interpreters. */ private static safe_add(x, y) { const lsw = (x & 0xFFFF) + (y & 0xFFFF); const msw = (x >> 16) + (y >> 16) + (lsw >> 16); return (msw << 16) | (lsw & 0xFFFF); } /* * Bitwise rotate a 32-bit number to the left. */ private static bit_rol(num, cnt) { return (num << cnt) | (num >>> (32 - cnt)); } }

export class HMACMD5 { public static hex_hmac_md5(k, d) { return HMACMD5.rstr2hex(HMACMD5.rstr_hmac_md5(HMACMD5.str2rstr_utf8(k), HMACMD5.str2rstr_utf8(d))); } /* * Calculate the HMAC-MD5, of a key and some data (raw strings) */ private static rstr_hmac_md5(key, data) { let bkey = HMACMD5.rstr2binl(key); if (bkey.length > 16) { bkey = HMACMD5.binl_md5(bkey, key.length * 8); } const ipad = Array(16), opad = Array(16); for (let i = 0; i < 16; i++) { ipad[i] = bkey[i] ^ 0x36363636; opad[i] = bkey[i] ^ 0x5C5C5C5C; } const hash = HMACMD5.binl_md5(ipad.concat(HMACMD5.rstr2binl(data)), 512 + data.length * 8); return HMACMD5.binl2rstr(HMACMD5.binl_md5(opad.concat(hash), 512 + 128)); } /* * Convert a raw string to a hex string */ private static rstr2hex(input) { let hexcase = 0; try { hexcase } catch (e) { hexcase = 0; } const hex_tab = hexcase ? '0123456789ABCDEF' : '0123456789abcdef'; let output = ''; let x; for (let i = 0; i < input.length; i++) { x = input.charCodeAt(i); output += hex_tab.charAt((x >>> 4) & 0x0F) + hex_tab.charAt(x & 0x0F); } return output; } /* * Encode a string as utf-8. * For efficiency, this assumes the input is valid utf-16. */ private static str2rstr_utf8(input) { let output = ''; let i = -1; let x, y; while (++i < input.length) { /* Decode utf-16 surrogate pairs */ x = input.charCodeAt(i); y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0; if (0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) { x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF); i++; } /* Encode output as utf-8 */ if (x <= 0x7F) { output += String.fromCharCode(x); } else if (x <= 0x7FF) { output += String.fromCharCode(0xC0 | ((x >>> 6) & 0x1F), 0x80 | (x & 0x3F)); } else if (x <= 0xFFFF) { output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F)); } else if (x <= 0x1FFFFF) { output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07), 0x80 | ((x >>> 12) & 0x3F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F)); } } return output; } /* * Convert a raw string to an array of little-endian words * Characters >255 have their high-byte silently ignored. */ private static rstr2binl(input) { let i; const output = Array(input.length >> 2); for (i = 0; i < output.length; i++) { output[i] = 0; } for (i = 0; i < input.length * 8; i += 8) { output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32); } return output; } /* * Convert an array of little-endian words to a string */ private static binl2rstr(input) { let output = ''; for (let i = 0; i < input.length * 32; i += 8) { output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF); } return output; } /* * Calculate the MD5 of an array of little-endian words, and a bit length. */ private static binl_md5(x, len) { /* append padding */ x[len >> 5] |= 0x80 << ((len) % 32); x[(((len + 64) >>> 9) << 4) + 14] = len; let a = 1732584193; let b = -271733879; let c = -1732584194; let d = 271733878; for (let i = 0; i < x.length; i += 16) { const olda = a; const oldb = b; const oldc = c; const oldd = d; a = HMACMD5.md5_ff(a, b, c, d, x[i], 7, -680876936); d = HMACMD5.md5_ff(d, a, b, c, x[i + 1], 12, -389564586); c = HMACMD5.md5_ff(c, d, a, b, x[i + 2], 17, 606105819); b = HMACMD5.md5_ff(b, c, d, a, x[i + 3], 22, -1044525330); a = HMACMD5.md5_ff(a, b, c, d, x[i + 4], 7, -176418897); d = HMACMD5.md5_ff(d, a, b, c, x[i + 5], 12, 1200080426); c = HMACMD5.md5_ff(c, d, a, b, x[i + 6], 17, -1473231341); b = HMACMD5.md5_ff(b, c, d, a, x[i + 7], 22, -45705983); a = HMACMD5.md5_ff(a, b, c, d, x[i + 8], 7, 1770035416); d = HMACMD5.md5_ff(d, a, b, c, x[i + 9], 12, -1958414417); c = HMACMD5.md5_ff(c, d, a, b, x[i + 10], 17, -42063); b = HMACMD5.md5_ff(b, c, d, a, x[i + 11], 22, -1990404162); a = HMACMD5.md5_ff(a, b, c, d, x[i + 12], 7, 1804603682); d = HMACMD5.md5_ff(d, a, b, c, x[i + 13], 12, -40341101); c = HMACMD5.md5_ff(c, d, a, b, x[i + 14], 17, -1502002290); b = HMACMD5.md5_ff(b, c, d, a, x[i + 15], 22, 1236535329); a = HMACMD5.md5_gg(a, b, c, d, x[i + 1], 5, -165796510); d = HMACMD5.md5_gg(d, a, b, c, x[i + 6], 9, -1069501632); c = HMACMD5.md5_gg(c, d, a, b, x[i + 11], 14, 643717713); b = HMACMD5.md5_gg(b, c, d, a, x[i], 20, -373897302); a = HMACMD5.md5_gg(a, b, c, d, x[i + 5], 5, -701558691); d = HMACMD5.md5_gg(d, a, b, c, x[i + 10], 9, 38016083); c = HMACMD5.md5_gg(c, d, a, b, x[i + 15], 14, -660478335); b = HMACMD5.md5_gg(b, c, d, a, x[i + 4], 20, -405537848); a = HMACMD5.md5_gg(a, b, c, d, x[i + 9], 5, 568446438); d = HMACMD5.md5_gg(d, a, b, c, x[i + 14], 9, -1019803690); c = HMACMD5.md5_gg(c, d, a, b, x[i + 3], 14, -187363961); b = HMACMD5.md5_gg(b, c, d, a, x[i + 8], 20, 1163531501); a = HMACMD5.md5_gg(a, b, c, d, x[i + 13], 5, -1444681467); d = HMACMD5.md5_gg(d, a, b, c, x[i + 2], 9, -51403784); c = HMACMD5.md5_gg(c, d, a, b, x[i + 7], 14, 1735328473); b = HMACMD5.md5_gg(b, c, d, a, x[i + 12], 20, -1926607734); a = HMACMD5.md5_hh(a, b, c, d, x[i + 5], 4, -378558); d = HMACMD5.md5_hh(d, a, b, c, x[i + 8], 11, -2022574463); c = HMACMD5.md5_hh(c, d, a, b, x[i + 11], 16, 1839030562); b = HMACMD5.md5_hh(b, c, d, a, x[i + 14], 23, -35309556); a = HMACMD5.md5_hh(a, b, c, d, x[i + 1], 4, -1530992060); d = HMACMD5.md5_hh(d, a, b, c, x[i + 4], 11, 1272893353); c = HMACMD5.md5_hh(c, d, a, b, x[i + 7], 16, -155497632); b = HMACMD5.md5_hh(b, c, d, a, x[i + 10], 23, -1094730640); a = HMACMD5.md5_hh(a, b, c, d, x[i + 13], 4, 681279174); d = HMACMD5.md5_hh(d, a, b, c, x[i], 11, -358537222); c = HMACMD5.md5_hh(c, d, a, b, x[i + 3], 16, -722521979); b = HMACMD5.md5_hh(b, c, d, a, x[i + 6], 23, 76029189); a = HMACMD5.md5_hh(a, b, c, d, x[i + 9], 4, -640364487); d = HMACMD5.md5_hh(d, a, b, c, x[i + 12], 11, -421815835); c = HMACMD5.md5_hh(c, d, a, b, x[i + 15], 16, 530742520); b = HMACMD5.md5_hh(b, c, d, a, x[i + 2], 23, -995338651); a = HMACMD5.md5_ii(a, b, c, d, x[i], 6, -198630844); d = HMACMD5.md5_ii(d, a, b, c, x[i + 7], 10, 1126891415); c = HMACMD5.md5_ii(c, d, a, b, x[i + 14], 15, -1416354905); b = HMACMD5.md5_ii(b, c, d, a, x[i + 5], 21, -57434055); a = HMACMD5.md5_ii(a, b, c, d, x[i + 12], 6, 1700485571); d = HMACMD5.md5_ii(d, a, b, c, x[i + 3], 10, -1894986606); c = HMACMD5.md5_ii(c, d, a, b, x[i + 10], 15, -1051523); b = HMACMD5.md5_ii(b, c, d, a, x[i + 1], 21, -2054922799); a = HMACMD5.md5_ii(a, b, c, d, x[i + 8], 6, 1873313359); d = HMACMD5.md5_ii(d, a, b, c, x[i + 15], 10, -30611744); c = HMACMD5.md5_ii(c, d, a, b, x[i + 6], 15, -1560198380); b = HMACMD5.md5_ii(b, c, d, a, x[i + 13], 21, 1309151649); a = HMACMD5.md5_ii(a, b, c, d, x[i + 4], 6, -145523070); d = HMACMD5.md5_ii(d, a, b, c, x[i + 11], 10, -1120210379); c = HMACMD5.md5_ii(c, d, a, b, x[i + 2], 15, 718787259); b = HMACMD5.md5_ii(b, c, d, a, x[i + 9], 21, -343485551); a = HMACMD5.safe_add(a, olda); b = HMACMD5.safe_add(b, oldb); c = HMACMD5.safe_add(c, oldc); d = HMACMD5.safe_add(d, oldd); } return Array(a, b, c, d); } /* * These functions implement the four basic operations the algorithm uses. */ private static md5_cmn(q, a, b, x, s, t) { return HMACMD5.safe_add(HMACMD5.bit_rol(HMACMD5.safe_add(HMACMD5.safe_add(a, q), HMACMD5.safe_add(x, t)), s), b); } private static md5_ff(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn((b & c) | ((~b) & d), a, b, x, s, t); } private static md5_gg(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn((b & d) | (c & (~d)), a, b, x, s, t); } private static md5_hh(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn(b ^ c ^ d, a, b, x, s, t); } private static md5_ii(a, b, c, d, x, s, t) { return HMACMD5.md5_cmn(c ^ (b | (~d)), a, b, x, s, t); } /* * Add integers, wrapping at 2^32. This uses 16-bit operations internally * to work around bugs in some JS interpreters. */ private static safe_add(x, y) { const lsw = (x & 0xFFFF) + (y & 0xFFFF); const msw = (x >> 16) + (y >> 16) + (lsw >> 16); return (msw << 16) | (lsw & 0xFFFF); } /* * Bitwise rotate a 32-bit number to the left. */ private static bit_rol(num, cnt) { return (num << cnt) | (num >>> (32 - cnt)); } }

a39abc380f4c4af8e45296a9d17dd3369b215f99

ts

TypeScript

solutions/day15.ts

GiyoMoon/aoc2021

83d7e9018ed3b628353bc9a0a37b70a1462ecd74

solutions/day15.ts

GiyoMoon/aoc2021

83d7e9018ed3b628353bc9a0a37b70a1462ecd74

2022-02-03T11:04:17.000Z

2022-02-03T11:04:17.000Z

solutions/day15.ts

GiyoMoon/aoc2021

83d7e9018ed3b628353bc9a0a37b70a1462ecd74

export default class Day15 { private _points: { distance: number; value: number; visited: boolean; }[][] = []; public solve(input: string): { part1: any, part2: any; } { const inputPoints = input.split('\n').map(l => l.split('').map(c => parseInt(c))); this._initPoints(inputPoints); let finished = false; while (!finished) { const shortestDistanceCoord = this._findShortestDistance(); if ( shortestDistanceCoord[0] === null && shortestDistanceCoord[1] === null ) { finished = true; break; } this._updateAdjacent(shortestDistanceCoord); } const lastPointDistancePart1 = this._points[this._points.length - 1][this._points[0].length - 1].distance; this._initBigPoints(inputPoints); finished = false; while (!finished) { const shortestDistanceCoord = this._findShortestDistance(); if ( shortestDistanceCoord[0] === null && shortestDistanceCoord[1] === null ) { finished = true; break; } this._updateAdjacent(shortestDistanceCoord); } const lastPointDistancePart2 = this._points[this._points.length - 1][this._points[0].length - 1].distance; return { part1: lastPointDistancePart1, part2: lastPointDistancePart2 }; } private _findShortestDistance() { let distance = Number.MAX_VALUE; const shortestDistance: [number, number] = [null, null]; this._points.forEach((l, y) => { l.forEach((c, x) => { if (!c.visited && c.distance < distance) { distance = c.distance; shortestDistance[0] = y; shortestDistance[1] = x; } }); }); return shortestDistance; } private _updateAdjacent(sDC: [number, number]) { const distance = this._points[sDC[0]][sDC[1]].distance; this._points[sDC[0]][sDC[1]].visited = true; const yCoords = [sDC[0] + 1, sDC[0] - 1, sDC[0], sDC[0]]; const xCoords = [sDC[1], sDC[1], sDC[1] + 1, sDC[1] - 1]; for (let i = 0; i < yCoords.length; i++) { if (this._points[yCoords[i]] && this._points[yCoords[i]][xCoords[i]]) { const oldDistance = this._points[yCoords[i]][xCoords[i]].distance; const newDistance = distance + this._points[yCoords[i]][xCoords[i]].value; this._points[yCoords[i]][xCoords[i]].distance = oldDistance > newDistance ? newDistance : oldDistance; } } } private _initPoints(inputPoints: number[][]) { inputPoints.forEach((l, y) => { if (!this._points[y]) { this._points[y] = []; } l.forEach((c, x) => { this._points[y][x] = { distance: Number.MAX_VALUE, value: c, visited: false }; }); }); this._points[0][0].distance = 0; } private _initBigPoints(inputPoints: number[][]) { const size = inputPoints.length; inputPoints.forEach((l, y) => { l.forEach((c, x) => { for (let yy = 0; yy < 5; yy++) { for (let xx = 0; xx < 5; xx++) { if (!this._points[y + size * yy]) { this._points[y + size * yy] = []; } const value = (c + yy + xx) % 9 === 0 ? 9 : (c + yy + xx) % 9; this._points[y + size * yy][x + size * xx] = { distance: Number.MAX_VALUE, value, visited: false }; } } }); }); this._points[0][0].distance = 0; } }

export default class Day15 { private _points = []; public solve(input) { const inputPoints = input.split('\n').map(l => l.split('').map(c => parseInt(c))); this._initPoints(inputPoints); let finished = false; while (!finished) { const shortestDistanceCoord = this._findShortestDistance(); if ( shortestDistanceCoord[0] === null && shortestDistanceCoord[1] === null ) { finished = true; break; } this._updateAdjacent(shortestDistanceCoord); } const lastPointDistancePart1 = this._points[this._points.length - 1][this._points[0].length - 1].distance; this._initBigPoints(inputPoints); finished = false; while (!finished) { const shortestDistanceCoord = this._findShortestDistance(); if ( shortestDistanceCoord[0] === null && shortestDistanceCoord[1] === null ) { finished = true; break; } this._updateAdjacent(shortestDistanceCoord); } const lastPointDistancePart2 = this._points[this._points.length - 1][this._points[0].length - 1].distance; return { part1: lastPointDistancePart1, part2: lastPointDistancePart2 }; } private _findShortestDistance() { let distance = Number.MAX_VALUE; const shortestDistance = [null, null]; this._points.forEach((l, y) => { l.forEach((c, x) => { if (!c.visited && c.distance < distance) { distance = c.distance; shortestDistance[0] = y; shortestDistance[1] = x; } }); }); return shortestDistance; } private _updateAdjacent(sDC) { const distance = this._points[sDC[0]][sDC[1]].distance; this._points[sDC[0]][sDC[1]].visited = true; const yCoords = [sDC[0] + 1, sDC[0] - 1, sDC[0], sDC[0]]; const xCoords = [sDC[1], sDC[1], sDC[1] + 1, sDC[1] - 1]; for (let i = 0; i < yCoords.length; i++) { if (this._points[yCoords[i]] && this._points[yCoords[i]][xCoords[i]]) { const oldDistance = this._points[yCoords[i]][xCoords[i]].distance; const newDistance = distance + this._points[yCoords[i]][xCoords[i]].value; this._points[yCoords[i]][xCoords[i]].distance = oldDistance > newDistance ? newDistance : oldDistance; } } } private _initPoints(inputPoints) { inputPoints.forEach((l, y) => { if (!this._points[y]) { this._points[y] = []; } l.forEach((c, x) => { this._points[y][x] = { distance: Number.MAX_VALUE, value: c, visited: false }; }); }); this._points[0][0].distance = 0; } private _initBigPoints(inputPoints) { const size = inputPoints.length; inputPoints.forEach((l, y) => { l.forEach((c, x) => { for (let yy = 0; yy < 5; yy++) { for (let xx = 0; xx < 5; xx++) { if (!this._points[y + size * yy]) { this._points[y + size * yy] = []; } const value = (c + yy + xx) % 9 === 0 ? 9 : (c + yy + xx) % 9; this._points[y + size * yy][x + size * xx] = { distance: Number.MAX_VALUE, value, visited: false }; } } }); }); this._points[0][0].distance = 0; } }

a3c87e22c30072055cfbcdaba851bef6a0244dc3

ts

TypeScript

src/infrastructure/service-utils/dto-mapper.ts

aspian-io/adrian-blog

51380c2134ac20256d7535b2714b2853044251c4

2022-02-06T19:49:20.000Z

2022-02-06T19:49:20.000Z

src/infrastructure/service-utils/dto-mapper.ts

aspian-io/adrian-blog

51380c2134ac20256d7535b2714b2853044251c4

src/infrastructure/service-utils/dto-mapper.ts

aspian-io/adrian-blog

51380c2134ac20256d7535b2714b2853044251c4

// /** // * DTOs must extends this class // */ export class DTOMapper { dtoMapperProfile (): IDtoMapperOption<any>[] | undefined { return undefined; }; } /** * DTO Mapper Option Type * @param T - Type of class */ export interface IDtoMapperOption<T> { mapToClass?: IDtoMapperToClass<T>; mapToPath?: IDtoMapperToPath; } // Mapping to class type export interface IDtoMapperToClass<T> { mapFromKey: string; dtoClass: new () => T; } // mapping to path type export interface IDtoMapperToPath { mapFromKey: string; valueFromPath: string; } /** * * Map source object to destination class * * @param {T} source - Source object to map from * @param {U} destination - Destination class to map to * @returns {U} An object of type U */ export function dtoMapper<T, U extends DTOMapper> ( source: T extends Array<any> ? never : T, destination: new () => U ): U; /** * * Map source object to destination class * * @param {T[]} source - Source array of objects to map from * @param {U} destination - Destination class to which map each object from the source * @returns {U[]} An array of type U */ export function dtoMapper<T, U extends DTOMapper> ( source: T[], destination: new () => U ): U[]; export function dtoMapper<T, U extends DTOMapper> ( source: T | T[], destination: new () => U ): U | U[] { if ( Array.isArray( source ) ) { return source.map( s => { return mapper( s, new destination() ); } ); } return mapper( source, new destination() ); } // Mapper to map source to destination function mapper<T, U extends DTOMapper> ( source: T, destination: U ): U { Object.keys( destination ).forEach( key => { destination[ key as keyof U ] = <any>source[ key as keyof T ]; if ( destination.dtoMapperProfile()?.length ) { destination.dtoMapperProfile()?.forEach( option => { // To class mapping (recursively) if ( option.mapToClass?.mapFromKey === key ) { if ( source[ key as keyof T ] ) { if ( Array.isArray( source[ key as keyof T ] ) ) { const result = Array.from( source[ key as keyof T ] as any ).map( el => { return mapper( el, new option.mapToClass!.dtoClass() ); } ); destination[ key as keyof U ] = result as any; } else { const result = mapper( source[ key as keyof T ], new option.mapToClass.dtoClass() ); destination[ key as keyof U ] = result as any; } } // To value mapping } else if ( option.mapToPath?.mapFromKey === key ) { let sourceVal: any; if ( Array.isArray( option.mapToPath.valueFromPath.split( '.' ) ) ) { const paths = option.mapToPath.valueFromPath.split( '.' ); paths.forEach( p => { if ( !sourceVal ) { sourceVal = source[ p as keyof T ]; } else { sourceVal = sourceVal[ p ]; } } ); } else { sourceVal = <any>source[ option.mapToPath.valueFromPath as keyof T ]; } destination[ key as keyof U ] = sourceVal; } } ); } } ); return destination; }

// /** // * DTOs must extends this class // */ export class DTOMapper { dtoMapperProfile () { return undefined; }; } /** * DTO Mapper Option Type * @param T - Type of class */ export interface IDtoMapperOption<T> { mapToClass?; mapToPath?; } // Mapping to class type export interface IDtoMapperToClass<T> { mapFromKey; dtoClass; } // mapping to path type export interface IDtoMapperToPath { mapFromKey; valueFromPath; } /** * * Map source object to destination class * * @param {T} source - Source object to map from * @param {U} destination - Destination class to map to * @returns {U} An object of type U */ export function dtoMapper<T, U extends DTOMapper> ( source, destination ); /** * * Map source object to destination class * * @param {T[]} source - Source array of objects to map from * @param {U} destination - Destination class to which map each object from the source * @returns {U[]} An array of type U */ export function dtoMapper<T, U extends DTOMapper> ( source, destination ); export function dtoMapper<T, U extends DTOMapper> ( source, destination ) { if ( Array.isArray( source ) ) { return source.map( s => { return mapper( s, new destination() ); } ); } return mapper( source, new destination() ); } // Mapper to map source to destination /* Example usages of 'mapper' are shown below: mapper(s, new destination()); mapper(source, new destination()); mapper(el, new option.mapToClass!.dtoClass()); mapper(source[key as keyof T], new option.mapToClass.dtoClass()); */ function mapper<T, U extends DTOMapper> ( source, destination ) { Object.keys( destination ).forEach( key => { destination[ key as keyof U ] = <any>source[ key as keyof T ]; if ( destination.dtoMapperProfile()?.length ) { destination.dtoMapperProfile()?.forEach( option => { // To class mapping (recursively) if ( option.mapToClass?.mapFromKey === key ) { if ( source[ key as keyof T ] ) { if ( Array.isArray( source[ key as keyof T ] ) ) { const result = Array.from( source[ key as keyof T ] as any ).map( el => { return mapper( el, new option.mapToClass!.dtoClass() ); } ); destination[ key as keyof U ] = result as any; } else { const result = mapper( source[ key as keyof T ], new option.mapToClass.dtoClass() ); destination[ key as keyof U ] = result as any; } } // To value mapping } else if ( option.mapToPath?.mapFromKey === key ) { let sourceVal; if ( Array.isArray( option.mapToPath.valueFromPath.split( '.' ) ) ) { const paths = option.mapToPath.valueFromPath.split( '.' ); paths.forEach( p => { if ( !sourceVal ) { sourceVal = source[ p as keyof T ]; } else { sourceVal = sourceVal[ p ]; } } ); } else { sourceVal = <any>source[ option.mapToPath.valueFromPath as keyof T ]; } destination[ key as keyof U ] = sourceVal; } } ); } } ); return destination; }

a3d0d102f121fd1bc264184794013ec8c867f62c

ts

TypeScript

packages/react-table/src/aggregationTypes.ts

dvh91/react-table

ca69c89008b216cf1f20bcbadc5ef92dbec9bc4e

2022-03-09T05:24:51.000Z

2022-03-09T05:24:51.000Z

packages/react-table/src/aggregationTypes.ts

dvh91/react-table

ca69c89008b216cf1f20bcbadc5ef92dbec9bc4e

packages/react-table/src/aggregationTypes.ts

dvh91/react-table

ca69c89008b216cf1f20bcbadc5ef92dbec9bc4e

export const aggregationTypes = { sum, min, max, extent, mean, median, unique, uniqueCount, count, } export type BuiltInAggregationType = keyof typeof aggregationTypes function sum(_leafValues: unknown[], childValues: unknown[]) { // It's faster to just add the aggregations together instead of // process leaf nodes individually return childValues.reduce( (sum: number, next: unknown) => sum + (typeof next === 'number' ? next : 0), 0 ) } function min(_leafValues: unknown[], childValues: unknown[]) { let min: number | undefined for (const value of childValues as number[]) { if ( value != null && (min! > value || (min === undefined && value >= value)) ) { min = value } } return min } function max(_leafValues: unknown[], childValues: unknown[]) { let max: number | undefined for (const value of childValues as number[]) { if ( value != null && (max! < value || (max === undefined && value >= value)) ) { max = value } } return max } function extent(_leafValues: unknown[], childValues: unknown[]) { let min: number | undefined let max: number | undefined for (const value of childValues as number[]) { if (value != null) { if (min === undefined) { if (value >= value) min = max = value } else { if (min > value) min = value if (max! < value) max = value } } } return [min, max] } function mean(leafValues: unknown[]) { let count = 0 let sum = 0 for (let value of leafValues as number[]) { if (value != null && (value = +value) >= value) { ++count, (sum += value) } } if (count) return sum / count return } function median(values: unknown[]) { if (!values.length) { return } let min = 0 let max = 0 values.forEach(value => { if (typeof value === 'number') { min = Math.min(min, value) max = Math.max(max, value) } }) return (min + max) / 2 } function unique<T>(values: T[]) { return Array.from(new Set(values).values()) } function uniqueCount(values: unknown[]) { return new Set(values).size } function count(values: unknown[]) { return values.length }

export const aggregationTypes = { sum, min, max, extent, mean, median, unique, uniqueCount, count, } export type BuiltInAggregationType = keyof typeof aggregationTypes /* Example usages of 'sum' are shown below: ; sum + (typeof next === 'number' ? next : 0); var sum = 0; sum += value; sum / count; */ function sum(_leafValues, childValues) { // It's faster to just add the aggregations together instead of // process leaf nodes individually return childValues.reduce( (sum, next) => sum + (typeof next === 'number' ? next : 0), 0 ) } /* Example usages of 'min' are shown below: ; var min; min! > value || (min === undefined && value >= value); min === undefined && value >= value; min = value; return min; min === undefined; min = max = value; min > value; [min, max]; var min = 0; min = Math.min(min, value); min + max; */ function min(_leafValues, childValues) { let min for (const value of childValues as number[]) { if ( value != null && (min! > value || (min === undefined && value >= value)) ) { min = value } } return min } /* Example usages of 'max' are shown below: ; var max; max! < value || (max === undefined && value >= value); max === undefined && value >= value; max = value; return max; min = max = value; max! < value; [min, max]; var max = 0; max = Math.max(max, value); min + max; */ function max(_leafValues, childValues) { let max for (const value of childValues as number[]) { if ( value != null && (max! < value || (max === undefined && value >= value)) ) { max = value } } return max } /* Example usages of 'extent' are shown below: ; */ function extent(_leafValues, childValues) { let min let max for (const value of childValues as number[]) { if (value != null) { if (min === undefined) { if (value >= value) min = max = value } else { if (min > value) min = value if (max! < value) max = value } } } return [min, max] } /* Example usages of 'mean' are shown below: ; */ function mean(leafValues) { let count = 0 let sum = 0 for (let value of leafValues as number[]) { if (value != null && (value = +value) >= value) { ++count, (sum += value) } } if (count) return sum / count return } /* Example usages of 'median' are shown below: ; */ function median(values) { if (!values.length) { return } let min = 0 let max = 0 values.forEach(value => { if (typeof value === 'number') { min = Math.min(min, value) max = Math.max(max, value) } }) return (min + max) / 2 } /* Example usages of 'unique' are shown below: ; */ function unique<T>(values) { return Array.from(new Set(values).values()) } /* Example usages of 'uniqueCount' are shown below: ; */ function uniqueCount(values) { return new Set(values).size } /* Example usages of 'count' are shown below: ; var count = 0; ++count, (sum += value); sum / count; */ function count(values) { return values.length }

a3e1dd02d438bd56221d60dc4674790870208976

ts

TypeScript

src/utils/config-mach.ts

Disq-Code-Bot/dyarn

9de5fce5161b46b07a88d75bc17b3c3ff9d14ee4

2022-03-29T15:53:46.000Z

2022-03-29T15:53:46.000Z

src/utils/config-mach.ts

Disq-Code-Bot/dyarn

9de5fce5161b46b07a88d75bc17b3c3ff9d14ee4

src/utils/config-mach.ts

Disq-Code-Bot/dyarn

9de5fce5161b46b07a88d75bc17b3c3ff9d14ee4

interface RecursiveTypeCheckOverload { (obj: Record<string, any>, againstObj: Record<string, any>): { checks: true } | { checks: false, err: string } } //TODO Improve error handling messages and overall code structure/algorithm export const RecursiveTypeCheck: RecursiveTypeCheckOverload = (obj, againstObj) => { for(const key in againstObj) { //* In case type should be an array if(key.startsWith('[]') || key.startsWith('_[]')) { //* In case is optional: checking if is even defined if(key.startsWith('_')) { const keyNoArr = key.replace('_[]', '') if(!obj[keyNoArr]) continue } const keyNoArr = key.replace(`${key.startsWith('_') ? '_[]' : '[]'}`, '') //* In case is not defined and obligatory if(!obj[keyNoArr]) return { checks: false, err: `The key '${keyNoArr}' is missing!` } //* In case is not array check type if(!Array.isArray(obj[keyNoArr])) return { checks: false, err: `The key '${keyNoArr}' is not an array!` } //* In case is array get deeper const arrCheck = Array.from(obj[keyNoArr]).map((value: any) => RecursiveTypeCheck(value, againstObj[key])) for(const optionCheck of arrCheck) { if(!optionCheck.checks) return optionCheck } } //* In case type should be an object else if(key.startsWith('{}') || key.startsWith('_{}')) { //* In case is optional: checking if is even defined if(key.startsWith('_')) { const keyNoObj = key.replace('_{}', '') if(!obj[keyNoObj]) continue } const keyNoObj = key.replace(`${key.startsWith('_') ? '_{}' : '{}'}`, '') //* In case is not defined and obligatory if(!obj[keyNoObj]) return { checks: false, err: `The key '${keyNoObj}' is missing!` } //* In case is not object check type if(!(typeof obj[keyNoObj] === 'object')) return { checks: false, err: `The key '${keyNoObj}' is not an object!` } //* In case object may contain any key and value if(againstObj[key] === "?") continue //* In case is object get deeper for(const checkObjChild in obj[keyNoObj]) { const objectCheck = RecursiveTypeCheck(obj[keyNoObj][checkObjChild], againstObj[key]) if(!objectCheck.checks) return objectCheck } } //* Checking if key is optional else if(key.startsWith('_')) { const keyNoUnder = key.replace('_', '') //* Checking if value is even defined if(!obj[keyNoUnder]) continue //* In case is not object check type if(typeof obj[keyNoUnder] !== typeof againstObj[key]) return { checks: false, err: `The key '${keyNoUnder}' is not of type '${typeof againstObj[key]}'!` } //* In case is object get deeper if(typeof obj[keyNoUnder] === 'object') { const checkObject = RecursiveTypeCheck(obj[keyNoUnder], againstObj[key]) if(!checkObject.checks) return checkObject } } //* In case key is not optional and doesn't exist else if(!obj[key]) return { checks: false, err: `The key '${key}' is missing inside your dyarn config file!` } //* Checking if key is of the right type else if(typeof obj[key] !== typeof againstObj[key]) { return { checks: false, err: `The key '${key}' is not of type '${typeof againstObj[key]}'` } } //* Get deeper in case it's an object else if(typeof obj[key] === 'object') { if(againstObj[key] === "?") continue const recursiveRes = RecursiveTypeCheck(obj[key], againstObj[key]) if(!recursiveRes.checks) return recursiveRes } } return { checks: true } }

interface RecursiveTypeCheckOverload { (obj, againstObj) } //TODO Improve error handling messages and overall code structure/algorithm export /* Example usages of 'RecursiveTypeCheck' are shown below: RecursiveTypeCheck(value, againstObj[key]); RecursiveTypeCheck(obj[keyNoObj][checkObjChild], againstObj[key]); RecursiveTypeCheck(obj[keyNoUnder], againstObj[key]); RecursiveTypeCheck(obj[key], againstObj[key]); */ const RecursiveTypeCheck = (obj, againstObj) => { for(const key in againstObj) { //* In case type should be an array if(key.startsWith('[]') || key.startsWith('_[]')) { //* In case is optional: checking if is even defined if(key.startsWith('_')) { const keyNoArr = key.replace('_[]', '') if(!obj[keyNoArr]) continue } const keyNoArr = key.replace(`${key.startsWith('_') ? '_[]' : '[]'}`, '') //* In case is not defined and obligatory if(!obj[keyNoArr]) return { checks: false, err: `The key '${keyNoArr}' is missing!` } //* In case is not array check type if(!Array.isArray(obj[keyNoArr])) return { checks: false, err: `The key '${keyNoArr}' is not an array!` } //* In case is array get deeper const arrCheck = Array.from(obj[keyNoArr]).map((value) => RecursiveTypeCheck(value, againstObj[key])) for(const optionCheck of arrCheck) { if(!optionCheck.checks) return optionCheck } } //* In case type should be an object else if(key.startsWith('{}') || key.startsWith('_{}')) { //* In case is optional: checking if is even defined if(key.startsWith('_')) { const keyNoObj = key.replace('_{}', '') if(!obj[keyNoObj]) continue } const keyNoObj = key.replace(`${key.startsWith('_') ? '_{}' : '{}'}`, '') //* In case is not defined and obligatory if(!obj[keyNoObj]) return { checks: false, err: `The key '${keyNoObj}' is missing!` } //* In case is not object check type if(!(typeof obj[keyNoObj] === 'object')) return { checks: false, err: `The key '${keyNoObj}' is not an object!` } //* In case object may contain any key and value if(againstObj[key] === "?") continue //* In case is object get deeper for(const checkObjChild in obj[keyNoObj]) { const objectCheck = RecursiveTypeCheck(obj[keyNoObj][checkObjChild], againstObj[key]) if(!objectCheck.checks) return objectCheck } } //* Checking if key is optional else if(key.startsWith('_')) { const keyNoUnder = key.replace('_', '') //* Checking if value is even defined if(!obj[keyNoUnder]) continue //* In case is not object check type if(typeof obj[keyNoUnder] !== typeof againstObj[key]) return { checks: false, err: `The key '${keyNoUnder}' is not of type '${typeof againstObj[key]}'!` } //* In case is object get deeper if(typeof obj[keyNoUnder] === 'object') { const checkObject = RecursiveTypeCheck(obj[keyNoUnder], againstObj[key]) if(!checkObject.checks) return checkObject } } //* In case key is not optional and doesn't exist else if(!obj[key]) return { checks: false, err: `The key '${key}' is missing inside your dyarn config file!` } //* Checking if key is of the right type else if(typeof obj[key] !== typeof againstObj[key]) { return { checks: false, err: `The key '${key}' is not of type '${typeof againstObj[key]}'` } } //* Get deeper in case it's an object else if(typeof obj[key] === 'object') { if(againstObj[key] === "?") continue const recursiveRes = RecursiveTypeCheck(obj[key], againstObj[key]) if(!recursiveRes.checks) return recursiveRes } } return { checks: true } }

5d19ce050bd5135b5325905de8019e55bc87ff19

ts

TypeScript

src/helpers/stop-loss.ts

mikekruithof22/apollo14

f1bebed7d3cc39ce91f2061449693c64f5d5e9bc

2022-01-04T04:33:16.000Z

2022-01-04T04:33:16.000Z

src/helpers/stop-loss.ts

mikekruithof22/apollo14

f1bebed7d3cc39ce91f2061449693c64f5d5e9bc

src/helpers/stop-loss.ts

mikekruithof22/apollo14

f1bebed7d3cc39ce91f2061449693c64f5d5e9bc

export default class Stoploss { public static stopLossCalculation = (startCandle, nextCandlesAfterHit, takeLossPercentage, takeProfitPercentage) => { let message: string; let sellResult: number = 0; const takeLossPercentageInPercentage: number = takeLossPercentage / 100; const takeLossPrice: number = (1 - takeLossPercentageInPercentage) * startCandle.close; const takeProfitPercentageInPercentage: number = takeProfitPercentage / 100; let takeProfitPrice: number = (1 + takeProfitPercentageInPercentage) * startCandle.close; takeProfitPrice = Number(takeProfitPrice.toFixed(5)); for (var i = 0; i < nextCandlesAfterHit.length; i++) { let comparisonCandle = Object.assign({}, nextCandlesAfterHit[i]); if (comparisonCandle.low <= takeLossPrice && comparisonCandle.high >= takeProfitPrice) { message = `Unknown - Profit limit and sell limit occured inside the same candle.`; break; } else if (comparisonCandle.high >= takeProfitPrice) { message = `Profitable - After ${i} candles sold for: ${takeProfitPrice} at ${nextCandlesAfterHit[i].openTime}`; sellResult = takeProfitPercentageInPercentage; break; } else if (comparisonCandle.low <= takeLossPrice) { message = `Unprofitable - After ${i} candles sold for: ${takeLossPrice} at ${nextCandlesAfterHit[i].openTime}`; sellResult = - takeLossPercentageInPercentage; break; } else { message = `UNKOWN - UNABLE TO CALCULATE!`; } } return { message: message, profitOrLossPercentage: sellResult }; } public static findHighestCandle = (nextCandlesAfterHit): string => { let message: string; if (nextCandlesAfterHit.length === 0) { message = `No candle after hit found. Something might be wrong.`; } else { const candleWithHighstPrice = nextCandlesAfterHit.reduce(function (prev, current) { return (prev.high > current.high) ? prev : current }); message = `${candleWithHighstPrice.high} at ${candleWithHighstPrice.openTime}`; } return message; } public static findLowestCandle = (nextCandlesAfterHit): string => { let message: string; if (nextCandlesAfterHit.length === 0) { message = `No candle after hit found. Something might be wrong.`; } else { const candleWithLowestPrice = nextCandlesAfterHit.reduce(function (prev, current) { return (prev.low > current.low) ? prev : current }); message = `${candleWithLowestPrice.low} at ${candleWithLowestPrice.openTime} `; } return message; } }

export default class Stoploss { public static stopLossCalculation = (startCandle, nextCandlesAfterHit, takeLossPercentage, takeProfitPercentage) => { let message; let sellResult = 0; const takeLossPercentageInPercentage = takeLossPercentage / 100; const takeLossPrice = (1 - takeLossPercentageInPercentage) * startCandle.close; const takeProfitPercentageInPercentage = takeProfitPercentage / 100; let takeProfitPrice = (1 + takeProfitPercentageInPercentage) * startCandle.close; takeProfitPrice = Number(takeProfitPrice.toFixed(5)); for (var i = 0; i < nextCandlesAfterHit.length; i++) { let comparisonCandle = Object.assign({}, nextCandlesAfterHit[i]); if (comparisonCandle.low <= takeLossPrice && comparisonCandle.high >= takeProfitPrice) { message = `Unknown - Profit limit and sell limit occured inside the same candle.`; break; } else if (comparisonCandle.high >= takeProfitPrice) { message = `Profitable - After ${i} candles sold for: ${takeProfitPrice} at ${nextCandlesAfterHit[i].openTime}`; sellResult = takeProfitPercentageInPercentage; break; } else if (comparisonCandle.low <= takeLossPrice) { message = `Unprofitable - After ${i} candles sold for: ${takeLossPrice} at ${nextCandlesAfterHit[i].openTime}`; sellResult = - takeLossPercentageInPercentage; break; } else { message = `UNKOWN - UNABLE TO CALCULATE!`; } } return { message: message, profitOrLossPercentage: sellResult }; } public static findHighestCandle = (nextCandlesAfterHit) => { let message; if (nextCandlesAfterHit.length === 0) { message = `No candle after hit found. Something might be wrong.`; } else { const candleWithHighstPrice = nextCandlesAfterHit.reduce(function (prev, current) { return (prev.high > current.high) ? prev : current }); message = `${candleWithHighstPrice.high} at ${candleWithHighstPrice.openTime}`; } return message; } public static findLowestCandle = (nextCandlesAfterHit) => { let message; if (nextCandlesAfterHit.length === 0) { message = `No candle after hit found. Something might be wrong.`; } else { const candleWithLowestPrice = nextCandlesAfterHit.reduce(function (prev, current) { return (prev.low > current.low) ? prev : current }); message = `${candleWithLowestPrice.low} at ${candleWithLowestPrice.openTime} `; } return message; } }

5d2036de1c12012a440806dbc109ba41bb49e194

ts

TypeScript

utils/overlayPhoto.ts

dappweaver/ooxxnft_web

df249e520eab5f28576d1f4066a5245f8ee64fa2

utils/overlayPhoto.ts

dappweaver/ooxxnft_web

df249e520eab5f28576d1f4066a5245f8ee64fa2

utils/overlayPhoto.ts

dappweaver/ooxxnft_web

df249e520eab5f28576d1f4066a5245f8ee64fa2

2022-03-12T15:22:33.000Z

2022-03-12T15:22:33.000Z

export const SVG_W = 440; export const SVG_H = 660; export const NewGameSVG = `<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 420 660"><style>.base { fill: white; font-family: serif; font-size: 14px; }</style><rect width="100%" height="100%" fill="black" /><line x1="140" y1="0" x2="140" y2="420" stroke="white" stroke-width="3" /><line x1="280" y1="0" x2="280" y2="420" stroke="white" stroke-width="3" /><line x1="0" y1="140" x2="420" y2="140" stroke="white" stroke-width="3" /><line x1="0" y1="280" x2="420" y2="280" stroke="white" stroke-width="3" /></svg>`; export function getSharpIdx(x: number, y: number) { // console.log(`getSharpIdx() x:${x}, y: ${y}`); let yInd = (y < (130 / 660)) ? 0 : (y > (150 / 660) && y < (270 / 660)) ? 1 : (y > (290 / 660) && y < (410 / 660)) ? 2 : -1; if (yInd < 0) { return -1; } let xInd = (x < (130 / 420)) ? 0 : (x > (150 / 420) && x < (270 / 420)) ? 1 : (x > (290 / 420) && x < (420 / 420)) ? 2 : -1; if (xInd < 0) { return -1; } return xInd + yInd * 3; } function decimalToHex(d: number) { var hex = Number(d).toString(16); hex = "000000".substr(0, 6 - hex.length) + hex; return hex; } export function xmlDrawO(xmlDoc: any, space: number, color: number) { // console.log("xmlDrawO:, space:", space); const x = (space % 3) * 140 + 70; const y = Math.floor(space / 3) * 140 + 70; let o = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "circle"); o.setAttribute('cx', x); o.setAttribute('cy', y); o.setAttribute('r', '50'); o.setAttribute("stroke", "#" + decimalToHex(color)); o.setAttribute("stroke-width", "3"); o.setAttribute("fill", "none"); xmlDoc.childNodes[0].insertBefore(o, xmlDoc.childNodes[0].childNodes[3]); } export function xmlDrawX(xmlDoc: any, space: number, color: number) { const x = (space % 3) * 140 + 20; const y = Math.floor(space / 3) * 140 + 20; // console.log("xmlDrawO:, space:", space); // console.log(`x=${x}, y=${y}`); // '\' of 'X' let l1 = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "line"); l1.setAttribute('x1', x); l1.setAttribute('y1', y); l1.setAttribute('x2', x + 100); l1.setAttribute('y2', y + 100); l1.setAttribute("stroke", "#" + decimalToHex(color)); l1.setAttribute("stroke-width", "3"); // '/' of 'X' let l2 = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "line"); l2.setAttribute('x1', x + 100); l2.setAttribute('y1', y); l2.setAttribute('x2', x); l2.setAttribute('y2', y + 100); l2.setAttribute("stroke", "#" + decimalToHex(color)); l2.setAttribute("stroke-width", "3"); xmlDoc.childNodes[0].insertBefore(l1, xmlDoc.childNodes[0].childNodes[3]); xmlDoc.childNodes[0].insertBefore(l2, xmlDoc.childNodes[0].childNodes[3]); } function getBoolean(_packedBools: number, _boolNumber: number) { const flag = (_packedBools >> _boolNumber) & (1); return (flag == 1 ? true : false); } export function getSpaceOXChar(marksO: number, marksX: number, space: number) { const o = getBoolean(marksO, space); if (o) { return 'O'; } const x = getBoolean(marksX, space); if (x) { return 'X'; } return null; }

export const SVG_W = 440; export const SVG_H = 660; export const NewGameSVG = `<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 420 660"><style>.base { fill: white; font-family: serif; font-size: 14px; }</style><rect width="100%" height="100%" fill="black" /><line x1="140" y1="0" x2="140" y2="420" stroke="white" stroke-width="3" /><line x1="280" y1="0" x2="280" y2="420" stroke="white" stroke-width="3" /><line x1="0" y1="140" x2="420" y2="140" stroke="white" stroke-width="3" /><line x1="0" y1="280" x2="420" y2="280" stroke="white" stroke-width="3" /></svg>`; export function getSharpIdx(x, y) { // console.log(`getSharpIdx() x:${x}, y: ${y}`); let yInd = (y < (130 / 660)) ? 0 : (y > (150 / 660) && y < (270 / 660)) ? 1 : (y > (290 / 660) && y < (410 / 660)) ? 2 : -1; if (yInd < 0) { return -1; } let xInd = (x < (130 / 420)) ? 0 : (x > (150 / 420) && x < (270 / 420)) ? 1 : (x > (290 / 420) && x < (420 / 420)) ? 2 : -1; if (xInd < 0) { return -1; } return xInd + yInd * 3; } /* Example usages of 'decimalToHex' are shown below: o.setAttribute("stroke", "#" + decimalToHex(color)); l1.setAttribute("stroke", "#" + decimalToHex(color)); l2.setAttribute("stroke", "#" + decimalToHex(color)); */ function decimalToHex(d) { var hex = Number(d).toString(16); hex = "000000".substr(0, 6 - hex.length) + hex; return hex; } export function xmlDrawO(xmlDoc, space, color) { // console.log("xmlDrawO:, space:", space); const x = (space % 3) * 140 + 70; const y = Math.floor(space / 3) * 140 + 70; let o = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "circle"); o.setAttribute('cx', x); o.setAttribute('cy', y); o.setAttribute('r', '50'); o.setAttribute("stroke", "#" + decimalToHex(color)); o.setAttribute("stroke-width", "3"); o.setAttribute("fill", "none"); xmlDoc.childNodes[0].insertBefore(o, xmlDoc.childNodes[0].childNodes[3]); } export function xmlDrawX(xmlDoc, space, color) { const x = (space % 3) * 140 + 20; const y = Math.floor(space / 3) * 140 + 20; // console.log("xmlDrawO:, space:", space); // console.log(`x=${x}, y=${y}`); // '\' of 'X' let l1 = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "line"); l1.setAttribute('x1', x); l1.setAttribute('y1', y); l1.setAttribute('x2', x + 100); l1.setAttribute('y2', y + 100); l1.setAttribute("stroke", "#" + decimalToHex(color)); l1.setAttribute("stroke-width", "3"); // '/' of 'X' let l2 = xmlDoc.createElementNS(xmlDoc.documentElement.namespaceURI, "line"); l2.setAttribute('x1', x + 100); l2.setAttribute('y1', y); l2.setAttribute('x2', x); l2.setAttribute('y2', y + 100); l2.setAttribute("stroke", "#" + decimalToHex(color)); l2.setAttribute("stroke-width", "3"); xmlDoc.childNodes[0].insertBefore(l1, xmlDoc.childNodes[0].childNodes[3]); xmlDoc.childNodes[0].insertBefore(l2, xmlDoc.childNodes[0].childNodes[3]); } /* Example usages of 'getBoolean' are shown below: getBoolean(marksO, space); getBoolean(marksX, space); */ function getBoolean(_packedBools, _boolNumber) { const flag = (_packedBools >> _boolNumber) & (1); return (flag == 1 ? true : false); } export function getSpaceOXChar(marksO, marksX, space) { const o = getBoolean(marksO, space); if (o) { return 'O'; } const x = getBoolean(marksX, space); if (x) { return 'X'; } return null; }

5df08bc984ff9aa5bbc66b68ebf7b948d951bbac

ts

TypeScript

libs/imagery/CoordTransform.ts

ts-gis/ts-cesium-lib

6937e7d905037d3555bbcfe7561867b5a23f13fe

2022-01-06T01:21:31.000Z

2022-01-06T01:21:31.000Z

libs/imagery/CoordTransform.ts

ts-gis/ts-cesium-lib

6937e7d905037d3555bbcfe7561867b5a23f13fe

libs/imagery/CoordTransform.ts

ts-gis/ts-cesium-lib

6937e7d905037d3555bbcfe7561867b5a23f13fe

const BD_FACTOR = (3.14159265358979324 * 3000.0) / 180.0 const PI = 3.1415926535897932384626 const RADIUS = 6378245.0 const EE = 0.00669342162296594323 class CoordTransform { /** * BD-09 To GCJ-02 * @param lng * @param lat * @returns {number[]} */ static BD09ToGCJ02(lng:number, lat:number) { let x = +lng - 0.0065 let y = +lat - 0.006 let z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * BD_FACTOR) let theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * BD_FACTOR) let gg_lng = z * Math.cos(theta) let gg_lat = z * Math.sin(theta) return [gg_lng, gg_lat] } /** * GCJ-02 To BD-09 * @param lng * @param lat * @returns {number[]} * @constructor */ static GCJ02ToBD09(lng:number, lat:number) { lat = +lat lng = +lng let z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * BD_FACTOR) let theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * BD_FACTOR) let bd_lng = z * Math.cos(theta) + 0.0065 let bd_lat = z * Math.sin(theta) + 0.006 return [bd_lng, bd_lat] } /** * WGS-84 To GCJ-02 * @param lng * @param lat * @returns {number[]} */ static WGS84ToGCJ02(lng:number, lat:number) { lat = +lat lng = +lng if (this.out_of_china(lng, lat)) { return [lng, lat] } else { let d = this.delta(lng, lat) return [lng + d[0], lat + d[1]] } } /** * GCJ-02 To WGS-84 * @param lng * @param lat * @returns {number[]} * @constructor */ static GCJ02ToWGS84(lng:number, lat:number) { lat = +lat lng = +lng if (this.out_of_china(lng, lat)) { return [lng, lat] } else { let d = this.delta(lng, lat) let mgLng = lng + d[0] let mgLat = lat + d[1] return [lng * 2 - mgLng, lat * 2 - mgLat] } } /** * * @param lng * @param lat * @returns {number[]} */ static delta(lng:number, lat:number) { let dLng = this.transformLng(lng - 105, lat - 35) let dLat = this.transformLat(lng - 105, lat - 35) const radLat = (lat / 180) * PI let magic = Math.sin(radLat) magic = 1 - EE * magic * magic const sqrtMagic = Math.sqrt(magic) dLng = (dLng * 180) / ((RADIUS / sqrtMagic) * Math.cos(radLat) * PI) dLat = (dLat * 180) / (((RADIUS * (1 - EE)) / (magic * sqrtMagic)) * PI) return [dLng, dLat] } /** * * @param lng * @param lat * @returns {number} */ static transformLng(lng:number, lat:number) { lat = +lat lng = +lng let ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng)) ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0 ret += ((20.0 * Math.sin(lng * PI) + 40.0 * Math.sin((lng / 3.0) * PI)) * 2.0) / 3.0 ret += ((150.0 * Math.sin((lng / 12.0) * PI) + 300.0 * Math.sin((lng / 30.0) * PI)) * 2.0) / 3.0 return ret } /** * * @param lng * @param lat * @returns {number} */ static transformLat(lng:number, lat:number) { lat = +lat lng = +lng let ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng)) ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0 ret += ((20.0 * Math.sin(lat * PI) + 40.0 * Math.sin((lat / 3.0) * PI)) * 2.0) / 3.0 ret += ((160.0 * Math.sin((lat / 12.0) * PI) + 320 * Math.sin((lat * PI) / 30.0)) * 2.0) / 3.0 return ret } /** * * @param lng * @param lat * @returns {boolean} */ static out_of_china(lng:number, lat:number) { lat = +lat lng = +lng return !(lng > 73.66 && lng < 135.05 && lat > 3.86 && lat < 53.55) } } export default CoordTransform

const BD_FACTOR = (3.14159265358979324 * 3000.0) / 180.0 const PI = 3.1415926535897932384626 const RADIUS = 6378245.0 const EE = 0.00669342162296594323 class CoordTransform { /** * BD-09 To GCJ-02 * @param lng * @param lat * @returns {number[]} */ static BD09ToGCJ02(lng, lat) { let x = +lng - 0.0065 let y = +lat - 0.006 let z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * BD_FACTOR) let theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * BD_FACTOR) let gg_lng = z * Math.cos(theta) let gg_lat = z * Math.sin(theta) return [gg_lng, gg_lat] } /** * GCJ-02 To BD-09 * @param lng * @param lat * @returns {number[]} * @constructor */ static GCJ02ToBD09(lng, lat) { lat = +lat lng = +lng let z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * BD_FACTOR) let theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * BD_FACTOR) let bd_lng = z * Math.cos(theta) + 0.0065 let bd_lat = z * Math.sin(theta) + 0.006 return [bd_lng, bd_lat] } /** * WGS-84 To GCJ-02 * @param lng * @param lat * @returns {number[]} */ static WGS84ToGCJ02(lng, lat) { lat = +lat lng = +lng if (this.out_of_china(lng, lat)) { return [lng, lat] } else { let d = this.delta(lng, lat) return [lng + d[0], lat + d[1]] } } /** * GCJ-02 To WGS-84 * @param lng * @param lat * @returns {number[]} * @constructor */ static GCJ02ToWGS84(lng, lat) { lat = +lat lng = +lng if (this.out_of_china(lng, lat)) { return [lng, lat] } else { let d = this.delta(lng, lat) let mgLng = lng + d[0] let mgLat = lat + d[1] return [lng * 2 - mgLng, lat * 2 - mgLat] } } /** * * @param lng * @param lat * @returns {number[]} */ static delta(lng, lat) { let dLng = this.transformLng(lng - 105, lat - 35) let dLat = this.transformLat(lng - 105, lat - 35) const radLat = (lat / 180) * PI let magic = Math.sin(radLat) magic = 1 - EE * magic * magic const sqrtMagic = Math.sqrt(magic) dLng = (dLng * 180) / ((RADIUS / sqrtMagic) * Math.cos(radLat) * PI) dLat = (dLat * 180) / (((RADIUS * (1 - EE)) / (magic * sqrtMagic)) * PI) return [dLng, dLat] } /** * * @param lng * @param lat * @returns {number} */ static transformLng(lng, lat) { lat = +lat lng = +lng let ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng)) ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0 ret += ((20.0 * Math.sin(lng * PI) + 40.0 * Math.sin((lng / 3.0) * PI)) * 2.0) / 3.0 ret += ((150.0 * Math.sin((lng / 12.0) * PI) + 300.0 * Math.sin((lng / 30.0) * PI)) * 2.0) / 3.0 return ret } /** * * @param lng * @param lat * @returns {number} */ static transformLat(lng, lat) { lat = +lat lng = +lng let ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng)) ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0 ret += ((20.0 * Math.sin(lat * PI) + 40.0 * Math.sin((lat / 3.0) * PI)) * 2.0) / 3.0 ret += ((160.0 * Math.sin((lat / 12.0) * PI) + 320 * Math.sin((lat * PI) / 30.0)) * 2.0) / 3.0 return ret } /** * * @param lng * @param lat * @returns {boolean} */ static out_of_china(lng, lat) { lat = +lat lng = +lng return !(lng > 73.66 && lng < 135.05 && lat > 3.86 && lat < 53.55) } } export default CoordTransform

574a90b8366d07f821fdec6eb1f5c102e754c994

ts

TypeScript

src/utils/PitchUtil.ts

igorski/molecular-music-generator-web

b1265ab84a18e893d71bf537a534dc730d090f21

2022-02-02T01:45:08.000Z

2022-03-03T23:17:28.000Z

src/utils/PitchUtil.ts

igorski/molecular-music-generator-web

b1265ab84a18e893d71bf537a534dc730d090f21

src/utils/PitchUtil.ts

igorski/molecular-music-generator-web

b1265ab84a18e893d71bf537a534dc730d090f21

/** * The MIT License (MIT) * * Igor Zinken 2016-2022 - https://www.igorski.nl * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /** * order of note names within a single octave */ export const OCTAVE_SCALE: Array<string> = [ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" ]; /** * @param {string} aNote - musical note to return ( A, B, C, D, E, F, G with * possible enharmonic notes ( 'b' meaning 'flat', '#' meaning 'sharp' ) * NOTE: flats are CASE sensitive ( to prevent seeing the note 'B' instead of 'b' ) * @param {number} aOctave - the octave to return ( accepted range 0 - 9 ) * @return {number} containing exact frequency in Hz for requested note */ export const getFrequency = ( aNote: string, aOctave: number ): number => { let freq; let enharmonic = 0; // detect flat enharmonic let i = aNote.indexOf( "b" ); if ( i > -1 ) { aNote = aNote.substr( i - 1, 1 ); enharmonic = -1; } // detect sharp enharmonic i = aNote.indexOf( "#" ); if ( i > -1 ) { aNote = aNote.substr( i - 1, 1 ); enharmonic = 1; } freq = getOctaveIndex( aNote, enharmonic ); if ( aOctave === 4 ) { return freq; } else { // translate the pitches to the requested octave const d = aOctave - 4; let j = Math.abs( d ); for ( i = 0; i < j; ++i ) { if ( d > 0 ) { freq *= 2; } else { freq *= 0.5; } } return freq; } }; /* internal methods */ /** * pitch table for all notes from C to B at octave 4 * which is used for calculating all pitches at other octaves */ const OCTAVE: Array<number> = [ 261.626, 277.183, 293.665, 311.127, 329.628, 349.228, 369.994, 391.995, 415.305, 440, 466.164, 493.883 ]; /** * retrieves the index in the octave array for a given note * modifier enharmonic returns the previous ( for a 'flat' note ) * or next ( for a 'sharp' note ) index * * @param {string} aNote ( A, B, C, D, E, F, G ) * @param {number=} aEnharmonic optional, defaults to 0 ( 0, -1 for flat, 1 for sharp ) * @return {number} */ function getOctaveIndex( aNote: string, aEnharmonic?: number ): number { if ( typeof aEnharmonic !== "number" ) { aEnharmonic = 0; } for ( let i = 0, j = OCTAVE.length; i < j; ++i ) { if ( OCTAVE_SCALE[ i ] === aNote ) { let k = i + aEnharmonic; if ( k > j ) { return OCTAVE[ 0 ]; } if ( k < 0 ) { return OCTAVE[ OCTAVE.length - 1 ]; } return OCTAVE[ k ]; } } return NaN; }

/** * The MIT License (MIT) * * Igor Zinken 2016-2022 - https://www.igorski.nl * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /** * order of note names within a single octave */ export const OCTAVE_SCALE = [ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" ]; /** * @param {string} aNote - musical note to return ( A, B, C, D, E, F, G with * possible enharmonic notes ( 'b' meaning 'flat', '#' meaning 'sharp' ) * NOTE: flats are CASE sensitive ( to prevent seeing the note 'B' instead of 'b' ) * @param {number} aOctave - the octave to return ( accepted range 0 - 9 ) * @return {number} containing exact frequency in Hz for requested note */ export const getFrequency = ( aNote, aOctave ) => { let freq; let enharmonic = 0; // detect flat enharmonic let i = aNote.indexOf( "b" ); if ( i > -1 ) { aNote = aNote.substr( i - 1, 1 ); enharmonic = -1; } // detect sharp enharmonic i = aNote.indexOf( "#" ); if ( i > -1 ) { aNote = aNote.substr( i - 1, 1 ); enharmonic = 1; } freq = getOctaveIndex( aNote, enharmonic ); if ( aOctave === 4 ) { return freq; } else { // translate the pitches to the requested octave const d = aOctave - 4; let j = Math.abs( d ); for ( i = 0; i < j; ++i ) { if ( d > 0 ) { freq *= 2; } else { freq *= 0.5; } } return freq; } }; /* internal methods */ /** * pitch table for all notes from C to B at octave 4 * which is used for calculating all pitches at other octaves */ const OCTAVE = [ 261.626, 277.183, 293.665, 311.127, 329.628, 349.228, 369.994, 391.995, 415.305, 440, 466.164, 493.883 ]; /** * retrieves the index in the octave array for a given note * modifier enharmonic returns the previous ( for a 'flat' note ) * or next ( for a 'sharp' note ) index * * @param {string} aNote ( A, B, C, D, E, F, G ) * @param {number=} aEnharmonic optional, defaults to 0 ( 0, -1 for flat, 1 for sharp ) * @return {number} */ /* Example usages of 'getOctaveIndex' are shown below: freq = getOctaveIndex(aNote, enharmonic); */ function getOctaveIndex( aNote, aEnharmonic? ) { if ( typeof aEnharmonic !== "number" ) { aEnharmonic = 0; } for ( let i = 0, j = OCTAVE.length; i < j; ++i ) { if ( OCTAVE_SCALE[ i ] === aNote ) { let k = i + aEnharmonic; if ( k > j ) { return OCTAVE[ 0 ]; } if ( k < 0 ) { return OCTAVE[ OCTAVE.length - 1 ]; } return OCTAVE[ k ]; } } return NaN; }

57c96f4bfc6c09374f01c03292bc09d487ea9ade

ts

TypeScript

src/note_durations.ts

bawierino/noiez

c2649008a29b8e811f77c14832c4bfd52e3fd94a

2022-02-11T07:51:37.000Z

2022-02-11T07:51:37.000Z

src/note_durations.ts

bawierino/noiez

c2649008a29b8e811f77c14832c4bfd52e3fd94a

src/note_durations.ts

bawierino/noiez

c2649008a29b8e811f77c14832c4bfd52e3fd94a

const noteDurationModifiers = { dotted: 3 / 2, triplet: 2 / 3, quintuplet: 4 / 5, septuplet: 4 / 7, nonuplet: 8 / 9, }; export type NTupletValue = 3 | 5 | 7 | 9; export enum NoteDivision { FULL = "FULL", HALF = "HALF", QUARTER = "QUARTER", EIGHTH = "EIGHTH", SIXTEENTH = "SIXTEENTH", THIRTYSECOND = "THIRTYSECOND", SIXTYFOURTH = "SIXTYFOURTH", ONEHUNDERDANDTWENTYEIGHTH = "ONEHUNDERDANDTWENTYEIGHTH", } export function getNoteDuration(model: { bpm: number; noteDivision: NoteDivision; nTupletValue?: NTupletValue; dotted?: boolean; }): number { const { bpm, noteDivision, dotted = false, nTupletValue = undefined, } = model; const noteDivisionRatio = getNoteDivisionRatio(noteDivision); const nTupletRatio = nTupletValue ? getNTupletRatio(nTupletValue) : 1; const dottedRatio = dotted ? noteDurationModifiers.dotted : 1; const durationOfOneMeasure = (60 * 1000 * 4) / bpm; return ( durationOfOneMeasure * noteDivisionRatio * nTupletRatio * dottedRatio ); } function getNoteDivisionRatio(noteDivision: NoteDivision): number { switch (noteDivision) { case NoteDivision.FULL: return 1; case NoteDivision.HALF: return 1 / 2; case NoteDivision.QUARTER: return 1 / 4; case NoteDivision.EIGHTH: return 1 / 8; case NoteDivision.SIXTEENTH: return 1 / 16; case NoteDivision.THIRTYSECOND: return 1 / 32; case NoteDivision.SIXTYFOURTH: return 1 / 64; case NoteDivision.ONEHUNDERDANDTWENTYEIGHTH: return 1 / 128; default: throw new Error(`Unknown note division ${noteDivision}`); } } function getNTupletRatio(nTupletValue: NTupletValue): number { switch (nTupletValue) { case 3: return noteDurationModifiers.triplet; case 5: return noteDurationModifiers.quintuplet; case 7: return noteDurationModifiers.septuplet; case 9: return noteDurationModifiers.nonuplet; default: throw new Error(`Unknown nTupletValue ${nTupletValue}`); } }

const noteDurationModifiers = { dotted: 3 / 2, triplet: 2 / 3, quintuplet: 4 / 5, septuplet: 4 / 7, nonuplet: 8 / 9, }; export type NTupletValue = 3 | 5 | 7 | 9; export enum NoteDivision { FULL = "FULL", HALF = "HALF", QUARTER = "QUARTER", EIGHTH = "EIGHTH", SIXTEENTH = "SIXTEENTH", THIRTYSECOND = "THIRTYSECOND", SIXTYFOURTH = "SIXTYFOURTH", ONEHUNDERDANDTWENTYEIGHTH = "ONEHUNDERDANDTWENTYEIGHTH", } export function getNoteDuration(model) { const { bpm, noteDivision, dotted = false, nTupletValue = undefined, } = model; const noteDivisionRatio = getNoteDivisionRatio(noteDivision); const nTupletRatio = nTupletValue ? getNTupletRatio(nTupletValue) : 1; const dottedRatio = dotted ? noteDurationModifiers.dotted : 1; const durationOfOneMeasure = (60 * 1000 * 4) / bpm; return ( durationOfOneMeasure * noteDivisionRatio * nTupletRatio * dottedRatio ); } /* Example usages of 'getNoteDivisionRatio' are shown below: getNoteDivisionRatio(noteDivision); */ function getNoteDivisionRatio(noteDivision) { switch (noteDivision) { case NoteDivision.FULL: return 1; case NoteDivision.HALF: return 1 / 2; case NoteDivision.QUARTER: return 1 / 4; case NoteDivision.EIGHTH: return 1 / 8; case NoteDivision.SIXTEENTH: return 1 / 16; case NoteDivision.THIRTYSECOND: return 1 / 32; case NoteDivision.SIXTYFOURTH: return 1 / 64; case NoteDivision.ONEHUNDERDANDTWENTYEIGHTH: return 1 / 128; default: throw new Error(`Unknown note division ${noteDivision}`); } } /* Example usages of 'getNTupletRatio' are shown below: nTupletValue ? getNTupletRatio(nTupletValue) : 1; */ function getNTupletRatio(nTupletValue) { switch (nTupletValue) { case 3: return noteDurationModifiers.triplet; case 5: return noteDurationModifiers.quintuplet; case 7: return noteDurationModifiers.septuplet; case 9: return noteDurationModifiers.nonuplet; default: throw new Error(`Unknown nTupletValue ${nTupletValue}`); } }

57d87d12960f35a593f6da68902f487a24c0f939

ts

TypeScript

tmp/2-function/examples/1-structures/structures_ok.ts

LabsAdemy/Docs-CleanCode-Intro

fb5e7908ab52f6b6adbab62fa41e84401c119e4c

2022-02-17T10:19:04.000Z

2022-02-17T10:19:04.000Z

tmp/2-function/examples/1-structures/structures_ok.ts

LabsAdemy/Docs-CleanCode-Intro

fb5e7908ab52f6b6adbab62fa41e84401c119e4c

tmp/2-function/examples/1-structures/structures_ok.ts

LabsAdemy/Docs-CleanCode-Intro

fb5e7908ab52f6b6adbab62fa41e84401c119e4c

// ✔️ Define types (or interfaces, os structs... or even classes) type Currency = 'EUR' | 'USD'; type Money = { amount: number; currency: Currency }; type SavingsCondition = { principal: Money; rate: number; years: number }; export function calculateInterest(): Money { // ✔️ object literal const mySavingsConditionsLit: SavingsCondition = { principal: { amount: 1000, currency: 'EUR' }, rate: 3.5, years: 1, }; // ✔️ object factory const mySavingsConditions: SavingsCondition = conditionsFactory(100, 3.5); // ✔️ single parameter const interest = getSimpleInterest(mySavingsConditions); return interest; } function moneyFactory(amount: number, currency: Currency = 'EUR') { // ✔️ parameter validation, and default value assertAmountPositive(amount); return { amount, currency, }; } function conditionsFactory( amount: number, rate: number, years: number = 1, currency: Currency = 'EUR' ) { // ✔️ parameter validation assertAmountPositive(amount); assertRateRange(rate); assertYearsRange(years); const conditions: SavingsCondition = { principal: moneyFactory(amount, currency), rate: rate, years: years, }; return conditions; } function assertYearsRange(years: number) { const MIN_YEARS = 0; const MAX_YEARS = 100; if (years < MIN_YEARS || years > MAX_YEARS) throw new Error(`Year must be between ${MIN_YEARS} and ${MAX_YEARS}`); } function assertRateRange(rate: number) { const MIN_RATE = 1; const MAX_RATE = 10; if (rate < MIN_RATE || rate > MAX_RATE) throw new Error(`Rate must be between ${MIN_RATE} and ${MAX_RATE}`); } function assertAmountPositive(amount: number) { if (amount < 0) throw new Error(`Amount must be positive`); } function getSimpleInterest(conditions: SavingsCondition): Money { const PER_CENT = 100; const interestAmount = (conditions.principal.amount * conditions.rate * conditions.years) / PER_CENT; return moneyFactory(interestAmount, conditions.principal.currency); }

// ✔️ Define types (or interfaces, os structs... or even classes) type Currency = 'EUR' | 'USD'; type Money = { amount; currency }; type SavingsCondition = { principal; rate; years }; export function calculateInterest() { // ✔️ object literal const mySavingsConditionsLit = { principal: { amount: 1000, currency: 'EUR' }, rate: 3.5, years: 1, }; // ✔️ object factory const mySavingsConditions = conditionsFactory(100, 3.5); // ✔️ single parameter const interest = getSimpleInterest(mySavingsConditions); return interest; } /* Example usages of 'moneyFactory' are shown below: moneyFactory(amount, currency); moneyFactory(interestAmount, conditions.principal.currency); */ function moneyFactory(amount, currency = 'EUR') { // ✔️ parameter validation, and default value assertAmountPositive(amount); return { amount, currency, }; } /* Example usages of 'conditionsFactory' are shown below: conditionsFactory(100, 3.5); */ function conditionsFactory( amount, rate, years = 1, currency = 'EUR' ) { // ✔️ parameter validation assertAmountPositive(amount); assertRateRange(rate); assertYearsRange(years); const conditions = { principal: moneyFactory(amount, currency), rate: rate, years: years, }; return conditions; } /* Example usages of 'assertYearsRange' are shown below: assertYearsRange(years); */ function assertYearsRange(years) { const MIN_YEARS = 0; const MAX_YEARS = 100; if (years < MIN_YEARS || years > MAX_YEARS) throw new Error(`Year must be between ${MIN_YEARS} and ${MAX_YEARS}`); } /* Example usages of 'assertRateRange' are shown below: assertRateRange(rate); */ function assertRateRange(rate) { const MIN_RATE = 1; const MAX_RATE = 10; if (rate < MIN_RATE || rate > MAX_RATE) throw new Error(`Rate must be between ${MIN_RATE} and ${MAX_RATE}`); } /* Example usages of 'assertAmountPositive' are shown below: // ✔️ parameter validation, and default value assertAmountPositive(amount); // ✔️ parameter validation assertAmountPositive(amount); */ function assertAmountPositive(amount) { if (amount < 0) throw new Error(`Amount must be positive`); } /* Example usages of 'getSimpleInterest' are shown below: getSimpleInterest(mySavingsConditions); */ function getSimpleInterest(conditions) { const PER_CENT = 100; const interestAmount = (conditions.principal.amount * conditions.rate * conditions.years) / PER_CENT; return moneyFactory(interestAmount, conditions.principal.currency); }

8d18343dd4de319dd4ace0d978101024dfde816a

ts

TypeScript

src/Random.ts

merakigenart/meraki-js-sdk

975536ee5b0fa997c7222d68e9574ac7acf08fdd

2022-01-20T23:02:12.000Z

2022-02-05T10:27:55.000Z

src/Random.ts

merakigenart/meraki-js-sdk

975536ee5b0fa997c7222d68e9574ac7acf08fdd

2022-01-17T19:18:03.000Z

2022-03-30T19:29:21.000Z

src/Random.ts

merakigenart/meraki-js-sdk

975536ee5b0fa997c7222d68e9574ac7acf08fdd

/* eslint-disable no-unused-vars */ // @ts-nocheck //import { generateRandomTokenData } from './helpers'; export class Random { protected state: Record<string, any>; protected seedValues: Record<string, any>; constructor(public tokenData = { tokenHash: '', tokenId: '' }) { if (this.tokenData.tokenHash === '') { this.tokenData.tokenHash = '0x940cca72744643225ef08d17711cb873940cca72744643225ef08d17711cb873'; } const seeds = this.generateSeeds(this.tokenData.tokenHash); this.state = this.initializeState().state; this.seedValues = this.initializeSeeds(seeds); this.rnd(); } // random number between 0 (inclusive) and 1 (exclusive) decimal() { return this.rnd(); } // random number between a (inclusive) and b (exclusive) number(a = undefined, b = undefined) { if (a === undefined && b === undefined) { a = 0; b = Number.MAX_VALUE - 2; } if (b === undefined) { b = a; a = 0; } if (a === undefined) { a = 0; } return a + (b - a) * this.decimal(); } // random integer between a (inclusive) and b (inclusive) // requires a < b for proper probability distribution integer(a = undefined, b = undefined) { if (a === undefined && b === undefined) { a = 0; b = Number.MAX_VALUE - 2; } if (b === undefined) { b = a; a = 0; } if (a === undefined) { a = 0; } return Math.floor(this.number(a, b + 1)); } // random boolean with p as percent likelihood of true boolean(p = 50) { return this.decimal() < p * 0.1; } // random value in an array of items element(list) { return list[this.integer(0, list.length - 1)]; } generateSeeds(str: string): number[] { let part = 0; const seeds: number[] = []; str = `${str}`; if (str.startsWith('0x')) { str = str.slice(2); } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 4; } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 2; } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 1; } for (let i = 0; i < str.length; i++) { part = str.substring(str.length - i - 4, str.length - i); part = part.substring(2, 4) + part.substring(0, 2); seeds.push(parseInt(part, 16)); i += 4; } return seeds; } protected initializeSeeds(seeds: number[]) { const seedValues = Object.assign( {}, { eps: Math.pow(2, -32), m0: seeds[0], m1: seeds[1], m2: seeds[2], m3: seeds[3], a0: seeds[4], a1: seeds[5], a2: seeds[6], a3: seeds[7], }, ); return seedValues; } protected initializeState(stateSize = 4, integerSize: 8 | 16 | 32 | 64 = 16) { const intMap = { 8: Uint8Array, 16: Uint16Array, 32: Uint32Array, 64: BigUint64Array, }; const intClass = intMap[integerSize]; const state = new intClass(stateSize); const dataView = new DataView(state.buffer); return { integerSize, stateSize, state, dataView, }; } rnd() { const { eps, a0, a1, a2, a3, m0, m1, m2, m3 } = this.seedValues; const a = this.state[0], b = this.state[1], c = this.state[2], e = this.state[3], f = 0 | (a0 + m0 * a), g = 0 | (a1 + m0 * b + (m1 * a + (f >>> 16))), h = 0 | (a2 + m0 * c + m1 * b + (m2 * a + (g >>> 16))); this.state[0] = f; this.state[1] = g; this.state[2] = h; this.state[3] = a3 + m0 * e + (m1 * c + m2 * b) + (m3 * a + (h >>> 16)); const i = (e << 21) + (((e >> 2) ^ c) << 5) + (((c >> 2) ^ b) >> 11); return eps * (((i >>> (e >> 11)) | (i << (31 & -(e >> 11)))) >>> 0); } shuffle(a: any[]) { const f = [...a]; let b, c, e = a.length; for (let i = 0; i < e; i++) { b = ~~(this.rnd() * e - 1); c = f[e]; f[e] = f[b]; f[b] = c; e--; } return f; } }

/* eslint-disable no-unused-vars */ // @ts-nocheck //import { generateRandomTokenData } from './helpers'; export class Random { protected state; protected seedValues; constructor(public tokenData = { tokenHash: '', tokenId: '' }) { if (this.tokenData.tokenHash === '') { this.tokenData.tokenHash = '0x940cca72744643225ef08d17711cb873940cca72744643225ef08d17711cb873'; } const seeds = this.generateSeeds(this.tokenData.tokenHash); this.state = this.initializeState().state; this.seedValues = this.initializeSeeds(seeds); this.rnd(); } // random number between 0 (inclusive) and 1 (exclusive) decimal() { return this.rnd(); } // random number between a (inclusive) and b (exclusive) number(a = undefined, b = undefined) { if (a === undefined && b === undefined) { a = 0; b = Number.MAX_VALUE - 2; } if (b === undefined) { b = a; a = 0; } if (a === undefined) { a = 0; } return a + (b - a) * this.decimal(); } // random integer between a (inclusive) and b (inclusive) // requires a < b for proper probability distribution integer(a = undefined, b = undefined) { if (a === undefined && b === undefined) { a = 0; b = Number.MAX_VALUE - 2; } if (b === undefined) { b = a; a = 0; } if (a === undefined) { a = 0; } return Math.floor(this.number(a, b + 1)); } // random boolean with p as percent likelihood of true boolean(p = 50) { return this.decimal() < p * 0.1; } // random value in an array of items element(list) { return list[this.integer(0, list.length - 1)]; } generateSeeds(str) { let part = 0; const seeds = []; str = `${str}`; if (str.startsWith('0x')) { str = str.slice(2); } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 4; } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 2; } for (let i = 0; i < str.length; i++) { part = str.slice(i, i + 4); seeds.push(parseInt(part, 16)); i += 1; } for (let i = 0; i < str.length; i++) { part = str.substring(str.length - i - 4, str.length - i); part = part.substring(2, 4) + part.substring(0, 2); seeds.push(parseInt(part, 16)); i += 4; } return seeds; } protected initializeSeeds(seeds) { const seedValues = Object.assign( {}, { eps: Math.pow(2, -32), m0: seeds[0], m1: seeds[1], m2: seeds[2], m3: seeds[3], a0: seeds[4], a1: seeds[5], a2: seeds[6], a3: seeds[7], }, ); return seedValues; } protected initializeState(stateSize = 4, integerSize = 16) { const intMap = { 8: Uint8Array, 16: Uint16Array, 32: Uint32Array, 64: BigUint64Array, }; const intClass = intMap[integerSize]; const state = new intClass(stateSize); const dataView = new DataView(state.buffer); return { integerSize, stateSize, state, dataView, }; } rnd() { const { eps, a0, a1, a2, a3, m0, m1, m2, m3 } = this.seedValues; const a = this.state[0], b = this.state[1], c = this.state[2], e = this.state[3], f = 0 | (a0 + m0 * a), g = 0 | (a1 + m0 * b + (m1 * a + (f >>> 16))), h = 0 | (a2 + m0 * c + m1 * b + (m2 * a + (g >>> 16))); this.state[0] = f; this.state[1] = g; this.state[2] = h; this.state[3] = a3 + m0 * e + (m1 * c + m2 * b) + (m3 * a + (h >>> 16)); const i = (e << 21) + (((e >> 2) ^ c) << 5) + (((c >> 2) ^ b) >> 11); return eps * (((i >>> (e >> 11)) | (i << (31 & -(e >> 11)))) >>> 0); } shuffle(a) { const f = [...a]; let b, c, e = a.length; for (let i = 0; i < e; i++) { b = ~~(this.rnd() * e - 1); c = f[e]; f[e] = f[b]; f[b] = c; e--; } return f; } }

8d3bf72ed17bb55c1069d0cfbf9974cd71ba2ac9

ts

TypeScript

lib/Models/BaseModel.ts

pangyunchuan/testOrm

a9c928cfad5a1d75feffd5c33ce6b222f6f93f00

2022-02-26T09:49:56.000Z

2022-02-26T09:49:56.000Z

lib/Models/BaseModel.ts

pangyunchuan/testOrm

a9c928cfad5a1d75feffd5c33ce6b222f6f93f00

lib/Models/BaseModel.ts

pangyunchuan/testOrm

a9c928cfad5a1d75feffd5c33ce6b222f6f93f00

2022-02-22T11:47:37.000Z

2022-02-22T11:47:37.000Z

export default abstract class BaseModel<ModelData extends object = {}> { /** * 模型数据类型，只用于获取类型，无用途 */ _data?: ModelData; // protected abstract table: string // // protected abstract getTable(): string /** * 模型数据 * @protected */ protected abstract data: ModelData; /** * 模型主键 * @protected */ protected primaryKey:string = 'id'; //是否已代理数据 private isProxyData: boolean = false; //无法做到,会让后代提示,this类型问题 // constructor() { // // super(props); // return this.proxyData() // } /** * 创建一个代理模型数据的模型实例 * @param data 模型数据 * @param call */ static createModel<M extends BaseModel, Da extends Partial<NonNullable<M['_data']>> = NonNullable<M['_data']>>( this: new () => M, data?: Da, call?: (model: M & Da) => void ): M & Da { return new this().createModel(data, call) } /** * 创建一个代理模型数据的模型实例 * @param data 模型数据 * @param call 模型建立后回调 * @param newInst 是否新建模型 */ createModel<Da extends Partial<ModelData> = ModelData>(data?: Da, call?: (model: this & Da) => void, newInst = false): this & Da { const self = newInst ? <this>new (<any>this.constructor)() : this; const selfProxyData = self.proxyData<Da>() data && (selfProxyData.data = <any>data); call && call(selfProxyData) return selfProxyData } /** * 代理模型数据 data，让模型实例可以直接访问 * @protected */ protected proxyData<MD extends Partial<ModelData> = ModelData>(): this & MD { if (this.isProxyData) { return <this & MD>this } this.isProxyData = true; return <this & MD>new Proxy(this, { get(target: any, p: string | symbol) { if (p in target) { return target[p]; } if (target.data) { return target.data[p]; } return undefined; }, set(target: any, p: string | symbol, value: any) { if (p in target) { target[p] = value; return true; } if (target.data && p in target.data) { target.data[p] = value; return true; } target[p] = value; return true; // throw new Error('不存在的属性') // return true; }, has(target: any, p: string | symbol) { return (p in target) || (target.data && p in target.data); } // deleteProperty(target: any, p: string | symbol): boolean { // if (p in target) { // delete target[p]; // return true; // } // if (p in target.data) { // delete target.data[p]; // return true; // } // return false; // } }); } }

export default abstract class BaseModel<ModelData extends object = {}> { /** * 模型数据类型，只用于获取类型，无用途 */ _data?; // protected abstract table: string // // protected abstract getTable(): string /** * 模型数据 * @protected */ protected abstract data; /** * 模型主键 * @protected */ protected primaryKey = 'id'; //是否已代理数据 private isProxyData = false; //无法做到,会让后代提示,this类型问题 // constructor() { // // super(props); // return this.proxyData() // } /** * 创建一个代理模型数据的模型实例 * @param data 模型数据 * @param call */ static createModel<M extends BaseModel, Da extends Partial<NonNullable<M['_data']>> = NonNullable<M['_data']>>( this, data?, call? ) { return new this().createModel(data, call) } /** * 创建一个代理模型数据的模型实例 * @param data 模型数据 * @param call 模型建立后回调 * @param newInst 是否新建模型 */ createModel<Da extends Partial<ModelData> = ModelData>(data?, call?, newInst = false) { const self = newInst ? <this>new (<any>this.constructor)() : this; const selfProxyData = self.proxyData<Da>() data && (selfProxyData.data = <any>data); call && call(selfProxyData) return selfProxyData } /** * 代理模型数据 data，让模型实例可以直接访问 * @protected */ protected proxyData<MD extends Partial<ModelData> = ModelData>() { if (this.isProxyData) { return <this & MD>this } this.isProxyData = true; return <this & MD>new Proxy(this, { get(target, p) { if (p in target) { return target[p]; } if (target.data) { return target.data[p]; } return undefined; }, set(target, p, value) { if (p in target) { target[p] = value; return true; } if (target.data && p in target.data) { target.data[p] = value; return true; } target[p] = value; return true; // throw new Error('不存在的属性') // return true; }, has(target, p) { return (p in target) || (target.data && p in target.data); } // deleteProperty(target: any, p: string | symbol): boolean { // if (p in target) { // delete target[p]; // return true; // } // if (p in target.data) { // delete target.data[p]; // return true; // } // return false; // } }); } }

8d8e0680708b7322d95d0440ee9a53c1c5f7ec52

ts

TypeScript

cli/src/protocol/render/typescript/static/protocol.validator.ts

DmitryAstafyev/fiber

82b4c585ea811769a0b228445dc40bab9a4f875f

2022-01-03T16:04:34.000Z

2022-02-12T10:22:19.000Z

cli/src/protocol/render/typescript/static/protocol.validator.ts

DmitryAstafyev/fiber

82b4c585ea811769a0b228445dc40bab9a4f875f

cli/src/protocol/render/typescript/static/protocol.validator.ts

DmitryAstafyev/fiber

82b4c585ea811769a0b228445dc40bab9a4f875f

2022-02-07T21:54:16.000Z

2022-02-07T21:54:16.000Z

// injectable export interface IValidator { validate(value: any): Error | undefined; } export interface IPropScheme { prop: string; optional?: boolean; types?: Required<IValidator>; options?: IPropScheme[]; } export function validate(obj: any, scheme: IPropScheme[]): Error | undefined { if (typeof obj !== "object" || obj === null) { return new Error(`Expecting input to be object`); } const errors: string[] = scheme .map((property: IPropScheme) => { if (property.optional && obj[property.prop] === undefined) { return undefined; } if (property.types !== undefined) { const err: Error | undefined = property.types.validate( obj[property.prop] ); if (err instanceof Error) { return err.message; } else { return undefined; } } else if (property.options instanceof Array) { if ( typeof obj[property.prop] !== "object" || obj[property.prop] === null ) { return `Property "${property.prop}" should be an object, because it's enum`; } const target: any = obj[property.prop]; const options: string[] = []; try { property.options.forEach((prop: IPropScheme) => { if (prop.types === undefined) { throw new Error( `Invalid option description for option "${prop.prop}" of option "${property.prop}"` ); } if (target[prop.prop] !== undefined) { options.push(prop.prop); const err: Error | undefined = prop.types.validate( target[prop.prop] ); if (err instanceof Error) { throw new Error( `Fail to validate option "${prop.prop}" of option "${property.prop}" due: ${err.message}` ); } } }); } catch (err) { return err instanceof Error ? err.message : `Unknown error: ${err}`; } if (options.length > 1) { return `Enum should have only one definition or nothing. Found values for: ${options.join( ", " )}`; } return undefined; } else { return `Invalid map definition for property ${property.prop}`; } }) .filter((err) => err !== undefined) as string[]; return errors.length > 0 ? new Error(errors.join("\n")) : undefined; }

// injectable export interface IValidator { validate(value); } export interface IPropScheme { prop; optional?; types?; options?; } export /* Example usages of 'validate' are shown below: ; property.types.validate(obj[property.prop]); prop.types.validate(target[prop.prop]); */ function validate(obj, scheme) { if (typeof obj !== "object" || obj === null) { return new Error(`Expecting input to be object`); } const errors = scheme .map((property) => { if (property.optional && obj[property.prop] === undefined) { return undefined; } if (property.types !== undefined) { const err = property.types.validate( obj[property.prop] ); if (err instanceof Error) { return err.message; } else { return undefined; } } else if (property.options instanceof Array) { if ( typeof obj[property.prop] !== "object" || obj[property.prop] === null ) { return `Property "${property.prop}" should be an object, because it's enum`; } const target = obj[property.prop]; const options = []; try { property.options.forEach((prop) => { if (prop.types === undefined) { throw new Error( `Invalid option description for option "${prop.prop}" of option "${property.prop}"` ); } if (target[prop.prop] !== undefined) { options.push(prop.prop); const err = prop.types.validate( target[prop.prop] ); if (err instanceof Error) { throw new Error( `Fail to validate option "${prop.prop}" of option "${property.prop}" due: ${err.message}` ); } } }); } catch (err) { return err instanceof Error ? err.message : `Unknown error: ${err}`; } if (options.length > 1) { return `Enum should have only one definition or nothing. Found values for: ${options.join( ", " )}`; } return undefined; } else { return `Invalid map definition for property ${property.prop}`; } }) .filter((err) => err !== undefined) as string[]; return errors.length > 0 ? new Error(errors.join("\n")) : undefined; }

8d948986abaf04bbce20a35d6e23ee5152559bc8

tsx

TypeScript

apps/mobile-ctc/src/@libs/elsa-ui/theme/default.tsx

Elsa-Health/mammoth

afdf8453b75ed414a1438bb78309e8649ae7e20b

2022-03-03T17:43:39.000Z

2022-03-08T23:26:23.000Z

apps/mobile-ctc/src/@libs/elsa-ui/theme/default.tsx

Elsa-Health/mammoth

afdf8453b75ed414a1438bb78309e8649ae7e20b

2022-03-10T09:23:00.000Z

2022-03-18T14:14:16.000Z

apps/mobile-ctc/src/@libs/elsa-ui/theme/default.tsx

Elsa-Health/mammoth

afdf8453b75ed414a1438bb78309e8649ae7e20b

export type fontFamiliStyleType = | 'light' | 'normal' | 'medium' | 'bold' | 'black' | 'extra-black'; export const fontFamilyStyle = ( props: {italic?: boolean; font?: fontFamiliStyleType} = {}, ) => { if (props.italic !== undefined) { if (props.italic) { // italic fonts switch (props.font || 'normal') { case 'light': return 'AvenirLTStd-LightOblique'; case 'medium': return 'AvenirLTStd-MediumOblique'; case 'bold': return 'AvenirLTStd-HeavyOblique'; case 'black': return 'AvenirLTStd-BookOblique'; case 'extra-black': return 'AvenirLTStd-BlackOblique'; case 'normal': default: return 'AvenirLTStd-Oblique'; } } } switch (props.font || 'normal') { case 'light': return 'AvenirLTStd-Light'; case 'medium': return 'AvenirLTStd-Medium'; case 'bold': return 'AvenirLTStd-Heavy'; case 'black': return 'AvenirLTStd-Book'; case 'extra-black': return 'AvenirLTStd-Black'; case 'normal': default: return 'AvenirLTStd-Roman'; } }; export const DefaultColor = { primary: { base: '#4665AF', light: '#7992e1', dark: '#003b7f', }, secondary: { base: '#5558A6', light: '#8685d8', dark: '#222f77', // can change in the future }, }; export const DefaultSpacing = { xs: 4, sm: 8, md: 16, lg: 24, xl: 32, '2xl': 48, }; export const DefaultTypography = { fontFamilyStyle, sizes: { xs: '12px', sm: '14px', md: '16px', lg: '20px', xl: '24px', '2xl': '28px', }, };

export type fontFamiliStyleType = | 'light' | 'normal' | 'medium' | 'bold' | 'black' | 'extra-black'; export /* Example usages of 'fontFamilyStyle' are shown below: ; */ const fontFamilyStyle = ( props = {}, ) => { if (props.italic !== undefined) { if (props.italic) { // italic fonts switch (props.font || 'normal') { case 'light': return 'AvenirLTStd-LightOblique'; case 'medium': return 'AvenirLTStd-MediumOblique'; case 'bold': return 'AvenirLTStd-HeavyOblique'; case 'black': return 'AvenirLTStd-BookOblique'; case 'extra-black': return 'AvenirLTStd-BlackOblique'; case 'normal': default: return 'AvenirLTStd-Oblique'; } } } switch (props.font || 'normal') { case 'light': return 'AvenirLTStd-Light'; case 'medium': return 'AvenirLTStd-Medium'; case 'bold': return 'AvenirLTStd-Heavy'; case 'black': return 'AvenirLTStd-Book'; case 'extra-black': return 'AvenirLTStd-Black'; case 'normal': default: return 'AvenirLTStd-Roman'; } }; export const DefaultColor = { primary: { base: '#4665AF', light: '#7992e1', dark: '#003b7f', }, secondary: { base: '#5558A6', light: '#8685d8', dark: '#222f77', // can change in the future }, }; export const DefaultSpacing = { xs: 4, sm: 8, md: 16, lg: 24, xl: 32, '2xl': 48, }; export const DefaultTypography = { fontFamilyStyle, sizes: { xs: '12px', sm: '14px', md: '16px', lg: '20px', xl: '24px', '2xl': '28px', }, };

8dcef4976e2861209d2b66ec9ff2808b56c0bf9b

ts

TypeScript

src/TeaProgram.ts

lydell/elm-watch

d1511b24940db26d25f256ecec0f5beb82d4c34c

2022-03-12T19:21:46.000Z

2022-03-25T10:17:47.000Z

src/TeaProgram.ts

lydell/elm-watch

d1511b24940db26d25f256ecec0f5beb82d4c34c

2022-03-15T14:53:51.000Z

2022-03-15T14:53:51.000Z

src/TeaProgram.ts

lydell/elm-watch

d1511b24940db26d25f256ecec0f5beb82d4c34c

2022-03-13T16:15:33.000Z

2022-03-15T14:23:23.000Z

export async function runTeaProgram<Mutable, Msg, Model, Cmd, Result>(options: { initMutable: ( dispatch: (msg: Msg) => void, resolvePromise: (result: Result) => void, rejectPromise: (error: Error) => void ) => Mutable; init: [Model, Array<Cmd>]; update: (msg: Msg, model: Model) => [Model, Array<Cmd>]; runCmd: ( cmd: Cmd, mutable: Mutable, dispatch: (msg: Msg) => void, resolvePromise: (result: Result) => void, rejectPromise: (error: Error) => void ) => void; }): Promise<Result> { return new Promise((resolve, reject) => { const [initialModel, initialCmds] = options.init; let model: Model = initialModel; const msgQueue: Array<Msg> = []; let killed = false; const dispatch = (dispatchedMsg: Msg): void => { if (killed) { return; } const alreadyRunning = msgQueue.length > 0; msgQueue.push(dispatchedMsg); if (alreadyRunning) { return; } for (const msg of msgQueue) { const [newModel, cmds] = options.update(msg, model); model = newModel; runCmds(cmds); } msgQueue.length = 0; }; const runCmds = (cmds: Array<Cmd>): void => { for (const cmd of cmds) { options.runCmd( cmd, mutable, dispatch, (result) => { cmds.length = 0; killed = true; resolve(result); }, // istanbul ignore next (error) => { cmds.length = 0; killed = true; reject(error); } ); // istanbul ignore next if (killed) { break; } } }; const mutable = options.initMutable( dispatch, (result) => { killed = true; resolve(result); }, // istanbul ignore next (error) => { killed = true; reject(error); } ); runCmds(initialCmds); }); }

export async function runTeaProgram<Mutable, Msg, Model, Cmd, Result>(options) { return new Promise((resolve, reject) => { const [initialModel, initialCmds] = options.init; let model = initialModel; const msgQueue = []; let killed = false; /* Example usages of 'dispatch' are shown below: options.runCmd(cmd, mutable, dispatch, (result) => { cmds.length = 0; killed = true; resolve(result); }, // istanbul ignore next (error) => { cmds.length = 0; killed = true; reject(error); }); options.initMutable(dispatch, (result) => { killed = true; resolve(result); }, // istanbul ignore next (error) => { killed = true; reject(error); }); */ const dispatch = (dispatchedMsg) => { if (killed) { return; } const alreadyRunning = msgQueue.length > 0; msgQueue.push(dispatchedMsg); if (alreadyRunning) { return; } for (const msg of msgQueue) { const [newModel, cmds] = options.update(msg, model); model = newModel; runCmds(cmds); } msgQueue.length = 0; }; /* Example usages of 'runCmds' are shown below: runCmds(cmds); runCmds(initialCmds); */ const runCmds = (cmds) => { for (const cmd of cmds) { options.runCmd( cmd, mutable, dispatch, (result) => { cmds.length = 0; killed = true; resolve(result); }, // istanbul ignore next (error) => { cmds.length = 0; killed = true; reject(error); } ); // istanbul ignore next if (killed) { break; } } }; const mutable = options.initMutable( dispatch, (result) => { killed = true; resolve(result); }, // istanbul ignore next (error) => { killed = true; reject(error); } ); runCmds(initialCmds); }); }

8dd4eba467cc4f8c283713bdfc23d3b71e87f31d

ts

TypeScript

packages/typescript/src/lib.ts

mxenabled/widget-post-message-definitions

5de58da92fe4c12a5c2e8210b237e638ab2d8d73

packages/typescript/src/lib.ts

mxenabled/widget-post-message-definitions

5de58da92fe4c12a5c2e8210b237e638ab2d8d73

2022-03-23T22:15:42.000Z

2022-03-23T22:15:42.000Z

packages/typescript/src/lib.ts

mxenabled/widget-post-message-definitions

5de58da92fe4c12a5c2e8210b237e638ab2d8d73

export type BasePostMessageCallbackProps<T> = { onMessage?: (message: T) => void onInvalidMessageError?: (message: T, error: Error) => void } // This is an internal error. Thrown when we are decoding a post message's // metadata and we encourntered a missing field or an invalid value. This // likely means there has been a change to the definition of a post message // that we do not know about. export class PostMessageFieldDecodeError extends Error { public messageType: string public field: string public expectedType: TypeDef public gotValue: unknown constructor(messageType: string, field: string, expectedType: TypeDef, gotValue: unknown) { super(`Unable to decode '${field}' from '${messageType}'`) this.messageType = messageType this.field = field this.expectedType = expectedType this.gotValue = gotValue Object.setPrototypeOf(this, PostMessageFieldDecodeError.prototype) } } // This is an internal error. Thrown when we get a post message we don't konw // about. This likely means there is a new post message that this package needs // to define. export class PostMessageUnknownTypeError extends Error { public postMessageType: string constructor(postMessageType: string) { super(`Unknown post message: ${postMessageType}`) this.postMessageType = postMessageType Object.setPrototypeOf(this, PostMessageUnknownTypeError.prototype) } } export type MessageEventData = { mx?: boolean metadata?: Metadata type?: string } export type Value = string | number export type NestedValue = Record<string, Value> export type TypeDef = string | Array<string> | Record<string, string> export type Metadata = Record<string, Value | NestedValue> export function assertMessageProp( container: Metadata, postMessageType: string, field: string, expectedType: TypeDef, ) { const value = container[field] const valueIsDefined = typeof value !== "undefined" const valueIsString = typeof value === "string" const valueIsNumber = typeof value === "number" const valueIsObject = typeof value === "object" && !Array.isArray(value) const typeIsString = expectedType === "string" const typeIsNumber = expectedType === "number" const typeIsArray = expectedType instanceof Array const typeIsObject = typeof expectedType === "object" && !Array.isArray(expectedType) if (!valueIsDefined) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsString && !valueIsString) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsNumber && !valueIsNumber) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsArray && !(valueIsString && expectedType.includes(value))) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsObject && !valueIsObject) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsObject && valueIsObject) { Object.keys(expectedType).forEach((field) => { assertMessageProp(value, postMessageType, field, expectedType[field]) }) } }

export type BasePostMessageCallbackProps<T> = { onMessage? onInvalidMessageError? } // This is an internal error. Thrown when we are decoding a post message's // metadata and we encourntered a missing field or an invalid value. This // likely means there has been a change to the definition of a post message // that we do not know about. export class PostMessageFieldDecodeError extends Error { public messageType public field public expectedType public gotValue constructor(messageType, field, expectedType, gotValue) { super(`Unable to decode '${field}' from '${messageType}'`) this.messageType = messageType this.field = field this.expectedType = expectedType this.gotValue = gotValue Object.setPrototypeOf(this, PostMessageFieldDecodeError.prototype) } } // This is an internal error. Thrown when we get a post message we don't konw // about. This likely means there is a new post message that this package needs // to define. export class PostMessageUnknownTypeError extends Error { public postMessageType constructor(postMessageType) { super(`Unknown post message: ${postMessageType}`) this.postMessageType = postMessageType Object.setPrototypeOf(this, PostMessageUnknownTypeError.prototype) } } export type MessageEventData = { mx? metadata? type? } export type Value = string | number export type NestedValue = Record<string, Value> export type TypeDef = string | Array<string> | Record<string, string> export type Metadata = Record<string, Value | NestedValue> export /* Example usages of 'assertMessageProp' are shown below: assertMessageProp(value, postMessageType, field, expectedType[field]); */ function assertMessageProp( container, postMessageType, field, expectedType, ) { const value = container[field] const valueIsDefined = typeof value !== "undefined" const valueIsString = typeof value === "string" const valueIsNumber = typeof value === "number" const valueIsObject = typeof value === "object" && !Array.isArray(value) const typeIsString = expectedType === "string" const typeIsNumber = expectedType === "number" const typeIsArray = expectedType instanceof Array const typeIsObject = typeof expectedType === "object" && !Array.isArray(expectedType) if (!valueIsDefined) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsString && !valueIsString) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsNumber && !valueIsNumber) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsArray && !(valueIsString && expectedType.includes(value))) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsObject && !valueIsObject) { throw new PostMessageFieldDecodeError(postMessageType, field, expectedType, value) } else if (typeIsObject && valueIsObject) { Object.keys(expectedType).forEach((field) => { assertMessageProp(value, postMessageType, field, expectedType[field]) }) } }

8debaa49041fffba960b6052b906718c2db42bf8

ts

TypeScript

src/lib/markdown.ts

Lantern-chat/frontend

9bf63a15e45329a46415e954efdb263860a22a67

2022-01-26T20:07:24.000Z

2022-03-23T06:10:08.000Z

src/lib/markdown.ts

Lantern-chat/frontend

9bf63a15e45329a46415e954efdb263860a22a67

2022-01-26T19:27:06.000Z

2022-02-23T15:53:11.000Z

src/lib/markdown.ts

Lantern-chat/frontend

9bf63a15e45329a46415e954efdb263860a22a67

interface FreeState { // consecutive_spoiler cs: number, // consecutive_code cc: number, // flags f: number, // position p: number, // prefixes that make it not free r: string[], } const INSIDE_CODE_BLOCK: number = 1 << 0; const INSIDE_SPOILER: number = 1 << 1; const INSIDE_INLINE_CODE: number = 1 << 2; const INSIDE_ANY_CODE: number = INSIDE_CODE_BLOCK | INSIDE_INLINE_CODE; const INSIDE_EMOTE: number = 1 << 3; const ESCAPED: number = 1 << 4; const DEFAULT_FREE_FLAGS: number = INSIDE_INLINE_CODE | INSIDE_SPOILER | INSIDE_INLINE_CODE; const DEFAULT_PREFIXES: string[] = ['<', '\\', ':']; export function create(prefixes: string[] = DEFAULT_PREFIXES): FreeState { return { cs: 0, cc: 0, f: 0, p: 0, r: prefixes }; } const VALID_EMOTE_CHAR: RegExp = /[\w\-]/; export function incr(self: FreeState, input: string, new_position: number) { let c, i, { f, cc, cs, p } = self; input = input.slice(p, new_position); for(i = 0; i < input.length; i += 1) { if(f & ESCAPED) { f &= ~ESCAPED; continue; } c = input[i]; if(c == '\\') { f |= ESCAPED; continue; } if(c == '`') { cc++; } else { // if this character is not part of a code token, // but there were two consecitive code tokens, // then it was probably a zero-length inline code span if(cc == 2 && !(f & INSIDE_CODE_BLOCK)) { f ^= INSIDE_INLINE_CODE; } cc = 0; } if(c == '|') { cs++; } else { cs = 0; } if(cc == 3) { // toggle code block flag f ^= INSIDE_CODE_BLOCK; // remove inline code flag f &= ~INSIDE_INLINE_CODE; } else { if(!(f & INSIDE_CODE_BLOCK)) { // if does not contain code block flag if(cc == 1) { f ^= INSIDE_INLINE_CODE; } if(cs == 2) { f ^= INSIDE_SPOILER; } } // if not in any code if(!(f & INSIDE_ANY_CODE)) { if(c == ':') { f ^= INSIDE_EMOTE; } else if(!VALID_EMOTE_CHAR.test(c)) { f &= ~INSIDE_EMOTE; } } } } self.p = new_position; self.f = f; self.cc = cc; self.cs = cs; } export function is_free(self: FreeState, input: string, new_position: number, flags: number = DEFAULT_FREE_FLAGS): boolean { // start of the string is trivially free if(new_position == 0) return true; // if the position is prefixed by escaped if(self.r.includes(input[new_position - 1])) return false; incr(self, input, new_position); // if the flags intersect if((self.f & flags) != 0) return false; return true; } export function is_free_simple(input: string, position: number, prefixes: string[] = DEFAULT_PREFIXES, flags: number = DEFAULT_FREE_FLAGS): boolean { return is_free(create(prefixes), input, position, flags); } export function is_inside_code(input: string, position: number): boolean { if(position == 0) return false; let f = create([]); incr(f, input, position); return !!(f.f & (INSIDE_INLINE_CODE | INSIDE_CODE_BLOCK)); } export function is_inside_spoiler(input: string, position: number): boolean { if(position == 0) return false; let f = create([]); incr(f, input, position); return !!(f.f & INSIDE_SPOILER); } export function emote_start(input: string, position: number): number { let start = position; while(start > 0 && input[start] != ':') { start--; } let is_valid = /^:[\w\-]*$/.test(input.slice(start, position)) && input.slice(0, position).match(/:/g)!.length % 2 == 1; return is_valid ? start : -1; }

interface FreeState { // consecutive_spoiler cs, // consecutive_code cc, // flags f, // position p, // prefixes that make it not free r, } const INSIDE_CODE_BLOCK = 1 << 0; const INSIDE_SPOILER = 1 << 1; const INSIDE_INLINE_CODE = 1 << 2; const INSIDE_ANY_CODE = INSIDE_CODE_BLOCK | INSIDE_INLINE_CODE; const INSIDE_EMOTE = 1 << 3; const ESCAPED = 1 << 4; const DEFAULT_FREE_FLAGS = INSIDE_INLINE_CODE | INSIDE_SPOILER | INSIDE_INLINE_CODE; const DEFAULT_PREFIXES = ['<', '\\', ':']; export /* Example usages of 'create' are shown below: is_free(create(prefixes), input, position, flags); create([]); */ function create(prefixes = DEFAULT_PREFIXES) { return { cs: 0, cc: 0, f: 0, p: 0, r: prefixes }; } const VALID_EMOTE_CHAR = /[\w\-]/; export /* Example usages of 'incr' are shown below: incr(self, input, new_position); incr(f, input, position); */ function incr(self, input, new_position) { let c, i, { f, cc, cs, p } = self; input = input.slice(p, new_position); for(i = 0; i < input.length; i += 1) { if(f & ESCAPED) { f &= ~ESCAPED; continue; } c = input[i]; if(c == '\\') { f |= ESCAPED; continue; } if(c == '`') { cc++; } else { // if this character is not part of a code token, // but there were two consecitive code tokens, // then it was probably a zero-length inline code span if(cc == 2 && !(f & INSIDE_CODE_BLOCK)) { f ^= INSIDE_INLINE_CODE; } cc = 0; } if(c == '|') { cs++; } else { cs = 0; } if(cc == 3) { // toggle code block flag f ^= INSIDE_CODE_BLOCK; // remove inline code flag f &= ~INSIDE_INLINE_CODE; } else { if(!(f & INSIDE_CODE_BLOCK)) { // if does not contain code block flag if(cc == 1) { f ^= INSIDE_INLINE_CODE; } if(cs == 2) { f ^= INSIDE_SPOILER; } } // if not in any code if(!(f & INSIDE_ANY_CODE)) { if(c == ':') { f ^= INSIDE_EMOTE; } else if(!VALID_EMOTE_CHAR.test(c)) { f &= ~INSIDE_EMOTE; } } } } self.p = new_position; self.f = f; self.cc = cc; self.cs = cs; } export /* Example usages of 'is_free' are shown below: is_free(create(prefixes), input, position, flags); */ function is_free(self, input, new_position, flags = DEFAULT_FREE_FLAGS) { // start of the string is trivially free if(new_position == 0) return true; // if the position is prefixed by escaped if(self.r.includes(input[new_position - 1])) return false; incr(self, input, new_position); // if the flags intersect if((self.f & flags) != 0) return false; return true; } export function is_free_simple(input, position, prefixes = DEFAULT_PREFIXES, flags = DEFAULT_FREE_FLAGS) { return is_free(create(prefixes), input, position, flags); } export function is_inside_code(input, position) { if(position == 0) return false; let f = create([]); incr(f, input, position); return !!(f.f & (INSIDE_INLINE_CODE | INSIDE_CODE_BLOCK)); } export function is_inside_spoiler(input, position) { if(position == 0) return false; let f = create([]); incr(f, input, position); return !!(f.f & INSIDE_SPOILER); } export function emote_start(input, position) { let start = position; while(start > 0 && input[start] != ':') { start--; } let is_valid = /^:[\w\-]*$/.test(input.slice(start, position)) && input.slice(0, position).match(/:/g)!.length % 2 == 1; return is_valid ? start : -1; }

9a7c699fe8f449d3a7a939d3dca5b7e6442a9fd0

ts

TypeScript

Web Site/React/src/scripts/aes.ts

mr-bwnz/SplendidAppBuilder

79ec92d4cb805ccf408ff95103a1a0a78bc765b7

2022-03-01T10:27:25.000Z

2022-03-01T10:27:25.000Z

Web Site/React/src/scripts/aes.ts

mr-bwnz/SplendidAppBuilder

79ec92d4cb805ccf408ff95103a1a0a78bc765b7

Web Site/React/src/scripts/aes.ts

mr-bwnz/SplendidAppBuilder

79ec92d4cb805ccf408ff95103a1a0a78bc765b7

2022-02-21T13:28:37.000Z

2022-03-18T06:42:07.000Z

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* AES implementation in JavaScript (c) Chris Veness 2005-2011 */ /* http://www.movable-type.co.uk/scripts/aes.html */ /* http://www.movable-type.co.uk/scripts/aes.js */ /* - see http://csrc.nist.gov/publications/PubsFIPS.html#197 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ export default class Aes { /** * AES Cipher function: encrypt 'input' state with Rijndael algorithm * applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage * * @param {Number[]} input 16-byte (128-bit) input state array * @param {Number[][]} w Key schedule as 2D byte-array (Nr+1 x Nb bytes) * @returns {Number[]} Encrypted output state array */ static cipher( input, w ) { // main Cipher function [§5.1] var Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES) var Nr = w.length / Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys var state = [[], [], [], []]; // initialise 4xNb byte-array 'state' with input [§3.4] for ( var i = 0; i < 4 * Nb; i++ ) state[i % 4][Math.floor( i / 4 )] = input[i]; state = Aes.addRoundKey( state, w, 0, Nb ); for ( var round = 1; round < Nr; round++ ) { state = Aes.subBytes( state, Nb ); state = Aes.shiftRows( state, Nb ); state = Aes.mixColumns( state, Nb ); state = Aes.addRoundKey( state, w, round, Nb ); } state = Aes.subBytes( state, Nb ); state = Aes.shiftRows( state, Nb ); state = Aes.addRoundKey( state, w, Nr, Nb ); var output = new Array( 4 * Nb ); // convert state to 1-d array before returning [§3.4] for ( var i = 0; i < 4 * Nb; i++ ) output[i] = state[i % 4][Math.floor( i / 4 )]; return output; } /** * Perform Key Expansion to generate a Key Schedule * * @param {Number[]} key Key as 16/24/32-byte array * @returns {Number[][]} Expanded key schedule as 2D byte-array (Nr+1 x Nb bytes) */ static keyExpansion( key ) { // generate Key Schedule (byte-array Nr+1 x Nb) from Key [§5.2] var Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES) var Nk = key.length / 4 // key length (in words): 4/6/8 for 128/192/256-bit keys var Nr = Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys var w = new Array( Nb * ( Nr + 1 ) ); var temp = new Array( 4 ); for ( var i = 0; i < Nk; i++ ) { var r = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]]; w[i] = r; } for ( var i = Nk; i < ( Nb * ( Nr + 1 ) ); i++ ) { w[i] = new Array( 4 ); for ( var t = 0; t < 4; t++ ) temp[t] = w[i - 1][t]; if ( i % Nk == 0 ) { temp = Aes.subWord( Aes.rotWord( temp ) ); for ( var t = 0; t < 4; t++ ) temp[t] ^= Aes.rCon[i / Nk][t]; } else if ( Nk > 6 && i % Nk == 4 ) { temp = Aes.subWord( temp ); } for ( var t = 0; t < 4; t++ ) w[i][t] = w[i - Nk][t] ^ temp[t]; } return w; } /* * ---- remaining routines are private, not called externally ---- */ static subBytes( s, Nb ) { // apply SBox to state S [§5.1.1] for ( var r = 0; r < 4; r++ ) { for ( var c = 0; c < Nb; c++ ) s[r][c] = Aes.sBox[s[r][c]]; } return s; } static shiftRows( s, Nb ) { // shift row r of state S left by r bytes [§5.1.2] var t = new Array( 4 ); for ( var r = 1; r < 4; r++ ) { for ( var c = 0; c < 4; c++ ) t[c] = s[r][( c + r ) % Nb]; // shift into temp copy for ( var c = 0; c < 4; c++ ) s[r][c] = t[c]; // and copy back } // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES): return s; // see asmaes.sourceforge.net/rijndael/rijndaelImplementation.pdf } static mixColumns( s, Nb ) { // combine bytes of each col of state S [§5.1.3] for ( var c = 0; c < 4; c++ ) { var a = new Array( 4 ); // 'a' is a copy of the current column from 's' var b = new Array( 4 ); // 'b' is a•{02} in GF(2^8) for ( var i = 0; i < 4; i++ ) { a[i] = s[i][c]; b[i] = s[i][c] & 0x80 ? s[i][c] << 1 ^ 0x011b : s[i][c] << 1; } // a[n] ^ b[n] is a•{03} in GF(2^8) s[0][c] = b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]; // 2*a0 + 3*a1 + a2 + a3 s[1][c] = a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]; // a0 * 2*a1 + 3*a2 + a3 s[2][c] = a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]; // a0 + a1 + 2*a2 + 3*a3 s[3][c] = a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]; // 3*a0 + a1 + a2 + 2*a3 } return s; } static addRoundKey( state, w, rnd, Nb ) { // xor Round Key into state S [§5.1.4] for ( var r = 0; r < 4; r++ ) { for ( var c = 0; c < Nb; c++ ) state[r][c] ^= w[rnd * 4 + c][r]; } return state; } static subWord( w ) { // apply SBox to 4-byte word w for ( var i = 0; i < 4; i++ ) w[i] = Aes.sBox[w[i]]; return w; } static rotWord( w ) { // rotate 4-byte word w left by one byte var tmp = w[0]; for ( var i = 0; i < 3; i++ ) w[i] = w[i + 1]; w[3] = tmp; return w; } // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1] static sBox = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]; // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2] static rCon = [[0x00, 0x00, 0x00, 0x00], [0x01, 0x00, 0x00, 0x00], [0x02, 0x00, 0x00, 0x00], [0x04, 0x00, 0x00, 0x00], [0x08, 0x00, 0x00, 0x00], [0x10, 0x00, 0x00, 0x00], [0x20, 0x00, 0x00, 0x00], [0x40, 0x00, 0x00, 0x00], [0x80, 0x00, 0x00, 0x00], [0x1b, 0x00, 0x00, 0x00], [0x36, 0x00, 0x00, 0x00]]; /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Utf8 class: encode / decode between multi-byte Unicode characters and UTF-8 multiple */ /* http://www.movable-type.co.uk/scripts/utf8.js */ /* single-byte character encoding (c) Chris Veness 2002-2011 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* changelog * 2010-09-29: fixed decode order of operation to avoid falsely recognising decoded string as 3-byte * utf-8 charaacter */ static Ctr = class // Aes.Ctr namespace: a subclass or extension of Aes { /** * Encrypt a text using AES encryption in Counter mode of operation * * Unicode multi-byte character safe * * @param {String} plaintext Source text to be encrypted * @param {String} password The password to use to generate a key * @param {Number} nBits Number of bits to be used in the key (128, 192, or 256) * @returns {string} Encrypted text */ static encrypt( plaintext, password, nBits ) { var blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES if ( !( nBits == 128 || nBits == 192 || nBits == 256 ) ) return ''; // standard allows 128/192/256 bit keys plaintext = Utf8.encode( plaintext ); password = Utf8.encode( password ); //var t = new Date(); // timer // use AES itself to encrypt password to get cipher key (using plain password as source for key // expansion) - gives us well encrypted key (though hashed key might be preferred for prod'n use) var nBytes = nBits / 8; // no bytes in key (16/24/32) var pwBytes = new Array( nBytes ); for ( var i = 0; i < nBytes; i++ ) { // use 1st 16/24/32 chars of password for key pwBytes[i] = isNaN( password.charCodeAt( i ) ) ? 0 : password.charCodeAt( i ); } var key = Aes.cipher( pwBytes, Aes.keyExpansion( pwBytes ) ); // gives us 16-byte key key = key.concat( key.slice( 0, nBytes - 16 ) ); // expand key to 16/24/32 bytes long // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec, // [2-3] = random, [4-7] = seconds, together giving full sub-millisec uniqueness up to Feb 2106 var counterBlock = new Array( blockSize ); var nonce = ( new Date() ).getTime(); // timestamp: milliseconds since 1-Jan-1970 var nonceMs = nonce % 1000; var nonceSec = Math.floor( nonce / 1000 ); var nonceRnd = Math.floor( Math.random() * 0xffff ); for ( var i = 0; i < 2; i++ ) counterBlock[i] = ( nonceMs >>> i * 8 ) & 0xff; for ( var i = 0; i < 2; i++ ) counterBlock[i + 2] = ( nonceRnd >>> i * 8 ) & 0xff; for ( var i = 0; i < 4; i++ ) counterBlock[i + 4] = ( nonceSec >>> i * 8 ) & 0xff; // and convert it to a string to go on the front of the ciphertext var ctrTxt = ''; for ( var i = 0; i < 8; i++ ) ctrTxt += String.fromCharCode( counterBlock[i] ); // generate key schedule - an expansion of the key into distinct Key Rounds for each round var keySchedule = Aes.keyExpansion( key ); var blockCount = Math.ceil( plaintext.length / blockSize ); var ciphertxt = new Array( blockCount ); // ciphertext as array of strings for ( var b = 0; b < blockCount; b++ ) { // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes) // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB) for ( var c = 0; c < 4; c++ ) counterBlock[15 - c] = ( b >>> c * 8 ) & 0xff; for ( var c = 0; c < 4; c++ ) counterBlock[15 - c - 4] = ( b / 0x100000000 >>> c * 8 ) var cipherCntr = Aes.cipher( counterBlock, keySchedule ); // -- encrypt counter block -- // block size is reduced on final block var blockLength = b < blockCount - 1 ? blockSize : ( plaintext.length - 1 ) % blockSize + 1; var cipherChar = new Array( blockLength ); for ( var i = 0; i < blockLength; i++ ) { // -- xor plaintext with ciphered counter char-by-char -- cipherChar[i] = cipherCntr[i] ^ plaintext.charCodeAt( b * blockSize + i ); cipherChar[i] = String.fromCharCode( cipherChar[i] ); } ciphertxt[b] = cipherChar.join( '' ); } // Array.join is more efficient than repeated string concatenation in IE var ciphertext = ctrTxt + ciphertxt.join( '' ); ciphertext = Base64.encode( ciphertext ); // encode in base64 //alert((new Date()) - t); return ciphertext; } /** * Decrypt a text encrypted by AES in counter mode of operation * * @param {String} ciphertext Source text to be encrypted * @param {String} password The password to use to generate a key * @param {Number} nBits Number of bits to be used in the key (128, 192, or 256) * @returns {String} Decrypted text */ static decrypt = function ( ciphertext, password, nBits ) { var blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES if ( !( nBits == 128 || nBits == 192 || nBits == 256 ) ) return ''; // standard allows 128/192/256 bit keys ciphertext = Base64.decode( ciphertext ); password = Utf8.encode( password ); //var t = new Date(); // timer // use AES to encrypt password (mirroring encrypt routine) var nBytes = nBits / 8; // no bytes in key var pwBytes = new Array( nBytes ); for ( var i = 0; i < nBytes; i++ ) { pwBytes[i] = isNaN( password.charCodeAt( i ) ) ? 0 : password.charCodeAt( i ); } var key = Aes.cipher( pwBytes, Aes.keyExpansion( pwBytes ) ); key = key.concat( key.slice( 0, nBytes - 16 ) ); // expand key to 16/24/32 bytes long // recover nonce from 1st 8 bytes of ciphertext var counterBlock = new Array( 8 ); var ctrTxt = ciphertext.slice( 0, 8 ); for ( var i = 0; i < 8; i++ ) counterBlock[i] = ctrTxt.charCodeAt( i ); // generate key schedule var keySchedule = Aes.keyExpansion( key ); // separate ciphertext into blocks (skipping past initial 8 bytes) var nBlocks = Math.ceil( ( ciphertext.length - 8 ) / blockSize ); var ct = new Array( nBlocks ); for ( var b = 0; b < nBlocks; b++ ) ct[b] = ciphertext.slice( 8 + b * blockSize, 8 + b * blockSize + blockSize ); ciphertext = ct; // ciphertext is now array of block-length strings // plaintext will get generated block-by-block into array of block-length strings var plaintxt = new Array( ciphertext.length ); for ( var b = 0; b < nBlocks; b++ ) { // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes) for ( var c = 0; c < 4; c++ ) counterBlock[15 - c] = ( ( b ) >>> c * 8 ) & 0xff; for ( var c = 0; c < 4; c++ ) counterBlock[15 - c - 4] = ( ( ( b + 1 ) / 0x100000000 - 1 ) >>> c * 8 ) & 0xff; var cipherCntr = Aes.cipher( counterBlock, keySchedule ); // encrypt counter block var plaintxtByte = new Array( ciphertext[b].length ); for ( var i = 0; i < ciphertext[b].length; i++ ) { // -- xor plaintxt with ciphered counter byte-by-byte -- plaintxtByte[i] = cipherCntr[i] ^ ciphertext[b].charCodeAt( i ); plaintxtByte[i] = String.fromCharCode( plaintxtByte[i] ); } plaintxt[b] = plaintxtByte.join( '' ); } // join array of blocks into single plaintext string var plaintext = plaintxt.join( '' ); plaintext = Utf8.decode( plaintext ); // decode from UTF8 back to Unicode multi-byte chars //alert((new Date()) - t); return plaintext; } } } class Utf8 { /** * Encode multi-byte Unicode string into utf-8 multiple single-byte characters * (BMP / basic multilingual plane only) * * Chars in range U+0080 - U+07FF are encoded in 2 chars, U+0800 - U+FFFF in 3 chars * * @param {String} strUni Unicode string to be encoded as UTF-8 * @returns {String} encoded string */ static encode( strUni ) { // use regular expressions & String.replace callback function for better efficiency // than procedural approaches var strUtf = strUni.replace( /[\u0080-\u07ff]/g, // U+0080 - U+07FF => 2 bytes 110yyyyy, 10zzzzzz function ( c ) { var cc = c.charCodeAt( 0 ); return String.fromCharCode( 0xc0 | cc >> 6, 0x80 | cc & 0x3f ); } ); strUtf = strUtf.replace( /[\u0800-\uffff]/g, // U+0800 - U+FFFF => 3 bytes 1110xxxx, 10yyyyyy, 10zzzzzz function ( c ) { var cc = c.charCodeAt( 0 ); return String.fromCharCode( 0xe0 | cc >> 12, 0x80 | cc >> 6 & 0x3F, 0x80 | cc & 0x3f ); } ); return strUtf; } /** * Decode utf-8 encoded string back into multi-byte Unicode characters * * @param {String} strUtf UTF-8 string to be decoded back to Unicode * @returns {String} decoded string */ static decode( strUtf ) { // note: decode 3-byte chars first as decoded 2-byte strings could appear to be 3-byte char! var strUni = strUtf.replace( /[\u00e0-\u00ef][\u0080-\u00bf][\u0080-\u00bf]/g, // 3-byte chars function ( c ) { // (note parentheses for precence) var cc = ( ( c.charCodeAt( 0 ) & 0x0f ) << 12 ) | ( ( c.charCodeAt( 1 ) & 0x3f ) << 6 ) | ( c.charCodeAt( 2 ) & 0x3f ); return String.fromCharCode( cc ); } ); strUni = strUni.replace( /[\u00c0-\u00df][\u0080-\u00bf]/g, // 2-byte chars function ( c ) { // (note parentheses for precence) var cc = ( c.charCodeAt( 0 ) & 0x1f ) << 6 | c.charCodeAt( 1 ) & 0x3f; return String.fromCharCode( cc ); } ); return strUni; } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Base64 class: Base 64 encoding / decoding (c) Chris Veness 2002-2011 */ /* http://www.movable-type.co.uk/scripts/base64.js */ /* note: depends on Utf8 class */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ } class Base64 { static code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; /** * Encode string into Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] * (instance method extending String object). As per RFC 4648, no newlines are added. * * @param {String} str The string to be encoded as base-64 * @param {Boolean} [utf8encode=false] Flag to indicate whether str is Unicode string to be encoded * to UTF8 before conversion to base64; otherwise string is assumed to be 8-bit characters * @returns {String} Base64-encoded string */ static encode( str, utf8encode?) { // http://tools.ietf.org/html/rfc4648 utf8encode = ( typeof utf8encode == 'undefined' ) ? false : utf8encode; var o1, o2, o3, bits, h1, h2, h3, h4, e = [], pad = '', c, plain, coded; var b64 = Base64.code; plain = utf8encode ? Utf8.encode( str ) : str; c = plain.length % 3; // pad string to length of multiple of 3 if ( c > 0 ) { while ( c++ < 3 ) { pad += '='; plain += '\0'; } } // note: doing padding here saves us doing special-case packing for trailing 1 or 2 chars for ( c = 0; c < plain.length; c += 3 ) { // pack three octets into four hexets o1 = plain.charCodeAt( c ); o2 = plain.charCodeAt( c + 1 ); o3 = plain.charCodeAt( c + 2 ); bits = o1 << 16 | o2 << 8 | o3; h1 = bits >> 18 & 0x3f; h2 = bits >> 12 & 0x3f; h3 = bits >> 6 & 0x3f; h4 = bits & 0x3f; // use hextets to index into code string e[c / 3] = b64.charAt( h1 ) + b64.charAt( h2 ) + b64.charAt( h3 ) + b64.charAt( h4 ); } coded = e.join( '' ); // join() is far faster than repeated string concatenation in IE // replace 'A's from padded nulls with '='s coded = coded.slice( 0, coded.length - pad.length ) + pad; return coded; } /** * Decode string from Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] * (instance method extending String object). As per RFC 4648, newlines are not catered for. * * @param {String} str The string to be decoded from base-64 * @param {Boolean} [utf8decode=false] Flag to indicate whether str is Unicode string to be decoded * from UTF8 after conversion from base64 * @returns {String} decoded string */ static decode( str, utf8decode?) { utf8decode = ( typeof utf8decode == 'undefined' ) ? false : utf8decode; var o1, o2, o3, h1, h2, h3, h4, bits, d = [], plain, coded; var b64 = Base64.code; coded = utf8decode ? Utf8.decode( str ) : str; for ( var c = 0; c < coded.length; c += 4 ) { // unpack four hexets into three octets h1 = b64.indexOf( coded.charAt( c ) ); h2 = b64.indexOf( coded.charAt( c + 1 ) ); h3 = b64.indexOf( coded.charAt( c + 2 ) ); h4 = b64.indexOf( coded.charAt( c + 3 ) ); bits = h1 << 18 | h2 << 12 | h3 << 6 | h4; o1 = bits >>> 16 & 0xff; o2 = bits >>> 8 & 0xff; o3 = bits & 0xff; d[c / 4] = String.fromCharCode( o1, o2, o3 ); // check for padding if ( h4 == 0x40 ) d[c / 4] = String.fromCharCode( o1, o2 ); if ( h3 == 0x40 ) d[c / 4] = String.fromCharCode( o1 ); } plain = d.join( '' ); // join() is far faster than repeated string concatenation in IE return utf8decode ? Utf8.decode( plain ) : plain; } } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* AES Counter-mode implementation in JavaScript (c) Chris Veness 2005-2011 */ /* http://www.movable-type.co.uk/scripts/aes-ctr.js */ /* - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* AES implementation in JavaScript (c) Chris Veness 2005-2011 */ /* http://www.movable-type.co.uk/scripts/aes.html */ /* http://www.movable-type.co.uk/scripts/aes.js */ /* - see http://csrc.nist.gov/publications/PubsFIPS.html#197 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ export default class Aes { /** * AES Cipher function: encrypt 'input' state with Rijndael algorithm * applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage * * @param {Number[]} input 16-byte (128-bit) input state array * @param {Number[][]} w Key schedule as 2D byte-array (Nr+1 x Nb bytes) * @returns {Number[]} Encrypted output state array */ static cipher( input, w ) { // main Cipher function [§5.1] var Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES) var Nr = w.length / Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys var state = [[], [], [], []]; // initialise 4xNb byte-array 'state' with input [§3.4] for ( var i = 0; i < 4 * Nb; i++ ) state[i % 4][Math.floor( i / 4 )] = input[i]; state = Aes.addRoundKey( state, w, 0, Nb ); for ( var round = 1; round < Nr; round++ ) { state = Aes.subBytes( state, Nb ); state = Aes.shiftRows( state, Nb ); state = Aes.mixColumns( state, Nb ); state = Aes.addRoundKey( state, w, round, Nb ); } state = Aes.subBytes( state, Nb ); state = Aes.shiftRows( state, Nb ); state = Aes.addRoundKey( state, w, Nr, Nb ); var output = new Array( 4 * Nb ); // convert state to 1-d array before returning [§3.4] for ( var i = 0; i < 4 * Nb; i++ ) output[i] = state[i % 4][Math.floor( i / 4 )]; return output; } /** * Perform Key Expansion to generate a Key Schedule * * @param {Number[]} key Key as 16/24/32-byte array * @returns {Number[][]} Expanded key schedule as 2D byte-array (Nr+1 x Nb bytes) */ static keyExpansion( key ) { // generate Key Schedule (byte-array Nr+1 x Nb) from Key [§5.2] var Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES) var Nk = key.length / 4 // key length (in words): 4/6/8 for 128/192/256-bit keys var Nr = Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys var w = new Array( Nb * ( Nr + 1 ) ); var temp = new Array( 4 ); for ( var i = 0; i < Nk; i++ ) { var r = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]]; w[i] = r; } for ( var i = Nk; i < ( Nb * ( Nr + 1 ) ); i++ ) { w[i] = new Array( 4 ); for ( var t = 0; t < 4; t++ ) temp[t] = w[i - 1][t]; if ( i % Nk == 0 ) { temp = Aes.subWord( Aes.rotWord( temp ) ); for ( var t = 0; t < 4; t++ ) temp[t] ^= Aes.rCon[i / Nk][t]; } else if ( Nk > 6 && i % Nk == 4 ) { temp = Aes.subWord( temp ); } for ( var t = 0; t < 4; t++ ) w[i][t] = w[i - Nk][t] ^ temp[t]; } return w; } /* * ---- remaining routines are private, not called externally ---- */ static subBytes( s, Nb ) { // apply SBox to state S [§5.1.1] for ( var r = 0; r < 4; r++ ) { for ( var c = 0; c < Nb; c++ ) s[r][c] = Aes.sBox[s[r][c]]; } return s; } static shiftRows( s, Nb ) { // shift row r of state S left by r bytes [§5.1.2] var t = new Array( 4 ); for ( var r = 1; r < 4; r++ ) { for ( var c = 0; c < 4; c++ ) t[c] = s[r][( c + r ) % Nb]; // shift into temp copy for ( var c = 0; c < 4; c++ ) s[r][c] = t[c]; // and copy back } // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES): return s; // see asmaes.sourceforge.net/rijndael/rijndaelImplementation.pdf } static mixColumns( s, Nb ) { // combine bytes of each col of state S [§5.1.3] for ( var c = 0; c < 4; c++ ) { var a = new Array( 4 ); // 'a' is a copy of the current column from 's' var b = new Array( 4 ); // 'b' is a•{02} in GF(2^8) for ( var i = 0; i < 4; i++ ) { a[i] = s[i][c]; b[i] = s[i][c] & 0x80 ? s[i][c] << 1 ^ 0x011b : s[i][c] << 1; } // a[n] ^ b[n] is a•{03} in GF(2^8) s[0][c] = b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]; // 2*a0 + 3*a1 + a2 + a3 s[1][c] = a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]; // a0 * 2*a1 + 3*a2 + a3 s[2][c] = a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]; // a0 + a1 + 2*a2 + 3*a3 s[3][c] = a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]; // 3*a0 + a1 + a2 + 2*a3 } return s; } static addRoundKey( state, w, rnd, Nb ) { // xor Round Key into state S [§5.1.4] for ( var r = 0; r < 4; r++ ) { for ( var c = 0; c < Nb; c++ ) state[r][c] ^= w[rnd * 4 + c][r]; } return state; } static subWord( w ) { // apply SBox to 4-byte word w for ( var i = 0; i < 4; i++ ) w[i] = Aes.sBox[w[i]]; return w; } static rotWord( w ) { // rotate 4-byte word w left by one byte var tmp = w[0]; for ( var i = 0; i < 3; i++ ) w[i] = w[i + 1]; w[3] = tmp; return w; } // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1] static sBox = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]; // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2] static rCon = [[0x00, 0x00, 0x00, 0x00], [0x01, 0x00, 0x00, 0x00], [0x02, 0x00, 0x00, 0x00], [0x04, 0x00, 0x00, 0x00], [0x08, 0x00, 0x00, 0x00], [0x10, 0x00, 0x00, 0x00], [0x20, 0x00, 0x00, 0x00], [0x40, 0x00, 0x00, 0x00], [0x80, 0x00, 0x00, 0x00], [0x1b, 0x00, 0x00, 0x00], [0x36, 0x00, 0x00, 0x00]]; /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Utf8 class: encode / decode between multi-byte Unicode characters and UTF-8 multiple */ /* http://www.movable-type.co.uk/scripts/utf8.js */ /* single-byte character encoding (c) Chris Veness 2002-2011 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* changelog * 2010-09-29: fixed decode order of operation to avoid falsely recognising decoded string as 3-byte * utf-8 charaacter */ static Ctr = class // Aes.Ctr namespace: a subclass or extension of Aes { /** * Encrypt a text using AES encryption in Counter mode of operation * * Unicode multi-byte character safe * * @param {String} plaintext Source text to be encrypted * @param {String} password The password to use to generate a key * @param {Number} nBits Number of bits to be used in the key (128, 192, or 256) * @returns {string} Encrypted text */ static encrypt( plaintext, password, nBits ) { var blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES if ( !( nBits == 128 || nBits == 192 || nBits == 256 ) ) return ''; // standard allows 128/192/256 bit keys plaintext = Utf8.encode( plaintext ); password = Utf8.encode( password ); //var t = new Date(); // timer // use AES itself to encrypt password to get cipher key (using plain password as source for key // expansion) - gives us well encrypted key (though hashed key might be preferred for prod'n use) var nBytes = nBits / 8; // no bytes in key (16/24/32) var pwBytes = new Array( nBytes ); for ( var i = 0; i < nBytes; i++ ) { // use 1st 16/24/32 chars of password for key pwBytes[i] = isNaN( password.charCodeAt( i ) ) ? 0 : password.charCodeAt( i ); } var key = Aes.cipher( pwBytes, Aes.keyExpansion( pwBytes ) ); // gives us 16-byte key key = key.concat( key.slice( 0, nBytes - 16 ) ); // expand key to 16/24/32 bytes long // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec, // [2-3] = random, [4-7] = seconds, together giving full sub-millisec uniqueness up to Feb 2106 var counterBlock = new Array( blockSize ); var nonce = ( new Date() ).getTime(); // timestamp: milliseconds since 1-Jan-1970 var nonceMs = nonce % 1000; var nonceSec = Math.floor( nonce / 1000 ); var nonceRnd = Math.floor( Math.random() * 0xffff ); for ( var i = 0; i < 2; i++ ) counterBlock[i] = ( nonceMs >>> i * 8 ) & 0xff; for ( var i = 0; i < 2; i++ ) counterBlock[i + 2] = ( nonceRnd >>> i * 8 ) & 0xff; for ( var i = 0; i < 4; i++ ) counterBlock[i + 4] = ( nonceSec >>> i * 8 ) & 0xff; // and convert it to a string to go on the front of the ciphertext var ctrTxt = ''; for ( var i = 0; i < 8; i++ ) ctrTxt += String.fromCharCode( counterBlock[i] ); // generate key schedule - an expansion of the key into distinct Key Rounds for each round var keySchedule = Aes.keyExpansion( key ); var blockCount = Math.ceil( plaintext.length / blockSize ); var ciphertxt = new Array( blockCount ); // ciphertext as array of strings for ( var b = 0; b < blockCount; b++ ) { // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes) // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB) for ( var c = 0; c < 4; c++ ) counterBlock[15 - c] = ( b >>> c * 8 ) & 0xff; for ( var c = 0; c < 4; c++ ) counterBlock[15 - c - 4] = ( b / 0x100000000 >>> c * 8 ) var cipherCntr = Aes.cipher( counterBlock, keySchedule ); // -- encrypt counter block -- // block size is reduced on final block var blockLength = b < blockCount - 1 ? blockSize : ( plaintext.length - 1 ) % blockSize + 1; var cipherChar = new Array( blockLength ); for ( var i = 0; i < blockLength; i++ ) { // -- xor plaintext with ciphered counter char-by-char -- cipherChar[i] = cipherCntr[i] ^ plaintext.charCodeAt( b * blockSize + i ); cipherChar[i] = String.fromCharCode( cipherChar[i] ); } ciphertxt[b] = cipherChar.join( '' ); } // Array.join is more efficient than repeated string concatenation in IE var ciphertext = ctrTxt + ciphertxt.join( '' ); ciphertext = Base64.encode( ciphertext ); // encode in base64 //alert((new Date()) - t); return ciphertext; } /** * Decrypt a text encrypted by AES in counter mode of operation * * @param {String} ciphertext Source text to be encrypted * @param {String} password The password to use to generate a key * @param {Number} nBits Number of bits to be used in the key (128, 192, or 256) * @returns {String} Decrypted text */ static decrypt = function ( ciphertext, password, nBits ) { var blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES if ( !( nBits == 128 || nBits == 192 || nBits == 256 ) ) return ''; // standard allows 128/192/256 bit keys ciphertext = Base64.decode( ciphertext ); password = Utf8.encode( password ); //var t = new Date(); // timer // use AES to encrypt password (mirroring encrypt routine) var nBytes = nBits / 8; // no bytes in key var pwBytes = new Array( nBytes ); for ( var i = 0; i < nBytes; i++ ) { pwBytes[i] = isNaN( password.charCodeAt( i ) ) ? 0 : password.charCodeAt( i ); } var key = Aes.cipher( pwBytes, Aes.keyExpansion( pwBytes ) ); key = key.concat( key.slice( 0, nBytes - 16 ) ); // expand key to 16/24/32 bytes long // recover nonce from 1st 8 bytes of ciphertext var counterBlock = new Array( 8 ); var ctrTxt = ciphertext.slice( 0, 8 ); for ( var i = 0; i < 8; i++ ) counterBlock[i] = ctrTxt.charCodeAt( i ); // generate key schedule var keySchedule = Aes.keyExpansion( key ); // separate ciphertext into blocks (skipping past initial 8 bytes) var nBlocks = Math.ceil( ( ciphertext.length - 8 ) / blockSize ); var ct = new Array( nBlocks ); for ( var b = 0; b < nBlocks; b++ ) ct[b] = ciphertext.slice( 8 + b * blockSize, 8 + b * blockSize + blockSize ); ciphertext = ct; // ciphertext is now array of block-length strings // plaintext will get generated block-by-block into array of block-length strings var plaintxt = new Array( ciphertext.length ); for ( var b = 0; b < nBlocks; b++ ) { // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes) for ( var c = 0; c < 4; c++ ) counterBlock[15 - c] = ( ( b ) >>> c * 8 ) & 0xff; for ( var c = 0; c < 4; c++ ) counterBlock[15 - c - 4] = ( ( ( b + 1 ) / 0x100000000 - 1 ) >>> c * 8 ) & 0xff; var cipherCntr = Aes.cipher( counterBlock, keySchedule ); // encrypt counter block var plaintxtByte = new Array( ciphertext[b].length ); for ( var i = 0; i < ciphertext[b].length; i++ ) { // -- xor plaintxt with ciphered counter byte-by-byte -- plaintxtByte[i] = cipherCntr[i] ^ ciphertext[b].charCodeAt( i ); plaintxtByte[i] = String.fromCharCode( plaintxtByte[i] ); } plaintxt[b] = plaintxtByte.join( '' ); } // join array of blocks into single plaintext string var plaintext = plaintxt.join( '' ); plaintext = Utf8.decode( plaintext ); // decode from UTF8 back to Unicode multi-byte chars //alert((new Date()) - t); return plaintext; } } } class Utf8 { /** * Encode multi-byte Unicode string into utf-8 multiple single-byte characters * (BMP / basic multilingual plane only) * * Chars in range U+0080 - U+07FF are encoded in 2 chars, U+0800 - U+FFFF in 3 chars * * @param {String} strUni Unicode string to be encoded as UTF-8 * @returns {String} encoded string */ static encode( strUni ) { // use regular expressions & String.replace callback function for better efficiency // than procedural approaches var strUtf = strUni.replace( /[\u0080-\u07ff]/g, // U+0080 - U+07FF => 2 bytes 110yyyyy, 10zzzzzz function ( c ) { var cc = c.charCodeAt( 0 ); return String.fromCharCode( 0xc0 | cc >> 6, 0x80 | cc & 0x3f ); } ); strUtf = strUtf.replace( /[\u0800-\uffff]/g, // U+0800 - U+FFFF => 3 bytes 1110xxxx, 10yyyyyy, 10zzzzzz function ( c ) { var cc = c.charCodeAt( 0 ); return String.fromCharCode( 0xe0 | cc >> 12, 0x80 | cc >> 6 & 0x3F, 0x80 | cc & 0x3f ); } ); return strUtf; } /** * Decode utf-8 encoded string back into multi-byte Unicode characters * * @param {String} strUtf UTF-8 string to be decoded back to Unicode * @returns {String} decoded string */ static decode( strUtf ) { // note: decode 3-byte chars first as decoded 2-byte strings could appear to be 3-byte char! var strUni = strUtf.replace( /[\u00e0-\u00ef][\u0080-\u00bf][\u0080-\u00bf]/g, // 3-byte chars function ( c ) { // (note parentheses for precence) var cc = ( ( c.charCodeAt( 0 ) & 0x0f ) << 12 ) | ( ( c.charCodeAt( 1 ) & 0x3f ) << 6 ) | ( c.charCodeAt( 2 ) & 0x3f ); return String.fromCharCode( cc ); } ); strUni = strUni.replace( /[\u00c0-\u00df][\u0080-\u00bf]/g, // 2-byte chars function ( c ) { // (note parentheses for precence) var cc = ( c.charCodeAt( 0 ) & 0x1f ) << 6 | c.charCodeAt( 1 ) & 0x3f; return String.fromCharCode( cc ); } ); return strUni; } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Base64 class: Base 64 encoding / decoding (c) Chris Veness 2002-2011 */ /* http://www.movable-type.co.uk/scripts/base64.js */ /* note: depends on Utf8 class */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ } class Base64 { static code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; /** * Encode string into Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] * (instance method extending String object). As per RFC 4648, no newlines are added. * * @param {String} str The string to be encoded as base-64 * @param {Boolean} [utf8encode=false] Flag to indicate whether str is Unicode string to be encoded * to UTF8 before conversion to base64; otherwise string is assumed to be 8-bit characters * @returns {String} Base64-encoded string */ static encode( str, utf8encode?) { // http://tools.ietf.org/html/rfc4648 utf8encode = ( typeof utf8encode == 'undefined' ) ? false : utf8encode; var o1, o2, o3, bits, h1, h2, h3, h4, e = [], pad = '', c, plain, coded; var b64 = Base64.code; plain = utf8encode ? Utf8.encode( str ) : str; c = plain.length % 3; // pad string to length of multiple of 3 if ( c > 0 ) { while ( c++ < 3 ) { pad += '='; plain += '\0'; } } // note: doing padding here saves us doing special-case packing for trailing 1 or 2 chars for ( c = 0; c < plain.length; c += 3 ) { // pack three octets into four hexets o1 = plain.charCodeAt( c ); o2 = plain.charCodeAt( c + 1 ); o3 = plain.charCodeAt( c + 2 ); bits = o1 << 16 | o2 << 8 | o3; h1 = bits >> 18 & 0x3f; h2 = bits >> 12 & 0x3f; h3 = bits >> 6 & 0x3f; h4 = bits & 0x3f; // use hextets to index into code string e[c / 3] = b64.charAt( h1 ) + b64.charAt( h2 ) + b64.charAt( h3 ) + b64.charAt( h4 ); } coded = e.join( '' ); // join() is far faster than repeated string concatenation in IE // replace 'A's from padded nulls with '='s coded = coded.slice( 0, coded.length - pad.length ) + pad; return coded; } /** * Decode string from Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648] * (instance method extending String object). As per RFC 4648, newlines are not catered for. * * @param {String} str The string to be decoded from base-64 * @param {Boolean} [utf8decode=false] Flag to indicate whether str is Unicode string to be decoded * from UTF8 after conversion from base64 * @returns {String} decoded string */ static decode( str, utf8decode?) { utf8decode = ( typeof utf8decode == 'undefined' ) ? false : utf8decode; var o1, o2, o3, h1, h2, h3, h4, bits, d = [], plain, coded; var b64 = Base64.code; coded = utf8decode ? Utf8.decode( str ) : str; for ( var c = 0; c < coded.length; c += 4 ) { // unpack four hexets into three octets h1 = b64.indexOf( coded.charAt( c ) ); h2 = b64.indexOf( coded.charAt( c + 1 ) ); h3 = b64.indexOf( coded.charAt( c + 2 ) ); h4 = b64.indexOf( coded.charAt( c + 3 ) ); bits = h1 << 18 | h2 << 12 | h3 << 6 | h4; o1 = bits >>> 16 & 0xff; o2 = bits >>> 8 & 0xff; o3 = bits & 0xff; d[c / 4] = String.fromCharCode( o1, o2, o3 ); // check for padding if ( h4 == 0x40 ) d[c / 4] = String.fromCharCode( o1, o2 ); if ( h3 == 0x40 ) d[c / 4] = String.fromCharCode( o1 ); } plain = d.join( '' ); // join() is far faster than repeated string concatenation in IE return utf8decode ? Utf8.decode( plain ) : plain; } } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* AES Counter-mode implementation in JavaScript (c) Chris Veness 2005-2011 */ /* http://www.movable-type.co.uk/scripts/aes-ctr.js */ /* - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

9ada6acc954a701a2ece52a2a58ac02cedcaac80

tsx

TypeScript

src/util/index.tsx

rBurgett/poktlint.com

df4e6c973bbde258073ff96531492c99bfe5e036

src/util/index.tsx

rBurgett/poktlint.com

df4e6c973bbde258073ff96531492c99bfe5e036

2022-03-25T19:25:26.000Z

2022-03-25T19:46:02.000Z

src/util/index.tsx

decentralized-authority/poktlint.com

df4e6c973bbde258073ff96531492c99bfe5e036

export const relayIdToName = (relayId: string): string => { switch(relayId) { case '0029': return 'algorand-mainnet'; case '0003': return 'avax-mainnet'; case '00A3': return 'avax-archival'; case '0004': return 'bsc-mainnet'; case '0010': return 'bsc-archival'; case '0021': return 'eth-mainnet'; case '0022': return 'eth-archival'; case '0028': return 'eth-archival-trace'; case '0026': return 'eth-goerli'; case '0024': return 'poa-kovan'; case '0025': return 'eth-rinkeby'; case '0023': return 'eth-ropsten'; case '0005': return 'fuse-mainnet'; case '000A': return 'fuse-archival'; case '0027': return 'gnosischain-mainnet'; case '000C': return 'gnosischain-archival'; case '0040': return 'harmony-0'; case '0044': return 'iotex-mainnet'; case '0047': return 'oec-mainnet'; case '0001': return 'pocket-mainnet'; case '0009': return 'poly-mainnet'; case '000B': return 'poly-archival'; case '0006': return 'sol-mainnet'; default: return 'unknown'; } }; const regionDirectionToShortened = (region: string): string => { switch(region) { case 'north': return 'n'; case 'south': return 's'; case 'east': return 'e'; case 'west': return 'w'; case 'central': return 'c'; case 'northeast': return 'ne'; case 'southeast': return 'se'; case 'northwest': return 'nw'; case 'southwest': return 'sw'; default: return region; } }; export const regionToShortened = (region: string): string => { try { const splitRegion = region.split('-'); splitRegion[1] = regionDirectionToShortened(splitRegion[1]); return splitRegion.join('-'); } catch(err) { // ignore error return region; } } export const regionToName = (region: string): string => { switch(region) { case 'us-east-1': return 'United States East 1'; case 'us-east-2': return 'United States East 2'; case 'us-west-1': return 'United States West 1'; case 'us-west-2': return 'United States West 2'; case 'ap-east-1': return 'Asia Pacific East 1'; case 'ap-northeast-1': return 'Asia Pacific Northeast 1'; case 'ap-southeast-1': return 'Asia Pacific Southeast 1'; case 'eu-central-1': return 'Europe Central 1'; case 'eu-north-1': return 'Europe North 1'; case 'eu-south-1': return 'Europe South 1'; case 'eu-west-1': return 'Europe West 1'; default: return region; } }

export const relayIdToName = (relayId) => { switch(relayId) { case '0029': return 'algorand-mainnet'; case '0003': return 'avax-mainnet'; case '00A3': return 'avax-archival'; case '0004': return 'bsc-mainnet'; case '0010': return 'bsc-archival'; case '0021': return 'eth-mainnet'; case '0022': return 'eth-archival'; case '0028': return 'eth-archival-trace'; case '0026': return 'eth-goerli'; case '0024': return 'poa-kovan'; case '0025': return 'eth-rinkeby'; case '0023': return 'eth-ropsten'; case '0005': return 'fuse-mainnet'; case '000A': return 'fuse-archival'; case '0027': return 'gnosischain-mainnet'; case '000C': return 'gnosischain-archival'; case '0040': return 'harmony-0'; case '0044': return 'iotex-mainnet'; case '0047': return 'oec-mainnet'; case '0001': return 'pocket-mainnet'; case '0009': return 'poly-mainnet'; case '000B': return 'poly-archival'; case '0006': return 'sol-mainnet'; default: return 'unknown'; } }; /* Example usages of 'regionDirectionToShortened' are shown below: splitRegion[1] = regionDirectionToShortened(splitRegion[1]); */ const regionDirectionToShortened = (region) => { switch(region) { case 'north': return 'n'; case 'south': return 's'; case 'east': return 'e'; case 'west': return 'w'; case 'central': return 'c'; case 'northeast': return 'ne'; case 'southeast': return 'se'; case 'northwest': return 'nw'; case 'southwest': return 'sw'; default: return region; } }; export const regionToShortened = (region) => { try { const splitRegion = region.split('-'); splitRegion[1] = regionDirectionToShortened(splitRegion[1]); return splitRegion.join('-'); } catch(err) { // ignore error return region; } } export const regionToName = (region) => { switch(region) { case 'us-east-1': return 'United States East 1'; case 'us-east-2': return 'United States East 2'; case 'us-west-1': return 'United States West 1'; case 'us-west-2': return 'United States West 2'; case 'ap-east-1': return 'Asia Pacific East 1'; case 'ap-northeast-1': return 'Asia Pacific Northeast 1'; case 'ap-southeast-1': return 'Asia Pacific Southeast 1'; case 'eu-central-1': return 'Europe Central 1'; case 'eu-north-1': return 'Europe North 1'; case 'eu-south-1': return 'Europe South 1'; case 'eu-west-1': return 'Europe West 1'; default: return region; } }

9ae0d8a6893a908199e9b2369297fd233ae64973

ts

TypeScript

problemset/mini-parser/index.ts

OUDUIDUI/leet-code

50e61ce16d1c419ccefc075ae9ead721cdd1cdbb

2022-01-17T03:19:56.000Z

2022-01-17T05:45:39.000Z

problemset/mini-parser/index.ts

OUDUIDUI/leet-code

50e61ce16d1c419ccefc075ae9ead721cdd1cdbb

problemset/mini-parser/index.ts

OUDUIDUI/leet-code

50e61ce16d1c419ccefc075ae9ead721cdd1cdbb

export class NestedInteger { list: NestedInteger[] = [] constructor(public value?: number) {} isInteger(): boolean { return this.value !== undefined } getInteger(): number | null { return this.isInteger() ? this.value! : null } setInteger(value: number) { this.value = value } add(elem: NestedInteger) { this.list.push(elem) } getList(): NestedInteger[] { return this.list } } /** * 深度优先搜索 * @desc 时间复杂度 O(N) 空间复杂度 O(N) * @param s * @returns */ export function deserialize(s: string): NestedInteger { let i = 0 return dfs(s) function dfs(s: string) { if (s[i] === '[') { i++ const ni = new NestedInteger() while (s[i] !== ']') { ni.add(dfs(s)) if (s[i] === ',') i++ } i++ return ni } else { let negative = false if (s[i] === '-') { negative = true i++ } let num = 0 while (i < s.length && isDigit(s[i])) { num = num * 10 + s[i].charCodeAt(0) - '0'.charCodeAt(0) i++ } if (negative) num = -num return new NestedInteger(num) } } function isDigit(ch: string): boolean { return !isNaN(Number(ch)) } } /** * 栈 * @desc 时间复杂度 O(N) 空间复杂度 O(N) * @param s * @returns */ export function deserialize2(s: string): NestedInteger { if (s[0] !== '[') return new NestedInteger(Number(s)) const isDigit = (ch: string): boolean => !isNaN(Number(ch)) const stack: NestedInteger[] = [] let num = 0 let negative = false for (let i = 0; i < s.length; i++) { const ch = s[i] if (ch === '-') { negative = true } else if (isDigit(ch)) { num = num * 10 + ch.charCodeAt(0) - '0'.charCodeAt(0) } else if (ch === '[') { stack.push(new NestedInteger()) } else if (ch === ',' || ch === ']') { if (isDigit(s[i - 1])) { if (negative) num = -num stack[stack.length - 1].add(new NestedInteger(num)) } num = 0 negative = false if (ch === ']' && stack.length > 1) { const ni = stack.pop()! stack[stack.length - 1].add(ni) } } } return stack.pop()! }

export class NestedInteger { list = [] constructor(public value?) {} isInteger() { return this.value !== undefined } getInteger() { return this.isInteger() ? this.value! : null } setInteger(value) { this.value = value } add(elem) { this.list.push(elem) } getList() { return this.list } } /** * 深度优先搜索 * @desc 时间复杂度 O(N) 空间复杂度 O(N) * @param s * @returns */ export function deserialize(s) { let i = 0 return dfs(s) /* Example usages of 'dfs' are shown below: dfs(s); ni.add(dfs(s)); */ function dfs(s) { if (s[i] === '[') { i++ const ni = new NestedInteger() while (s[i] !== ']') { ni.add(dfs(s)) if (s[i] === ',') i++ } i++ return ni } else { let negative = false if (s[i] === '-') { negative = true i++ } let num = 0 while (i < s.length && isDigit(s[i])) { num = num * 10 + s[i].charCodeAt(0) - '0'.charCodeAt(0) i++ } if (negative) num = -num return new NestedInteger(num) } } /* Example usages of 'isDigit' are shown below: i < s.length && isDigit(s[i]); isDigit(ch); isDigit(s[i - 1]); */ function isDigit(ch) { return !isNaN(Number(ch)) } } /** * 栈 * @desc 时间复杂度 O(N) 空间复杂度 O(N) * @param s * @returns */ export function deserialize2(s) { if (s[0] !== '[') return new NestedInteger(Number(s)) /* Example usages of 'isDigit' are shown below: i < s.length && isDigit(s[i]); isDigit(ch); isDigit(s[i - 1]); */ const isDigit = (ch) => !isNaN(Number(ch)) const stack = [] let num = 0 let negative = false for (let i = 0; i < s.length; i++) { const ch = s[i] if (ch === '-') { negative = true } else if (isDigit(ch)) { num = num * 10 + ch.charCodeAt(0) - '0'.charCodeAt(0) } else if (ch === '[') { stack.push(new NestedInteger()) } else if (ch === ',' || ch === ']') { if (isDigit(s[i - 1])) { if (negative) num = -num stack[stack.length - 1].add(new NestedInteger(num)) } num = 0 negative = false if (ch === ']' && stack.length > 1) { const ni = stack.pop()! stack[stack.length - 1].add(ni) } } } return stack.pop()! }

f239eadf444e4af3e91bed7eb153ee144d34ba78

ts

TypeScript

day-23.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

2022-03-14T00:03:38.000Z

2022-03-14T11:51:27.000Z

day-23.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

day-23.ts

dubzzz/advent-of-pbt-2021

7b324588cc582bea60155cc922778f39d503a818

/** * Each year, Santa receives wish lists coming from everywhere. * * Lists are ordered starting by the most important present to the last * important one. Santa does not always offer the most important one. * From time to time he wants to wait one more year to check if the * present stays in the top. * * Each year, Santa manually performs a diff of the list with * the one of the year before. Based on this diff he makes his choice. * * You can see the diff manually computed by Santa as an usual git diff * between two strings including many lines. * * Let's take the example: * * Year N: * Cars * Trains * Planes * * Year N+1: * Cars * Buses * Trains * Boats * * Diff of Santa: * === Cars * +++ Buses * === Trains * +++ Boats * --- Planes * * @param before - String representing the list of presents (before) * @param after - String representing the list of presents (after) */ export function wishListsDiffer(before: string, after: string): string { const beforeLines = before.split("\n"); const afterLines = after.split("\n"); const sharedLines = longestCommonSubarray(beforeLines, afterLines, 0, 0, []); const diffLines: string[] = []; let indexBefore = 0; let indexAfter = 0; for (const sharedLine of sharedLines) { for (; afterLines[indexAfter] !== sharedLine; ++indexAfter) { diffLines.push("+++ " + afterLines[indexAfter]); } for (; beforeLines[indexBefore] !== sharedLine; ++indexBefore) { diffLines.push("--- " + beforeLines[indexBefore]); } ++indexBefore; ++indexAfter; diffLines.push("=== " + sharedLine); } for (; indexAfter !== afterLines.length; ++indexAfter) { diffLines.push("+++ " + afterLines[indexAfter]); } for (; indexBefore !== beforeLines.length; ++indexBefore) { diffLines.push("--- " + beforeLines[indexBefore]); } return diffLines.join("\n"); } function longestCommonSubarray( dataA: string[], dataB: string[], startA: number, startB: number, sharedCache: string[][][] ): string[] { if (dataA.length <= startA || dataB.length <= startB) { return []; } if (startA in sharedCache) { if (startB in sharedCache[startA]) { return sharedCache[startA][startB]; } } else { sharedCache[startA] = []; } const optionSkippingStartA = longestCommonSubarray( dataA, dataB, startA + 1, startB, sharedCache ); const indexStartAInB = dataB.indexOf(dataA[startA], startB); if (indexStartAInB === -1) { sharedCache[startA][startB] = optionSkippingStartA; return optionSkippingStartA; } const optionIncludingStartA = [ dataA[startA], ...longestCommonSubarray( dataA, dataB, startA + 1, indexStartAInB + 1, sharedCache ), ]; const bestOption = optionSkippingStartA.length < optionIncludingStartA.length ? optionIncludingStartA : optionSkippingStartA; sharedCache[startA][startB] = bestOption; return bestOption; }

/** * Each year, Santa receives wish lists coming from everywhere. * * Lists are ordered starting by the most important present to the last * important one. Santa does not always offer the most important one. * From time to time he wants to wait one more year to check if the * present stays in the top. * * Each year, Santa manually performs a diff of the list with * the one of the year before. Based on this diff he makes his choice. * * You can see the diff manually computed by Santa as an usual git diff * between two strings including many lines. * * Let's take the example: * * Year N: * Cars * Trains * Planes * * Year N+1: * Cars * Buses * Trains * Boats * * Diff of Santa: * === Cars * +++ Buses * === Trains * +++ Boats * --- Planes * * @param before - String representing the list of presents (before) * @param after - String representing the list of presents (after) */ export function wishListsDiffer(before, after) { const beforeLines = before.split("\n"); const afterLines = after.split("\n"); const sharedLines = longestCommonSubarray(beforeLines, afterLines, 0, 0, []); const diffLines = []; let indexBefore = 0; let indexAfter = 0; for (const sharedLine of sharedLines) { for (; afterLines[indexAfter] !== sharedLine; ++indexAfter) { diffLines.push("+++ " + afterLines[indexAfter]); } for (; beforeLines[indexBefore] !== sharedLine; ++indexBefore) { diffLines.push("--- " + beforeLines[indexBefore]); } ++indexBefore; ++indexAfter; diffLines.push("=== " + sharedLine); } for (; indexAfter !== afterLines.length; ++indexAfter) { diffLines.push("+++ " + afterLines[indexAfter]); } for (; indexBefore !== beforeLines.length; ++indexBefore) { diffLines.push("--- " + beforeLines[indexBefore]); } return diffLines.join("\n"); } /* Example usages of 'longestCommonSubarray' are shown below: longestCommonSubarray(beforeLines, afterLines, 0, 0, []); longestCommonSubarray(dataA, dataB, startA + 1, startB, sharedCache); longestCommonSubarray(dataA, dataB, startA + 1, indexStartAInB + 1, sharedCache); */ function longestCommonSubarray( dataA, dataB, startA, startB, sharedCache ) { if (dataA.length <= startA || dataB.length <= startB) { return []; } if (startA in sharedCache) { if (startB in sharedCache[startA]) { return sharedCache[startA][startB]; } } else { sharedCache[startA] = []; } const optionSkippingStartA = longestCommonSubarray( dataA, dataB, startA + 1, startB, sharedCache ); const indexStartAInB = dataB.indexOf(dataA[startA], startB); if (indexStartAInB === -1) { sharedCache[startA][startB] = optionSkippingStartA; return optionSkippingStartA; } const optionIncludingStartA = [ dataA[startA], ...longestCommonSubarray( dataA, dataB, startA + 1, indexStartAInB + 1, sharedCache ), ]; const bestOption = optionSkippingStartA.length < optionIncludingStartA.length ? optionIncludingStartA : optionSkippingStartA; sharedCache[startA][startB] = bestOption; return bestOption; }

f2d62565325ed7fda8208aaa71f5b4b0ffe7f4e8

ts

TypeScript

src/shared/general.ts

u007/vite-ssg-ant

271d08f40d08f586dc2d4827e377183001762a19

src/shared/general.ts

u007/vite-ssg-ant

271d08f40d08f586dc2d4827e377183001762a19

src/shared/general.ts

u007/vite-ssg-ant

271d08f40d08f586dc2d4827e377183001762a19

2022-01-08T14:22:48.000Z

2022-01-08T14:22:48.000Z

export const pagination = { limit: 10, } export const cacheDuration = 60 * 10 // 10minutes // data has to be object or array export const parseFormForServer = (data: any) => { let res: any = {} for (let key in data) { if (key === '__ob__') { continue } let value = data[key] // console.log('parseFormForServer', key, value) if ( value !== undefined && value != null && typeof value === 'object' && !Array.isArray(value) && !value._d ) { // console.log('clone object', key) res[key] = parseFormForServer(value) } else if (value !== undefined && value !== null && value._d) { if (value.isValid()) { res[key] = value.toDate() } else { res[key] = null } } else if (Array.isArray(value)) { // when clone array, map does not include private or observers // console.log('clone array', key, value) res[key] = value.map((v, i) => { // console.log('array ', v, i) if (typeof v === 'object') { return parseFormForServer(v) } return v // console.log('arr value', newval) }) } else if (typeof value === 'function') { // ignore } else { // console.log('normalclone', i, Array.isArray(val), val) res[key] = value } } return res } export const valueOrClone = (i: string | number, value: any) => { if ( value != null && typeof value === 'object' && !Array.isArray(value) && !value._d ) { // console.log('clone object', i, val) return cloneData(value) } else if (Array.isArray(value)) { // when clone array, map does not include private or observers return value.map((v, i) => { return valueOrClone(i, v) }) } else if (typeof value === 'function') { // ignore return undefined } else { // console.log('normalclone', i, Array.isArray(val), val) return value } } export const formats = { date: 'dd MMM yyyy', dateTime: 'dd MMM yyyy HH:mm:ss', } export const makeRandomAplhaNumeric = (length: number) => { let text = '' let possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' for (let i = 0; i < length; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)) } return text } export const makeID = (length: number) => { return makeRandomAplhaNumeric(length) } // not case sensitive and does not contain similar looking charactor like O vs 0 export const makeFriendlyRandomCaseInsentitiveAplhaNumeric = ( length: number ) => { let text = '' let possible = 'ABCDEFGHIJKLMNPQRSTUVWXYZ123456789' for (let i = 0; i < length; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)) } return text } export const region = 'asia-northeast1' export const cloneData = (obj) => { let clone: any = {} for (let i in obj) { // if (typeof obj[i] !== 'function') { // console.log('clone', i, obj[i], typeof obj[i]) // } if (obj[i] !== null) { clone[i] = valueOrClone(i, obj[i]) } } return clone }

export const pagination = { limit: 10, } export const cacheDuration = 60 * 10 // 10minutes // data has to be object or array export /* Example usages of 'parseFormForServer' are shown below: // console.log('clone object', key) res[key] = parseFormForServer(value); parseFormForServer(v); */ const parseFormForServer = (data) => { let res = {} for (let key in data) { if (key === '__ob__') { continue } let value = data[key] // console.log('parseFormForServer', key, value) if ( value !== undefined && value != null && typeof value === 'object' && !Array.isArray(value) && !value._d ) { // console.log('clone object', key) res[key] = parseFormForServer(value) } else if (value !== undefined && value !== null && value._d) { if (value.isValid()) { res[key] = value.toDate() } else { res[key] = null } } else if (Array.isArray(value)) { // when clone array, map does not include private or observers // console.log('clone array', key, value) res[key] = value.map((v, i) => { // console.log('array ', v, i) if (typeof v === 'object') { return parseFormForServer(v) } return v // console.log('arr value', newval) }) } else if (typeof value === 'function') { // ignore } else { // console.log('normalclone', i, Array.isArray(val), val) res[key] = value } } return res } export /* Example usages of 'valueOrClone' are shown below: valueOrClone(i, v); clone[i] = valueOrClone(i, obj[i]); */ const valueOrClone = (i, value) => { if ( value != null && typeof value === 'object' && !Array.isArray(value) && !value._d ) { // console.log('clone object', i, val) return cloneData(value) } else if (Array.isArray(value)) { // when clone array, map does not include private or observers return value.map((v, i) => { return valueOrClone(i, v) }) } else if (typeof value === 'function') { // ignore return undefined } else { // console.log('normalclone', i, Array.isArray(val), val) return value } } export const formats = { date: 'dd MMM yyyy', dateTime: 'dd MMM yyyy HH:mm:ss', } export /* Example usages of 'makeRandomAplhaNumeric' are shown below: makeRandomAplhaNumeric(length); */ const makeRandomAplhaNumeric = (length) => { let text = '' let possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' for (let i = 0; i < length; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)) } return text } export const makeID = (length) => { return makeRandomAplhaNumeric(length) } // not case sensitive and does not contain similar looking charactor like O vs 0 export const makeFriendlyRandomCaseInsentitiveAplhaNumeric = ( length ) => { let text = '' let possible = 'ABCDEFGHIJKLMNPQRSTUVWXYZ123456789' for (let i = 0; i < length; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)) } return text } export const region = 'asia-northeast1' export /* Example usages of 'cloneData' are shown below: cloneData(value); */ const cloneData = (obj) => { let clone = {} for (let i in obj) { // if (typeof obj[i] !== 'function') { // console.log('clone', i, obj[i], typeof obj[i]) // } if (obj[i] !== null) { clone[i] = valueOrClone(i, obj[i]) } } return clone }

f2f61b40b240c398abf6f8f23862d7db05a4ccde

ts

TypeScript

src/authorization/lib/Utils.ts

api-client/core

aa157d09b39efa77d49f2d425e7b37828abe0c5b

src/authorization/lib/Utils.ts

api-client/core

aa157d09b39efa77d49f2d425e7b37828abe0c5b

2022-02-14T00:01:04.000Z

2022-02-14T00:04:07.000Z

src/authorization/lib/Utils.ts

advanced-rest-client/core

2efb946f786d8b46e7131c62e0011f6e090ddec3

/** * Normalizes type name to a string identifier. * It casts input to a string and lowercase it. * @param type Type value * @return Normalized value. */ export const normalizeType = (type?: string): string => String(type).toLowerCase(); export const METHOD_BASIC = "basic"; export const METHOD_BEARER = "bearer"; export const METHOD_NTLM = "ntlm"; export const METHOD_DIGEST = "digest"; export const METHOD_OAUTH2 = "oauth 2"; export const METHOD_OIDC = "open id"; export const METHOD_CC = 'client certificate'; export const CUSTOM_CREDENTIALS = "Custom credentials"; /** * @param value The value to validate * @returns True if the redirect URI can be considered valid. */ export function validateRedirectUri(value: unknown): boolean { let result = true; if (!value || typeof value !== 'string') { result = false; } // the redirect URI can have any value, especially for installed apps which // may use custom schemes. We do very basic sanity check for any script content // validation to make sure we are not passing any script. if (result) { const u = String(value).toLowerCase(); if (u.startsWith("javascript:") || u.startsWith("data:") || u.startsWith("vbscript:")) { result = false; } } return result; } /** * Generates client nonce for Digest authorization. * * @return Generated client nonce. */ export function generateCnonce(): string { const characters = 'abcdef0123456789'; let token = ''; for (let i = 0; i < 16; i++) { const randNum = Math.round(Math.random() * characters.length); token += characters.substring(randNum, 1); } return token; } /** * Generates `state` parameter for the OAuth2 call. * * @return Generated state string. */ export function generateState(): string { let text = ''; const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; for (let i = 0; i < 6; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)); } return text; } /** * When defined and the `url` is a relative path staring with `/` then it * adds base URI to the path and returns concatenated value. * * @param url The URL to process * @param baseUri Base URI to use. * @returns Final URL value. */ export function readUrlValue(url?: string, baseUri?: string): string { if (!url) { return ''; } const result = String(url); if (!baseUri) { return result; } if (result[0] === '/') { let uri = baseUri; if (uri[uri.length - 1] === '/') { uri = uri.substring(0, uri.length - 1); } return `${uri}${result}`; } return result; }

/** * Normalizes type name to a string identifier. * It casts input to a string and lowercase it. * @param type Type value * @return Normalized value. */ export const normalizeType = (type?) => String(type).toLowerCase(); export const METHOD_BASIC = "basic"; export const METHOD_BEARER = "bearer"; export const METHOD_NTLM = "ntlm"; export const METHOD_DIGEST = "digest"; export const METHOD_OAUTH2 = "oauth 2"; export const METHOD_OIDC = "open id"; export const METHOD_CC = 'client certificate'; export const CUSTOM_CREDENTIALS = "Custom credentials"; /** * @param value The value to validate * @returns True if the redirect URI can be considered valid. */ export function validateRedirectUri(value) { let result = true; if (!value || typeof value !== 'string') { result = false; } // the redirect URI can have any value, especially for installed apps which // may use custom schemes. We do very basic sanity check for any script content // validation to make sure we are not passing any script. if (result) { const u = String(value).toLowerCase(); if (u.startsWith("javascript:") || u.startsWith("data:") || u.startsWith("vbscript:")) { result = false; } } return result; } /** * Generates client nonce for Digest authorization. * * @return Generated client nonce. */ export function generateCnonce() { const characters = 'abcdef0123456789'; let token = ''; for (let i = 0; i < 16; i++) { const randNum = Math.round(Math.random() * characters.length); token += characters.substring(randNum, 1); } return token; } /** * Generates `state` parameter for the OAuth2 call. * * @return Generated state string. */ export function generateState() { let text = ''; const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; for (let i = 0; i < 6; i++) { text += possible.charAt(Math.floor(Math.random() * possible.length)); } return text; } /** * When defined and the `url` is a relative path staring with `/` then it * adds base URI to the path and returns concatenated value. * * @param url The URL to process * @param baseUri Base URI to use. * @returns Final URL value. */ export function readUrlValue(url?, baseUri?) { if (!url) { return ''; } const result = String(url); if (!baseUri) { return result; } if (result[0] === '/') { let uri = baseUri; if (uri[uri.length - 1] === '/') { uri = uri.substring(0, uri.length - 1); } return `${uri}${result}`; } return result; }

605858e60bc493837d811926d2e93af92a0ec0eb

ts

TypeScript

src/utils/dateTime.ts

ben-garcia/stack-client

5d8d24163106b5e3dbb0e25969c8dc726b576fb7

src/utils/dateTime.ts

ben-garcia/stack-client

5d8d24163106b5e3dbb0e25969c8dc726b576fb7

2022-02-26T20:53:24.000Z

2022-02-26T20:53:24.000Z

src/utils/dateTime.ts

ben-garcia/stack-client

5d8d24163106b5e3dbb0e25969c8dc726b576fb7

// helper functions to format ISO string to local time and day const getDay = (day: number): string => { switch (day + 1) { case 1: return 'Sunday'; case 2: return 'Monday'; case 3: return 'Tuesday'; case 4: return 'Wednesday'; case 5: return 'Thursday'; case 6: return 'Friday'; default: return 'Saturday'; } }; const getDate = (date: number): string => { switch (date) { case 1: return `${date}st`; case 2: return `${date}nd`; case 3: return `${date}rd`; default: return `${date}th`; } }; const getMonth = (month: number): string => { switch (month + 1) { case 1: return 'January'; case 2: return 'February'; case 3: return 'March'; case 4: return 'April'; case 5: return 'May'; case 6: return 'June'; case 7: return 'July'; case 8: return 'August'; case 9: return 'September'; case 10: return 'October'; case 11: return 'November'; default: return 'December'; } }; const setupMap = (date: string): Map<number, number> => { const monthMaxDays = new Map<number, number>(); monthMaxDays.set(1, 31); // check for leap year if (Number(date.split('/')[2]) / 4 === 0) { monthMaxDays.set(2, 29); } else { monthMaxDays.set(2, 28); } monthMaxDays.set(3, 31); monthMaxDays.set(4, 30); monthMaxDays.set(5, 31); monthMaxDays.set(6, 30); monthMaxDays.set(7, 31); monthMaxDays.set(8, 31); monthMaxDays.set(9, 30); monthMaxDays.set(10, 31); monthMaxDays.set(11, 30); monthMaxDays.set(12, 31); return monthMaxDays; }; const isMessageFromYesterday = ( today: string, dateInQuestion: string ): boolean => { const monthMaxDays = setupMap(today); const month = Number(dateInQuestion.split('/')[0]); const date = Number(dateInQuestion.split('/')[1]); const year = Number(dateInQuestion.split('/')[2]); const todayMonth = Number(today.split('/')[0]); const todayDate = Number(today.split('/')[1]); const todayYear = Number(today.split('/')[2]); let dateToCompare; let todayToCompare; // check that it isn't the 1st of the month if (date === 1) { todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (todayToCompare === dateInQuestion) { return true; } // check that month isn't January and date is 1 } else if (date === 1 && month !== 1) { const newDate = monthMaxDays.get(month - 1); dateToCompare = `${month - 1}/${newDate}/${year}`; todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (dateToCompare === todayToCompare) { return true; } } else { dateToCompare = `${month}/${date}/${year}`; todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (dateToCompare === todayToCompare) { return true; } } return false; }; const getCurrentYear = (): number => new Date().getFullYear(); export const printFormattedDate = (ISOString: string): string => { const dateToFormat = new Date(ISOString); // if the current year is equal to the ISOString year // then format string like so: month date, year if (getCurrentYear() === dateToFormat.getFullYear()) { const todaysDate = new Date().toLocaleDateString(); const dateInQuestion = dateToFormat.toLocaleDateString(); // for those messages that were created in the current day month and year if (todaysDate === dateInQuestion) { return 'Today'; } if (isMessageFromYesterday(todaysDate, dateInQuestion)) { // messages created 1 day before return 'Yesterday'; } // otherwise: day, month date return `${getDay(dateToFormat.getDay())}, ${getMonth( dateToFormat.getMonth() )} ${getDate(dateToFormat.getDate())}`; } // format ISOString like so: month date, year return `${getMonth(dateToFormat.getMonth())} ${getDate( dateToFormat.getDate() )}, ${dateToFormat.getFullYear()}`; }; export const getTime = (ISOString: string, amOrPm: boolean = true): string => { const date = new Date(ISOString).toLocaleTimeString().split(':'); const hour = date[0]; const minutes = date[1]; const pmOrAm = date[2].split(' ')[1]; if (amOrPm) { return `${hour}:${minutes} ${pmOrAm}`; } return `${hour}:${minutes}`; };

// helper functions to format ISO string to local time and day /* Example usages of 'getDay' are shown below: getDay(dateToFormat.getDay()); */ const getDay = (day) => { switch (day + 1) { case 1: return 'Sunday'; case 2: return 'Monday'; case 3: return 'Tuesday'; case 4: return 'Wednesday'; case 5: return 'Thursday'; case 6: return 'Friday'; default: return 'Saturday'; } }; /* Example usages of 'getDate' are shown below: getDate(dateToFormat.getDate()); */ const getDate = (date) => { switch (date) { case 1: return `${date}st`; case 2: return `${date}nd`; case 3: return `${date}rd`; default: return `${date}th`; } }; /* Example usages of 'getMonth' are shown below: getMonth(dateToFormat.getMonth()); */ const getMonth = (month) => { switch (month + 1) { case 1: return 'January'; case 2: return 'February'; case 3: return 'March'; case 4: return 'April'; case 5: return 'May'; case 6: return 'June'; case 7: return 'July'; case 8: return 'August'; case 9: return 'September'; case 10: return 'October'; case 11: return 'November'; default: return 'December'; } }; /* Example usages of 'setupMap' are shown below: setupMap(today); */ const setupMap = (date) => { const monthMaxDays = new Map<number, number>(); monthMaxDays.set(1, 31); // check for leap year if (Number(date.split('/')[2]) / 4 === 0) { monthMaxDays.set(2, 29); } else { monthMaxDays.set(2, 28); } monthMaxDays.set(3, 31); monthMaxDays.set(4, 30); monthMaxDays.set(5, 31); monthMaxDays.set(6, 30); monthMaxDays.set(7, 31); monthMaxDays.set(8, 31); monthMaxDays.set(9, 30); monthMaxDays.set(10, 31); monthMaxDays.set(11, 30); monthMaxDays.set(12, 31); return monthMaxDays; }; /* Example usages of 'isMessageFromYesterday' are shown below: isMessageFromYesterday(todaysDate, dateInQuestion); */ const isMessageFromYesterday = ( today, dateInQuestion ) => { const monthMaxDays = setupMap(today); const month = Number(dateInQuestion.split('/')[0]); const date = Number(dateInQuestion.split('/')[1]); const year = Number(dateInQuestion.split('/')[2]); const todayMonth = Number(today.split('/')[0]); const todayDate = Number(today.split('/')[1]); const todayYear = Number(today.split('/')[2]); let dateToCompare; let todayToCompare; // check that it isn't the 1st of the month if (date === 1) { todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (todayToCompare === dateInQuestion) { return true; } // check that month isn't January and date is 1 } else if (date === 1 && month !== 1) { const newDate = monthMaxDays.get(month - 1); dateToCompare = `${month - 1}/${newDate}/${year}`; todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (dateToCompare === todayToCompare) { return true; } } else { dateToCompare = `${month}/${date}/${year}`; todayToCompare = `${todayMonth}/${todayDate - 1}/${todayYear}`; if (dateToCompare === todayToCompare) { return true; } } return false; }; /* Example usages of 'getCurrentYear' are shown below: getCurrentYear() === dateToFormat.getFullYear(); */ const getCurrentYear = () => new Date().getFullYear(); export const printFormattedDate = (ISOString) => { const dateToFormat = new Date(ISOString); // if the current year is equal to the ISOString year // then format string like so: month date, year if (getCurrentYear() === dateToFormat.getFullYear()) { const todaysDate = new Date().toLocaleDateString(); const dateInQuestion = dateToFormat.toLocaleDateString(); // for those messages that were created in the current day month and year if (todaysDate === dateInQuestion) { return 'Today'; } if (isMessageFromYesterday(todaysDate, dateInQuestion)) { // messages created 1 day before return 'Yesterday'; } // otherwise: day, month date return `${getDay(dateToFormat.getDay())}, ${getMonth( dateToFormat.getMonth() )} ${getDate(dateToFormat.getDate())}`; } // format ISOString like so: month date, year return `${getMonth(dateToFormat.getMonth())} ${getDate( dateToFormat.getDate() )}, ${dateToFormat.getFullYear()}`; }; export const getTime = (ISOString, amOrPm = true) => { const date = new Date(ISOString).toLocaleTimeString().split(':'); const hour = date[0]; const minutes = date[1]; const pmOrAm = date[2].split(' ')[1]; if (amOrPm) { return `${hour}:${minutes} ${pmOrAm}`; } return `${hour}:${minutes}`; };

6098211daafdab1fe8de0c09c0ecd62b337844c8

ts

TypeScript

lib/index.ts

princess-rosella/spu-md5

ddfae1ee439a5e7238e23a5f2c66f80d94aab651

2021-12-31T03:11:45.000Z

2021-12-31T03:11:45.000Z

lib/index.ts

princess-rosella/spu-md5

ddfae1ee439a5e7238e23a5f2c66f80d94aab651

lib/index.ts

princess-rosella/spu-md5

ddfae1ee439a5e7238e23a5f2c66f80d94aab651

/* * Copyright (c) 2018 Princess Rosella. All rights reserved. * * @LICENSE_HEADER_START@ * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * @LICENSE_HEADER_END@ */ export const BLOCK_SIZE = 64; export const BLOCK_LENGTH = 16; const isLittleEndian = new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x78; const rotl = function(n: number, b: number): number { return (n << b) | (n >>> (32 - b)); }; const swab32s = function(n: number): number { return (rotl(n, 8) & 0x00FF00FF) | (rotl(n, 24) & 0xFF00FF00); }; const le32_to_cpu_uint32array = function(array: Uint32Array) { if (isLittleEndian) return; for (let i = 0; i < array.length; i++) array[i] = swab32s(array[i]); }; const cpu_to_le32_uint32array = function(array: Uint32Array) { if (isLittleEndian) return; for (let i = 0; i < array.length; i++) array[i] = swab32s(array[i]); }; const memcpy = function(dest: Uint8Array, destOffset: number, src: Uint8Array, srcOffset: number, length: number): void { dest.set(src.subarray(srcOffset, srcOffset + length), destOffset); }; const bzero = function(dest: Uint8Array, offset: number, length: number): void { while (length--) dest[offset++] = 0; } const FF = function(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number { const n = a + (b & c | ~b & d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; const GG = function(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number { const n = a + (b & d | c & ~d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; const HH = function(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number { const n = a + (b ^ c ^ d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; const II = function(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number { const n = a + (c ^ (b | ~d)) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; const transform = function(block: Uint32Array, hash: Uint32Array) { const aa = hash[0]; const bb = hash[1]; const cc = hash[2]; const dd = hash[3]; let a = aa; let b = bb; let c = cc; let d = dd; a = FF(a, b, c, d, block[ 0], 7, -680876936); d = FF(d, a, b, c, block[ 1], 12, -389564586); c = FF(c, d, a, b, block[ 2], 17, 606105819); b = FF(b, c, d, a, block[ 3], 22, -1044525330); a = FF(a, b, c, d, block[ 4], 7, -176418897); d = FF(d, a, b, c, block[ 5], 12, 1200080426); c = FF(c, d, a, b, block[ 6], 17, -1473231341); b = FF(b, c, d, a, block[ 7], 22, -45705983); a = FF(a, b, c, d, block[ 8], 7, 1770035416); d = FF(d, a, b, c, block[ 9], 12, -1958414417); c = FF(c, d, a, b, block[10], 17, -42063); b = FF(b, c, d, a, block[11], 22, -1990404162); a = FF(a, b, c, d, block[12], 7, 1804603682); d = FF(d, a, b, c, block[13], 12, -40341101); c = FF(c, d, a, b, block[14], 17, -1502002290); b = FF(b, c, d, a, block[15], 22, 1236535329); a = GG(a, b, c, d, block[ 1]|0, 5, -165796510); d = GG(d, a, b, c, block[ 6]|0, 9, -1069501632); c = GG(c, d, a, b, block[11]|0, 14, 643717713); b = GG(b, c, d, a, block[ 0]|0, 20, -373897302); a = GG(a, b, c, d, block[ 5]|0, 5, -701558691); d = GG(d, a, b, c, block[10]|0, 9, 38016083); c = GG(c, d, a, b, block[15]|0, 14, -660478335); b = GG(b, c, d, a, block[ 4]|0, 20, -405537848); a = GG(a, b, c, d, block[ 9]|0, 5, 568446438); d = GG(d, a, b, c, block[14]|0, 9, -1019803690); c = GG(c, d, a, b, block[ 3]|0, 14, -187363961); b = GG(b, c, d, a, block[ 8]|0, 20, 1163531501); a = GG(a, b, c, d, block[13]|0, 5, -1444681467); d = GG(d, a, b, c, block[ 2]|0, 9, -51403784); c = GG(c, d, a, b, block[ 7]|0, 14, 1735328473); b = GG(b, c, d, a, block[12]|0, 20, -1926607734); a = HH(a, b, c, d, block[ 5]|0, 4, -378558); d = HH(d, a, b, c, block[ 8]|0, 11, -2022574463); c = HH(c, d, a, b, block[11]|0, 16, 1839030562); b = HH(b, c, d, a, block[14]|0, 23, -35309556); a = HH(a, b, c, d, block[ 1]|0, 4, -1530992060); d = HH(d, a, b, c, block[ 4]|0, 11, 1272893353); c = HH(c, d, a, b, block[ 7]|0, 16, -155497632); b = HH(b, c, d, a, block[10]|0, 23, -1094730640); a = HH(a, b, c, d, block[13]|0, 4, 681279174); d = HH(d, a, b, c, block[ 0]|0, 11, -358537222); c = HH(c, d, a, b, block[ 3]|0, 16, -722521979); b = HH(b, c, d, a, block[ 6]|0, 23, 76029189); a = HH(a, b, c, d, block[ 9]|0, 4, -640364487); d = HH(d, a, b, c, block[12]|0, 11, -421815835); c = HH(c, d, a, b, block[15]|0, 16, 530742520); b = HH(b, c, d, a, block[ 2]|0, 23, -995338651); a = II(a, b, c, d, block[ 0]|0, 6, -198630844); d = II(d, a, b, c, block[ 7]|0, 10, 1126891415); c = II(c, d, a, b, block[14]|0, 15, -1416354905); b = II(b, c, d, a, block[ 5]|0, 21, -57434055); a = II(a, b, c, d, block[12]|0, 6, 1700485571); d = II(d, a, b, c, block[ 3]|0, 10, -1894986606); c = II(c, d, a, b, block[10]|0, 15, -1051523); b = II(b, c, d, a, block[ 1]|0, 21, -2054922799); a = II(a, b, c, d, block[ 8]|0, 6, 1873313359); d = II(d, a, b, c, block[15]|0, 10, -30611744); c = II(c, d, a, b, block[ 6]|0, 15, -1560198380); b = II(b, c, d, a, block[13]|0, 21, 1309151649); a = II(a, b, c, d, block[ 4]|0, 6, -145523070); d = II(d, a, b, c, block[11]|0, 10, -1120210379); c = II(c, d, a, b, block[ 2]|0, 15, 718787259); b = II(b, c, d, a, block[ 9]|0, 21, -343485551); hash[0] = (a + aa) >>> 0; hash[1] = (b + bb) >>> 0; hash[2] = (c + cc) >>> 0; hash[3] = (d + dd) >>> 0; }; /** * MD5 message-digest algorithm */ export class MD5 { private hash = new Uint32Array([1732584193, -271733879, -1732584194, 271733878]); private block = new Uint32Array(16); private block8: Uint8Array; private byteCount = 0; constructor() { this.block8 = new Uint8Array(this.block.buffer, this.block.byteOffset, this.block.byteLength); } /** * Dynamic version of MD5.update that accepts different types to binary data as parameters. * * @param data Data to hash * @see MD5.update */ dynamicUpdate(data: Uint8Array | DataView | ArrayBuffer): void { if (data instanceof DataView) data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength); else if (data instanceof ArrayBuffer) data = new Uint8Array(data); if (!(data instanceof Uint8Array)) throw new Error(`Expected a Uint8Array, a DataView or an ArrayBuffer. Received ${data.constructor.name}`); return this.update(data); } /** * Process an array of bytes to hash. * * @param data Bytes to hash */ update(data: Uint8Array): void { const avail = (BLOCK_SIZE - (this.byteCount & 0x3f))|0; let length = data.length; this.byteCount += length; if (avail > length) { memcpy(this.block8, BLOCK_SIZE - avail, data, 0, length); return; } memcpy(this.block8, BLOCK_SIZE - avail, data, 0, avail); this.transformHelper(); let offset = avail; length -= avail; while (length >= BLOCK_SIZE) { memcpy(this.block8, 0, data, offset, BLOCK_SIZE); this.transformHelper(); offset += BLOCK_SIZE; length -= BLOCK_SIZE; } memcpy(this.block8, 0, data, offset, length); } /** * Produce the hash as a sequence of 16 bytes. */ toUint8Array(): Uint8Array { const offset = this.byteCount & 0x3f; let p = offset; let padding = 56 - (offset + 1); const block8 = this.block8.slice(0); const block = new Uint32Array(block8.buffer); const hash = this.hash.slice(0); block8[p++] = 0x80; if (padding < 0) { bzero(block8, p, padding + 8); if (!isLittleEndian) le32_to_cpu_uint32array(block); transform(block, hash); p = 0; padding = 56; } bzero(block8, p, padding); block[14] = this.byteCount << 3; block[15] = this.byteCount >>> 29; if (!isLittleEndian) { le32_to_cpu_uint32array(block.subarray(0, BLOCK_LENGTH - 2)); transform(block, hash); cpu_to_le32_uint32array(hash); } else { transform(block, hash); } return new Uint8Array(hash.buffer); } /** * Produce the hash as string in hexadecimal format. */ toString(): string { let hex = ""; const hash = this.toUint8Array(); const hashLength = hash.byteLength; for (let i = 0; i < hashLength; i++) { hex += ((hash[i] >>> 4) & 0xF).toString(16); hex += ((hash[i] >>> 0) & 0xF).toString(16); } return hex; } private transformHelper() { if (!isLittleEndian) le32_to_cpu_uint32array(this.block); return transform(this.block, this.hash); } static process(data: Uint8Array | DataView | ArrayBuffer): string { const md5 = new MD5(); md5.dynamicUpdate(data); return md5.toString(); } }

/* * Copyright (c) 2018 Princess Rosella. All rights reserved. * * @LICENSE_HEADER_START@ * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * @LICENSE_HEADER_END@ */ export const BLOCK_SIZE = 64; export const BLOCK_LENGTH = 16; const isLittleEndian = new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x78; /* Example usages of 'rotl' are shown below: rotl(n, 8) & 0x00FF00FF; rotl(n, 24) & 0xFF00FF00; */ const rotl = function(n, b) { return (n << b) | (n >>> (32 - b)); }; /* Example usages of 'swab32s' are shown below: array[i] = swab32s(array[i]); */ const swab32s = function(n) { return (rotl(n, 8) & 0x00FF00FF) | (rotl(n, 24) & 0xFF00FF00); }; /* Example usages of 'le32_to_cpu_uint32array' are shown below: le32_to_cpu_uint32array(block); le32_to_cpu_uint32array(block.subarray(0, BLOCK_LENGTH - 2)); le32_to_cpu_uint32array(this.block); */ const le32_to_cpu_uint32array = function(array) { if (isLittleEndian) return; for (let i = 0; i < array.length; i++) array[i] = swab32s(array[i]); }; /* Example usages of 'cpu_to_le32_uint32array' are shown below: cpu_to_le32_uint32array(hash); */ const cpu_to_le32_uint32array = function(array) { if (isLittleEndian) return; for (let i = 0; i < array.length; i++) array[i] = swab32s(array[i]); }; /* Example usages of 'memcpy' are shown below: memcpy(this.block8, BLOCK_SIZE - avail, data, 0, length); memcpy(this.block8, BLOCK_SIZE - avail, data, 0, avail); memcpy(this.block8, 0, data, offset, BLOCK_SIZE); memcpy(this.block8, 0, data, offset, length); */ const memcpy = function(dest, destOffset, src, srcOffset, length) { dest.set(src.subarray(srcOffset, srcOffset + length), destOffset); }; /* Example usages of 'bzero' are shown below: bzero(block8, p, padding + 8); bzero(block8, p, padding); */ const bzero = function(dest, offset, length) { while (length--) dest[offset++] = 0; } /* Example usages of 'FF' are shown below: a = FF(a, b, c, d, block[0], 7, -680876936); d = FF(d, a, b, c, block[1], 12, -389564586); c = FF(c, d, a, b, block[2], 17, 606105819); b = FF(b, c, d, a, block[3], 22, -1044525330); a = FF(a, b, c, d, block[4], 7, -176418897); d = FF(d, a, b, c, block[5], 12, 1200080426); c = FF(c, d, a, b, block[6], 17, -1473231341); b = FF(b, c, d, a, block[7], 22, -45705983); a = FF(a, b, c, d, block[8], 7, 1770035416); d = FF(d, a, b, c, block[9], 12, -1958414417); c = FF(c, d, a, b, block[10], 17, -42063); b = FF(b, c, d, a, block[11], 22, -1990404162); a = FF(a, b, c, d, block[12], 7, 1804603682); d = FF(d, a, b, c, block[13], 12, -40341101); c = FF(c, d, a, b, block[14], 17, -1502002290); b = FF(b, c, d, a, block[15], 22, 1236535329); */ const FF = function(a, b, c, d, x, s, t) { const n = a + (b & c | ~b & d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; /* Example usages of 'GG' are shown below: a = GG(a, b, c, d, block[1] | 0, 5, -165796510); d = GG(d, a, b, c, block[6] | 0, 9, -1069501632); c = GG(c, d, a, b, block[11] | 0, 14, 643717713); b = GG(b, c, d, a, block[0] | 0, 20, -373897302); a = GG(a, b, c, d, block[5] | 0, 5, -701558691); d = GG(d, a, b, c, block[10] | 0, 9, 38016083); c = GG(c, d, a, b, block[15] | 0, 14, -660478335); b = GG(b, c, d, a, block[4] | 0, 20, -405537848); a = GG(a, b, c, d, block[9] | 0, 5, 568446438); d = GG(d, a, b, c, block[14] | 0, 9, -1019803690); c = GG(c, d, a, b, block[3] | 0, 14, -187363961); b = GG(b, c, d, a, block[8] | 0, 20, 1163531501); a = GG(a, b, c, d, block[13] | 0, 5, -1444681467); d = GG(d, a, b, c, block[2] | 0, 9, -51403784); c = GG(c, d, a, b, block[7] | 0, 14, 1735328473); b = GG(b, c, d, a, block[12] | 0, 20, -1926607734); */ const GG = function(a, b, c, d, x, s, t) { const n = a + (b & d | c & ~d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; /* Example usages of 'HH' are shown below: a = HH(a, b, c, d, block[5] | 0, 4, -378558); d = HH(d, a, b, c, block[8] | 0, 11, -2022574463); c = HH(c, d, a, b, block[11] | 0, 16, 1839030562); b = HH(b, c, d, a, block[14] | 0, 23, -35309556); a = HH(a, b, c, d, block[1] | 0, 4, -1530992060); d = HH(d, a, b, c, block[4] | 0, 11, 1272893353); c = HH(c, d, a, b, block[7] | 0, 16, -155497632); b = HH(b, c, d, a, block[10] | 0, 23, -1094730640); a = HH(a, b, c, d, block[13] | 0, 4, 681279174); d = HH(d, a, b, c, block[0] | 0, 11, -358537222); c = HH(c, d, a, b, block[3] | 0, 16, -722521979); b = HH(b, c, d, a, block[6] | 0, 23, 76029189); a = HH(a, b, c, d, block[9] | 0, 4, -640364487); d = HH(d, a, b, c, block[12] | 0, 11, -421815835); c = HH(c, d, a, b, block[15] | 0, 16, 530742520); b = HH(b, c, d, a, block[2] | 0, 23, -995338651); */ const HH = function(a, b, c, d, x, s, t) { const n = a + (b ^ c ^ d) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; /* Example usages of 'II' are shown below: a = II(a, b, c, d, block[0] | 0, 6, -198630844); d = II(d, a, b, c, block[7] | 0, 10, 1126891415); c = II(c, d, a, b, block[14] | 0, 15, -1416354905); b = II(b, c, d, a, block[5] | 0, 21, -57434055); a = II(a, b, c, d, block[12] | 0, 6, 1700485571); d = II(d, a, b, c, block[3] | 0, 10, -1894986606); c = II(c, d, a, b, block[10] | 0, 15, -1051523); b = II(b, c, d, a, block[1] | 0, 21, -2054922799); a = II(a, b, c, d, block[8] | 0, 6, 1873313359); d = II(d, a, b, c, block[15] | 0, 10, -30611744); c = II(c, d, a, b, block[6] | 0, 15, -1560198380); b = II(b, c, d, a, block[13] | 0, 21, 1309151649); a = II(a, b, c, d, block[4] | 0, 6, -145523070); d = II(d, a, b, c, block[11] | 0, 10, -1120210379); c = II(c, d, a, b, block[2] | 0, 15, 718787259); b = II(b, c, d, a, block[9] | 0, 21, -343485551); */ const II = function(a, b, c, d, x, s, t) { const n = a + (c ^ (b | ~d)) + (x >>> 0) + t; return ((n << s) | (n >>> (32 - s))) + b; }; /* Example usages of 'transform' are shown below: transform(block, hash); transform(this.block, this.hash); */ const transform = function(block, hash) { const aa = hash[0]; const bb = hash[1]; const cc = hash[2]; const dd = hash[3]; let a = aa; let b = bb; let c = cc; let d = dd; a = FF(a, b, c, d, block[ 0], 7, -680876936); d = FF(d, a, b, c, block[ 1], 12, -389564586); c = FF(c, d, a, b, block[ 2], 17, 606105819); b = FF(b, c, d, a, block[ 3], 22, -1044525330); a = FF(a, b, c, d, block[ 4], 7, -176418897); d = FF(d, a, b, c, block[ 5], 12, 1200080426); c = FF(c, d, a, b, block[ 6], 17, -1473231341); b = FF(b, c, d, a, block[ 7], 22, -45705983); a = FF(a, b, c, d, block[ 8], 7, 1770035416); d = FF(d, a, b, c, block[ 9], 12, -1958414417); c = FF(c, d, a, b, block[10], 17, -42063); b = FF(b, c, d, a, block[11], 22, -1990404162); a = FF(a, b, c, d, block[12], 7, 1804603682); d = FF(d, a, b, c, block[13], 12, -40341101); c = FF(c, d, a, b, block[14], 17, -1502002290); b = FF(b, c, d, a, block[15], 22, 1236535329); a = GG(a, b, c, d, block[ 1]|0, 5, -165796510); d = GG(d, a, b, c, block[ 6]|0, 9, -1069501632); c = GG(c, d, a, b, block[11]|0, 14, 643717713); b = GG(b, c, d, a, block[ 0]|0, 20, -373897302); a = GG(a, b, c, d, block[ 5]|0, 5, -701558691); d = GG(d, a, b, c, block[10]|0, 9, 38016083); c = GG(c, d, a, b, block[15]|0, 14, -660478335); b = GG(b, c, d, a, block[ 4]|0, 20, -405537848); a = GG(a, b, c, d, block[ 9]|0, 5, 568446438); d = GG(d, a, b, c, block[14]|0, 9, -1019803690); c = GG(c, d, a, b, block[ 3]|0, 14, -187363961); b = GG(b, c, d, a, block[ 8]|0, 20, 1163531501); a = GG(a, b, c, d, block[13]|0, 5, -1444681467); d = GG(d, a, b, c, block[ 2]|0, 9, -51403784); c = GG(c, d, a, b, block[ 7]|0, 14, 1735328473); b = GG(b, c, d, a, block[12]|0, 20, -1926607734); a = HH(a, b, c, d, block[ 5]|0, 4, -378558); d = HH(d, a, b, c, block[ 8]|0, 11, -2022574463); c = HH(c, d, a, b, block[11]|0, 16, 1839030562); b = HH(b, c, d, a, block[14]|0, 23, -35309556); a = HH(a, b, c, d, block[ 1]|0, 4, -1530992060); d = HH(d, a, b, c, block[ 4]|0, 11, 1272893353); c = HH(c, d, a, b, block[ 7]|0, 16, -155497632); b = HH(b, c, d, a, block[10]|0, 23, -1094730640); a = HH(a, b, c, d, block[13]|0, 4, 681279174); d = HH(d, a, b, c, block[ 0]|0, 11, -358537222); c = HH(c, d, a, b, block[ 3]|0, 16, -722521979); b = HH(b, c, d, a, block[ 6]|0, 23, 76029189); a = HH(a, b, c, d, block[ 9]|0, 4, -640364487); d = HH(d, a, b, c, block[12]|0, 11, -421815835); c = HH(c, d, a, b, block[15]|0, 16, 530742520); b = HH(b, c, d, a, block[ 2]|0, 23, -995338651); a = II(a, b, c, d, block[ 0]|0, 6, -198630844); d = II(d, a, b, c, block[ 7]|0, 10, 1126891415); c = II(c, d, a, b, block[14]|0, 15, -1416354905); b = II(b, c, d, a, block[ 5]|0, 21, -57434055); a = II(a, b, c, d, block[12]|0, 6, 1700485571); d = II(d, a, b, c, block[ 3]|0, 10, -1894986606); c = II(c, d, a, b, block[10]|0, 15, -1051523); b = II(b, c, d, a, block[ 1]|0, 21, -2054922799); a = II(a, b, c, d, block[ 8]|0, 6, 1873313359); d = II(d, a, b, c, block[15]|0, 10, -30611744); c = II(c, d, a, b, block[ 6]|0, 15, -1560198380); b = II(b, c, d, a, block[13]|0, 21, 1309151649); a = II(a, b, c, d, block[ 4]|0, 6, -145523070); d = II(d, a, b, c, block[11]|0, 10, -1120210379); c = II(c, d, a, b, block[ 2]|0, 15, 718787259); b = II(b, c, d, a, block[ 9]|0, 21, -343485551); hash[0] = (a + aa) >>> 0; hash[1] = (b + bb) >>> 0; hash[2] = (c + cc) >>> 0; hash[3] = (d + dd) >>> 0; }; /** * MD5 message-digest algorithm */ export class MD5 { private hash = new Uint32Array([1732584193, -271733879, -1732584194, 271733878]); private block = new Uint32Array(16); private block8; private byteCount = 0; constructor() { this.block8 = new Uint8Array(this.block.buffer, this.block.byteOffset, this.block.byteLength); } /** * Dynamic version of MD5.update that accepts different types to binary data as parameters. * * @param data Data to hash * @see MD5.update */ dynamicUpdate(data) { if (data instanceof DataView) data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength); else if (data instanceof ArrayBuffer) data = new Uint8Array(data); if (!(data instanceof Uint8Array)) throw new Error(`Expected a Uint8Array, a DataView or an ArrayBuffer. Received ${data.constructor.name}`); return this.update(data); } /** * Process an array of bytes to hash. * * @param data Bytes to hash */ update(data) { const avail = (BLOCK_SIZE - (this.byteCount & 0x3f))|0; let length = data.length; this.byteCount += length; if (avail > length) { memcpy(this.block8, BLOCK_SIZE - avail, data, 0, length); return; } memcpy(this.block8, BLOCK_SIZE - avail, data, 0, avail); this.transformHelper(); let offset = avail; length -= avail; while (length >= BLOCK_SIZE) { memcpy(this.block8, 0, data, offset, BLOCK_SIZE); this.transformHelper(); offset += BLOCK_SIZE; length -= BLOCK_SIZE; } memcpy(this.block8, 0, data, offset, length); } /** * Produce the hash as a sequence of 16 bytes. */ toUint8Array() { const offset = this.byteCount & 0x3f; let p = offset; let padding = 56 - (offset + 1); const block8 = this.block8.slice(0); const block = new Uint32Array(block8.buffer); const hash = this.hash.slice(0); block8[p++] = 0x80; if (padding < 0) { bzero(block8, p, padding + 8); if (!isLittleEndian) le32_to_cpu_uint32array(block); transform(block, hash); p = 0; padding = 56; } bzero(block8, p, padding); block[14] = this.byteCount << 3; block[15] = this.byteCount >>> 29; if (!isLittleEndian) { le32_to_cpu_uint32array(block.subarray(0, BLOCK_LENGTH - 2)); transform(block, hash); cpu_to_le32_uint32array(hash); } else { transform(block, hash); } return new Uint8Array(hash.buffer); } /** * Produce the hash as string in hexadecimal format. */ toString() { let hex = ""; const hash = this.toUint8Array(); const hashLength = hash.byteLength; for (let i = 0; i < hashLength; i++) { hex += ((hash[i] >>> 4) & 0xF).toString(16); hex += ((hash[i] >>> 0) & 0xF).toString(16); } return hex; } private transformHelper() { if (!isLittleEndian) le32_to_cpu_uint32array(this.block); return transform(this.block, this.hash); } static process(data) { const md5 = new MD5(); md5.dynamicUpdate(data); return md5.toString(); } }

60baa4be3249fdb09aa4318611c9c4351e704e60

ts

TypeScript

backend/src/helpers/BaseHelper.ts

verida/Credentials-Management-Platform

0ab28f637975825a79fc11077bbcff892fc4ba1d