umt 1.9.0 → 2.1.0

package/module/es5/IP/ipToLong.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ipToLong = void 0;
+var _ipToBinaryString = require("./ipToBinaryString");
+/**
+ * IPアドレスを32ビットの数値に変換します
+ * @param {string} ip - 変換するIPアドレス
+ * @returns {number} 32ビットの数値
+ */
+var ipToLong = exports.ipToLong = function ipToLong(ip) {
+  return Number.parseInt((0, _ipToBinaryString.ipToBinaryString)(ip), 2) >>> 0;
+};

package/module/es5/IP/isInRange.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 指定のIPアドレスが範囲内かどうかを判定します
+ * @param {string} remoteIp - リモートIPアドレス
+ * @param {string} networkIp - ネットワークIPアドレス
+ * @param {number} cidr - CIDR
+ * @returns {boolean} 範囲内であればtrue
+ */
+export declare const isInRange: (remoteIp: string, networkIp: string, cidr: number) => boolean;

package/module/es5/IP/isInRange.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInRange = void 0;
+var _ipToLong = require("./ipToLong");
+/**
+ * 指定のIPアドレスが範囲内かどうかを判定します
+ * @param {string} remoteIp - リモートIPアドレス
+ * @param {string} networkIp - ネットワークIPアドレス
+ * @param {number} cidr - CIDR
+ * @returns {boolean} 範囲内であればtrue
+ */
+var isInRange = exports.isInRange = function isInRange(remoteIp, networkIp, cidr) {
+  var shift = 32 - cidr;
+  return (0, _ipToLong.ipToLong)(remoteIp) >>> shift === (0, _ipToLong.ipToLong)(networkIp) >>> shift;
+};

package/module/es5/IP/isPrivateIp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * IPアドレスがプライベート範囲にあるかどうかを判定します
+ * @param {string} ip - 判定するIPアドレス
+ * @returns {boolean} プライベート範囲にあればtrue
+ */
+export declare const isPrivateIp: (ip: string) => boolean;

package/module/es5/IP/isPrivateIp.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPrivateIp = void 0;
+var _ipToLong = require("./ipToLong");
+var _isInRange = require("./isInRange");
+/**
+ * IPアドレスがプライベート範囲にあるかどうかを判定します
+ * @param {string} ip - 判定するIPアドレス
+ * @returns {boolean} プライベート範囲にあればtrue
+ */
+var isPrivateIp = exports.isPrivateIp = function isPrivateIp(ip) {
+  // プライベートIP範囲の定義
+  var privateRanges = [{
+    start: "10.0.0.0",
+    end: "10.255.255.255"
+  }, {
+    start: "172.16.0.0",
+    end: "172.31.255.255"
+  }, {
+    start: "192.168.0.0",
+    end: "192.168.255.255"
+  }];
+  return privateRanges.some(function (range) {
+    return (0, _isInRange.isInRange)(ip, range.start, (0, _ipToLong.ipToLong)(range.end));
+  });
+};

package/module/es5/IP/longToIp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 32ビットの数値をIPアドレスに変換します
+ * @param {number} long - 変換する32ビットの数値
+ * @returns {string} IPアドレス
+ */
+export declare const longToIp: (long: number) => string;

package/module/es5/IP/longToIp.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.longToIp = void 0;
+/**
+ * 32ビットの数値をIPアドレスに変換します
+ * @param {number} long - 変換する32ビットの数値
+ * @returns {string} IPアドレス
+ */
+var longToIp = exports.longToIp = function longToIp(_long) {
+  var binary = _long.toString(2).padStart(32, "0");
+  return Array.from({
+    length: 4
+  }, function (_, index) {
+    return Number.parseInt(binary.slice(index * 8, (index + 1) * 8), 2);
+  }).join(".");
+};

package/module/es5/IP/subnetMaskToCidr.d.ts

@@ -0,0 +1,6 @@
+/**
+ * サブネットマスクからCIDRを取得します
+ * @param {string} subnetMask - サブネットマスク
+ * @returns {number} CIDR
+ */
+export declare const subnetMaskToCidr: (subnetMask: string) => number;

package/module/es5/IP/subnetMaskToCidr.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subnetMaskToCidr = void 0;
+var _ipToBinaryString = require("./ipToBinaryString");
+var _isValueNaN = require("@/Validate/isValueNaN");
+/**
+ * サブネットマスクからCIDRを取得します
+ * @param {string} subnetMask - サブネットマスク
+ * @returns {number} CIDR
+ */
+var subnetMaskToCidr = exports.subnetMaskToCidr = function subnetMaskToCidr(subnetMask) {
+  // サブネットマスクが有効なIPアドレス形式かどうかをチェック
+  var octets = subnetMask.split(".").map(Number);
+  if (octets.length !== 4 || octets.some(function (octet) {
+    return (0, _isValueNaN.isValueNaN)(octet, true) || octet < 0 || octet > 255;
+  })) {
+    return 0;
+  }
+  return (0, _ipToBinaryString.ipToBinaryString)(subnetMask).match(/1/g).length;
+};

