Add comprehensive library expansion with new components and demos

- Add new libraries: ui-accessibility, ui-animations, ui-backgrounds, ui-code-display, ui-data-utils, ui-font-manager, hcl-studio
- Add extensive layout components: gallery-grid, infinite-scroll-container, kanban-board, masonry, split-view, sticky-layout
- Add comprehensive demo components for all new features
- Update project configuration and dependencies
- Expand component exports and routing structure
- Add UI landing pages planning document

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

projects/ui-code-display/node_modules/zone.js/fesm2015/zone-bluebird.js

@@ -0,0 +1,87 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+function patchBluebird(Zone) {
+    Zone.__load_patch('bluebird', (global, Zone, api) => {
+        // TODO: @JiaLiPassion, we can automatically patch bluebird
+        // if global.Promise = Bluebird, but sometimes in nodejs,
+        // global.Promise is not Bluebird, and Bluebird is just be
+        // used by other libraries such as sequelize, so I think it is
+        // safe to just expose a method to patch Bluebird explicitly
+        const BLUEBIRD = 'bluebird';
+        Zone[Zone.__symbol__(BLUEBIRD)] = function patchBluebird(Bluebird) {
+            // patch method of Bluebird.prototype which not using `then` internally
+            const bluebirdApis = ['then', 'spread', 'finally'];
+            bluebirdApis.forEach((bapi) => {
+                api.patchMethod(Bluebird.prototype, bapi, (delegate) => (self, args) => {
+                    const zone = Zone.current;
+                    for (let i = 0; i < args.length; i++) {
+                        const func = args[i];
+                        if (typeof func === 'function') {
+                            args[i] = function () {
+                                const argSelf = this;
+                                const argArgs = arguments;
+                                return new Bluebird((res, rej) => {
+                                    zone.scheduleMicroTask('Promise.then', () => {
+                                        try {
+                                            res(func.apply(argSelf, argArgs));
+                                        }
+                                        catch (error) {
+                                            rej(error);
+                                        }
+                                    });
+                                });
+                            };
+                        }
+                    }
+                    return delegate.apply(self, args);
+                });
+            });
+            if (typeof window !== 'undefined') {
+                window.addEventListener('unhandledrejection', function (event) {
+                    const error = event.detail && event.detail.reason;
+                    if (error && error.isHandledByZone) {
+                        event.preventDefault();
+                        if (typeof event.stopImmediatePropagation === 'function') {
+                            event.stopImmediatePropagation();
+                        }
+                    }
+                });
+            }
+            else if (typeof process !== 'undefined') {
+                process.on('unhandledRejection', (reason, p) => {
+                    if (reason && reason.isHandledByZone) {
+                        const listeners = process.listeners('unhandledRejection');
+                        if (listeners) {
+                            // remove unhandledRejection listeners so the callback
+                            // will not be triggered.
+                            process.removeAllListeners('unhandledRejection');
+                            process.nextTick(() => {
+                                listeners.forEach((listener) => process.on('unhandledRejection', listener));
+                            });
+                        }
+                    }
+                });
+            }
+            Bluebird.onPossiblyUnhandledRejection(function (e, promise) {
+                try {
+                    Zone.current.runGuarded(() => {
+                        e.isHandledByZone = true;
+                        throw e;
+                    });
+                }
+                catch (err) {
+                    err.isHandledByZone = false;
+                    api.onUnhandledError(err);
+                }
+            });
+            // override global promise
+            global.Promise = Bluebird;
+        };
+    });
+}
+
+patchBluebird(Zone);