diff --git a/assets/sass/post.scss b/assets/sass/post.scss index dc3e0fb..9d62838 100644 --- a/assets/sass/post.scss +++ b/assets/sass/post.scss @@ -79,4 +79,19 @@ .tectonics-readout-name-container { grid-template-rows: repeat(13, auto); /* This number is very specific to 39 names, adjust as needed */ } +} + +.page-content figure { + margin-bottom: 24px; +} + +.page-content figure:has(> figcaption) .highlight { + margin-bottom: 10px; +} + +.page-content figure figcaption { + font-size: 14px; + color: #666; + text-align: center; + margin-bottom: 10px; } \ No newline at end of file diff --git a/content/en/blog/2024-09-09-porting-c-to-rust-for-AV1.md b/content/en/blog/2024-09-09-porting-c-to-rust-for-AV1.md new file mode 100644 index 0000000..c5a343c --- /dev/null +++ b/content/en/blog/2024-09-09-porting-c-to-rust-for-AV1.md @@ -0,0 +1,195 @@ +--- +author: Stephen Crane +date: 2024-09-09T00:00:00Z +title: "Porting C to Rust for a Fast and Safe AV1 Media Decoder" +slug: porting-c-to-rust-for-AV1 +excerpt: "We ported the ```dav1d``` AV1 decoder to Rust. Here’s how we did it and what we learned." +--- + + +
+
+ +
+

AV1 is an increasingly important video format and it needs a memory safe, high performance decoder. We worked with the team at Immunant to develop rav1d, a Rust-based port of dav1d, a C decoder. This is the first of two blog posts about how the team approached this effort.

+ +
+
+
+ + + +Complex data parsing is one of the most security-critical operations in modern software. Browsers must decode untrusted audio and video inputs encoded with extremely complicated formats in real time. Memory safety bugs in this decoding process are disastrous and common. For example, researchers fuzzing H.264 decoder implementations have demonstrated that these decoders are a [dangerous source of bugs](https://www.usenix.org/conference/usenixsecurity23/presentation/vasquez). AV1 is a similarly complex, widely used video format. We need a [memory safe, performant implementation](https://www.memorysafety.org/initiative/av1/) of AV1 format parsing to avoid parsing vulnerabilities in heavily targeted software such as browsers. + +To create this fast and safe AV1 decoder, we have ported an existing high performance AV1 decoding library, [```dav1d```](https://code.videolan.org/videolan/dav1d), from C to Rust: [```rav1d```](https://github.com/memorysafety/rav1d/). Our implementation is drop-in compatible with the ```dav1d``` C API. Format parsers that were unsafe C are now memory safe Rust. To preserve performance, we have kept the (unsafe) native assembly routines that implement low-level decoding operations. These assembly routines primarily operate on buffers of primitive values using validated data from the Rust parsing code. Historically, most exploitable bugs are in higher level format parsing code, rather than low level data operations. We will continue to fuzz and analyze the assembly routines to mitigate memory corruption bugs at that level. + +Our goals for the ```rav1d``` implementation are: + +- Move ```dav1d```'s C code to Rust for memory safety +- Drop-in C API compatibility +- Performance on par with the C implementation +- Reuse the assembly code from ```dav1d``` and make it easy to frequently synchronize it +- X86-64 and ARM64 support + +## Migration Approach + +Writing a high performance and complete AV1 decoder from scratch is a challenging project. It requires a deep understanding of the AV1 standard and domain knowledge about how to best implement this codec format in a performant and compatible way. The ```dav1d``` implementation, developed by the VideoLAN and FFmpeg communities and sponsored by the Alliance for Open Media, has been under development for 6 years. It contains about 50k lines of C code and 250k lines of assembly. This implementation is mature, fast, and widely used. Rather than try to reimplement such a decoder in Rust from scratch, we chose to migrate the existing ```dav1d``` C code to Rust. + +We want to provide a compatible C API to make migration to our new Rust library smoother. We also want to reuse the ```dav1d``` assembly code to preserve performance. These compatibility constraints mean that we must preserve some of the same data structure layout as ```dav1d``` both externally and internally. We must also call the assembly routines in the exact same way as ```dav1d``` does. Functionally, this requires that we implement decoding in effectively the same way as ```dav1d```. + +We could have manually rewritten ```dav1d``` into Rust one function or module at a time. However, given the compatibility we wanted to retain, this would have been a tedious process. To get to the point where we could make cross-cutting changes to internal data structures necessary for enforcing memory safety would require rewriting much of the codebase. Instead we chose to migrate by initially transpiling the C code into equivalent but unsafe Rust using [c2rust](http://c2ru.st). This allowed us to start the rewriting process from a fully working, seamlessly compatible Rust codebase without introducing any new logic bugs in the process. The bulk of the work then consisted of manually refactoring and rewriting the unsafe Rust into a safe, idiomatic Rust. + +Transpiling into unsafe Rust followed by rewriting provided two important advantages for this project: 1) starting from a fully working Rust implementation allowed us to thoroughly test decoding functionality while incrementally refactoring, and 2) transpiling complex decoding logic reduced the need for expert domain knowledge of the AV1 specification. We found that full CI testing from the beginning while rewriting and improving the Rust code was immensely beneficial. We could make cross-cutting changes to the codebase and run the existing ```dav1d``` tests on every commit. Between the static checking of the Rust compiler and integration testing of the full decoder, we spent comparatively less time debugging than we would have implementing a decoder from scratch. The majority of the team on this project were experts in systems programming and Rust, but did not have previous experience with AV codecs. Our codec expert on the project, [Frank Bossen](http://bossentech.com/), provided invaluable guidance but did not need to be involved in the bulk of the effort. + +When we first embarked on this project, we estimated that it would take on the order of 7 person-months of effort. However, we found that we needed to spend significantly more manual effort than we had anticipated. In total we spent more than 20 person-months of effort with a team of 3 developers. The rewriting process, especially while attempting to preserve performance, ended up being far more involved than we had anticipated. We encountered some challenges that were due to idiosyncrasies of the ```dav1d``` codebase itself or the c2rust transpiler tooling. For example, the ```dav1d``` C code structure resulted in significant duplication of transpiled Rust code for both 8- and 16-bit depths, which we had to manually unify and deduplicate. Interfacing with existing assembly in a safe and ergonomic way while preserving performance required significant care and effort. Many of the other challenges we encountered are more fundamental to migrating C code to Rust, so this post will focus on these issues and our solutions. + +## Challenges + +We encountered various challenges due to the mismatch between C and safe Rust patterns. Lifetime management required understanding the existing codebase in great detail, but we did not find that lifetimes and borrows were the most challenging issues. Rust thread safety, which makes sharing mutable data across worker threads difficult, was a poor fit for the ```dav1d``` threading model which shares almost all data implicitly between threads. Memory ownership and buffer pointers were further important sources of difficulty, as well as unions and other unsafe C patterns. + +### Threading + +```dav1d``` uses a pool of worker threads to concurrently execute tasks that do not depend on each other. However, these tasks operate on shared global and per-frame context structures and even share mutable access into the same buffers. For example, Figure 1a shows an excerpt from the root context structure that all threads must access. Each in-progress frame has a ```dav1d```FrameContext which is shared between worker threads operating on that frame. Each ```dav1d```TaskContext object is only ever used by a single thread, but in the C version each object is accessible to all other threads via the root ```dav1dContext```. Finally, the root context contains many other state fields, some of which must be mutable by the main thread but readable in worker threads. + +
+ +```C++ +struct dav1dContext { + dav1dFrameContext *fc; + unsigned n_fc; + + dav1dTaskContext *tc; + unsigned n_tc; + + struct dav1dTileGroup *tile; + int n_tile_data_alloc; + int n_tile_data; + int n_tiles; + + // ... +} +``` + +
Figure 1a: Excerpt from the C root context structure
+
+ + + +Rust requires that all data shared between threads be ```Sync```, which means that the data must be safe to access concurrently from multiple threads. We want to share a borrowed root context between all threads, so all data in that context must be immutable. To allow mutation of shared data, we must introduce locks to ensure thread safety is maintained at runtime. We added ```Mutex``` and ```RwLock``` as needed to allow interior mutation. If we assume that the original C code does not have data races (we did not observe any in ```dav1d```), these new locks should never be contended. We made heavy use of ```Mutex::try_lock()``` and ```RwLock::try_read()``` / ```RwLock::try_write()``` to validate at runtime that a thread could safely access data without possibly introducing delays waiting on a lock. + +
+ +```C++ +pub struct rav1dContext { + pub(crate) state: Mutex, + pub(crate) fc: Box<[rav1dFrameContext]>, + pub(crate) tc: Box<[rav1dContextTaskThread]>, + + // ... +} + +pub struct rav1dState { + pub(crate) tiles: Vec, + pub(crate) n_tiles: c_int, + + // ... +} +``` + +
Figure 1b: Corresponding context excerpt from rav1d
+
+ +As shown in Figure 1b, we had to reorganize the ```dav1d``` structures to better fit into the Rust thread safety model. We refactored mutable state into a new ```rav1dState``` structure and wrapped this in a mutex. It's also worth noting that ```tc``` no longer contains thread-local data for all threads but instead only the thread handle and ```Sync``` metadata for thread coordination. All thread-local data from ```dav1dTaskContext``` is now managed by each worker thread independently so it does not need to be ```Sync```. + +Adding extra locks handles the case where only a single thread needs to mutate a particular field or structure. ```dav1d```, in many cases, relies on concurrent but non-overlapping access to a single buffer. One thread must read or write from a range of the buffer while another thread accesses a different, disjoint range of the same buffer. This pattern, while free of data races in practice, does not map cleanly into safe Rust idioms. In safe Rust, one would generally first partition a buffer into disjoint slices then distribute these disjoint slices to different threads for processing. That pattern requires knowing the precise partitioning of each data buffer ahead of time in order to properly distribute these slices to task threads. In the case of AV1, this buffer partitioning would be extremely complicated as the partitioning is not static or even contiguous. Crates exist for storing N-dimensional arrays to allow for partitioning and chunking these buffers, such as [ndarray](https://crates.io/crates/ndarray), but we would need to understand the precise access patterns of all tasks for all buffers in order to properly partition these buffers. This would have required a fundamental re-architecting of the ```rav1d``` task scheduling. + +Instead, we implemented another approach that more closely fits the model used in ```dav1d```. We created a buffer wrapper type, ```DisjointMut``` that allows for disjoint, concurrent mutable access to a buffer. In debug builds, we track each borrowed range to ensure that each mutable borrow has exclusive access to its range of elements. We found this tracking to be incredibly useful for debugging and ensuring threads did not borrow data in a way that overlaps with other threads. However, tracking each borrow is too expensive for release builds, so in release builds the entire ```DisjointMut``` structure is a zero-cost wrapper over the underlying buffer. Access into the buffer is still bounds checked, so we preserve spatial safety while potentially compromising thread safety. All ```DisjointMut``` buffers in ```rav1d``` are primitive data, so at worst this pattern could only introduce nondeterminism if access is not correctly disjoint. Figure 2 shows an excerpt from a structure that is shared by all worker threads. Multiple threads concurrently mutate different blocks in the b field, so we wrapped this vector in ```DisjointMut``` to allow concurrent access. + +
+ +```C++ +struct dav1dFrameContext_frame_thread { + // ... + + // indexed using t->by * f->b4_stride + t->bx + Av1Block *b; + int16_t *cbi; /* bits 0-4: txtp, bits 5-15: eob */ + + // ... +} frame_thread; +``` +
Figure 2a: Excerpt from the C frame context structure
+
+ + + +
+ +```C++ +pub struct rav1dFrameContextFrameThread { + // ... + + // Indexed using `t.b.y * f.b4_stride + t.b.x`. + pub b: DisjointMut>, + + pub cbi: Vec>, + + // ... +} + +``` + +
Figure 2b: rav1d Rust equivalent to Figure 2a
+
+ +Where possible, we used atomic types instead of adding locking. We are relying on the code already avoiding logical data races, and atomic primitive types provide formal thread safety. We did not require any particular atomic memory ordering because we are assuming that writes to shared fields are not racy, so we used relaxed ordering. On the platforms we are targeting, naturally aligned loads and stores are already atomic, so relaxed ordering atomic operations in Rust lower to the same memory operations as in C with no additional overhead[^1]. We could not use non-relaxed atomics or fetch+update methods, as these operations lower to complex, slower instructions. We added a ```RelaxedAtomic``` wrapper to simplify usage of these atomic fields and ensure that we did not use inefficient patterns. We also used the [atomig](https://docs.rs/atomig) crate to make simple primitive sized structures and enums atomic. + +Overall, we found the Rust thread safety model to be overly strict. Were we to write this decoder from scratch, we would have designed more disjoint and clear data sharing between threads. However, we were able to basically preserve performance without drastic changes to the existing logic by using new data structures such as ```DisjointMut``` and ```RelaxedAtomic``` that still give us the memory safety guarantees we want while relaxing data race safety enforcement. + +### Self-Referential Structures + +Pointers into the same structure or recursively between structures is a common pattern in C that is not easily reproducible in safe Rust. The challenging pointers we encountered in porting ```dav1d``` largely fit into one of two categories: cursors tracking buffer positions, and links between context structures. + +We generally refactored buffer cursor pointers into integer indices. However, this was not always straightforward -- some buffer pointers could temporarily go out of bounds before the beginning of the buffer because a positive offset would later be added or the pointer would not be dereferenced at all. We refactored these cases to ensure that offsets stayed non-negative by moving index calculations. Even for simpler cases, changing pointers to indices required that we carefully track and document which buffer each index was referencing and ensure that every use of the index had access to the corresponding buffer. + +We had to disentangle the ```dav1d``` context structures by removing pointers from child structures to their containers and then passing additional structure references as function parameters instead. For example, we added ```rav1dContext``` and ```rav1dFrameData``` reference parameters to ```decode_tile_sbrow```, because we had to remove these pointers from the task context structure. + +
+ +```C++ +// Original C function +int dav1d_decode_tile_sbrow(dav1dTaskContext *const t) { + const dav1dFrameContext *const f = t->f; + dav1dTileState *const ts = t->ts; + const dav1dContext *const c = f->c; + // ... +} +``` + +```Rust +// Safe Rust version +pub(crate) fn rav1d_decode_tile_sbrow( + c: &rav1dContext, + t: &mut rav1dTaskContext, + f: &rav1dFrameData, +) -> Result<(), ()> { + let ts = &f.ts[t.ts]; +} +``` + +
Figure 3: Separating context structure
+
+ + + +### Unions + +```dav1d``` makes some use of untagged C unions. In cases where an additional field was used as a tag, we rewrote these unions into safe tagged Rust enums. The discriminant for some unions, however, was implicit in C. For example, the stage of a task, stored in an entirely different context structure, would determine which union variant should be used. For these cases, rather than add a redundant tag and change the structure representation and size, we opted to use the [```zerocopy```](https://docs.rs/zerocopy) crate to reinterpret the same bytes as two different types at runtime. This was only an option because these unions consisted entirely of primitive types without padding. The ```zerocopy``` traits enforce this invariant and allow zero-cost access to the union contents, without requiring an explicit tag. Though this pattern is less idiomatic, we found it was necessary in a few cases for performance and compatibility. + +## Conclusions + +Was transpiling and rewriting worthwhile? We believe so, at least for the ```rav1d``` project. Rewriting an AV1 video decoder from scratch would have introduced all sorts of new bugs and compatibility issues. We found that, despite the threading and borrowing challenges, rewriting existing C code into safe, performant Rust was possible. Our ```rav1d``` implementation is currently about [6% slower](https://github.com/memorysafety/rav1d/issues/1294) than the current ```dav1d``` C implementation. We will go into more detail on the process of optimizing ```rav1d``` performance in an upcoming blog post. For applications where safety is paramount, ```rav1d``` offers a memory safe implementation without additional overhead from mitigations such as sandboxing. We believe that with continued optimization and improvements, the Rust implementation can compete favorably with a C implementation in all situations, while also providing memory safety. + +[^1]: The only overhead is from not being able to combine, for example, 2 consecutive, aligned ```AtomicU8``` loads into a single ```AtomicU16``` store, which would transparently be done for ```u8```s and ```u16```s. For individual fields accessed separately, this is not a problem. It does, however, introduce more overhead when working with arrays and slices. + +*We'd like to thank Amazon Web Services, Sovereign Tech Fund, and Alpha-Omega for supporting the development of this work. If you want to learn more about ```rav1d``` or start using it, check it out on [GitHub](https://github.com/memorysafety/rav1d/).* \ No newline at end of file diff --git a/content/en/initiative/av1.html b/content/en/initiative/av1.html index 649d028..29dc072 100644 --- a/content/en/initiative/av1.html +++ b/content/en/initiative/av1.html @@ -2,7 +2,7 @@ title: AV1 Decoder slug: av1 background: dce0e9 -blog_posts: ["2023-03-09-safer-av1-decoder.md"] +blog_posts: ["2024-09-09-porting-c-to-rust-for-AV1.md","2023-03-09-safer-av1-decoder.md"] funders: ["AWS", "Sovereign-Tech-Fund", "Alpha-Omega"] image: /images/av1.png --- diff --git a/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.content b/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.content new file mode 100644 index 0000000..f6d3c22 --- /dev/null +++ b/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.content @@ -0,0 +1 @@ +a{color:#082659!important;text-decoration-color:#082659;text-decoration-thickness:1px}a:hover{text-decoration:underline;text-decoration-color:#082659;text-decoration-thickness:1px}a.nav-link:hover{text-decoration:none}.btn:hover{text-decoration:none}.btn-primary{background-color:#082659!important;border-color:#082659!important;color:#fff!important}.btn-outline-primary{border-color:#082659!important;color:#082659!important}.btn-outline-primary:hover{background-color:#082659!important;color:#fff!important}.text-primary{color:#082659!important}.btn-scroll-top{background-color:#082659!important}.btn-scroll-top i{color:#fff}.navbar-light .navbar-nav .nav-link:hover,.navbar-light .navbar-nav .nav-link:focus,.navbar-light .navbar-nav .nav-item:hover>.nav-link,.dropdown-item:hover,.dropdown-item:focus{color:#082659!important}.btn-mint{background-color:#14dfb4!important;color:#082659!important;border-color:#14dfb4;font-weight:700!important;font-family:open sans;border:1px solid transparent}.btn-mint:hover{border-color:#082659!important}footer a{color:#fff!important}:root{--font-family-sans-serif:"Open Sans", sans-serif}body,.tooltip,.popover{font-family:open sans,sans-serif}.bg-dark{background-color:#051735!important}@media(min-width:768px){.pt-md-8{padding-top:8rem!important}}.pt-10{padding-top:1}.pt-7{padding-top:7rem!important}.pt-8{padding-top:8rem!important}.pt-9{padding-top:9rem!important}.pt-10{padding-top:10rem!important}.accordion-button{color:#082659!important;font-size:20px;line-height:34px}.accordion-button::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='none'%3e%3cpath fill-rule='evenodd' d='M7.999.667c.368 0 .667.298.667.667v6h6c.368 0 .667.298.667.667s-.299.667-.667.667h-6v6c0 .368-.298.667-.667.667s-.667-.299-.667-.667v-6h-6C.964 8.667.666 8.369.666 8s.298-.667.667-.667h6v-6c0-.368.298-.667.667-.667z' fill='%2314dfb4'/%3e%3c/svg%3e")!important}.accordion-button:not(.collapsed)::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='none'%3e%3cpath fill-rule='evenodd' d='M.666 8c0-.368.298-.667.667-.667v1.333C.964 8.666.666 8.368.666 8zm14 0v.667H1.333V7.333h13.333V8zm0 0v.667c.368 0 .667-.298.667-.667s-.299-.667-.667-.667V8z' fill='%2314dfb4'/%3e%3c/svg%3e")!important}.btn>[class^=ci-],.btn>[class*=" ci-"]{font-size:1em}.cs-page-wrapper{-ms-flex:1 0 auto;flex:1 0 auto}#dd-container .mg-forms-button,#dd-container .mg-forms-button.disabled,#dd-container .mg-forms-button[disabled],#dd-container .mg-forms-button.disabled:hover,#dd-container .mg-forms-button[disabled]:hover,#dd-container .mg-forms-button.disabled:focus,#dd-container .mg-forms-button[disabled]:focus,.dtd-plugin .mg-forms-button,.dtd-plugin .mg-forms-button.disabled,.dtd-plugin .mg-forms-button[disabled],.dtd-plugin .mg-forms-button.disabled:hover,.dtd-plugin .mg-forms-button[disabled]:hover,.dtd-plugin .mg-forms-button.disabled:focus,.dtd-plugin .mg-forms-button[disabled]:focus,#dd-container .mg-guidelines-button,#dd-container .mg-guidelines-button.disabled,#dd-container .mg-guidelines-button[disabled],#dd-container .mg-guidelines-button.disabled:hover,#dd-container .mg-guidelines-button[disabled]:hover,#dd-container .mg-guidelines-button.disabled:focus,#dd-container .mg-guidelines-button[disabled]:focus,.dtd-plugin .mg-guidelines-button,.dtd-plugin .mg-guidelines-button.disabled,.dtd-plugin .mg-guidelines-button[disabled],.dtd-plugin .mg-guidelines-button.disabled:hover,.dtd-plugin .mg-guidelines-button[disabled]:hover,.dtd-plugin .mg-guidelines-button.disabled:focus,.dtd-plugin .mg-guidelines-button[disabled]:focus{background-color:#14dfb4!important;font-size:14px!important;font-family:open sans!important;font-weight:700!important;color:#082659!important;border:0!important;padding:10px 32px!important}#dd-container .lets-check,#dd-container .lets-check.disabled,#dd-container .lets-check[disabled],#dd-container .lets-check.disabled:hover,#dd-container .lets-check[disabled]:hover,#dd-container .lets-check.disabled:focus,#dd-container .lets-check[disabled]:focus,.dtd-plugin .lets-check,.dtd-plugin .lets-check.disabled,.dtd-plugin .lets-check[disabled],.dtd-plugin .lets-check.disabled:hover,.dtd-plugin .lets-check[disabled]:hover,.dtd-plugin .lets-check.disabled:focus,.dtd-plugin .lets-check[disabled]:focus{background-color:#082659!important;font-size:14px!important;font-family:open sans!important;font-weight:700!important;color:#fff!important;border:0!important;padding:10px 32px!important}#dd-container body,.dtd-plugin body,#dd-container,.dtd-plugin,#dd-container h1,#dd-container .h1,#dd-container h2,#dd-container .h2,#dd-container h3,#dd-container .h3,#dd-container h4,#dd-container .h4,#dd-container h5,#dd-container .h5,#dd-container h6,#dd-container .h6,.dtd-plugin h1,.dtd-plugin .h1,.dtd-plugin h2,.dtd-plugin .h2,.dtd-plugin h3,.dtd-plugin .h3,.dtd-plugin h4,.dtd-plugin .h4,.dtd-plugin h5,.dtd-plugin .h5,.dtd-plugin h6,.dtd-plugin .h6{font-family:open sans,sans-serif!important}footer{color:#fff}footer input[type=radio]+label{padding-left:10px}footer label.checkbox{margin-left:8px}footer p{margin-bottom:4px}footer .font-small{font-size:12px;line-height:1.14;color:rgba(255,255,255,.6)!important}footer .font-small a{color:rgba(255,255,255,.6)!important}#mc_embed_signup{clear:left;color:#fff;font:14px Helvetica,Arial,sans-serif}#mc-embedded-subscribe-form input[type=checkbox]{display:inline;width:auto;margin-right:10px}#mergeRow-gdpr{margin-top:5px}#mergeRow-gdpr fieldset label{font-weight:400}#mc-embedded-subscribe-form .mc_fieldset{border:none;min-height:0;padding-bottom:0}#mc_embed_signup form{padding-left:0!important;padding-top:0!important}#mc_embed_signup div#mce-responses{padding-left:0!important;padding-right:0!important;width:100%}#mc_embed_signup div.response{width:100%!important;margin-top:0!important;padding-top:0!important;font-size:16px;font-weight:400}#mc_embed_signup div#mce-responses{margin:0!important}#mc_embed_signup #mce-success-response{color:#fff!important}.tpl-page .cs-page-wrapper{margin-top:100px}.tpl-page h1{text-align:center;color:#082659}.footnotes{padding-top:10px}.footnotes hr{margin-bottom:10px}.footnotes ol{padding-left:17px}.initiative-funders .funder-logos{justify-items:start;gap:10px}.initiative-funders .funder-logos .funder img{max-height:60px}.funder-logos{display:grid;grid-template-columns:repeat(3,1fr);gap:50px;align-items:center;justify-items:center}.funder-logos .funder{flex-basis:calc(33% - 6.67px)}#funders-home .funder-logos .funder{margin-bottom:0}.funder-logos .funder img{max-height:44px}.funder-logos .funder:last-child{margin-bottom:0}.no-br{white-space:nowrap}@media screen and (min-width:992px){.pt-lg-55{padding-top:5rem!important}}.tpl-initiative .initiative-hero{margin-bottom:35px!important}.tpl-post .cs-page-wrapper{margin-top:100px}.tpl-post h1{text-align:center;color:#082659}.tpl-post .slice,.tpl-post .page-content,.tpl-page .slice,.tpl-page .page-content{max-width:768px;margin-left:auto;margin-right:auto}.tpl-post .page-content pre+p,.tpl-page .page-content pre+p{margin-top:1.5rem}@media(min-width:768px){.pic-quote-right{float:right!important;max-width:33.33333%;margin-left:25px;flex:0 0 33.33333%}}.mw-240px{max-width:240px}.post-footer{background-color:#14dfb4;color:#082659;padding:1.5rem;margin-top:2rem}.post-footer a{text-decoration-color:#fff!important;text-underline-offset:3px}.post-footer a:hover{color:#fff!important}.post-footer h6{font-size:20px;color:#082659;line-height:1;font-weight:700;margin-top:0}.post-footer p:last-child{margin-bottom:0}.tectonics-readout-name-container{display:grid;grid-template-rows:repeat(20,auto);grid-auto-flow:column;gap:10px}@media(min-width:767.98px){.tectonics-readout-name-container{grid-template-rows:repeat(13,auto)}}.page-content figure{margin-bottom:24px}.page-content figure:has(>figcaption) .highlight{margin-bottom:10px}.page-content figure figcaption{font-size:14px;color:#666;text-align:center;margin-bottom:10px}.bg{background-color:#fff}.chroma{background-color:#fff}.chroma .err{color:#a61717;background-color:#e3d2d2}.chroma .lnlinks{outline:none;text-decoration:none;color:inherit}.chroma .lntd{vertical-align:top;padding:0;margin:0;border:0}.chroma .lntable{border-spacing:0;padding:0;margin:0;border:0}.chroma .hl{background-color:#ffc}.chroma .lnt{white-space:pre;user-select:none;margin-right:.4em;padding:0 .4em;color:#7f7f7f}.chroma .ln{white-space:pre;user-select:none;margin-right:.4em;padding:0 .4em;color:#7f7f7f}.chroma .line{display:flex}.chroma .k{color:#000;font-weight:700}.chroma .kc{color:#000;font-weight:700}.chroma .kd{color:#000;font-weight:700}.chroma .kn{color:#000;font-weight:700}.chroma .kp{color:#000;font-weight:700}.chroma .kr{color:#000;font-weight:700}.chroma .kt{color:#458;font-weight:700}.chroma .na{color:teal}.chroma .nb{color:#0086b3}.chroma .bp{color:#999}.chroma .nc{color:#458;font-weight:700}.chroma .no{color:teal}.chroma .nd{color:#3c5d5d;font-weight:700}.chroma .ni{color:purple}.chroma .ne{color:#900;font-weight:700}.chroma .nf{color:#900;font-weight:700}.chroma .nl{color:#900;font-weight:700}.chroma .nn{color:#555}.chroma .nt{color:navy}.chroma .nv{color:teal}.chroma .vc{color:teal}.chroma .vg{color:teal}.chroma .vi{color:teal}.chroma .s{color:#d14}.chroma .sa{color:#d14}.chroma .sb{color:#d14}.chroma .sc{color:#d14}.chroma .dl{color:#d14}.chroma .sd{color:#d14}.chroma .s2{color:#d14}.chroma .se{color:#d14}.chroma .sh{color:#d14}.chroma .si{color:#d14}.chroma .sx{color:#d14}.chroma .sr{color:#009926}.chroma .s1{color:#d14}.chroma .ss{color:#990073}.chroma .m{color:#099}.chroma .mb{color:#099}.chroma .mf{color:#099}.chroma .mh{color:#099}.chroma .mi{color:#099}.chroma .il{color:#099}.chroma .mo{color:#099}.chroma .o{color:#000;font-weight:700}.chroma .ow{color:#000;font-weight:700}.chroma .c{color:#998;font-style:italic}.chroma .ch{color:#998;font-style:italic}.chroma .cm{color:#998;font-style:italic}.chroma .c1{color:#998;font-style:italic}.chroma .cs{color:#999;font-weight:700;font-style:italic}.chroma .cp{color:#999;font-weight:700;font-style:italic}.chroma .cpf{color:#999;font-weight:700;font-style:italic}.chroma .gd{color:#000;background-color:#fdd}.chroma .ge{color:#000;font-style:italic}.chroma .gr{color:#a00}.chroma .gh{color:#999}.chroma .gi{color:#000;background-color:#dfd}.chroma .go{color:#888}.chroma .gp{color:#555}.chroma .gs{font-weight:700}.chroma .gu{color:#aaa}.chroma .gt{color:#a00}.chroma .gl{text-decoration:underline}.chroma .w{color:#bbb}body{color:#082659!important}#footer-logo{max-width:300px;max-height:55px;margin-bottom:5px}.footer-text a{text-decoration:underline;text-decoration-color:#14dfb4;text-underline-offset:2px}.footer-text a:hover{color:#14dfb4!important}.btn-large{font-size:18px}.logo-container{max-width:200px;max-height:200px}.logo-container img{width:100%;height:100%;max-width:100%;max-height:200px;object-fit:contain}.home-initiatives .logo-image{max-height:120px}.text-primary-knockout{color:#082659;padding:3px 0;display:inline-block;white-space:nowrap}.initiative_list_item{align-items:center}.initiative_list_item .initiative-status{text-align:center;display:flex;align-items:center}.initiative_list_item .initiative-status__item{white-space:nowrap;width:100%}.initiative_list_item__blogLanding{margin-bottom:20px}.initiative_list_item__blogLanding h2,.initiative_list_item__blogLanding p{margin-bottom:.5rem}.initiative-description ol{padding-left:17px}@media screen and (min-width:768px){.initiative_list_item__meta{display:flex}.initiative_list_item .initiative-status{padding-left:25px;line-height:21px;text-align:left!important}}@media screen and (max-width:767.98px){.initiative-status{padding-top:20px}}@media screen and (max-width:991.98px){#prossimoNavbar{box-shadow:0 10px 10px -2px rgba(0,0,0,.2)}}.placeholder{font-weight:700;color:#f0f}.key-value-table th{text-align:right;padding-right:5px;white-space:nowrap;vertical-align:top}.key-value-table+p{margin-top:24px}.key-value-table td{vertical-align:top}#home-hero .btn{width:320px;position:relative}#home-hero .btn i{position:absolute;left:18px;top:16px}.sponsor-highlight{background:#e8fcf8;text-align:center;padding:20px 10px 10px;margin:10px 0 20px}.sponsor-highlight h2{font-size:20px;text-transform:uppercase;letter-spacing:.5px}.sponsor-highlight p{font-size:20px}pre.code-block{margin:10px 0 20px;border-radius:10px;background:#eee}.highlight{margin:10px 0 20px}.highlight .chroma{border-radius:10px;background:#eee}#donate-via-paypal{background:#e8fcf8;padding:10px}#donate-via-paypal h2{text-align:center}#donate-via-paypal #paypal-button-container .paypal-buttons{margin:20px auto;display:block}#copyright-line{background-color:#292c37}#copyright-line a{text-decoration:none}#copyright-line a:hover{text-decoration:underline;text-decoration-color:#14dfb4}.back-to-top-btn:hover .btn-scroll-top{background-color:#14dfb4!important}.back-to-top-btn:hover .btn-scroll-top>.btn-scroll-top-icon{color:#082659!important}label.checkbox input[type=checkbox]+span{margin-left:10px}@media screen and (max-width:525px){#see-if-organization-matches{white-space:normal!important}}.navbar-floating{z-index:1030}a[name]{scroll-margin-top:110px}code{color:#082659;font-weight:700}h1 code,h2 code,h3 code,h4 code,h5 code,h6 code{color:#000}a.autoanchor{text-decoration:none;color:grey;font-size:.8em;margin-left:.5em;background-image:url(/images/link-solid.svg);background-repeat:no-repeat;background-position:50%;color:transparent;height:24px;width:24px;transform:translateY(2px)}.scroll-offset-for-sticky-nav{scroll-margin-top:100px}html[dir=rtl] a.autoanchor{margin-right:.5em;margin-left:0}.page-content h1 .autoanchor,.page-content h2 .autoanchor,.page-content h3 .autoanchor{display:none}.page-content h1:hover .autoanchor,.page-content h2:hover .autoanchor,.page-content h3:hover .autoanchor{display:inline-block!important}.home-headline{font-size:33px;border-bottom:1px solid #000;margin-bottom:30px}.home-headline a{text-decoration:none;color:#000!important}.home-headline a:hover{color:#082659!important}.home-eyebrow{font-size:16px;line-height:20px;text-transform:uppercase;margin-bottom:30px}.home-eyebrow::after{content:'';width:100%;height:1px;background:#14dfb4;display:block;position:relative;top:-10px;z-index:1}.home-eyebrow a,.home-eyebrow span{text-decoration:none;color:#000!important;color:#082659!important;display:inline-block;background:#fff;padding:0 10px 0 0;z-index:2;letter-spacing:.75px;position:relative}.home-eyebrow a:hover{color:#082659!important;text-decoration:underline}.blog-title-link{font-size:24px;text-decoration:none;color:#000!important}.blog-title-link:hover{color:#082659!important}.read-more-link{color:#000!important}.read-more-link:hover{color:#082659!important}#blog .blog-title-link{font-weight:400;font-size:22px;line-height:1.4!important;display:block}.blog-date{color:#888;font-size:14px}.home-h3{font-weight:900}@media(min-width:768px){.pr-md-1{padding-right:.25rem!important}.pl-md-1{padding-left:.25rem!important}.pr-md-2{padding-right:.5rem!important}.pl-md-2{padding-left:.5rem!important}.pr-md-3{padding-right:1rem!important}.pr-md-4{padding-right:1.5rem!important}.pr-md-5{padding-right:3rem!important}.pl-md-3{padding-left:1rem!important}.pl-md-4{padding-left:1.5rem!important}}.code-block{color:#3c3c3c}.code-red{color:#fe1016}.code-blue{color:#124bc0}.code-green{color:#609e4c}#site-banner a{display:block;text-align:center;padding:10px 0;color:#14dfb4!important;font-weight:700;background-color:#082659}#site-banner a:hover{background-color:#04122a;text-decoration:none}div[data-netlify-site-id]{display:none;pointer-events:none} \ No newline at end of file diff --git a/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.json b/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.json new file mode 100644 index 0000000..fd7fedf --- /dev/null +++ b/resources/_gen/assets/sass/main.scss_77b10c8e87ff110a62c52933fe3f7f11.json @@ -0,0 +1 @@ +{"Target":"/sass/main.min.0a372fa6349f79907392a11cc2cab7389fbb356e4bef81888301a64efbb11c47.css","MediaType":"text/css","Data":{"Integrity":"sha256-CjcvpjSfeZBzkqEcwsq3OJ+7NW5L74GIgwGmTvuxHEc="}} \ No newline at end of file