@design-edito/tools 0.1.52 → 0.1.53

package/chunks/chunk-UXM54YBI.js

@@ -0,0 +1,68 @@
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@design-edito/thumbnails/easings/index.ts
+var easings_exports = {};
+__export(easings_exports, {
+  ease: () => ease,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInSine: () => easeInSine,
+  easeOutQuad: () => easeOutQuad,
+  easeOutSine: () => easeOutSine,
+  linear: () => linear
+});
+function ease(t, name) {
+  switch (name) {
+    case "in-sine":
+      return easeInSine(t);
+    case "out-sine":
+      return easeOutSine(t);
+    case "in-out-sine":
+      return easeInOutSine(t);
+    case "in-quad":
+      return easeInQuad(t);
+    case "out-quad":
+      return easeOutQuad(t);
+    case "in-out-quad":
+      return easeInOutQuad(t);
+    case "linear":
+    default:
+      return linear(t);
+  }
+}
+function linear(t) {
+  return t;
+}
+function easeOutSine(t) {
+  return Math.sin(t * (Math.PI / 2));
+}
+function easeInSine(t) {
+  return -1 * Math.cos(t * (Math.PI / 2)) + 1;
+}
+function easeInOutSine(t) {
+  return -0.5 * (Math.cos(Math.PI * t) - 1);
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
+export {
+  ease,
+  linear,
+  easeOutSine,
+  easeInSine,
+  easeInOutSine,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easings_exports
+};

package/chunks/chunk-VHFMQI7Z.js

@@ -0,0 +1,20 @@
+import {
+  get_metadata_exports
+} from "./chunk-AF2MI5O5.js";
+import {
+  list_exports
+} from "./chunk-KYMCGWPM.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@google-cloud/storage/bucket/index.ts
+var bucket_exports = {};
+__export(bucket_exports, {
+  GetMetadata: () => get_metadata_exports,
+  List: () => list_exports
+});
+
+export {
+  bucket_exports
+};

package/chunks/chunk-VP3Y6EMX.js

@@ -0,0 +1,190 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-XCBH6NLF.js";
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module) {
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/inherits/inherits.js"(exports, module) {
+    try {
+      util = __require("util");
+      if (typeof util.inherits !== "function") throw "";
+      module.exports = util.inherits;
+    } catch (e) {
+      module.exports = require_inherits_browser();
+    }
+    var util;
+  }
+});
+
+// node_modules/process-nextick-args/index.js
+var require_process_nextick_args = __commonJS({
+  "node_modules/process-nextick-args/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
+      module.exports = { nextTick };
+    } else {
+      module.exports = process;
+    }
+    function nextTick(fn, arg1, arg2, arg3) {
+      if (typeof fn !== "function") {
+        throw new TypeError('"callback" argument must be a function');
+      }
+      var len = arguments.length;
+      var args, i;
+      switch (len) {
+        case 0:
+        case 1:
+          return process.nextTick(fn);
+        case 2:
+          return process.nextTick(function afterTickOne() {
+            fn.call(null, arg1);
+          });
+        case 3:
+          return process.nextTick(function afterTickTwo() {
+            fn.call(null, arg1, arg2);
+          });
+        case 4:
+          return process.nextTick(function afterTickThree() {
+            fn.call(null, arg1, arg2, arg3);
+          });
+        default:
+          args = new Array(len - 1);
+          i = 0;
+          while (i < args.length) {
+            args[i++] = arguments[i];
+          }
+          return process.nextTick(function afterTick() {
+            fn.apply(null, args);
+          });
+      }
+    }
+  }
+});
+
+// node_modules/isarray/index.js
+var require_isarray = __commonJS({
+  "node_modules/isarray/index.js"(exports, module) {
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  }
+});
+
+// node_modules/core-util-is/lib/util.js
+var require_util = __commonJS({
+  "node_modules/core-util-is/lib/util.js"(exports) {
+    function isArray(arg) {
+      if (Array.isArray) {
+        return Array.isArray(arg);
+      }
+      return objectToString(arg) === "[object Array]";
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    function isError(e) {
+      return objectToString(e) === "[object Error]" || e instanceof Error;
+    }
+    exports.isError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+      typeof arg === "undefined";
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = __require("buffer").Buffer.isBuffer;
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+  }
+});
+
+// node_modules/util-deprecate/node.js
+var require_node = __commonJS({
+  "node_modules/util-deprecate/node.js"(exports, module) {
+    module.exports = __require("util").deprecate;
+  }
+});
+
+export {
+  require_process_nextick_args,
+  require_isarray,
+  require_util,
+  require_inherits,
+  require_node
+};