@blotch/rsbuild-plugin-angular-lynx 22.2.6 → 22.2.7

package/README.md

@@ -36,6 +36,7 @@ export default defineConfig({
 - Runs Tailwind CSS 3 from a `tailwind.config.*`, and rewrites the CSS Tailwind CSS 4 writes (layers, `@property`, nesting, `oklch()` and `color-mix()`, logical properties, `translate`/`rotate`/`scale`) into CSS Lynx reads, for the device and the web preview alike. See [Tailwind CSS](https://angularlynx.js.org/guide/tailwindcss)
 - Registers `CUSTOM_ELEMENTS_SCHEMA` so Angular accepts Lynx elements (`<view>`, `<text>`, etc.)
 - Enforces the build target's `budgets` with `ng build`'s units and messages: a warning is printed, an error fails the build
+- Applies the build target's `fileReplacements`, as Angular's builders do: both threads' bundles are built from each `with` file instead of its `replace` file, and a watch build rebuilds when it changes
 
 ## Budgets
 

package/dist/file-replacements.d.ts

@@ -0,0 +1,25 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+/**
+ * Swaps each of angular.json's `fileReplacements` into the bundle: a module
+ * that resolves to a `replace` file is built from its `with` file instead.
+ *
+ * Angular's compiler host only redirects TypeScript's module resolution (see
+ * `fileReplacements` in angular.ts), so the compiled program type-checks and
+ * emits the `with` file. The compiled code still imports the `replace` path,
+ * though, and the bundler resolves imports itself. Angular's own builders
+ * redirect them too: the esbuild one when it loads the module (TypeScript,
+ * JavaScript and JSON files), and the webpack one, which this mirrors, with a
+ * `NormalModuleReplacementPlugin` for each replacement.
+ *
+ * Replacing the module rather than its contents makes rspack treat the `with`
+ * file as the module: its own imports resolve from its folder, wherever it is
+ * (`../common/environments/environment.prod.ts`), the loader finds its
+ * compiled output, and a watch build rebuilds when it changes. Every
+ * environment gets the plugins, and every module request goes through them,
+ * so both threads' bundles and the generated background entry get the `with`
+ * file.
+ *
+ * @param fileReplacements - The `replace` files' absolute paths, mapped to
+ *   their `with` files' (`normalizeBuildOptions`).
+ */
+export declare const applyFileReplacements: (api: Pick<RsbuildPluginAPI, "modifyBundlerChain">, fileReplacements: Readonly<Record<string, string>> | undefined) => void;

package/dist/file-replacements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -638,6 +638,17 @@ const applyBudgets = (api, { budgets, componentStyleSizes, underAngularCli })=>{
         ]);
     });
 };
+const file_replacements_PLUGIN_NAME = 'lynx:angular:file-replacement';
+const exactPath = (file)=>new RegExp(`^${file.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&')}$`);
+const applyFileReplacements = (api, fileReplacements)=>{
+    if (!fileReplacements) return;
+    api.modifyBundlerChain((chain, { rspack })=>{
+        for (const [replace, replacement] of Object.entries(fileReplacements))chain.plugin(`${file_replacements_PLUGIN_NAME}:${replace}`).use(rspack.NormalModuleReplacementPlugin, [
+            exactPath(replace),
+            replacement
+        ]);
+    });
+};
 const injectLynxSchema = (source)=>{
     if (source.includes('CUSTOM_ELEMENTS_SCHEMA') || source.includes('NO_ERRORS_SCHEMA')) return source;
     const importLine = `import { CUSTOM_ELEMENTS_SCHEMA as __LynxCES__ } from '@angular/core';\n`;
@@ -1719,6 +1730,7 @@ const applyAngularRules = async (api, pluginOptions, backgroundEntries, appEntri
         cli
     });
     applyAngularConfig(api, buildOptions);
