@ultirequiem/leap-year 2.0.0 → 2.1.0

package/README.md

@@ -22,6 +22,7 @@ isLeapYear(2016); //=> true
 isLeapYear("6 October 2006 00:07:00 GMT"); //=> false
 isLeapYear("2000"); //=> false
 isLeapYear(new Date(2016, 1, 1)); //=> true
+isLeapYear("13 December 400 00:07:00 GMT", true); //=> { year: 400, result: true }
 ```
 
 ### [Node.js 🐢](https://www.npmjs.com/package/@ultirequiem/leap-year)
@@ -35,16 +36,10 @@ import { isLeapYear } from "@ultirequiem/leap-year";
 You can use any [CDN](https://en.wikipedia.org/wiki/Content_delivery_network)
 that you like.
 
-As an example, for
-[type module](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
-👇
-
-- [SkyPack](https://cdn.skypack.dev/@ultirequiem/leap-year)
-
-Or for a plain
-[script tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) 🦔
-
-- [jsdelivr](https://cdn.jsdelivr.net/npm/@ultirequiem/leap-year)
+Eg. [ESM](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+▶ [SkyPack](https://cdn.skypack.dev/@ultirequiem/leap-year) _/_
+[script tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) ▶
+[JSDelivr](https://cdn.jsdelivr.net/npm/@ultirequiem/leap-year).
 
 The API is the same on all this platforms.
 
@@ -53,6 +48,50 @@ The API is the same on all this platforms.
 [Autogenerated Documentation](https://doc.deno.land/https://deno.land/x/leap_year/mod.ts)
 🚀
 
+## CLI Tool
+
+Was done mainly as usage example.
+
+### Install
+
+- Node.js 🦍
+
+```sh
+npm install -g @ultirequiem/leap-year
+```
+
+- Deno 🦕
+
+```sh
+deno install https://deno.land/x/leap_year/leap-year.ts
+```
+
+### Usage
+
+```sh
+leap-year "13 October 2020 00:07:00 GMT" 400 345
+true
+true
+false
+```
+
+Or with the verbose flag 👇
+
+```sh
+leap-year "13 October 2020 00:07:00 GMT" 400 345 --verbose # -v
+2020 is a leap year.
+400 is a leap year.
+345 is not a leap year.
+```
+
+## Related
+
+- [leap_year_utils](https://github.com/UltiRequiem/leap_year_utils): Utilities
+  around this package
+
+- [parse_datelike](https://github.com/UltiRequiem/parse_datelike): Parse a
+  number/string/date to a number/string/date
+
 ## Support
 
 Open an Issue, I will check it a soon as possible 👀

package/esm/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/_dnt.shims.js

@@ -0,0 +1,62 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/deno.land/std@0.128.0/_util/assert.js

@@ -0,0 +1,14 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export class DenoStdInternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DenoStdInternalError";
+    }
+}
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new DenoStdInternalError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.128.0/flags/mod.js

@@ -0,0 +1,256 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assert } from "../_util/assert.js";
+const { hasOwn } = Object;
+function get(obj, key) {
+    if (hasOwn(obj, key)) {
+        return obj[key];
+    }
+}
+function getForce(obj, key) {
+    const v = get(obj, key);
+    assert(v != null);
+    return v;
+}
+function isNumber(x) {
+    if (typeof x === "number")
+        return true;
+    if (/^0x[0-9a-f]+$/i.test(String(x)))
+        return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));
+}
+function hasKey(obj, keys) {
+    let o = obj;
+    keys.slice(0, -1).forEach((key) => {
+        o = (get(o, key) ?? {});
+    });
+    const key = keys[keys.length - 1];
+    return key in o;
+}
+/** Take a set of command line arguments, with an optional set of options, and
+ * return an object representation of those argument.
+ *
+ * ```ts
+ *      import { parse } from "./mod.ts";
+ *      const parsedArgs = parse(Deno.args);
+ * ```
+ */
+export function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], unknown = (i) => i, } = {}) {
+    const flags = {
+        bools: {},
+        strings: {},
+        unknownFn: unknown,
+        allBools: false,
+    };
+    if (boolean !== undefined) {
+        if (typeof boolean === "boolean") {
+            flags.allBools = !!boolean;
+        }
+        else {
+            const booleanArgs = typeof boolean === "string" ? [boolean] : boolean;
+            for (const key of booleanArgs.filter(Boolean)) {
+                flags.bools[key] = true;
+            }
+        }
+    }
+    const aliases = {};
+    if (alias !== undefined) {
+        for (const key in alias) {
+            const val = getForce(alias, key);
+            if (typeof val === "string") {
+                aliases[key] = [val];
+            }
+            else {
+                aliases[key] = val;
+            }
+            for (const alias of getForce(aliases, key)) {
+                aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y));
+            }
+        }
+    }
+    if (string !== undefined) {
+        const stringArgs = typeof string === "string" ? [string] : string;
+        for (const key of stringArgs.filter(Boolean)) {
+            flags.strings[key] = true;
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const al of alias) {
+                    flags.strings[al] = true;
+                }
+            }
+        }
+    }
+    const argv = { _: [] };
+    function argDefined(key, arg) {
+        return ((flags.allBools && /^--[^=]+$/.test(arg)) ||
+            get(flags.bools, key) ||
+            !!get(flags.strings, key) ||
+            !!get(aliases, key));
+    }
+    function setKey(obj, keys, value) {
+        let o = obj;
+        keys.slice(0, -1).forEach(function (key) {
+            if (get(o, key) === undefined) {
+                o[key] = {};
+            }
+            o = get(o, key);
+        });
+        const key = keys[keys.length - 1];
+        if (get(o, key) === undefined ||
+            get(flags.bools, key) ||
+            typeof get(o, key) === "boolean") {
+            o[key] = value;
+        }
+        else if (Array.isArray(get(o, key))) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [get(o, key), value];
+        }
+    }
+    function setArg(key, val, arg = undefined) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg, key, val) === false)
+                return;
+        }
+        const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val;
+        setKey(argv, key.split("."), value);
+        const alias = get(aliases, key);
+        if (alias) {
+            for (const x of alias) {
+                setKey(argv, x.split("."), value);
+            }
+        }
+    }
+    function aliasIsBoolean(key) {
+        return getForce(aliases, key).some((x) => typeof get(flags.bools, x) === "boolean");
+    }
+    for (const key of Object.keys(flags.bools)) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    }
+    let notFlags = [];
+    // all args after "--" are not parsed
+    if (args.includes("--")) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (/^--.+=/.test(arg)) {
+            const m = arg.match(/^--([^=]+)=(.*)$/s);
+            assert(m != null);
+            const [, key, value] = m;
+            if (flags.bools[key]) {
+                const booleanValue = value !== "false";
+                setArg(key, booleanValue, arg);
+            }
+            else {
+                setArg(key, value, arg);
+            }
+        }
+        else if (/^--no-.+/.test(arg)) {
+            const m = arg.match(/^--no-(.+)/);
+            assert(m != null);
+            setArg(m[1], false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            const m = arg.match(/^--(.+)/);
+            assert(m != null);
+            const [, key] = m;
+            const next = args[i + 1];
+            if (next !== undefined &&
+                !/^-/.test(next) &&
+                !get(flags.bools, key) &&
+                !flags.allBools &&
+                (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === "true", arg);
+                i++;
+            }
+            else {
+                setArg(key, get(flags.strings, key) ? "" : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            const letters = arg.slice(1, -1).split("");
+            let broken = false;
+            for (let j = 0; j < letters.length; j++) {
+                const next = arg.slice(j + 2);
+                if (next === "-") {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split(/=(.+)/)[1], arg);
+                    broken = true;
+                    break;
+                }
+                if (/[A-Za-z]/.test(letters[j]) &&
+                    /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j + 2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg);
+                }
+            }
+            const [key] = arg.slice(-1);
+            if (!broken && key !== "-") {
+                if (args[i + 1] &&
+                    !/^(-|--)[^-]/.test(args[i + 1]) &&
+                    !get(flags.bools, key) &&
+                    (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i + 1], arg);
+                    i++;
+                }
+                else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+                    setArg(key, args[i + 1] === "true", arg);
+                    i++;
+                }
+                else {
+                    setArg(key, get(flags.strings, key) ? "" : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg));
+            }
+            if (stopEarly) {
+                argv._.push(...args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    for (const key of Object.keys(defaults)) {
+        if (!hasKey(argv, key.split("."))) {
+            setKey(argv, key.split("."), defaults[key]);
+            if (aliases[key]) {
+                for (const x of aliases[key]) {
+                    setKey(argv, x.split("."), defaults[key]);
+                }
+            }
+        }
+    }
+    if (doubleDash) {
+        argv["--"] = [];
+        for (const key of notFlags) {
+            argv["--"].push(key);
+        }
+    }
+    else {
+        for (const key of notFlags) {
+            argv._.push(key);
+        }
+    }
+    return argv;
+}

package/esm/deps/deno.land/x/parse_datelike@0.0.1/mod.js

@@ -0,0 +1,9 @@
+export function parseDateLike(date) {
+    if (typeof date === "string") {
+        date = new Date(date);
+    }
+    if (!(date instanceof Date) && typeof date !== "number") {
+        throw new TypeError(`Expected "year" type to be "Date" | "number" | "string" and got ${typeof date}.`);
+    }
+    return date instanceof Date ? date.getUTCFullYear() : date;
+}

package/esm/leap-year.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import "./_dnt.polyfills.js";
+import * as dntShim from "./_dnt.shims.js";
+import { parse } from "./deps/deno.land/std@0.128.0/flags/mod.js";
+import { isLeapYear } from "./mod.js";
+const { _: years, verbose } = parse(dntShim.Deno.args, {
+    boolean: ["verbose"],
+    alias: { v: "verbose" },
+});
+for (const year of years) {
+    const { year: parsedYear, result } = isLeapYear(year, true);
+    if (verbose) {
+        console.log(`${parsedYear} is ${result ? "" : "not "}a leap year.`);
+        continue;
+    }
+    console.log(result);
+}

package/esm/mod.js

@@ -1,40 +1,7 @@
-/**
- * Check if a year is a [leap year](https://en.wikipedia.org/wiki/Leap_year).
- *
- * @param year - Default: `new Date()`.
- *
- * @example
- * ```javascript
- * import { isLeapYear } from "https://deno.land/x/leap_year/mod.ts";
- *
- * isLeapYear(2014); //=> false
- * isLeapYear(2016); //=> true
- * isLeapYear("6 October 2006 00:07:00 GMT") //=> false
- * isLeapYear("200"); //=> false
- * isLeapYear(new Date(2016, 1, 1)); //=> true
- * ```
- */
-export function isLeapYear(year = new Date()) {
-    year = internalParse(year);
-    return (year % 4 === 0 && year % 100 !== 0) ?? year % 400 === 0;
-}
-export function generateLeapYear(config) {
-    const { min = 0, max = new Date() } = config;
-    const maxYear = internalParse(max);
-    const leapYears = [];
-    for (let year = min; year <= maxYear; year++) {
-        if (isLeapYear(year)) {
-            leapYears.push(year);
-        }
-    }
-    return leapYears;
-}
-function internalParse(date) {
-    if (typeof date === "string") {
-        date = new Date(date);
-    }
-    if (!(date instanceof Date) && typeof date !== "number") {
-        throw new TypeError(`Expected "year" type to be "Date" | "number" | "string" and got ${typeof date}.`);
-    }
-    return date instanceof Date ? date.getUTCFullYear() : date;
+import "./_dnt.polyfills.js";
+import { parseDateLike } from "./deps/deno.land/x/parse_datelike@0.0.1/mod.js";
+export function isLeapYear(year = new Date(), returnValue = false) {
+    year = parseDateLike(year);
+    const result = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return returnValue ? { result, year } : result;
 }

package/package.json

@@ -2,9 +2,12 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
+  "bin": {
+    "leap-year": "./esm/leap-year.js"
+  },
   "name": "@ultirequiem/leap-year",
   "description": "Check if a year is leap.",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "funding": {
     "type": "patreon",
@@ -31,10 +34,11 @@
   "scripts": {
     "test": "node test_runner.js"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@deno/shim-deno": "~0.4.3"
+  },
   "devDependencies": {
     "@types/node": "16.11.26",
-    "chalk": "4.1.2",
-    "@deno/shim-deno": "~0.4.3"
+    "chalk": "4.1.2"
   }
 }

package/script/_dnt.polyfills.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}

package/script/_dnt.shims.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/deno.land/std@0.128.0/_util/assert.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = exports.DenoStdInternalError = void 0;
+class DenoStdInternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DenoStdInternalError";
+    }
+}
+exports.DenoStdInternalError = DenoStdInternalError;
+/** Make an assertion, if not `true`, then throw. */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new DenoStdInternalError(msg);
+    }
+}
+exports.assert = assert;

package/script/deps/deno.land/std@0.128.0/flags/mod.js

@@ -0,0 +1,260 @@
+"use strict";
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const assert_js_1 = require("../_util/assert.js");
+const { hasOwn } = Object;
+function get(obj, key) {
+    if (hasOwn(obj, key)) {
+        return obj[key];
+    }
+}
+function getForce(obj, key) {
+    const v = get(obj, key);
+    (0, assert_js_1.assert)(v != null);
+    return v;
+}
+function isNumber(x) {
+    if (typeof x === "number")
+        return true;
+    if (/^0x[0-9a-f]+$/i.test(String(x)))
+        return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));
+}
+function hasKey(obj, keys) {
+    let o = obj;
+    keys.slice(0, -1).forEach((key) => {
+        o = (get(o, key) ?? {});
+    });
+    const key = keys[keys.length - 1];
+    return key in o;
+}
+/** Take a set of command line arguments, with an optional set of options, and
+ * return an object representation of those argument.
+ *
+ * ```ts
+ *      import { parse } from "./mod.ts";
+ *      const parsedArgs = parse(Deno.args);
+ * ```
+ */
+function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], unknown = (i) => i, } = {}) {
+    const flags = {
+        bools: {},
+        strings: {},
+        unknownFn: unknown,
+        allBools: false,
+    };
+    if (boolean !== undefined) {
+        if (typeof boolean === "boolean") {
+            flags.allBools = !!boolean;
+        }
+        else {
+            const booleanArgs = typeof boolean === "string" ? [boolean] : boolean;
+            for (const key of booleanArgs.filter(Boolean)) {
+                flags.bools[key] = true;
+            }
+        }
+    }
+    const aliases = {};
+    if (alias !== undefined) {
+        for (const key in alias) {
+            const val = getForce(alias, key);
+            if (typeof val === "string") {
+                aliases[key] = [val];
+            }
+            else {
+                aliases[key] = val;
+            }
+            for (const alias of getForce(aliases, key)) {
+                aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y));
+            }
+        }
+    }
+    if (string !== undefined) {
+        const stringArgs = typeof string === "string" ? [string] : string;
+        for (const key of stringArgs.filter(Boolean)) {
+            flags.strings[key] = true;
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const al of alias) {
+                    flags.strings[al] = true;
+                }
+            }
+        }
+    }
+    const argv = { _: [] };
+    function argDefined(key, arg) {
+        return ((flags.allBools && /^--[^=]+$/.test(arg)) ||
+            get(flags.bools, key) ||
+            !!get(flags.strings, key) ||
+            !!get(aliases, key));
+    }
+    function setKey(obj, keys, value) {
+        let o = obj;
+        keys.slice(0, -1).forEach(function (key) {
+            if (get(o, key) === undefined) {
+                o[key] = {};
+            }
+            o = get(o, key);
+        });
+        const key = keys[keys.length - 1];
+        if (get(o, key) === undefined ||
+            get(flags.bools, key) ||
+            typeof get(o, key) === "boolean") {
+            o[key] = value;
+        }
+        else if (Array.isArray(get(o, key))) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [get(o, key), value];
+        }
+    }
+    function setArg(key, val, arg = undefined) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg, key, val) === false)
+                return;
+        }
+        const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val;
+        setKey(argv, key.split("."), value);
+        const alias = get(aliases, key);
+        if (alias) {
+            for (const x of alias) {
+                setKey(argv, x.split("."), value);
+            }
+        }
+    }
+    function aliasIsBoolean(key) {
+        return getForce(aliases, key).some((x) => typeof get(flags.bools, x) === "boolean");
+    }
+    for (const key of Object.keys(flags.bools)) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    }
+    let notFlags = [];
+    // all args after "--" are not parsed
+    if (args.includes("--")) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (/^--.+=/.test(arg)) {
+            const m = arg.match(/^--([^=]+)=(.*)$/s);
+            (0, assert_js_1.assert)(m != null);
+            const [, key, value] = m;
+            if (flags.bools[key]) {
+                const booleanValue = value !== "false";
+                setArg(key, booleanValue, arg);
+            }
+            else {
+                setArg(key, value, arg);
+            }
+        }
+        else if (/^--no-.+/.test(arg)) {
+            const m = arg.match(/^--no-(.+)/);
+            (0, assert_js_1.assert)(m != null);
+            setArg(m[1], false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            const m = arg.match(/^--(.+)/);
+            (0, assert_js_1.assert)(m != null);
+            const [, key] = m;
+            const next = args[i + 1];
+            if (next !== undefined &&
+                !/^-/.test(next) &&
+                !get(flags.bools, key) &&
+                !flags.allBools &&
+                (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === "true", arg);
+                i++;
+            }
+            else {
+                setArg(key, get(flags.strings, key) ? "" : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            const letters = arg.slice(1, -1).split("");
+            let broken = false;
+            for (let j = 0; j < letters.length; j++) {
+                const next = arg.slice(j + 2);
+                if (next === "-") {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split(/=(.+)/)[1], arg);
+                    broken = true;
+                    break;
+                }
+                if (/[A-Za-z]/.test(letters[j]) &&
+                    /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j + 2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg);
+                }
+            }
+            const [key] = arg.slice(-1);
+            if (!broken && key !== "-") {
+                if (args[i + 1] &&
+                    !/^(-|--)[^-]/.test(args[i + 1]) &&
+                    !get(flags.bools, key) &&
+                    (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i + 1], arg);
+                    i++;
+                }
+                else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+                    setArg(key, args[i + 1] === "true", arg);
+                    i++;
+                }
+                else {
+                    setArg(key, get(flags.strings, key) ? "" : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg));
+            }
+            if (stopEarly) {
+                argv._.push(...args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    for (const key of Object.keys(defaults)) {
+        if (!hasKey(argv, key.split("."))) {
+            setKey(argv, key.split("."), defaults[key]);
+            if (aliases[key]) {
+                for (const x of aliases[key]) {
+                    setKey(argv, x.split("."), defaults[key]);
+                }
+            }
+        }
+    }
+    if (doubleDash) {
+        argv["--"] = [];
+        for (const key of notFlags) {
+            argv["--"].push(key);
+        }
+    }
+    else {
+        for (const key of notFlags) {
+            argv._.push(key);
+        }
+    }
+    return argv;
+}
+exports.parse = parse;

package/script/deps/deno.land/x/parse_datelike@0.0.1/mod.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateLike = void 0;
+function parseDateLike(date) {
+    if (typeof date === "string") {
+        date = new Date(date);
+    }
+    if (!(date instanceof Date) && typeof date !== "number") {
+        throw new TypeError(`Expected "year" type to be "Date" | "number" | "string" and got ${typeof date}.`);
+    }
+    return date instanceof Date ? date.getUTCFullYear() : date;
+}
+exports.parseDateLike = parseDateLike;

package/script/leap-year.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./_dnt.polyfills.js");
+const dntShim = __importStar(require("./_dnt.shims.js"));
+const mod_js_1 = require("./deps/deno.land/std@0.128.0/flags/mod.js");
+const mod_js_2 = require("./mod.js");
+const { _: years, verbose } = (0, mod_js_1.parse)(dntShim.Deno.args, {
+    boolean: ["verbose"],
+    alias: { v: "verbose" },
+});
+for (const year of years) {
+    const { year: parsedYear, result } = (0, mod_js_2.isLeapYear)(year, true);
+    if (verbose) {
+        console.log(`${parsedYear} is ${result ? "" : "not "}a leap year.`);
+        continue;
+    }
+    console.log(result);
+}

package/script/mod.js

@@ -1,45 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateLeapYear = exports.isLeapYear = void 0;
-/**
- * Check if a year is a [leap year](https://en.wikipedia.org/wiki/Leap_year).
- *
- * @param year - Default: `new Date()`.
- *
- * @example
- * ```javascript
- * import { isLeapYear } from "https://deno.land/x/leap_year/mod.ts";
- *
- * isLeapYear(2014); //=> false
- * isLeapYear(2016); //=> true
- * isLeapYear("6 October 2006 00:07:00 GMT") //=> false
- * isLeapYear("200"); //=> false
- * isLeapYear(new Date(2016, 1, 1)); //=> true
- * ```
- */
-function isLeapYear(year = new Date()) {
-    year = internalParse(year);
-    return (year % 4 === 0 && year % 100 !== 0) ?? year % 400 === 0;
+exports.isLeapYear = void 0;
+require("./_dnt.polyfills.js");
+const mod_js_1 = require("./deps/deno.land/x/parse_datelike@0.0.1/mod.js");
+function isLeapYear(year = new Date(), returnValue = false) {
+    year = (0, mod_js_1.parseDateLike)(year);
+    const result = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return returnValue ? { result, year } : result;
 }
 exports.isLeapYear = isLeapYear;
-function generateLeapYear(config) {
-    const { min = 0, max = new Date() } = config;
-    const maxYear = internalParse(max);
-    const leapYears = [];
-    for (let year = min; year <= maxYear; year++) {
-        if (isLeapYear(year)) {
-            leapYears.push(year);
-        }
-    }
-    return leapYears;
-}
-exports.generateLeapYear = generateLeapYear;
-function internalParse(date) {
-    if (typeof date === "string") {
-        date = new Date(date);
-    }
-    if (!(date instanceof Date) && typeof date !== "number") {
-        throw new TypeError(`Expected "year" type to be "Date" | "number" | "string" and got ${typeof date}.`);
-    }
-    return date instanceof Date ? date.getUTCFullYear() : date;
-}

package/types/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/types/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/types/deps/deno.land/std@0.128.0/_util/assert.d.ts

@@ -0,0 +1,5 @@
+export declare class DenoStdInternalError extends Error {
+    constructor(message: string);
+}
+/** Make an assertion, if not `true`, then throw. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/types/deps/deno.land/std@0.128.0/flags/mod.d.ts

@@ -0,0 +1,50 @@
+export interface Args {
+    /** Contains all the arguments that didn't have an option associated with
+     * them. */
+    _: Array<string | number>;
+    [key: string]: any;
+}
+export interface ArgParsingOptions {
+    /** When `true`, populate the result `_` with everything before the `--` and
+     * the result `['--']` with everything after the `--`. Here's an example:
+     *
+     * ```ts
+     *      // $ deno run example.ts -- a arg1
+     *      import { parse } from "./mod.ts";
+     *      console.dir(parse(Deno.args, { "--": false }));
+     *      // output: { _: [ "a", "arg1" ] }
+     *      console.dir(parse(Deno.args, { "--": true }));
+     *      // output: { _: [], --: [ "a", "arg1" ] }
+     * ```
+     *
+     * Defaults to `false`.
+     */
+    "--"?: boolean;
+    /** An object mapping string names to strings or arrays of string argument
+     * names to use as aliases */
+    alias?: Record<string, string | string[]>;
+    /** A boolean, string or array of strings to always treat as booleans. If
+     * `true` will treat all double hyphenated arguments without equal signs as
+     * `boolean` (e.g. affects `--foo`, not `-f` or `--foo=bar`) */
+    boolean?: boolean | string | string[];
+    /** An object mapping string argument names to default values. */
+    default?: Record<string, unknown>;
+    /** When `true`, populate the result `_` with everything after the first
+     * non-option. */
+    stopEarly?: boolean;
+    /** A string or array of strings argument names to always treat as strings. */
+    string?: string | string[];
+    /** A function which is invoked with a command line parameter not defined in
+     * the `options` configuration object. If the function returns `false`, the
+     * unknown option is not added to `parsedArgs`. */
+    unknown?: (arg: string, key?: string, value?: unknown) => unknown;
+}
+/** Take a set of command line arguments, with an optional set of options, and
+ * return an object representation of those argument.
+ *
+ * ```ts
+ *      import { parse } from "./mod.ts";
+ *      const parsedArgs = parse(Deno.args);
+ * ```
+ */
+export declare function parse(args: string[], { "--": doubleDash, alias, boolean, default: defaults, stopEarly, string, unknown, }?: ArgParsingOptions): Args;

package/types/deps/deno.land/x/parse_datelike@0.0.1/mod.d.ts

@@ -0,0 +1,2 @@
+export declare type DateLike = Date | number | string;
+export declare function parseDateLike(date: DateLike): number;

package/types/leap-year.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./_dnt.polyfills.js";

package/types/mod.d.ts

@@ -1,3 +1,4 @@
+import "./_dnt.polyfills.js";
 /**
  * Check if a year is a [leap year](https://en.wikipedia.org/wiki/Leap_year).
  *
@@ -14,9 +15,8 @@
  * isLeapYear(new Date(2016, 1, 1)); //=> true
  * ```
  */
-export declare function isLeapYear(year?: DateLike): boolean;
-export declare function generateLeapYear(config: {
-    min?: number;
-    max?: DateLike;
-}): number[];
-export declare type DateLike = Date | number | string;
+export declare function isLeapYear(year?: Date | string | number): boolean;
+export declare function isLeapYear(year?: Date | string | number, returnValue?: boolean): {
+    year: number;
+    result: boolean;
+};