@yahoo/uds 3.145.0-beta.1 → 3.145.0-beta.2

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/getModuleDependencies.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getModuleDependencies;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let jsExtensions = [
+    ".js",
+    ".cjs",
+    ".mjs"
+];
+// Given the current file `a.ts`, we want to make sure that when importing `b` that we resolve
+// `b.ts` before `b.js`
+//
+// E.g.:
+//
+// a.ts
+//   b // .ts
+//   c // .ts
+// a.js
+//   b // .js or .ts
+let jsResolutionOrder = [
+    "",
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".ts",
+    ".cts",
+    ".mts",
+    ".jsx",
+    ".tsx"
+];
+let tsResolutionOrder = [
+    "",
+    ".ts",
+    ".cts",
+    ".mts",
+    ".tsx",
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".jsx"
+];
+function resolveWithExtension(file, extensions) {
+    // Try to find `./a.ts`, `./a.ts`, ... from `./a`
+    for (let ext of extensions){
+        let full = `${file}${ext}`;
+        if (_fs.default.existsSync(full) && _fs.default.statSync(full).isFile()) {
+            return full;
+        }
+    }
+    // Try to find `./a/index.js` from `./a`
+    for (let ext of extensions){
+        let full = `${file}/index${ext}`;
+        if (_fs.default.existsSync(full)) {
+            return full;
+        }
+    }
+    return null;
+}
+function* _getModuleDependencies(filename, base, seen, ext = _path.default.extname(filename)) {
+    // Try to find the file
+    let absoluteFile = resolveWithExtension(_path.default.resolve(base, filename), jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder);
+    if (absoluteFile === null) return; // File doesn't exist
+    // Prevent infinite loops when there are circular dependencies
+    if (seen.has(absoluteFile)) return; // Already seen
+    seen.add(absoluteFile);
+    // Mark the file as a dependency
+    yield absoluteFile;
+    // Resolve new base for new imports/requires
+    base = _path.default.dirname(absoluteFile);
+    ext = _path.default.extname(absoluteFile);
+    let contents = _fs.default.readFileSync(absoluteFile, "utf-8");
+    // Find imports/requires
+    for (let match of [
+        ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi)
+    ]){
+        // Bail out if it's not a relative file
+        if (!match[1].startsWith(".")) continue;
+        yield* _getModuleDependencies(match[1], base, seen, ext);
+    }
+}
+function getModuleDependencies(absoluteFilePath) {
+    if (absoluteFilePath === null) return new Set();
+    return new Set(_getModuleDependencies(absoluteFilePath, _path.default.dirname(absoluteFilePath), new Set()));
+}

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/load-config.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useCustomJiti: function() {
+        return useCustomJiti;
+    },
+    loadConfig: function() {
+        return loadConfig;
+    }
+});
+const _jiti = /*#__PURE__*/ _interop_require_default(require("jiti"));
+const _sucrase = require("sucrase");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let jiti = null;
+function useCustomJiti(_jiti) {
+    jiti = _jiti();
+}
+function lazyJiti() {
+    return jiti !== null && jiti !== void 0 ? jiti : jiti = (0, _jiti.default)(__filename, {
+        interopDefault: true,
+        transform: (opts)=>{
+            // Sucrase can't transform import.meta so we have to use Babel
+            if (opts.source.includes("import.meta")) {
+                return require("jiti/dist/babel.js")(opts);
+            }
+            return (0, _sucrase.transform)(opts.source, {
+                transforms: [
+                    "typescript",
+                    "imports"
+                ]
+            });
+        }
+    });
+}
+function loadConfig(path) {
+    let config = function() {
+        if (!path) return {};
+        try {
+            return require(path);
+        } catch  {
+            return lazyJiti()(path);
+        }
+    }();
+    var _config_default;
+    return (_config_default = config.default) !== null && _config_default !== void 0 ? _config_default : config;
+}

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/normalizeTailwindDirectives.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return normalizeTailwindDirectives;
+    }
+});
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function normalizeTailwindDirectives(root) {
+    let tailwindDirectives = new Set();
+    let layerDirectives = new Set();
+    let applyDirectives = new Set();
+    root.walkAtRules((atRule)=>{
+        if (atRule.name === "apply") {
+            applyDirectives.add(atRule);
+        }
+        if (atRule.name === "import") {
+            if (atRule.params === '"tailwindcss/base"' || atRule.params === "'tailwindcss/base'") {
+                atRule.name = "tailwind";
+                atRule.params = "base";
+            } else if (atRule.params === '"tailwindcss/components"' || atRule.params === "'tailwindcss/components'") {
+                atRule.name = "tailwind";
+                atRule.params = "components";
+            } else if (atRule.params === '"tailwindcss/utilities"' || atRule.params === "'tailwindcss/utilities'") {
+                atRule.name = "tailwind";
+                atRule.params = "utilities";
+            } else if (atRule.params === '"tailwindcss/screens"' || atRule.params === "'tailwindcss/screens'" || atRule.params === '"tailwindcss/variants"' || atRule.params === "'tailwindcss/variants'") {
+                atRule.name = "tailwind";
+                atRule.params = "variants";
+            }
+        }
+        if (atRule.name === "tailwind") {
+            if (atRule.params === "screens") {
+                atRule.params = "variants";
+            }
+            tailwindDirectives.add(atRule.params);
+        }
+        if ([
+            "layer",
+            "responsive",
+            "variants"
+        ].includes(atRule.name)) {
+            if ([
+                "responsive",
+                "variants"
+            ].includes(atRule.name)) {
+                _log.default.warn(`${atRule.name}-at-rule-deprecated`, [
+                    `The \`@${atRule.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
+                    `Use \`@layer utilities\` or \`@layer components\` instead.`,
+                    "https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer"
+                ]);
+            }
+            layerDirectives.add(atRule);
+        }
+    });
+    if (!tailwindDirectives.has("base") || !tailwindDirectives.has("components") || !tailwindDirectives.has("utilities")) {
+        for (let rule of layerDirectives){
+            if (rule.name === "layer" && [
+                "base",
+                "components",
+                "utilities"
+            ].includes(rule.params)) {
+                if (!tailwindDirectives.has(rule.params)) {
+                    throw rule.error(`\`@layer ${rule.params}\` is used but no matching \`@tailwind ${rule.params}\` directive is present.`);
+                }
+            } else if (rule.name === "responsive") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@responsive` is used but `@tailwind utilities` is missing.");
+                }
+            } else if (rule.name === "variants") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@variants` is used but `@tailwind utilities` is missing.");
+                }
+            }
+        }
+    }
+    return {
+        tailwindDirectives,
+        applyDirectives
+    };
+}

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/offsets.js