package/module/es5/Math/addition.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 誤差のない足し算
+ * @param  {number[]} numbers
+ * @returns number
+ * @example addition(0.1, 0.2); // 0.3
+ */
+export declare const addition: (...numbers: number[]) => number;

package/module/es5/Math/addition.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addition = void 0;
+var _getDecimalLength = require("./getDecimalLength");
+var _max = require("./max");
+var _multiplication = require("./multiplication");
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * 誤差のない足し算
+ * @param  {number[]} numbers
+ * @returns number
+ * @example addition(0.1, 0.2); // 0.3
+ */
+var addition = exports.addition = function addition() {
+  for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
+    numbers[_key] = arguments[_key];
+  }
+  var z = Math.pow(10, _max.max.apply(void 0, _toConsumableArray(numbers.map(function (element) {
+    return (0, _getDecimalLength.getDecimalLength)(element);
+  }))));
+  return numbers.reduce(function (sum, current) {
+    return sum + (0, _multiplication.multiplication)(current, z);
+  }, 0) / z;
+};

package/module/es5/Math/average.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 平均値
+ * @param  {number[]} numbers
+ * @returns number
+ * @example average([1, 2, 3]); // 2
+ */
+export declare const average: (numbers: number[]) => number;

package/module/es5/Math/average.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.average = void 0;
+var _addition = require("./addition");
+var _division = require("./division");
+/**
+ * 平均値
+ * @param  {number[]} numbers
+ * @returns number
+ * @example average([1, 2, 3]); // 2
+ */
+var average = exports.average = function average(numbers) {
+  if (numbers.length === 0) {
+    return 0;
+  }
+  var sum = numbers.reduce(function (a, b) {
+    return (0, _addition.addition)(a, b);
+  }, 0);
+  var avg = (0, _division.division)(sum, numbers.length);
+  return avg;
+};

package/module/es5/Math/bitwise.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ビット回転を行う関数
+ * @param x 回転させる32ビット整数
+ * @param k 回転するビット数
+ * @param direction 回転方向 ('left' または 'right')
+ * @returns 指定された方向にkビット回転された結果
+ * @example
+ * const resultLeft = bitwise(0x12345678, 8);
+ * console.log(resultLeft.toString(16)); // '34567812'
+ * const resultRight = bitwise(0x12345678, 8, 'right');
+ * console.log(resultRight.toString(16)); // '78123456'
+ */
+export declare const bitwise: (x: number, k: number, direction?: "left" | "right") => number;

package/module/es5/Math/bitwise.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitwise = void 0;
+/**
+ * ビット回転を行う関数
+ * @param x 回転させる32ビット整数
+ * @param k 回転するビット数
+ * @param direction 回転方向 ('left' または 'right')
+ * @returns 指定された方向にkビット回転された結果
+ * @example
+ * const resultLeft = bitwise(0x12345678, 8);
+ * console.log(resultLeft.toString(16)); // '34567812'
+ * const resultRight = bitwise(0x12345678, 8, 'right');
+ * console.log(resultRight.toString(16)); // '78123456'
+ */
+var bitwise = exports.bitwise = function bitwise(x, k) {
+  var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "left";
+  var rotation = (k % 32 + 32) % 32;
+  switch (direction) {
+    case "left":
+      {
+        return x << rotation | x >>> 32 - rotation;
+      }
+    case "right":
+      {
+        return x >>> rotation | x << 32 - rotation;
+      }
+    default:
+      {
+        throw new Error("Invalid direction ".concat(direction));
+      }
+  }
+};

package/module/es5/Math/calculator/calculator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 電卓
+ * ()や符号に対応
+ * 一文字までの方程式に対応
+ * @param  {string} expression 計算式または方程式
+ * @param  {object} exchange 為替
+ * @returns 計算結果
+ * @example calculator("1+2"); // 3
+ */
+export declare const calculator: <T extends Record<string, string | number>>(expression: string, exchange?: T) => string;

package/module/es5/Math/calculator/calculator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculator = void 0;
+var _core = require("./core");
+var _literalExpression = require("./literalExpression");
+/**
+ * 電卓
+ * ()や符号に対応
+ * 一文字までの方程式に対応
+ * @param  {string} expression 計算式または方程式
+ * @param  {object} exchange 為替
+ * @returns 計算結果
+ * @example calculator("1+2"); // 3
+ */
+var calculator = exports.calculator = function calculator(expression, exchange) {
+  var cleanExpression = expression.replaceAll(/\s+/g, "");
+  return cleanExpression.includes("=") ? (0, _literalExpression.literalExpression)(cleanExpression) : (0, _core.calculatorCore)(cleanExpression, exchange);
+};