+    applyFileReplacements(api, buildOptions.fileReplacements);
     const componentStyleSizes = new Map();
     applyBudgets(api, {
         budgets: buildOptions.budgets,
@@ -1771,6 +1783,7 @@ const applyAngularRules = async (api, pluginOptions, backgroundEntries, appEntri
             result = await compilation.initialize(tsconfig, {
                 processWebWorker: (workerFile, _containingFile)=>workerFile,
                 transformStylesheet,
+                fileReplacements: buildOptions.fileReplacements,
                 modifiedFiles: changedFiles && new Set([
                     ...changedFiles
                 ].filter((file)=>!seededFiles.has(file)))

package/dist/polyfills.js

@@ -1,3 +1,1147 @@
+const definePolyfillOverride = (target, name, value)=>{
+    Object.defineProperty(target, name, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+};
+const definePolyfill = (target, name, value)=>{
+    if (target && 'function' != typeof target[name]) definePolyfillOverride(target, name, value);
+};
+const definePolyfills = (target, methods)=>{
+    for (const name of Object.keys(methods))definePolyfill(target, name, methods[name]);
+};
+const isObject = (value)=>'object' == typeof value && null !== value || 'function' == typeof value;
+const requireCallable = (value)=>{
+    if ('function' != typeof value) throw new TypeError('Expected a function');
+    return value;
+};
+const toObject = (value)=>{
+    if (null == value) throw new TypeError('Cannot convert undefined or null to object');
+    return Object(value);
+};
+const toThisString = (value)=>String(toObject(value));
+const toIntegerOrInfinity = (value)=>Math.trunc(+value) || 0;
+const lengthOf = (object)=>Math.min(Math.max(toIntegerOrInfinity(object.length), 0), Number.MAX_SAFE_INTEGER);
+const isConstructor = (value)=>{
+    if ('function' != typeof value) return false;
+    try {
+        Reflect.construct(String, [], value);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const createDataProperty = (object, key, value)=>{
+    Object.defineProperty(object, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+    });
+};
+const iteratorRecord = (iterator)=>({
+        iterator,
+        next: iterator.next
+    });
+const DONE = {};
+const stepValue = (record)=>{
+    const result = record.next.call(record.iterator);
+    if (!isObject(result)) throw new TypeError('Iterator result is not an object');
+    return result.done ? DONE : result.value;
+};
+const closeIterator = (iterator)=>{
+    const method = iterator.return;
+    if (null == method) return;
+    if (!isObject(requireCallable(method).call(iterator))) throw new TypeError('Iterator result is not an object');
+};
+const closeAndThrow = (iterator, error)=>{
+    try {
+        const method = iterator.return;
+        if (null != method) method.call(iterator);
+    } catch  {}
+    throw error;
+};
+const relativeIndex = (object, index)=>{
+    const length = lengthOf(object);
+    let n = toIntegerOrInfinity(index);
+    if (n < 0) n += length;
+    if (n < 0 || n >= length) return;
+    return 'string' == typeof object ? object.charAt(n) : object[n];
+};
+const requireComparator = (comparator)=>{
+    if (void 0 !== comparator && 'function' != typeof comparator) throw new TypeError('The comparison function must be a function');
+};
+const createArray = (length)=>{
+    const array = [];
+    array.length = length;
+    return array;
+};
+const copyArrayLike = (object, length)=>{
+    const copy = createArray(length);
+    for(let index = 0; index < length; index++)copy[index] = object[index];
+    return copy;
+};
+const actualIndex = (index, length)=>{
+    const relative = toIntegerOrInfinity(index);
+    const actual = relative < 0 ? length + relative : relative;
+    if (actual < 0 || actual >= length) throw new RangeError('Invalid index');
+    return actual;
+};
+definePolyfills(Array.prototype, {
+    at (index) {
+        return relativeIndex(toObject(this), index);
+    },
+    findLast (predicate) {
+        const object = toObject(this);
+        const length = lengthOf(object);
+        requireCallable(predicate);
+        const thisArg = arguments[1];
+        for(let index = length - 1; index >= 0; index--){
+            const value = object[index];
+            if (predicate.call(thisArg, value, index, object)) return value;
+        }
+    },
+    findLastIndex (predicate) {
+        const object = toObject(this);
+        const length = lengthOf(object);
+        requireCallable(predicate);
+        const thisArg = arguments[1];
+        for(let index = length - 1; index >= 0; index--)if (predicate.call(thisArg, object[index], index, object)) return index;
+        return -1;
+    },
+    toReversed () {
+        const object = toObject(this);
+        const length = lengthOf(object);
+        const result = createArray(length);
+        for(let index = 0; index < length; index++)result[index] = object[length - 1 - index];
+        return result;
+    },
+    toSorted (comparator) {
+        requireComparator(comparator);
+        const object = toObject(this);
+        return copyArrayLike(object, lengthOf(object)).sort(comparator);
+    },
+    toSpliced (start, skipCount) {
+        const object = toObject(this);
+        const length = lengthOf(object);
+        const relativeStart = toIntegerOrInfinity(start);
+        const actualStart = relativeStart < 0 ? Math.max(length + relativeStart, 0) : Math.min(relativeStart, length);
+        const actualSkipCount = 0 === arguments.length ? 0 : 1 === arguments.length ? length - actualStart : Math.min(Math.max(toIntegerOrInfinity(skipCount), 0), length - actualStart);
+        const newLength = length + Math.max(arguments.length - 2, 0) - actualSkipCount;
+        if (newLength > Number.MAX_SAFE_INTEGER) throw new TypeError('Invalid array length');
+        const result = createArray(newLength);
+        let to = 0;
+        for(let from = 0; from < actualStart; from++)result[to++] = object[from];
+        for(let item = 2; item < arguments.length; item++)result[to++] = arguments[item];
+        for(let from = actualStart + actualSkipCount; from < length; from++)result[to++] = object[from];
+        return result;
+    },
+    with (index, value) {
+        const object = toObject(this);
+        const length = lengthOf(object);
+        const actual = actualIndex(index, length);
+        const result = createArray(length);
+        for(let k = 0; k < length; k++)result[k] = k === actual ? value : object[k];
+        return result;
+    }
+});
+const TypedArrayPrototype = 'function' == typeof Int8Array ? Object.getPrototypeOf(Int8Array.prototype) : void 0;
+const typedArrayName = TypedArrayPrototype && Object.getOwnPropertyDescriptor(TypedArrayPrototype, Symbol.toStringTag).get;
+const typedArrayLength = TypedArrayPrototype && Object.getOwnPropertyDescriptor(TypedArrayPrototype, 'length').get;
+const typedArrayKind = (value)=>{
+    const name = typedArrayName.call(value);
+    if (void 0 === name) throw new TypeError('Expected a typed array');
+    return globalThis[name];
+};
+if (TypedArrayPrototype) definePolyfills(TypedArrayPrototype, {
+    at (index) {
+        typedArrayKind(this);
+        return relativeIndex(this, index);
+    },
+    toReversed () {
+        const Kind = typedArrayKind(this);
+        const length = typedArrayLength.call(this);
+        const result = new Kind(length);
+        for(let index = 0; index < length; index++)result[index] = this[length - 1 - index];
+        return result;
+    },
+    toSorted (comparator) {
+        requireComparator(comparator);
+        const Kind = typedArrayKind(this);
+        const length = typedArrayLength.call(this);
+        const result = new Kind(length);
+        for(let index = 0; index < length; index++)result[index] = this[index];
+        return result.sort(comparator);
+    },
+    with (index, value) {
+        const Kind = typedArrayKind(this);
+        const length = typedArrayLength.call(this);
+        const relative = toIntegerOrInfinity(index);
+        const actual = relative < 0 ? length + relative : relative;
+        const converted = new Kind(1);
+        converted[0] = value;
+        if (actual < 0 || actual >= length) throw new RangeError('Invalid index');
+        const result = new Kind(length);
+        for(let k = 0; k < length; k++)result[k] = k === actual ? converted[0] : this[k];
+        return result;
+    }
+});
+const loneSurrogateIndex = (string, from)=>{
+    for(let index = from; index < string.length; index++){
+        const code = string.charCodeAt(index);
+        if (!(code < 0xd800) && !(code > 0xdfff)) {
+            if (code <= 0xdbff) {
+                const next = string.charCodeAt(index + 1);
+                if (next >= 0xdc00 && next <= 0xdfff) {
+                    index++;
+                    continue;
+                }
+            }
+            return index;
+        }
+    }
+    return -1;
+};
+definePolyfills(String.prototype, {
+    at (index) {
+        return relativeIndex(toThisString(this), index);
+    },
+    isWellFormed () {
+        return -1 === loneSurrogateIndex(toThisString(this), 0);
+    },
+    toWellFormed () {
+        const string = toThisString(this);
+        let result = '';
+        let start = 0;
+        for(let index = loneSurrogateIndex(string, 0); -1 !== index; index = loneSurrogateIndex(string, start)){
+            result += string.slice(start, index) + '\uFFFD';
+            start = index + 1;
+        }
+        return result + string.slice(start);
+    },
+    replaceAll (search, replacement) {
+        const subject = toThisString(this);
+        if (search instanceof RegExp) {
+            if (!search.global) throw new TypeError('replaceAll must be called with a global RegExp');
+            return subject.replace(search, replacement);
+        }
+        const pattern = new RegExp(String(search).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+        return subject.replace(pattern, replacement);
+    }
+});
+const groupItems = (items, callback, add)=>{
+    if (null == items) throw new TypeError('Cannot group undefined or null');
+    requireCallable(callback);
+    let index = 0;
+    for (const item of items)add(callback(item, index++), item);
+};
+definePolyfills(Object, {
+    groupBy (items, callback) {
+        const groups = Object.create(null);
+        groupItems(items, callback, (key, item)=>{
+            const property = 'symbol' == typeof key ? key : String(key);
+            const group = groups[property];
+            if (group) group.push(item);
+            else groups[property] = [
+                item
+            ];
+        });
+        return groups;
+    },
+    hasOwn (object, key) {
+        return Object.prototype.hasOwnProperty.call(toObject(object), key);
+    }
+});
+definePolyfills(Map, {
+    groupBy (items, callback) {
+        const groups = new Map();
+        groupItems(items, callback, (key, item)=>{
+            const group = groups.get(key);
+            if (group) group.push(item);
+            else groups.set(key, [
+                item
+            ]);
+        });
+        return groups;
+    }
+});
+const promiseCapability = (Constructor)=>{
+    let resolve;
+    let reject;
+    const promise = new Constructor((resolveFn, rejectFn)=>{
+        resolve = resolveFn;
+        reject = rejectFn;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+};
+definePolyfills(Promise, {
+    allSettled (promises) {
+        return this.all(Array.from(promises, (promise)=>this.resolve(promise).then((value)=>({
+                    status: 'fulfilled',
+                    value
+                }), (reason)=>({
+                    status: 'rejected',
+                    reason
+                }))));
+    },
+    any (promises) {
+        const capability = promiseCapability(this);
+        try {
+            const resolve = requireCallable(this.resolve);
+            const errors = [];
+            let remaining = 1;
+            const rejectIfAllRejected = ()=>{
+                if (0 === --remaining) capability.reject(new AggregateError(errors, 'All promises were rejected'));
+            };
+            for (const promise of promises){
+                const index = errors.length;
+                errors.push(void 0);
+                remaining++;
+                let rejected = false;
+                resolve.call(this, promise).then(capability.resolve, (error)=>{
+                    if (rejected) return;
+                    rejected = true;
+                    errors[index] = error;
+                    rejectIfAllRejected();
+                });
+            }
+            rejectIfAllRejected();
+        } catch (error) {
+            capability.reject(error);
+        }
+        return capability.promise;
+    },
+    withResolvers () {
+        return promiseCapability(this);
+    },
+    try (callback, ...args) {
+        const capability = promiseCapability(this);
+        let value;
+        try {
+            value = callback(...args);
+        } catch (error) {
+            capability.reject(error);
+            return capability.promise;
+        }
+        capability.resolve(value);
+        return capability.promise;
+    }
+});
+const fromAsync = async (Constructor, items, mapper, thisArg)=>{
+    if (void 0 !== mapper) requireCallable(mapper);
+    const isAsync = null != items[Symbol.asyncIterator];
+    if (isAsync || null != items[Symbol.iterator]) {
+        const result = isConstructor(Constructor) ? new Constructor() : [];
+        let index = 0;
+        const add = async (value)=>{
+            createDataProperty(result, index, void 0 === mapper ? value : await mapper.call(thisArg, value, index));
+            index++;
+        };
+        if (isAsync) for await (const value of items)await add(value);
+        else for (const value of items)await add(await value);
+        result.length = index;
+        return result;
+    }
+    const arrayLike = Object(items);
+    const length = lengthOf(arrayLike);
+    const result = isConstructor(Constructor) ? new Constructor(length) : createArray(length);
+    for(let index = 0; index < length; index++){
+        const value = await arrayLike[index];
+        createDataProperty(result, index, void 0 === mapper ? value : await mapper.call(thisArg, value, index));
+    }
+    result.length = length;
+    return result;
+};
+definePolyfills(Array, {
+    fromAsync (items) {
+        return fromAsync(this, items, arguments[1], arguments[2]);
+    }
+});
+const setSize = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get;
+const setHas = Set.prototype.has;
+const setAdd = Set.prototype.add;
+const setDelete = Set.prototype.delete;
+const setValues = Set.prototype.values;
+const getSetRecord = (other)=>{
+    if (!isObject(other)) throw new TypeError('Expected a set-like object');
+    const size = +other.size;
+    if (size !== size) throw new TypeError("The set-like's size is not a number");
+    const integerSize = toIntegerOrInfinity(size);
+    if (integerSize < 0) throw new RangeError("The set-like's size is negative");
+    const has = requireCallable(other.has);
+    const keys = requireCallable(other.keys);
+    return {
+        set: other,
+        size: integerSize,
+        has,
+        keys
+    };
+};
+const copySet = (set)=>{
+    const copy = new Set();
+    for (const value of setValues.call(set))setAdd.call(copy, value);
+    return copy;
+};
+const keysOf = (record)=>{
+    const iterator = record.keys.call(record.set);
+    if (!isObject(iterator)) throw new TypeError('keys() must return an object');
+    return iteratorRecord(iterator);
+};
+const someKey = (keys, visit)=>{
+    for(let key = stepValue(keys); key !== DONE; key = stepValue(keys))if (visit(0 === key ? 0 : key)) {
+        closeIterator(keys.iterator);
+        return true;
+    }
+    return false;
+};
+definePolyfills(Set.prototype, {
+    union (other) {
+        setSize.call(this);
+        const keys = keysOf(getSetRecord(other));
+        const result = copySet(this);
+        someKey(keys, (key)=>{
+            setAdd.call(result, key);
+        });
+        return result;
+    },
+    intersection (other) {
+        const size = setSize.call(this);
+        const record = getSetRecord(other);
+        const result = new Set();
+        if (size <= record.size) {
+            for (const value of setValues.call(this))if (record.has.call(record.set, value)) setAdd.call(result, value);
+        } else someKey(keysOf(record), (key)=>{
+            if (setHas.call(this, key)) setAdd.call(result, key);
+        });
+        return result;
+    },
+    difference (other) {
+        const size = setSize.call(this);
+        const record = getSetRecord(other);
+        const result = copySet(this);
+        if (size <= record.size) {
+            for (const value of setValues.call(result))if (record.has.call(record.set, value)) setDelete.call(result, value);
+        } else someKey(keysOf(record), (key)=>{
+            setDelete.call(result, key);
+        });
+        return result;
+    },
+    symmetricDifference (other) {
+        setSize.call(this);
+        const keys = keysOf(getSetRecord(other));
+        const result = copySet(this);
+        someKey(keys, (key)=>{
+            if (setHas.call(this, key)) setDelete.call(result, key);
+            else setAdd.call(result, key);
+        });
+        return result;
+    },
+    isSubsetOf (other) {
+        const size = setSize.call(this);
+        const record = getSetRecord(other);
+        if (size > record.size) return false;
+        for (const value of setValues.call(this))if (!record.has.call(record.set, value)) return false;
+        return true;
+    },
+    isSupersetOf (other) {
+        const size = setSize.call(this);
+        const record = getSetRecord(other);
+        if (size < record.size) return false;
+        return !someKey(keysOf(record), (key)=>!setHas.call(this, key));
+    },
+    isDisjointFrom (other) {
+        const size = setSize.call(this);
+        const record = getSetRecord(other);
+        if (size <= record.size) {
+            for (const value of setValues.call(this))if (record.has.call(record.set, value)) return false;
+            return true;
+        }
+        return !someKey(keysOf(record), (key)=>setHas.call(this, key));
+    }
+});
+const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+const iteratorOrIterable = (value, allowStrings)=>{
+    if (!isObject(value) && !(allowStrings && 'string' == typeof value)) throw new TypeError('Expected an iterator or an iterable');
+    const method = value[Symbol.iterator];
+    const iterator = null == method ? value : requireCallable(method).call(value);
+    if (!isObject(iterator)) throw new TypeError('Expected an iterator');
+    return iteratorRecord(iterator);
+};
+const IteratorHelperPrototype = Object.create(IteratorPrototype);
+const helperStates = new WeakMap();
+const createHelper = (step, close)=>{
+    const helper = Object.create(IteratorHelperPrototype);
+    helperStates.set(helper, {
+        step,
+        close,
+        running: false,
+        done: false
+    });
+    return helper;
+};
+const helperState = (helper)=>{
+    const state = helperStates.get(helper);
+    if (!state) throw new TypeError('Expected an Iterator Helper');
+    if (state.running) throw new TypeError('Iterator Helper is already running');
+    return state;
+};
+definePolyfills(IteratorHelperPrototype, {
+    next () {
+        const state = helperState(this);
+        if (state.done) return {
+            value: void 0,
+            done: true
+        };
+        state.running = true;
+        let value;
+        try {
+            value = state.step();
+        } catch (error) {
+            state.done = true;
+            throw error;
+        } finally{
+            state.running = false;
+        }
+        if (value === DONE) {
+            state.done = true;
+            return {
+                value: void 0,
+                done: true
+            };
+        }
+        return {
+            value,
+            done: false
+        };
+    },
+    return () {
+        const state = helperState(this);
+        if (!state.done) {
+            state.done = true;
+            state.close();
+        }
+        return {
+            value: void 0,
+            done: true
+        };
+    }
+});
+Object.defineProperty(IteratorHelperPrototype, Symbol.toStringTag, {
+    value: 'Iterator Helper',
+    configurable: true
+});
+const thisIterator = (value)=>{
+    if (!isObject(value)) throw new TypeError('Expected an iterator object');
+    return value;
+};
+const callableOrClose = (iterator, value)=>{
+    if ('function' != typeof value) closeAndThrow(iterator, new TypeError('Expected a function'));
+};
+const limitOrClose = (iterator, limit)=>{
+    let number;
+    try {
+        number = +limit;
+    } catch (error) {
+        closeAndThrow(iterator, error);
+    }
+    const integer = toIntegerOrInfinity(number);
+    if (number !== number || integer < 0) closeAndThrow(iterator, new RangeError('Expected a non-negative limit'));
+    return integer;
+};
+const findMatch = (receiver, predicate, wanted)=>{
+    const iterator = thisIterator(receiver);
+    callableOrClose(iterator, predicate);
+    const record = iteratorRecord(iterator);
+    let counter = 0;
+    for(let value = stepValue(record); value !== DONE; value = stepValue(record)){
+        let result;
+        try {
+            result = predicate(value, counter++);
+        } catch (error) {
+            closeAndThrow(iterator, error);
+        }
+        if (!!result === wanted) {
+            closeIterator(iterator);
+            return {
+                value
+            };
+        }
+    }
+};
+definePolyfills(IteratorPrototype, {
+    map (mapper) {
+        const iterator = thisIterator(this);
+        callableOrClose(iterator, mapper);
+        const record = iteratorRecord(iterator);
+        let counter = 0;
+        return createHelper(()=>{
+            const value = stepValue(record);
+            if (value === DONE) return DONE;
+            try {
+                return mapper(value, counter++);
+            } catch (error) {
+                closeAndThrow(iterator, error);
+            }
+        }, ()=>closeIterator(iterator));
+    },
+    filter (predicate) {
+        const iterator = thisIterator(this);
+        callableOrClose(iterator, predicate);
+        const record = iteratorRecord(iterator);
+        let counter = 0;
+        return createHelper(()=>{
+            for(;;){
+                const value = stepValue(record);
+                if (value === DONE) return DONE;
+                let selected;
+                try {
+                    selected = predicate(value, counter++);
+                } catch (error) {
+                    closeAndThrow(iterator, error);
+                }
+                if (selected) return value;
+            }
+        }, ()=>closeIterator(iterator));
+    },
+    take (limit) {
+        const iterator = thisIterator(this);
+        let remaining = limitOrClose(iterator, limit);
+        const record = iteratorRecord(iterator);
+        return createHelper(()=>{
+            if (0 === remaining) {
+                closeIterator(iterator);
+                return DONE;
+            }
+            if (remaining !== 1 / 0) remaining--;
+            return stepValue(record);
+        }, ()=>closeIterator(iterator));
+    },
+    drop (limit) {
+        const iterator = thisIterator(this);
+        let remaining = limitOrClose(iterator, limit);
+        const record = iteratorRecord(iterator);
+        return createHelper(()=>{
+            while(remaining > 0){
+                if (remaining !== 1 / 0) remaining--;
+                if (stepValue(record) === DONE) return DONE;
+            }
+            return stepValue(record);
+        }, ()=>closeIterator(iterator));
+    },
+    flatMap (mapper) {
+        const iterator = thisIterator(this);
+        callableOrClose(iterator, mapper);
+        const record = iteratorRecord(iterator);
+        let counter = 0;
+        let inner;
+        return createHelper(()=>{
+            for(;;){
+                if (inner) {
+                    let value;
+                    try {
+                        value = stepValue(inner);
+                    } catch (error) {
+                        closeAndThrow(iterator, error);
+                    }
+                    if (value !== DONE) return value;
+                    inner = void 0;
+                }
+                const value = stepValue(record);
+                if (value === DONE) return DONE;
+                try {
+                    inner = iteratorOrIterable(mapper(value, counter++), false);
+                } catch (error) {
+                    closeAndThrow(iterator, error);
+                }
+            }
+        }, ()=>{
+            if (inner) try {
+                closeIterator(inner.iterator);
+            } catch (error) {
+                closeAndThrow(iterator, error);
+            }
+            closeIterator(iterator);
+        });
+    },
+    reduce (reducer) {
+        const iterator = thisIterator(this);
+        callableOrClose(iterator, reducer);
+        const record = iteratorRecord(iterator);
+        let accumulator;
+        let counter = 0;
+        if (arguments.length < 2) {
+            accumulator = stepValue(record);
+            if (accumulator === DONE) throw new TypeError('Reduce of empty iterator with no initial value');
+            counter = 1;
+        } else accumulator = arguments[1];
+        for(let value = stepValue(record); value !== DONE; value = stepValue(record))try {
+            accumulator = reducer(accumulator, value, counter++);
+        } catch (error) {
+            closeAndThrow(iterator, error);
+        }
+        return accumulator;
+    },
+    toArray () {
+        const record = iteratorRecord(thisIterator(this));
+        const items = [];
+        for(let value = stepValue(record); value !== DONE; value = stepValue(record))items.push(value);
+        return items;
+    },
+    forEach (callback) {
+        const iterator = thisIterator(this);
+        callableOrClose(iterator, callback);
+        const record = iteratorRecord(iterator);
+        let counter = 0;
+        for(let value = stepValue(record); value !== DONE; value = stepValue(record))try {
+            callback(value, counter++);
+        } catch (error) {
+            closeAndThrow(iterator, error);
+        }
+    },
+    some (predicate) {
+        return void 0 !== findMatch(this, predicate, true);
+    },
+    every (predicate) {
+        return void 0 === findMatch(this, predicate, false);
+    },
+    find (predicate) {
+        const match = findMatch(this, predicate, true);
+        return void 0 === match ? void 0 : match.value;
+    }
+});
+if ('function' != typeof globalThis.Iterator) {
+    const Iterator = function Iterator() {
+        if (new.target === void 0 || new.target === Iterator) throw new TypeError('Abstract class Iterator not directly constructable');
+    };
+    Object.defineProperty(Iterator, 'prototype', {
+        value: IteratorPrototype,
+        writable: false
+    });
+    definePolyfillOverride(IteratorPrototype, 'constructor', Iterator);
+    definePolyfillOverride(IteratorPrototype, Symbol.toStringTag, 'Iterator');
+    definePolyfillOverride(globalThis, 'Iterator', Iterator);
+}
+const WrapForValidIteratorPrototype = Object.create(IteratorPrototype);
+const wrappedRecords = new WeakMap();
+const wrappedRecord = (wrapper)=>{
+    const record = wrappedRecords.get(wrapper);
+    if (!record) throw new TypeError('Expected an iterator from Iterator.from');
+    return record;
+};
+definePolyfills(WrapForValidIteratorPrototype, {
+    next () {
+        const record = wrappedRecord(this);
+        return record.next.call(record.iterator);
+    },
+    return () {
+        const { iterator } = wrappedRecord(this);
+        const method = iterator.return;
+        if (null == method) return {
+            value: void 0,
+            done: true
+        };
+        return requireCallable(method).call(iterator);
+    }
+});
+definePolyfills(globalThis.Iterator, {
+    from (value) {
+        const record = iteratorOrIterable(value, true);
+        if (IteratorPrototype.isPrototypeOf(record.iterator)) return record.iterator;
+        const wrapper = Object.create(WrapForValidIteratorPrototype);
+        wrappedRecords.set(wrapper, record);
+        return wrapper;
+    },
+    concat () {
+        const iterables = [];
+        for(let index = 0; index < arguments.length; index++){
+            const iterable = arguments[index];
+            if (!isObject(iterable)) throw new TypeError('Expected an iterable');
+            iterables.push({
+                iterable,
+                open: requireCallable(iterable[Symbol.iterator])
+            });
+        }
+        let position = 0;
+        let current;
+        return createHelper(()=>{
+            for(;;){
+                if (!current) {
+                    if (position === iterables.length) return DONE;
+                    const { iterable, open } = iterables[position++];
+                    const iterator = open.call(iterable);
+                    if (!isObject(iterator)) throw new TypeError('Expected an iterator');
+                    current = iteratorRecord(iterator);
+                }
+                const value = stepValue(current);
+                if (value !== DONE) return value;
+                current = void 0;
+            }
+        }, ()=>{
+            if (current) closeIterator(current.iterator);
+        });
+    }
+});
+const CONTROL_ESCAPES = {
+    '\t': 't',
+    '\n': 'n',
+    '\v': 'v',
+    '\f': 'f',
+    '\r': 'r'
+};
+const hexEscape = (code, digits)=>(2 === digits ? '\\x' : '\\u') + code.toString(16).padStart(digits, '0');
+definePolyfills(RegExp, {
+    escape (string) {
+        if ('string' != typeof string) throw new TypeError('Expected a string');
+        let escaped = '';
+        for (const char of string){
+            const code = char.codePointAt(0);
+            if ('' === escaped && /[0-9A-Za-z]/.test(char)) escaped += hexEscape(code, 2);
+            else if ('^$\\.*+?()[]{}|/'.includes(char)) escaped += '\\' + char;
+            else if (char in CONTROL_ESCAPES) escaped += '\\' + CONTROL_ESCAPES[char];
+            else if (',-=<>#&!%:;@~\'`"'.includes(char) || /[ \u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/.test(char) || code >= 0xd800 && code <= 0xdfff) escaped += code <= 0xff ? hexEscape(code, 2) : hexEscape(code, 4);
+            else escaped += char;
+        }
+        return escaped;
+    }
+});
+const roundHalfEven = (value)=>{
+    const floor = Math.floor(value);
+    const fraction = value - floor;
+    if (0.5 !== fraction) return fraction < 0.5 ? floor : floor + 1;
+    return floor % 2 === 0 ? floor : floor + 1;
+};
+const MAX_ULP = 2 ** 971;
+const twoSum = (x, y)=>{
+    const high = x + y;
+    return {
+        high,
+        low: y - (high - x)
+    };
+};
+const sumPartials = (partials, overflow)=>{
+    let n = partials.length - 1;
+    let high = 0;
+    let low = 0;
+    if (0 !== overflow) {
+        const next = n >= 0 ? partials[n] : 0;
+        n--;
+        if (Math.abs(overflow) > 1 || overflow > 0 && next > 0 || overflow < 0 && next < 0) return overflow > 0 ? 1 / 0 : -1 / 0;
+        ({ high, low } = twoSum(overflow * 2 ** 1023, next / 2));
+        low *= 2;
+        if (Math.abs(2 * high) === 1 / 0) {
+            if (high > 0) return high === 2 ** 1023 && low === -(MAX_ULP / 2) && n >= 0 && partials[n] < 0 ? Number.MAX_VALUE : 1 / 0;
+            return high === -(2 ** 1023) && low === MAX_ULP / 2 && n >= 0 && partials[n] > 0 ? -Number.MAX_VALUE : -1 / 0;
+        }
+        if (0 !== low) {
+            partials[++n] = low;
+            low = 0;
+        }
+        high *= 2;
+    }
+    while(n >= 0){
+        ({ high, low } = twoSum(high, partials[n--]));
+        if (0 !== low) break;
+    }
+    if (n >= 0 && (low < 0 && partials[n] < 0 || low > 0 && partials[n] > 0)) {
+        const y = 2 * low;
+        const x = high + y;
+        if (y === x - high) high = x;
+    }
+    return high;
+};
+definePolyfills(Math, {
+    f16round (value) {
+        const x = +value;
+        if (x !== x || 0 === x || x === 1 / 0 || x === -1 / 0) return x;
+        const magnitude = Math.abs(x);
+        let exponent = Math.floor(Math.log2(magnitude));
+        if (2 ** exponent > magnitude) exponent--;
+        else if (2 ** (exponent + 1) <= magnitude) exponent++;
+        const step = 2 ** (Math.max(exponent, -14) - 10);
+        const rounded = roundHalfEven(magnitude / step) * step;
+        const result = rounded > 65504 ? 1 / 0 : rounded;
+        return x < 0 ? -result : result;
+    },
+    sumPrecise (items) {
+        if (null == items) throw new TypeError('Expected an iterable of numbers');
+        const partials = [];
+        let overflow = 0;
+        let special = 0;
+        let onlyMinusZero = true;
+        for (const value of items){
+            if ('number' != typeof value) throw new TypeError('Math.sumPrecise expects only numbers');
+            if (special === special) {
+                if (value !== value) special = NaN;
+                else if (value === 1 / 0 || value === -1 / 0) special = special === -value ? NaN : value;
+                else if (0 === special && !Object.is(value, -0)) {
+                    onlyMinusZero = false;
+                    let x = value;
+                    let used = 0;
+                    for(let index = 0; index < partials.length; index++){
+                        let y = partials[index];
+                        if (Math.abs(x) < Math.abs(y)) [x, y] = [
+                            y,
+                            x
+                        ];
+                        let { high, low } = twoSum(x, y);
+                        if (Math.abs(high) === 1 / 0) {
+                            const sign = high > 0 ? 1 : -1;
+                            overflow += sign;
+                            x = x - sign * 2 ** 1023 - sign * 2 ** 1023;
+                            if (Math.abs(x) < Math.abs(y)) [x, y] = [
+                                y,
+                                x
+                            ];
+                            ({ high, low } = twoSum(x, y));
+                        }
+                        if (0 !== low) partials[used++] = low;
+                        x = high;
+                    }
+                    partials.length = used;
+                    if (0 !== x) partials.push(x);
+                }
+            }
+        }
+        if (0 !== special) return special;
+        return onlyMinusZero ? -0 : sumPartials(partials, overflow);
+    }
+});
+definePolyfills(Error, {
+    isError (value) {
+        return isObject(value) && '[object Error]' === Object.prototype.toString.call(value);
+    }
+});
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64URL = BASE64.slice(0, 62) + '-_';
+const ALPHABETS = [
+    'base64',
+    'base64url'
+];
+const LAST_CHUNK_HANDLINGS = [
+    'loose',
+    'strict',
+    'stop-before-partial'
+];
+const requireOptions = (options)=>{
+    if (void 0 !== options && !isObject(options)) throw new TypeError('Options must be an object');
+};
+const readOption = (options, name, values)=>{
+    const value = void 0 === options ? void 0 : options[name];
+    if (void 0 === value) return values[0];
+    if (!values.includes(value)) throw new TypeError(`Invalid ${name} option`);
+    return value;
+};
+const skipAsciiWhitespace = (string, index)=>{
+    while(index < string.length && '\t\n\f\r '.includes(string[index]))index++;
+    return index;
+};
+const decodeBase64Chunk = (chunk, strict, bytes)=>{
+    let n = 0;
+    for (const char of (chunk + 'AA').slice(0, 4))n = 64 * n + BASE64.indexOf(char);
+    const decoded = [
+        n >> 16,
+        n >> 8 & 255,
+        255 & n
+    ];
+    const count = chunk.length - 1;
+    if (strict && count < 3 && 0 !== decoded[count]) return new SyntaxError('Extra bits in a base64 chunk');
+    for(let index = 0; index < count; index++)bytes.push(decoded[index]);
+};
+const decodeBase64 = (string, alphabet, lastChunkHandling, maxLength)=>{
+    const bytes = [];
+    let read = 0;
+    let chunk = '';
+    let index = 0;
+    const result = (error)=>({
+            read,
+            bytes,
+            error
+        });
+    const syntaxError = ()=>result(new SyntaxError('Invalid base64 string'));
+    if (0 === maxLength) return result();
+    for(;;){
+        index = skipAsciiWhitespace(string, index);
+        if (index === string.length) {
+            if (chunk.length > 0) {
+                if ('stop-before-partial' === lastChunkHandling) return result();
+                if ('strict' === lastChunkHandling || 1 === chunk.length) return syntaxError();
+                decodeBase64Chunk(chunk, false, bytes);
+            }
+            read = string.length;
+            return result();
+        }
+        let char = string[index++];
+        if ('=' === char) {
+            if (chunk.length < 2) return syntaxError();
+            index = skipAsciiWhitespace(string, index);
+            if (2 === chunk.length) {
+                if (index === string.length) return 'stop-before-partial' === lastChunkHandling ? result() : syntaxError();
+                if ('=' === string[index]) index = skipAsciiWhitespace(string, index + 1);
+            }
+            if (index < string.length) return syntaxError();
+            const error = decodeBase64Chunk(chunk, 'strict' === lastChunkHandling, bytes);
+            if (error) return result(error);
+            read = string.length;
+            return result();
+        }
+        if ('base64url' === alphabet) {
+            if ('+' === char || '/' === char) return syntaxError();
+            if ('-' === char) char = '+';
+            else if ('_' === char) char = '/';
+        }
+        if (!BASE64.includes(char)) return syntaxError();
+        const remaining = maxLength - bytes.length;
+        if (1 === remaining && 2 === chunk.length || 2 === remaining && 3 === chunk.length) return result();
+        chunk += char;
+        if (4 === chunk.length) {
+            decodeBase64Chunk(chunk, false, bytes);
+            chunk = '';
+            read = index;
+            if (bytes.length === maxLength) return result();
+        }
+    }
+};
+const decodeHex = (string, maxLength)=>{
+    const bytes = [];
+    let read = 0;
+    if (string.length % 2 !== 0) return {
+        read,
+        bytes,
+        error: new SyntaxError('A hex string must have an even length')
+    };
+    while(read < string.length && bytes.length < maxLength){
+        const pair = string.slice(read, read + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(pair)) return {
+            read,
+            bytes,
+            error: new SyntaxError('Invalid hex string')
+        };
+        read += 2;
+        bytes.push(parseInt(pair, 16));
+    }
+    return {
+        read,
+        bytes,
+        error: void 0
+    };
+};
+const requireString = (value)=>{
+    if ('string' != typeof value) throw new TypeError('Expected a string');
+};
+const requireUint8Array = (value)=>{
+    if ('Uint8Array' !== typedArrayName.call(value)) throw new TypeError('Expected a Uint8Array');
+};
+const writeDecoded = (target, { read, bytes, error })=>{
+    for(let index = 0; index < bytes.length; index++)target[index] = bytes[index];
+    if (error) throw error;
+    return {
+        read,
+        written: bytes.length
+    };
+};
+if ('function' == typeof Uint8Array) {
+    definePolyfills(Uint8Array, {
+        fromBase64 (string) {
+            requireString(string);
+            const options = arguments[1];
+            requireOptions(options);
+            const alphabet = readOption(options, 'alphabet', ALPHABETS);
+            const lastChunkHandling = readOption(options, 'lastChunkHandling', LAST_CHUNK_HANDLINGS);
+            const { bytes, error } = decodeBase64(string, alphabet, lastChunkHandling, 1 / 0);
+            if (error) throw error;
+            return new Uint8Array(bytes);
+        },
+        fromHex (string) {
+            requireString(string);
+            const { bytes, error } = decodeHex(string, 1 / 0);
+            if (error) throw error;
+            return new Uint8Array(bytes);
+        }
+    });
+    definePolyfills(Uint8Array.prototype, {
+        toBase64 () {
+            requireUint8Array(this);
+            const options = arguments[0];
+            requireOptions(options);
+            const table = 'base64' === readOption(options, 'alphabet', ALPHABETS) ? BASE64 : BASE64URL;
+            const padding = void 0 !== options && options.omitPadding ? '' : '=';
+            const length = typedArrayLength.call(this);
+            let encoded = '';
+            for(let index = 0; index < length; index += 3){
+                const left = length - index;
+                const n = this[index] << 16 | (left > 1 ? this[index + 1] << 8 : 0) | (left > 2 ? this[index + 2] : 0);
+                encoded += table[n >> 18] + table[n >> 12 & 63] + (left > 1 ? table[n >> 6 & 63] : padding) + (left > 2 ? table[63 & n] : padding);
+            }
+            return encoded;
+        },
+        toHex () {
+            requireUint8Array(this);
+            const length = typedArrayLength.call(this);
+            let hex = '';
+            for(let index = 0; index < length; index++)hex += this[index].toString(16).padStart(2, '0');
+            return hex;
+        },
+        setFromBase64 (string) {
+            requireUint8Array(this);
+            requireString(string);
+            const options = arguments[1];
+            requireOptions(options);
+            const alphabet = readOption(options, 'alphabet', ALPHABETS);
+            const lastChunkHandling = readOption(options, 'lastChunkHandling', LAST_CHUNK_HANDLINGS);
+            return writeDecoded(this, decodeBase64(string, alphabet, lastChunkHandling, typedArrayLength.call(this)));
+        },
+        setFromHex (string) {
+            requireUint8Array(this);
+            requireString(string);
+            return writeDecoded(this, decodeHex(string, typedArrayLength.call(this)));
+        }
+    });
+}
+const defineUpsert = (Kind, requireKey)=>{
+    const { has, get, set } = Kind.prototype;
+    definePolyfills(Kind.prototype, {
+        getOrInsert (key, value) {
+            if (has.call(this, key)) return get.call(this, key);
+            set.call(this, key, value);
+            return value;
+        },
+        getOrInsertComputed (key, callback) {
+            requireCallable(callback);
+            requireKey(key);
+            if (has.call(this, key)) return get.call(this, key);
+            const stored = 0 === key ? 0 : key;
+            const value = callback(stored);
+            set.call(this, stored, value);
+            return value;
+        }
+    });
+};
+defineUpsert(Map, ()=>{});
+defineUpsert(WeakMap, (key)=>{
+    if (!isObject(key) && !('symbol' == typeof key && void 0 === Symbol.keyFor(key))) throw new TypeError('Invalid value used as weak map key');
+});
+if ("u" < typeof Intl) definePolyfillOverride(Number.prototype, 'toLocaleString', function(_locales, options) {
+    const value = Number(this);
+    if (Number.isNaN(value)) return 'NaN';
+    if (!Number.isFinite(value)) return value > 0 ? '∞' : '-∞';
+    const opts = options || {};
+    const min = opts.minimumFractionDigits ?? 0;
+    const max = Math.max(min, opts.maximumFractionDigits ?? Math.max(min, 3));
+    const fixed = Math.abs(value).toFixed(max);
+    const dot = fixed.indexOf('.');
+    let integer = dot < 0 ? fixed : fixed.slice(0, dot);
+    let fraction = dot < 0 ? '' : fixed.slice(dot + 1).replace(/0+$/, '');
+    while(fraction.length < min)fraction += '0';
+    if (false !== opts.useGrouping) integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    const sign = value < 0 && 0 !== Number(fixed) ? '-' : '';
+    return sign + integer + (fraction ? `.${fraction}` : '');
+});
 if ("u" < typeof AbortController) {
     class LynxAbortSignal {
         constructor(){
@@ -39,70 +1183,6 @@ if ("u" < typeof AbortController) {
         }
     };
 }
-if ('function' != typeof Object.hasOwn) Object.hasOwn = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-const definePolyfillOverride = (proto, name, value)=>{
-    Object.defineProperty(proto, name, {
-        value,
-        writable: true,
-        configurable: true,
-        enumerable: false
-    });
-};
-const definePolyfill = (proto, name, value)=>{
-    if (proto && 'function' != typeof proto[name]) definePolyfillOverride(proto, name, value);
-};
-const relativeIndex = function(index) {
-    const length = this.length;
-    let n = Math.trunc(Number(index)) || 0;
-    if (n < 0) n += length;
-    if (n < 0 || n >= length) return;
-    return 'string' == typeof this ? this.charAt(n) : this[n];
-};
-definePolyfill(Array.prototype, 'at', relativeIndex);
-definePolyfill(String.prototype, 'at', function(index) {
-    return relativeIndex.call(String(this), index);
-});
-if ('function' == typeof Int8Array) definePolyfill(Object.getPrototypeOf(Int8Array.prototype), 'at', relativeIndex);
-definePolyfill(Array.prototype, 'findLastIndex', function(predicate, thisArg) {
-    for(let i = this.length - 1; i >= 0; i--)if (predicate.call(thisArg, this[i], i, this)) return i;
-    return -1;
-});
-definePolyfill(Array.prototype, 'findLast', function(predicate, thisArg) {
-    for(let i = this.length - 1; i >= 0; i--)if (predicate.call(thisArg, this[i], i, this)) return this[i];
-});
-definePolyfill(String.prototype, 'replaceAll', function(search, replacement) {
-    const subject = String(this);
-    if (search instanceof RegExp) {
-        if (!search.global) throw new TypeError('replaceAll must be called with a global RegExp');
-        return subject.replace(search, replacement);
-    }
-    const needle = String(search);
-    const pattern = new RegExp(needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
-    return subject.replace(pattern, replacement);
-});
-if ("u" < typeof Intl) definePolyfillOverride(Number.prototype, 'toLocaleString', function(_locales, options) {
-    const value = Number(this);
-    if (Number.isNaN(value)) return 'NaN';
-    if (!Number.isFinite(value)) return value > 0 ? '∞' : '-∞';
-    const opts = options || {};
-    const min = opts.minimumFractionDigits ?? 0;
-    const max = Math.max(min, opts.maximumFractionDigits ?? Math.max(min, 3));
-    const fixed = Math.abs(value).toFixed(max);
-    const dot = fixed.indexOf('.');
-    let integer = dot < 0 ? fixed : fixed.slice(0, dot);
-    let fraction = dot < 0 ? '' : fixed.slice(dot + 1).replace(/0+$/, '');
-    while(fraction.length < min)fraction += '0';
-    if (false !== opts.useGrouping) integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-    const sign = value < 0 && 0 !== Number(fixed) ? '-' : '';
-    return sign + integer + (fraction ? `.${fraction}` : '');
-});
-if ('function' != typeof Promise.allSettled) Promise.allSettled = (promises)=>Promise.all(Array.from(promises, (p)=>Promise.resolve(p).then((value)=>({
-                status: 'fulfilled',
-                value
-            }), (reason)=>({
-                status: 'rejected',
-                reason
-            }))));
 if ("u" < typeof performance) globalThis.performance = void 0;
 if ("u" < typeof queueMicrotask) {
     globalThis.queueMicrotaskPromiseCache = Promise.resolve();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotch/rsbuild-plugin-angular-lynx",
-  "version": "22.2.6",
+  "version": "22.2.7",
   "description": "Rsbuild plugin for building AngularLynx applications",
   "homepage": "https://github.com/Blotch-Smart-Frames/AngularLynx#readme",
   "bugs": {