Coder Social home page Coder Social logo

prosemirror-markdown's Introduction

prosemirror

[ WEBSITE | ISSUES | FORUM ]

ProseMirror is a well-behaved rich semantic content editor based on contentEditable, with support for collaborative editing and custom document schemas.

The ProseMirror library consists of a number of separate modules. This repository just serves as a central issue tracker, and holds a script to help easily check out all the core modules for development.

The project page has more information, a number of examples and the documentation.

This code is released under an MIT license. There's a forum for general discussion and support requests, and the Github bug tracker is the place to report issues.

STOP READING HERE IF YOU'RE SIMPLY USING PROSEMIRROR. YOU CAN INSTALL THE SEPARATE NPM MODULES FOR THAT. THE INSTRUCTIONS BELOW ONLY APPLY WHEN DEVELOPING PROSEMIRROR!

Setting up a dev environment

Clone this repository, and make sure you have node and yarn (due to a string of issues with NPM 5, NPM is not currently supported) installed. Next, from the cloned directory run:

bin/pm install

This will fetch the submodules, install their dependencies, and build them.

The bin/pm script in this repository provides functionality for working with the repositories:

  • bin/pm build rebuilds all the modules

  • bin/pm watch sets up a process that automatically rebuilds the modules when they change

  • bin/pm status prints the git status of all submodules

  • bin/pm commit <args> runs git commit with the given arguments in all submodules that have pending changes

  • bin/pm test runs the (non-browser) tests in all modules

  • bin/pm push runs git push in all modules

  • bin/pm grep <pattern> greps through the source code for the modules for the given pattern

  • bin/pm dev-start starts a server that rebuilds the packages whenever their sources change, and exposes the demo (demo/*) under a webserver on port 8080

(Functionality for managing releases will be added in the future.)

Community

Development of ProseMirror happens in the various repositories exposed under the ProseMirror organization on GitHub. Bugs for core packages are tracked in the bug tracker for the meta repository.

We aim to be an inclusive, welcoming community. To make that explicit, we have a code of conduct that applies to communication around the project.

prosemirror-markdown's People

Contributors

adrianheine avatar aguingand avatar cncuckoo avatar coderaiser avatar d4rkr00t avatar dragonman225 avatar duongtn811 avatar eloquence avatar ericandrewlewis avatar kepta avatar kiejo avatar konstantinmuenster avatar l42y avatar lpellegr avatar m-gallesio avatar marcodejongh avatar marijnh avatar marionebl avatar martinstarman avatar mstijak avatar nsfmc avatar remorses avatar rowanc1 avatar rsaccon avatar safonoi avatar segevfiner avatar susnux avatar timjb avatar torifat avatar wioux avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

prosemirror-markdown's Issues

Markdown parser does not correctly handle marks around inline nodes

I expanded the schema and markdown-it with a new type of node with markup that looks like this: $$[text]. This is an inline node and NOT a mark because these nodes need to be able to be placed next to each other (e.g. $$[textOne]$$[textTwo]).

If I then try to use a mark, such as strong, in a paragraph surrounding my new node, the parser stops the mark after my custom node.

For example, this markdown: **here is some text $$[exampleText] some more text**

Becomes incorrectly parsed and rendered into something like this: <strong>here is some text </strong><span class="myCustomClass"><strong>exampleText</strong></span> some more text

I am using parsemirror-markdown version 1.8.0 according to npm.

Unneeded escaping of colons at the start of a line

From: nextcloud/text#969

The common mark specs only have a special usage for colons used after a link mark for Link reference and they are only used by extended markdown for definition lists, not part of the specification.
But currently colons at the start of a line are escaped even if there is no reason for it.
This leads to problems if you use extended markdown (e.g. vimwiki) where tags start with a colon.

A better solution would be to allow configure escaping : or not (e.g. remove the escaping so if you need it you could add it to escapeExtraCharacters).

Escaping colons at start of line

Support for restricted HTML

Many Markdown renderers such as GitHub, or VS Code, allow a restricted subset of HTML syntax in the Markdown they support. Besides allowing for a few formatting options and tags that are missing from basic Markdown, this also makes markdown-it properly identify stuff like HTML comments, as otherwise they are passed though as text into the editor.

I think they do so by running an HTML sanitizer on rendered HTML of the Markdown, rather than doing something at the parser/tokens level.

For parity with such Markdown files, is there any reasonable way to support such things using prosemirror-markdown? While remaining safe from any XSS of course.

Markdown-It dependency

Hello! I've got a couple of questions.

Is there any reason to have ^6.0.4 instead of latest version of markdown-it?

And if there is no reasons why not update the dependency?

Serializer does not escape '>' at start of line

Details

Markdown serializer currently does not escape a greater-than character > occurring at start of line.

Version

prosemirror-markdown 1.5.1
Can be reproduced with markdown example.

Steps to reprocude

  1. Insert line starting with > in WYSIWYM mode.
  2. Switch mode to markdown.
  3. > character is not escaped.
  4. Switch back to WYSIWYM.
  5. Line is now unintentionally quoted.

image
image
image

Expected result:

> character at start of line is escaped as \> during markdown serialization.

Hard line breaks always also add newline

I noticed that hard line breaks always add a newline character, which breaks stuff when set `preserveWhitespaces: 'full'´ for paragraphs.

Consider this:

*foo\
bar*

will result in

<p><em>foo<br \>
bar</em></p>

And then serialized as:

*foo \

 bar*

which results in this:

<p>*foo \</p>
<p>bar*</p>

My use case:
keep differences of markdown files after editing as small as possible, especially custom formatting (from external editors). E.g.:

foo
bar

without preserveWhitespaces: 'full' this would result in

foo bar

The rendered version would look the same, but the source file is different and may be harder to read.

Extend `noOpenClose`

When extending this library with other markdown-it extensions, I am having to extend the function noOpenClose(type) here:
https://github.com/ProseMirror/prosemirror-markdown/blob/master/src/from_markdown.js#L94

For example, in markdown-it-texmath the following blocks are needed:

type == 'math_inline' || type == 'math_inline_double' || type == 'math_block' || type == 'math_block_eqno'

I was wondering if it is worth passing an options into MarkdownParser that then goes to tokenHandlers, so that this can be done without forking the library?

Let me know if this would be wanted and I can put together a PR.

Empty paragraph is added before custom node

I 'm parsing git hub todo list (- [x]) to be replaced by a custom node. I've written a plugin to replace paragraphs with my custom node by just switching type on open and close tag:
tokens[i - 1].type = "app_todo_open"

That doesn't seem to be a problem since the output from Markdown-it looks correct. But when running through MarkdownParser it generates an extra paragraph node before every app_todo node.

So without the custom node I get:

<ul>
  <li>
    <p>[ ] Not done</p>
  </li>
</ul>

And with the custom node:

<ul>
  <li>
    <p><br/></p>
    <p class="todo">Not done</p>
  </li>
</ul>

Breaks are set to false and when running it through only the markdown-it renderer I get the expected result:

<ul>
  <li>Not done</li>
</ul>

Any ideas what can cause this?

HTML entity unescaping on parse can lead to unexpected results on serialize

markdown-it currently parses HTML entities into text, this leads to weird side effects on a parse/serialize cycle.

  1. &lt;b&gt;Not Bold&lt;b&gt; will parse into <b>Not Bold</b> and serialize as <b>Not Bold</b>, which leads to it being bold in Markdown parsers that do honor HTML (Or a subset thereof).
  2. &nbsp&nbspFoo parses as Foo and serializes as Foo, but will parse back as Foo, as Markdown trims normal spaces. The same applies to trailing &nbsp, which might be further confused as an hard break.
  3. Typing &lt; into prosemirror, serializes as &lt; but parses as <.

All of these behaviors can be seen here https://prosemirror.net/examples/markdown/ and switching between Markdown and WYSIWYM.

Wrong parsing of emphasis and strong emphasis formatting

From CommonMark example 431:

**foo *bar **baz**
bim* bop**

should be parsed as:

<p><strong>foo <em>bar <strong>baz</strong>
bim</em> bop</strong></p>

Using just markdown-it this works as expected but the defaultMarkdownParser creates this incorrect representation:

<p><strong>foo </strong><em><strong>bar baz</strong>
bim</em> bop</p>

Invalid parsing of emphasis and strong emphasis

Editor removes line breaks when line starts with \ (backslash)

Issue details

Editor removes line breaks when line starts with \ (backslash)

Steps to reproduce

  1. Open http://prosemirror.net/examples/markdown/
  2. Select markdown mode
  3. Type this text in textarea:
**Text** line 1
\- text line 2
\- text line 3
\- text line 4
\- text line 5
- text line 6
  1. Switch to WYSIWYM
  2. Try to edit text (e.g. try to add a space at line 2)
  3. Now editor removed all linebreak for lines, that starts with \

ProseMirror version

ProseMirror example at http://prosemirror.net/examples/markdown/ (as of 27th July 2020)

Affected platforms

  • Chrome
  • Firefox
  • Internet Explorer
  • Other

Screenshots / Screencast (Optional)

Dt3M9Kf2yG

) in URL is not escaped

From commonmark spec example 499:

This markdown:

[link](foo\)\:)

Results in this HTML:

<p><a href="foo):">link</a></p>

But it is then serialized to this invalid (different) markdown:

[link](foo):)

Note the not escaped ) character

link not escaped

Tight lists are not correctly rendered in the editor

I ran into a list-rendering-related inconsistency in ProseMirror. After digging around, I found #51 (TIL about "list tightness" in Markdown!), and the fix does seem to correctly detect the "hidden" attributes in Markdown-it's tokens and correctly attaches them on lists, but the then the (default) list rendering does not take these into account:

screenshot

In the above screenshot, the left-hand side is plain Markdown-it, the right-hand side is ProseMirror. As evidenced by the data-tight="true" in the list DOM, the tightness is correctly detected but ignored on render.

This behavior can also be reproduced by the Friendly Markdown example on the website.

I tried looking into where this gets rendered (is it prosemirror-schema-list?) but arguably I'm still a bit new to ProseMirror's internals and couldn't quite get to it, would be happy to help to have this fixed.

Code Block in MarkDown

The Code block ``` is created right after the last back-tick. As it should convert after the space is entered. Thus if the user wants they can use ```js for getting syntax highlighting.

Escape of dots in list items

When there are dots, following a number, as text in list items they must be escaped.
Found by an user of the nextcloud text app: nextcloud/text#2480


E.g. consider this text:

Hello

  • 1. world
  • 2. world
  • 3. world

which is based on this source code:

Hello
* 1\. world
* 2\. world
* 3\. world

But using the WYSIWYG editor it emits this markdown:

Hello
* 1. world
* 2. world
* 3. world

which results in:

Hello

    1. world
    1. world
    1. world

See also this example:
Example within the WYSIWYG editor

markdown-it update to actual version (v12)

Hi!
Please upgrade markdown-it to the latest version.
Our project uses markdown-it version 12 and we have to use yarn resolutions

   "resolutions": {
     "markdown-it": "^12.3.0"
   }

One-word relative links are serialized as <autolinks>

Description

  1. Have a one-word relative link in a document, where link text (relative) equals link destination (relative)
  2. Serialize it into markdown
    Expected markdown: [relative](relative)
    Actual markdown: "<relative>", which is not valid CommonMark (see reference example https://spec.commonmark.org/dingus/?text=%3Crelative%3E)

Test case (via prosemirror-test-builders):

  it('should serialize relative links', () => {
    const {a} = builders(schema, {
      a: {markType: 'link', href: 'relative'}
    });

    const node = doc(paragraph(a('relative')));

    expect(markdownSerializer.serialize(node))
      .toEqual('[relative](relative)');
  });

Issue with hard breaks in headline

When adding a hard break Ctrl+Enter within a headline the markdown result is:

## asdf\
asdf

Which will be rendered as:

grafik

My workaround was to use the splitBlock command in the Ctrl+Enter keymap if the selection resides within a headline.

Handling of `softbreak` is weird

Currently prosemirror-markdown converts a softbreak to a \n in the text node, this seems to render as a line break when initially viewed, but is stripped away on the first edit of that text node. I think this is weird and unintuitive. How should this be handled better?

Recording 2023-04-03 at 21 39 05

Support passing in markdown-it `env`

markdown-it can receive an env object in its parse call that can be used to retrieve and pass in some information into the parser for some plugins and token types. It would be nice to be able to pass it in.

How to handle tables?

markdown-it doesn't output a paragraph_{open,close} token around a table cell's contents which causes it to be dropped with just:

  table: { block: "table" },
  tr: { block: "tableRow" },
  th: { block: "tableHeader" },
  td: { block: "tableCell" },
  thead: { ignore: true },
  tbody: { ignore: true },

As there is only an inline inside the th and td but the schema I have specifies block+ for them, which means it should have a paragraph... Or is that invalid in Markdown and I should reconfigure the schema?

Escape ! character next to a link

! should be escaped if followed by a link, consider this:

Markdown: [Hello](https://example.com)
and then type a ! just before the link inside the WYSIWYG editor.

Expected result:
\![Hello](https://example.com)

Actual result:
![Hello](https://example.com)
(results in parsing as image -> invalid)

I try to visualize the problem:
Exclamation marks must be escaped before links

From: nextcloud/text#931

Schema definition has duplicate entries

There are duplicate entries for ordered_list, bullet_list and list_item.

I also noticed that code_block serializing / deserializing deals with data attributes.

Escaping on serialization but not unescaping on parsing

defaultMarkdownSerializer escapes text, however there is no mention of unescaping in from_markdown.js.

If defaultMarkdownSerializer is given the input [ for example, it outputs \[.
If this is later fed into defaultMarkdownParser, the output is \[ when it should be [

Content is escaped but never unescaped resulting in documents accumulating more and more backslashes.
Surely this is not correct default behaviour?

bug in lists

In the demo, clear the plain textbox and type:

* item
* another item

Then switch to WYSIWYM, then switch back, and you'll see

* item

* another item

This means something completely different in markdown -- it's a list with lots of space between each entry.

As far as I can tell, there isn't a way to even make a bulleted list without lots of space between entries using the WYSIWYM mode.


View the difference via Github's Markdown Renderer:

  • item
  • another item

VERSUS

  • item

  • another item

Underscores are not escaped during serialization

Description

Underscores are not escaped by the MarkdownSerializer.

Steps to Reproduce

  1. Enter "_test_" in the WYSIWYM view under https://prosemirror.net/examples/markdown/
  2. Switch to markdown view.

Expected Behavior

The text in markdown view is "\_test\_". When we switch back to WYSIWYM view, the text there is still "_test_".

Actual Behavior

The text in markdown view is "_test_". When we switch back to WYSIWYM view, this is parsed to "test".

Further Notes

As far as I can tell, this line would merely have to be expanded so that the RegEx also matches _ characters.

Prosemirror Markdown example does weird things with code blocks

A video will show it better than words...

markdown_code

As you can see in the GIF, switching between code and no-code is very tricky. I kind-of understand why it happens (all has to do with the paragraphs in markdown), but actually is pretty confusing.

Problems are:

  • If I have no text after a code block, I can't leave it without losing format in all lines.
  • After returning to a paragraph block the different lines in the previous code block are shown separate, if I write anything else, the contiguous lines are put together in a single line.
  • If I select various paragraphs, and set them to code block, it creates one code block per paragraph.

Solutions might be:

  • If I press backspace in an empty codeblock line, transform the current line into a paragraph.
  • If I transform a codeblock into a paragraph, put contiguous lines together immediately. If I do select a single line, transform that line into a paragraph and leave the rest as a codeblock.
  • If I select various paragraphs, and transform them into a codeblock, create a single codeblock with them.

Option to set tight list style on document level

Currently one can set a tight attribute on a list node to control how it gets serialized. I have a use case where my nodes do not have such an attribute, but I would like to serialize all list nodes of the document using the tight style.
I haven't seen a way to control this on the document level. One way to allow this, would be to support an optional tightLists serializer option, which would be used as the default style if no tight attribute is set on a list node.

Improve markdown implementation for italic/bold handling (edge cases)

(Originally reported by @Mobiletainment as ProseMirror/prosemirror#730)

Issue details

When putting italic and bold text directly next to each other, there's a good chance that it gets interpreted wrongly due to weaknesses in markdown's italic and bold formatting.

Steps to reproduce

Take the following markdown for example:

*italic text directly next to ***bold text**

  • Expected output: italic text directly next to bold text
  • Actual output: *italic text directly next to *bold text

Please specify which version of ProseMirror you're running

ProseMirror v0.10.1
ProseMirror example at http://prosemirror.net/examples/markdown/ (as of 28th November 2017)

Affected platforms

  • all

Screenshots / Screencast (Optional)

prosemirror-markdown

I tested this behavior with other markdown implementations and saw that this edge case is properly handled by some, e.g. pandoc: http://johnmacfarlane.net/babelmark2/?text=*italic+text+directly+next+to+***bold+text**

prosemirror markdown

Wrongly escaped $ at the start of a line

We were investigating why a single line like

$50

was being serialized into the following markdown:

\$50

We discovered in to_markdown.js there's an esc() method which uses a regex to escape certain characters that could have special meaning at the start of a line, but the offending regex /^[:#-*+]/ contains a range #-* which provokes that $%&'() also be matched, which we assume wasn't your intention.

A simple fix would be move the - to the end or start or end of the character class, such as /^[-:#*+]/.

This commit appears to be where the bug was introduced.

Link is split into multiple ones

From commonmark spec example 515:

[link *foo **bar** `#`*](/uri)

Which correctly results in:

<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>

But the serialization of it using prosemirror-markdown results in this markdown which is definitely a different markdown:

[link ](/uri)*[foo](/uri) **[bar ](/uri)**[`#`](/uri)*

markdown is split into multiple links

Ordered lists forced to start from "1" even if they have other numeration

Dear Contributors, thank you so much for mantaining this brilliant library.

I faced a small issue with it that I hope can be fixed relatively simple:

  1. Have markdown like that (without "" symbols):
4. asdfasdf
5. asdfasdf
  1. Check how it is interpreted by canonical markdown implementation
    image

  2. Check how it parses by prosemirror-markdown in this usage example:
    image

markdown-it also respects this numeration as far as I see.

Thank you very much for investigating this!

Error: Package subpath './package.json' is not defined by "exports" in node_modules/w3c-keyname/package.json

rollup v2.22.1
bundles src/main.js → public/build/bundle.js...
[!] (plugin svelte) Error: Package subpath './package.json' is not defined by "exports" in /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/w3c-keyname/package.json
Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './package.json' is not defined by "exports" in /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/w3c-keyname/package.json
    at applyExports (internal/modules/cjs/loader.js:498:9)
    at resolveExports (internal/modules/cjs/loader.js:514:23)
    at Function.Module._findPath (internal/modules/cjs/loader.js:642:31)
    at Function.Module._resolveFilename (internal/modules/cjs/loader.js:1017:27)
    at Function.requireRelative.resolve (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/require-relative/index.js:30:17)
    at tryResolve (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup-plugin-svelte/index.js:50:19)
    at Object.resolveId (/Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup-plugin-svelte/index.js:177:21)
    at /Users/user1/github/pm/frontend/svelte/prosermarkdown-editor/node_modules/rollup/dist/shared/rollup.js:18264:25

node -v
v14.5.0

Escaping special markdown characters causes problems with links

Users are occasionally pasting links directly in the editor.

During serialization, the underscore character is escaped into \_. This causes problems later on when markdown is converted to HTML.

For example, https://miro.com/app/board/abc_def

becomes

https://miro.com/app/board/abc\_def

which later becomes an unusable link:

<a href="https://miro.com/app/board/abc\_def">https://miro.com/app/board/abc\_def</a> .

What would be the best way to handle this issue? Should links be detected before escaping text or maybe there is some other way?

Serialize autolinks as <url> rather than [url](url)

  • Original Markdown: <https://github.com/ProseMirror/prosemirror-markdown>
  • Rendered HTML: <a href="https://github.com/ProseMirror/prosemirror-markdown">https://github.com/ProseMirror/prosemirror-markdown</a>
  • Expected serialized Markdown: <https://github.com/ProseMirror/prosemirror-markdown>
  • Actual serialized Markdown: [https://github.com/ProseMirror/prosemirror-markdown](https://github.com/ProseMirror/prosemirror-markdown)

I made an attempt at writing generic support for dynamic mark delimiters in an early iteration of #29, which would have made it relatively easy to fix this serialization as well, but that PR was ultimately replaced by 0448d32 which was specific to code marks but was much less complex.

in parser, allow spec to to read child info

A tag like <table> has an attribute, columns, which can only be known after child nodes have been parsed.

The following patch supports a handleClose function in a parser spec which could be used to add or update attrs to the node when its close tag has been reached. I'm posting here for feedback before submitting as a PR; this works for me but I'm not sure if there would be a better/preferred approach.

Patch:
https://github.com/mhuebert/prosemirror-markdown/tree/patch-1

Example usage:

{ // ...in token map...
  table: 
  { block: "table",
    handleClose: function (node) {
      // copy attrs from first child, which will be `thead`
      node.attrs = node.content[0].attrs
    }
  },
  thead: 
  { block: "table_header",
    handleClose: function (node) {
      // copy attrs from first child, which will be `tr`
      node.attrs = node.content[0].attrs
    }
  },
  tr: 
  { block: "table_row",
    handleClose: function (node) {
      // column count is equal to number of child nodes
      node.attrs = {columns: node.content.length}
    }
  }
 // ...
}

In the case of a table, we want the column attribute to 'bubble up' from tr elements, up to thead or tbody elements, and then finally the table itself. Copying the attr to the intermediate parents seems necessary so that we can enforce content constraints, eg. for a table body, "table_row[columns=.columns]+".

(Note that to support Github-style markdown tables, a different schema is required than what prosemirror-schema-table specifies, as table headers are required - it's not possible to have a table without <thead> and <th> elements.)

Fenced code blocks does not check for backticks

Fenced code blocks should check the content for any sequence of backticks, as CommonMark defines a code block to end with a sequence of backticks of at least the number it started.

Meaning this is perfectly valid markdown:

````
```
code
```
````

But currently prosemirror-markdown will serialize this:

<pre><code>
```
code
```
</code></pre>

to this markdown:

```
```
code
```
```

which is a code block followed by a paragraph "code" and a second code block.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.