package/module/es5/Math/calculator/calculatorInitialization.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 電卓関数を初期化する
+ * @param {object} exchange - 為替レート
+ * @return {Function} - calculator
+ * @example calculatorInitialization({ $: 100 })("$1"); // "100"
+ */
+export declare const calculatorInitialization: <T extends {
+    [key: string]: string | number;
+}>(exchange: T) => ((x: string) => string);

package/module/es5/Math/calculator/calculatorInitialization.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculatorInitialization = void 0;
+var _calculator = require("./calculator");
+/**
+ * 電卓関数を初期化する
+ * @param {object} exchange - 為替レート
+ * @return {Function} - calculator
+ * @example calculatorInitialization({ $: 100 })("$1"); // "100"
+ */
+var calculatorInitialization = exports.calculatorInitialization = function calculatorInitialization(exchange) {
+  /**
+   * @param {string} x - 金額
+   * @return {string} - 計算結果
+   */
+  return function (x) {
+    return (0, _calculator.calculator)(x, exchange);
+  };
+};

package/module/es5/Math/calculator/convertCurrency.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 文字列内の通貨記号を利用して通貨を換算する。
+ *
+ * @param inputString - 換算する通貨額を含む文字列
+ * @param conversionRates - 通貨記号と換算レートのオブジェクト
+ * @returns 換算後の通貨額を文字列で返す。換算できない場合は元の文字列を返す。
+ * @example convertCurrency("¥100", { "¥": 0.01 }); // "1"
+ */
+export declare const convertCurrency: <T extends {
+    [key: string]: number | string;
+}>(inputString: string, conversionRates?: T) => string;

package/module/es5/Math/calculator/convertCurrency.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertCurrency = void 0;
+var _multiplication = require("@/Math/multiplication");
+var _isNumber = require("@/Validate/isNumber");
+/**
+ * 文字列内の通貨記号を利用して通貨を換算する。
+ *
+ * @param inputString - 換算する通貨額を含む文字列
+ * @param conversionRates - 通貨記号と換算レートのオブジェクト
+ * @returns 換算後の通貨額を文字列で返す。換算できない場合は元の文字列を返す。
+ * @example convertCurrency("¥100", { "¥": 0.01 }); // "1"
+ */
+var convertCurrency = exports.convertCurrency = function convertCurrency(inputString, conversionRates) {
+  if (!conversionRates) {
+    return inputString;
+  }
+  for (var currencySymbol in conversionRates) {
+    if (inputString.startsWith(currencySymbol)) {
+      var amountString = inputString.slice(currencySymbol.length);
+      var rate = conversionRates[currencySymbol];
+      if ((0, _isNumber.isNumber)(rate)) {
+        var amount = Number(amountString);
+        var convertedAmount = (0, _multiplication.multiplication)(amount, Number(rate));
+        return Number.isNaN(convertedAmount) ? inputString : String(convertedAmount);
+      }
+    }
+  }
+  return inputString;
+};

package/module/es5/Math/calculator/core.d.ts

@@ -0,0 +1,3 @@
+export declare const calculatorCore: <T extends {
+    [key: string]: string | number;
+}>(expression: string, currencyExchange?: T) => string;