@@ -0,0 +1,355 @@
+// @ts-check
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Offsets", {
+    enumerable: true,
+    get: function() {
+        return Offsets;
+    }
+});
+const _bigSign = /*#__PURE__*/ _interop_require_default(require("../util/bigSign"));
+const _remapbitfield = require("./remap-bitfield.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class Offsets {
+    constructor(){
+        /**
+     * Offsets for the next rule in a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.offsets = {
+            defaults: 0n,
+            base: 0n,
+            components: 0n,
+            utilities: 0n,
+            variants: 0n,
+            user: 0n
+        };
+        /**
+     * Positions for a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.layerPositions = {
+            defaults: 0n,
+            base: 1n,
+            components: 2n,
+            utilities: 3n,
+            // There isn't technically a "user" layer, but we need to give it a position
+            // Because it's used for ordering user-css from @apply
+            user: 4n,
+            variants: 5n
+        };
+        /**
+     * The total number of functions currently registered across all variants (including arbitrary variants)
+     *
+     * @type {bigint}
+     */ this.reservedVariantBits = 0n;
+        /**
+     * Positions for a given variant
+     *
+     * @type {Map<string, bigint>}
+     */ this.variantOffsets = new Map();
+    }
+    /**
+   * @param {Layer} layer
+   * @returns {RuleOffset}
+   */ create(layer) {
+        return {
+            layer,
+            parentLayer: layer,
+            arbitrary: 0n,
+            variants: 0n,
+            parallelIndex: 0n,
+            index: this.offsets[layer]++,
+            propertyOffset: 0n,
+            property: "",
+            options: []
+        };
+    }
+    /**
+   * @param {string} name
+   * @returns {RuleOffset}
+   */ arbitraryProperty(name) {
+        return {
+            ...this.create("utilities"),
+            arbitrary: 1n,
+            property: name
+        };
+    }
+    /**
+   * Get the offset for a variant
+   *
+   * @param {string} variant
+   * @param {number} index
+   * @returns {RuleOffset}
+   */ forVariant(variant, index = 0) {
+        let offset = this.variantOffsets.get(variant);
+        if (offset === undefined) {
+            throw new Error(`Cannot find offset for unknown variant ${variant}`);
+        }
+        return {
+            ...this.create("variants"),
+            variants: offset << BigInt(index)
+        };
+    }
+    /**
+   * @param {RuleOffset} rule
+   * @param {RuleOffset} variant
+   * @param {VariantOption} options
+   * @returns {RuleOffset}
+   */ applyVariantOffset(rule, variant, options) {
+        options.variant = variant.variants;
+        return {
+            ...rule,
+            layer: "variants",
+            parentLayer: rule.layer === "variants" ? rule.parentLayer : rule.layer,
+            variants: rule.variants | variant.variants,
+            options: options.sort ? [].concat(options, rule.options) : rule.options,
+            // TODO: Technically this is wrong. We should be handling parallel index on a per variant basis.
+            // We'll take the max of all the parallel indexes for now.
+            // @ts-ignore
+            parallelIndex: max([
+                rule.parallelIndex,
+                variant.parallelIndex
+            ])
+        };
+    }
+    /**
+   * @param {RuleOffset} offset
+   * @param {number} parallelIndex
+   * @returns {RuleOffset}
+   */ applyParallelOffset(offset, parallelIndex) {
+        return {
+            ...offset,
+            parallelIndex: BigInt(parallelIndex)
+        };
+    }
+    /**
+   * Each variant gets 1 bit per function / rule registered.
+   * This is because multiple variants can be applied to a single rule and we need to know which ones are present and which ones are not.
+   * Additionally, every unique group of variants is grouped together in the stylesheet.
+   *
+   * This grouping is order-independent. For instance, we do not differentiate between `hover:focus` and `focus:hover`.
+   *
+   * @param {string[]} variants
+   * @param {(name: string) => number} getLength
+   */ recordVariants(variants, getLength) {
+        for (let variant of variants){
+            this.recordVariant(variant, getLength(variant));
+        }
+    }
+    /**
+   * The same as `recordVariants` but for a single arbitrary variant at runtime.
+   * @param {string} variant
+   * @param {number} fnCount
+   *
+   * @returns {RuleOffset} The highest offset for this variant
+   */ recordVariant(variant, fnCount = 1) {
+        this.variantOffsets.set(variant, 1n << this.reservedVariantBits);
+        // Ensure space is reserved for each "function" in the parallel variant
+        // by offsetting the next variant by the number of parallel variants
+        // in the one we just added.
+        // Single functions that return parallel variants are NOT handled separately here
+        // They're offset by 1 (or the number of functions) as usual
+        // And each rule returned is tracked separately since the functions are evaluated lazily.
+        // @see `RuleOffset.parallelIndex`
+        this.reservedVariantBits += BigInt(fnCount);
+        return {
+            ...this.create("variants"),
+            variants: this.variantOffsets.get(variant)
+        };
+    }
+    /**
+   * @param {RuleOffset} a
+   * @param {RuleOffset} b
+   * @returns {bigint}
+   */ compare(a, b) {
+        // Sort layers together
+        if (a.layer !== b.layer) {
+            return this.layerPositions[a.layer] - this.layerPositions[b.layer];
+        }
+        // When sorting the `variants` layer, we need to sort based on the parent layer as well within
+        // this variants layer.
+        if (a.parentLayer !== b.parentLayer) {
+            return this.layerPositions[a.parentLayer] - this.layerPositions[b.parentLayer];
+        }
+        // Sort based on the sorting function
+        for (let aOptions of a.options){
+            for (let bOptions of b.options){
+                if (aOptions.id !== bOptions.id) continue;
+                if (!aOptions.sort || !bOptions.sort) continue;
+                var _max;
+                let maxFnVariant = (_max = max([
+                    aOptions.variant,
+                    bOptions.variant
+                ])) !== null && _max !== void 0 ? _max : 0n;
+                // Create a mask of 0s from bits 1..N where N represents the mask of the Nth bit
+                let mask = ~(maxFnVariant | maxFnVariant - 1n);
+                let aVariantsAfterFn = a.variants & mask;
+                let bVariantsAfterFn = b.variants & mask;
+                // If the variants the same, we _can_ sort them
+                if (aVariantsAfterFn !== bVariantsAfterFn) {
+                    continue;
+                }
+                let result = aOptions.sort({
+                    value: aOptions.value,
+                    modifier: aOptions.modifier
+                }, {
+                    value: bOptions.value,
+                    modifier: bOptions.modifier
+                });
+                if (result !== 0) return result;
+            }
+        }
+        // Sort variants in the order they were registered
+        if (a.variants !== b.variants) {
+            return a.variants - b.variants;
+        }
+        // Make sure each rule returned by a parallel variant is sorted in ascending order
+        if (a.parallelIndex !== b.parallelIndex) {
+            return a.parallelIndex - b.parallelIndex;
+        }
+        // Always sort arbitrary properties after other utilities
+        if (a.arbitrary !== b.arbitrary) {
+            return a.arbitrary - b.arbitrary;
+        }
+        // Always sort arbitrary properties alphabetically
+        if (a.propertyOffset !== b.propertyOffset) {
+            return a.propertyOffset - b.propertyOffset;
+        }
+        // Sort utilities, components, etc… in the order they were registered
+        return a.index - b.index;
+    }
+    /**
+   * Arbitrary variants are recorded in the order they're encountered.
+   * This means that the order is not stable between environments and sets of content files.
+   *
+   * In order to make the order stable, we need to remap the arbitrary variant offsets to
+   * be in alphabetical order starting from the offset of the first arbitrary variant.
+   */ recalculateVariantOffsets() {
+        // Sort the variants by their name
+        let variants = Array.from(this.variantOffsets.entries()).filter(([v])=>v.startsWith("[")).sort(([a], [z])=>fastCompare(a, z));
+        // Sort the list of offsets
+        // This is not necessarily a discrete range of numbers which is why
+        // we're using sort instead of creating a range from min/max
+        let newOffsets = variants.map(([, offset])=>offset).sort((a, z)=>(0, _bigSign.default)(a - z));
+        // Create a map from the old offsets to the new offsets in the new sort order
+        /** @type {[bigint, bigint][]} */ let mapping = variants.map(([, oldOffset], i)=>[
+                oldOffset,
+                newOffsets[i]
+            ]);
+        // Remove any variants that will not move letting us skip
+        // remapping if everything happens to be in order
+        return mapping.filter(([a, z])=>a !== z);
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ remapArbitraryVariantOffsets(list) {
+        let mapping = this.recalculateVariantOffsets();
+        // No arbitrary variants? Nothing to do.
+        // Everyhing already in order? Nothing to do.
+        if (mapping.length === 0) {
+            return list;
+        }
+        // Remap every variant offset in the list
+        return list.map((item)=>{
+            let [offset, rule] = item;
+            offset = {
+                ...offset,
+                variants: (0, _remapbitfield.remapBitfield)(offset.variants, mapping)
+            };
+            return [
+                offset,
+                rule
+            ];
+        });
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ sortArbitraryProperties(list) {
+        // Collect all known arbitrary properties
+        let known = new Set();
+        for (let [offset] of list){
+            if (offset.arbitrary === 1n) {
+                known.add(offset.property);
+            }
+        }
+        // No arbitrary properties? Nothing to do.
+        if (known.size === 0) {
+            return list;
+        }
+        // Sort the properties alphabetically
+        let properties = Array.from(known).sort();
+        // Create a map from the property name to its offset
+        let offsets = new Map();
+        let offset = 1n;
+        for (let property of properties){
+            offsets.set(property, offset++);
+        }
+        // Apply the sorted offsets to the list
+        return list.map((item)=>{
+            let [offset, rule] = item;
+            var _offsets_get;
+            offset = {
+                ...offset,
+                propertyOffset: (_offsets_get = offsets.get(offset.property)) !== null && _offsets_get !== void 0 ? _offsets_get : 0n
+            };
+            return [
+                offset,
+                rule
+            ];
+        });
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ sort(list) {
+        // Sort arbitrary variants so they're in alphabetical order
+        list = this.remapArbitraryVariantOffsets(list);
+        // Sort arbitrary properties so they're in alphabetical order
+        list = this.sortArbitraryProperties(list);
+        return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
+    }
+}
+/**
+ *
+ * @param {bigint[]} nums
+ * @returns {bigint|null}
+ */ function max(nums) {
+    let max = null;
+    for (const num of nums){
+        max = max !== null && max !== void 0 ? max : num;
+        max = max > num ? max : num;
+    }
+    return max;
+}
+/**
+ * A fast ASCII order string comparison function.
+ *
+ * Using `.sort()` without a custom compare function is faster
+ * But you can only use that if you're sorting an array of
+ * only strings. If you're sorting strings inside objects
+ * or arrays, you need must use a custom compare function.
+ *
+ * @param {string} a
+ * @param {string} b
+ */ function fastCompare(a, b) {
+    let aLen = a.length;
+    let bLen = b.length;
+    let minLen = aLen < bLen ? aLen : bLen;
+    for(let i = 0; i < minLen; i++){
+        let cmp = a.charCodeAt(i) - b.charCodeAt(i);
+        if (cmp !== 0) return cmp;
+    }
+    return aLen - bLen;
+}

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/partitionApplyAtRules.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return expandApplyAtRules;
+    }
+});
+function partitionRules(root) {
+    if (!root.walkAtRules) return;
+    let applyParents = new Set();
+    root.walkAtRules("apply", (rule)=>{
+        applyParents.add(rule.parent);
+    });
+    if (applyParents.size === 0) {
+        return;
+    }
+    for (let rule of applyParents){
+        let nodeGroups = [];
+        let lastGroup = [];
+        for (let node of rule.nodes){
+            if (node.type === "atrule" && node.name === "apply") {
+                if (lastGroup.length > 0) {
+                    nodeGroups.push(lastGroup);
+                    lastGroup = [];
+                }
+                nodeGroups.push([
+                    node
+                ]);
+            } else {
+                lastGroup.push(node);
+            }
+        }
+        if (lastGroup.length > 0) {
+            nodeGroups.push(lastGroup);
+        }
+        if (nodeGroups.length === 1) {
+            continue;
+        }
+        for (let group of [
+            ...nodeGroups
+        ].reverse()){
+            let clone = rule.clone({
+                nodes: []
+            });
+            clone.append(group);
+            rule.after(clone);
+        }
+        rule.remove();
+    }
+}
+function expandApplyAtRules() {
+    return (root)=>{
+        partitionRules(root);
+    };
+}