package/module/es5/Math/calculator/core.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculatorCore = void 0;
+var _convertCurrency = require("./convertCurrency");
+var _addition = require("@/Math/addition");
+var _division = require("@/Math/division");
+var _multiplication = require("@/Math/multiplication");
+var _subtract = require("@/Math/subtract");
+var _isNumber = require("@/Validate/isNumber");
+var calculatorCore = exports.calculatorCore = function calculatorCore(expression, currencyExchange) {
+  var sanitizedExpression = expression;
+
+  // 符号の処理
+  sanitizedExpression = sanitizeSigns(sanitizedExpression);
+
+  // 主要な計算ループ
+  while (true) {
+    // 通貨計算
+    if (currencyExchange) {
+      sanitizedExpression = applyCurrencyExchange(sanitizedExpression, currencyExchange);
+    }
+
+    // 括弧の処理
+    if (containsParentheses(sanitizedExpression)) {
+      var temporary = resolveParentheses(sanitizedExpression);
+      if (temporary === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = temporary;
+    }
+
+    // 乗算、べき乗の処理
+    else if (containsMulExp(sanitizedExpression)) {
+      var _temporary = resolveMulExp(sanitizedExpression);
+      if (_temporary === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary;
+    }
+
+    // 除算の処理
+    else if (containsDiv(sanitizedExpression)) {
+      var _temporary2 = resolveDiv(sanitizedExpression);
+      if (_temporary2 === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary2;
+    }
+
+    // 加算と減算の処理
+    else if (containsAddSub(sanitizedExpression) && !(0, _isNumber.isNumber)(sanitizedExpression)) {
+      var _temporary3 = resolveAddSub(sanitizedExpression);
+      if (_temporary3 === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary3;
+    }
+
+    // もう計算するものがなければ結果を返す
+    else {
+      return sanitizedExpression;
+    }
+  }
+};
+var sanitizeSigns = function sanitizeSigns(expr) {
+  return expr.replaceAll("--", "+").replaceAll("++", "+").replaceAll("+-", "+0-").replaceAll("-+", "+0-");
+};
+var applyCurrencyExchange = function applyCurrencyExchange(expr, rates) {
+  var returnExpr = expr;
+  // 通貨の交換ロジック
+  for (var index in rates) {
+    if (returnExpr.includes(index)) {
+      var $ = returnExpr.match(new RegExp("\\".concat(index, "([0-9]+)")));
+      if ($) {
+        returnExpr = returnExpr.replace($[0], (0, _convertCurrency.convertCurrency)($[0], rates));
+      }
+    }
+  }
+  return returnExpr;
+};
+var containsParentheses = function containsParentheses(expr) {
+  return expr.includes("(") || expr.includes(")");
+};
+var resolveParentheses = function resolveParentheses(expr) {
+  // 括弧内の計算ロジック
+  var match = expr.match(/\(\d+\.?(\d+)?([*+/-])\d+\.?(\d+)?\)/);
+  if (match) {
+    return expr.replace(match[0], calculatorCore(match[0].replaceAll(/\(|\)/g, "")));
+  }
+  return Number.NaN.toString();
+};
+var containsMulExp = function containsMulExp(expr) {
+  return expr.includes("^") || expr.includes("*");
+};
+var containsDiv = function containsDiv(expr) {
+  return expr.includes("/");
+};
+var resolveMulExp = function resolveMulExp(expr) {
+  // 乗算、べき乗の計算ロジック
+  var match = expr.match(/(.*?)(\d+\.?(\d+)?([*^])\d+\.?(\d+)?$)/);
+  if (match) {
+    var operands = match[2].split(/([*/^])/);
+    var result = operands[1] === "^" ? Math.pow(Number(operands[0]), Number(operands[2])) : (0, _multiplication.multiplication)(Number(operands[0]), Number(operands[2]));
+    return "".concat(match[1]).concat(result);
+  }
+  return Number.NaN.toString();
+};
+var resolveDiv = function resolveDiv(expr) {
+  // 除算の計算ロジック
+  var match = expr.match(/\d+\.?(\d+)?(\/)\d+\.?(\d+)?/);
+  if (match) {
+    var operands = match[0].split(/(\/)/);
+    var result = (0, _division.division)(Number(operands[0]), Number(operands[2]));
+    return expr.replace(match[0], String(result));
+  }
+  return Number.NaN.toString();
+};
+var containsAddSub = function containsAddSub(expr) {
+  return expr.includes("+") || expr.includes("-");
+};
+var resolveAddSub = function resolveAddSub(expr) {
+  // 加算、減算の計算ロジック
+  var match = expr.match(/(-?\d+)\.?(\d+)?(\+|-)(-?\d+)\.?(\d+)?/);
+  if (match) {
+    var result = match[3] === "+" ? (0, _addition.addition)(Number(match[1]), Number(match[4])) : (0, _subtract.subtract)(Number(match[1]), Number(match[4]));
+    return expr.replace(match[0], String(result));
+  }
+  return Number.NaN.toString();
+};

package/module/es5/Math/calculator/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./calculator";
+export * from "./calculatorInitialization";
+export * from "./convertCurrency";
+export * from "./core";
+export * from "./literalExpression";

package/module/es5/Math/calculator/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _calculator = require("./calculator");
+Object.keys(_calculator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _calculator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _calculator[key];
+    }
+  });
+});
+var _calculatorInitialization = require("./calculatorInitialization");
+Object.keys(_calculatorInitialization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _calculatorInitialization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _calculatorInitialization[key];
+    }
+  });
+});
+var _convertCurrency = require("./convertCurrency");
+Object.keys(_convertCurrency).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _convertCurrency[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _convertCurrency[key];
+    }
+  });
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});
+var _literalExpression = require("./literalExpression");
+Object.keys(_literalExpression).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _literalExpression[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _literalExpression[key];
+    }
+  });
+});

package/module/es5/Math/calculator/literalExpression.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 文字式の方程式を計算する
+ * @param x 方程式の文字列
+ * @returns 計算結果
+ * @example literalExpression("x+1=2"); // "1"
+ */
+export declare const literalExpression: (x: string) => string;